Nektar::SolverUtils::Forcing Class Reference

Defines a forcing term to be explicitly applied. More...

#include <Forcing.h>

Inheritance diagram for Nektar::SolverUtils::Forcing:

Collaboration diagram for Nektar::SolverUtils::Forcing:

Public Member Functions
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...

Static Public Member Functions
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr >	Load (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)

Protected Member Functions
SOLVER_UTILS_EXPORT	Forcing (const LibUtilities::SessionReaderSharedPtr &)
	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
SOLVER_UTILS_EXPORT void	EvaluateFunction (Array< OneD, MultiRegions::ExpListSharedPtr > pFields, LibUtilities::SessionReaderSharedPtr pSession, std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, NekDouble pTime=NekDouble(0))
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)

Protected Attributes
LibUtilities::SessionReaderSharedPtr	m_session
	Session reader. More...
Array< OneD, Array< OneD, NekDouble > >	m_Forcing
	Evaluated forcing function. More...
int	m_NumVariable
	Number of variables. More...

Detailed Description

Defines a forcing term to be explicitly applied.

Definition at line 70 of file Forcing.h.

Constructor & Destructor Documentation

virtual SOLVER_UTILS_EXPORT Nektar::SolverUtils::Forcing::~Forcing ( )

inlinevirtual

Definition at line 73 of file Forcing.h.

{}

Nektar::SolverUtils::Forcing::Forcing ( const LibUtilities::SessionReaderSharedPtr &  pSession )

protected

Constructor.

Definition at line 51 of file Forcing.cpp.

                : m_session(pSession)
        {

        }

Member Function Documentation

void Nektar::SolverUtils::Forcing::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.

Parameters

fields	Expansion lists corresponding to input arrays
inarray	u^n from previous timestep
outarray	output array to append forcing to

Definition at line 71 of file Forcing.cpp.

References v_Apply().

        {
            v_Apply(fields, inarray, outarray, time);
        }

void Nektar::SolverUtils::Forcing::EvaluateFunction ( Array< OneD, MultiRegions::ExpListSharedPtr >  pFields, LibUtilities::SessionReaderSharedPtr  pSession, std::string  pFieldName, Array< OneD, NekDouble > &  pArray, const std::string &  pFunctionName, NekDouble  pTime = NekDouble(0)  )

protected

Definition at line 149 of file Forcing.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, m_session, and Vmath::Zero().

