#include <ForcingMovingReferenceFrame.h>

Inheritance diagram for Nektar::SolverUtils::ForcingMovingReferenceFrame:

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

Protected Member Functions
SOLVER_UTILS_EXPORT void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields, const TiXmlElement *pForce) override
	Initialise the forcing module. More...

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
	Adds the body force, -Omega X u. More...

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) override
	Compute the moving frame velocity at given time. More...

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	~Forcing ()=default

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

	~ForcingMovingReferenceFrame (void) override

void	UpdatePrescribed (const NekDouble &time, std::map< int, NekDouble > &Dirs)

void	UpdateFrameVelocity (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)
	Updates the forcing array with the current required forcing. More...

void	UpdateFluidInterface (Array< OneD, Array< OneD, NekDouble > > &bodyVel, const int step)

void	SetInitialConditions ()

void	SetInitialConditions (std::map< int, NekDouble > &Dirs)

void	addRotation (int npoints, const Array< OneD, Array< OneD, NekDouble > > &inarray0, NekDouble angVelScale, const Array< OneD, Array< OneD, NekDouble > > &inarray1, Array< OneD, Array< OneD, NekDouble > > &outarray)
	outarray = inarray0 + angVelScale Omega x inarray1 More...

void	InitBodySolver (const TiXmlElement *pForce)

void	SolveBodyMotion (Array< OneD, Array< OneD, NekDouble > > &bodyVel, const Array< OneD, NekDouble > &forcebody, std::map< int, NekDouble > &Dirs)

void	LoadParameters (const TiXmlElement *pForce)

NekDouble	EvaluateExpression (std::string expression)

void	InitialiseFilter (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pForce)

void	UpdateBoundaryConditions (NekDouble time)
	Set velocity boundary condition at the next time step. More...

Private Attributes
Array< OneD, NekDouble >	m_pivotPoint

Array< OneD, NekDouble >	m_travelWave

FrameTransform	m_frame

std::map< int, LibUtilities::EquationSharedPtr >	m_frameVelFunction

std::ofstream	m_outputStream

bool	m_isRoot

Array< OneD, bool >	m_hasVel

Array< OneD, bool >	m_hasOmega

bool	m_hasRotation

Array< OneD, NekDouble >	m_velxyz

Array< OneD, NekDouble >	m_omegaxyz

Array< OneD, Array< OneD, NekDouble > >	m_coords

NekDouble	m_currentTime

NekDouble	m_timestep

bool	m_isH1d

bool	m_hasPlane0

bool	m_isH2d

int32_t	m_spacedim

int32_t	m_expdim

unsigned int	m_index

unsigned int	m_outputFrequency

struct {
Array< OneD, Array< OneD, NekDouble > > vel

bool hasFreeMotion

std::set< int > dirDoFs

bool isCircular

FilterAeroForcesSharedPtr aeroforceFilter

std::map< int, LibUtilities::EquationSharedPtr > extForceFunction

Array< OneD, NekDouble > extForceXYZ

Array< OneD, NekDouble > M

Array< OneD, NekDouble > C

Array< OneD, NekDouble > K

}	m_body

Newmark_BetaSolver	m_bodySolver

Friends
class	MemoryManager< ForcingMovingReferenceFrame >

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::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 105 of file ForcingMovingReferenceFrame.h.

Constructor & Destructor Documentation

◆ ForcingMovingReferenceFrame()

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

private

Parameters

pSession
pEquation

Definition at line 65 of file ForcingMovingReferenceFrame.cpp.

    : Forcing(pSession, pEquation)
{
}

◆ ~ForcingMovingReferenceFrame()

Nektar::SolverUtils::ForcingMovingReferenceFrame::~ForcingMovingReferenceFrame ( void )

overrideprivate

Definition at line 72 of file ForcingMovingReferenceFrame.cpp.

{
    if (m_isRoot)
    {
        m_outputStream.close();
    }
}

References m_isRoot, and m_outputStream.

Member Function Documentation

◆ addRotation()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::addRotation	(	int	npoints,
		const Array< OneD, Array< OneD, NekDouble > > &	inarray0,
		NekDouble	angVelScale,
		const Array< OneD, Array< OneD, NekDouble > > &	inarray1,
		Array< OneD, Array< OneD, NekDouble > > &	outarray
	)

private

outarray = inarray0 + angVelScale Omega x inarray1

Definition at line 771 of file ForcingMovingReferenceFrame.cpp.

{
    ASSERTL0(&inarray1 != &outarray, "inarray1 and outarray "
                                     "should not be the same.");
 
    // TODO: In case of having support for all three components of Omega,
    // they should be transformed into the rotating frame first!
 
    // In case that the inarray0 and outarry are different, to avoid using
    // un-initialized array, copy the array first
    if (&inarray0 != &outarray)
    {
        ASSERTL0(inarray0.size() == outarray.size(),
                 "inarray0 and outarray must have same dimentions");
        for (int i = 0; i < inarray0.size(); ++i)
        {
            Vmath::Vcopy(nPnts, inarray0[i], 1, outarray[i], 1);
        }
    }
 
    if (m_spacedim >= 2 && m_hasOmega[2])
    {
        NekDouble cp = m_omegaxyz[2] * angVelScale;
        NekDouble cm = -1. * cp;
 
        Vmath::Svtvp(nPnts, cm, inarray1[1], 1, outarray[0], 1, outarray[0], 1);
        Vmath::Svtvp(nPnts, cp, inarray1[0], 1, outarray[1], 1, outarray[1], 1);
    }
 
    if (m_spacedim == 3 && m_hasOmega[0])
    {
        NekDouble cp = m_omegaxyz[0] * angVelScale;
        NekDouble cm = -1. * cp;
 
        Vmath::Svtvp(nPnts, cp, inarray1[1], 1, outarray[2], 1, outarray[2], 1);
        Vmath::Svtvp(nPnts, cm, inarray1[2], 1, outarray[1], 1, outarray[1], 1);
    }
 
    if (m_spacedim == 3 && m_hasOmega[1])
    {
        NekDouble cp = m_omegaxyz[1] * angVelScale;
        NekDouble cm = -1. * cp;
 
        Vmath::Svtvp(nPnts, cp, inarray1[2], 1, outarray[0], 1, outarray[0], 1);
        Vmath::Svtvp(nPnts, cm, inarray1[0], 1, outarray[2], 1, outarray[2], 1);
    }
}

References ASSERTL0, m_hasOmega, m_omegaxyz, m_spacedim, Vmath::Svtvp(), and Vmath::Vcopy().

