MacroscopicProperties.H

Go to the documentation of this file.

/* Copyright 2020 Revathi Jambunathan
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
 
#ifndef WARPX_MACROSCOPICPROPERTIES_H_
#define WARPX_MACROSCOPICPROPERTIES_H_
 
#include "MacroscopicProperties_fwd.H"
 
#include "Utils/WarpXConst.H"
 
#include <AMReX_Array.H>
#include <AMReX_Extension.H>
#include <AMReX_GpuQualifiers.H>
#include <AMReX_MultiFab.H>
#include <AMReX_Parser.H>
#include <AMReX_REAL.H>
 
#include <memory>
#include <string>
 
 
class
MacroscopicProperties
{
public:
     MacroscopicProperties (); // constructor
     void ReadParameters ();
     void InitData ();
 
     amrex::MultiFab& getsigma_mf  () {return (*m_sigma_mf);}
     amrex::MultiFab& getepsilon_mf  () {return (*m_eps_mf);}
     amrex::MultiFab& getmu_mf  () {return (*m_mu_mf);}
 
     void InitializeMacroMultiFabUsingParser (amrex::MultiFab *macro_mf,
                                  amrex::ParserExecutor<3> const& macro_parser,
                                  const int lev);
 
     amrex::GpuArray<int, 3> sigma_IndexType;
     amrex::GpuArray<int, 3> epsilon_IndexType;
     amrex::GpuArray<int, 3> mu_IndexType;
     amrex::GpuArray<int, 3> Ex_IndexType;
     amrex::GpuArray<int, 3> Ey_IndexType;
     amrex::GpuArray<int, 3> Ez_IndexType;
     amrex::GpuArray<int, 3> macro_cr_ratio;
 
private:
 
     amrex::Real m_sigma = 0.0;
     amrex::Real m_epsilon = PhysConst::ep0;
     amrex::Real m_mu = PhysConst::mu0;
     std::unique_ptr<amrex::MultiFab> m_sigma_mf;
     std::unique_ptr<amrex::MultiFab> m_eps_mf;
     std::unique_ptr<amrex::MultiFab> m_mu_mf;
 
     std::string m_sigma_s = "constant";
     std::string m_epsilon_s = "constant";
     std::string m_mu_s = "constant";
 
     std::string m_str_sigma_function;
     std::string m_str_epsilon_function;
     std::string m_str_mu_function;
     std::unique_ptr<amrex::Parser> m_sigma_parser;
     std::unique_ptr<amrex::Parser> m_epsilon_parser;
     std::unique_ptr<amrex::Parser> m_mu_parser;
 
};
 
struct LaxWendroffAlgo {
 
     AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
     static amrex::Real alpha (amrex::Real const sigma,
                               amrex::Real const epsilon,
                               amrex::Real dt) {
         using namespace amrex;
         const amrex::Real fac1 = 0.5_rt * sigma * dt / epsilon;
         const amrex::Real alpha = (1._rt - fac1)/(1._rt + fac1);
         return alpha;
     }
 
     AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
     static amrex::Real beta (amrex::Real const sigma,
                              amrex::Real const epsilon,
                              amrex::Real dt) {
         using namespace amrex;
         const amrex::Real fac1 = 0.5_rt * sigma * dt / epsilon;
         const amrex::Real beta = dt / ( epsilon * (1._rt + fac1) );
         return beta;
     }
 
};
 
struct BackwardEulerAlgo {
 
     AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
     static amrex::Real alpha (amrex::Real const sigma,
                               amrex::Real const epsilon,
                               amrex::Real dt) {
         using namespace amrex;
         const amrex::Real fac1 = sigma * dt / epsilon;
         const amrex::Real alpha = (1._rt)/(1._rt + fac1);
         return alpha;
     }
 
     AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
     static amrex::Real beta (amrex::Real const sigma,
                              amrex::Real const epsilon,
                              amrex::Real dt) {
         using namespace amrex;
         const amrex::Real fac1 = sigma * dt / epsilon;
         const amrex::Real beta = dt / ( epsilon * (1._rt + fac1) );
         return beta;
     }
 
};
 
#endif // WARPX_MACROSCOPIC_PROPERTIES_H_