ensemble_simulations.h

Go to the documentation of this file.

#ifndef _ENSEMBLE_SIM_H_
#define _ENSEMBLE_SIM_H_

#include <stdio.h>
#include <vector>
#include <simulation.h>

#define _ENSEMBLE_SIM_INP_FNAME_ "simulation.inp"

class EnsembleSimulation : public Simulation
{
  public:

    EnsembleSimulation()
    {
      m_is_defined = false;
      m_sims.clear();
      m_nsims = 0;
      m_nproc = -1;
      m_rank = -1;
    }

    ~EnsembleSimulation()
    {
      int err = Cleanup((void*) m_sims.data(), m_nsims);
      if (err) {
        printf( "Error: CleanUp() returned with status %d on process %d.\n",
                err, m_rank );
      }
      m_sims.clear();
    }

    int define(int, int);

    inline int ReadInputs()
    {
      int retval = ::ReadInputs(  (void*) m_sims.data(),
                                  m_nsims, 
                                  m_rank );
      ::WriteInputs( (void*) m_sims.data(),
                     m_nsims, 
                     m_rank );
      return retval;
    }

    inline int Initialize()
    {
      int retval = ::Initialize(  (void*) m_sims.data(),
                                  m_nsims );
      return retval;
    }

    inline int InitialSolution()
    {
      int retval = ::InitialSolution( (void*) m_sims.data(),
                                      m_nsims );
      return retval;
    }

    inline int InitializeBoundaries()
    {
      int retval = ::InitializeBoundaries(  (void*) m_sims.data(),
                                            m_nsims );
      return retval;
    }

    inline int InitializeImmersedBoundaries()
    {
      int retval = ::InitializeImmersedBoundaries(  (void*) m_sims.data(),
                                                    m_nsims );
      return retval;
    }

    inline int InitializePhysics()
    {
      int retval = ::InitializePhysics( (void*) m_sims.data(),
                                        m_nsims );
      return retval;
    }

    inline int InitializePhysicsData()
    {
      for (int ns = 0; ns < m_nsims; ns++) {
        int retval = ::InitializePhysicsData( (void*) &(m_sims[ns]),
                                              ns, m_nsims, NULL );
        if (retval) {
          fprintf(stderr, "Error in EnsembleSimulations::InitializePhysicsData()\n");
          fprintf(stderr, "  InitializePhysicsData returned with error code %d on rank %d.\n",
                  retval, m_sims[ns].mpi.rank);
          return retval;
        }
      }
      return 0;
    }

    inline int InitializeSolvers()
    {
      int retval = ::InitializeSolvers( (void*) m_sims.data(),
                                        m_nsims );
      return retval;
    }

    inline int Solve()
    {
      int retval = ::Solve( (void*) m_sims.data(),
                            m_nsims,
                            m_rank,
                            m_nproc );
      return retval;
    }

    inline void WriteErrors(double a_wt_solver,
                            double a_wt_total )
    {
      ::SimWriteErrors( (void*) m_sims.data(),
                        m_nsims,
                        m_rank,
                        a_wt_solver,
                        a_wt_total );
      return;
    }

    inline bool isDefined() const { return m_is_defined; }

#ifndef serial

    inline int mpiCommDup() 
    {
      for (int n = 0; n < m_nsims; n++) {
        MPI_Comm_dup(MPI_COMM_WORLD, &(m_sims[n].mpi.world));
      }
      return 0;
    }
#endif

#ifdef with_petsc

    inline void usePetscTS(PetscBool a_flag)
    {
      for (int n = 0; n < m_nsims; n++) {
        m_sims[n].solver.use_petscTS  = a_flag;
      }
    }

    inline int SolvePETSc()
    {
      int retval = ::SolvePETSc(  (void*) m_sims.data(),
                                  m_nsims,
                                  m_rank,
                                  m_nproc );
      return retval;
    }
#endif

  protected:

    bool  m_is_defined;     
    int   m_nsims;          
    int   m_rank,           
          m_nproc;          
    std::vector<SimulationObject> m_sims; 
  private:

};

#endif