#include <ForcingAbsorption.h>

Inheritance diagram for Nektar::SolverUtils::ForcingAbsorption:

Collaboration diagram for Nektar::SolverUtils::ForcingAbsorption:

Static Public Member Functions
static SOLVER_UTILS_EXPORT ForcingSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, 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 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
virtual SOLVER_UTILS_EXPORT void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce)

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)

Protected Member Functions inherited from Nektar::SolverUtils::Forcing
SOLVER_UTILS_EXPORT	Forcing (const LibUtilities::SessionReaderSharedPtr &)
	Constructor. More...

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
bool	m_hasRefFlow

bool	m_hasRefFlowTime

Array< OneD, Array< OneD, NekDouble > >	m_Absorption

Array< OneD, Array< OneD, NekDouble > >	m_Refflow

std::string	m_funcNameTime

Protected Attributes inherited from Nektar::SolverUtils::Forcing
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...

Private Member Functions
	ForcingAbsorption (const LibUtilities::SessionReaderSharedPtr &pSession)

virtual	~ForcingAbsorption (void)

Friends
class	MemoryManager< ForcingAbsorption >

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...

Detailed Description

Definition at line 51 of file ForcingAbsorption.h.

Constructor & Destructor Documentation

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

private

Definition at line 50 of file ForcingAbsorption.cpp.

             : Forcing(pSession),
               m_hasRefFlow(false),  
               m_hasRefFlowTime(false)
     {
     }

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

inlineprivatevirtual

Definition at line 92 of file ForcingAbsorption.h.

92 {};

Member Function Documentation

static SOLVER_UTILS_EXPORT ForcingSharedPtr Nektar::SolverUtils::ForcingAbsorption::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const unsigned int &	pNumForcingFields,
		const TiXmlElement *	pForce
	)

inlinestatic

Creates an instance of this class.

Definition at line 57 of file ForcingAbsorption.h.

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

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

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

protectedvirtual

Implements Nektar::SolverUtils::Forcing.

Definition at line 117 of file ForcingAbsorption.cpp.

References Nektar::SolverUtils::Forcing::EvaluateTimeFunction(), m_Absorption, Nektar::SolverUtils::Forcing::m_Forcing, m_funcNameTime, m_hasRefFlow, m_hasRefFlowTime, Nektar::SolverUtils::Forcing::m_NumVariable, m_Refflow, Nektar::SolverUtils::Forcing::m_session, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vsub().

     {
         int nq = m_Forcing[0].num_elements();
        
         std::string s_FieldStr;
         Array<OneD, NekDouble> TimeScale(1);
         Array<OneD, Array<OneD, NekDouble> > RefflowScaled(m_NumVariable);
 
         if (m_hasRefFlow)
         {
             for (int i = 0; i < m_NumVariable; i++)
             {
                 RefflowScaled[i] = Array<OneD, NekDouble> (nq);
                 if (m_hasRefFlowTime)
                 {
                     s_FieldStr = m_session->GetVariable(i);
                     EvaluateTimeFunction(m_session, s_FieldStr, TimeScale, m_funcNameTime, time);
                     Vmath::Smul(nq, TimeScale[0], m_Refflow[i],1,RefflowScaled[i],1);
                 }
                 else
                 {
                     Vmath::Vcopy(nq, m_Refflow[i],1, RefflowScaled[i],1);
                 }
                 
 
                 Vmath::Vsub(nq, inarray[i], 1,
                             RefflowScaled[i], 1, m_Forcing[i], 1);
                 Vmath::Vmul(nq, m_Absorption[i], 1,
                             m_Forcing[i], 1, m_Forcing[i], 1);
                 Vmath::Vadd(nq, m_Forcing[i], 1,
                             outarray[i], 1, outarray[i], 1);
             }
         }
         else
         {
             for (int i = 0; i < m_NumVariable; i++)
             {
                 Vmath::Vmul(nq, m_Absorption[i], 1,
                             inarray[i], 1, m_Forcing[i], 1);
                 Vmath::Vadd(nq, m_Forcing[i], 1,
                             outarray[i], 1, outarray[i], 1);
             }
         }
     }

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

protectedvirtual

Implements Nektar::SolverUtils::Forcing.

Definition at line 57 of file ForcingAbsorption.cpp.

References ASSERTL0, Nektar::SolverUtils::Forcing::EvaluateFunction(), m_Absorption, Nektar::SolverUtils::Forcing::m_Forcing, m_funcNameTime, m_hasRefFlow, m_hasRefFlowTime, Nektar::SolverUtils::Forcing::m_NumVariable, m_Refflow, Nektar::SolverUtils::Forcing::m_session, and npts.

     {
         m_NumVariable = pNumForcingFields;
         int npts       = pFields[0]->GetTotPoints();
 
         const TiXmlElement* funcNameElmt;
         funcNameElmt = pForce->FirstChildElement("COEFF");
         ASSERTL0(funcNameElmt, "Requires COEFF tag, specifying function "
                                "name which prescribes absorption layer coefficient.");
 
         string funcName = funcNameElmt->GetText();
         ASSERTL0(m_session->DefinesFunction(funcName),
                  "Function '" + funcName + "' not defined.");
 
         std::string s_FieldStr;
         m_Absorption  = Array<OneD, Array<OneD, NekDouble> > (m_NumVariable);
         m_Forcing = Array<OneD, Array<OneD, NekDouble> > (m_NumVariable);
         for (int i = 0; i < m_NumVariable; ++i)
         {
             s_FieldStr = m_session->GetVariable(i);
             ASSERTL0(m_session->DefinesFunction(funcName, s_FieldStr),
                      "Variable '" + s_FieldStr + "' not defined.");
             m_Absorption[i]  = Array<OneD, NekDouble> (npts, 0.0);
             m_Forcing[i] = Array<OneD, NekDouble> (npts, 0.0);
             EvaluateFunction(pFields, m_session, s_FieldStr,
                              m_Absorption[i], funcName);
         }
 
         funcNameElmt = pForce->FirstChildElement("REFFLOW");
         if (funcNameElmt)
         {
             string funcName = funcNameElmt->GetText();
             ASSERTL0(m_session->DefinesFunction(funcName),
                      "Function '" + funcName + "' not defined.");
 
             m_Refflow = Array<OneD, Array<OneD, NekDouble> > (m_NumVariable);
             for (int i = 0; i < m_NumVariable; ++i)
             {
                 s_FieldStr = m_session->GetVariable(i);
                 ASSERTL0(m_session->DefinesFunction(funcName, s_FieldStr),
                          "Variable '" + s_FieldStr + "' not defined.");
                 m_Refflow[i] = Array<OneD, NekDouble> (npts, 0.0);
                 EvaluateFunction(pFields, m_session, s_FieldStr,
                                  m_Refflow[i], funcName);
             }
             m_hasRefFlow = true;
         }
    
         funcNameElmt = pForce->FirstChildElement("REFFLOWTIME");
         if (funcNameElmt)
         {
             m_funcNameTime = funcNameElmt->GetText();
             m_hasRefFlowTime = true;
         }
 
     }

Friends And Related Function Documentation

friend class MemoryManager< ForcingAbsorption >

friend

Definition at line 54 of file ForcingAbsorption.h.

Member Data Documentation

std::string Nektar::SolverUtils::ForcingAbsorption::className

static

Initial value:

= GetForcingFactory().
                                RegisterCreatorFunction("Absorption",
                                                        ForcingAbsorption::create,
                                                        "Forcing Absorption")

Name of the class.

Definition at line 70 of file ForcingAbsorption.h.