#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

Protected Member Functions inherited from Nektar::SolverUtils::Forcing
SOLVER_UTILS_EXPORT	Forcing (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)
	Constructor. More...

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

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

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

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

SOLVER_UTILS_EXPORT SessionFunctionSharedPtr	GetFunction (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const LibUtilities::SessionReaderSharedPtr &pSession, std::string pName, bool pCache=false)
	Get a SessionFunction by name. More...

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

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

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

	~ForcingMovingReferenceFrame (void) override

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

void	UpdateRotMat ()

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

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, const int dim, const int rank, const NekDouble time)

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

void	LoadParameters (const TiXmlElement *pForce, const NekDouble time)

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::map< int, LibUtilities::EquationSharedPtr >	m_extForceFunction

std::ofstream	m_outputStream

int	m_rank

Array< OneD, bool >	m_hasVel

Array< OneD, bool >	m_hasOmega

Array< OneD, NekDouble >	m_velXYZ

Array< OneD, NekDouble >	m_velxyz

Array< OneD, NekDouble >	m_omegaXYZ

Array< OneD, NekDouble >	m_omegaxyz

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

Array< OneD, NekDouble >	m_extForceXYZ

Array< OneD, NekDouble >	m_disp

bn::ublas::matrix< NekDouble >	m_ProjMatZ

NekDouble	m_startTime

NekDouble	m_timestep

bool	m_hasRotation

bool	m_isH1d

bool	m_hasPlane0

bool	m_isH2d

bool	m_hasFreeMotion

NekInt	m_spacedim

NekInt	m_expdim

unsigned int	m_index

unsigned int	m_outputFrequency

Newmark_BetaSolver	m_bodySolver

Array< OneD, Array< OneD, NekDouble > >	m_bodyVel

std::set< int >	m_DirDoFs

FilterAeroForcesSharedPtr	m_aeroforceFilter

Friends
class	MemoryManager< ForcingMovingReferenceFrame >

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 100 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 66 of file ForcingMovingReferenceFrame.cpp.

    : Forcing(pSession, pEquation)
{
}

◆ ~ForcingMovingReferenceFrame()

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

overrideprivate

Definition at line 73 of file ForcingMovingReferenceFrame.cpp.

{
    if (m_rank == 0)
    {
        m_outputStream.close();
    }
}

References m_outputStream, and m_rank.

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 840 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().

◆ CheckForRestartTime()

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

private

Definition at line 949 of file ForcingMovingReferenceFrame.cpp.

{
    std::map<std::string, std::string> fieldMetaDataMap;
    if (m_session->DefinesFunction("InitialConditions"))
    {
        for (int i = 0; i < pFields.size(); ++i)
        {
            LibUtilities::FunctionType vType;
 
            vType = m_session->GetFunctionType("InitialConditions",
                                               m_session->GetVariable(i));
 
            if (vType == 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)
                {
                    std::string strt = "Time";
                    if (fieldMetaDataMap.find(strt) != fieldMetaDataMap.end())
                    {
                        time = boost::lexical_cast<NekDouble>(
                            fieldMetaDataMap[strt]);
                        break;
                    }
                }
            }
        }
    }
}

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

Referenced by v_InitObject().

◆ 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 107 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 204 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,
		const int	dim,
		const int	rank,
		const NekDouble	time
	)

private

Definition at line 363 of file ForcingMovingReferenceFrame.cpp.

