#include <ForcingBody.h>

Inheritance diagram for Nektar::SolverUtils::ForcingBody:

Static Public Member Functions
static SOLVER_UTILS_EXPORT ForcingSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< 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	classNameBody
	Name of the class. More...

static std::string	classNameField

Protected Member Functions
virtual SOLVER_UTILS_EXPORT void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce) override

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) override

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) 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_PreApply (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
	ForcingBody (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)

virtual	~ForcingBody (void)

void	Update (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const Array< OneD, Array< OneD, NekDouble >> &inarray, const NekDouble &time)

Private Attributes
std::string	m_funcName

bool	m_hasTimeFcnScaling

LibUtilities::EquationSharedPtr	m_timeFcnEqn

bool	m_homogeneous

bool	m_hasEvars

std::map< int, std::vector< int > >	m_eqnEvars

Friends
class	MemoryManager< ForcingBody >

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 50 of file ForcingBody.h.

Constructor & Destructor Documentation

◆ ForcingBody()

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

private

Definition at line 53 of file ForcingBody.cpp.

     : Forcing(pSession, pEquation), m_hasTimeFcnScaling(false)
 {
 }

◆ ~ForcingBody()

virtual Nektar::SolverUtils::ForcingBody::~ForcingBody ( void )

inlineprivatevirtual

Definition at line 101 of file ForcingBody.h.

101 {};

Member Function Documentation

◆ create()

static SOLVER_UTILS_EXPORT ForcingSharedPtr Nektar::SolverUtils::ForcingBody::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< 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 56 of file ForcingBody.h.

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

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

◆ Update()

void Nektar::SolverUtils::ForcingBody::Update	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		const NekDouble &	time
	)

private

Definition at line 167 of file ForcingBody.cpp.

 {
     std::vector<Array<OneD, const NekDouble>> fielddata;
     int nq = pFields[0]->GetNpoints();
     if (m_hasEvars)
     {
         Array<OneD, NekDouble> xc(nq), yc(nq), zc(nq), t(nq, time);
         pFields[0]->GetCoords(xc, yc, zc);
         fielddata.push_back(xc);
         fielddata.push_back(yc);
         fielddata.push_back(zc);
         fielddata.push_back(t);
     }
  
     for (const auto &it : m_eqnEvars)
     {
         int i = it.first;
         if (it.second.size() > 0)
         {
             // Coupled forcing, reset fielddata for each equation
             fielddata.resize(4);
             for (int j : it.second)
             {
                 if (m_homogeneous && pFields[i]->GetWaveSpace())
                 {
                     Array<OneD, NekDouble> tmp(nq);
                     pFields[i]->HomogeneousBwdTrans(nq, inarray[j], tmp);
                     fielddata.push_back(tmp);
                 }
                 else
                 {
                     fielddata.push_back(inarray[j]);
                 }
             }
             m_session->GetFunction(m_funcName, m_session->GetVariable(i))
                 ->Evaluate(fielddata, m_Forcing[i]);
         }
         else
         {
             GetFunction(pFields, m_session, m_funcName, true)
                 ->Evaluate(m_session->GetVariable(i), m_Forcing[i], time);
         }
  
         // If homogeneous expansion is used, transform the forcing term to
         // be in the Fourier space
         if (m_homogeneous)
         {
             pFields[i]->HomogeneousFwdTrans(pFields[i]->GetTotPoints(),
                                             m_Forcing[i], m_Forcing[i]);
         }
     }
 }

References Nektar::SolverUtils::Forcing::GetFunction(), m_eqnEvars, Nektar::SolverUtils::Forcing::m_Forcing, m_funcName, m_hasEvars, m_homogeneous, and Nektar::SolverUtils::Forcing::m_session.

Referenced by v_Apply(), v_ApplyCoeff(), and v_InitObject().

◆ v_Apply()

void Nektar::SolverUtils::ForcingBody::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 222 of file ForcingBody.cpp.

 {
     if (m_hasTimeFcnScaling)
     {
         Array<OneD, NekDouble> TimeFcn(1);
         EvaluateTimeFunction(time, m_timeFcnEqn, TimeFcn);
  
         for (const auto &it : m_eqnEvars)
         {
             int i = it.first;
             Vmath::Svtvp(outarray[i].size(), TimeFcn[0], m_Forcing[i], 1,
                          outarray[i], 1, outarray[i], 1);
         }
     }
     else
     {
         Update(fields, inarray, time);
  
         for (const auto &it : m_eqnEvars)
         {
             int i = it.first;
             Vmath::Vadd(outarray[i].size(), outarray[i], 1, m_Forcing[i], 1,
                         outarray[i], 1);
         }
     }
 }

