Nektar::ForcingQuasi1D Class Reference

#include <ForcingQuasi1D.h>

Inheritance diagram for Nektar::ForcingQuasi1D:

Static Public Member Functions
static SolverUtils::ForcingSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< SolverUtils::EquationSystem > &pEquation, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)
	Creates an instance of this class. More...
Static Public Member Functions inherited from Nektar::SolverUtils::Forcing
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr >	Load (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)

Static Public Attributes
static std::string	className
	Name of the class. More...

Protected Member Functions
void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce) override
void	v_Apply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time) override
Protected Member Functions inherited from Nektar::SolverUtils::Forcing
SOLVER_UTILS_EXPORT	Forcing (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)
	Constructor. More...
virtual SOLVER_UTILS_EXPORT void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)=0
virtual SOLVER_UTILS_EXPORT void	v_Apply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)=0
virtual SOLVER_UTILS_EXPORT void	v_PreApply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
virtual SOLVER_UTILS_EXPORT void	v_ApplyCoeff (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr	GetFunction (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const LibUtilities::SessionReaderSharedPtr &pSession, std::string pName, bool pCache=false)
	Get a SessionFunction by name. More...
SOLVER_UTILS_EXPORT void	EvaluateTimeFunction (LibUtilities::SessionReaderSharedPtr pSession, std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, NekDouble pTime=NekDouble(0))
SOLVER_UTILS_EXPORT void	EvaluateTimeFunction (const NekDouble pTime, const LibUtilities::EquationSharedPtr &pEqn, Array< OneD, NekDouble > &pArray)

Private Member Functions
	ForcingQuasi1D (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< SolverUtils::EquationSystem > &pEquation)

Private Attributes
Array< OneD, NekDouble >	m_geomFactor
VariableConverterSharedPtr	m_varConv

Friends
class	MemoryManager< ForcingQuasi1D >

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::Forcing
virtual SOLVER_UTILS_EXPORT	~Forcing ()
SOLVER_UTILS_EXPORT void	InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)
	Initialise the forcing object. More...
SOLVER_UTILS_EXPORT void	Apply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
	Apply the forcing. More...
SOLVER_UTILS_EXPORT void	PreApply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
	Change the advection velocity before applying the forcing. For example, subtracting the frame velocity from the advection velocity in the MovingRefercenceFrame. More...
SOLVER_UTILS_EXPORT void	ApplyCoeff (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time)
	Apply the forcing. More...
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > &	GetForces ()
SOLVER_UTILS_EXPORT Array< OneD, Array< OneD, NekDouble > > &	UpdateForces ()
Protected Attributes inherited from Nektar::SolverUtils::Forcing
LibUtilities::SessionReaderSharedPtr	m_session
	Session reader. More...
const std::weak_ptr< EquationSystem >	m_equ
	Weak pointer to equation system using this forcing. More...
Array< OneD, Array< OneD, NekDouble > >	m_Forcing
	Evaluated forcing function. More...
int	m_NumVariable
	Number of variables. More...
std::map< std::string, SolverUtils::SessionFunctionSharedPtr >	m_sessionFunctions
	Map of known SessionFunctions. More...

Detailed Description

Definition at line 44 of file ForcingQuasi1D.h.

Constructor & Destructor Documentation

ForcingQuasi1D()

Nektar::ForcingQuasi1D::ForcingQuasi1D ( const LibUtilities::SessionReaderSharedPtr &  pSession, const std::weak_ptr< SolverUtils::EquationSystem > &  pEquation  )

private

Definition at line 45 of file ForcingQuasi1D.cpp.

    : Forcing(pSession, pEquation)
{
}

Member Function Documentation

create()

static SolverUtils::ForcingSharedPtr Nektar::ForcingQuasi1D::create ( const LibUtilities::SessionReaderSharedPtr &  pSession, const std::weak_ptr< SolverUtils::EquationSystem > &  pEquation, const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields, const unsigned int &  pNumForcingFields, const TiXmlElement *  pForce  )

inlinestatic

Creates an instance of this class.

