Объясните пожалуйста. что происходит в коде

class Main
{
private:
    using FlowMainEbosType = FlowMainEbos<Properties::TTag::EclFlowProblem>;
 
public:
    Main(int argc, char** argv) : argc_(argc), argv_(argv)  { initMPI();  }
 
    // This constructor can be called from Python
    Main(const std::string& filename)
    {
        setArgvArgc_(filename);
        initMPI();
    }
 
    // This constructor can be called from Python when Python has
    // already parsed a deck
    Main(std::shared_ptr<Deck> deck,
         std::shared_ptr<EclipseState> eclipseState,
         std::shared_ptr<Schedule> schedule,
         std::shared_ptr<SummaryConfig> summaryConfig)
        : deck_{std::move(deck)}
        , eclipseState_{std::move(eclipseState)}
        , schedule_{std::move(schedule)}
        , summaryConfig_{std::move(summaryConfig)}
    {
        setArgvArgc_(deck_->getDataFile());
        initMPI();
    }
 
 
    ~Main()
    {
#if HAVE_MPI
        if (test_split_comm_) {
            // Cannot use EclGenericVanguard::comm()
            // to get world size here, as it may be
            // a split communication at this point.
            int world_size;
            MPI_Comm_size(MPI_COMM_WORLD, &world_size);
            if (world_size > 1) {
                MPI_Comm new_comm = EclGenericVanguard::comm();
                int result;
                MPI_Comm_compare(MPI_COMM_WORLD, new_comm, &result);
                assert(result == MPI_UNEQUAL);
                MPI_Comm_free(&new_comm);
            }
        }
#endif // HAVE_MPI
 
        EclGenericVanguard::setCommunication(nullptr);
 
#if HAVE_MPI && !HAVE_DUNE_FEM
        MPI_Finalize();
#endif
    }
 
    void setArgvArgc_(const std::string& filename)
    {
        this->deckFilename_ = filename;
        this->flowProgName_ = "flow";
 
        this->argc_ = 2;
        this->saveArgs_[0] = const_cast<char *>(this->flowProgName_.c_str());
        this->saveArgs_[1] = const_cast<char *>(this->deckFilename_.c_str());
 
        // Note: argv[argc] must exist and be nullptr
        assert ((sizeof this->saveArgs_) > (this->argc_ * sizeof this->saveArgs_[0]));
        this->saveArgs_[this->argc_] = nullptr;
 
        this->argv_ = this->saveArgs_;
    }
 
    void initMPI()
    {
#if HAVE_DUNE_FEM
        Dune::Fem::MPIManager::initialize(argc_, argv_);
#elif HAVE_MPI
        MPI_Init(&argc_, &argv_);
#endif
        EclGenericVanguard::setCommunication(std::make_unique<Parallel::Communication>());
 
        handleTestSplitCommunicatorCmdLine_();
 
#if HAVE_MPI
        if (test_split_comm_ && EclGenericVanguard::comm().size() > 1) {
            int world_rank = EclGenericVanguard::comm().rank();
            int color = (world_rank == 0);
            MPI_Comm new_comm;
            MPI_Comm_split(EclGenericVanguard::comm(), color, world_rank, &new_comm);
            isSimulationRank_ = (world_rank > 0);
            EclGenericVanguard::setCommunication(std::make_unique<Parallel::Communication>(new_comm));
        }
#endif // HAVE_MPI
    }
 
    int runDynamic()
    {
        int exitCode = EXIT_SUCCESS;
        if (isSimulationRank_) {
            if (initialize_<Properties::TTag::FlowEarlyBird>(exitCode)) {
                return this->dispatchDynamic_();
            }
        }
 
        return exitCode;
    }