Referenced by v_Apply(), and v_PreApply().

◆ create()

static SOLVER_UTILS_EXPORT ForcingSharedPtr Nektar::SolverUtils::ForcingMovingReferenceFrame::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 112 of file ForcingMovingReferenceFrame.h.

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

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

◆ EvaluateExpression()

NekDouble Nektar::SolverUtils::ForcingMovingReferenceFrame::EvaluateExpression ( std::string expression )

private

Definition at line 170 of file ForcingMovingReferenceFrame.cpp.

{
    NekDouble value = 0.;
    try
    {
        LibUtilities::Equation expession(m_session->GetInterpreter(),
                                         expression);
        value = expession.Evaluate();
    }
    catch (const std::runtime_error &)
    {
        NEKERROR(ErrorUtil::efatal, "Error evaluating expression" + expression);
    }
    return value;
}

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::Equation::Evaluate(), Nektar::SolverUtils::Forcing::m_session, and NEKERROR.

Referenced by InitBodySolver(), and LoadParameters().

◆ InitBodySolver()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::InitBodySolver ( const TiXmlElement * pForce )

private

Definition at line 381 of file ForcingMovingReferenceFrame.cpp.

{
    int NumDof = m_spacedim + 1;
    const TiXmlElement *mssgTag;
    std::string mssgStr;
    // allocate memory and initialise
    m_body.vel = Array<OneD, Array<OneD, NekDouble>>(3);
    for (size_t i = 0; i < 3; ++i)
    {
        m_body.vel[i] = Array<OneD, NekDouble>(NumDof, 0.);
    }
    SetInitialConditions();
    UpdateFluidInterface(m_body.vel, 1);
    // read free motion DoFs
    m_body.dirDoFs.clear();
    for (int i = 0; i < NumDof; ++i)
    {
        m_body.dirDoFs.insert(i);
    }
    mssgTag = pForce->FirstChildElement("MOTIONPRESCRIBED");
    if (mssgTag)
    {
        std::vector<std::string> values;
        mssgStr = mssgTag->GetText();
        ParseUtils::GenerateVector(mssgStr, values);
        ASSERTL0(values.size() == NumDof,
                 "MOTIONPRESCRIBED vector should be of size " +
                     std::to_string(NumDof));
        for (int i = 0; i < NumDof; ++i)
        {
            if (EvaluateExpression(values[i]) == 0)
            {
                m_body.dirDoFs.erase(i);
                if (i < m_spacedim)
                {
                    m_hasVel[i] = true;
                }
                else if (i == m_spacedim)
                {
                    m_hasOmega[2] = true;
                    m_hasRotation = true;
                }
            }
        }
    }
    m_body.hasFreeMotion = m_body.dirDoFs.size() < NumDof;
    // read mass matrix
    m_body.M = Array<OneD, NekDouble>(NumDof * NumDof, 0.);
    mssgTag  = pForce->FirstChildElement("MASS");
    ASSERTL0(m_body.dirDoFs.size() == NumDof || mssgTag,
             "Mass matrix is required.");
    if (mssgTag)
    {
        std::vector<std::string> values;
        mssgStr = mssgTag->GetText();
        ParseUtils::GenerateVector(mssgStr, values);
        ASSERTL0(values.size() == NumDof * NumDof,
                 "Mass matrix should be of size " + std::to_string(NumDof) +
                     "X" + std::to_string(NumDof));
        int count = 0;
        for (int i = 0; i < NumDof; ++i)
        {
            for (int j = 0; j < NumDof; ++j)
            {
                m_body.M[count] = EvaluateExpression(values[count]);
                ++count;
            }
        }
    }
    // read damping matrix
    m_body.C = Array<OneD, NekDouble>(NumDof * NumDof, 0.);
    mssgTag  = pForce->FirstChildElement("DAMPING");
    if (mssgTag)
    {
        std::vector<std::string> values;
        mssgStr = mssgTag->GetText();
        ParseUtils::GenerateVector(mssgStr, values);
        ASSERTL0(values.size() == NumDof * NumDof,
                 "Damping matrix should be of size " + std::to_string(NumDof) +
                     "X" + std::to_string(NumDof));
        int count = 0;
        for (int i = 0; i < NumDof; ++i)
        {
            for (int j = 0; j < NumDof; ++j)
            {
                m_body.C[count] = EvaluateExpression(values[count]);
                ++count;
            }
        }
    }
    // read rigidity matrix
    m_body.K = Array<OneD, NekDouble>(NumDof * NumDof, 0.);
    mssgTag  = pForce->FirstChildElement("RIGIDITY");
    if (mssgTag)
    {
        std::vector<std::string> values;
        mssgStr = mssgTag->GetText();
        ParseUtils::GenerateVector(mssgStr, values);
        ASSERTL0(values.size() == NumDof * NumDof,
                 "Rigidity matrix should be of size " + std::to_string(NumDof) +
                     "X" + std::to_string(NumDof));
        int count = 0;
        for (int i = 0; i < NumDof; ++i)
        {
            for (int j = 0; j < NumDof; ++j)
            {
                m_body.K[count] = EvaluateExpression(values[count]);
                ++count;
            }
        }
    }
    // read Newmark Beta paramters
    m_timestep      = m_session->GetParameter("TimeStep");
    NekDouble beta  = 0.25;
    NekDouble gamma = 0.51;
    if (m_session->DefinesParameter("NewmarkBeta"))
    {
        beta = m_session->GetParameter("NewmarkBeta");
    }
    if (m_session->DefinesParameter("NewmarkGamma"))
    {
        gamma = m_session->GetParameter("NewmarkGamma");
    }
    m_bodySolver.SetNewmarkBeta(beta, gamma, m_timestep, m_body.M, m_body.C,
                                m_body.K, m_body.dirDoFs);
}

References ASSERTL0, Nektar::LibUtilities::beta, EvaluateExpression(), Nektar::ParseUtils::GenerateVector(), m_body, m_bodySolver, m_hasOmega, m_hasRotation, m_hasVel, Nektar::SolverUtils::Forcing::m_session, m_spacedim, m_timestep, SetInitialConditions(), Nektar::SolverUtils::Newmark_BetaSolver::SetNewmarkBeta(), and UpdateFluidInterface().

Referenced by v_InitObject().

◆ InitialiseFilter()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::InitialiseFilter	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const TiXmlElement *	pForce
	)

private

Definition at line 983 of file ForcingMovingReferenceFrame.cpp.