{
    int NumDof = dim + 1;
    std::set<int> DirBCs;
    const TiXmlElement *mssgTag;
    std::string mssgStr;
    // read free motion DoFs
    m_DirDoFs.clear();
    for (int i = 0; i < NumDof; ++i)
    {
        m_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_DirDoFs.erase(i);
                if (i < dim)
                {
                    m_hasVel[i] = true;
                }
                else if (i == dim)
                {
                    m_hasOmega[2] = true;
                }
            }
        }
    }
    m_hasFreeMotion = m_DirDoFs.size() < NumDof;
    // read mass matrix
    DNekMatSharedPtr M =
        MemoryManager<DNekMat>::AllocateSharedPtr(NumDof, NumDof, 0.0, eFULL);
    mssgTag = pForce->FirstChildElement("MASS");
    ASSERTL0(m_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));
        for (int i = 0; i < NumDof; ++i)
        {
            for (int j = 0; j < NumDof; ++j)
            {
                M->SetValue(i, j, EvaluateExpression(values[i * NumDof + j]));
            }
        }
    }
    // read damping matrix
    DNekMatSharedPtr C =
        MemoryManager<DNekMat>::AllocateSharedPtr(NumDof, NumDof, 0.0, eFULL);
    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));
        for (int i = 0; i < NumDof; ++i)
        {
            for (int j = 0; j < NumDof; ++j)
            {
                C->SetValue(i, j, EvaluateExpression(values[i * NumDof + j]));
            }
        }
    }
    // read rigidity matrix
    DNekMatSharedPtr K =
        MemoryManager<DNekMat>::AllocateSharedPtr(NumDof, NumDof, 0.0, eFULL);
    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));
        for (int i = 0; i < NumDof; ++i)
        {
            for (int j = 0; j < NumDof; ++j)
            {
                K->SetValue(i, j, EvaluateExpression(values[i * NumDof + j]));
            }
        }
    }
    // read Newmark Beta paramters
    m_timestep      = m_session->GetParameter("TimeStep");
    NekDouble beta  = 0.25;
    NekDouble gamma = 0.75;
    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, C, K, m_DirDoFs);
    // OutputFile
    string filename;
    mssgTag = pForce->FirstChildElement("OutputFile");
    if (mssgTag)
    {
        filename = mssgTag->GetText();
    }
    else
    {
        filename = m_session->GetSessionName();
    }
    if (!(filename.length() >= 4 &&
          filename.substr(filename.length() - 4) == ".mrf"))
    {
        filename += ".mrf";
    }
    if (rank == 0)
    {
        m_outputStream.open(filename.c_str());
        if (dim == 2)
        {
            m_outputStream
                << "Variables = t, x, ux, ax, y, uy, ay, theta, omega, domega"
                << endl;
        }
        else if (dim == 3)
        {
            m_outputStream << "Variables = t, x, ux, ax, y, uy, ay, z, uz, az, "
                              "theta, omega, domega"
                           << endl;
        }
    }
    // output frequency
    m_index           = 0;
    m_outputFrequency = 1;
    mssgTag           = pForce->FirstChildElement("OutputFrequency");
    if (mssgTag)
    {
        std::vector<std::string> values;
        mssgStr           = mssgTag->GetText();
        m_outputFrequency = round(EvaluateExpression(mssgStr));
    }
    ASSERTL0(m_outputFrequency > 0,
             "OutputFrequency should be greater than zero.");
    // initialize displacement velocity
    m_bodyVel = Array<OneD, Array<OneD, NekDouble>>(3);
    for (size_t i = 0; i < 3; ++i)
    {
        m_bodyVel[i] = Array<OneD, NekDouble>(NumDof, 0.);
    }
    for (int i = 0; i < m_spacedim; ++i)
    {
        m_bodyVel[0][i] = m_disp[i];
    }
    m_bodyVel[0][NumDof - 1] = m_disp[5];
    for (auto it : m_frameVelFunction)
    {
        if (it.first < 3)
        {
            m_bodyVel[1][it.first] = it.second->Evaluate(0., 0., 0., time);
        }
        else if (it.first == 5)
        {
            m_bodyVel[1][NumDof - 1] = it.second->Evaluate(0., 0., 0., time);
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::beta, Nektar::eFULL, EvaluateExpression(), Nektar::ParseUtils::GenerateVector(), m_bodySolver, m_bodyVel, m_DirDoFs, m_disp, m_frameVelFunction, m_hasFreeMotion, m_hasOmega, m_hasVel, m_index, m_outputFrequency, m_outputStream, Nektar::SolverUtils::Forcing::m_session, m_spacedim, m_timestep, and Nektar::SolverUtils::Newmark_BetaSolver::SetNewmarkBeta().

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 996 of file ForcingMovingReferenceFrame.cpp.

{
    std::map<std::string, std::string> vParams;
    vParams["OutputFile"]     = ".dummyfilename";
    const TiXmlElement *param = pForce->FirstChildElement("BOUNDARY");
    ASSERTL0(param, "Body surface should be assigned");
    vParams["Boundary"] = param->GetText();
    m_aeroforceFilter   = MemoryManager<FilterAeroForces>::AllocateSharedPtr(
        pSession, m_equ, vParams);
    m_aeroforceFilter->Initialise(pFields, 0.0);
}

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

Referenced by v_InitObject().

◆ LoadParameters()

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

private

Definition at line 221 of file ForcingMovingReferenceFrame.cpp.

{
    const TiXmlElement *funcNameElmt;
    // 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;
            }
        }
        // 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;
            }
        }
        // TODO: add the support for general rotation
        for (int i = 0; i < 2; ++i)
        {
            ASSERTL0(!m_hasOmega[i], "Currently only Omega_z is supported");
        }
    }
    if (m_expdim == 1)
    {
        m_hasRotation = false;
    }
 
    // 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_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_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]);
            m_disp[6 + j]   = m_pivotPoint[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;
            }
        }
    }
 
    // load initial displacement
    std::map<int, LibUtilities::EquationSharedPtr> initDisplacement;
    funcNameElmt = pForce->FirstChildElement("INITIALDISPLACEMENT");
    if (funcNameElmt)
    {
        std::string FuncName = funcNameElmt->GetText();
        ASSERTL0(m_session->DefinesFunction(FuncName),
                 "Function '" + FuncName + "' is not defined in the session.");
        // linear displacement
        std::vector<std::string> dispVar = {"x", "y", "z"};
        for (int i = 0; i < m_spacedim; ++i)
        {
            std::string var = dispVar[i];
            if (m_session->DefinesFunction(FuncName, var))
            {
                m_disp[i] = m_session->GetFunction(FuncName, var)
                                ->Evaluate(0., 0., 0., time);
            }
        }
        // angular displacement
        std::vector<std::string> angleVar = {"theta_x", "theta_y", "theta_z"};
        for (int i = 0; i < 3; ++i)
        {
            std::string var = angleVar[i];
            if (m_session->DefinesFunction(FuncName, var))
            {
                m_disp[i + 3] =
                    m_session->GetFunction(FuncName, var)->Evaluate();
            }
        }
    }
}

