Nektar::SolverUtils::ForcingMovingReferenceFrame Class Reference

#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
virtual 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...
virtual SOLVER_UTILS_EXPORT void	v_Apply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time) override
	Adds the body force, -Omega X u. More...
virtual SOLVER_UTILS_EXPORT void	v_PreApply (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble &time) 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)
virtual	~ForcingMovingReferenceFrame (void)
void	Update (const NekDouble &time)
	Updates the forcing array with the current required forcing. More...
void	UpdateTheta (const NekDouble &time)
void	CheckForRestartTheta (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, Array< OneD, NekDouble > &theta)
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...

Private Attributes
std::string	m_funcName
std::string	m_velFuncName
std::string	m_omegaFuncName
std::map< int, LibUtilities::EquationSharedPtr >	m_frameFunction
std::map< int, LibUtilities::EquationSharedPtr >	m_velFunction
std::map< int, LibUtilities::EquationSharedPtr >	m_omegaFunction
std::map< int, bool >	m_hasVel
std::map< int, bool >	m_hasOmega
std::map< int, NekDouble >	m_velXYZ
std::map< int, NekDouble >	m_velxyz
std::map< int, NekDouble >	m_omegaXYZ
std::map< int, NekDouble >	m_omegaxyz
Array< OneD, Array< OneD, NekDouble > >	m_coords
Array< OneD, NekDouble >	m_pivotPoint
Array< OneD, NekDouble >	m_theta
bn::ublas::matrix< NekDouble >	m_ProjMatX
bn::ublas::matrix< NekDouble >	m_ProjMatY
bn::ublas::matrix< NekDouble >	m_ProjMatZ
bool	m_hasRotation
bool	m_isH1d
bool	m_hasPlane0
bool	m_isH2d
NekInt	m_spacedim

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

    : Forcing(pSession, pEquation)
{
}

~ForcingMovingReferenceFrame()

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

inlineprivatevirtual

Definition at line 156 of file ForcingMovingReferenceFrame.h.

{};

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

CheckForRestartTheta()

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

private

Definition at line 542 of file ForcingMovingReferenceFrame.cpp.

