RHS.H

Go to the documentation of this file.

#ifndef __RHS_H__
#define __RHS_H__

#include "PCPPTypes.H"
#include "StateOperators.H"
#include "Boundary.H"

using namespace fixtures;
namespace simulation {
  namespace rhs {

    template<typename DomainType>
    class base {

    public:

      typedef typename DomainType::GridType GridType;
      typedef typename DomainType::StateType StateType;
      typedef simulation::domain::boundary::base         BoundaryType;
      typedef simulation::domain::boundary::bc::base     BCType;

    public:

      virtual int ProcessInterior(GridType &inGrid,StateType &inState,StateType &outState)
      { return(0); };
      virtual int ProcessHalos(GridType &inGrid,StateType &inState,StateType &outState,std::vector<StateType *> &haloStates)
      { return(0); };
      virtual int ProcessBoundaries(GridType &inGrid,StateType &inState,StateType &outState,std::vector<BoundaryType *> domainBoundaries,
                                    std::vector<StateType *> &boundaryStates)
      { return(0); };

    protected:
      std::vector<std::string> fieldNames;
      std::vector<int>         fieldIDs;
    };

    template<typename GridT,typename StateT,typename OperatorT>
    class domain_base {

    public:
      typedef GridT     GridType;
      typedef StateT    StateType;
      typedef OperatorT OperatorType;

      typedef simulation::grid::halo                     halo_t;
      typedef simulation::domain::boundary::base         BoundaryType;
      typedef simulation::domain::boundary::bc::base     BCType;
      typedef pcpp::ParallelGlobalType                   GlobalType;

    public:

      virtual int Initialize(GridType &inGrid, StateType &inState, StateType &inParam,
                             OperatorType &inOperator)
      { 
        std::cout << "WARNING: Calling rhs::domain_base Initialize" << std::endl;
        return(0); 
      };
      virtual int Initialize(GridType &inGrid, StateType &inState, StateType &inParam,
                             StateType &targetState, OperatorType &inOperator)
      { 
        std::cout << "WARNING: Calling rhs::domain_base Initialize" << std::endl;
        return(0); 
      };
      virtual int SetupRHS(GridType &inGrid, StateType &inState, StateType &rhsState,int threadId)
      { 
        std::cout << "WARNING: Calling rhs::domain_base SetupRHS" << std::endl;
        return(0); 
      };
      virtual int RHS(int threadId)
      { 
        std::cout << "WARNING: Calling rhs::domain_base RHS" << std::endl;
        return(0); 
      };
      virtual double TimeStep(double *outCFL = NULL)
      { 
        std::cout << "WARNING: Calling rhs::domain_base TimeStep" << std::endl;
        return(0.0); 
      };
      virtual void SetGlobal(GlobalType &inGlobal)
      {
        globalPtr = &inGlobal;
      };
      virtual void SetDomainBCs(std::vector<BoundaryType> &domainBoundaries,
                                std::vector<BCType> &domainBCs)
      {
        std::cout << "WARNING: Calling rhs::domain_base SetDomainBCs" << std::endl;
      };
      virtual int InitThreadIntervals() 
      { 
        std::cout << "WARNING: Calling rhs::domain_base InitThreadIntervals" << std::endl;
        return(0); 
      };
      virtual int ComputeDV(int threadId = 0) 
      { 
        std::cout << "WARNING: Calling rhs::domain_base ComputeDV" << std::endl;
        return(0); 
      };
    protected:
      GlobalType *globalPtr;

    };

  };
};
#endif