References ASSERTL0, EvaluateExpression(), Nektar::ParseUtils::GenerateVector(), Nektar::NekConstants::kNekMachineEpsilon, m_disp, m_expdim, m_extForceFunction, m_frameVelFunction, m_hasOmega, m_hasRotation, m_hasVel, m_pivotPoint, Nektar::SolverUtils::Forcing::m_session, m_spacedim, and m_travelWave.

Referenced by v_InitObject().

◆ 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 637 of file ForcingMovingReferenceFrame.cpp.

{
    if (!m_hasRotation || Dirs.find(m_spacedim) != Dirs.end())
    {
        Array<OneD, NekDouble> force(6, 0.), tmp;
        if (Dirs.find(m_spacedim) != Dirs.end())
        {
            Array<OneD, NekDouble> angle(3, 0.);
            angle[2] =
                bodyVel[0][m_spacedim] +
                0.5 * m_timestep * (bodyVel[1][m_spacedim] + Dirs[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_extForceXYZ[i];
        }
        force[m_spacedim] = force[5] + m_extForceXYZ[5];
        m_bodySolver.Solve(bodyVel, force, Dirs);
    }
    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_extForceXYZ[i];
            }
            force[m_spacedim] = force[5] + m_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_bodySolver, m_extForceXYZ, m_frame, m_hasRotation, m_spacedim, m_timestep, Nektar::SolverUtils::FrameTransform::SetAngle(), Nektar::SolverUtils::Newmark_BetaSolver::Solve(), and Vmath::Vcopy().

Referenced by Update(), and UpdateBoundaryConditions().

◆ Update()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::Update	(	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 550 of file ForcingMovingReferenceFrame.cpp.

{
    // compute the velociites whos functions are provided in inertial frame
    for (auto it : m_frameVelFunction)
    {
        if (it.first < 3)
        {
            m_velXYZ[it.first] = it.second->Evaluate(0., 0., 0., time);
        }
        else
        {
            m_omegaXYZ[it.first - 3] = it.second->Evaluate(0., 0., 0., time);
        }
    }
    for (auto it : m_extForceFunction)
    {
        m_extForceXYZ[it.first] = it.second->Evaluate(0., 0., 0., time);
    }
    auto equ = m_equ.lock();
    ASSERTL0(equ, "Weak pointer to the equation system is expired");
    auto FluidEq = std::dynamic_pointer_cast<FluidInterface>(equ);
    if (time > m_startTime)
    {
        Array<OneD, NekDouble> forcebody(6, 0.); // fluid force
        std::map<int, NekDouble> Dirs;           // prescribed Motion
        for (auto it : m_DirDoFs)
        {
            if (it < m_spacedim)
            {
                Dirs[it] = m_velXYZ[it];
            }
            else if (it == m_spacedim)
            {
                Dirs[it] = m_omegaXYZ[2];
            }
        }
        if (m_hasFreeMotion)
        {
            m_aeroforceFilter->GetForces(pFields, NullNekDouble1DArray, time);
        }
        FluidEq->GetAeroForce(forcebody);
        SolveBodyMotion(m_bodyVel, forcebody, Dirs);
    }
    if (m_rank == 0 && m_index % m_outputFrequency == 0)
    {
        m_outputStream << boost::format("%25.19e") % time << " ";
        for (size_t i = 0; i < m_bodyVel[0].size(); ++i)
        {
            m_outputStream << boost::format("%25.19e") % m_bodyVel[0][i] << " "
                           << boost::format("%25.19e") % m_bodyVel[1][i] << " "
                           << boost::format("%25.19e") % m_bodyVel[2][i] << " ";
        }
        m_outputStream << endl;
    }
    // overwirte m_omegaXYZ with u, also update theta
    for (int i = 0; i < m_spacedim; ++i)
    {
        m_velXYZ[i] = m_bodyVel[1][i];
    }
    m_omegaXYZ[2] = m_bodyVel[1][m_spacedim];
    for (int i = 0; i < m_spacedim; ++i)
    {
        m_disp[i] = m_bodyVel[0][i] + m_travelWave[i] * time;
    }
    m_disp[5] = m_bodyVel[0][m_spacedim];
 
    // include the effect of rotation
    if (m_hasRotation)
    {
        UpdateRotMat();
        m_frame.SetAngle(m_disp + 3);
        m_frame.IneritalToBody(3, m_velxyz, m_velXYZ);
        m_frame.IneritalToBody(3, m_omegaxyz, m_omegaXYZ);
    }
    else
    {
        // for translation only,
        for (int i = 0; i < m_spacedim; ++i)
        {
            m_velxyz[i] = m_velXYZ[i];
        }
    }
    ++m_index;
}

References ASSERTL0, CellMLToNektar.pycml::format, Nektar::SolverUtils::FrameTransform::IneritalToBody(), m_aeroforceFilter, m_bodyVel, m_DirDoFs, m_disp, Nektar::SolverUtils::Forcing::m_equ, m_extForceFunction, m_extForceXYZ, m_frame, m_frameVelFunction, m_hasFreeMotion, m_hasRotation, m_index, m_omegaXYZ, m_omegaxyz, m_outputFrequency, m_outputStream, m_rank, m_spacedim, m_startTime, m_travelWave, m_velXYZ, m_velxyz, Nektar::NullNekDouble1DArray, Nektar::SolverUtils::FrameTransform::SetAngle(), SolveBodyMotion(), and UpdateRotMat().

Referenced by v_PreApply().

◆ UpdateBoundaryConditions()

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

private

Set velocity boundary condition at the next time step.

Definition at line 741 of file ForcingMovingReferenceFrame.cpp.

{
    time += m_timestep;
    // compute the velocities whose functions are provided in inertial frame
    for (auto it : m_frameVelFunction)
    {
        if (it.first < 3)
        {
            m_velXYZ[it.first] = it.second->Evaluate(0., 0., 0., time);
        }
        else
        {
            m_omegaXYZ[it.first - 3] = it.second->Evaluate(0., 0., 0., time);
        }
    }
    for (auto it : m_extForceFunction)
    {
        m_extForceXYZ[it.first] = it.second->Evaluate(0., 0., 0., time);
    }
    std::map<int, NekDouble> Dirs; // prescribed Motion
    for (auto it : m_DirDoFs)
    {
        if (it < m_spacedim)
        {
            Dirs[it] = m_velXYZ[it];
        }
        else if (it == m_spacedim)
        {
            Dirs[it] = m_omegaXYZ[2];
        }
    }
 
    auto equ = m_equ.lock();
    ASSERTL0(equ, "Weak pointer to the equation system is expired");
    auto FluidEq = std::dynamic_pointer_cast<FluidInterface>(equ);
    Array<OneD, NekDouble> forcebody(6, 0.); // fluid force
    FluidEq->GetAeroForce(forcebody);
 
    Array<OneD, Array<OneD, NekDouble>> bodyVel(m_bodyVel.size());
    for (size_t i = 0; i < m_bodyVel.size(); ++i)
    {
        bodyVel[i] = Array<OneD, NekDouble>(m_bodyVel[i].size());
    }
    // copy initial condition
    for (size_t i = 0; i < m_bodyVel.size(); ++i)
    {
        Vmath::Vcopy(m_bodyVel[i].size(), m_bodyVel[i], 1, bodyVel[i], 1);
    }
    SolveBodyMotion(bodyVel, forcebody, Dirs);
    // to stablize the velocity bcs, use the old values if extrapolation is
    // involved
    for (size_t i = 0; i < bodyVel[0].size(); ++i)
    {
        if (Dirs.find(i) == Dirs.end())
        {
            for (size_t k = 0; k < bodyVel.size(); ++k)
            {
                bodyVel[k][i] = m_bodyVel[k][i];
            }
        }
    }
    // set displacements at the next time step
    for (int i = 0; i < m_spacedim; ++i)
    {
        m_disp[i] = bodyVel[0][i] + m_travelWave[i] * time;
    }
    m_disp[5] = bodyVel[0][m_spacedim];
    // copy the velocities and rotation matrix for enforcing bc
    // copy linear and angular velocities and accelerations
    Array<OneD, NekDouble> vel(12, 0.0), tmp;
    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];
    if (m_hasRotation)
    {
        UpdateRotMat();
        m_frame.SetAngle(m_disp + 3);
        m_frame.IneritalToBody(3, vel, vel);
        m_frame.IneritalToBody(3, tmp = vel + 6, vel + 6);
    }
 
    // to set the boundary condition of the next time step
    // update the frame velocities
    FluidEq->SetMovingFrameVelocities(vel);
    // update the projection matrix
    FluidEq->SetMovingFrameProjectionMat(m_ProjMatZ);
    // update the frame angle (with respect to the inertial frame)
    // this angle is used to update the meta data,
    // on the other hand, for boundary conditions the projection matrix is used
    FluidEq->SetMovingFrameDisp(m_disp);
}

References ASSERTL0, Nektar::SolverUtils::FrameTransform::IneritalToBody(), m_bodyVel, m_DirDoFs, m_disp, Nektar::SolverUtils::Forcing::m_equ, m_extForceFunction, m_extForceXYZ, m_frame, m_frameVelFunction, m_hasRotation, m_omegaXYZ, m_ProjMatZ, m_spacedim, m_timestep, m_travelWave, m_velXYZ, Nektar::SolverUtils::FrameTransform::SetAngle(), SolveBodyMotion(), UpdateRotMat(), and Vmath::Vcopy().

Referenced by v_Apply().

◆ UpdateRotMat()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::UpdateRotMat ( )

private

Definition at line 702 of file ForcingMovingReferenceFrame.cpp.

{
    // update the rotation matrix
    NekDouble sn, cs;
    sn = sin(m_disp[5]);
    cs = cos(m_disp[5]);
 
    m_ProjMatZ(0, 0) = cs;
    m_ProjMatZ(0, 1) = sn;
    m_ProjMatZ(1, 0) = -sn;
    m_ProjMatZ(1, 1) = cs;
    m_ProjMatZ(2, 2) = 1.0;
}

References m_disp, and m_ProjMatZ.

Referenced by Update(), and UpdateBoundaryConditions().

◆ 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 723 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 87 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;
    }
 
    int npoints   = pFields[0]->GetNpoints();
    m_expdim      = m_isH2d ? 1 : pFields[0]->GetGraph()->GetMeshDimension();
    m_spacedim    = m_expdim + (m_isH1d ? 1 : 0) + (m_isH2d ? 2 : 0);
    m_NumVariable = m_spacedim;
 
    m_hasPlane0 = true;
    if (m_isH1d)
    {
        m_hasPlane0 = pFields[0]->GetZIDs()[0] == 0;
    }
 
    // initialize variables
    m_velXYZ      = Array<OneD, NekDouble>(3, 0.0);
    m_velxyz      = Array<OneD, NekDouble>(3, 0.0);
    m_omegaXYZ    = Array<OneD, NekDouble>(3, 0.0);
    m_omegaxyz    = Array<OneD, NekDouble>(3, 0.0);
    m_extForceXYZ = Array<OneD, NekDouble>(6, 0.0);
    m_hasVel      = Array<OneD, bool>(3, false);
    m_hasOmega    = Array<OneD, bool>(3, false);
    m_disp        = Array<OneD, NekDouble>(9, 0.0);
    m_pivotPoint  = Array<OneD, NekDouble>(3, 0.0);
    m_travelWave  = Array<OneD, NekDouble>(3, 0.);
 
    // initialize time
    NekDouble time = 0.;
    CheckForRestartTime(pFields, time);
    m_startTime = time;
    // load moving frame infomation
    LoadParameters(pForce, time);
    if (m_hasRotation)
    {
        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);
        }
    }
 
    // init body solver
    m_rank = pFields[0]->GetComm()->GetRank();
    InitBodySolver(pForce, m_spacedim, m_rank, time);
 
    // Initialize theta with the data from NS class
    // This ensure correct moving coordinate orientation with respect to the
    // stationary inertial frame when we restart the simulation
    auto equ = m_equ.lock();
    ASSERTL0(equ, "Weak pointer to the equation system is expired");
    auto FluidEq = std::dynamic_pointer_cast<FluidInterface>(equ);
    FluidEq->SetMovingFrameDisp(m_disp);
 
    // initiate the rotation matrix to zero,
    // Note that the rotation matrix is assumed for the rotation around z axis
    // TODO: Generalize this for the 3D case with possiblity of rotation around
    // each of axis. Probabley we only can support rotation around one axis. In
    // that case the generalization means the user can provide Omega for one of
    // x, y or z axis. Not sure how complicated to consider a general axis of
    // rotation
    //
    // Note that these rotation matrices should be extrinsic rotations
    m_ProjMatZ = bn::ublas::zero_matrix<NekDouble>(3, 3);
    // populate the rotation matrix R(z)
    {
        NekDouble sn, cs;
        sn = sin(m_disp[5]);
        cs = cos(m_disp[5]);
 
        m_ProjMatZ(0, 0) = cs;
        m_ProjMatZ(0, 1) = sn;
        m_ProjMatZ(1, 0) = -1. * sn;
        m_ProjMatZ(1, 1) = cs;
        m_ProjMatZ(2, 2) = 1.0;
    }
    // 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;
        }
    }
    // initialize aeroforce filter
    if (m_hasFreeMotion)
    {
        InitialiseFilter(m_session, pFields, pForce);
    }
}

