#include <VariableConverter.h>

Public Member Functions
	VariableConverter (const LibUtilities::SessionReaderSharedPtr &pSession, const int spaceDim, const SpatialDomains::MeshGraphSharedPtr &pGraph=nullptr)

	~VariableConverter ()=default

void	GetDynamicEnergy (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &energy)
	Compute the dynamic energy \( e = rho*V^2/2 \). More...

void	GetInternalEnergy (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &energy)
	Compute the specific internal energy \( e = (E - rho*V^2/2)/rho \). More...

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> \|\| tinysimd::is_vector_floating_point_v<T>>::type>
T	GetInternalEnergy (T *physfield)

void	GetEnthalpy (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &enthalpy)
	Compute the specific enthalpy \( h = e + p/rho \). More...

void	GetVelocityVector (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)
	Compute the velocity field \( \mathbf{v} \) given the momentum \( \rho\mathbf{v} \). More...

void	GetMach (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &soundspeed, Array< OneD, NekDouble > &mach)
	Compute the mach number \( M = \\| \mathbf{v} \\|^2 / c \). More...

void	GetDynamicViscosity (const Array< OneD, const NekDouble > &temperature, Array< OneD, NekDouble > &mu)
	Compute the dynamic viscosity using the Sutherland's law \( \mu = \mu_star * (T / T_star)^3/2 * (1 + C) / (T/T_star + C) \), C : 110. /Tref Tref : the reference temperature, Tref, should always given in Kelvin, if non-dimensional should be the reference for non-dimensionalizing muref : the dynamic viscosity or the 1/Re corresponding to Tref T_star : m_pInf / (m_rhoInf * m_gasConstant),non-dimensional or dimensional. More...

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> \|\| tinysimd::is_vector_floating_point_v<T>>::type>
T	GetDynamicViscosity (T &temperature)

void	GetAbsoluteVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &Vtot)

void	GetTemperature (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &temperature)
	Compute the temperature using the equation of state. More...

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> \|\| tinysimd::is_vector_floating_point_v<T>>::type>
T	GetTemperature (T *physfield)

void	GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
	Calculate the pressure using the equation of state. More...

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> \|\| tinysimd::is_vector_floating_point_v<T>>::type>
T	GetPressure (T *physfield)

void	GetSoundSpeed (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &soundspeed)
	Compute the sound speed using the equation of state. More...

void	GetEntropy (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &entropy)
	Compute the entropy using the equation of state. More...

void	GetEFromRhoP (const Array< OneD, NekDouble > &rho, const Array< OneD, NekDouble > &pressure, Array< OneD, NekDouble > &energy)
	Compute \( e(rho,p) \) using the equation of state. More...

void	GetRhoFromPT (const Array< OneD, NekDouble > &pressure, const Array< OneD, NekDouble > &temperature, Array< OneD, NekDouble > &rho)
	Compute \( rho(p,T) \) using the equation of state. More...

void	GetDmuDT (const Array< OneD, const NekDouble > &temperature, const Array< OneD, const NekDouble > &mu, Array< OneD, NekDouble > &DmuDT)
	Compute the dynamic viscosity using the Sutherland's law \( \mu = \mu_star * (T / T_star)^3/2 * (T_star + 110) / (T + 110) \),. More...

const EquationOfStateSharedPtr	Geteos ()

void	SetAv (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const Array< OneD, NekDouble > > &consVar, const Array< OneD, NekDouble > &div=NullNekDouble1DArray, const Array< OneD, NekDouble > &curlSquared=NullNekDouble1DArray)

Array< OneD, NekDouble > &	GetAv ()

Array< OneD, NekDouble > &	GetAvTrace ()

bool	GetFlagCalcDivCurl (void) const

void	SetElmtMinHP (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
	Compute an estimate of minimum h/p for each element of the expansion. More...

Array< OneD, NekDouble > &	GetElmtMinHP ()

void	GetSensor (const MultiRegions::ExpListSharedPtr &field, const Array< OneD, const Array< OneD, NekDouble > > &physarray, Array< OneD, NekDouble > &Sensor, Array< OneD, NekDouble > &SensorKappa, int offset=1)

void	GetMuAv (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &muAv)
	Calculate the physical artificial viscosity based on modal sensor. More...

void	GetMuAv (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, const Array< OneD, NekDouble > > &consVar, const Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &muAv)
	Calculate the physical artificial viscosity based on dilatation of velocity vector. More...

void	ApplyDucros (const Array< OneD, NekDouble > &div, const Array< OneD, NekDouble > &curlSquare, Array< OneD, NekDouble > &muAv)
	Apply Ducros (anti-vorticity) sensor averaged over the element. More...

void	ApplyC0Smooth (Array< OneD, NekDouble > &field)
	Make field C0. More...

Protected Attributes
LibUtilities::SessionReaderSharedPtr	m_session

EquationOfStateSharedPtr	m_eos

size_t	m_spacedim

NekDouble	m_pInf

NekDouble	m_rhoInf

NekDouble	m_gasConstant

NekDouble	m_mu

NekDouble	m_Skappa

NekDouble	m_Kappa

NekDouble	m_oneOverT_star

NekDouble	m_Tref

NekDouble	m_TRatioSutherland

NekDouble	m_mu0
	Shock sensor. More...

std::string	m_shockCaptureType

std::string	m_shockSensorType

std::string	m_ducrosSensor

std::string	m_smoothing

MultiRegions::ContFieldSharedPtr	m_C0ProjectExp = nullptr

Array< OneD, NekDouble >	m_hOverP
	h/p scaling More...

Array< OneD, NekDouble >	m_muAv
	storage More...

Array< OneD, NekDouble >	m_muAvTrace

bool	m_flagCalcDivCurl = false

Detailed Description

Definition at line 51 of file VariableConverter.h.

Constructor & Destructor Documentation

◆ VariableConverter()

Nektar::VariableConverter::VariableConverter	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const int	spaceDim,
		const SpatialDomains::MeshGraphSharedPtr &	pGraph = `nullptr`
	)