{
    std::map<std::string, std::string> vParams;
    vParams["OutputFile"]     = ".dummyMRFForceFile";
    const TiXmlElement *param = pForce->FirstChildElement("BOUNDARY");
    ASSERTL0(param, "Body surface should be assigned");
 
    vParams["Boundary"]           = param->GetText();
    const TiXmlElement *pivotElmt = pForce->FirstChildElement("PIVOTPOINT");
    if (pivotElmt)
    {
        std::string pstr = pivotElmt->GetText();
        std::replace(pstr.begin(), pstr.end(), ',', ' ');
        vParams["MomentPoint"] = pstr;
    }
    m_body.aeroforceFilter = MemoryManager<FilterAeroForces>::AllocateSharedPtr(
        pSession, m_equ.lock(), vParams);
 
    m_body.aeroforceFilter->Initialise(pFields, 0.0);
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, m_body, and Nektar::SolverUtils::Forcing::m_equ.

Referenced by v_InitObject().

◆ LoadParameters()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::LoadParameters ( const TiXmlElement * pForce )

private

Definition at line 187 of file ForcingMovingReferenceFrame.cpp.

{
    const TiXmlElement *funcNameElmt;
    // body is a circular cylinder
    const TiXmlElement *mssgTagSpecial =
        pForce->FirstChildElement("CIRCULARCYLINDER");
    if (mssgTagSpecial)
    {
        m_body.isCircular = true;
    }
    else
    {
        m_body.isCircular = false;
    }
    // load frame velocity
    funcNameElmt = pForce->FirstChildElement("FRAMEVELOCITY");
    if (funcNameElmt)
    {
        std::string FuncName = funcNameElmt->GetText();
        ASSERTL0(m_session->DefinesFunction(FuncName),
                 "Function '" + FuncName + "' is not defined in the session.");
        // linear velocity
        for (int i = 0; i < m_spacedim; ++i)
        {
            std::string var = m_session->GetVariable(i);
            if (m_session->DefinesFunction(FuncName, var))
            {
                m_frameVelFunction[i] = m_session->GetFunction(FuncName, var);
                m_hasVel[i]           = true;
            }
        }
        // linear displacement and acceleration
        std::vector<std::string> linearDispVar = {"X", "Y", "Z"};
        std::vector<std::string> linearAcceVar = {"A_x", "A_y", "A_z"};
        for (int i = 0; i < m_spacedim; ++i)
        {
            if (m_session->DefinesFunction(FuncName, linearDispVar[i]))
            {
                m_frameVelFunction[i + 6] =
                    m_session->GetFunction(FuncName, linearDispVar[i]);
            }
            if (m_session->DefinesFunction(FuncName, linearAcceVar[i]))
            {
                m_frameVelFunction[i + 12] =
                    m_session->GetFunction(FuncName, linearAcceVar[i]);
            }
        }
        // angular velocities
        m_hasRotation                       = false;
        std::vector<std::string> angularVar = {"Omega_x", "Omega_y", "Omega_z"};
        for (int i = 0; i < 3; ++i)
        {
            std::string var = angularVar[i];
            if (m_session->DefinesFunction(FuncName, var))
            {
                m_frameVelFunction[i + 3] =
                    m_session->GetFunction(FuncName, var);
                m_hasOmega[i] = true;
                m_hasRotation = true;
            }
        }
        // angular displacement and acceleration
        std::vector<std::string> angularDispVar  = {"Theta_x", "Theta_y",
                                                    "Theta_z"};
        std::vector<std::string> angularAccepVar = {"DOmega_x", "DOmega_y",
                                                    "DOmega_z"};
        for (int i = 0; i < 3; ++i)
        {
            if (m_session->DefinesFunction(FuncName, angularDispVar[i]))
            {
                m_frameVelFunction[i + 3 + 6] =
                    m_session->GetFunction(FuncName, angularDispVar[i]);
            }
            if (m_session->DefinesFunction(FuncName, angularAccepVar[i]))
            {
                m_frameVelFunction[i + 3 + 12] =
                    m_session->GetFunction(FuncName, angularAccepVar[i]);
            }
        }
        // TODO: add the support for general rotation
        for (int i = 0; i < 2; ++i)
        {
            ASSERTL0(!m_hasOmega[i], "Currently only Omega_z is supported");
        }
    }
 
    // load external force
    funcNameElmt = pForce->FirstChildElement("EXTERNALFORCE");
    if (funcNameElmt)
    {
        std::string FuncName = funcNameElmt->GetText();
        if (m_session->DefinesFunction(FuncName))
        {
            std::vector<std::string> forceVar = {"Fx", "Fy", "Fz"};
            for (int i = 0; i < m_spacedim; ++i)
            {
                std::string var = forceVar[i];
                if (m_session->DefinesFunction(FuncName, var))
                {
                    m_body.extForceFunction[i] =
                        m_session->GetFunction(FuncName, var);
                }
            }
            std::vector<std::string> momentVar = {"Mx", "My", "Mz"};
            for (int i = 0; i < 3; ++i)
            {
                std::string var = momentVar[i];
                if (m_session->DefinesFunction(FuncName, var))
                {
                    m_body.extForceFunction[i + 3] =
                        m_session->GetFunction(FuncName, var);
                }
            }
        }
    }
 
    // load pitching pivot
    const TiXmlElement *pivotElmt = pForce->FirstChildElement("PIVOTPOINT");
    if (pivotElmt)
    {
        std::vector<std::string> values;
        std::string mssgStr = pivotElmt->GetText();
        ParseUtils::GenerateVector(mssgStr, values);
        for (int j = 0; j < m_spacedim; ++j)
        {
            m_pivotPoint[j] = EvaluateExpression(values[j]);
        }
    }
 
    // load travelling wave speed
    const TiXmlElement *TWSElmt =
        pForce->FirstChildElement("TRAVELINGWAVESPEED");
    if (TWSElmt)
    {
        std::vector<std::string> values;
        std::string mssgStr = TWSElmt->GetText();
        ParseUtils::GenerateVector(mssgStr, values);
        for (int j = 0; j < m_spacedim; ++j)
        {
            NekDouble tmp = EvaluateExpression(values[j]);
            if (fabs(tmp) > NekConstants::kNekMachineEpsilon)
            {
                m_travelWave[j] = tmp;
                m_hasVel[j]     = true;
            }
        }
    }
 
    // OutputFile
    const TiXmlElement *mssgTag = pForce->FirstChildElement("OutputFile");
    std::string filename;
    if (mssgTag)
    {
        filename = mssgTag->GetText();
    }
    else
    {
        filename = m_session->GetSessionName();
    }
    if (!(filename.length() >= 4 &&
          filename.substr(filename.length() - 4) == ".mrf"))
    {
        filename += ".mrf";
    }
    if (m_isRoot)
    {
        m_outputStream.open(filename.c_str());
        if (m_spacedim == 2)
        {
            m_outputStream
                << "Variables = t, x, ux, ax, y, uy, ay, theta, omega, domega"
                << std::endl;
        }
        else if (m_spacedim == 3)
        {
            m_outputStream << "Variables = t, x, ux, ax, y, uy, ay, z, uz, az, "
                              "theta, omega, domega"
                           << std::endl;
        }
    }
 
    // output frequency
    m_outputFrequency = 1;
    mssgTag           = pForce->FirstChildElement("OutputFrequency");
    if (mssgTag)
    {
        std::vector<std::string> values;
        std::string mssgStr = mssgTag->GetText();
        m_outputFrequency   = round(EvaluateExpression(mssgStr));
    }
    ASSERTL0(m_outputFrequency > 0,
             "OutputFrequency should be greater than zero.");
}

References ASSERTL0, EvaluateExpression(), Nektar::ParseUtils::GenerateVector(), Nektar::NekConstants::kNekMachineEpsilon, m_body, m_frameVelFunction, m_hasOmega, m_hasRotation, m_hasVel, m_isRoot, m_outputFrequency, m_outputStream, m_pivotPoint, Nektar::SolverUtils::Forcing::m_session, m_spacedim, and m_travelWave.

Referenced by v_InitObject().

◆ SetInitialConditions() [1/2]

void Nektar::SolverUtils::ForcingMovingReferenceFrame::SetInitialConditions ( )

private

Definition at line 883 of file ForcingMovingReferenceFrame.cpp.

{
    NekDouble time = 0.;
    std::map<std::string, std::string> fieldMetaDataMap;
    std::vector<std::string> strFrameData = {
        "X",   "Y",   "Z",   "Theta_x",  "Theta_y",  "Theta_z",
        "U",   "V",   "W",   "Omega_x",  "Omega_y",  "Omega_z",
        "A_x", "A_y", "A_z", "DOmega_x", "DOmega_y", "DOmega_z"};
    std::map<std::string, NekDouble> fileData;
    if (m_session->DefinesFunction("InitialConditions"))
    {
        for (int i = 0; i < m_session->GetVariables().size(); ++i)
        {
            if (m_session->GetFunctionType("InitialConditions",
                                           m_session->GetVariable(i)) ==
                LibUtilities::eFunctionTypeFile)
            {
                std::string filename = m_session->GetFunctionFilename(
                    "InitialConditions", m_session->GetVariable(i));
                fs::path pfilename(filename);
                // redefine path for parallel file which is in directory
                if (fs::is_directory(pfilename))
                {
                    fs::path metafile("Info.xml");
                    fs::path fullpath = pfilename / metafile;
                    filename          = LibUtilities::PortablePath(fullpath);
                }
                LibUtilities::FieldIOSharedPtr fld =
                    LibUtilities::FieldIO::CreateForFile(m_session, filename);
                fld->ImportFieldMetaData(filename, fieldMetaDataMap);
 
                // check to see if time is defined
                if (fieldMetaDataMap != LibUtilities::NullFieldMetaDataMap)
                {
                    if (fieldMetaDataMap.find("Time") != fieldMetaDataMap.end())
                    {
                        time = std::stod(fieldMetaDataMap["Time"]);
                    }
                    fileData.clear();
                    for (auto &var : strFrameData)
                    {
                        if (fieldMetaDataMap.find(var) !=
                            fieldMetaDataMap.end())
                        {
                            fileData[var] = std::stod(fieldMetaDataMap[var]);
                        }
                    }
                    if (fileData.size() == strFrameData.size())
                    {
                        break;
                    }
                }
            }
        }
    }
    if (m_session->DefinesCmdLineArgument("set-start-time"))
    {
        time = std::stod(
            m_session->GetCmdLineArgument<std::string>("set-start-time"));
    }
    if (fileData.size() == strFrameData.size())
    {
        int NumDofm1 = m_body.vel[0].size() - 1;
        for (int i = 0; i < m_spacedim; ++i)
        {
            m_body.vel[0][i] = fileData[strFrameData[i]];
            m_body.vel[1][i] = fileData[strFrameData[i + 6]];
            m_body.vel[2][i] = fileData[strFrameData[i + 12]];
        }
        m_body.vel[0][NumDofm1] = fileData[strFrameData[5]];
        m_body.vel[1][NumDofm1] = fileData[strFrameData[11]];
        m_body.vel[2][NumDofm1] = fileData[strFrameData[17]];
    }
    std::map<int, NekDouble> Dirs;
    UpdatePrescribed(time, Dirs);
    SetInitialConditions(Dirs);
}

References Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::LibUtilities::eFunctionTypeFile, m_body, Nektar::SolverUtils::Forcing::m_session, m_spacedim, Nektar::LibUtilities::NullFieldMetaDataMap, Nektar::LibUtilities::PortablePath(), SetInitialConditions(), and UpdatePrescribed().

Referenced by InitBodySolver(), SetInitialConditions(), and UpdateFrameVelocity().

◆ SetInitialConditions() [2/2]

void Nektar::SolverUtils::ForcingMovingReferenceFrame::SetInitialConditions ( std::map< int, NekDouble > & Dirs )

private

Definition at line 961 of file ForcingMovingReferenceFrame.cpp.

{
    for (auto it : Dirs)
    {
        int NumDof  = m_body.vel[0].size();
        int NumDof2 = NumDof << 1;
        if (it.first < m_body.vel[0].size())
        {
            m_body.vel[1][it.first] = it.second;
        }
        else if (it.first < NumDof2)
        {
            m_body.vel[0][it.first - NumDof] = it.second;
        }
        else
        {
            m_body.vel[2][it.first - NumDof2] = it.second;
        }
    }
}

References m_body.

◆ SolveBodyMotion()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::SolveBodyMotion	(	Array< OneD, Array< OneD, NekDouble > > &	bodyVel,
		const Array< OneD, NekDouble > &	forcebody,
		std::map< int, NekDouble > &	Dirs
	)

private

Definition at line 658 of file ForcingMovingReferenceFrame.cpp.

{
    if (!m_body.hasFreeMotion)
    {
        m_bodySolver.SolvePrescribed(bodyVel, Dirs);
    }
    else if (!m_hasRotation || Dirs.find(m_spacedim) != Dirs.end())
    {
        m_bodySolver.SolvePrescribed(bodyVel, Dirs);
        Array<OneD, NekDouble> force(6, 0.), tmp;
        if (m_hasRotation && Dirs.find(m_spacedim) != Dirs.end())
        {
            Array<OneD, NekDouble> angle(3, 0.);
            angle[2] = bodyVel[0][m_spacedim];
            m_frame.SetAngle(angle);
            m_frame.BodyToInerital(3, forcebody, force);
            m_frame.BodyToInerital(3, forcebody + 3, tmp = force + 3);
        }
        else
        {
            Vmath::Vcopy(6, forcebody, 1, force, 1);
        }
        for (int i = 0; i < m_spacedim; ++i)
        {
            force[i] += m_body.extForceXYZ[i];
        }
        force[m_spacedim] = force[5] + m_body.extForceXYZ[5];
        m_bodySolver.SolveFree(bodyVel, force);
    }
    else
    {
        Array<OneD, Array<OneD, NekDouble>> tmpbodyVel(bodyVel.size());
        for (size_t i = 0; i < bodyVel.size(); ++i)
        {
            tmpbodyVel[i] = Array<OneD, NekDouble>(bodyVel[i].size());
        }
        Array<OneD, NekDouble> angle(3, 0.);
        angle[2] = bodyVel[0][m_spacedim];
        for (int iter = 0; iter < 2; ++iter)
        {
            // copy initial condition
            for (size_t i = 0; i < bodyVel.size(); ++i)
            {
                Vmath::Vcopy(bodyVel[i].size(), bodyVel[i], 1, tmpbodyVel[i],
                             1);
            }
            Array<OneD, NekDouble> force(6, 0.), tmp;
            m_frame.SetAngle(angle);
            m_frame.BodyToInerital(3, forcebody, force);
            m_frame.BodyToInerital(3, forcebody + 3, tmp = force + 3);
            for (int i = 0; i < m_spacedim; ++i)
            {
                force[i] += m_body.extForceXYZ[i];
            }
            force[m_spacedim] = force[5] + m_body.extForceXYZ[5];
            m_bodySolver.Solve(tmpbodyVel, force, Dirs);
            angle[2] = tmpbodyVel[0][m_spacedim];
        }
        // copy final results
        for (size_t i = 0; i < bodyVel.size(); ++i)
        {
            Vmath::Vcopy(bodyVel[i].size(), tmpbodyVel[i], 1, bodyVel[i], 1);
        }
    }
}

References Nektar::SolverUtils::FrameTransform::BodyToInerital(), m_body, m_bodySolver, m_frame, m_hasRotation, m_spacedim, Nektar::SolverUtils::FrameTransform::SetAngle(), Nektar::SolverUtils::Newmark_BetaSolver::Solve(), Nektar::SolverUtils::Newmark_BetaSolver::SolveFree(), Nektar::SolverUtils::Newmark_BetaSolver::SolvePrescribed(), and Vmath::Vcopy().

Referenced by UpdateFrameVelocity().

◆ UpdateBoundaryConditions()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::UpdateBoundaryConditions ( NekDouble time )

private

Set velocity boundary condition at the next time step.

Definition at line 751 of file ForcingMovingReferenceFrame.cpp.

{
    time += m_timestep;
    // compute the velocities whose functions are provided in inertial frame
    std::map<int, NekDouble> Dirs;
    UpdatePrescribed(time, Dirs);
    Array<OneD, Array<OneD, NekDouble>> bodyVel(m_body.vel.size());
    for (size_t i = 0; i < m_body.vel.size(); ++i)
    {
        bodyVel[i] = Array<OneD, NekDouble>(m_body.vel[i].size());
        Vmath::Vcopy(m_body.vel[i].size(), m_body.vel[i], 1, bodyVel[i], 1);
    }
    m_bodySolver.SolvePrescribed(bodyVel, Dirs);
    // set displacements at the next time step
    UpdateFluidInterface(bodyVel, 1);
}

References m_body, m_bodySolver, m_timestep, Nektar::SolverUtils::Newmark_BetaSolver::SolvePrescribed(), UpdateFluidInterface(), UpdatePrescribed(), and Vmath::Vcopy().

Referenced by v_Apply().

◆ UpdateFluidInterface()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::UpdateFluidInterface	(	Array< OneD, Array< OneD, NekDouble > > &	bodyVel,
		const int	step
	)

private

Definition at line 621 of file ForcingMovingReferenceFrame.cpp.

{
    // set displacements at the current or next time step
    Array<OneD, NekDouble> disp(6, 0.);
    Array<OneD, NekDouble> vel(12, 0.0);
    for (int i = 0; i < m_spacedim; ++i)
    {
        disp[i] = bodyVel[0][i];
    }
    if (!m_body.isCircular)
    {
        disp[5] = bodyVel[0][m_spacedim];
    }
    // to set the boundary condition of the next time step
    // update the frame velocities and accelerations
    for (int i = 0; i < m_spacedim; ++i)
    {
        vel[i]     = bodyVel[1][i];
        vel[i + 6] = bodyVel[2][i];
    }
    vel[5]  = bodyVel[1][m_spacedim];
    vel[11] = bodyVel[2][m_spacedim];
    Array<OneD, NekDouble> tmp;
    if (step && m_hasRotation)
    {
        m_frame.SetAngle(disp + 3);
        m_frame.IneritalToBody(3, vel, vel);
        m_frame.IneritalToBody(3, vel + 6, tmp = vel + 6);
    }
    auto equ = m_equ.lock();
    ASSERTL0(equ, "Weak pointer to the equation system is expired");
    auto FluidEq = std::dynamic_pointer_cast<FluidInterface>(equ);
    FluidEq->SetMovingFrameVelocities(vel, step);
    FluidEq->SetMovingFrameDisp(disp, step);
}

References ASSERTL0, Nektar::SolverUtils::FrameTransform::IneritalToBody(), m_body, Nektar::SolverUtils::Forcing::m_equ, m_frame, m_hasRotation, m_spacedim, Nektar::SolverUtils::FrameTransform::SetAngle(), and vel.

Referenced by InitBodySolver(), UpdateBoundaryConditions(), and UpdateFrameVelocity().

◆ UpdateFrameVelocity()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::UpdateFrameVelocity	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

private

Updates the forcing array with the current required forcing.

Parameters

pFields
time

Definition at line 556 of file ForcingMovingReferenceFrame.cpp.

{
    if (m_currentTime >= time)
    {
        return;
    }
    m_currentTime = time;
    std::map<int, NekDouble> Dirs;
    UpdatePrescribed(time, Dirs);
    if (m_index == 0)
    {
        SetInitialConditions(Dirs);
    }
    else
    {
        // compute the velocites whoes functions are provided in inertial frame
        Array<OneD, NekDouble> forcebody(6, 0.); // fluid force
        if (m_body.hasFreeMotion)
        {
            for (auto it : m_body.extForceFunction)
            {
                m_body.extForceXYZ[it.first] =
                    it.second->Evaluate(0., 0., 0., time);
            }
            m_body.aeroforceFilter->GetForces(pFields, NullNekDouble1DArray,
                                              time);
            auto equ = m_equ.lock();
            ASSERTL0(equ, "Weak pointer to the equation system is expired");
            auto FluidEq = std::dynamic_pointer_cast<FluidInterface>(equ);
            FluidEq->GetAeroForce(forcebody);
        }
        SolveBodyMotion(m_body.vel, forcebody, Dirs);
    }
    if (m_isRoot && m_index % m_outputFrequency == 0)
    {
        m_outputStream << boost::format("%25.19e") % time << " ";
        for (size_t i = 0; i < m_body.vel[0].size(); ++i)
        {
            m_outputStream << boost::format("%25.19e") % m_body.vel[0][i] << " "
                           << boost::format("%25.19e") % m_body.vel[1][i] << " "
                           << boost::format("%25.19e") % m_body.vel[2][i]
                           << " ";
        }
        m_outputStream << std::endl;
    }
    // extract values and transform to body frame
    for (int i = 0; i < m_spacedim; ++i)
    {
        m_velxyz[i] = m_body.vel[1][i];
    }
    if (m_hasRotation)
    {
        m_omegaxyz[2] = m_body.vel[1][m_spacedim];
        Array<OneD, NekDouble> angle(3, 0.);
        angle[2] = m_body.vel[0][m_spacedim];
        m_frame.SetAngle(angle);
        m_frame.IneritalToBody(3, m_velxyz, m_velxyz);
    }
    // set displacements at the current time step
    UpdateFluidInterface(m_body.vel, 0);
    ++m_index;
}

References ASSERTL0, CellMLToNektar.pycml::format, Nektar::SolverUtils::FrameTransform::IneritalToBody(), m_body, m_currentTime, Nektar::SolverUtils::Forcing::m_equ, m_frame, m_hasRotation, m_index, m_isRoot, m_omegaxyz, m_outputFrequency, m_outputStream, m_spacedim, m_velxyz, Nektar::NullNekDouble1DArray, Nektar::SolverUtils::FrameTransform::SetAngle(), SetInitialConditions(), SolveBodyMotion(), UpdateFluidInterface(), and UpdatePrescribed().

Referenced by v_PreApply().

◆ UpdatePrescribed()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::UpdatePrescribed	(	const NekDouble &	time,
		std::map< int, NekDouble > &	Dirs
	)

private

Definition at line 508 of file ForcingMovingReferenceFrame.cpp.

{
    int NumDof = m_spacedim + 1;
    for (auto it : m_frameVelFunction)
    {
        if (it.first < 3)
        {
            Dirs[it.first] = it.second->Evaluate(0., 0., 0., time);
        }
        else if (it.first == 5)
        {
            Dirs[m_spacedim] = it.second->Evaluate(0., 0., 0., time);
        }
        else if (it.first < 9)
        {
            Dirs[NumDof + it.first - 6] = it.second->Evaluate(0., 0., 0., time);
        }
        else if (it.first == 11)
        {
            Dirs[NumDof + m_spacedim] = it.second->Evaluate(0., 0., 0., time);
        }
        else if (it.first < 15)
        {
            Dirs[(NumDof << 1) + it.first - 12] =
                it.second->Evaluate(0., 0., 0., time);
        }
        else if (it.first == 17)
        {
            Dirs[(NumDof << 1) + m_spacedim] =
                it.second->Evaluate(0., 0., 0., time);
        }
    }
    for (auto i : m_body.dirDoFs)
    {
        if (Dirs.find(i) == Dirs.end())
        {
            Dirs[i]                 = 0.;
            Dirs[i + NumDof]        = 0.;
            Dirs[i + (NumDof << 1)] = 0.;
        }
    }
}

References m_body, m_frameVelFunction, and m_spacedim.

Referenced by SetInitialConditions(), UpdateBoundaryConditions(), and UpdateFrameVelocity().

◆ v_Apply()

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

Adds the body force, -Omega X u.

Parameters

fields
inarray
outarray
time

Implements Nektar::SolverUtils::Forcing.

Definition at line 733 of file ForcingMovingReferenceFrame.cpp.

{
    // If there is no rotation, body force is zero,
    // nothing needs to be done here.
    if (m_hasRotation)
    {
        int npoints = fields[0]->GetNpoints();
        addRotation(npoints, outarray, -1., inarray, outarray);
    }
    UpdateBoundaryConditions(time);
}

References addRotation(), m_hasRotation, and UpdateBoundaryConditions().

◆ v_InitObject()

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

overrideprotectedvirtual

Initialise the forcing module.

Parameters

pFields
pNumForcingFields
pForce

Implements Nektar::SolverUtils::Forcing.

Definition at line 86 of file ForcingMovingReferenceFrame.cpp.

{
    m_session->MatchSolverInfo("Homogeneous", "1D", m_isH1d, false);
    m_session->MatchSolverInfo("Homogeneous", "2D", m_isH2d, false);
    bool singleMode, halfMode;
    m_session->MatchSolverInfo("ModeType", "SingleMode", singleMode, false);
    m_session->MatchSolverInfo("ModeType", "HalfMode", halfMode, false);
    if (singleMode || halfMode)
    {
        m_isH1d = false;
    }
    m_expdim    = m_isH2d ? 1 : pFields[0]->GetGraph()->GetMeshDimension();
    m_spacedim  = m_expdim + (m_isH1d ? 1 : 0) + (m_isH2d ? 2 : 0);
    m_isRoot    = pFields[0]->GetComm()->TreatAsRankZero();
    m_hasPlane0 = true;
    if (m_isH1d)
    {
        m_hasPlane0 = pFields[0]->GetZIDs()[0] == 0;
    }
    // initialize variables
    m_velxyz           = Array<OneD, NekDouble>(3, 0.0);
    m_omegaxyz         = Array<OneD, NekDouble>(3, 0.0);
    m_body.extForceXYZ = Array<OneD, NekDouble>(6, 0.0);
    m_hasVel           = Array<OneD, bool>(3, false);
    m_hasOmega         = Array<OneD, bool>(3, false);
    m_travelWave       = Array<OneD, NekDouble>(3, 0.);
    m_pivotPoint       = Array<OneD, NekDouble>(3, 0.0);
    m_index            = 0;
    m_currentTime      = -1.;
    LoadParameters(pForce);
    InitBodySolver(pForce);
    if (m_body.isCircular || m_expdim == 1)
    {
        for (int i = 0; i < 3; ++i)
        {
            m_hasOmega[i] = false;
        }
        m_hasRotation = false;
    }
    // account for the effect of rotation
    // Omega_X results in having v and w even if not defined by user
    // Omega_Y results in having u and w even if not defined by user
    // Omega_Z results in having u and v even if not defined by user
    for (int i = 0; i < 3; ++i)
    {
        int j = (i + 1) % 3;
        int k = (i + 2) % 3;
        if (m_hasOmega[i])
        {
            m_hasVel[j] = true;
            m_hasVel[k] = true;
        }
    }
    if (m_hasRotation)
    {
        int npoints = pFields[0]->GetNpoints();
        m_coords    = Array<OneD, Array<OneD, NekDouble>>(3);
        for (int j = 0; j < m_spacedim; ++j)
        {
            m_coords[j] = Array<OneD, NekDouble>(npoints);
        }
        pFields[0]->GetCoords(m_coords[0], m_coords[1], m_coords[2]);
        // move the origin to the pivot point
        for (int i = 0; i < m_spacedim; ++i)
        {
            Vmath::Sadd(npoints, -m_pivotPoint[i], m_coords[i], 1, m_coords[i],
                        1);
        }
    }
    // initialise pivot point for fluid interface
    auto equ = m_equ.lock();
    ASSERTL0(equ, "Weak pointer to the equation system is expired");
    auto FluidEq = std::dynamic_pointer_cast<FluidInterface>(equ);
    FluidEq->SetMovingFramePivot(m_pivotPoint);
    // initialize aeroforce filter
    if (m_body.hasFreeMotion)
    {
        InitialiseFilter(m_session, pFields, pForce);
    }
}

References ASSERTL0, InitBodySolver(), InitialiseFilter(), LoadParameters(), m_body, m_coords, m_currentTime, Nektar::SolverUtils::Forcing::m_equ, m_expdim, m_hasOmega, m_hasPlane0, m_hasRotation, m_hasVel, m_index, m_isH1d, m_isH2d, m_isRoot, m_omegaxyz, m_pivotPoint, Nektar::SolverUtils::Forcing::m_session, m_spacedim, m_travelWave, m_velxyz, and Vmath::Sadd().

◆ v_PreApply()

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

overrideprotectedvirtual

Compute the moving frame velocity at given time.

Reimplemented from Nektar::SolverUtils::Forcing.

Definition at line 826 of file ForcingMovingReferenceFrame.cpp.

{
    UpdateFrameVelocity(fields, time);
    int npoints = fields[0]->GetNpoints();
    if (m_isH2d && fields[0]->GetWaveSpace())
    {
        for (int i = 0; i < m_spacedim; ++i)
        {
            if (m_hasVel[i])
            {
                Array<OneD, NekDouble> tmpphys(npoints,
                                               -m_velxyz[i] - m_travelWave[i]);
                Array<OneD, NekDouble> tmpcoef(npoints);
                fields[0]->HomogeneousFwdTrans(npoints, tmpphys, tmpcoef);
                Vmath::Vadd(npoints, tmpcoef, 1, inarray[i], 1, outarray[i], 1);
            }
            else if (&inarray != &outarray)
            {
                Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1);
            }
        }
    }
    else
    {
        int npoints0 = npoints;
        if (m_isH1d && fields[0]->GetWaveSpace())
        {
            npoints0 = m_hasPlane0 ? fields[0]->GetPlane(0)->GetNpoints() : 0;
        }
        for (int i = 0; i < m_spacedim; ++i)
        {
            if (m_hasVel[i])
            {
                Vmath::Sadd(npoints0, -m_velxyz[i] - m_travelWave[i],
                            inarray[i], 1, outarray[i], 1);
                if (&inarray != &outarray && npoints != npoints0)
                {
                    Array<OneD, NekDouble> tmp = outarray[i] + npoints0;
                    Vmath::Vcopy(npoints - npoints0, inarray[i] + npoints0, 1,
                                 tmp, 1);
                }
            }
            else if (&inarray != &outarray)
            {
                Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1);
            }
        }
        if (m_hasRotation)
        {
            addRotation(npoints0, outarray, -1., m_coords, outarray);
        }
    }
}