References ASSERTL0, CheckForRestartTime(), InitBodySolver(), InitialiseFilter(), LoadParameters(), m_coords, m_disp, Nektar::SolverUtils::Forcing::m_equ, m_expdim, m_extForceXYZ, m_hasFreeMotion, m_hasOmega, m_hasPlane0, m_hasRotation, m_hasVel, m_isH1d, m_isH2d, Nektar::SolverUtils::Forcing::m_NumVariable, m_omegaXYZ, m_omegaxyz, m_pivotPoint, m_ProjMatZ, m_rank, Nektar::SolverUtils::Forcing::m_session, m_spacedim, m_startTime, m_travelWave, m_velXYZ, 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

Reimplemented from Nektar::SolverUtils::Forcing.

Definition at line 892 of file ForcingMovingReferenceFrame.cpp.

{
    Update(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(), Update(), Vmath::Vadd(), and Vmath::Vcopy().

Friends And Related Function Documentation

◆ MemoryManager< ForcingMovingReferenceFrame >

friend class MemoryManager< ForcingMovingReferenceFrame >

friend

Definition at line 97 of file ForcingMovingReferenceFrame.h.

Member Data Documentation

◆ classNameBody

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

static

Initial value:

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

Name of the class.

Definition at line 121 of file ForcingMovingReferenceFrame.h.

◆ m_aeroforceFilter

FilterAeroForcesSharedPtr Nektar::SolverUtils::ForcingMovingReferenceFrame::m_aeroforceFilter

private

Definition at line 200 of file ForcingMovingReferenceFrame.h.

Referenced by InitialiseFilter(), and Update().

◆ m_bodySolver

Newmark_BetaSolver Nektar::SolverUtils::ForcingMovingReferenceFrame::m_bodySolver

private

Definition at line 197 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), and SolveBodyMotion().

◆ m_bodyVel

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

private

Definition at line 198 of file ForcingMovingReferenceFrame.h.

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

◆ m_coords

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

private

Definition at line 174 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_DirDoFs

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

private

Definition at line 199 of file ForcingMovingReferenceFrame.h.

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

◆ m_disp

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

private

Definition at line 179 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), LoadParameters(), Update(), UpdateBoundaryConditions(), UpdateRotMat(), and v_InitObject().