References Nektar::SolverUtils::Forcing::EvaluateTimeFunction(), m_eqnEvars, Nektar::SolverUtils::Forcing::m_Forcing, m_hasTimeFcnScaling, m_timeFcnEqn, Vmath::Svtvp(), Update(), and Vmath::Vadd().

◆ v_ApplyCoeff()

void Nektar::SolverUtils::ForcingBody::v_ApplyCoeff	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const NekDouble &	time
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::Forcing.

Definition at line 252 of file ForcingBody.cpp.

 {
     int ncoeff = outarray[m_NumVariable - 1].size();
     Array<OneD, NekDouble> tmp(ncoeff, 0.0);
  
     if (m_hasTimeFcnScaling)
     {
         Array<OneD, NekDouble> TimeFcn(1);
         EvaluateTimeFunction(time, m_timeFcnEqn, TimeFcn);
  
         for (const auto &it : m_eqnEvars)
         {
             int i = it.first;
             fields[i]->FwdTrans(m_Forcing[i], tmp);
             Vmath::Svtvp(ncoeff, TimeFcn[0], tmp, 1, outarray[i], 1,
                          outarray[i], 1);
         }
     }
     else
     {
         Update(fields, inarray, time);
  
         for (const auto &it : m_eqnEvars)
         {
             int i = it.first;
             fields[i]->FwdTrans(m_Forcing[i], tmp);
             Vmath::Vadd(ncoeff, outarray[i], 1, tmp, 1, outarray[i], 1);
         }
     }
 }

References Nektar::SolverUtils::Forcing::EvaluateTimeFunction(), m_eqnEvars, Nektar::SolverUtils::Forcing::m_Forcing, m_hasTimeFcnScaling, Nektar::SolverUtils::Forcing::m_NumVariable, m_timeFcnEqn, Vmath::Svtvp(), Update(), and Vmath::Vadd().

◆ v_InitObject()

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

overrideprotectedvirtual

Implements Nektar::SolverUtils::Forcing.

Definition at line 59 of file ForcingBody.cpp.

 {
     m_NumVariable = pNumForcingFields;
  
     const TiXmlElement *funcNameElmt = pForce->FirstChildElement("BODYFORCE");
     if (!funcNameElmt)
     {
         funcNameElmt = pForce->FirstChildElement("FIELDFORCE");
  
         ASSERTL0(funcNameElmt,
                  "Requires BODYFORCE or FIELDFORCE tag "
                  "specifying function name which prescribes body force.");
     }
  
     m_funcName = funcNameElmt->GetText();
     ASSERTL0(m_session->DefinesFunction(m_funcName),
              "Function '" + m_funcName + "' not defined.");
  
     m_homogeneous = pFields[0]->GetExpType() == MultiRegions::e3DH1D ||
                     pFields[0]->GetExpType() == MultiRegions::e3DH2D;
  
     // Time function is optional
     funcNameElmt = pForce->FirstChildElement("BODYFORCETIMEFCN");
     if (!funcNameElmt)
     {
         funcNameElmt = pForce->FirstChildElement("FIELDFORCETIMEFCN");
     }
  
     // Load time function if specified
     if (funcNameElmt)
     {
         std::string funcNameTime = funcNameElmt->GetText();
  
         ASSERTL0(!funcNameTime.empty(),
                  "Expression must be given in BODYFORCETIMEFCN or "
                  "FIELDFORCETIMEFCN.");
  
         m_session->SubstituteExpressions(funcNameTime);
         m_timeFcnEqn = MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
             m_session->GetInterpreter(), funcNameTime);
  
         m_hasTimeFcnScaling = true;
     }
  
     Array<OneD, Array<OneD, NekDouble>> tmp(m_NumVariable);
     for (int i = 0; i < m_NumVariable; ++i)
     {
         tmp[i] = pFields[i]->GetPhys();
     }
  
     std::map<std::string, int> varIndex;
     for (int i = 0; i < m_NumVariable; ++i)
     {
         varIndex[m_session->GetVariable(i)] = i;
         if (m_session->DefinesFunction(m_funcName, m_session->GetVariable(i)))
         {
             m_eqnEvars[i] = vector<int>();
         }
     }
     m_hasEvars = false;
     for (auto &it : m_eqnEvars)
     {
         string varStr = m_session->GetVariable(it.first);
         if (LibUtilities::eFunctionTypeExpression ==
             m_session->GetFunctionType(m_funcName, varStr))
         {
             LibUtilities::EquationSharedPtr eqn =
                 m_session->GetFunction(m_funcName, varStr);
             string vlist = eqn->GetVlist();
             if (!boost::iequals(vlist, "x y z t"))
             {
                 // Coupled forcing
                 m_hasEvars = true;
                 std::vector<std::string> vars;
                 boost::split(vars, vlist, boost::is_any_of(", "));
                 for (size_t j = 4; j < vars.size(); ++j)
                 {
                     if (vars[j].size() != 0 &&
                         varIndex.find(vars[j]) == varIndex.end())
                     {
                         NEKERROR(ErrorUtil::efatal,
                                  "Variable '" + vars[j] +
                                      "' cannot be used as equation variable in "
                                      "the body force '" +
                                      m_funcName + "'.");
                     }
                     if (vars[j].size() &&
                         varIndex.find(vars[j]) != varIndex.end())
                     {
                         it.second.push_back(varIndex[vars[j]]);
                     }
                 }
             }
         }
     }
  
     m_Forcing = Array<OneD, Array<OneD, NekDouble>>(m_NumVariable);
     for (const auto &it : m_eqnEvars)
     {
         m_Forcing[it.first] =
             Array<OneD, NekDouble>(pFields[0]->GetTotPoints(), 0.0);
     }
  
     Update(pFields, tmp, 0.0);
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eFunctionTypeExpression, m_eqnEvars, Nektar::SolverUtils::Forcing::m_Forcing, m_funcName, m_hasEvars, m_hasTimeFcnScaling, m_homogeneous, Nektar::SolverUtils::Forcing::m_NumVariable, Nektar::SolverUtils::Forcing::m_session, m_timeFcnEqn, NEKERROR, and Update().

