Nektar++
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
Nektar::SmoothedProfileMethod Class Reference

#include <SmoothedProfileMethod.h>

Inheritance diagram for Nektar::SmoothedProfileMethod:
[legend]

Public Member Functions

 SmoothedProfileMethod (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Construct a new Smoothed Profile Method object. More...
 
virtual ~SmoothedProfileMethod ()
 Destroy the Smoothed Profile Method object. More...
 
virtual void v_InitObject (bool DeclareField=true)
 Init object for UnsteadySystem class. More...
 
virtual void v_GenerateSummary (SolverUtils::SummaryList &s)
 Generates the summary of the current simulation. More...
 
void SolveUnsteadyStokesSystem (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time, const NekDouble a_iixDt)
 
- Public Member Functions inherited from Nektar::VelocityCorrectionScheme
 VelocityCorrectionScheme (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Constructor. More...
 
virtual ~VelocityCorrectionScheme ()
 
void SetUpPressureForcing (const Array< OneD, const Array< OneD, NekDouble >> &fields, Array< OneD, Array< OneD, NekDouble >> &Forcing, const NekDouble aii_Dt)
 
void SetUpViscousForcing (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &Forcing, const NekDouble aii_Dt)
 
void SolvePressure (const Array< OneD, NekDouble > &Forcing)
 
void SolveViscous (const Array< OneD, const Array< OneD, NekDouble >> &Forcing, const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble aii_Dt)
 
void SolveUnsteadyStokesSystem (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time, const NekDouble a_iixDt)
 
void EvaluateAdvection_SetPressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)
 
- Public Member Functions inherited from Nektar::IncNavierStokes
virtual ~IncNavierStokes ()
 
int GetNConvectiveFields (void)
 
Array< OneD, int > & GetVelocity (void)
 
void AddForcing (const SolverUtils::ForcingSharedPtr &pForce)
 
virtual void GetPressure (const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, NekDouble > &pressure) override
 Extract array with pressure from physfield. More...
 
virtual void GetDensity (const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, NekDouble > &density) override
 Extract array with density from physfield. More...
 
virtual bool HasConstantDensity () override
 
virtual void GetVelocity (const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &velocity) override
 Extract array with velocity from physfield. More...
 
virtual void SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels) override
 
virtual void GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels) override
 
virtual void SetMovingFrameAngles (const Array< OneD, NekDouble > &vFrameTheta) override
 
virtual void GetMovingFrameAngles (Array< OneD, NekDouble > &vFrameTheta) override
 
virtual void SetMovingFrameProjectionMat (const bnu::matrix< NekDouble > &vProjMat) override
 
virtual void GetMovingFrameProjectionMat (bnu::matrix< NekDouble > &vProjMat) override
 
virtual bool DefinedForcing (const std::string &sForce)
 
virtual void GetPivotPoint (Array< OneD, NekDouble > &vPivotPoint)
 
- Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
virtual SOLVER_UTILS_EXPORT ~AdvectionSystem ()
 
SOLVER_UTILS_EXPORT AdvectionSharedPtr GetAdvObject ()
 Returns the advection object held by this instance. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleGetElmtCFLVals (const bool FlagAcousticCFL=true)
 
SOLVER_UTILS_EXPORT NekDouble GetCFLEstimate (int &elmtid)
 
- Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
virtual SOLVER_UTILS_EXPORT ~UnsteadySystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble >> &inarray)
 Calculate the larger time-step mantaining the problem stable. More...
 
SOLVER_UTILS_EXPORT void SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void SetUpTraceNormals (void)
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise ()
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
std::shared_ptr< T > as ()
 
SOLVER_UTILS_EXPORT void ResetSessionName (std::string newname)
 Reset Session name. More...
 
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr GetSession ()
 Get Session name. More...
 
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr GetPressure ()
 Get pressure field if available. More...
 
SOLVER_UTILS_EXPORT void ExtraFldOutput (std::vector< Array< OneD, NekDouble >> &fieldcoeffs, std::vector< std::string > &variables)
 
SOLVER_UTILS_EXPORT void PrintSummary (std::ostream &out)
 Print a summary of parameters and solver characteristics. More...
 
SOLVER_UTILS_EXPORT void SetLambda (NekDouble lambda)
 Set parameter m_lambda. More...
 
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name. More...
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields. More...
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the L2 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n)
 Write checkpoint file of m_fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble >> &fieldcoeffs, std::vector< std::string > &variables)
 Write checkpoint file of custom data fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_BaseFlow (const int n)
 Write base flow file of m_fields. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname)
 Write field data to the given filename. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble >> &fieldcoeffs, std::vector< std::string > &variables)
 Write input fields to the given filename. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
 Input field data from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
 Input field data from the given file to multiple domains. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble >> &coeffs)
 Output a field. Input field data into array from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
 Output a field. Input field data into ExpList from the given file. More...
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMapUpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetFinalTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const std::string GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
SOLVER_UTILS_EXPORT int GetCheckpointNumber ()
 
SOLVER_UTILS_EXPORT void SetCheckpointNumber (int num)
 
SOLVER_UTILS_EXPORT int GetCheckpointSteps ()
 
SOLVER_UTILS_EXPORT void SetCheckpointSteps (int num)
 
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp ()
 Virtual function to identify if operator is negated in DoSolve. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual ~FluidInterface ()=default
 
virtual SOLVER_UTILS_EXPORT void SetMovingFrameProjectionMat (const boost::numeric::ublas::matrix< NekDouble > &vProjMat)
 
virtual SOLVER_UTILS_EXPORT void GetMovingFrameProjectionMat (boost::numeric::ublas::matrix< NekDouble > &vProjMat)
 

Static Public Member Functions

static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Creates an instance of this class. More...
 
- Static Public Member Functions inherited from Nektar::VelocityCorrectionScheme
static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Creates an instance of this class. More...
 

Static Public Attributes

static std::string className
 Name of class. More...
 
- Static Public Attributes inherited from Nektar::VelocityCorrectionScheme
static std::string className
 Name of class. More...
 
- Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
static std::string cmdSetStartTime
 
static std::string cmdSetStartChkNum
 

Protected Member Functions

virtual void v_SolveUnsteadyStokesSystem (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, NekDouble time, NekDouble a_iixDt)
 Linear terms due to pressure and visosity are calculated here. After solving the velocity filed without taking into account the immersed boundaries, a new correction is applied through the force \(f_s\): More...
 
void SetUpCorrectionPressure (const Array< OneD, const Array< OneD, NekDouble >> &fields, Array< OneD, Array< OneD, NekDouble >> &Forcing)
 Sets the forcing term of the equation for the correction pressure \(p_p\): More...
 
void SolveCorrectionPressure (const Array< OneD, NekDouble > &Forcing)
 Solves the Poisson equation for the correction pressure \(p_p\): More...
 
void SolveCorrectedVelocity (Array< OneD, Array< OneD, NekDouble >> &Forcing, Array< OneD, Array< OneD, NekDouble >> &fields, NekDouble dt)
 Corrects the velocity field so that the IBs are taken into account. Solves the explicit equation: More...
 
void SetCorrectionPressureBCs ()
 Updates the BCs for boundaries with Neumann or periodic BCs in the pressure: More...
 
void UpdatePhiUp (NekDouble time)
 Calculates the values of the shape function. More...
 