Referenced by Nektar::ForcingMovingBody::v_Apply(), Nektar::SolverUtils::ForcingBody::v_InitObject(), and Nektar::SolverUtils::ForcingAbsorption::v_InitObject().

        {
            ASSERTL0(pSession->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");

            unsigned int nq = pFields[0]->GetNpoints();
            if (pArray.num_elements() != nq)
            {
                pArray = Array<OneD, NekDouble> (nq);
            }

            LibUtilities::FunctionType vType;
            vType = pSession->GetFunctionType(pFunctionName, pFieldName);
            if (vType == LibUtilities::eFunctionTypeExpression)
            {
                Array<OneD, NekDouble> x0(nq);
                Array<OneD, NekDouble> x1(nq);
                Array<OneD, NekDouble> x2(nq);
                
                pFields[0]->GetCoords(x0, x1, x2);
                LibUtilities::EquationSharedPtr ffunc =
                    pSession->GetFunction(pFunctionName, pFieldName);
                
                ffunc->Evaluate(x0, x1, x2, pTime, pArray);
            }
            else if (vType == LibUtilities::eFunctionTypeFile)
            {
                std::string filename = pSession->GetFunctionFilename(
                                                    pFunctionName,
                                                    pFieldName);

                std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
                std::vector<std::vector<NekDouble> > FieldData;
                Array<OneD, NekDouble> vCoeffs(pFields[0]->GetNcoeffs());
                Vmath::Zero(vCoeffs.num_elements(), vCoeffs, 1);

                LibUtilities::FieldIOSharedPtr fld =
                    MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(m_session->GetComm());
                fld->Import(filename, FieldDef, FieldData);

                int idx = -1;
                for (int i = 0; i < FieldDef.size(); ++i)
                {
                    for (int j = 0; j < FieldDef[i]->m_fields.size(); ++j)
                    {
                        if (FieldDef[i]->m_fields[j] == pFieldName)
                        {
                            idx = j;
                        }
                    }

                    if (idx >= 0)
                    {
                        pFields[0]->ExtractDataToCoeffs(
                                                    FieldDef[i],
                                                    FieldData[i],
                                                    FieldDef[i]->m_fields[idx],
                                                    vCoeffs);
                    }
                    else
                    {
                        cout << "Field " + pFieldName + " not found." << endl;
                    }
                }
                pFields[0]->BwdTrans_IterPerExp(vCoeffs, pArray);
            }
        }

void Nektar::SolverUtils::Forcing::EvaluateTimeFunction ( LibUtilities::SessionReaderSharedPtr  pSession, std::string  pFieldName, Array< OneD, NekDouble > &  pArray, const std::string &  pFunctionName, NekDouble  pTime = NekDouble(0)  )

protected

Definition at line 119 of file Forcing.cpp.

References ASSERTL0.

Referenced by Nektar::SolverUtils::ForcingBody::v_Apply(), and Nektar::SolverUtils::ForcingAbsorption::v_Apply().

        {
            ASSERTL0(pSession->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");
            
            LibUtilities::EquationSharedPtr ffunc =
                pSession->GetFunction(pFunctionName, pFieldName);
            
            EvaluateTimeFunction(pTime,ffunc,pArray);
        }

void Nektar::SolverUtils::Forcing::EvaluateTimeFunction ( const NekDouble  pTime, const LibUtilities::EquationSharedPtr &  pEqn, Array< OneD, NekDouble > &  pArray  )

protected

Definition at line 136 of file Forcing.cpp.

        {
            // dummy array of zero pts.
            Array<OneD, NekDouble> x0(pArray.num_elements(),0.0);

            pEqn->Evaluate(x0, x0, x0, pTime, pArray);
        }

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

Initialise the forcing object.

Definition at line 57 of file Forcing.cpp.

References v_InitObject().

        {
            v_InitObject(pFields, pNumForcingFields, pForce);
        }

vector< ForcingSharedPtr > Nektar::SolverUtils::Forcing::Load ( const LibUtilities::SessionReaderSharedPtr &  pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields, const unsigned int &  pNumForcingFields = 0  )

static

Definition at line 84 of file Forcing.cpp.

References Nektar::SolverUtils::GetForcingFactory().

Referenced by Nektar::IncNavierStokes::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), and Nektar::CompressibleFlowSystem::v_InitObject().

        {
            vector<ForcingSharedPtr> vForceList;

            if (!pSession->DefinesElement("Nektar/Forcing"))
            {
                return vForceList;
            }

            TiXmlElement* vForcing = pSession->GetElement("Nektar/Forcing");
            if (vForcing)
            {
                unsigned int vNumForcingFields = pNumForcingFields;
                if (!pNumForcingFields)
                {
                    vNumForcingFields = pFields.num_elements();
                }

                TiXmlElement* vForce = vForcing->FirstChildElement("FORCE");
                while (vForce)
                {
                    string vType = vForce->Attribute("TYPE");

                    vForceList.push_back(GetForcingFactory().CreateInstance(
                                            vType, pSession, pFields,
                                            vNumForcingFields, vForce));
                    vForce = vForce->NextSiblingElement("FORCE");
                }
            }
            return vForceList;
        }

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

protectedpure virtual

Implemented in Nektar::SolverUtils::ForcingProgrammatic, Nektar::SolverUtils::ForcingAbsorption, Nektar::ForcingMovingBody, Nektar::SolverUtils::ForcingBody, Nektar::SolverUtils::ForcingNoise, and Nektar::ForcingStabilityCoupledLNS.

Referenced by Apply().

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

protectedpure virtual

Implemented in Nektar::SolverUtils::ForcingProgrammatic, Nektar::SolverUtils::ForcingAbsorption, Nektar::ForcingMovingBody, Nektar::SolverUtils::ForcingBody, Nektar::SolverUtils::ForcingNoise, and Nektar::ForcingStabilityCoupledLNS.

Referenced by InitObject().

Member Data Documentation

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::Forcing::m_Forcing

protected

Evaluated forcing function.

Definition at line 97 of file Forcing.h.

Referenced by Nektar::SolverUtils::ForcingProgrammatic::UpdateForces(), Nektar::SolverUtils::ForcingNoise::v_Apply(), Nektar::SolverUtils::ForcingBody::v_Apply(), Nektar::SolverUtils::ForcingAbsorption::v_Apply(), Nektar::SolverUtils::ForcingProgrammatic::v_Apply(), Nektar::SolverUtils::ForcingNoise::v_InitObject(), Nektar::SolverUtils::ForcingBody::v_InitObject(), Nektar::SolverUtils::ForcingAbsorption::v_InitObject(), and Nektar::SolverUtils::ForcingProgrammatic::v_InitObject().

int Nektar::SolverUtils::Forcing::m_NumVariable

protected

Number of variables.

Definition at line 99 of file Forcing.h.

Referenced by Nektar::SolverUtils::ForcingNoise::v_Apply(), Nektar::SolverUtils::ForcingBody::v_Apply(), Nektar::SolverUtils::ForcingAbsorption::v_Apply(), Nektar::SolverUtils::ForcingProgrammatic::v_Apply(), Nektar::SolverUtils::ForcingNoise::v_InitObject(), Nektar::SolverUtils::ForcingBody::v_InitObject(), Nektar::SolverUtils::ForcingAbsorption::v_InitObject(), and Nektar::SolverUtils::ForcingProgrammatic::v_InitObject().

LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::Forcing::m_session

protected

Session reader.

Definition at line 95 of file Forcing.h.

Referenced by Nektar::ForcingMovingBody::CheckIsFromFile(), EvaluateFunction(), Nektar::ForcingMovingBody::EvaluateStructDynModel(), Nektar::ForcingMovingBody::InitialiseCableModel(), Nektar::ForcingMovingBody::Newmark_betaSolver(), Nektar::ForcingMovingBody::SetDynEqCoeffMatrix(), Nektar::ForcingMovingBody::v_Apply(), Nektar::SolverUtils::ForcingAbsorption::v_Apply(), Nektar::SolverUtils::ForcingBody::v_InitObject(), Nektar::ForcingMovingBody::v_InitObject(), and Nektar::SolverUtils::ForcingAbsorption::v_InitObject().