References addRotation(), m_coords, m_hasPlane0, m_hasRotation, m_hasVel, m_isH1d, m_isH2d, m_spacedim, m_travelWave, m_velxyz, Vmath::Sadd(), UpdateFrameVelocity(), Vmath::Vadd(), and Vmath::Vcopy().

Friends And Related Function Documentation

◆ MemoryManager< ForcingMovingReferenceFrame >

friend class MemoryManager< ForcingMovingReferenceFrame >

friend

Definition at line 102 of file ForcingMovingReferenceFrame.h.

Member Data Documentation

◆ aeroforceFilter

FilterAeroForcesSharedPtr Nektar::SolverUtils::ForcingMovingReferenceFrame::aeroforceFilter

Definition at line 193 of file ForcingMovingReferenceFrame.h.

◆ C

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::C

Definition at line 198 of file ForcingMovingReferenceFrame.h.

◆ classNameBody

std::string Nektar::SolverUtils::ForcingMovingReferenceFrame::classNameBody

static

Initial value:

=
    GetForcingFactory().RegisterCreatorFunction(
        "MovingReferenceFrame", ForcingMovingReferenceFrame::create,
        "Moving Frame")

Name of the class.

Definition at line 126 of file ForcingMovingReferenceFrame.h.

◆ dirDoFs