void UpdateForcing (const Array< OneD, const Array< OneD, NekDouble >> &fields, NekDouble dt)
 For a body with a velocity \(\mathbf{u_p}\), the force \(\mathbf{f_s}\) applied to the fluid ensures that the IBC are met: More...
 
bool GetVarTimeDependence (std::string funcName, std::string attrName)
 True if the function is timedependent, false otherwise. More...
 
TiXmlElement * GetFunctionHdl (std::string functionName)
 Returns a handle to the requested function. Returns NULL if it does not exist. More...
 
void ReadPhi ()
 
template<typename T >
void SetUpExpansions (int nvel)
 Initialises the expansions for the intermediate pressure, the 'Phi' function and the IB forcing. More...
 
- Protected Member Functions inherited from Nektar::VelocityCorrectionScheme
void SetupFlowrate (NekDouble aii_dt)
 Set up the Stokes solution used to impose constant flowrate through a boundary. More...
 
NekDouble MeasureFlowrate (const Array< OneD, Array< OneD, NekDouble >> &inarray)
 Measure the volumetric flow rate through the volumetric flow rate reference surface. More...
 
virtual bool v_PostIntegrate (int step)
 
virtual void v_TransCoeffToPhys (void)
 Virtual function for transformation to physical space. More...
 
virtual void v_TransPhysToCoeff (void)
 Virtual function for transformation to coefficient space. More...
 
virtual void v_DoInitialise (void)
 Sets up initial conditions. More...
 
virtual Array< OneD, bool > v_GetSystemSingularChecks ()
 
virtual int v_GetForceDimension ()
 
virtual void v_SetUpPressureForcing (const Array< OneD, const Array< OneD, NekDouble >> &fields, Array< OneD, Array< OneD, NekDouble >> &Forcing, const NekDouble aii_Dt)
 
virtual void v_SetUpViscousForcing (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &Forcing, const NekDouble aii_Dt)
 
virtual void v_SolvePressure (const Array< OneD, NekDouble > &Forcing)
 
virtual void v_SolveViscous (const Array< OneD, const Array< OneD, NekDouble >> &Forcing, const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble aii_Dt)
 
virtual void v_EvaluateAdvection_SetPressureBCs (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)
 
virtual bool v_RequireFwdTrans ()
 
virtual std::string v_GetExtrapolateStr (void)
 
virtual std::string v_GetSubSteppingExtrapolateStr (const std::string &instr)
 
void SetUpSVV (void)
 
void SetUpExtrapolation (void)
 
void SVVVarDiffCoeff (const NekDouble velmag, Array< OneD, NekDouble > &diffcoeff, const Array< OneD, Array< OneD, NekDouble >> &vel=NullNekDoubleArrayOfArray)
 
void AppendSVVFactors (StdRegions::ConstFactorMap &factors, MultiRegions::VarFactorsMap &varFactorsMap)
 
- Protected Member Functions inherited from Nektar::IncNavierStokes
 IncNavierStokes (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Constructor. More...
 
EquationType GetEquationType (void)
 
void EvaluateAdvectionTerms (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)
 
void WriteModalEnergy (void)
 
void SetBoundaryConditions (NekDouble time)
 time dependent boundary conditions updating More...
 
void SetRadiationBoundaryForcing (int fieldid)
 Set Radiation forcing term. More...
 
void SetZeroNormalVelocity ()
 Set Normal Velocity Component to Zero. More...
 
void SetWomersleyBoundary (const int fldid, const int bndid)
 Set Womersley Profile if specified. More...
 
void SetUpWomersley (const int fldid, const int bndid, std::string womstr)
 Set Up Womersley details. More...
 
void SetMovingReferenceFrameBCs (const NekDouble &time)
 Set the moving reference frame boundary conditions. More...
 
void SetMRFWallBCs (const NekDouble &time)
 
void SetMRFDomainVelBCs (const NekDouble &time)
 
virtual MultiRegions::ExpListSharedPtr v_GetPressure () override
 
virtual Array< OneD, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override
 
virtual bool v_PreIntegrate (int step) override
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_AppendOutput1D (Array< OneD, Array< OneD, NekDouble >> &solution1D)
 Print the solution at each solution point in a txt file. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble >> &inarray)
 Return the timestep to be used for the next step in the time-marching loop. More...
 
virtual SOLVER_UTILS_EXPORT void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time, int &nchk)
 
SOLVER_UTILS_EXPORT void SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble >> vel, StdRegions::VarCoeffMap &varCoeffMap)
 Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More...
 
virtual SOLVER_UTILS_EXPORT bool UpdateTimeStepCheck ()
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble >> &fieldcoeffs, std::vector< std::string > &variables)
 

Protected Attributes

MultiRegions::ExpListSharedPtr m_pressureP
 Correction pressure field for SPM. More...
 
Array< OneD, Array< OneD, NekDouble > > m_up
 Velocity of the immersed body(ies) More...
 
Array< OneD, Array< OneD, NekDouble > > m_upPrev
 
std::vector< std::string > m_velName
 Vector storing the names of the components of \u_p. More...
 
bool m_timeDependentUp
 Flag signaling if \(\u_p\) depends on time. More...
 
NekDouble m_gamma0
 Stiffly-stable scheme \(\gamma_0\) coefficient. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_fs
 Forcing function 'f_s'. More...
 
MultiRegions::ExpListSharedPtr m_phi
 Shape function 'phi' as expansion list. More...
 
SolverUtils::SessionFunctionSharedPtr m_phiEvaluator
 Function that evaluates the values of \Phi. More...
 
bool m_timeDependentPhi
 Flag that is true when phi depends on time. More...
 
bool m_filePhi
 Flag indicating that phi was defined in a file. More...
 
int m_forcesFilter
 Position of "AeroForcesSPM" filter in 'm_session->GetFilters()'. More...
 
- Protected Attributes inherited from Nektar::VelocityCorrectionScheme
bool m_useHomo1DSpecVanVisc
 bool to identify if spectral vanishing viscosity is active. More...
 
bool m_useSpecVanVisc
 bool to identify if spectral vanishing viscosity is active. More...
 
bool m_useGJPStabilisation
 bool to identify if GJP semi-implicit is active. More...
 
bool m_useGJPNormalVel
 bool to identify if GJP normal Velocity should be applied in explicit approach More...
 
NekDouble m_GJPJumpScale
 
NekDouble m_sVVCutoffRatio
 cutt off ratio from which to start decayhing modes More...
 
NekDouble m_sVVDiffCoeff
 Diffusion coefficient of SVV modes. More...
 
NekDouble m_sVVCutoffRatioHomo1D
 
NekDouble m_sVVDiffCoeffHomo1D
 Diffusion coefficient of SVV modes in homogeneous 1D Direction. More...
 
Array< OneD, NekDoublem_svvVarDiffCoeff
 Array of coefficient if power kernel is used in SVV. More...
 
bool m_IsSVVPowerKernel
 Identifier for Power Kernel otherwise DG kernel. More...
 
Array< OneD, NekDoublem_diffCoeff
 Diffusion coefficients (will be kinvis for velocities) More...
 
StdRegions::VarCoeffMap m_varCoeffLap
 Variable Coefficient map for the Laplacian which can be activated as part of SVV or otherwise. More...
 
NekDouble m_flowrate
 Desired volumetric flowrate. More...
 
NekDouble m_flowrateArea
 Area of the boundary through which we are measuring the flowrate. More...
 