Definition at line 47 of file VariableConverter.cpp.

    : m_session(pSession), m_spacedim(spaceDim)
{
    // Create equation of state object
    std::string eosType;
    m_session->LoadSolverInfo("EquationOfState", eosType, "IdealGas");
    m_eos = GetEquationOfStateFactory().CreateInstance(eosType, m_session);
 
    // Parameters for dynamic viscosity
    m_session->LoadParameter("pInf", m_pInf, 101325);
    m_session->LoadParameter("rhoInf", m_rhoInf, 1.225);
    m_session->LoadParameter("GasConstant", m_gasConstant, 287.058);
    m_session->LoadParameter("mu", m_mu, 1.78e-05);
    m_oneOverT_star = (m_rhoInf * m_gasConstant) / m_pInf;
 
    // Parameters for sensor
    m_session->LoadParameter("Skappa", m_Skappa, -1.0);
    m_session->LoadParameter("Kappa", m_Kappa, 0.25);
 
    m_hOverP = NullNekDouble1DArray;
 
    // Shock sensor
    m_session->LoadSolverInfo("ShockCaptureType", m_shockCaptureType, "Off");
    if (m_shockCaptureType == "Physical")
    {
        // Artificial viscosity scaling constant
        m_session->LoadParameter("mu0", m_mu0, 1.0);
 
        m_muAv      = NullNekDouble1DArray;
        m_muAvTrace = NullNekDouble1DArray;
 
        // Check for Modal/Dilatation sensor
        m_session->LoadSolverInfo("ShockSensorType", m_shockSensorType,
                                  "Dilatation");
 
        // Check for Ducros sensor
        m_session->LoadSolverInfo("DucrosSensor", m_ducrosSensor, "Off");
 
        if (m_ducrosSensor != "Off" || m_shockSensorType == "Dilatation")
        {
            m_flagCalcDivCurl = true;
        }
    }
    // Load smoothing type.
    // We only allocate the smoother if a mesh-graph was passed to the
    // constructor. This is done to prevent the smoother from being allocated
    // in cases when it won't be used. Otherwise, any class in the code that
    // allocates a VariableConverter object try to will allocate a smoother,
    // even if no mesh graph was passed to the constructor.
    // TODO: the smoother should be separated from the VariableConverter class.
    m_session->LoadSolverInfo("Smoothing", m_smoothing, "Off");
    if (m_smoothing == "C0" && pGraph.get() != nullptr)
    {
        m_C0ProjectExp =
            MemoryManager<MultiRegions::ContField>::AllocateSharedPtr(
                m_session, pGraph, m_session->GetVariable(0));
    }
 
    std::string viscosityType;
    m_session->LoadSolverInfo("ViscosityType", viscosityType, "Constant");
    if ("Variable" == viscosityType)
    {
        WARNINGL0(
            m_session->DefinesParameter("Tref"),
            "The Tref should be given in Kelvin for using the Sutherland's law "
            "of dynamic viscosity. The default is 288.15. Note the mu or "
            "Reynolds number should coorespond to this temperature.");
        m_session->LoadParameter("Tref", m_Tref, 288.15);
        m_TRatioSutherland = 110.0 / m_Tref;
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::GetEquationOfStateFactory(), m_C0ProjectExp, m_ducrosSensor, m_eos, m_flagCalcDivCurl, m_gasConstant, m_hOverP, m_Kappa, m_mu, m_mu0, m_muAv, m_muAvTrace, m_oneOverT_star, m_pInf, m_rhoInf, m_session, m_shockCaptureType, m_shockSensorType, m_Skappa, m_smoothing, m_TRatioSutherland, m_Tref, Nektar::NullNekDouble1DArray, and WARNINGL0.

◆ ~VariableConverter()

Nektar::VariableConverter::~VariableConverter ( )

default

Member Function Documentation

◆ ApplyC0Smooth()

void Nektar::VariableConverter::ApplyC0Smooth ( Array< OneD, NekDouble > & field )

Make field C0.

Parameters

field Input Field

Definition at line 764 of file VariableConverter.cpp.

{
    // Make sure that the C0 projection operator has been allocated. Note that
    // the VariableConverter object can be allocated without the C0 smoother.
    // This is why this check is needed. Ideally, the C0 smoother is separated
    // from the VariableConverter class.
    ASSERTL0(m_C0ProjectExp.get() != nullptr,
             "C0 projection operator not initialized in "
             "VariableConverter::ApplyC0Smooth()");
 
    int nCoeffs = m_C0ProjectExp->GetNcoeffs();
    Array<OneD, NekDouble> muFwd(nCoeffs);
    Array<OneD, NekDouble> weights(nCoeffs, 1.0);
    // Assemble global expansion coefficients for viscosity
    m_C0ProjectExp->FwdTransLocalElmt(field, m_C0ProjectExp->UpdateCoeffs());
    m_C0ProjectExp->Assemble();
    Vmath::Vcopy(nCoeffs, m_C0ProjectExp->GetCoeffs(), 1, muFwd, 1);
    // Global coefficients
    Vmath::Vcopy(nCoeffs, weights, 1, m_C0ProjectExp->UpdateCoeffs(), 1);
    // This is the sign vector
    m_C0ProjectExp->GlobalToLocal();
    // Get weights
    m_C0ProjectExp->Assemble();
    // Divide
    Vmath::Vdiv(nCoeffs, muFwd, 1, m_C0ProjectExp->GetCoeffs(), 1,
                m_C0ProjectExp->UpdateCoeffs(), 1);
    // Get local coefficients
    m_C0ProjectExp->GlobalToLocal();
    // Get C0 field
    m_C0ProjectExp->BwdTrans(m_C0ProjectExp->GetCoeffs(), field);
}

References ASSERTL0, FilterPython_Function::field, m_C0ProjectExp, Vmath::Vcopy(), and Vmath::Vdiv().

Referenced by SetAv().

◆ ApplyDucros()

void Nektar::VariableConverter::ApplyDucros	(	const Array< OneD, NekDouble > &	div,
		const Array< OneD, NekDouble > &	curlSquare,
		Array< OneD, NekDouble > &	muAv
	)

Apply Ducros (anti-vorticity) sensor averaged over the element.

Parameters

field Input Field

Definition at line 738 of file VariableConverter.cpp.

{
    // machine eps**2
    NekDouble eps = std::numeric_limits<NekDouble>::epsilon();
    eps *= eps;
 
    // loop over points
    size_t nPts = div.size();
    for (size_t p = 0; p < nPts; ++p)
    {
        NekDouble tmpDiv2 = div[p];
        tmpDiv2 *= tmpDiv2;
        NekDouble denDuc = tmpDiv2 + curlSquare[p] + eps;
        NekDouble Duc    = tmpDiv2 / denDuc;
        // apply
        muAv[p] *= Duc;
    }
}

References CellMLToNektar.cellml_metadata::p.

Referenced by SetAv().

◆ GetAbsoluteVelocity()

void Nektar::VariableConverter::GetAbsoluteVelocity	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	Vtot
	)

Definition at line 276 of file VariableConverter.cpp.

{
    const size_t nPts = physfield[0].size();
 
    // Getting the velocity vector on the 2D normal space
    Array<OneD, Array<OneD, NekDouble>> velocity(m_spacedim);
 
    Vmath::Zero(Vtot.size(), Vtot, 1);
 
    for (size_t i = 0; i < m_spacedim; ++i)
    {
        velocity[i] = Array<OneD, NekDouble>(nPts);
    }
 
    GetVelocityVector(physfield, velocity);
 
    for (size_t i = 0; i < m_spacedim; ++i)
    {
        Vmath::Vvtvp(nPts, velocity[i], 1, velocity[i], 1, Vtot, 1, Vtot, 1);
    }
 
    Vmath::Vsqrt(nPts, Vtot, 1, Vtot, 1);
}

References GetVelocityVector(), m_spacedim, Vmath::Vsqrt(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by GetMuAv().

◆ GetAv()

Array< OneD, NekDouble > & Nektar::VariableConverter::GetAv ( )

inline

Definition at line 166 of file VariableConverter.h.

    {
        ASSERTL1(m_muAv != NullNekDouble1DArray, "m_muAv not set");
        return m_muAv;
    }

References ASSERTL1, m_muAv, and Nektar::NullNekDouble1DArray.

◆ GetAvTrace()

Array< OneD, NekDouble > & Nektar::VariableConverter::GetAvTrace ( )

inline

Definition at line 172 of file VariableConverter.h.

    {
        ASSERTL1(m_muAvTrace != NullNekDouble1DArray, "m_muAvTrace not set");
        return m_muAvTrace;
    }

References ASSERTL1, m_muAvTrace, and Nektar::NullNekDouble1DArray.

◆ GetDmuDT()

void Nektar::VariableConverter::GetDmuDT	(	const Array< OneD, const NekDouble > &	temperature,
		const Array< OneD, const NekDouble > &	mu,
		Array< OneD, NekDouble > &	DmuDT
	)

Compute the dynamic viscosity using the Sutherland's law \( \mu = \mu_star * (T / T_star)^3/2 * (T_star + 110) / (T + 110) \),.

Definition at line 259 of file VariableConverter.cpp.

{
    const size_t nPts = temperature.size();
    NekDouble tmp     = 0.0;
    NekDouble ratio;
 
    for (size_t i = 0; i < nPts; ++i)
    {
        ratio = temperature[i] * m_oneOverT_star;
        tmp   = 0.5 * (ratio + 3.0 * m_TRatioSutherland) /
              (ratio * (ratio + m_TRatioSutherland));
        DmuDT[i] = mu[i] * tmp * m_oneOverT_star;
    }
}

References m_oneOverT_star, and m_TRatioSutherland.

◆ GetDynamicEnergy()

void Nektar::VariableConverter::GetDynamicEnergy	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	energy
	)

Compute the dynamic energy \( e = rho*V^2/2 \).

Definition at line 125 of file VariableConverter.cpp.

{
    size_t nPts = physfield[m_spacedim + 1].size();
    Vmath::Zero(nPts, energy, 1);
 
    // tmp = (rho * u_i)^2
    for (size_t i = 0; i < m_spacedim; ++i)
    {
        Vmath::Vvtvp(nPts, physfield[i + 1], 1, physfield[i + 1], 1, energy, 1,
                     energy, 1);
    }
    // Divide by rho and multiply by 0.5 --> tmp = 0.5 * rho * u^2
    Vmath::Vdiv(nPts, energy, 1, physfield[0], 1, energy, 1);
    Vmath::Smul(nPts, 0.5, energy, 1, energy, 1);
}

References m_spacedim, Vmath::Smul(), Vmath::Vdiv(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by GetInternalEnergy().

◆ GetDynamicViscosity() [1/2]

void Nektar::VariableConverter::GetDynamicViscosity	(	const Array< OneD, const NekDouble > &	temperature,
		Array< OneD, NekDouble > &	mu
	)

Compute the dynamic viscosity using the Sutherland's law \( \mu = \mu_star * (T / T_star)^3/2 * (1 + C) / (T/T_star + C) \), C : 110. /Tref Tref : the reference temperature, Tref, should always given in Kelvin, if non-dimensional should be the reference for non-dimensionalizing muref : the dynamic viscosity or the 1/Re corresponding to Tref T_star : m_pInf / (m_rhoInf * m_gasConstant),non-dimensional or dimensional.

WARNING, if this routine is modified the same must be done in the FieldConvert utility ProcessWSS.cpp (this class should be restructured).

Parameters

temperature	Input temperature.
mu	The resulting dynamic viscosity.

Definition at line 244 of file VariableConverter.cpp.

{
    const size_t nPts = temperature.size();
 
    for (size_t i = 0; i < nPts; ++i)
    {
        mu[i] = GetDynamicViscosity(temperature[i]);
    }
}

References GetDynamicViscosity().

Referenced by GetDynamicViscosity().

◆ GetDynamicViscosity() [2/2]

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>

T Nektar::VariableConverter::GetDynamicViscosity ( T & temperature )

inline

Definition at line 100 of file VariableConverter.h.

    {
        const NekDouble onePlusC = 1.0 + m_TRatioSutherland;
 
        NekDouble mu_star = m_mu;
 
        T ratio = temperature * m_oneOverT_star;
        return mu_star * ratio * sqrt(ratio) * onePlusC /
               (ratio + m_TRatioSutherland);
    }

References m_mu, m_oneOverT_star, m_TRatioSutherland, and tinysimd::sqrt().

◆ GetEFromRhoP()

void Nektar::VariableConverter::GetEFromRhoP	(	const Array< OneD, NekDouble > &	rho,
		const Array< OneD, NekDouble > &	pressure,
		Array< OneD, NekDouble > &	energy
	)

Compute \( e(rho,p) \) using the equation of state.

Parameters

rho	Input density
pressure	Input pressure
energy	The resulting internal energy.

Definition at line 393 of file VariableConverter.cpp.

{
    size_t nPts = rho.size();
 
    for (size_t i = 0; i < nPts; ++i)
    {
        energy[i] = m_eos->GetEFromRhoP(rho[i], pressure[i]);
    }
}

References m_eos, and CG_Iterations::pressure.

◆ GetElmtMinHP()

Array< OneD, NekDouble > & Nektar::VariableConverter::GetElmtMinHP ( )

Definition at line 538 of file VariableConverter.cpp.

{
    ASSERTL1(m_hOverP != NullNekDouble1DArray, "m_hOverP not set");
    return m_hOverP;
}

References ASSERTL1, m_hOverP, and Nektar::NullNekDouble1DArray.

◆ GetEnthalpy()

void Nektar::VariableConverter::GetEnthalpy	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	enthalpy
	)

Compute the specific enthalpy \( h = e + p/rho \).

Definition at line 165 of file VariableConverter.cpp.

{
    size_t nPts = physfield[0].size();
    Array<OneD, NekDouble> energy(nPts, 0.0);
    Array<OneD, NekDouble> pressure(nPts, 0.0);
 
    GetInternalEnergy(physfield, energy);
    GetPressure(physfield, pressure);
 
    // Calculate p/rho
    Vmath::Vdiv(nPts, pressure, 1, physfield[0], 1, enthalpy, 1);
    // Calculate h = e + p/rho
    Vmath::Vadd(nPts, energy, 1, enthalpy, 1, enthalpy, 1);
}

References GetInternalEnergy(), GetPressure(), CG_Iterations::pressure, Vmath::Vadd(), and Vmath::Vdiv().

◆ GetEntropy()

void Nektar::VariableConverter::GetEntropy	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	entropy
	)