◆ m_expdim

NekInt Nektar::SolverUtils::ForcingMovingReferenceFrame::m_expdim

private

Definition at line 194 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), and v_InitObject().

◆ m_extForceFunction

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

private

Definition at line 151 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), Update(), and UpdateBoundaryConditions().

◆ m_extForceXYZ

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

private

Definition at line 176 of file ForcingMovingReferenceFrame.h.

Referenced by SolveBodyMotion(), Update(), UpdateBoundaryConditions(), and v_InitObject().

◆ m_frame

FrameTransform Nektar::SolverUtils::ForcingMovingReferenceFrame::m_frame

private

Definition at line 147 of file ForcingMovingReferenceFrame.h.

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

◆ m_frameVelFunction

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

private

Definition at line 150 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), LoadParameters(), Update(), and UpdateBoundaryConditions().

◆ m_hasFreeMotion

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasFreeMotion

private

Definition at line 192 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), Update(), and v_InitObject().

◆ m_hasOmega

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

private

Definition at line 160 of file ForcingMovingReferenceFrame.h.

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

◆ m_hasPlane0

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasPlane0

private

Definition at line 190 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_hasRotation

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasRotation

private

Definition at line 188 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), SolveBodyMotion(), Update(), UpdateBoundaryConditions(), v_Apply(), v_InitObject(), and v_PreApply().