bool m_homd1DFlowinPlane
 
NekDouble m_greenFlux
 Flux of the Stokes function solution. More...
 
NekDouble m_alpha
 Current flowrate correction. More...
 
int m_flowrateBndID
 Boundary ID of the flowrate reference surface. More...
 
int m_planeID
 Plane ID for cases with homogeneous expansion. More...
 
MultiRegions::ExpListSharedPtr m_flowrateBnd
 Flowrate reference surface. More...
 
Array< OneD, Array< OneD, NekDouble > > m_flowrateStokes
 Stokes solution used to impose flowrate. More...
 
std::ofstream m_flowrateStream
 Output stream to record flowrate. More...
 
int m_flowrateSteps
 Interval at which to record flowrate data. More...
 
NekDouble m_flowrateAiidt
 Value of aii_dt used to compute Stokes flowrate solution. More...
 
Array< OneD, Array< OneD, NekDouble > > m_F
 
- Protected Attributes inherited from Nektar::IncNavierStokes
ExtrapolateSharedPtr m_extrapolation
 
std::ofstream m_mdlFile
 modal energy file More...
 
bool m_SmoothAdvection
 bool to identify if advection term smoothing is requested More...
 
std::vector< SolverUtils::ForcingSharedPtrm_forcing
 Forcing terms. More...
 
int m_nConvectiveFields
 Number of fields to be convected;. More...
 
Array< OneD, int > m_velocity
 int which identifies which components of m_fields contains the velocity (u,v,w); More...
 
MultiRegions::ExpListSharedPtr m_pressure
 Pointer to field holding pressure field. More...
 
NekDouble m_kinvis
 Kinematic viscosity. More...
 
int m_energysteps
 dump energy to file at steps time More...
 
EquationType m_equationType
 equation type; More...
 
Array< OneD, Array< OneD, int > > m_fieldsBCToElmtID
 Mapping from BCs to Elmt IDs. More...
 
Array< OneD, Array< OneD, int > > m_fieldsBCToTraceID
 Mapping from BCs to Elmt Edge IDs. More...
 
Array< OneD, Array< OneD, NekDouble > > m_fieldsRadiationFactor
 RHS Factor for Radiation Condition. More...
 
int m_intSteps
 Number of time integration steps AND Order of extrapolation for pressure boundary conditions. More...
 
Array< OneD, NekDoublem_pivotPoint
 
std::map< int, std::map< int, WomersleyParamsSharedPtr > > m_womersleyParams
 Womersley parameters if required. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr m_advObject
 Advection term. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
int m_infosteps
 Number of time steps between outputting status information. More...
 
int m_abortSteps
 Number of steps between checks for abort conditions. More...
 
int m_filtersInfosteps
 Number of time steps between outputting filters information. More...
 
int m_nanSteps
 
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
NekDouble m_epsilon
 
bool m_explicitDiffusion
 Indicates if explicit or implicit treatment of diffusion is used. More...
 
bool m_explicitAdvection
 Indicates if explicit or implicit treatment of advection is used. More...
 
bool m_explicitReaction
 Indicates if explicit or implicit treatment of reaction is used. More...
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
NekDouble m_steadyStateTol
 Tolerance to which steady state should be evaluated at. More...
 
int m_steadyStateSteps
 Check for steady state at step interval. More...
 
NekDouble m_steadyStateRes = 1.0
 
NekDouble m_steadyStateRes0 = 1.0
 
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
 Storage for previous solution for steady-state check. More...
 
std::ofstream m_errFile
 
std::vector< int > m_intVariables
 
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
 
NekDouble m_filterTimeWarning
 Number of time steps between outputting status information. More...
 
NekDouble m_TimeIntegLambda = 0.0
 coefff of spacial derivatives(rhs or m_F in GLM) in calculating the residual of the whole equation(used in unsteady time integrations) More...
 
bool m_flagImplicitItsStatistics
 
bool m_flagImplicitSolver = false
 
Array< OneD, NekDoublem_magnitdEstimat
 estimate the magnitude of each conserved varibles More...
 
Array< OneD, NekDoublem_locTimeStep
 local time step(notice only for jfnk other see m_cflSafetyFactor) More...
 
NekDouble m_inArrayNorm = -1.0
 
int m_TotLinItePerStep = 0
 
int m_StagesPerStep = 1
 
bool m_flagUpdatePreconMat
 
int m_maxLinItePerNewton
 
int m_TotNewtonIts = 0
 
int m_TotLinIts = 0
 
int m_TotImpStages = 0
 
bool m_CalcPhysicalAV = true
 flag to update artificial viscosity More...
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
bool m_verbose
 
bool m_root
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
std::map< std::string, SolverUtils::SessionFunctionSharedPtrm_sessionFunctions
 Map of known SessionFunctions. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_fields
 Array holding all dependent variables. More...
 
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
 Pointer to boundary conditions object. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Pointer to graph defining mesh. More...
 
std::string m_sessionName
 Name of the session. More...
 
NekDouble m_time
 Current time of simulation. More...
 
int m_initialStep
 Number of the step where the simulation should begin. More...
 
NekDouble m_fintime
 Finish time of the simulation. More...
 
NekDouble m_timestep
 Time step size. More...
 
NekDouble m_timestepMax = -1.0
 Time step size. More...
 
NekDouble m_lambda
 Lambda constant in real system if one required. More...
 
NekDouble m_checktime
 Time between checkpoints. More...
 
NekDouble m_lastCheckTime
 
NekDouble m_TimeIncrementFactor
 
int m_nchk
 Number of checkpoints written so far. More...
 
int m_steps
 Number of steps to take. More...
 
int m_checksteps
 Number of steps between checkpoints. More...
 
int m_spacedim
 Spatial dimension (>= expansion dim). More...
 
int m_expdim
 Expansion dimension. More...
 
bool m_singleMode
 Flag to determine if single homogeneous mode is used. More...
 
bool m_halfMode
 Flag to determine if half homogeneous mode is used. More...
 
bool m_multipleModes
 Flag to determine if use multiple homogenenous modes are used. More...
 
bool m_useFFT
 Flag to determine if FFT is used for homogeneous transform. More...
 
bool m_homogen_dealiasing
 Flag to determine if dealiasing is used for homogeneous simulations. More...
 
bool m_specHP_dealiasing
 Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...
 
enum MultiRegions::ProjectionType m_projectionType
 Type of projection; e.g continuous or discontinuous. More...
 
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
 Array holding trace normals for DG simulations in the forwards direction. More...
 
Array< OneD, bool > m_checkIfSystemSingular
 Flag to indicate if the fields should be checked for singularity. More...
 
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
 Map to identify relevant solver info to dump in output fields. More...
 
Array< OneD, NekDoublem_movingFrameVelsxyz
 Moving frame of reference velocities. More...
 
Array< OneD, NekDoublem_movingFrameTheta
 Moving frame of reference angles with respect to the. More...
 
boost::numeric::ublas::matrix< NekDoublem_movingFrameProjMat
 Projection matrix for transformation between inertial and moving. More...
 
int m_NumQuadPointsError
 Number of Quadrature points used to work out the error. More...
 
enum HomogeneousType m_HomogeneousType
 
NekDouble m_LhomX
 physical length in X direction (if homogeneous) More...
 
NekDouble m_LhomY
 physical length in Y direction (if homogeneous) More...
 