Compute the entropy using the equation of state.

Parameters

physfield	Input physical field
soundspeed	The resulting sound speed \( c \).

Definition at line 371 of file VariableConverter.cpp.

{
    size_t nPts = physfield[0].size();
 
    Array<OneD, NekDouble> energy(nPts);
    GetInternalEnergy(physfield, energy);
 
    for (size_t i = 0; i < nPts; ++i)
    {
        entropy[i] = m_eos->GetEntropy(physfield[0][i], energy[i]);
    }
}

References GetInternalEnergy(), and m_eos.

◆ Geteos()

const EquationOfStateSharedPtr Nektar::VariableConverter::Geteos ( )

inline

Definition at line 154 of file VariableConverter.h.

    {
        return m_eos;
    }

References m_eos.

◆ GetFlagCalcDivCurl()

bool Nektar::VariableConverter::GetFlagCalcDivCurl ( void ) const

inline

Definition at line 178 of file VariableConverter.h.

    {
        return m_flagCalcDivCurl;
    }

References m_flagCalcDivCurl.

◆ GetInternalEnergy() [1/2]

void Nektar::VariableConverter::GetInternalEnergy	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	energy
	)

Compute the specific internal energy \( e = (E - rho*V^2/2)/rho \).

Definition at line 147 of file VariableConverter.cpp.