◆ m_hasVel

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

private

Definition at line 159 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 195 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), and Update().

◆ m_isH1d

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_isH1d

private

Definition at line 189 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_isH2d

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_isH2d

private

Definition at line 191 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

◆ m_omegaXYZ

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

private

Definition at line 169 of file ForcingMovingReferenceFrame.h.

Referenced by Update(), UpdateBoundaryConditions(), and v_InitObject().

◆ m_omegaxyz

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

private

Definition at line 172 of file ForcingMovingReferenceFrame.h.

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

◆ m_outputFrequency

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

private

Definition at line 196 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), and Update().

◆ m_outputStream

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

private

Definition at line 152 of file ForcingMovingReferenceFrame.h.

Referenced by InitBodySolver(), Update(), and ~ForcingMovingReferenceFrame().

◆ m_pivotPoint

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

private

Definition at line 145 of file ForcingMovingReferenceFrame.h.

Referenced by LoadParameters(), and v_InitObject().

◆ m_ProjMatZ

bn::ublas::matrix<NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_ProjMatZ

private

Definition at line 183 of file ForcingMovingReferenceFrame.h.

Referenced by UpdateBoundaryConditions(), UpdateRotMat(), and v_InitObject().

◆ m_rank

int Nektar::SolverUtils::ForcingMovingReferenceFrame::m_rank

