CD_CdrPlasmaImExSdcStorage.H

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2021-2026 SINTEF Energy Research
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
 
#ifndef CD_CDRPLASMAIMEXSDCSTORAGE_H
#define CD_CDRPLASMAIMEXSDCSTORAGE_H
 
// Our includes
#include <CD_CdrPlasmaImExSdcStepper.H>
#include <CD_AmrMesh.H>
#include <CD_NamespaceHeader.H>
 
namespace Physics {
  namespace CdrPlasma {
 
    class CdrPlasmaImExSdcStepper::CdrStorage
    {
    public:
      CdrStorage();
 
      CdrStorage(const RefCountedPtr<AmrMesh>& a_amr,
                 const std::string&            a_realm,
                 const phase::which_phase      a_phase,
                 const int                     a_ncomp);
 
      ~CdrStorage();
 
      void
      allocateStorage(const int a_p);
 
      void
      deallocateStorage();
 
      EBAMRCellData&
      getScratch()
      {
        return m_scratch;
      }
 
      EBAMRCellData&
      getScratch2()
      {
        return m_scratch2;
      }
 
      EBAMRCellData&
      getError()
      {
        return m_error;
      }
 
      EBAMRCellData&
      getGradient()
      {
        return m_gradient;
      }
 
      EBAMRCellData&
      getOld()
      {
        return m_old;
      }
 
      EBAMRCellData&
      getScratchD()
      {
        return m_scratchD;
      }
 
      EBAMRCellData&
      getDivF()
      {
        return m_divF;
      }
 
      Vector<EBAMRCellData>&
      getPhi()
      {
        return m_phi;
      }
 
      Vector<EBAMRCellData>&
      getFAR()
      {
        return m_FAR;
      }
 
      Vector<EBAMRCellData>&
      getFD()
      {
        return m_FD;
      }
 
      Vector<EBAMRCellData>&
      getF()
      {
        return m_F;
      }
 
      EBAMRIVData&
      getEbScratch1()
      {
        return m_scratchIVs;
      }
 
      EBAMRIVData&
      getEbScratchD()
      {
        return m_scratchIVD;
      }
 
      EBAMRIVData&
      getEbState()
      {
        return m_scratchIV1;
      }
 
      EBAMRIVData&
      getEbVelo()
      {
        return m_scratchIV2;
      }
 
      EBAMRIVData&
      getEbFlux()
      {
        return m_scratchIV3;
      }
 
      EBAMRIVData&
      getEbGrad()
      {
        return m_scratchIV4;
      }
 
      EBAMRIFData&
      getDomainState()
      {
        return m_scratchIF1;
      }
 
      EBAMRIFData&
      getDomainVelo()
      {
        return m_scratchIF2;
      }
 
      EBAMRIFData&
      getDomainFlux()
      {
        return m_scratchIF3;
      }
 
      EBAMRIFData&
      getDomainGrad()
      {
        return m_scratchIF4;
      }
 
    protected:
      std::string m_realm;
 
      RefCountedPtr<AmrMesh> m_amr;
 
      phase::which_phase m_phase;
 
      int m_ncomp;
 
      int m_p;
 
      bool m_subcycle;
 
      EBAMRCellData m_scratch;
 
      EBAMRCellData m_scratch2;
 
      EBAMRCellData m_error;
 
      EBAMRCellData m_gradient;
 
      EBAMRCellData m_old;
 
      EBAMRCellData m_scratchD;
 
      EBAMRCellData m_divF;
 
      Vector<EBAMRCellData> m_phi;
 
      Vector<EBAMRCellData> m_FAR;
 
      Vector<EBAMRCellData> m_FD;
 
      Vector<EBAMRCellData> m_F;
 
      EBAMRIVData m_scratchIVs;
 
      EBAMRIVData m_scratchIVD;
 
      EBAMRIVData m_scratchIV1;
 
      EBAMRIVData m_scratchIV2;
 
      EBAMRIVData m_scratchIV3;
 
      EBAMRIVData m_scratchIV4;
 
      EBAMRIFData m_scratchIF1;
 