{
    size_t nPts = physfield[0].size();
    Array<OneD, NekDouble> tmp(nPts);
 
    GetDynamicEnergy(physfield, tmp);
 
    // Calculate rhoe = E - rho*V^2/2
    Vmath::Vsub(nPts, physfield[m_spacedim + 1], 1, tmp, 1, energy, 1);
    // Divide by rho
    Vmath::Vdiv(nPts, energy, 1, physfield[0], 1, energy, 1);
}

References GetDynamicEnergy(), m_spacedim, Vmath::Vdiv(), and Vmath::Vsub().

Referenced by GetEnthalpy(), GetEntropy(), GetPressure(), GetSoundSpeed(), and GetTemperature().

◆ GetInternalEnergy() [2/2]

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>

T Nektar::VariableConverter::GetInternalEnergy ( T * physfield )

inline

Definition at line 71 of file VariableConverter.h.

    {
        // get dynamic energy
        T oneOrho = 1.0 / physfield[0];
        T dynEne{};
        for (size_t d = 1; d < m_spacedim + 1; ++d)
        {
            T tmp = physfield[d]; // load 1x
            dynEne += tmp * tmp;
        }
        dynEne = 0.5 * dynEne * oneOrho;
 
        // Calculate rhoe = E - rho*V^2/2
        T energy = physfield[m_spacedim + 1] - dynEne;
        return energy * oneOrho;
    }

References Nektar::UnitTests::d(), and m_spacedim.

◆ GetMach()

void Nektar::VariableConverter::GetMach	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	soundspeed,
		Array< OneD, NekDouble > &	mach
	)

Compute the mach number \( M = \| \mathbf{v} \|^2 / c \).

Parameters

physfield	Input physical field.
soundfield	The speed of sound corresponding to physfield.
mach	The resulting mach number \( M \).

Definition at line 208 of file VariableConverter.cpp.

{
    const size_t nPts = physfield[0].size();
 
    Vmath::Vmul(nPts, physfield[1], 1, physfield[1], 1, mach, 1);
 
    for (size_t i = 1; i < m_spacedim; ++i)
    {
        Vmath::Vvtvp(nPts, physfield[1 + i], 1, physfield[1 + i], 1, mach, 1,
                     mach, 1);
    }
 
    Vmath::Vdiv(nPts, mach, 1, physfield[0], 1, mach, 1);
    Vmath::Vdiv(nPts, mach, 1, physfield[0], 1, mach, 1);
    Vmath::Vsqrt(nPts, mach, 1, mach, 1);
 
    Vmath::Vdiv(nPts, mach, 1, soundspeed, 1, mach, 1);
}