NekDouble m_LhomZ
 physical length in Z direction (if homogeneous) More...
 
int m_npointsX
 number of points in X direction (if homogeneous) More...
 
int m_npointsY
 number of points in Y direction (if homogeneous) More...
 
int m_npointsZ
 number of points in Z direction (if homogeneous) More...
 
int m_HomoDirec
 number of homogenous directions More...
 

Additional Inherited Members

- Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 
NekDouble m_cflNonAcoustic
 
NekDouble m_CFLGrowth
 CFL growth rate. More...
 
NekDouble m_CFLEnd
 maximun cfl in cfl growth More...
 
- Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum  HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
 Parameter for homogeneous expansions. More...
 
- Static Protected Attributes inherited from Nektar::IncNavierStokes
static std::string eqTypeLookupIds []
 
- Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
static std::string equationSystemTypeLookupIds []
 

Detailed Description

Definition at line 44 of file SmoothedProfileMethod.h.

Constructor & Destructor Documentation

◆ SmoothedProfileMethod()

Nektar::SmoothedProfileMethod::SmoothedProfileMethod ( const LibUtilities::SessionReaderSharedPtr pSession,
const SpatialDomains::MeshGraphSharedPtr pGraph 
)

Construct a new Smoothed Profile Method object.

Parameters
pSession
pGraph

Definition at line 58 of file SmoothedProfileMethod.cpp.

61  : UnsteadySystem(pSession, pGraph),
62  VelocityCorrectionScheme(pSession, pGraph)
63 {
64 }
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
VelocityCorrectionScheme(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Constructor.

◆ ~SmoothedProfileMethod()

Nektar::SmoothedProfileMethod::~SmoothedProfileMethod ( void  )
virtual

Destroy the Smoothed Profile Method object.

Definition at line 70 of file SmoothedProfileMethod.cpp.

71 {
72 }

Member Function Documentation

◆ create()

static SolverUtils::EquationSystemSharedPtr Nektar::SmoothedProfileMethod::create ( const LibUtilities::SessionReaderSharedPtr pSession,
const SpatialDomains::MeshGraphSharedPtr pGraph 
)
inlinestatic

Creates an instance of this class.

Definition at line 48 of file SmoothedProfileMethod.h.

51  {
54  pGraph);
55  p->InitObject();
56  return p;
57  }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.

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

◆ GetFunctionHdl()

TiXmlElement * Nektar::SmoothedProfileMethod::GetFunctionHdl ( std::string  functionName)
protected

Returns a handle to the requested function. Returns NULL if it does not exist.

Parameters
functionName
Returns
TiXmlElement*

Definition at line 568 of file SmoothedProfileMethod.cpp.

569 {
570  // Get the handler of first function block
571  TiXmlElement *conds = m_session->GetElement("Nektar/Conditions");
572  TiXmlElement *function = conds->FirstChildElement("FUNCTION");
573 
574  // Loop over functions until the block 'name' is found
575  string functionType = function->Attribute("NAME");
576  while (function && !boost::iequals(functionType, functionName))
577  {
578  function = function->NextSiblingElement("FUNCTION");
579  functionType = function->Attribute("NAME");
580  }
581 
582  return function;
583 }
LibUtilities::SessionReaderSharedPtr m_session
The session reader.

References Nektar::SolverUtils::EquationSystem::m_session.

Referenced by GetVarTimeDependence(), and ReadPhi().

◆ GetVarTimeDependence()

bool Nektar::SmoothedProfileMethod::GetVarTimeDependence ( std::string  funcName,
std::string  attrName 
)
protected

True if the function is timedependent, false otherwise.

Parameters
name
type
attribute
Returns
string

Definition at line 528 of file SmoothedProfileMethod.cpp.