{
    std::map<std::string, std::string> fieldMetaDataMap;
 
    // initialize theta to zero
    for (auto &t : theta)
    {
        t = 0.0;
    }
 
    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 theta is defined
                if (fieldMetaDataMap != LibUtilities::NullFieldMetaDataMap)
                {
                    std::vector<std::string> vSuffix = {"_x", "_y", "_z"};
 
                    for (int j = 0; j < 3; ++j)
                    {
                        std::string sTheta = "Theta" + vSuffix[j];
                        auto iter          = fieldMetaDataMap.find(sTheta);
                        if (iter != fieldMetaDataMap.end())
                        {
                            theta[j] =
                                boost::lexical_cast<NekDouble>(iter->second);
                        }
                    }
 
                    break;
                }
 
                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 67 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.

Update()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::Update ( const NekDouble &  time )

private

Updates the forcing array with the current required forcing.

Parameters

pFields
time

Definition at line 297 of file ForcingMovingReferenceFrame.cpp.

{
    // compute the velociites whos functions are provided in inertial frame
    for (auto it : m_velFunction)
    {
        m_velXYZ[it.first] = it.second->Evaluate(0., 0., 0., time);
    }
    for (auto it : m_omegaFunction)
    {
        m_omegaXYZ[it.first] = it.second->Evaluate(0., 0., 0., time);
    }
    // include the effect of rotation
    if (m_hasRotation)
    {
        UpdateTheta(time);
 
        // transform the translation velocities to the moving frame
        bn::ublas::vector<NekDouble> v0 = bn::ublas::zero_vector<NekDouble>(3);
        bn::ublas::vector<NekDouble> v1 = bn::ublas::zero_vector<NekDouble>(3);
        for (int i = 0; i < m_spacedim; ++i)
        {
            v0(i) = m_velXYZ[i];
        }
        v1 = bn::ublas::prec_prod(m_ProjMatZ, v0);
        for (int i = 0; i < 3; ++i)
        {
            m_velxyz[i] = v1(i);
        }
 
        // transform the angular velocities to moving frame
        v0 = bn::ublas::zero_vector<NekDouble>(3);
        v1 = bn::ublas::zero_vector<NekDouble>(3);
        for (auto it : m_omegaXYZ)
        {
            v0(it.first) = it.second;
        }
        v1 = bn::ublas::prec_prod(m_ProjMatZ, v0);
        for (int i = 0; i < 3; ++i)
        {
            m_omegaxyz[i] = v1(i);
        }
    }
    else
    {
        // for translation only,
        for (int i = 0; i < m_spacedim; ++i)
        {
            m_velxyz[i] = m_velXYZ[i];
        }
    }
 
    // set the velocities and rotation matrix for enforcement of boundary
    // conditions in the Incompressible Naveri-Stokes
    Array<OneD, NekDouble> vel(6, 0.0);
    // save the linear and angular velocities to be used in enforcing bc
    for (int i = 0; i < 3; ++i)
    {
        vel[i]     = m_velxyz[i];
        vel[i + 3] = m_omegaxyz[i];
    }
 
    auto equ = m_equ.lock();
    ASSERTL0(equ, "Weak pointer to the equation system is expired");
    auto FluidEq = std::dynamic_pointer_cast<FluidInterface>(equ);
    // 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->SetMovingFrameAngles(m_theta);
}

References ASSERTL0, Nektar::SolverUtils::Forcing::m_equ, m_hasRotation, m_omegaFunction, m_omegaXYZ, m_omegaxyz, m_ProjMatZ, m_spacedim, m_theta, m_velFunction, m_velXYZ, m_velxyz, and UpdateTheta().

Referenced by v_PreApply().

UpdateTheta()

void Nektar::SolverUtils::ForcingMovingReferenceFrame::UpdateTheta ( const NekDouble &  time )

private

Definition at line 371 of file ForcingMovingReferenceFrame.cpp.

{
 
    NekDouble dt = m_session->GetParameter("TimeStep");
    NekDouble t1 = time + dt;
    std::map<int, NekDouble> Omega;
 
    // Calculate angular velocities at dt
    // TODO: Generalize to the case with a general 3D rotation support
    for (int i = 0; i < 3; ++i)
    {
        if (m_hasOmega[i])
        {
            Omega[i] = 0.5 * (m_omegaXYZ[i] +
                              m_omegaFunction[i]->Evaluate(0., 0., 0., t1));
        }
    }
 
    // Using the Omega_z
    m_theta[2] += (Omega[2] * dt);
 
    // update the rotation matrix
    {
        NekDouble sn, cs;
        sn = sin(m_theta[2]);
        cs = cos(m_theta[2]);
 
        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_hasOmega, m_omegaFunction, m_omegaXYZ, m_ProjMatZ, Nektar::SolverUtils::Forcing::m_session, m_theta, and Omega.

Referenced by Update().

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

{
    boost::ignore_unused(time);
    // If there is no rotation, body force is zero,
    // nothing needs to be done here.
    if (!m_hasRotation)
    {
        return;
    }
    // frame velocities are already updated in pre_Apply
    int npoints = fields[0]->GetNpoints();
    boost::ignore_unused(npoints);
    addRotation(npoints, outarray, -1., inarray, outarray);
}

References addRotation(), and m_hasRotation.

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

{
    boost::ignore_unused(pNumForcingFields);
    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();
    int expdim    = m_isH2d ? 1 : pFields[0]->GetGraph()->GetMeshDimension();
    m_spacedim    = 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;
    }
 
    // linear velocities
    const TiXmlElement *funcNameElmt;
 
    funcNameElmt = pForce->FirstChildElement("LinearVelocity");
    ASSERTL0(funcNameElmt, "Requires LinearVelocity tag specifying function "
                           "name which prescribes velocity of the moving "
                           "frame.");
 
    m_velFuncName = funcNameElmt->GetText();
    ASSERTL0(m_session->DefinesFunction(m_velFuncName),
             "Function '" + m_velFuncName + "' is not defined in the session.");
 
    // angular velocities
    // Initiate the rotation to false, will be updated later if rotation defined
    m_hasRotation = false;
    funcNameElmt  = pForce->FirstChildElement("AngularVelocity");
    if (funcNameElmt)
    {
        m_omegaFuncName = funcNameElmt->GetText();
        ASSERTL0(m_session->DefinesFunction(m_omegaFuncName),
                 "Function '" + m_omegaFuncName +
                     "' is not defined in the session.");
        m_hasRotation = true;
    }
 
    // initiate the linear velocity values in both local and inertial frames
    for (int i = 0; i < 3; ++i)
    {
        m_velXYZ[i] = 0.;
        m_velxyz[i] = 0.;
    }
 
    // initiate the angular velocity values in both local and inertial frames
    for (int i = 0; i < 3; ++i)
    {
        m_omegaXYZ[i] = 0;
        m_omegaxyz[i] = 0;
    }
 
    // initiate the available frame velocities all to false
    // this will be updated after reading the frame velocities and checking
    // for the rotation
    for (int i = 0; i < 3; ++i)
    {
        m_hasVel[i]   = false;
        m_hasOmega[i] = false;
    }
 
    // initiate the rotation angle to zero
    // m_theta = {theta_X, theta_Y, theta_Z}
    m_theta = Array<OneD, NekDouble>(3, 0.0);
 
    // initialize theta from the metadata of restart file or zero
    CheckForRestartTheta(pFields, m_theta);
 
    // 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);
    // Set the angles
    FluidEq->SetMovingFrameAngles(m_theta);
 
    // 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_ProjMatX = bn::ublas::zero_matrix<NekDouble>(3, 3);
    m_ProjMatY = bn::ublas::zero_matrix<NekDouble>(3, 3);
    m_ProjMatZ = bn::ublas::zero_matrix<NekDouble>(3, 3);
    // populate the rotation matrix R(z)
    {
        NekDouble sn, cs;
        sn = sin(m_theta[2]);
        cs = cos(m_theta[2]);
 
        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;
    }
 
    // frame linear velocity
    for (int i = 0; i < m_spacedim; ++i)
    {
        std::string s_FieldStr = m_session->GetVariable(i);
 
        if (m_session->DefinesFunction(m_velFuncName, s_FieldStr))
        {
            m_velFunction[i] =
                m_session->GetFunction(m_velFuncName, s_FieldStr);
            m_hasVel[i] = true;
        }
    }
    if (expdim == 1)
    {
        return;
    }
 
    // initialize the poivot coordinate with a default at origin
    m_pivotPoint = Array<OneD, NekDouble>(3, 0.0);
    if (m_hasRotation)
    {
        // frame angular velocity
        std::vector<std::string> angularVar = {"Omega_x", "Omega_y", "Omega_z"};
        for (int i = 0; i < 3; ++i)
        {
            std::string s_FieldStr = angularVar[i];
            if (m_session->DefinesFunction(m_omegaFuncName, s_FieldStr))
            {
                // m_hasRotation = true;
                m_omegaFunction[i] =
                    m_session->GetFunction(m_omegaFuncName, s_FieldStr);
                m_hasOmega[i] = true;
                // m_hasVel[m_spacedim+i]=true;
            }
        }
 
        // for now only support Omega_z
        // TODO: add the support for general rotation
        for (int i = 0; i < 2; ++i)
        {
            ASSERTL0(!m_hasOmega[i], "Currently only Omega_z is supported");
        }
 
        // Reading the pivot point coordinate for rotation
        const TiXmlElement *pivotElmt = pForce->FirstChildElement("PivotPoint");
        // if not defined, zero would be the default
        if (pivotElmt)
        {
            std::stringstream pivotPointStream;
            std::string pivotPointStr = pivotElmt->GetText();
            pivotPointStream.str(pivotPointStr);
 
            for (int j = 0; j < m_spacedim; ++j)
            {
                pivotPointStream >> pivotPointStr;
                if (!pivotPointStr.empty())
                {
                    LibUtilities::Equation equ(m_session->GetInterpreter(),
                                               pivotPointStr);
                    m_pivotPoint[j] = equ.Evaluate();
                }
            }
        }
 
        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);
        }
 
        // 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;
            }
        }
    }
}