References m_spacedim, Vmath::Vdiv(), Vmath::Vmul(), Vmath::Vsqrt(), and Vmath::Vvtvp().

◆ GetMuAv() [1/2]

void Nektar::VariableConverter::GetMuAv	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, const Array< OneD, NekDouble > > &	consVar,
		const Array< OneD, NekDouble > &	div,
		Array< OneD, NekDouble > &	muAv
	)

Calculate the physical artificial viscosity based on dilatation of velocity vector.

Parameters

Definition at line 689 of file VariableConverter.cpp.

{
    size_t nPts = consVar[0].size();
 
    // Get sound speed
    // theoretically it should be used  the critical sound speed, this
    // matters for large Mach numbers (above 3.0)
    Array<OneD, NekDouble> soundSpeed(nPts, 0.0);
    GetSoundSpeed(consVar, soundSpeed);
 
    // Get abosolute velocity to compute lambda
    Array<OneD, NekDouble> absVelocity(nPts, 0.0);
    GetAbsoluteVelocity(consVar, absVelocity);
 
    // Loop over elements
    size_t nElmt = fields[0]->GetExpSize();
    for (size_t e = 0; e < nElmt; ++e)
    {
        int nElmtPoints = fields[0]->GetExp(e)->GetTotPoints();
        int physOffset  = fields[0]->GetPhys_Offset(e);
        int physEnd     = physOffset + nElmtPoints;
 
        NekDouble hOpTmp = m_hOverP[e];
 
        // Loop over the points
        for (int p = physOffset; p < physEnd; ++p)
        {
            // Get non-dimensional sensor based on dilatation
            NekDouble sSpeedTmp = soundSpeed[p];
            // (only compression waves)
            NekDouble divTmp = -div[p];
            divTmp           = std::max(divTmp, 0.0);
            NekDouble sensor = m_mu0 * hOpTmp * divTmp / sSpeedTmp;
            // Scale to viscosity scale
            NekDouble rho    = consVar[0][p];
            NekDouble lambda = sSpeedTmp + absVelocity[p];
            muAv[p]          = sensor * rho * lambda * hOpTmp;
        }
    }
}

References GetAbsoluteVelocity(), GetSoundSpeed(), m_hOverP, m_mu0, and CellMLToNektar.cellml_metadata::p.

◆ GetMuAv() [2/2]

void Nektar::VariableConverter::GetMuAv	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, const Array< OneD, NekDouble > > &	consVar,
		Array< OneD, NekDouble > &	muAv
	)

Calculate the physical artificial viscosity based on modal sensor.

Parameters

consVar Input field.

Definition at line 641 of file VariableConverter.cpp.

{
    size_t nPts = consVar[0].size();
    // Determine the maximum wavespeed
    Array<OneD, NekDouble> Lambdas(nPts, 0.0);
    Array<OneD, NekDouble> soundspeed(nPts, 0.0);
    Array<OneD, NekDouble> absVelocity(nPts, 0.0);
    GetSoundSpeed(consVar, soundspeed);
    GetAbsoluteVelocity(consVar, absVelocity);
    Vmath::Vadd(nPts, absVelocity, 1, soundspeed, 1, Lambdas, 1);
 
    // Compute sensor based on rho
    Array<OneD, NekDouble> Sensor(nPts, 0.0);
    GetSensor(fields[0], consVar, Sensor, muAv, 1);
 
    Array<OneD, NekDouble> tmp;
    size_t nElmt = fields[0]->GetExpSize();
    for (size_t e = 0; e < nElmt; ++e)
    {
        int physOffset  = fields[0]->GetPhys_Offset(e);
        int nElmtPoints = fields[0]->GetExp(e)->GetTotPoints();
 
        // Compute the maximum wave speed
        NekDouble LambdaElmt = 0.0;
        LambdaElmt = Vmath::Vmax(nElmtPoints, tmp = Lambdas + physOffset, 1);
 
        // Compute average bounded density
        NekDouble rhoAve =
            Vmath::Vsum(nElmtPoints, tmp = consVar[0] + physOffset, 1);
        rhoAve = rhoAve / nElmtPoints;
        rhoAve = Smath::Smax(rhoAve, 1.0e-4, 1.0e+4);
 
        // Scale sensor by coeff, h/p, and density
        LambdaElmt *= m_mu0 * m_hOverP[e] * rhoAve;
        Vmath::Smul(nElmtPoints, LambdaElmt, tmp = muAv + physOffset, 1,
                    tmp = muAv + physOffset, 1);
    }
}

References GetAbsoluteVelocity(), GetSensor(), GetSoundSpeed(), m_hOverP, m_mu0, Smath::Smax(), Vmath::Smul(), Vmath::Vadd(), Vmath::Vmax(), and Vmath::Vsum().

Referenced by SetAv().

◆ GetPressure() [1/2]

void Nektar::VariableConverter::GetPressure	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	pressure
	)

Calculate the pressure using the equation of state.

Parameters

physfield	Input momentum.
pressure	Computed pressure field.

Definition at line 308 of file VariableConverter.cpp.

{
    size_t nPts = physfield[0].size();
 
    Array<OneD, NekDouble> energy(nPts);
    GetInternalEnergy(physfield, energy);
 
    for (size_t i = 0; i < nPts; ++i)
    {
        pressure[i] = m_eos->GetPressure(physfield[0][i], energy[i]);
    }
}

References GetInternalEnergy(), m_eos, and CG_Iterations::pressure.

Referenced by GetEnthalpy().

◆ GetPressure() [2/2]

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>

T Nektar::VariableConverter::GetPressure ( T * physfield )

inline

Definition at line 133 of file VariableConverter.h.

    {
        T energy = GetInternalEnergy(physfield);
        return m_eos->GetPressure(physfield[0], energy);
    }

References GetInternalEnergy(), and m_eos.

◆ GetRhoFromPT()

void Nektar::VariableConverter::GetRhoFromPT	(	const Array< OneD, NekDouble > &	pressure,
		const Array< OneD, NekDouble > &	temperature,
		Array< OneD, NekDouble > &	rho
	)

Compute \( rho(p,T) \) using the equation of state.

Parameters

