Nektar::VariableConverter Class Reference

#include <VariableConverter.h>

Public Member Functions
	VariableConverter (const LibUtilities::SessionReaderSharedPtr &pSession, const int spaceDim)
	~VariableConverter ()
	Destructor for VariableConverter class. More...
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<T>::value || tinysimd::is_vector_floating_point<T>::value >::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) \), where: \mu_star = 1.7894 * 10^-5 Kg / (m * s) T_star = 288.15 K C = 110. / 288.15. More...
template<class T , typename = typename std::enable_if < std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value >::type>
T	GetDynamicViscosity (T &temperature)
void	GetAbsoluteVelocity (const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, NekDouble > &Vtot)
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	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<T>::value || tinysimd::is_vector_floating_point<T>::value >::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<T>::value || tinysimd::is_vector_floating_point<T>::value >::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) \), where: \mu_star = 1.7894 * 10^-5 Kg / (m * s) T_star = 288.15 K. More...
const EquationOfStateSharedPtr	Geteos ()

Protected Attributes
LibUtilities::SessionReaderSharedPtr	m_session
EquationOfStateSharedPtr	m_eos
int	m_spacedim
NekDouble	m_pInf
NekDouble	m_rhoInf
NekDouble	m_gasConstant
NekDouble	m_mu
NekDouble	m_Skappa
NekDouble	m_Kappa
NekDouble	m_oneOverT_star

Detailed Description

Definition at line 50 of file VariableConverter.h.

Constructor & Destructor Documentation

VariableConverter()

Nektar::VariableConverter::VariableConverter	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const int	spaceDim
	)

Definition at line 44 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);
 
 
}

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::GetEquationOfStateFactory(), m_eos, m_gasConstant, m_Kappa, m_mu, m_oneOverT_star, m_pInf, m_rhoInf, m_session, and m_Skappa.

~VariableConverter()

Nektar::VariableConverter::~VariableConverter

(

)

Destructor for VariableConverter class.

Definition at line 70 of file VariableConverter.cpp.

{
}

Member Function Documentation

GetAbsoluteVelocity()

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

Definition at line 231 of file VariableConverter.cpp.

{
    const int 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 (int i = 0; i < m_spacedim; ++i)
    {
        velocity[i] = Array<OneD, NekDouble>(nPts);
    }
 
    GetVelocityVector(physfield, velocity);
 
    for (int 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().

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) \), where: \mu_star = 1.7894 * 10^-5 Kg / (m * s) T_star = 288.15 K.

Parameters

physfield	Input physical field.
mu	The resulting dynamic viscosity.

Definition at line 215 of file VariableConverter.cpp.

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

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 78 of file VariableConverter.cpp.

{
    size_t nPts = physfield[m_spacedim + 1].size();
    Vmath::Zero(nPts, energy, 1);
 
    // tmp = (rho * u_i)^2
    for (int 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) \), where: \mu_star = 1.7894 * 10^-5 Kg / (m * s) T_star = 288.15 K C = 110. / 288.15.

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 field.
mu	The resulting dynamic viscosity.

Definition at line 195 of file VariableConverter.cpp.

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

GetDynamicViscosity() [2/2]

template<class T , typename = typename std::enable_if < std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value >::type>

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

inline

Definition at line 103 of file VariableConverter.h.

    {
        constexpr NekDouble C = .38175;
        constexpr NekDouble onePlusC = 1.0 + C;
 
        NekDouble mu_star = m_mu;
 
        T ratio = temperature * m_oneOverT_star;
        return mu_star * ratio * sqrt(ratio) * onePlusC / (ratio + C);
    }

References m_mu, m_oneOverT_star, 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 441 of file VariableConverter.cpp.

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

References m_eos, and CG_Iterations::pressure.

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 118 of file VariableConverter.cpp.

{
    int 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 419 of file VariableConverter.cpp.

{
    int nPts = physfield[0].size();
 
    Array<OneD, NekDouble> energy(nPts);
    GetInternalEnergy(physfield, energy);
 
    for (int 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 168 of file VariableConverter.h.

    {
        return m_eos;
    }

References m_eos.

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 100 of file VariableConverter.cpp.

{
    int 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<T>::value || tinysimd::is_vector_floating_point<T>::value >::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 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 161 of file VariableConverter.cpp.

{
    const int nPts = physfield[0].size();
 
    Vmath::Vmul(nPts, physfield[1], 1, physfield[1], 1, mach, 1);
 
    for (int 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().

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 356 of file VariableConverter.cpp.

{
    int nPts = physfield[0].size();
 
    Array<OneD, NekDouble> energy(nPts);
    GetInternalEnergy(physfield, energy);
 
    for (int 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<T>::value || tinysimd::is_vector_floating_point<T>::value >::type>

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

inline

Definition at line 146 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 460 of file VariableConverter.cpp.

{
    int nPts = pressure.size();
 
    for (int 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 257 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(max(elmtSensor, NekConstants::kNekSqrtTol));
 
        Vmath::Fill(nElmtPoints, elmtSensor, tmp = Sensor + physOffset, 1);
 
        // Compute reference value for sensor
        order = 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(), Vmath::Fill(), Nektar::NekConstants::kNekSqrtTol, m_Kappa, m_Skappa, tinysimd::sqrt(), and Vmath::Vsub().

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 398 of file VariableConverter.cpp.

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

References GetInternalEnergy(), and m_eos.

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 377 of file VariableConverter.cpp.

{
    int nPts = physfield[0].size();
 
    Array<OneD, NekDouble> energy(nPts);
    GetInternalEnergy(physfield, energy);
 
    for (int 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<T>::value || tinysimd::is_vector_floating_point<T>::value >::type>

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

inline

Definition at line 132 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 142 of file VariableConverter.cpp.

{
    const int nPts = physfield[0].size();
 
    for (int 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().

Member Data Documentation

m_eos

EquationOfStateSharedPtr Nektar::VariableConverter::m_eos

protected

Definition at line 175 of file VariableConverter.h.

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

m_gasConstant

NekDouble Nektar::VariableConverter::m_gasConstant

protected

Definition at line 179 of file VariableConverter.h.

Referenced by VariableConverter().

m_Kappa

NekDouble Nektar::VariableConverter::m_Kappa

protected

Definition at line 182 of file VariableConverter.h.

Referenced by GetSensor(), and VariableConverter().

m_mu

NekDouble Nektar::VariableConverter::m_mu

protected

Definition at line 180 of file VariableConverter.h.

Referenced by GetDynamicViscosity(), and VariableConverter().

m_oneOverT_star

NekDouble Nektar::VariableConverter::m_oneOverT_star

protected

Definition at line 183 of file VariableConverter.h.

Referenced by GetDynamicViscosity(), and VariableConverter().

m_pInf

NekDouble Nektar::VariableConverter::m_pInf

protected

Definition at line 177 of file VariableConverter.h.

Referenced by VariableConverter().

m_rhoInf

NekDouble Nektar::VariableConverter::m_rhoInf

protected

Definition at line 178 of file VariableConverter.h.

Referenced by VariableConverter().

m_session

LibUtilities::SessionReaderSharedPtr Nektar::VariableConverter::m_session

protected

Definition at line 174 of file VariableConverter.h.

Referenced by VariableConverter().

m_Skappa

NekDouble Nektar::VariableConverter::m_Skappa

protected

Definition at line 181 of file VariableConverter.h.

Referenced by GetSensor(), and VariableConverter().

m_spacedim

int Nektar::VariableConverter::m_spacedim

protected

Definition at line 176 of file VariableConverter.h.

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