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_BoxArray.H>
#include <AMReX_DistributionMapping.H>
#include <AMReX_Extension.H>
#include <AMReX_GpuQualifiers.H>
#include <AMReX_IntVect.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 AllocateLevelMFs (
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm,
        const amrex::IntVect& ng_EB_alloc );

    void InitData (
        const amrex::Geometry& geom,
        const amrex::IntVect& Ex_stag,
        const amrex::IntVect& Ey_stag,
        const amrex::IntVect& Ez_stag);

    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 amrex::GpuArray<amrex::Real, AMREX_SPACEDIM>& dx_lev,
                                  const amrex::RealBox& prob_domain_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::epsilon_0;
    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_