private

Definition at line 153 of file ForcingMovingReferenceFrame.h.

Referenced by Update(), v_InitObject(), and ~ForcingMovingReferenceFrame().

◆ m_spacedim

NekInt Nektar::SolverUtils::ForcingMovingReferenceFrame::m_spacedim

private

Definition at line 193 of file ForcingMovingReferenceFrame.h.

Referenced by addRotation(), InitBodySolver(), LoadParameters(), SolveBodyMotion(), Update(), UpdateBoundaryConditions(), v_InitObject(), and v_PreApply().

◆ m_startTime

NekDouble Nektar::SolverUtils::ForcingMovingReferenceFrame::m_startTime

private

Definition at line 185 of file ForcingMovingReferenceFrame.h.

Referenced by Update(), and v_InitObject().

◆ m_timestep

NekDouble Nektar::SolverUtils::ForcingMovingReferenceFrame::m_timestep

private

Definition at line 186 of file ForcingMovingReferenceFrame.h.

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

◆ m_travelWave

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

private

Definition at line 146 of file ForcingMovingReferenceFrame.h.

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

◆ m_velXYZ

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

private

Definition at line 163 of file ForcingMovingReferenceFrame.h.

Referenced by Update(), UpdateBoundaryConditions(), and v_InitObject().

◆ m_velxyz

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

