Constant.H

Go to the documentation of this file.

//
// Basic IC that just sets the entire field to a constant value.
// Works with a single or multiple-component field.
//
 
#ifndef IC_CONSTANT_H_
#define IC_CONSTANT_H_
 
#include "AMReX_Config.H"
#include "IC/IC.H"
#include "IO/ParmParse.H"
#include "Util/Util.H"
#include "Unit/Unit.H"
 
namespace IC
{
class Constant : public IC<Set::Scalar>, public IC<Set::Vector>
{
public:
    class Zero;
    class One;
 
    static constexpr const char* name = "constant";
 
    virtual ~Constant() = default;
 
    Constant (amrex::Vector<amrex::Geometry> &_geom) :
        IC<Set::Scalar>(_geom), IC<Set::Vector>(_geom) {}
    Constant (amrex::Vector<amrex::Geometry> &_geom, IO::ParmParse &pp) : 
        IC<Set::Scalar>(_geom), IC<Set::Vector>(_geom)
    {pp_queryclass(*this);}
    Constant (amrex::Vector<amrex::Geometry> &_geom, IO::ParmParse &pp, std::string name) : 
        IC<Set::Scalar>(_geom), IC<Set::Vector>(_geom)
    {pp_queryclass(name,*this);}
    Constant (amrex::Vector<amrex::Geometry> &_geom, Unit a_unit, IO::ParmParse &pp, std::string name) : 
        IC<Set::Scalar>(_geom), IC<Set::Vector>(_geom), unit(a_unit)
    {pp_queryclass(name,*this);}
 
 
    virtual void Add(const int &lev, Set::Field<Set::Scalar> &a_field, Set::Scalar /*time*/) override
    {
        Util::Assert(INFO,TEST((m_value.size() == 1 || (int)m_value.size() == (int)a_field[lev]->nComp())));
        for (amrex::MFIter mfi(*a_field[lev],amrex::TilingIfNotGPU()); mfi.isValid(); ++mfi)
        {
            const amrex::Box& bx = mfi.growntilebox();
            amrex::Array4<Set::Scalar> const& field = a_field[lev]->array(mfi);
            for (int m = 0; m < a_field[lev]->nComp(); m++)
            {
                const Set::Scalar value =
                    m_value.size() == 1 ? m_value[0] : m_value[m];
                amrex::ParallelFor (bx,[=] AMREX_GPU_DEVICE(int i, int j, int k) {
                    field(i,j,k,m) += value;
                });
            }
        }
    }
 
    virtual void Add(const int &lev, Set::Field<Set::Vector> &a_field, Set::Scalar /*time*/) override
    {
        Util::Assert(INFO,TEST((m_value.size() == 1 || (int)m_value.size() == AMREX_SPACEDIM)));
        for (amrex::MFIter mfi(*a_field[lev],amrex::TilingIfNotGPU()); mfi.isValid(); ++mfi)
        {
            const amrex::Box& bx = mfi.growntilebox();
            amrex::Array4<Set::Vector> const& field = a_field[lev]->array(mfi);
            for (int m = 0; m < a_field[lev]->nComp(); m++)
            {
                const Set::Scalar value =
                    m_value.size() == 1 ? m_value[0] : m_value[m];
                amrex::ParallelFor (bx,[=] AMREX_GPU_DEVICE(int i, int j, int k) {
                    field(i,j,k)(m) += value;
                });
            }
        }
    }
 
    static void Parse(Constant & value, IO::ParmParse & pp)
    {
        // Default: set equal to one everywhere
        value.m_value.clear();
 
        // Value (or values if multicomponent) to set field to 
        pp.queryarr_required("value", value.m_value, value.unit); 
    }
protected:
    std::vector<Set::Scalar> m_value;
    Unit unit;
};
 
class Constant::Zero : public Constant
{
public:
    explicit Zero(amrex::Vector<amrex::Geometry> &_geom) :
        Constant(_geom)
    {
        m_value = {0.0};
    }
};
 
class Constant::One : public Constant
{
public:
    explicit One(amrex::Vector<amrex::Geometry> &_geom) :
        Constant(_geom)
    {
        m_value = {1.0};
    }
};
}
#endif