530 {
531  // Get the handler of the function
532  TiXmlElement *function = GetFunctionHdl(funcName);
533 
534  // Go to the first element
535  TiXmlElement *functionDef = function->FirstChildElement();
536  ASSERTL0(functionDef, "At least one element must be defined in " + funcName)
537 
538  // And search the element with name 'elemName'
539  string varName = functionDef->Attribute("VAR");
540  while (functionDef && !boost::iequals(varName, elemName))
541  {
542  functionDef = functionDef->NextSiblingElement();
543  varName = functionDef->Attribute("VAR");
544  }
545 
546  ASSERTL0(functionDef,
547  "Variable " + elemName + " must be defined in " + funcName + ".");
548 
549  // And return the value of USERDEFINEDTYPE
550  string attr;
551  int err = functionDef->QueryStringAttribute("USERDEFINEDTYPE", &attr);
552  bool output = boost::iequals(attr, "TimeDependent");
553 
554  ASSERTL0((err == TIXML_NO_ATTRIBUTE) || (err == TIXML_SUCCESS && output),
555  "USERDEFINEDTYPE in " + elemName +
556  " must be TimeDependent if defined");
557 
558  return output;
559 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
TiXmlElement * GetFunctionHdl(std::string functionName)
Returns a handle to the requested function. Returns NULL if it does not exist.

References ASSERTL0, and GetFunctionHdl().

Referenced by ReadPhi().

◆ ReadPhi()

void Nektar::SmoothedProfileMethod::ReadPhi ( )
protected

Definition at line 585 of file SmoothedProfileMethod.cpp.

586 {
587  // Function evaluator for Phi and Up
588  m_phiEvaluator = GetFunction("ShapeFunction");
589 
590  TiXmlElement *function = GetFunctionHdl("ShapeFunction");
591  TiXmlElement *child = function->FirstChildElement();
592  m_filePhi = false;
593 
594  // If defined by using a file
595  if (boost::iequals(child->ValueStr(), "F"))
596  {
597  // Get name of STL file
598  string fileName;
599  int status = child->QueryStringAttribute("FILE", &fileName);
600  ASSERTL0(status == TIXML_SUCCESS,
601  "An FLD file with the values "
602  "of the phi function has to be supplied.")
603  ASSERTL0(boost::iequals(fileName.substr(fileName.length() - 4), ".fld"),
604  "A valid FLD file must be supplied in the "
605  "'ShapeFunction' field.")
606 
607  // Get phi values from XML file (after "FieldConvert" the STL file)
608  // First, load the data
609  std::vector<LibUtilities::FieldDefinitionsSharedPtr> fieldDef;
610  std::vector<std::vector<NekDouble>> fieldData;
611  LibUtilities::FieldMetaDataMap fieldMetaData;
612  LibUtilities::FieldIOSharedPtr phiFile =
613  LibUtilities::FieldIO::CreateForFile(m_session, fileName);
614  phiFile->Import(fileName, fieldDef, fieldData, fieldMetaData);
615 
616  // Only Phi field should be defined in the file
617  ASSERTL0(fieldData.size() == 1, "Only one field (phi) must be "
618  "defined in the FLD file.")
619 
620  // Extract Phi field to output
621  string tmp("phi");
622  m_phi->ExtractDataToCoeffs(fieldDef[0], fieldData[0], tmp,
623  m_phi->UpdateCoeffs());
624  m_phi->BwdTrans(m_phi->GetCoeffs(), m_phi->UpdatePhys());
625  m_filePhi = true;
626  m_timeDependentPhi = false;
627  m_timeDependentUp = false;
628  }
629  else
630  {
631  // Check if Phi is timedependent
632  m_timeDependentPhi = GetVarTimeDependence("ShapeFunction", "Phi");
633 
634  // If so, check if its velocity changes as well
635  m_timeDependentUp = GetVarTimeDependence("ShapeFunction", "Up");
636  switch (m_velocity.size())
637  {
638  case 3:
640  GetVarTimeDependence("ShapeFunction", "Wp");
641  case 2:
643  GetVarTimeDependence("ShapeFunction", "Vp");
644  }
645  }
646 }
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
bool m_filePhi
Flag indicating that phi was defined in a file.
bool m_timeDependentPhi
Flag that is true when phi depends on time.
SolverUtils::SessionFunctionSharedPtr m_phiEvaluator
Function that evaluates the values of \Phi.
bool m_timeDependentUp
Flag signaling if depends on time.
bool GetVarTimeDependence(std::string funcName, std::string attrName)
True if the function is timedependent, false otherwise.
MultiRegions::ExpListSharedPtr m_phi
Shape function 'phi' as expansion list.
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction(std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
Get a SessionFunction by name.
std::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:301
void Import(const std::string &infilename, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble >> &fielddata, FieldMetaDataMap &fieldinfomap, const Array< OneD, int > &ElementIDs)
This function allows for data to be imported from an FLD file when a session and/or communicator is n...
Definition: FieldIO.cpp:291
std::map< std::string, std::string > FieldMetaDataMap
Definition: FieldIO.h:52
std::shared_ptr< FieldDefinitions > FieldDefinitionsSharedPtr
Definition: FieldIO.h:177
double NekDouble

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::SolverUtils::EquationSystem::GetFunction(), GetFunctionHdl(), GetVarTimeDependence(), m_filePhi, m_phi, m_phiEvaluator, Nektar::SolverUtils::EquationSystem::m_session, m_timeDependentPhi, m_timeDependentUp, and Nektar::IncNavierStokes::m_velocity.

Referenced by v_InitObject().

◆ SetCorrectionPressureBCs()

void Nektar::SmoothedProfileMethod::SetCorrectionPressureBCs ( )
protected

Updates the BCs for boundaries with Neumann or periodic BCs in the pressure:

\[ \frac{\partial p_p}{\partial\mathbf{n}} = \mathbf{f_s}\cdot\mathbf{n} \]

Definition at line 400 of file SmoothedProfileMethod.cpp.

401 {
402  int nvel = m_velocity.size();
403  Array<OneD, ExpListSharedPtr> BndExp;
404  Array<OneD, SpatialDomains::BoundaryConditionShPtr> BndCond;
405 
406  // Get the BC expansions
407  BndExp = m_pressureP->GetBndCondExpansions();
408  BndCond = m_pressureP->GetBndConditions();
409 
410  // For each boundary...
411  for (int b = 0; b < BndExp.size(); ++b)
412  {
413  // Only for BCs based on the derivative
414  if (BndCond[b]->GetBoundaryConditionType() ==
416  BndCond[b]->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
417  {
418  // Calculate f_s values
419  Array<OneD, Array<OneD, NekDouble>> f_s(nvel);
420  for (int i = 0; i < nvel; ++i)
421  {
422  f_s[i] = m_fs[0]->GetBndCondExpansions()[b]->GetPhys();
423  }
424 
425  // BC is f_s * n
426  BndExp[b]->NormVectorIProductWRTBase(f_s, BndExp[b]->UpdatePhys());
427  }
428  }
429 }
MultiRegions::ExpListSharedPtr m_pressureP
Correction pressure field for SPM.
Array< OneD, MultiRegions::ExpListSharedPtr > m_fs
Forcing function 'f_s'.

References Nektar::SpatialDomains::eNeumann, Nektar::SpatialDomains::ePeriodic, m_fs, m_pressureP, and Nektar::IncNavierStokes::m_velocity.

Referenced by SetUpCorrectionPressure().

◆ SetUpCorrectionPressure()

void Nektar::SmoothedProfileMethod::SetUpCorrectionPressure ( const Array< OneD, const Array< OneD, NekDouble >> &  fields,
Array< OneD, Array< OneD, NekDouble >> &  Forcing 
)
protected

Sets the forcing term of the equation for the correction pressure \(p_p\):

\[ \nabla\cdot\mathbf{f_s} \]

Parameters
fields
Forcing

Definition at line 297 of file SmoothedProfileMethod.cpp.

300 {
301  int physTot = m_fs[0]->GetNpoints();
302  int nvel = m_velocity.size();
303 
304  // Set boundary conditions
306 
307  // Divergence of 'fs'
308  m_fields[m_velocity[0]]->PhysDeriv(eX, m_fs[0]->GetPhys(), Forcing[0]);
309 
310  // Using 'Forcing[1]' as storage
311  for (int i = 1; i < nvel; ++i)
312  {
313  int ind = m_velocity[i];
314  m_fields[ind]->PhysDeriv(DirCartesianMap[i], m_fs[i]->GetPhys(),
315  Forcing[1]);
316  Vmath::Vadd(physTot, Forcing[1], 1, Forcing[0], 1, Forcing[0], 1);
317  }
318 }
void SetCorrectionPressureBCs()
Updates the BCs for boundaries with Neumann or periodic BCs in the pressure:
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:89
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:359

References Nektar::MultiRegions::DirCartesianMap, Nektar::MultiRegions::eX, Nektar::SolverUtils::EquationSystem::m_fields, m_fs, Nektar::IncNavierStokes::m_velocity, SetCorrectionPressureBCs(), and Vmath::Vadd().

Referenced by v_SolveUnsteadyStokesSystem().

◆ SetUpExpansions()

template<typename T >
void Nektar::SmoothedProfileMethod::SetUpExpansions ( int  nvel)
inlineprotected

Initialises the expansions for the intermediate pressure, the 'Phi' function and the IB forcing.

Definition at line 140 of file SmoothedProfileMethod.h.

141  {
142  int iVel = m_velocity[0];
144  *std::dynamic_pointer_cast<T>(m_pressure));
146  *std::dynamic_pointer_cast<T>(m_fields[iVel]));
147 
148  m_fs = Array<OneD, MultiRegions::ExpListSharedPtr>(nvel);
149  for (int i = 0; i < nvel; ++i)
150  {
152  *std::dynamic_pointer_cast<T>(m_fields[iVel]));
153  }
154 
155  // Set to wave space if homogeneous case
157  {
158  m_pressureP->SetWaveSpace(true);
159  m_phi->SetWaveSpace(true);
160  for (int i = 0; i < nvel; ++i)
161  {
162  m_fs[i]->SetWaveSpace(true);
163  }
164  }
165  }
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
enum HomogeneousType m_HomogeneousType

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SolverUtils::EquationSystem::eNotHomogeneous, Nektar::SolverUtils::EquationSystem::m_fields, m_fs, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, m_phi, Nektar::IncNavierStokes::m_pressure, m_pressureP, and Nektar::IncNavierStokes::m_velocity.

◆ SolveCorrectedVelocity()

void Nektar::SmoothedProfileMethod::SolveCorrectedVelocity ( Array< OneD, Array< OneD, NekDouble >> &  Forcing,
Array< OneD, Array< OneD, NekDouble >> &  fields,
NekDouble  dt 
)
protected

Corrects the velocity field so that the IBs are taken into account. Solves the explicit equation:

\[ \frac{\gamma_0(\mathbf{u_p}^{n+1} - \mathbf{u}^*)}{\Delta t} = \mathbf{f_s} - \nabla p_p \]

