Simulation.H

Go to the documentation of this file.

#ifndef __SIMULATION_H__
#define __SIMULATION_H__

#include <vector>

#include "mpi.h"

#include "Application.H"
#include "PCPPProgram.H"
#include "Grid.H"
#include "State.H"
#include "Domain.H"
#include "Geometry.H"
#include "Advancer.H"
#include "RHS.H"

using namespace fixtures;

namespace simulation {

  //  class base : public application::base 
  template<typename DomainBaseT>
  class application : public pcpp::parallelprogram
  {
    

  public:

    typedef DomainBaseT                         DomainBaseType;
    typedef typename DomainBaseType::GridType   GridType;
    typedef typename DomainBaseType::StateType  StateType;
    typedef std::vector<DomainBaseType>         domainvector;
    typedef advancer::base<DomainBaseType>      AdvancerType;
    typedef std::vector<AdvancerType *>         advancervector;
    typedef domain::Initializer<DomainBaseType> DomainInitializerType;  
    typedef std::vector<DomainInitializerType>  initializervector;
    typedef domain::info                        DomainInfoType;
    typedef geometry::info                      GeometryInfoType;

  protected:
    
    fixtures::ConfigurationType        appConfig;
    
    //    int                      numDomains;          
    DomainInfoType           domainInfo;
    GeometryInfoType         geometryInfo;
    domainvector             appDomains;
    advancervector           domainAdvancers;
    initializervector        domainInitializers;
    
    int errorState;
    int iStep;
    int numStepsMax;
    int numStepsIO;
    int numStepsStatus;

  public:
    
    // Every parallel application must have this constructor
    application(int numArgs,char **argList,MPI_Comm mpiCommunicator) :
      pcpp::parallelprogram(numArgs,argList,mpiCommunicator),
      errorState(0), iStep(0), numStepsMax(0), numStepsIO(0), numStepsStatus(0)
    {};
    
    // Functions all applications must define
    virtual int  ConfigureApplication() { return(0); };
    virtual int  RunApplication()    
    {
      int initializeRunCode = InitializeRun();
      if(initializeRunCode){
        ErrOut("InitializeRun returned error code.\n");
        return(initializeRunCode);
      }
      bool keepGoing = !Finished();
      while(keepGoing){
        int initStepCode = InitializeStep();
        if(initStepCode){
          ErrOut("InitializeStep returned error code.\n");
          return(initStepCode);
        }
        int advanceCode  = Advance();
        if(advanceCode){
          ErrOut("Advance returned error code.\n");
          return(advanceCode);
        }
        int finalizeStepCode = FinalizeStep();
        if(finalizeStepCode){
          ErrOut("FinalizeStep returned error code.\n");
          return(finalizeStepCode);
        }
        keepGoing = !Finished();
      }
      int finalizeRunCode = FinalizeRun();
      if(finalizeRunCode){
        ErrOut("FinalizeStep returned error code.\n");
        return(finalizeRunCode);
      }
      return(0);
    };
    virtual int  InitializeApplication() {return(0);};
    virtual int  FinalizeApplication()   {return(0);};

    // These functions are specific to simulation applications
    virtual int  AdvanceDomains()
    {
      for(int iDomain = 0;iDomain < domainInfo.numDomains;iDomain++)
        {
          DomainBaseType &appDomain(appDomains[iDomain]);
          AdvancerType &domainAdvancer(*domainAdvancers[iDomain]);
          int advanceCode = domainAdvancer.AdvanceDomain();
          if(advanceCode){
            return(advanceCode);
          }
        }
      return(0);
    };
    virtual bool Finished() { return(true); };
    virtual int  InitializeRun()
    {
      int initCode = InitializeDomains();
      if(initCode){
        return(initCode);
      }
      return(0);
    };
    virtual int  InitializeDomains()
    {
      FunctionEntry("InitDomains");
      if(Restart()){
        return(RestartDomains());
      } else {
        for(int iDomain = 0;iDomain < domainInfo.numDomains;iDomain++)
          {
            DomainBaseType &appDomain(appDomains[iDomain]);
            DomainInitializerType &domainInitializer(domainInitializers[iDomain]);
            int initCode = domainInitializer.InitializeDomain(appDomain);
            if(initCode){
              return(initCode);
            }
          }
      }
      FunctionExit("InitDomains");
      return(WriteDomains());
    };
    virtual int  Advance()
    {
      FunctionEntry("Advance");
      int advanceCode = AdvanceDomains();
      if(advanceCode){
        return(advanceCode);
      }
      FunctionExit("Advance");
      return(0);
    };
    virtual int  FinalizeRun()
    {
      FunctionEntry("FinalizeRun");
      int finalizeCode = FinalizeDomains();
      if(finalizeCode){
        return(finalizeCode);
      }
      FunctionExit("FinalizeRun");
      return(0);
    };
    virtual int  FinalizeDomains()
    {
      FunctionEntry("FinalizeDomains");
      bool doRestart = !RestartStep();
      if(doRestart){
        WriteRestart();
      }
      FunctionExit("FinalizeDomains");
      return(0);
    };
    virtual bool RestartStep() {return(true);};
    virtual bool OutputStep()  {return(true);};
    virtual int  InitializeStep()
    {
      FunctionEntry("InitializeStep");
      for(int iDomain = 0;iDomain < domainInfo.numDomains;iDomain++)
        {
          DomainBaseType &appDomain(appDomains[iDomain]);
          AdvancerType &domainAdvancer(*domainAdvancers[iDomain]);
          int advanceInitCode = domainAdvancer.InitializeAdvance();
          if(advanceInitCode){
            return(advanceInitCode);
          }
        }
      FunctionExit("InitializeStep");
      return(0);
    };
    virtual int  FinalizeStep()
    {
      FunctionEntry("FinalizeStep");
      for(int iDomain = 0;iDomain < domainInfo.numDomains;iDomain++)
        {
          DomainBaseType &appDomain(appDomains[iDomain]);
          AdvancerType &domainAdvancer(*domainAdvancers[iDomain]);
          int advanceFinalizeCode = domainAdvancer.FinalizeAdvance();
          if(advanceFinalizeCode){
            return(advanceFinalizeCode);
          }      
        }
      if(OutputStep()){
        int writeOutputCode = WriteDomains();
        if(writeOutputCode){
          return(writeOutputCode);
        }
      }
      if(RestartStep()){
        int writeRestartCode = WriteRestart();
        if(writeRestartCode){
          return(writeRestartCode);
        }
      }
      FunctionExit("FinalizeStep");
      return(0);
    };
    
    virtual int  RestartDomains()        { return(0); };
    virtual int  WriteDomains()          { return(0); };
    virtual int  ReadDomains()           { return(0); };
    virtual int  WriteRestart()          { return(0); };
    virtual int  Restart()               { return(0); };
    virtual int  ConfigureSimulation()   { return(0); };
    virtual int  InitializeSimulation()  { return(0); };
    virtual int  ConfigureDomains()      { return(0); };

    DomainInfoType DomainInfo(){ return (domainInfo); };
    int NumberOfDomains(){ return (domainInfo.numDomains); };
    domainvector &GetDomains(){ return appDomains; };

  };

  //  typedef application ApplicationType;

//   namespace util {
//     int ConfigureMeta(fixtures::ConfigurationType &inConfig,field::metadataset &inMeta,
//                       std::ostream &messageStream);
//   }

};

#endif
//  
//