Friends And Related Function Documentation

◆ MemoryManager< ForcingBody >

friend class MemoryManager< ForcingBody >

friend

Definition at line 1 of file ForcingBody.h.

Member Data Documentation

◆ classNameBody

std::string Nektar::SolverUtils::ForcingBody::classNameBody

static

Initial value:

=
    GetForcingFactory().RegisterCreatorFunction("Body", ForcingBody::create,
                                                "Body Forcing")

Name of the class.

Definition at line 69 of file ForcingBody.h.

◆ classNameField

std::string Nektar::SolverUtils::ForcingBody::classNameField

static

Initial value:

=
    GetForcingFactory().RegisterCreatorFunction("Field", ForcingBody::create,
                                                "Field Forcing")

Definition at line 70 of file ForcingBody.h.

◆ m_eqnEvars

std::map<int, std::vector<int> > Nektar::SolverUtils::ForcingBody::m_eqnEvars

private

Definition at line 96 of file ForcingBody.h.

Referenced by Update(), v_Apply(), v_ApplyCoeff(), and v_InitObject().

◆ m_funcName

std::string Nektar::SolverUtils::ForcingBody::m_funcName

private

Definition at line 91 of file ForcingBody.h.

Referenced by Update(), and v_InitObject().

◆ m_hasEvars

bool Nektar::SolverUtils::ForcingBody::m_hasEvars

private

Definition at line 95 of file ForcingBody.h.

Referenced by Update(), and v_InitObject().

◆ m_hasTimeFcnScaling

bool Nektar::SolverUtils::ForcingBody::m_hasTimeFcnScaling

private

Definition at line 92 of file ForcingBody.h.

Referenced by v_Apply(), v_ApplyCoeff(), and v_InitObject().

◆ m_homogeneous

bool Nektar::SolverUtils::ForcingBody::m_homogeneous

private

Definition at line 94 of file ForcingBody.h.

Referenced by Update(), and v_InitObject().

◆ m_timeFcnEqn

LibUtilities::EquationSharedPtr Nektar::SolverUtils::ForcingBody::m_timeFcnEqn

private

Definition at line 93 of file ForcingBody.h.

Referenced by v_Apply(), v_ApplyCoeff(), and v_InitObject().

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ForcingBody()

◆ ~ForcingBody()

Member Function Documentation

◆ create()

◆ Update()

◆ v_Apply()

◆ v_ApplyCoeff()

◆ v_InitObject()

Friends And Related Function Documentation

◆ MemoryManager< ForcingBody >

Member Data Documentation

◆ classNameBody

◆ classNameField

◆ m_eqnEvars

◆ m_funcName

◆ m_hasEvars

◆ m_hasTimeFcnScaling

◆ m_homogeneous

◆ m_timeFcnEqn