Parameters
Forcing
fields
dt

Definition at line 353 of file SmoothedProfileMethod.cpp.

356 {
357  int physTot = m_phi->GetNpoints();
358 
359  // Gradient of p_p
360  int nvel = m_velocity.size();
361  if (nvel == 2)
362  {
363  m_pressureP->PhysDeriv(m_pressureP->GetPhys(), Forcing[0], Forcing[1]);
364  }
365  else
366  {
367  m_pressureP->PhysDeriv(m_pressureP->GetPhys(), Forcing[0], Forcing[1],
368  Forcing[2]);
369  }
370 
371  // Velocity correction
372  for (int i = 0; i < nvel; ++i)
373  {
374  // Adding -(1-m_phi)*grad(p_p) instead of -grad(p_p) reduces the
375  // flux through the walls, but the flow is not incompressible
376  if (m_session->DefinesSolverInfo("ForceBoundary") &&
377  boost::iequals(m_session->GetSolverInfo("ForceBoundary"), "True"))
378  {
379  Vmath::Vvtvm(physTot, m_phi->GetPhys(), 1, Forcing[i], 1,
380  Forcing[i], 1, Forcing[i], 1);
381  Vmath::Vadd(physTot, m_fs[i]->GetPhys(), 1, Forcing[i], 1,
382  Forcing[i], 1);
383  }
384  else
385  {
386  Vmath::Vsub(physTot, m_fs[i]->GetPhys(), 1, Forcing[i], 1,
387  Forcing[i], 1);
388  }
389  Blas::Daxpy(physTot, dt / m_gamma0, Forcing[i], 1, fields[i], 1);
390  }
391 }
NekDouble m_gamma0
Stiffly-stable scheme coefficient.
static void Daxpy(const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: y = alpha x plus y.
Definition: Blas.hpp:154
void Vvtvm(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvm (vector times vector plus vector): z = w*x - y
Definition: Vmath.cpp:598
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:419

References Blas::Daxpy(), m_fs, m_gamma0, m_phi, m_pressureP, Nektar::SolverUtils::EquationSystem::m_session, Nektar::IncNavierStokes::m_velocity, Vmath::Vadd(), Vmath::Vsub(), and Vmath::Vvtvm().

Referenced by v_SolveUnsteadyStokesSystem().

◆ SolveCorrectionPressure()

void Nektar::SmoothedProfileMethod::SolveCorrectionPressure ( const Array< OneD, NekDouble > &  Forcing)
protected

Solves the Poisson equation for the correction pressure \(p_p\):

\[ \nabla^2 p_p = \nabla\cdot\mathbf{f_s} \]

Parameters
Forcing

Definition at line 328 of file SmoothedProfileMethod.cpp.

330 {
332  // Factor 'lambda=0' in Helmholtz equation to get the Poisson form
333  factors[StdRegions::eFactorLambda] = 0.0;
334 
335  // Solve the Poisson equation
336  m_pressureP->HelmSolve(Forcing, m_pressureP->UpdateCoeffs(), factors);
337 
338  // Update node values from coefficients
339  m_pressureP->BwdTrans(m_pressureP->GetCoeffs(), m_pressureP->UpdatePhys());
340 }
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:282

References Nektar::StdRegions::eFactorLambda, and m_pressureP.

Referenced by v_SolveUnsteadyStokesSystem().

◆ SolveUnsteadyStokesSystem()

void Nektar::SmoothedProfileMethod::SolveUnsteadyStokesSystem ( const Array< OneD, const Array< OneD, NekDouble >> &  inarray,
Array< OneD, Array< OneD, NekDouble >> &  outarray,
const NekDouble  time,
const NekDouble  a_iixDt 
)
inline

Definition at line 75 of file SmoothedProfileMethod.h.

79  {
80  v_SolveUnsteadyStokesSystem(inarray, outarray, time, a_iixDt);
81  }
virtual void v_SolveUnsteadyStokesSystem(const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, NekDouble time, NekDouble a_iixDt)
Linear terms due to pressure and visosity are calculated here. After solving the velocity filed witho...

References v_SolveUnsteadyStokesSystem().

Referenced by v_InitObject().

◆ UpdateForcing()

void Nektar::SmoothedProfileMethod::UpdateForcing ( const Array< OneD, const Array< OneD, NekDouble >> &  fields,
NekDouble  dt 
)
protected

For a body with a velocity \(\mathbf{u_p}\), the force \(\mathbf{f_s}\) applied to the fluid ensures that the IBC are met:

\[ \mathbf{f_s} = \frac{\Phi^{n+1}\left(\mathbf{u_p}^{n+1} - \mathbf{u^*}\right)}{\Delta t} \]

Parameters
fields
dt
f_s

Definition at line 480 of file SmoothedProfileMethod.cpp.

482 {
483  int nvel = m_velocity.size();
484  int nq = m_phi->GetNpoints();
485 
486  for (int i = 0; i < nvel; ++i)
487  {
488  // In homogeneous cases, switch out of wave space
489  Array<OneD, NekDouble> tmpField(nq);
490  int ind = m_velocity[i];
491 
493  m_fields[ind]->GetWaveSpace())
494  {
495  m_fields[ind]->HomogeneousBwdTrans(fields[i], tmpField);
496  m_fs[i]->HomogeneousBwdTrans(m_fs[i]->GetPhys(),
497  m_fs[i]->UpdatePhys());
498  }
499  else
500  {
501  tmpField = fields[i];
502  }
503 
504  Vmath::Vsub(nq, m_up[i], 1, tmpField, 1, m_fs[i]->UpdatePhys(), 1);
505  Vmath::Vmul(nq, m_phi->GetPhys(), 1, m_fs[i]->GetPhys(), 1,
506  m_fs[i]->UpdatePhys(), 1);
507  Vmath::Smul(nq, m_gamma0 / dt, m_fs[i]->GetPhys(), 1,
508  m_fs[i]->UpdatePhys(), 1);
509 
510  // And go back to wave space if the 'if' was executed
512  m_fields[ind]->GetWaveSpace())
513  {
514  m_fs[i]->HomogeneousFwdTrans(m_fs[i]->GetPhys(),
515  m_fs[i]->UpdatePhys());
516  }
517  }
518 }
Array< OneD, Array< OneD, NekDouble > > m_up
Velocity of the immersed body(ies)
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:209
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:248

References Nektar::SolverUtils::EquationSystem::eNotHomogeneous, Nektar::SolverUtils::EquationSystem::m_fields, m_fs, m_gamma0, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, m_phi, m_up, Nektar::IncNavierStokes::m_velocity, Vmath::Smul(), Vmath::Vmul(), and Vmath::Vsub().

Referenced by v_SolveUnsteadyStokesSystem().

◆ UpdatePhiUp()

void Nektar::SmoothedProfileMethod::UpdatePhiUp ( NekDouble  t)
protected

Calculates the values of the shape function.

Parameters
t

Definition at line 436 of file SmoothedProfileMethod.cpp.