References ASSERTL0, CheckForRestartTheta(), Nektar::LibUtilities::Equation::Evaluate(), m_coords, Nektar::SolverUtils::Forcing::m_equ, m_hasOmega, m_hasPlane0, m_hasRotation, m_hasVel, m_isH1d, m_isH2d, Nektar::SolverUtils::Forcing::m_NumVariable, m_omegaFuncName, m_omegaFunction, m_omegaXYZ, m_omegaxyz, m_pivotPoint, m_ProjMatX, m_ProjMatY, m_ProjMatZ, Nektar::SolverUtils::Forcing::m_session, m_spacedim, m_theta, m_velFuncName, m_velFunction, 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 486 of file ForcingMovingReferenceFrame.cpp.

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

Friends And Related Function Documentation

MemoryManager< ForcingMovingReferenceFrame >

friend class MemoryManager< ForcingMovingReferenceFrame >

friend

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

m_coords

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

private

Definition at line 132 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

m_frameFunction

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

private

Definition at line 109 of file ForcingMovingReferenceFrame.h.

m_funcName

std::string Nektar::SolverUtils::ForcingMovingReferenceFrame::m_funcName

private

Definition at line 104 of file ForcingMovingReferenceFrame.h.

m_hasOmega

std::map<int, bool> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasOmega

