Boundary.H

Go to the documentation of this file.

#ifndef __BOUNDARY_H__
#define __BOUNDARY_H__

namespace simulation {
  namespace domain {
    namespace boundary {  

      namespace bc {
        
        enum BCType { HOLE=0,SPONGE, NUMBCTYPE };
        static const char *bcNames[] = {"HOLE","SPONGE","UNKNOWN"};
        int ResolveBCName(const std::string &inName);
        std::string ResolveBCType(int inType);
        
        class base {
          
        public:
          
          typedef simulation::state::base StateType;
          typedef StateType::MetaDataSetType DataDictionaryType;

          base() : bcType(0), paramPtr(NULL), myParams(true)
          {
            Create();
          };
          
          void SetParams(StateType &inParams)
          {
            DestroyParams();
            paramPtr = &inParams;
          };
          
          void DestroyParams()
          {
            if(myParams && (paramPtr != NULL))
              delete paramPtr;
            paramPtr = NULL;
            myParams = false;
          };
          
          void Destroy()
          {
            DestroyParams();
          };
          
          void Create()
          {
            Destroy();
            paramPtr = new StateType;
            myParams = true;
          };
          
          
          StateType &Params() { return(*paramPtr); };
          const StateType &Params() const { return(*paramPtr); };
          
          int BCType() const { return(bcType); };
          void SetBCType(int inType) { bcType = inType; };

          std::string &BCName() { return(bcName); };
          const std::string &BCName() const { return(bcName); };
          void SetBCName(const std::string &inName){ bcName = inName; };
          
          DataDictionaryType &ParamDictionary() { return(paramDictionary); };
          const DataDictionaryType &ParamDictionary() const { return(paramDictionary); };
          DataDictionaryType &StateDictionary() { return(stateDictionary); };
          const DataDictionaryType &StateDictionary() const { return(stateDictionary); };
          
        protected:
          
          int         bcType;
          std::string bcName;
          StateType  *paramPtr;
          
          DataDictionaryType     stateDictionary;
          DataDictionaryType     paramDictionary;
          
          bool myParams;
          
        };

      }


      class base {
        
      public:
        
        typedef simulation::state::base                    StateType;
        typedef simulation::grid::parallel_blockstructured GridType;
        typedef simulation::domain::boundary::bc::base     BCType;

        base() : statePtr(NULL), paramPtr(NULL), bcPtr(NULL), 
                 myState(true), myParams(true), myBC(true)
        {
          Create();
        };
        
        void SetBC(BCType &inBC)
        {
          DestroyBC();
          bcPtr = &inBC;
        }

        void SetState(StateType &inState)
        {
          DestroyState();
          statePtr = &inState;
        };
        
        void SetParams(StateType &inParams)
        {
          DestroyParams();
          paramPtr = &inParams;
        };
        
        void DestroyState()
        {
          if(myState && (statePtr != NULL))
            delete statePtr;
          statePtr = NULL;
          myState = false;
        };
        
        void DestroyParams()
        {
          if(myParams && (paramPtr != NULL))
            delete paramPtr;
          paramPtr = NULL;
          myParams = false;
        };

        void DestroyBC()
        {
          if(myBC && (bcPtr != NULL))
            delete bcPtr;
          bcPtr = NULL;
          myBC = false;
        };
        
        void Destroy()
        {
          DestroyState();
          DestroyParams();
          DestroyBC();
        };
        
        void Create()
        {
          Destroy();
          statePtr = new StateType;
          myState = true;
          paramPtr = new StateType;
          myParams = true;
          bcPtr    = new BCType;
          myBC     = true;
        };
        
        
        StateType &State() { return(*statePtr); };
        const StateType &State() const {return(*statePtr); };
        StateType &Params() { return(*paramPtr); };
        const StateType &Params() const { return(*paramPtr); };
        
        GridType &Grid() { return(*gridPtr); };
        const GridType &Grid() const {return(*gridPtr); };
        void SetGrid(GridType &inGrid) { gridPtr = &inGrid; };

        BCType &BC(){ return(*bcPtr); };
        const BCType &BC() const {return(*bcPtr); };

        int GridRegionID() const {return(gridRegionID); };
        void SetGridRegionID(int inID) { gridRegionID = inID; };

        const std::vector<pcpp::IndexIntervalType> &ThreadPartitionIntervals() const
        { return(threadPartitionIntervals); };
        std::vector<pcpp::IndexIntervalType> &ThreadPartitionIntervals()
        { return(threadPartitionIntervals); };
        const std::vector<pcpp::IndexIntervalType> &ThreadBufferIntervals() const
        { return(threadBufferIntervals); };
        std::vector<pcpp::IndexIntervalType> &ThreadBufferIntervals()
        { return(threadBufferIntervals); };
        const pcpp::IndexIntervalType &BoundaryPartitionInterval() const
        { return(boundaryPartitionInterval);};
        pcpp::IndexIntervalType &BoundaryPartitionInterval()
        { return(boundaryPartitionInterval);};
        const pcpp::IndexIntervalType &PartitionBufferInterval() const
        { return(partitionBufferInterval); };
        pcpp::IndexIntervalType &PartitionBufferInterval()
        { return(partitionBufferInterval); };
        
        void SetName(const std::string &inName) { boundaryName = inName; };
        const std::string &Name() const {return(boundaryName); };

      protected:
        
        int         gridRegionID;
        BCType     *bcPtr;
        StateType  *statePtr;
        StateType  *paramPtr;
        GridType   *gridPtr;
        std::string boundaryName;

        pcpp::IndexIntervalType boundaryPartitionInterval;
        pcpp::IndexIntervalType partitionBufferInterval;
        std::vector<pcpp::IndexIntervalType> threadPartitionIntervals;
        std::vector<pcpp::IndexIntervalType> threadBufferIntervals;
        
        //         StateType::MetaDataSetType     stateDataDictionary;
        //         StateType::MetaDataSetType     paramDataDictionary;
        
        bool myState;
        bool myParams;
        bool myBC;
        
      };



    }
  }
}
#endif