pressure	Input pressure
temperature	Input temperature
rho	The resulting density

Definition at line 412 of file VariableConverter.cpp.

{
    size_t nPts = pressure.size();
 
    for (size_t i = 0; i < nPts; ++i)
    {
        rho[i] = m_eos->GetRhoFromPT(pressure[i], temperature[i]);
    }
}

References m_eos, and CG_Iterations::pressure.

◆ GetSensor()

void Nektar::VariableConverter::GetSensor	(	const MultiRegions::ExpListSharedPtr &	field,
		const Array< OneD, const Array< OneD, NekDouble > > &	physarray,
		Array< OneD, NekDouble > &	Sensor,
		Array< OneD, NekDouble > &	SensorKappa,
		int	offset = `1`
	)

Definition at line 544 of file VariableConverter.cpp.

{
    NekDouble Skappa;
    NekDouble order;
    Array<OneD, NekDouble> tmp;
    Array<OneD, int> expOrderElement = field->EvalBasisNumModesMaxPerExp();
 
    for (int e = 0; e < field->GetExpSize(); e++)
    {
        int numModesElement = expOrderElement[e];
        int nElmtPoints     = field->GetExp(e)->GetTotPoints();
        int physOffset      = field->GetPhys_Offset(e);
        int nElmtCoeffs     = field->GetExp(e)->GetNcoeffs();
        int numCutOff       = numModesElement - offset;
 
        if (numModesElement <= offset)
        {
            Vmath::Fill(nElmtPoints, 0.0, tmp = Sensor + physOffset, 1);
            Vmath::Fill(nElmtPoints, 0.0, tmp = SensorKappa + physOffset, 1);
            continue;
        }
 
        // create vector to save the solution points per element at P = p;
        Array<OneD, NekDouble> elmtPhys(nElmtPoints,
                                        tmp = physarray[0] + physOffset);
        // Compute coefficients
        Array<OneD, NekDouble> elmtCoeffs(nElmtCoeffs, 0.0);
        field->GetExp(e)->FwdTrans(elmtPhys, elmtCoeffs);
 
        // ReduceOrderCoeffs reduces the polynomial order of the solution
        // that is represented by the coeffs given as an inarray. This is
        // done by projecting the higher order solution onto the orthogonal
        // basis and padding the higher order coefficients with zeros.
        Array<OneD, NekDouble> reducedElmtCoeffs(nElmtCoeffs, 0.0);
        field->GetExp(e)->ReduceOrderCoeffs(numCutOff, elmtCoeffs,
                                            reducedElmtCoeffs);
 
        Array<OneD, NekDouble> reducedElmtPhys(nElmtPoints, 0.0);
        field->GetExp(e)->BwdTrans(reducedElmtCoeffs, reducedElmtPhys);
 
        NekDouble numerator   = 0.0;
        NekDouble denominator = 0.0;
 
        // Determining the norm of the numerator of the Sensor
        Array<OneD, NekDouble> difference(nElmtPoints, 0.0);
        Vmath::Vsub(nElmtPoints, elmtPhys, 1, reducedElmtPhys, 1, difference,
                    1);
 
        numerator   = Vmath::Dot(nElmtPoints, difference, difference);
        denominator = Vmath::Dot(nElmtPoints, elmtPhys, elmtPhys);
 
        NekDouble elmtSensor = sqrt(numerator / denominator);
        elmtSensor =
            log10(std::max(elmtSensor, NekConstants::kNekMachineEpsilon));
 
        Vmath::Fill(nElmtPoints, elmtSensor, tmp = Sensor + physOffset, 1);
 
        // Compute reference value for sensor
        order = std::max(numModesElement - 1, 1);
        if (order > 0)
        {
            Skappa = m_Skappa - 4.25 * log10(static_cast<NekDouble>(order));
        }
        else
        {
            Skappa = 0.0;
        }
 
        // Compute artificial viscosity
        NekDouble elmtSensorKappa;
        if (elmtSensor < (Skappa - m_Kappa))
        {
            elmtSensorKappa = 0;
        }
        else if (elmtSensor > (Skappa + m_Kappa))
        {
            elmtSensorKappa = 1.0;
        }
        else
        {
            elmtSensorKappa =
                0.5 * (1 + sin(M_PI * (elmtSensor - Skappa) / (2 * m_Kappa)));
        }
        Vmath::Fill(nElmtPoints, elmtSensorKappa,
                    tmp = SensorKappa + physOffset, 1);
    }
}

References Vmath::Dot(), FilterPython_Function::field, Vmath::Fill(), Nektar::NekConstants::kNekMachineEpsilon, m_Kappa, m_Skappa, tinysimd::sqrt(), and Vmath::Vsub().

Referenced by GetMuAv().

◆ GetSoundSpeed()

void Nektar::VariableConverter::GetSoundSpeed	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	soundspeed
	)

Compute the sound speed using the equation of state.

Parameters

physfield	Input physical field
soundspeed	The resulting sound speed \( c \).

Definition at line 350 of file VariableConverter.cpp.

{
    size_t nPts = physfield[0].size();
 
    Array<OneD, NekDouble> energy(nPts);
    GetInternalEnergy(physfield, energy);
 
    for (size_t i = 0; i < nPts; ++i)
    {
        soundspeed[i] = m_eos->GetSoundSpeed(physfield[0][i], energy[i]);
    }
}

References GetInternalEnergy(), and m_eos.

Referenced by GetMuAv().

◆ GetTemperature() [1/2]

void Nektar::VariableConverter::GetTemperature	(	const Array< OneD, const Array< OneD, NekDouble > > &	physfield,
		Array< OneD, NekDouble > &	temperature
	)

Compute the temperature using the equation of state.

Parameters

physfield	Input physical field.
temperature	The resulting temperature \( T \).

Definition at line 329 of file VariableConverter.cpp.

{
    size_t nPts = physfield[0].size();
 
    Array<OneD, NekDouble> energy(nPts);
    GetInternalEnergy(physfield, energy);
 
    for (size_t i = 0; i < nPts; ++i)
    {
        temperature[i] = m_eos->GetTemperature(physfield[0][i], energy[i]);
    }
}

References GetInternalEnergy(), and m_eos.