private

Definition at line 118 of file ForcingMovingReferenceFrame.h.

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

m_hasPlane0

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasPlane0

private

Definition at line 148 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

m_hasRotation

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasRotation

private

Definition at line 146 of file ForcingMovingReferenceFrame.h.

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

m_hasVel

std::map<int, bool> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_hasVel

private

Definition at line 117 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

m_isH1d

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_isH1d

private

Definition at line 147 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

m_isH2d

bool Nektar::SolverUtils::ForcingMovingReferenceFrame::m_isH2d

private

Definition at line 149 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject(), and v_PreApply().

m_omegaFuncName

std::string Nektar::SolverUtils::ForcingMovingReferenceFrame::m_omegaFuncName

private

Definition at line 106 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject().

m_omegaFunction

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

private

Definition at line 111 of file ForcingMovingReferenceFrame.h.

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

m_omegaXYZ

std::map<int, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_omegaXYZ

private

Definition at line 127 of file ForcingMovingReferenceFrame.h.

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

m_omegaxyz

std::map<int, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_omegaxyz

private

Definition at line 130 of file ForcingMovingReferenceFrame.h.

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

m_pivotPoint

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

private

Definition at line 135 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject().

m_ProjMatX

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

private

Definition at line 142 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject().

m_ProjMatY

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

private

Definition at line 143 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject().

m_ProjMatZ

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

private

Definition at line 144 of file ForcingMovingReferenceFrame.h.

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

m_spacedim

NekInt Nektar::SolverUtils::ForcingMovingReferenceFrame::m_spacedim

private

Definition at line 150 of file ForcingMovingReferenceFrame.h.

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

m_theta

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

private

Definition at line 138 of file ForcingMovingReferenceFrame.h.

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

m_velFuncName

std::string Nektar::SolverUtils::ForcingMovingReferenceFrame::m_velFuncName

private

Definition at line 105 of file ForcingMovingReferenceFrame.h.

Referenced by v_InitObject().

m_velFunction

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

private

Definition at line 110 of file ForcingMovingReferenceFrame.h.

Referenced by Update(), and v_InitObject().

m_velXYZ

std::map<int, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_velXYZ

private

Definition at line 121 of file ForcingMovingReferenceFrame.h.

Referenced by Update(), and v_InitObject().

m_velxyz

std::map<int, NekDouble> Nektar::SolverUtils::ForcingMovingReferenceFrame::m_velxyz

private

Definition at line 124 of file ForcingMovingReferenceFrame.h.

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