Definition at line 50 of file ForcingQuasi1D.h.

    {
        SolverUtils::ForcingSharedPtr p =
            MemoryManager<ForcingQuasi1D>::AllocateSharedPtr(pSession,
                                                             pEquation);
        p->InitObject(pFields, pNumForcingFields, pForce);
        return p;
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SolverUtils::ForcingSharedPtr, and CellMLToNektar.cellml_metadata::p.

v_Apply()

void Nektar::ForcingQuasi1D::v_Apply ( const Array< OneD, MultiRegions::ExpListSharedPtr > &  fields, const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray, const NekDouble &  time  )

overrideprotectedvirtual

Implements Nektar::SolverUtils::Forcing.

Definition at line 120 of file ForcingQuasi1D.cpp.

{
    int nPoints = pFields[0]->GetTotPoints();
 
    // Get (E+p)
    Array<OneD, NekDouble> tmp(nPoints, 0.0);
    m_varConv->GetPressure(inarray, tmp);
    Vmath::Vadd(nPoints, tmp, 1, inarray[2], 1, tmp, 1);
 
    // F-rho = -Ax/A *rhou
    Vmath::Vmul(nPoints, m_geomFactor, 1, inarray[1], 1, m_Forcing[0], 1);
 
    // F-rhou = -Ax/A *rhou*u
    Vmath::Vmul(nPoints, m_geomFactor, 1, inarray[1], 1, m_Forcing[1], 1);
    Vmath::Vmul(nPoints, m_Forcing[1], 1, inarray[1], 1, m_Forcing[1], 1);
    Vmath::Vdiv(nPoints, m_Forcing[1], 1, inarray[0], 1, m_Forcing[1], 1);
 
    // F-E = -Ax/A *(E+p)*u
    Vmath::Vmul(nPoints, m_geomFactor, 1, inarray[1], 1, m_Forcing[2], 1);
    Vmath::Vmul(nPoints, m_Forcing[2], 1, tmp, 1, m_Forcing[2], 1);
    Vmath::Vdiv(nPoints, m_Forcing[2], 1, inarray[0], 1, m_Forcing[2], 1);
 
    // Apply forcing
    for (int i = 0; i < m_NumVariable; i++)
    {
        Vmath::Vadd(nPoints, outarray[i], 1, m_Forcing[i], 1, outarray[i], 1);
    }
}

References Nektar::SolverUtils::Forcing::m_Forcing, m_geomFactor, Nektar::SolverUtils::Forcing::m_NumVariable, m_varConv, Vmath::Vadd(), Vmath::Vdiv(), and Vmath::Vmul().

v_InitObject()

void Nektar::ForcingQuasi1D::v_InitObject ( const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields, const unsigned int &  pNumForcingFields, const TiXmlElement *  pForce  )

overrideprotectedvirtual

Implements Nektar::SolverUtils::Forcing.

Definition at line 52 of file ForcingQuasi1D.cpp.

{
    m_NumVariable = pNumForcingFields;
    m_varConv =
        MemoryManager<VariableConverter>::AllocateSharedPtr(m_session, 1);
 
    ASSERTL0(pFields[0]->GetGraph()->GetSpaceDimension() == 1,
             "ForcingQuasi1D requires a 1D problem.");
 
    const TiXmlElement *funcNameElmt = pForce->FirstChildElement("AREAFCN");
    if (!funcNameElmt)
    {
        ASSERTL0(funcNameElmt,
                 "Requires AREAFCN tag "
                 "specifying function name which prescribes nozzle area.");
    }
 
    string funcName = funcNameElmt->GetText();
    ASSERTL0(m_session->DefinesFunction(funcName),
             "Function '" + funcName + "' not defined.");
 
    // Evaluate geometrical term -Ax/A for forcing
    m_geomFactor = Array<OneD, NekDouble>(pFields[0]->GetTotPoints(), 0.0);
    Array<OneD, NekDouble> tmp(pFields[0]->GetTotPoints(), 0.0);
 
    std::string sFieldStr = m_session->GetVariable(0);
    ASSERTL0(m_session->DefinesFunction(funcName, sFieldStr),
             "Variable '" + sFieldStr + "' not defined.");
    GetFunction(pFields, m_session, funcName, true)
        ->Evaluate(sFieldStr, m_geomFactor, 0.0);
 
    // Check if DADXFCN is defined
    const TiXmlElement *dAFuncNameElmt = pForce->FirstChildElement("DADXFCN");
    if (dAFuncNameElmt)
    {
        funcName = dAFuncNameElmt->GetText();
        ASSERTL0(m_session->DefinesFunction(funcName),
                 "Function '" + funcName + "' not defined.");
        ASSERTL0(m_session->DefinesFunction(funcName, sFieldStr),
                 "Variable '" + sFieldStr + "' not defined.");
        GetFunction(pFields, m_session, funcName, true)
            ->Evaluate(sFieldStr, tmp, 0.0);
    }
    else
    {
        // Numerically evaluate dA/dX
        pFields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], m_geomFactor,
                              tmp);
    }
 
    Vmath::Vdiv(pFields[0]->GetTotPoints(), tmp, 1, m_geomFactor, 1,
                m_geomFactor, 1);
    Vmath::Neg(pFields[0]->GetTotPoints(), m_geomFactor, 1);
 
    // Project m_geomFactor to solution space
    Array<OneD, NekDouble> tmpCoeff(pFields[0]->GetNcoeffs(), 0.0);
    pFields[0]->FwdTransLocalElmt(m_geomFactor, tmpCoeff);
    pFields[0]->BwdTrans(tmpCoeff, m_geomFactor);
 
    m_Forcing = Array<OneD, Array<OneD, NekDouble>>(m_NumVariable);
    for (int i = 0; i < m_NumVariable; ++i)
    {
        m_Forcing[i] = Array<OneD, NekDouble>(pFields[0]->GetTotPoints(), 0.0);
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::MultiRegions::DirCartesianMap, Nektar::SolverUtils::Forcing::GetFunction(), Nektar::SolverUtils::Forcing::m_Forcing, m_geomFactor, Nektar::SolverUtils::Forcing::m_NumVariable, Nektar::SolverUtils::Forcing::m_session, m_varConv, Vmath::Neg(), and Vmath::Vdiv().

Friends And Related Function Documentation

MemoryManager< ForcingQuasi1D >

friend class MemoryManager< ForcingQuasi1D >

friend

Definition at line 1 of file ForcingQuasi1D.h.

Member Data Documentation

className

std::string Nektar::ForcingQuasi1D::className

static

Initial value:

=
    SolverUtils::GetForcingFactory().RegisterCreatorFunction(
        "Quasi1D", ForcingQuasi1D::create, "Quasi-1D nozzle Forcing")

Name of the class.

Definition at line 64 of file ForcingQuasi1D.h.

m_geomFactor

Array<OneD, NekDouble> Nektar::ForcingQuasi1D::m_geomFactor

private

Definition at line 81 of file ForcingQuasi1D.h.

Referenced by v_Apply(), and v_InitObject().

m_varConv

VariableConverterSharedPtr Nektar::ForcingQuasi1D::m_varConv

private

Definition at line 82 of file ForcingQuasi1D.h.

Referenced by v_Apply(), and v_InitObject().