std::set<int> Nektar::SolverUtils::ForcingMovingReferenceFrame::dirDoFs

Definition at line 190 of file ForcingMovingReferenceFrame.h.

◆ extForceFunction

std::map<int, LibUtilities::EquationSharedPtr> Nektar::SolverUtils::ForcingMovingReferenceFrame::extForceFunction

Definition at line 195 of file ForcingMovingReferenceFrame.h.

◆ extForceXYZ

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::extForceXYZ

Definition at line 196 of file ForcingMovingReferenceFrame.h.

◆ hasFreeMotion

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::hasFreeMotion

Definition at line 189 of file ForcingMovingReferenceFrame.h.

◆ isCircular

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::isCircular

Definition at line 191 of file ForcingMovingReferenceFrame.h.

◆ K

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::K

Definition at line 199 of file ForcingMovingReferenceFrame.h.

◆ M

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::M

Definition at line 197 of file ForcingMovingReferenceFrame.h.

◆

struct { ... } Nektar::SolverUtils::ForcingMovingReferenceFrame::m_body

Referenced by InitBodySolver(), InitialiseFilter(), LoadParameters(), SetInitialConditions(), SolveBodyMotion(), UpdateBoundaryConditions(), UpdateFluidInterface(), UpdateFrameVelocity(), UpdatePrescribed(), and v_InitObject().