437 {
438  // Initialise 'm_up' and 'm_phi' during first step
439  if (t <= 0.0)
440  {
441  if (!m_filePhi)
442  {
443  // Update 'm_phi' only if it was provided as a function
444  m_phiEvaluator->Evaluate("Phi", m_phi->UpdatePhys(), t);
445  }
446 
447  // Initialize both variables for the first step
448  m_phiEvaluator->Evaluate(m_velName, m_up, t);
449 
450  // Initialise 'm_upPrev' in all cases
451  m_upPrev = m_up;
452  }
453  // If timedependent 'm_phi'
454  // Phi functions from files are not timedependent
455  else if (m_timeDependentPhi)
456  {
457  m_phiEvaluator->Evaluate("Phi", m_phi->UpdatePhys(), t);
458 
459  // And if velocities are timedependent as well
460  if (m_timeDependentUp)
461  {
462  // Store previous value of u_p during simulation
463  m_upPrev = m_up;
464  m_phiEvaluator->Evaluate(m_velName, m_up, t);
465  }
466  }
467 }
std::vector< std::string > m_velName
Vector storing the names of the components of \u_p.
Array< OneD, Array< OneD, NekDouble > > m_upPrev

References m_filePhi, m_phi, m_phiEvaluator, m_timeDependentPhi, m_timeDependentUp, m_up, m_upPrev, and m_velName.

Referenced by v_InitObject(), and v_SolveUnsteadyStokesSystem().

◆ v_GenerateSummary()

void Nektar::SmoothedProfileMethod::v_GenerateSummary ( SolverUtils::SummaryList s)
virtual

Generates the summary of the current simulation.

Parameters
s

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 229 of file SmoothedProfileMethod.cpp.

230 {
232  SolverUtils::AddSummaryItem(s, "IB formulation",
233  "Smoothed Profile Method (SPM)");
234 }
virtual void v_GenerateSummary(SolverUtils::SummaryList &s)
Print a summary of time stepping parameters.
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
Definition: Misc.cpp:49

References Nektar::SolverUtils::AddSummaryItem(), and Nektar::VelocityCorrectionScheme::v_GenerateSummary().

◆ v_InitObject()

void Nektar::SmoothedProfileMethod::v_InitObject ( bool  DeclareField = true)
virtual

Init object for UnsteadySystem class.

Initialization object for UnsteadySystem class.

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 74 of file SmoothedProfileMethod.cpp.

75 {
77 
78  // Update implicit time-intregration class operators
80  this);
81 
82  // Number of dims as number of velocity vectors
83  int nvel = m_velocity.size();
84 
85  // Initialization of correction pressure and shape function
86  switch (nvel)
87  {
88  case 1:
90  {
91  SetUpExpansions<ContField>(nvel);
92  }
93  else if (m_projectionType == eDiscontinuous)
94  {
95  SetUpExpansions<DisContField>(nvel);
96  }
97  break;
98 
99  case 2:
101  {
102  SetUpExpansions<ContField>(nvel);
103  }
104  else if (m_projectionType == eDiscontinuous)
105  {
106  SetUpExpansions<DisContField>(nvel);
107  }
108  break;
109 
110  case 3:
112  {
114  {
115  SetUpExpansions<ContField>(nvel);
116  }
118  {
119  SetUpExpansions<ContField3DHomogeneous1D>(nvel);
120  }
123  {
124  SetUpExpansions<ContField3DHomogeneous2D>(nvel);
125  }
126  }
127  else if (m_projectionType == eDiscontinuous)
128  {
130  {
131  SetUpExpansions<DisContField>(nvel);
132  }
134  {
135  SetUpExpansions<DisContField3DHomogeneous1D>(nvel);
136  }
139  {
140  SetUpExpansions<DisContField3DHomogeneous2D>(nvel);
141  }
142  }
143  break;
144  }
145 
146  // Read 'm_phi' and its velocity
147  ASSERTL0(m_session->DefinesFunction("ShapeFunction"),
148  "ShapeFunction must be defined in the session file.")
149  ReadPhi();
150 
151  // Allocate the vector 'm_up'
152  int physTot = m_phi->GetTotPoints();
153  m_velName.push_back("Up");
154  if (nvel > 1)
155  {
156  m_velName.push_back("Vp");
157  }
158  if (nvel == 3)
159  {
160  m_velName.push_back("Wp");
161  }
162 
163  m_up = Array<OneD, Array<OneD, NekDouble>>(nvel);
164  for (int i = 0; i < nvel; ++i)
165  {
166  m_up[i] = Array<OneD, NekDouble>(physTot, 0.0);
167  }
168 
169  // Make sure that m_phi and m_up are defined
170  UpdatePhiUp(0.0);
171 
172  // Get the time integration scheme.
173  LibUtilities::TimeIntScheme timeInt;
174  if (m_session->DefinesTimeIntScheme())
175  {
176  timeInt = m_session->GetTimeIntScheme();
177  }
178  else
179  {
180  timeInt.method = m_session->GetSolverInfo("TimeIntegrationMethod");
181  timeInt.order = timeInt.method.back() - '0';
182 
183  // Remove everything past the IMEX.
184  timeInt.method = timeInt.method.substr(0, 4);
185  }
186 
187  // Select 'm_gamma0' depending on IMEX order
188  ASSERTL0(
189  boost::iequals(timeInt.method, "IMEX") && 1 <= timeInt.order &&
190  timeInt.order <= 4,
191  "The TimeIntegrationMethod scheme must be IMEX with order '1' to '4'.")
192 
193  switch (timeInt.order)
194  {
195  case 1:
196  m_gamma0 = 1.0;
197  break;
198 
199  case 2:
200  m_gamma0 = 3.0 / 2.0;
201  break;
202 
203  case 3:
204  m_gamma0 = 11.0 / 6.0;
205  break;
206 
207  case 4:
208  m_gamma0 = 25.0 / 12.0;
209  break;
210  }
211 
212  // Check if the aeroforces filter is active, negative if inactive
213  m_forcesFilter = -1;
214  for (int i = 0; i < m_session->GetFilters().size(); ++i)
215  {
216  if (boost::iequals(m_session->GetFilters()[i].first, "AeroForcesSPM"))
217  {
218  m_forcesFilter = i;
219  break;
220  }
221  }
222 }
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
int m_forcesFilter
Position of "AeroForcesSPM" filter in 'm_session->GetFilters()'.
void SolveUnsteadyStokesSystem(const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time, const NekDouble a_iixDt)
void UpdatePhiUp(NekDouble time)
Calculates the values of the shape function.
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
SOLVER_UTILS_EXPORT int GetTotPoints()
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
virtual void v_InitObject(bool DeclareField=true)
Init object for UnsteadySystem class.

References ASSERTL0, Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve(), Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SolverUtils::EquationSystem::eHomogeneous2D, Nektar::SolverUtils::EquationSystem::eHomogeneous3D, Nektar::SolverUtils::EquationSystem::eNotHomogeneous, m_forcesFilter, m_gamma0, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, Nektar::SolverUtils::UnsteadySystem::m_ode, m_phi, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::SolverUtils::EquationSystem::m_session, m_up, m_velName, Nektar::IncNavierStokes::m_velocity, Nektar::LibUtilities::TimeIntScheme::method, Nektar::LibUtilities::TimeIntScheme::order, ReadPhi(), SolveUnsteadyStokesSystem(), UpdatePhiUp(), and Nektar::VelocityCorrectionScheme::v_InitObject().

◆ v_SolveUnsteadyStokesSystem()

void Nektar::SmoothedProfileMethod::v_SolveUnsteadyStokesSystem ( const Array< OneD, const Array< OneD, NekDouble >> &  inarray,
Array< OneD, Array< OneD, NekDouble >> &  outarray,
NekDouble  time,
NekDouble  a_iixDt 
)
protectedvirtual