private

Definition at line 166 of file ForcingMovingReferenceFrame.h.

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

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

◆ CheckForRestartTime()

◆ create()

◆ EvaluateExpression()

◆ InitBodySolver()

◆ InitialiseFilter()

◆ LoadParameters()

◆ SolveBodyMotion()

◆ Update()

◆ UpdateBoundaryConditions()

◆ UpdateRotMat()

◆ v_Apply()

◆ v_InitObject()

◆ v_PreApply()

Friends And Related Function Documentation

◆ MemoryManager< ForcingMovingReferenceFrame >

Member Data Documentation

◆ classNameBody

◆ m_aeroforceFilter

◆ m_bodySolver

◆ m_bodyVel

◆ m_coords

◆ m_DirDoFs

◆ m_disp

◆ m_expdim

◆ m_extForceFunction

◆ m_extForceXYZ

◆ m_frame

◆ m_frameVelFunction

◆ m_hasFreeMotion

◆ m_hasOmega

◆ m_hasPlane0

◆ m_hasRotation

◆ m_hasVel

◆ m_index

◆ m_isH1d

◆ m_isH2d

◆ m_omegaXYZ

◆ m_omegaxyz

◆ m_outputFrequency

◆ m_outputStream

◆ m_pivotPoint

◆ m_ProjMatZ

◆ m_rank

◆ m_spacedim

◆ m_startTime

◆ m_timestep

◆ m_travelWave

◆ m_velXYZ

◆ m_velxyz