◆ GetTemperature() [2/2]

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>

T Nektar::VariableConverter::GetTemperature ( T * physfield )

inline

Definition at line 122 of file VariableConverter.h.

    {
        T energy = GetInternalEnergy(physfield);
        return m_eos->GetTemperature(physfield[0], energy);
    }

References GetInternalEnergy(), and m_eos.

◆ GetVelocityVector()

void Nektar::VariableConverter::GetVelocityVector	(	const Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	velocity
	)

Compute the velocity field \( \mathbf{v} \) given the momentum \( \rho\mathbf{v} \).

Parameters

physfield	Momentum field.
velocity	Velocity field.

Definition at line 189 of file VariableConverter.cpp.

{
    const size_t nPts = physfield[0].size();
 
    for (size_t i = 0; i < m_spacedim; ++i)
    {
        Vmath::Vdiv(nPts, physfield[1 + i], 1, physfield[0], 1, velocity[i], 1);
    }
}

References m_spacedim, and Vmath::Vdiv().

Referenced by GetAbsoluteVelocity().

◆ SetAv()

void Nektar::VariableConverter::SetAv	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, const Array< OneD, NekDouble > > &	consVar,
		const Array< OneD, NekDouble > &	div = `NullNekDouble1DArray`,
		const Array< OneD, NekDouble > &	curlSquared = `NullNekDouble1DArray`
	)

Definition at line 424 of file VariableConverter.cpp.

{
    size_t nTracePts = fields[0]->GetTrace()->GetTotPoints();
    if (m_muAv == NullNekDouble1DArray)
    {
        size_t nPts = fields[0]->GetTotPoints();
        m_muAv      = Array<OneD, NekDouble>(nPts, 0.0);
        m_muAvTrace = Array<OneD, NekDouble>(nTracePts, 0.0);
        SetElmtMinHP(fields);
    }
 
    if (m_shockSensorType == "Modal")
    {
        // Get viscosity based on modal sensor
        GetMuAv(fields, consVar, m_muAv);
    }
    else
    {
        // Get viscosity based on dilatation sensor
        GetMuAv(fields, consVar, div, m_muAv);
    }
 
    // Apply Ducros sensor
    if (m_ducrosSensor != "Off")
    {
        ApplyDucros(div, curlSquared, m_muAv);
    }
 
    // Apply approximate C0 smoothing
    if (m_smoothing == "C0")
    {
        ApplyC0Smooth(m_muAv);
    }
 
    // Set trace AV
    Array<OneD, NekDouble> muFwd(nTracePts, 0.0), muBwd(nTracePts, 0.0);
    fields[0]->GetFwdBwdTracePhys(m_muAv, muFwd, muBwd, false, false, false);
    for (size_t p = 0; p < nTracePts; ++p)
    {
        m_muAvTrace[p] = 0.5 * (muFwd[p] + muBwd[p]);
    }
}

References ApplyC0Smooth(), ApplyDucros(), GetMuAv(), m_ducrosSensor, m_muAv, m_muAvTrace, m_shockSensorType, m_smoothing, Nektar::NullNekDouble1DArray, CellMLToNektar.cellml_metadata::p, and SetElmtMinHP().

◆ SetElmtMinHP()

void Nektar::VariableConverter::SetElmtMinHP ( const Array< OneD, MultiRegions::ExpListSharedPtr > & fields )

Compute an estimate of minimum h/p for each element of the expansion.

Definition at line 475 of file VariableConverter.cpp.

{
    size_t nElements = fields[0]->GetExpSize();
    if (m_hOverP == NullNekDouble1DArray)
    {
        m_hOverP = Array<OneD, NekDouble>(nElements, 1.0);
    }
 
    // Determine h/p scaling
    Array<OneD, int> pOrderElmt = fields[0]->EvalBasisNumModesMaxPerExp();
    int expdim                  = fields[0]->GetGraph()->GetMeshDimension();
    for (size_t e = 0; e < nElements; e++)
    {
        NekDouble h = 1.0e+10;
        switch (expdim)
        {
            case 3:
            {
                LocalRegions::Expansion3DSharedPtr exp3D;
                exp3D = fields[0]->GetExp(e)->as<LocalRegions::Expansion3D>();
                for (int i = 0; i < exp3D->GetNtraces(); ++i)
                {
                    h = std::min(
                        h, exp3D->GetGeom3D()->GetEdge(i)->GetVertex(0)->dist(*(
                               exp3D->GetGeom3D()->GetEdge(i)->GetVertex(1))));
                }
                break;
            }
 
            case 2:
            {
                LocalRegions::Expansion2DSharedPtr exp2D;
                exp2D = fields[0]->GetExp(e)->as<LocalRegions::Expansion2D>();
                for (int i = 0; i < exp2D->GetNtraces(); ++i)
                {
                    h = std::min(
                        h, exp2D->GetGeom2D()->GetEdge(i)->GetVertex(0)->dist(*(
                               exp2D->GetGeom2D()->GetEdge(i)->GetVertex(1))));
                }
                break;
            }
            case 1:
            {
                LocalRegions::Expansion1DSharedPtr exp1D;
                exp1D = fields[0]->GetExp(e)->as<LocalRegions::Expansion1D>();
 
                h = std::min(h, exp1D->GetGeom1D()->GetVertex(0)->dist(
                                    *(exp1D->GetGeom1D()->GetVertex(1))));
 
                break;
            }
            default:
            {
                ASSERTL0(false, "Dimension out of bound.")
            }
        }
 
        // Store h/p scaling
        m_hOverP[e] = h / std::max(pOrderElmt[e] - 1, 1);
    }
}

References ASSERTL0, Nektar::LocalRegions::Expansion1D::GetGeom1D(), m_hOverP, and Nektar::NullNekDouble1DArray.

Referenced by SetAv().

Member Data Documentation

◆ m_C0ProjectExp

MultiRegions::ContFieldSharedPtr Nektar::VariableConverter::m_C0ProjectExp = nullptr

protected

Definition at line 228 of file VariableConverter.h.

Referenced by ApplyC0Smooth(), and VariableConverter().

◆ m_ducrosSensor

std::string Nektar::VariableConverter::m_ducrosSensor

protected