◆ m_bodySolver

Newmark_BetaSolver Nektar::SolverUtils::ForcingMovingReferenceFrame::m_bodySolver

private

Definition at line 201 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), SolveBodyMotion(), and UpdateBoundaryConditions().

◆ m_coords

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::ForcingMovingReferenceFrame::m_coords

private

Definition at line 173 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_currentTime

NekDouble Nektar::SolverUtils::ForcingMovingReferenceFrame::m_currentTime

private

Definition at line 175 of file ForcingMovingReferenceFrame.h.

Referenced by UpdateFrameVelocity(), and v_InitObject().

◆ m_expdim

int32_t Nektar::SolverUtils::ForcingMovingReferenceFrame::m_expdim

private

Definition at line 182 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject().

◆ m_frame

FrameTransform Nektar::SolverUtils::ForcingMovingReferenceFrame::m_frame

private

Definition at line 152 of file ForcingMovingReferenceFrame.h.

Referenced by SolveBodyMotion(), UpdateFluidInterface(), and UpdateFrameVelocity().

◆ m_frameVelFunction

std::map<int, LibUtilities::EquationSharedPtr> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_frameVelFunction

private

Definition at line 155 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), and UpdatePrescribed().

◆ m_hasOmega

Array<OneD, bool> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasOmega

private

Definition at line 164 of file ForcingMovingReferenceFrame.h.

Referenced by addRotation(), InitBodySolver(), LoadParameters(), and v_InitObject().

◆ m_hasPlane0

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasPlane0

private

Definition at line 179 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_hasRotation

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasRotation

private

Definition at line 165 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), LoadParameters(), SolveBodyMotion(), UpdateFluidInterface(), UpdateFrameVelocity(), v_Apply(), v_InitObject(), and v_PreApply().

◆ m_hasVel

Array<OneD, bool> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasVel

private

Definition at line 163 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), LoadParameters(), v_InitObject(), and v_PreApply().

◆ m_index

unsigned int Nektar::SolverUtils::ForcingMovingReferenceFrame::m_index

private

Definition at line 183 of file ForcingMovingReferenceFrame.h.

Referenced by UpdateFrameVelocity(), and v_InitObject().

◆ m_isH1d

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_isH1d

private

Definition at line 178 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_isH2d

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_isH2d

private

Definition at line 180 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_isRoot

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_isRoot

private

Definition at line 157 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), UpdateFrameVelocity(), v_InitObject(), and ~ForcingMovingReferenceFrame().

◆ m_omegaxyz

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_omegaxyz

private

Definition at line 171 of file ForcingMovingReferenceFrame.h.

