single_simulation.h

Go to the documentation of this file.

#ifndef _SINGLE_SIM_H_
#define _SINGLE_SIM_H_

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

#define _NSIMS_ 1

class SingleSimulation : public Simulation
{
  public:

    SingleSimulation()
    {
      m_is_defined = false;
      m_sim = nullptr;
      m_nproc = -1;
      m_rank = -1;
    }

    ~SingleSimulation()
    {
      int err = Cleanup((void*) m_sim, _NSIMS_);
      if (err) {
        printf( "Error: CleanUp() returned with status %d on process %d.\n",
                err, m_rank );
      }
      delete m_sim;
    }

    int define(int, int);

    inline int ReadInputs()
    {
      int retval = ::ReadInputs(  (void*) m_sim,
                                  _NSIMS_, 
                                  m_rank );
      ::WriteInputs( (void*) m_sim,
                     _NSIMS_, 
                     m_rank );
      return retval;
    }

    inline int Initialize()
    {
      int retval = ::Initialize(  (void*) m_sim,
                                  _NSIMS_ );
      return retval;
    }

    inline int InitialSolution()
    {
      int retval = ::InitialSolution( (void*) m_sim,
                                      _NSIMS_ );
      return retval;
    }

    inline int InitializeBoundaries()
    {
      int retval = ::InitializeBoundaries(  (void*) m_sim,
                                            _NSIMS_ );
      return retval;
    }

    inline int InitializeImmersedBoundaries()
    {
      int retval = ::InitializeImmersedBoundaries(  (void*) m_sim,
                                                    _NSIMS_ );
      return retval;
    }

    inline int InitializePhysics()
    {
      int retval = ::InitializePhysics( (void*) m_sim,
                                        _NSIMS_ );
      return retval;
    }

    inline int InitializePhysicsData()
    {
      int retval = ::InitializePhysicsData( (void*) m_sim,
                                            0, _NSIMS_, NULL );
      return retval;
    }

    inline int InitializeSolvers()
    {
      int retval = ::InitializeSolvers( (void*) m_sim,
                                        _NSIMS_ );
      return retval;
    }

    inline int Solve()
    {
      int retval = ::Solve( (void*) m_sim,
                            _NSIMS_,
                            m_rank,
                            m_nproc );
      return retval;
    }

    inline void WriteErrors(double a_wt_solver,
                            double a_wt_total )
    {
      ::SimWriteErrors( (void*) m_sim,
                        _NSIMS_,
                        m_rank,
                        a_wt_solver,
                        a_wt_total );
      return;
    }

    inline bool isDefined() const { return m_is_defined; }

#ifndef serial

    inline int mpiCommDup() 
    {
      MPI_Comm_dup(MPI_COMM_WORLD, &(m_sim->mpi.world));
      return 0;
    }
#endif

#ifdef with_petsc

    inline void usePetscTS(PetscBool a_flag)
    {
      m_sim->solver.use_petscTS  = a_flag;
    }

    inline int SolvePETSc()
    {
      int retval = ::SolvePETSc(  (void*) m_sim,
                                  _NSIMS_,
                                  m_rank,
                                  m_nproc );
      return retval;
    }
#endif

  protected:

    bool  m_is_defined;       
    int   m_rank,             
          m_nproc;            
    SimulationObject* m_sim;  /*< Simulation object */

  private:

};

#endif