Definition at line 226 of file VariableConverter.h.

Referenced by SetAv(), and VariableConverter().

◆ m_eos

EquationOfStateSharedPtr Nektar::VariableConverter::m_eos

protected

Definition at line 210 of file VariableConverter.h.

Referenced by GetEFromRhoP(), GetEntropy(), Geteos(), GetPressure(), GetRhoFromPT(), GetSoundSpeed(), GetTemperature(), and VariableConverter().

◆ m_flagCalcDivCurl

bool Nektar::VariableConverter::m_flagCalcDivCurl = false

protected

Definition at line 235 of file VariableConverter.h.

Referenced by GetFlagCalcDivCurl(), and VariableConverter().

◆ m_gasConstant

NekDouble Nektar::VariableConverter::m_gasConstant

protected

Definition at line 214 of file VariableConverter.h.

Referenced by VariableConverter().

◆ m_hOverP

Array<OneD, NekDouble> Nektar::VariableConverter::m_hOverP

protected

h/p scaling

Definition at line 231 of file VariableConverter.h.

Referenced by GetElmtMinHP(), GetMuAv(), SetElmtMinHP(), and VariableConverter().

◆ m_Kappa

NekDouble Nektar::VariableConverter::m_Kappa

protected

Definition at line 217 of file VariableConverter.h.

Referenced by GetSensor(), and VariableConverter().

◆ m_mu

NekDouble Nektar::VariableConverter::m_mu

protected

Definition at line 215 of file VariableConverter.h.

Referenced by GetDynamicViscosity(), and VariableConverter().

◆ m_mu0

NekDouble Nektar::VariableConverter::m_mu0

protected

Shock sensor.

Definition at line 223 of file VariableConverter.h.

Referenced by GetMuAv(), and VariableConverter().

◆ m_muAv

Array<OneD, NekDouble> Nektar::VariableConverter::m_muAv

protected

storage

Definition at line 233 of file VariableConverter.h.

Referenced by GetAv(), SetAv(), and VariableConverter().

◆ m_muAvTrace

Array<OneD, NekDouble> Nektar::VariableConverter::m_muAvTrace

protected

Definition at line 234 of file VariableConverter.h.

Referenced by GetAvTrace(), SetAv(), and VariableConverter().

◆ m_oneOverT_star

NekDouble Nektar::VariableConverter::m_oneOverT_star

protected

Definition at line 218 of file VariableConverter.h.

Referenced by GetDmuDT(), GetDynamicViscosity(), and VariableConverter().

◆ m_pInf

NekDouble Nektar::VariableConverter::m_pInf

protected

Definition at line 212 of file VariableConverter.h.

Referenced by VariableConverter().

◆ m_rhoInf

NekDouble Nektar::VariableConverter::m_rhoInf

protected

Definition at line 213 of file VariableConverter.h.

Referenced by VariableConverter().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::VariableConverter::m_session

protected

Definition at line 209 of file VariableConverter.h.

Referenced by VariableConverter().

◆ m_shockCaptureType

std::string Nektar::VariableConverter::m_shockCaptureType

protected

Definition at line 224 of file VariableConverter.h.

Referenced by VariableConverter().

◆ m_shockSensorType

std::string Nektar::VariableConverter::m_shockSensorType

protected

Definition at line 225 of file VariableConverter.h.

Referenced by SetAv(), and VariableConverter().

◆ m_Skappa

NekDouble Nektar::VariableConverter::m_Skappa

protected

Definition at line 216 of file VariableConverter.h.

Referenced by GetSensor(), and VariableConverter().

◆ m_smoothing

std::string Nektar::VariableConverter::m_smoothing

protected

Definition at line 227 of file VariableConverter.h.

Referenced by SetAv(), and VariableConverter().

◆ m_spacedim

size_t Nektar::VariableConverter::m_spacedim

protected

Definition at line 211 of file VariableConverter.h.

Referenced by GetAbsoluteVelocity(), GetDynamicEnergy(), GetInternalEnergy(), GetMach(), and GetVelocityVector().

◆ m_TRatioSutherland

NekDouble Nektar::VariableConverter::m_TRatioSutherland

protected

Definition at line 220 of file VariableConverter.h.

Referenced by GetDmuDT(), GetDynamicViscosity(), and VariableConverter().

◆ m_Tref

NekDouble Nektar::VariableConverter::m_Tref

protected

Definition at line 219 of file VariableConverter.h.

Referenced by VariableConverter().

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ VariableConverter()

◆ ~VariableConverter()

Member Function Documentation

◆ ApplyC0Smooth()

◆ ApplyDucros()

◆ GetAbsoluteVelocity()

◆ GetAv()

◆ GetAvTrace()

◆ GetDmuDT()

◆ GetDynamicEnergy()

◆ GetDynamicViscosity() [1/2]

◆ GetDynamicViscosity() [2/2]

◆ GetEFromRhoP()

◆ GetElmtMinHP()

◆ GetEnthalpy()

◆ GetEntropy()

◆ Geteos()

◆ GetFlagCalcDivCurl()

◆ GetInternalEnergy() [1/2]

◆ GetInternalEnergy() [2/2]

◆ GetMach()

◆ GetMuAv() [1/2]

◆ GetMuAv() [2/2]

◆ GetPressure() [1/2]

◆ GetPressure() [2/2]

◆ GetRhoFromPT()

◆ GetSensor()

◆ GetSoundSpeed()

◆ GetTemperature() [1/2]

◆ GetTemperature() [2/2]

◆ GetVelocityVector()

◆ SetAv()

◆ SetElmtMinHP()

Member Data Documentation

◆ m_C0ProjectExp

◆ m_ducrosSensor

◆ m_eos

◆ m_flagCalcDivCurl

◆ m_gasConstant

◆ m_hOverP

◆ m_Kappa

◆ m_mu

◆ m_mu0

◆ m_muAv

◆ m_muAvTrace

◆ m_oneOverT_star

◆ m_pInf

◆ m_rhoInf

◆ m_session

◆ m_shockCaptureType

◆ m_shockSensorType

◆ m_Skappa

◆ m_smoothing

◆ m_spacedim

◆ m_TRatioSutherland

◆ m_Tref