Referenced by addRotation(), UpdateFrameVelocity(), and v_InitObject().

◆ m_outputFrequency

unsigned int Nektar::SolverUtils::ForcingMovingReferenceFrame::m_outputFrequency

private

Definition at line 184 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), and UpdateFrameVelocity().

◆ m_outputStream

std::ofstream Nektar::SolverUtils::ForcingMovingReferenceFrame::m_outputStream

private

Definition at line 156 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), UpdateFrameVelocity(), and ~ForcingMovingReferenceFrame().

◆ m_pivotPoint

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_pivotPoint

private

Definition at line 150 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), and v_InitObject().

◆ m_spacedim

int32_t Nektar::SolverUtils::ForcingMovingReferenceFrame::m_spacedim

private

Definition at line 181 of file ForcingMovingReferenceFrame.h.

Referenced by addRotation(), InitBodySolver(), LoadParameters(), SetInitialConditions(), SolveBodyMotion(), UpdateFluidInterface(), UpdateFrameVelocity(), UpdatePrescribed(), v_InitObject(), and v_PreApply().

◆ m_timestep

NekDouble Nektar::SolverUtils::ForcingMovingReferenceFrame::m_timestep

private

Definition at line 176 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), and UpdateBoundaryConditions().

◆ m_travelWave

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_travelWave

private

Definition at line 151 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), v_InitObject(), and v_PreApply().

◆ m_velxyz

Array<OneD, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_velxyz

private

Definition at line 168 of file ForcingMovingReferenceFrame.h.

Referenced by UpdateFrameVelocity(), v_InitObject(), and v_PreApply().

◆ vel

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::ForcingMovingReferenceFrame::vel

Definition at line 188 of file ForcingMovingReferenceFrame.h.

Referenced by UpdateFluidInterface().

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ForcingMovingReferenceFrame()

◆ ~ForcingMovingReferenceFrame()

Member Function Documentation

◆ addRotation()

◆ create()

◆ EvaluateExpression()

◆ InitBodySolver()

◆ InitialiseFilter()

◆ LoadParameters()

◆ SetInitialConditions() [1/2]

◆ SetInitialConditions() [2/2]

◆ SolveBodyMotion()

◆ UpdateBoundaryConditions()

◆ UpdateFluidInterface()

◆ UpdateFrameVelocity()

◆ UpdatePrescribed()

◆ v_Apply()

◆ v_InitObject()

◆ v_PreApply()

Friends And Related Function Documentation

◆ MemoryManager< ForcingMovingReferenceFrame >

Member Data Documentation

◆ aeroforceFilter

◆ C

◆ classNameBody

◆ dirDoFs

◆ extForceFunction

◆ extForceXYZ

◆ hasFreeMotion

◆ isCircular

◆ K

◆ M

◆

◆ m_bodySolver

◆ m_coords

◆ m_currentTime

◆ m_expdim

◆ m_frame

◆ m_frameVelFunction

◆ m_hasOmega

◆ m_hasPlane0

◆ m_hasRotation

◆ m_hasVel

◆ m_index

◆ m_isH1d

◆ m_isH2d

◆ m_isRoot

◆ m_omegaxyz

◆ m_outputFrequency

◆ m_outputStream

◆ m_pivotPoint

◆ m_spacedim

◆ m_timestep

◆ m_travelWave

◆ m_velxyz

◆ vel