Linear terms due to pressure and visosity are calculated here. After solving the velocity filed without taking into account the immersed boundaries, a new correction is applied through the force \(f_s\):

\[ \mathbf{f_s} = \frac{\Phi^{n+1}(\mathbf{u_p}-\mathbf{u^*})} {\Delta t} \]

Parameters
inarray
outarray
time
a_iixDt

Definition at line 250 of file SmoothedProfileMethod.cpp.

254 {
256  a_iixDt);
257 
258  int physTot = m_pressureP->GetNpoints();
259 
260  /* SPM correction of velocity */
261  // Update 'm_phi' and 'm_up' if needed (evaluated at next time step)
262  UpdatePhiUp(time + a_iixDt);
263  // Update calculation of IB forcing 'm_fs'
264  UpdateForcing(outarray, a_iixDt);
265  // Estimate forces only if requested
266  if (m_forcesFilter >= 0)
267  {
268  static_pointer_cast<FilterAeroForcesSPM>(
269  m_filters[m_forcesFilter].second)
270  ->CalculateForces(outarray, m_upPrev, m_phi, time, a_iixDt);
271  }
272  // Set BC conditions for pressure p_p
273  SetUpCorrectionPressure(outarray, m_F);
274  // Solve Poisson equation for pressure p_p
276  // Solve velocity in the next step with IB
277  SolveCorrectedVelocity(m_F, outarray, a_iixDt);
278 
279  // Add pressures to get final value
280  Vmath::Vadd(physTot, m_pressure->GetPhys(), 1, m_pressureP->GetPhys(), 1,
281  m_pressure->UpdatePhys(), 1);
282  m_pressure->FwdTrans(m_pressure->GetPhys(), m_pressure->UpdateCoeffs());
283 
284  // Add presure to outflow bc if using convective like BCs
285  m_extrapolation->AddPressureToOutflowBCs(m_kinvis);
286 }
NekDouble m_kinvis
Kinematic viscosity.
ExtrapolateSharedPtr m_extrapolation
void SetUpCorrectionPressure(const Array< OneD, const Array< OneD, NekDouble >> &fields, Array< OneD, Array< OneD, NekDouble >> &Forcing)
Sets the forcing term of the equation for the correction pressure :
void SolveCorrectedVelocity(Array< OneD, Array< OneD, NekDouble >> &Forcing, Array< OneD, Array< OneD, NekDouble >> &fields, NekDouble dt)
Corrects the velocity field so that the IBs are taken into account. Solves the explicit equation:
void UpdateForcing(const Array< OneD, const Array< OneD, NekDouble >> &fields, NekDouble dt)
For a body with a velocity , the force applied to the fluid ensures that the IBC are met:
void SolveCorrectionPressure(const Array< OneD, NekDouble > &Forcing)
Solves the Poisson equation for the correction pressure :
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
void SolveUnsteadyStokesSystem(const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time, const NekDouble a_iixDt)
Array< OneD, Array< OneD, NekDouble > > m_F

References Nektar::IncNavierStokes::m_extrapolation, Nektar::VelocityCorrectionScheme::m_F, Nektar::SolverUtils::UnsteadySystem::m_filters, m_forcesFilter, Nektar::IncNavierStokes::m_kinvis, m_phi, Nektar::IncNavierStokes::m_pressure, m_pressureP, m_upPrev, SetUpCorrectionPressure(), SolveCorrectedVelocity(), SolveCorrectionPressure(), Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), UpdateForcing(), UpdatePhiUp(), and Vmath::Vadd().

Referenced by SolveUnsteadyStokesSystem().

Member Data Documentation

◆ className

string Nektar::SmoothedProfileMethod::className
static
Initial value:
=
"SmoothedProfileMethod", SmoothedProfileMethod::create)
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:198
static SolverUtils::EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Creates an instance of this class.
EquationSystemFactory & GetEquationSystemFactory()

Name of class.

Definition at line 60 of file SmoothedProfileMethod.h.

◆ m_filePhi

bool Nektar::SmoothedProfileMethod::m_filePhi
protected

Flag indicating that phi was defined in a file.

Definition at line 104 of file SmoothedProfileMethod.h.

Referenced by ReadPhi(), and UpdatePhiUp().

◆ m_forcesFilter

int Nektar::SmoothedProfileMethod::m_forcesFilter
protected

Position of "AeroForcesSPM" filter in 'm_session->GetFilters()'.

Definition at line 106 of file SmoothedProfileMethod.h.

Referenced by v_InitObject(), and v_SolveUnsteadyStokesSystem().

◆ m_fs

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SmoothedProfileMethod::m_fs
protected

◆ m_gamma0

NekDouble Nektar::SmoothedProfileMethod::m_gamma0
protected

Stiffly-stable scheme \(\gamma_0\) coefficient.

Definition at line 94 of file SmoothedProfileMethod.h.

Referenced by SolveCorrectedVelocity(), UpdateForcing(), and v_InitObject().

◆ m_phi

MultiRegions::ExpListSharedPtr Nektar::SmoothedProfileMethod::m_phi
protected

Shape function 'phi' as expansion list.

Definition at line 98 of file SmoothedProfileMethod.h.

Referenced by ReadPhi(), SetUpExpansions(), SolveCorrectedVelocity(), UpdateForcing(), UpdatePhiUp(), v_InitObject(), and v_SolveUnsteadyStokesSystem().

◆ m_phiEvaluator

SolverUtils::SessionFunctionSharedPtr Nektar::SmoothedProfileMethod::m_phiEvaluator
protected

Function that evaluates the values of \Phi.

Definition at line 100 of file SmoothedProfileMethod.h.

Referenced by ReadPhi(), and UpdatePhiUp().

◆ m_pressureP

MultiRegions::ExpListSharedPtr Nektar::SmoothedProfileMethod::m_pressureP
protected

◆ m_timeDependentPhi

bool Nektar::SmoothedProfileMethod::m_timeDependentPhi
protected

Flag that is true when phi depends on time.

Definition at line 102 of file SmoothedProfileMethod.h.

Referenced by ReadPhi(), and UpdatePhiUp().

◆ m_timeDependentUp

bool Nektar::SmoothedProfileMethod::m_timeDependentUp
protected

Flag signaling if \(\u_p\) depends on time.

Definition at line 92 of file SmoothedProfileMethod.h.

Referenced by ReadPhi(), and UpdatePhiUp().

◆ m_up

Array<OneD, Array<OneD, NekDouble> > Nektar::SmoothedProfileMethod::m_up
protected

Velocity of the immersed body(ies)

Definition at line 87 of file SmoothedProfileMethod.h.

Referenced by UpdateForcing(), UpdatePhiUp(), and v_InitObject().

◆ m_upPrev

Array<OneD, Array<OneD, NekDouble> > Nektar::SmoothedProfileMethod::m_upPrev
protected

Definition at line 88 of file SmoothedProfileMethod.h.

Referenced by UpdatePhiUp(), and v_SolveUnsteadyStokesSystem().

◆ m_velName

std::vector<std::string> Nektar::SmoothedProfileMethod::m_velName
protected

Vector storing the names of the components of \u_p.

Definition at line 90 of file SmoothedProfileMethod.h.

Referenced by UpdatePhiUp(), and v_InitObject().