      EBAMRIFData m_scratchIF2;
 
      EBAMRIFData m_scratchIF3;
 
      EBAMRIFData m_scratchIF4;
    };
 
    class CdrPlasmaImExSdcStepper::FieldStorage
    {
    public:
      FieldStorage();
 
      FieldStorage(const RefCountedPtr<AmrMesh>& a_amr,
                   const std::string&            a_realm,
                   const phase::which_phase      a_phase,
                   const int                     a_ncomp);
 
      ~FieldStorage();
 
      void
      allocateStorage(const int a_p);
 
      void
      deallocateStorage();
 
      MFAMRCellData&
      getPrevious()
      {
        return m_previous;
      }
 
      EBAMRCellData&
      getElectricFieldCell()
      {
        return m_E_cell;
      }
 
      EBAMRFluxData&
      getElectricFieldFace()
      {
        return m_E_face;
      }
 
      EBAMRIVData&
      getElectricFieldEb()
      {
        return m_E_eb;
      }
 
      EBAMRIFData&
      getElectricFieldDomain()
      {
        return m_E_dom;
      }
 
    protected:
      std::string m_realm;
 
      RefCountedPtr<AmrMesh> m_amr;
 
      phase::which_phase m_phase;
 
      int m_ncomp;
 
      int m_p;
 
      MFAMRCellData m_previous;
 
      EBAMRCellData m_E_cell;
 
      EBAMRFluxData m_E_face;
 
      EBAMRIVData m_E_eb;
 
      EBAMRIFData m_E_dom;
    };
 
    class CdrPlasmaImExSdcStepper::RtStorage
    {
    public:
      RtStorage();
 
      RtStorage(const RefCountedPtr<AmrMesh>& a_amr,
                const std::string&            a_realm,
                const phase::which_phase      a_phase,
                const int                     a_ncomp);
 
      ~RtStorage();
 
      void
      allocateStorage(const int a_p);
 
      void
      deallocateStorage();
 
      EBAMRCellData&
      getPrevious()
      {
        return m_previous;
      }
 
      EBAMRIVData&
      getEbFlux()
      {
        return m_scratchIV;
      }
 
      EBAMRIFData&
      getDomainFlux()
      {
        return m_scratchIF;
      }
 
    protected:
      std::string m_realm;
 
      RefCountedPtr<AmrMesh> m_amr;
 
      phase::which_phase m_phase;
 
      int m_ncomp;
 
      int m_p;
 
      EBAMRCellData m_previous;
 
      EBAMRIVData m_scratchIV;
 
      EBAMRIFData m_scratchIF;
    };
 
    class CdrPlasmaImExSdcStepper::SigmaStorage
    {
    public:
      SigmaStorage();
 
      SigmaStorage(const RefCountedPtr<AmrMesh>& a_amr,
                   const std::string&            a_realm,
                   const phase::which_phase      a_phase,
                   const int                     a_ncomp);
 
      ~SigmaStorage();
 
      void
      allocateStorage(const int a_p);
 
      void
      deallocateStorage();
 
      EBAMRIVData&
      getScratch()
      {
        return m_scratch;
      }
 
      EBAMRIVData&
      getError()
      {
        return m_error;
      }
 
      Vector<EBAMRIVData>&
      getSigmaSolver()
      {
        return m_sigma;
      }
 
      Vector<EBAMRIVData>&
      getFnew()
      {
        return m_Fnew;
      }
 
      Vector<EBAMRIVData>&
      getFold()
      {
        return m_Fold;
      }
 
    protected:
      std::string m_realm;
 
      RefCountedPtr<AmrMesh> m_amr;
 
      phase::which_phase m_phase;
 
      int m_ncomp;
 
      int m_p;
 
      EBAMRIVData m_scratch;
 
      EBAMRIVData m_error;
 
      Vector<EBAMRIVData> m_sigma;
 
      Vector<EBAMRIVData> m_Fnew;
 
      Vector<EBAMRIVData> m_Fold;
    };
  } // namespace CdrPlasma
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#endif