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

A model for cardiac conduction. More...

#include <MMFDiffusion.h>

Inheritance diagram for Nektar::MMFDiffusion:
[legend]

Public Member Functions

virtual ~MMFDiffusion ()
 Desctructor. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::MMFSystem
SOLVER_UTILS_EXPORT MMFSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
virtual SOLVER_UTILS_EXPORT ~MMFSystem ()
 
SOLVER_UTILS_EXPORT void MMFInitObject (const Array< OneD, const Array< OneD, NekDouble >> &Anisotropy, const int TangentXelem=-1)
 
SOLVER_UTILS_EXPORT void CopyBoundaryTrace (const Array< OneD, const NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd, const BoundaryCopyType BDCopyType, const int var=0, const std::string btype="NoUserDefined")
 
- 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...
 

Static Public Member Functions

static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Creates an instance of this class. More...
 

Public Attributes

TestType m_TestType
 
- Public Attributes inherited from Nektar::SolverUtils::MMFSystem
NekDouble m_pi
 
int m_shapedim
 
SurfaceType m_surfaceType
 
UpwindType m_upwindType
 
TestMaxwellType m_TestMaxwellType
 
PolType m_PolType
 
IncType m_IncType
 
Array< OneD, NekDoublem_MMFfactors
 
- 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...
 

Static Public Attributes

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

 MMFDiffusion (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Constructor. More...
 
virtual void v_InitObject (bool DeclareField=true)
 Init object for UnsteadySystem class. More...
 
void DoImplicitSolve (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, NekDouble time, NekDouble lambda)
 Solve for the diffusion term. More...
 
void DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)
 Computes the reaction terms \(f(u,v)\) and \(g(u,v)\). More...
 
void TestPlaneProblem (const NekDouble time, Array< OneD, NekDouble > &outfield)
 
void TestCubeProblem (const NekDouble time, Array< OneD, NekDouble > &outfield)
 
void Morphogenesis (const NekDouble time, unsigned int field, Array< OneD, NekDouble > &outfield)
 
Array< OneD, NekDoublePlanePhiWave ()
 
virtual void v_SetInitialConditions (NekDouble initialtime, bool dumpInitialConditions, const int domain)
 Sets a custom initial condition. More...
 
virtual void v_GenerateSummary (SolverUtils::SummaryList &s)
 Prints a summary of the model parameters. More...
 
virtual void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
- Protected Member Functions inherited from Nektar::SolverUtils::MMFSystem
void SetUpMovingFrames (const Array< OneD, const Array< OneD, NekDouble >> &Anisotropy, const int TangentXelem)
 
void CheckMovingFrames (const Array< OneD, const Array< OneD, NekDouble >> &movingframes)
 
SOLVER_UTILS_EXPORT void ComputencdotMF ()
 
SOLVER_UTILS_EXPORT void ComputeDivCurlMF ()
 
SOLVER_UTILS_EXPORT void ComputeMFtrace ()
 
SOLVER_UTILS_EXPORT void VectorDotProd (const Array< OneD, const Array< OneD, NekDouble >> &v1, const Array< OneD, const Array< OneD, NekDouble >> &v2, Array< OneD, NekDouble > &v3)
 
SOLVER_UTILS_EXPORT void VectorCrossProd (const Array< OneD, const Array< OneD, NekDouble >> &v1, const Array< OneD, const Array< OneD, NekDouble >> &v2, Array< OneD, Array< OneD, NekDouble >> &v3)
 
SOLVER_UTILS_EXPORT void VectorCrossProd (const Array< OneD, NekDouble > &v1, const Array< OneD, NekDouble > &v2, Array< OneD, NekDouble > &v3)
 
SOLVER_UTILS_EXPORT void ComputeCurl (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray)
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleCartesianToMovingframes (const Array< OneD, const Array< OneD, NekDouble >> &uvec, unsigned int field)
 
SOLVER_UTILS_EXPORT void DeriveCrossProductMF (Array< OneD, Array< OneD, NekDouble >> &CrossProductMF)
 
SOLVER_UTILS_EXPORT void ComputeNtimesMF ()
 
SOLVER_UTILS_EXPORT void ComputeNtimesFz (const int dir, const Array< OneD, Array< OneD, NekDouble >> &Fwd, const Array< OneD, Array< OneD, NekDouble >> &Bwd, const Array< OneD, const NekDouble > &imFwd, const Array< OneD, const NekDouble > &imBwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)
 
SOLVER_UTILS_EXPORT void ComputeNtimesF12 (const Array< OneD, Array< OneD, NekDouble >> &Fwd, const Array< OneD, Array< OneD, NekDouble >> &Bwd, const Array< OneD, const NekDouble > &im1Fwd, const Array< OneD, const NekDouble > &im1Bwd, const Array< OneD, const NekDouble > &im2Fwd, const Array< OneD, const NekDouble > &im2Bwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)
 
SOLVER_UTILS_EXPORT void ComputeNtimestimesdFz (const int dir, const Array< OneD, Array< OneD, NekDouble >> &Fwd, const Array< OneD, Array< OneD, NekDouble >> &Bwd, const Array< OneD, const NekDouble > &imFwd, const Array< OneD, const NekDouble > &imBwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)
 
SOLVER_UTILS_EXPORT void ComputeNtimestimesdF12 (const Array< OneD, Array< OneD, NekDouble >> &Fwd, const Array< OneD, Array< OneD, NekDouble >> &Bwd, const Array< OneD, const NekDouble > &im1Fwd, const Array< OneD, const NekDouble > &im1Bwd, const Array< OneD, const NekDouble > &im2Fwd, const Array< OneD, const NekDouble > &im2Bwd, Array< OneD, NekDouble > &outarrayFwd, Array< OneD, NekDouble > &outarrayBwd)
 
SOLVER_UTILS_EXPORT void CartesianToSpherical (const NekDouble x0j, const NekDouble x1j, const NekDouble x2j, NekDouble &sin_varphi, NekDouble &cos_varphi, NekDouble &sin_theta, NekDouble &cos_theta)
 
SOLVER_UTILS_EXPORT void ComputeZimYim (Array< OneD, Array< OneD, NekDouble >> &epsvec, Array< OneD, Array< OneD, NekDouble >> &muvec)
 
SOLVER_UTILS_EXPORT void AdddedtMaxwell (const Array< OneD, const Array< OneD, NekDouble >> &physarray, Array< OneD, Array< OneD, NekDouble >> &outarray)
 
SOLVER_UTILS_EXPORT void GetMaxwellFluxVector (const int var, const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &flux)
 
SOLVER_UTILS_EXPORT void GetMaxwellFlux1D (const int var, const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &flux)
 
SOLVER_UTILS_EXPORT void GetMaxwellFlux2D (const int var, const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &flux)
 
SOLVER_UTILS_EXPORT void LaxFriedrichMaxwellFlux1D (Array< OneD, Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &numfluxFwd, Array< OneD, Array< OneD, NekDouble >> &numfluxBwd)
 
SOLVER_UTILS_EXPORT void UpwindMaxwellFlux1D (Array< OneD, Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &numfluxFwd, Array< OneD, Array< OneD, NekDouble >> &numfluxBwd)
 
SOLVER_UTILS_EXPORT void AverageMaxwellFlux1D (Array< OneD, Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &numfluxFwd, Array< OneD, Array< OneD, NekDouble >> &numfluxBwd)
 
SOLVER_UTILS_EXPORT void NumericalMaxwellFlux (Array< OneD, Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &numfluxFwd, Array< OneD, Array< OneD, NekDouble >> &numfluxBwd, const NekDouble time=0.0)
 
SOLVER_UTILS_EXPORT void NumericalMaxwellFluxTM (Array< OneD, Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &numfluxFwd, Array< OneD, Array< OneD, NekDouble >> &numfluxBwd, const NekDouble time)
 
SOLVER_UTILS_EXPORT void NumericalMaxwellFluxTE (Array< OneD, Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &numfluxFwd, Array< OneD, Array< OneD, NekDouble >> &numfluxBwd, const NekDouble time)
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleGetIncidentField (const int var, const NekDouble time)
 
SOLVER_UTILS_EXPORT void Computedemdxicdote ()
 
SOLVER_UTILS_EXPORT NekDouble AvgInt (const Array< OneD, const NekDouble > &inarray)
 
SOLVER_UTILS_EXPORT NekDouble AvgAbsInt (const Array< OneD, const NekDouble > &inarray)
 
SOLVER_UTILS_EXPORT NekDouble AbsIntegral (const Array< OneD, const NekDouble > &inarray)
 
SOLVER_UTILS_EXPORT NekDouble RootMeanSquare (const Array< OneD, const NekDouble > &inarray)
 
SOLVER_UTILS_EXPORT NekDouble VectorAvgMagnitude (const Array< OneD, const Array< OneD, NekDouble >> &inarray)
 
SOLVER_UTILS_EXPORT void GramSchumitz (const Array< OneD, const Array< OneD, NekDouble >> &v1, const Array< OneD, const Array< OneD, NekDouble >> &v2, Array< OneD, Array< OneD, NekDouble >> &outarray, bool KeepTheMagnitude=true)
 
SOLVER_UTILS_EXPORT void BubbleSort (Array< OneD, NekDouble > &refarray, Array< OneD, NekDouble > &sortarray)
 
- 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_DoInitialise ()
 Sets up initial conditions. 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 bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans ()
 
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_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble >> &fieldcoeffs, std::vector< std::string > &variables)
 

Protected Attributes

InitWaveType m_InitWaveType
 
NekDouble m_InitPtx
 
NekDouble m_InitPty
 
NekDouble m_InitPtz
 
- Protected Attributes inherited from Nektar::SolverUtils::MMFSystem
NekDouble m_alpha
 
NekDouble m_Incfreq
 
int m_SmoothFactor
 
NekDouble m_SFinit
 
Array< OneD, Array< OneD, NekDouble > > m_movingframes
 
Array< OneD, Array< OneD, NekDouble > > m_surfaceNormal
 
Array< OneD, Array< OneD, NekDouble > > m_ncdotMFFwd
 
Array< OneD, Array< OneD, NekDouble > > m_ncdotMFBwd
 
Array< OneD, Array< OneD, NekDouble > > m_nperpcdotMFFwd
 
Array< OneD, Array< OneD, NekDouble > > m_nperpcdotMFBwd
 
Array< OneD, Array< OneD, NekDouble > > m_DivMF
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_CurlMF
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_MFtraceFwd
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_MFtraceBwd
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_ntimesMFFwd
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_ntimesMFBwd
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_ntimes_ntimesMFFwd
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_ntimes_ntimesMFBwd
 
Array< OneD, Array< OneD, NekDouble > > m_ZimFwd
 
Array< OneD, Array< OneD, NekDouble > > m_ZimBwd
 
Array< OneD, Array< OneD, NekDouble > > m_YimFwd
 
Array< OneD, Array< OneD, NekDouble > > m_YimBwd
 
Array< OneD, Array< OneD, NekDouble > > m_epsvec
 
Array< OneD, Array< OneD, NekDouble > > m_muvec
 
Array< OneD, Array< OneD, NekDouble > > m_negepsvecminus1
 
Array< OneD, Array< OneD, NekDouble > > m_negmuvecminus1
 
Array< OneD, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > > m_dedxi_cdot_e
 
SpatialDomains::GeomMMF m_MMFdir
 
Array< OneD, NekDoublem_MFlength
 
- 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...
 

Private Attributes

StdRegions::VarCoeffMap m_varcoeff
 Variable diffusivity. More...
 
Array< OneD, NekDoublem_epsilon
 
Array< OneD, NekDoublem_epsu
 

Friends

class MemoryManager< MMFDiffusion >
 

Additional Inherited Members

- Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum  HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
 Parameter for homogeneous expansions. More...
 
- Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
static std::string equationSystemTypeLookupIds []
 

Detailed Description

A model for cardiac conduction.

Definition at line 79 of file MMFDiffusion.h.

Constructor & Destructor Documentation

◆ ~MMFDiffusion()

Nektar::MMFDiffusion::~MMFDiffusion ( )
virtual

Desctructor.

Definition at line 184 of file MMFDiffusion.cpp.

185 {
186 }

◆ MMFDiffusion()

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

Constructor.

Definition at line 57 of file MMFDiffusion.cpp.

59  : UnsteadySystem(pSession, pGraph), MMFSystem(pSession, pGraph)
60 {
61 }
SOLVER_UTILS_EXPORT MMFSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: MMFSystem.cpp:43
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.

Member Function Documentation

◆ create()

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

Creates an instance of this class.

Definition at line 85 of file MMFDiffusion.h.

88  {
91  p->InitObject();
92  return p;
93  }
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.

◆ DoImplicitSolve()

void Nektar::MMFDiffusion::DoImplicitSolve ( const Array< OneD, const Array< OneD, NekDouble >> &  inarray,
Array< OneD, Array< OneD, NekDouble >> &  outarray,
NekDouble  time,
NekDouble  lambda 
)
protected

Solve for the diffusion term.

OdeRhs

Parameters
inarrayInput array.
outarrayOutput array.
timeCurrent simulation time.
lambdaTimestep.

Definition at line 194 of file MMFDiffusion.cpp.

198 {
199  int nvariables = inarray.size();
200  int nq = m_fields[0]->GetNpoints();
201 
203  factors[StdRegions::eFactorTau] = 1.0;
204 
205  Array<OneD, Array<OneD, NekDouble>> F(nvariables);
206  factors[StdRegions::eFactorLambda] = 1.0 / lambda;
207  F[0] = Array<OneD, NekDouble>(nq * nvariables);
208 
209  for (int n = 1; n < nvariables; ++n)
210  {
211  F[n] = F[n - 1] + nq;
212  // cout << "F["<< n<<"=" << F[n][1] <<endl;
213  }
214 
215  // We solve ( \nabla^2 - HHlambda ) Y[i] = rhs [i]
216  // inarray = input: \hat{rhs} -> output: \hat{Y}
217  // outarray = output: nabla^2 \hat{Y}
218  // where \hat = modal coeffs
219  SetBoundaryConditions(time);
220 
221  for (int i = 0; i < nvariables; ++i)
222  {
223  factors[StdRegions::eFactorLambda] = 1.0 / lambda / m_epsu[i];
224 
225  // Multiply 1.0/timestep
226  Vmath::Smul(nq, -factors[StdRegions::eFactorLambda], inarray[i], 1,
227  F[i], 1);
228 
229  /* for (int k = 0; k < 15; ++k)
230  cout << "inarray["<<i << "]"<< k<<"=" << inarray[i][k]<<endl;*/
231  // Solve a system of equations with Helmholtz solver and transform
232  // back into physical space.
233  m_fields[i]->HelmSolve(F[i], m_fields[i]->UpdateCoeffs(), factors,
234  m_varcoeff);
235 
236  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(), outarray[i]);
237  /* Array<OneD, NekDouble> coefarray = m_fields[i]->GetCoeffs();
238  for (int k = 0; k < 15; ++k)
239  cout << "inarray["<< k<<"=" << coefarray[k]<<endl;*/
240  }
241  /* for (int kk = 0; kk < 15; ++kk)
242  cout << "inarray["<< kk<<"=" <<
243  m_varcoeff[StdRegions::eVarCoeffMF3Mag][kk]<<endl;*/
244 }
StdRegions::VarCoeffMap m_varcoeff
Variable diffusivity.
Definition: MMFDiffusion.h:150
Array< OneD, NekDouble > m_epsu
Definition: MMFDiffusion.h:153
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:282
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::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorTau, m_epsu, Nektar::SolverUtils::EquationSystem::m_fields, m_varcoeff, Nektar::SolverUtils::EquationSystem::SetBoundaryConditions(), and Vmath::Smul().

Referenced by v_InitObject().

◆ DoOdeRhs()

void Nektar::MMFDiffusion::DoOdeRhs ( const Array< OneD, const Array< OneD, NekDouble >> &  inarray,
Array< OneD, Array< OneD, NekDouble >> &  outarray,
const NekDouble  time 
)
protected

Computes the reaction terms \(f(u,v)\) and \(g(u,v)\).

Definition at line 249 of file MMFDiffusion.cpp.

252 {
253  int nq = GetTotPoints();
254 
255  switch (m_TestType)
256  {
257  case eTestPlane:
258  {
259 
263 
264  m_fields[0]->GetCoords(x, y, z);
265 
266  for (int k = 0; k < nq; k++)
267  {
268  outarray[0][k] = (m_epsilon[0] + m_epsilon[1] - 1.0) * m_pi *
269  m_pi * exp(-1.0 * m_pi * m_pi * time) *
270  sin(m_pi * x[k]) * cos(m_pi * y[k]);
271  }
272  }
273  break;
274 
275  case eTestCube:
276  {
277 
281 
282  m_fields[0]->GetCoords(x, y, z);
283 
284  for (int k = 0; k < nq; k++)
285  {
286  outarray[0][k] =
287  (m_epsilon[0] + m_epsilon[1] + m_epsilon[2] - 1.0) * m_pi *
288  m_pi * exp(-1.0 * m_pi * m_pi * time) * sin(m_pi * x[k]) *
289  sin(m_pi * y[k]) * sin(m_pi * z[k]);
290  }
291  }
292  break;
293 
294  case eTestLinearSphere:
295  {
296  Array<OneD, NekDouble> temp(nq);
297 
298  NekDouble A = 2.0;
299  NekDouble B = 5.0;
300 
301  NekDouble m_a, m_b, m_c, m_d;
302  m_a = B - 1.0;
303  m_b = A * A;
304  m_c = -1.0 * B;
305  m_d = -1.0 * A * A;
306 
307  temp = Array<OneD, NekDouble>(nq, 0.0);
308  Vmath::Svtvp(nq, m_a, &inarray[0][0], 1, &temp[0], 1, &temp[0], 1);
309  Vmath::Svtvp(nq, m_b, &inarray[1][0], 1, &temp[0], 1,
310  &outarray[0][0], 1);
311 
312  temp = Array<OneD, NekDouble>(nq, 0.0);
313  Vmath::Svtvp(nq, m_c, &inarray[0][0], 1, &temp[0], 1, &temp[0], 1);
314  Vmath::Svtvp(nq, m_d, &inarray[1][0], 1, &temp[0], 1,
315  &outarray[1][0], 1);
316  }
317  break;
318 
320  {
321  NekDouble A = 2.0;
322  NekDouble B = 5.0;
323 
324  Array<OneD, NekDouble> Aonevec(nq, A);
325 
326  // cube = phys0*phys0*phy1
327  Array<OneD, NekDouble> cube(nq);
328  Vmath::Vmul(nq, &inarray[0][0], 1, &inarray[0][0], 1, &cube[0], 1);
329  Vmath::Vmul(nq, &inarray[1][0], 1, &cube[0], 1, &cube[0], 1);
330 
331  // outarray[0] = A - B*phy0 + phy0*phy0*phy1 - phy0
332  NekDouble coeff = -1.0 * B - 1.0;
333  Array<OneD, NekDouble> tmp(nq);
334  Vmath::Svtvp(nq, coeff, &inarray[0][0], 1, &cube[0], 1, &tmp[0], 1);
335  Vmath::Vadd(nq, &Aonevec[0], 1, &tmp[0], 1, &outarray[0][0], 1);
336 
337  // outarray[1] = B*phys0 - phy0*phy0*phy1
338  Vmath::Svtvm(nq, B, &inarray[0][0], 1, &cube[0], 1, &outarray[1][0],
339  1);
340  }
341  break;
342 
343  case eFHNStandard:
344  {
345  // \phi - \phi^3/3 - \psi
346  NekDouble a = 0.12;
347  NekDouble b = 0.011;
348  NekDouble c1 = 0.175;
349  NekDouble c2 = 0.03;
350  NekDouble d = 0.55;
351 
352  Array<OneD, NekDouble> tmp(nq);
353 
354  // Reaction for \phi = c1 \phi ( \phi - a)*(1 - \phi) - c2 v
355  Vmath::Smul(nq, -1.0 * c1, inarray[0], 1, outarray[0], 1);
356  Vmath::Sadd(nq, -1.0 * a, inarray[0], 1, tmp, 1);
357  Vmath::Vmul(nq, tmp, 1, inarray[0], 1, outarray[0], 1);
358  Vmath::Sadd(nq, -1.0, inarray[0], 1, tmp, 1);
359  Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
360 
361  Vmath::Smul(nq, -1.0 * c2, inarray[1], 1, tmp, 1);
362  Vmath::Vadd(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
363 
364  // Reaction for \psi = b (\phi - d \psi )
365  Vmath::Svtvp(nq, -1.0 * d, inarray[1], 1, inarray[0], 1,
366  outarray[1], 1);
367  Vmath::Smul(nq, b, outarray[1], 1, outarray[1], 1);
368  }
369  break;
370 
371  case eFHNRogers:
372  {
373  NekDouble a = 0.13;
374  NekDouble b = 0.013;
375  NekDouble c1 = 0.26;
376  NekDouble c2 = 0.1;
377  NekDouble d = 1.0;
378 
379  Array<OneD, NekDouble> tmp(nq);
380 
381  // Reaction for \phi = c1 \phi ( \phi - a)*(1 - \phi) - c2 u v
382  Vmath::Smul(nq, -1.0 * c1, inarray[0], 1, outarray[0], 1);
383  Vmath::Sadd(nq, -1.0 * a, inarray[0], 1, tmp, 1);
384  Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
385  Vmath::Sadd(nq, -1.0, inarray[0], 1, tmp, 1);
386  Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
387 
388  Vmath::Vmul(nq, inarray[0], 1, inarray[1], 1, tmp, 1);
389  Vmath::Smul(nq, -1.0 * c2, tmp, 1, tmp, 1);
390  Vmath::Vadd(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
391 
392  // Reaction for \psi = b (\phi - d \psi )
393  Vmath::Svtvp(nq, -1.0 * d, inarray[1], 1, inarray[0], 1,
394  outarray[1], 1);
395  Vmath::Smul(nq, b, outarray[1], 1, outarray[1], 1);
396  }
397  break;
398 
399  case eFHNAlievPanf:
400  {
401 
402  NekDouble a = 0.15;
403  NekDouble c1 = 8.0;
404  NekDouble c2 = 1.0;
405  NekDouble c0 = 0.002;
406  NekDouble mu1 = 0.2;
407  NekDouble mu2 = 0.3;
408 
409  Array<OneD, NekDouble> tmp(nq);
410 
411  // Reaction for \phi = c1 \phi ( \phi - a)*(1 - \phi) - c2 u v
412  Vmath::Smul(nq, -1.0 * c1, inarray[0], 1, outarray[0], 1);
413  Vmath::Sadd(nq, -1.0 * a, inarray[0], 1, tmp, 1);
414  Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
415  Vmath::Sadd(nq, -1.0, inarray[0], 1, tmp, 1);
416  Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
417 
418  Vmath::Vmul(nq, inarray[0], 1, inarray[1], 1, tmp, 1);
419  Vmath::Smul(nq, -1.0 * c2, tmp, 1, tmp, 1);
420  Vmath::Vadd(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
421 
422  // Reaction for \psi = (c0 + (\mu1 \psi/(\mu2+\phi) ) )*(-\psi - c1
423  // * \phi*(\phi - a - 1) )
424 
425  Vmath::Smul(nq, mu1, inarray[1], 1, outarray[1], 1);
426  Vmath::Sadd(nq, mu2, inarray[0], 1, tmp, 1);
427  Vmath::Vdiv(nq, outarray[1], 1, tmp, 1, outarray[1], 1);
428  Vmath::Sadd(nq, c0, outarray[1], 1, outarray[1], 1);
429 
430  Vmath::Sadd(nq, (-a - 1.0), inarray[0], 1, tmp, 1);
431  Vmath::Vmul(nq, inarray[0], 1, tmp, 1, tmp, 1);
432  Vmath::Smul(nq, c1, tmp, 1, tmp, 1);
433  Vmath::Vadd(nq, inarray[1], 1, tmp, 1, tmp, 1);
434  Vmath::Neg(nq, tmp, 1);
435 
436  Vmath::Vmul(nq, tmp, 1, outarray[1], 1, outarray[1], 1);
437  }
438  break;
439 
440  default:
441  break;
442  }
443 }
Array< OneD, NekDouble > m_epsilon
Definition: MMFDiffusion.h:152
SOLVER_UTILS_EXPORT int GetTotPoints()
@ eFHNStandard
Definition: MMFDiffusion.h:52
@ eTestLinearSphere
Definition: MMFDiffusion.h:50
@ eTestPlane
Definition: MMFDiffusion.h:48
@ eTestCube
Definition: MMFDiffusion.h:49
@ eTestNonlinearSphere
Definition: MMFDiffusion.h:51
@ eFHNRogers
Definition: MMFDiffusion.h:53
@ eFHNAlievPanf
Definition: MMFDiffusion.h:54
double NekDouble
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 Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:622
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:518
void Svtvm(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x - y
Definition: Vmath.cpp:664
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
void Vdiv(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:284
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha - x.
Definition: Vmath.cpp:384

References Nektar::eFHNAlievPanf, Nektar::eFHNRogers, Nektar::eFHNStandard, Nektar::eTestCube, Nektar::eTestLinearSphere, Nektar::eTestNonlinearSphere, Nektar::eTestPlane, Nektar::SolverUtils::EquationSystem::GetTotPoints(), m_epsilon, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::MMFSystem::m_pi, m_TestType, Vmath::Neg(), Vmath::Sadd(), Vmath::Smul(), Vmath::Svtvm(), Vmath::Svtvp(), Vmath::Vadd(), Vmath::Vdiv(), and Vmath::Vmul().

Referenced by v_InitObject().

◆ Morphogenesis()

void Nektar::MMFDiffusion::Morphogenesis ( const NekDouble  time,
unsigned int  field,
Array< OneD, NekDouble > &  outfield 
)
protected

Definition at line 569 of file MMFDiffusion.cpp.

571 {
572  int nq = GetTotPoints();
573 
574  int i, m, n, ind;
575  NekDouble a_n, d_n, gamma_n;
576  NekDouble A_mn, C_mn, theta, phi, radius;
577 
578  std::complex<double> Spericharmonic, delta_n, temp;
579  std::complex<double> varphi0, varphi1;
580  std::complex<double> B_mn, D_mn;
581 
582  // Set some parameter values
583  int Maxn = 6;
584  int Maxm = 2 * Maxn - 1;
585 
586  NekDouble A = 2.0;
587  NekDouble B = 5.0;
588 
589  NekDouble m_mu = 0.001;
590  NekDouble m_nu = 0.002;
591 
592  NekDouble m_a, m_b, m_c, m_d;
593 
594  m_a = B - 1.0;
595  m_b = A * A;
596  m_c = -1.0 * B;
597  m_d = -1.0 * A * A;
598 
601 
602  for (i = 0; i < Maxn; ++i)
603  {
604  Ainit[i] = Array<OneD, NekDouble>(Maxm, 0.0);
605  Binit[i] = Array<OneD, NekDouble>(Maxm, 0.0);
606  }
607 
608  Ainit[5][0] = -0.5839;
609  Ainit[5][1] = -0.8436;
610  Ainit[5][2] = -0.4764;
611  Ainit[5][3] = 0.6475;
612  Ainit[5][4] = 0.1886;
613  Ainit[5][5] = 0.8709;
614  Ainit[5][6] = -0.8338;
615  Ainit[5][7] = 0.1795;
616  Ainit[5][8] = -0.7873;
617  Ainit[5][9] = 0.8842;
618  Ainit[5][10] = 0.2943;
619 
620  Binit[5][0] = -0.6263;
621  Binit[5][1] = 0.9803;
622  Binit[5][2] = 0.7222;
623  Binit[5][3] = 0.5945;
624  Binit[5][4] = 0.6026;
625  Binit[5][5] = -0.2076;
626  Binit[5][6] = 0.4556;
627  Binit[5][7] = 0.6024;
628  Binit[5][8] = 0.9695;
629  Binit[5][9] = -0.4936;
630  Binit[5][10] = 0.1098;
631 
637 
638  m_fields[0]->GetCoords(x, y, z);
639  for (int i = 0; i < nq; ++i)
640  {
641  radius = sqrt(x[i] * x[i] + y[i] * y[i] + z[i] * z[i]);
642 
643  // theta is in [0, pi]
644  theta = asin(z[i] / radius) + 0.5 * m_pi;
645 
646  // phi is in [0, 2*pi]
647  phi = atan2(y[i], x[i]) + m_pi;
648 
649  varphi0 = 0.0 * varphi0;
650  varphi1 = 0.0 * varphi1;
651  for (n = 0; n < Maxn; ++n)
652  {
653  // Set up parameters
654  a_n = m_a - m_mu * (n * (n + 1) / radius / radius);
655  d_n = m_d - m_nu * (n * (n + 1) / radius / radius);
656 
657  gamma_n = 0.5 * (a_n + d_n);
658 
659  temp = (a_n + d_n) * (a_n + d_n) - 4.0 * (a_n * d_n - m_b * m_c);
660  delta_n = 0.5 * sqrt(temp);
661 
662  for (m = -n; m <= n; ++m)
663  {
664  ind = m + n;
665  A_mn = Ainit[n][ind];
666  C_mn = Binit[n][ind];
667 
668  B_mn = ((a_n - gamma_n) * Ainit[n][ind] + m_b * Binit[n][ind]) /
669  delta_n;
670  D_mn = (m_c * Ainit[n][ind] + (d_n - gamma_n) * Binit[n][ind]) /
671  delta_n;
672 
673  Spericharmonic =
674  boost::math::spherical_harmonic(n, m, theta, phi);
675  varphi0 += exp(gamma_n * time) *
676  (A_mn * cosh(delta_n * time) +
677  B_mn * sinh(delta_n * time)) *
678  Spericharmonic;
679  varphi1 += exp(gamma_n * time) *
680  (C_mn * cosh(delta_n * time) +
681  D_mn * sinh(delta_n * time)) *
682  Spericharmonic;
683  }
684  }
685 
686  u[i] = varphi0.real();
687  v[i] = varphi1.real();
688  }
689 
690  switch (field)
691  {
692  case 0:
693  {
694  outfield = u;
695  }
696  break;
697 
698  case 1:
699  {
700  outfield = v;
701  }
702  break;
703  }
704 }
NekDouble m_mu
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:291

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, m_mu, Nektar::SolverUtils::MMFSystem::m_pi, and tinysimd::sqrt().

Referenced by v_EvaluateExactSolution(), and v_SetInitialConditions().

◆ PlanePhiWave()

Array< OneD, NekDouble > Nektar::MMFDiffusion::PlanePhiWave ( )
protected

Definition at line 706 of file MMFDiffusion.cpp.

707 {
708  int nq = GetTotPoints();
709  Array<OneD, NekDouble> outarray(nq, 0.0);
710 
714 
715  m_fields[0]->GetCoords(x, y, z);
716 
717  NekDouble xmin, ymin, xmax;
718 
719  xmin = Vmath::Vmin(nq, x, 1);
720  xmax = Vmath::Vmax(nq, x, 1);
721  ymin = Vmath::Vmin(nq, y, 1);
722 
723  NekDouble xp, yp, xp2;
724  for (int i = 0; i < nq; i++)
725  {
726  switch (m_InitWaveType)
727  {
728  case eLeft:
729  {
730  NekDouble radiusofinit = 4.0;
731  NekDouble frontstiff = 0.1;
732 
733  xp = x[i] - xmin;
734  outarray[i] =
735  1.0 / (1.0 + exp((xp - radiusofinit) / frontstiff));
736  }
737  break;
738 
739  case eBothEnds:
740  {
741  NekDouble radiusofinit = 3.0;
742  NekDouble frontstiff = 0.1;
743 
744  xp = x[i] - xmin;
745  xp2 = x[i] - xmax;
746 
747  outarray[i] =
748  1.0 / (1.0 +
749  exp((sqrt(xp * xp) - radiusofinit) / frontstiff)) +
750  1.0 / (1.0 +
751  exp((sqrt(xp2 * xp2) - radiusofinit) / frontstiff));
752  }
753  break;
754 
755  case eCenter:
756  {
757  NekDouble radiusofinit = 6.0;
758  NekDouble frontstiff = 0.1;
759 
760  // NekDouble xc = 0.5*(Vmath::Vmax(nq, x, 1) + Vmath::Vmin(nq,
761  // x, 1));
762 
763  xp = x[i] - xmin;
764  outarray[i] =
765  1.0 / (1.0 + exp((xp - radiusofinit) / frontstiff));
766  }
767  break;
768 
769  case eLeftBottomCorner:
770  {
771  NekDouble radiusofinit = 6.0;
772  NekDouble frontstiff = 0.1;
773  NekDouble bs = 2.0;
774 
775  xp = x[i] - xmin;
776  yp = y[i] - ymin;
777  outarray[i] =
778  1.0 /
779  (1.0 + exp((sqrt(xp * xp + yp * yp) / bs - radiusofinit) /
780  frontstiff));
781  }
782  break;
783 
784  case ePoint:
785  {
786  NekDouble xloc, yloc, zloc, rad;
787  NekDouble radiusofinit = 10.0;
788 
789  xloc = x[i] - m_InitPtx;
790  yloc = y[i] - m_InitPty;
791  zloc = z[i] - m_InitPtz;
792 
793  rad = sqrt(xloc * xloc + yloc * yloc + zloc * zloc);
794 
795  xloc = xloc / radiusofinit;
796  yloc = yloc / radiusofinit;
797  zloc = zloc / radiusofinit;
798 
799  if (rad < radiusofinit)
800  {
801  outarray[i] =
802  exp(-(1.0 / 2.0) *
803  (xloc * xloc + yloc * yloc + zloc * zloc));
804  }
805 
806  else
807  {
808  outarray[i] = 0.0;
809  }
810  }
811  break;
812 
813  case eSpiralDock:
814  {
815  NekDouble radiusofinit = 3.0;
816  NekDouble frontstiff = 0.1;
817  xp = x[i] - 4.0;
818  yp = y[i];
819  outarray[i] =
820  (1.0 / (1.0 + exp(2.0 * yp))) *
821  (1.0 / (1.0 + exp(-2.0 * xp))) *
822  (1.0 / (1.0 + exp((xp - radiusofinit) / frontstiff)));
823  }
824  break;
825 
826  default:
827  break;
828  }
829  }
830 
831  return outarray;
832 }
InitWaveType m_InitWaveType
Definition: MMFDiffusion.h:108
static NekDouble rad(NekDouble x, NekDouble y)
Definition: Interpreter.cpp:86
@ eLeftBottomCorner
Definition: MMFDiffusion.h:68
@ eBothEnds
Definition: MMFDiffusion.h:66
@ eSpiralDock
Definition: MMFDiffusion.h:70
T Vmin(int n, const T *x, const int incx)
Return the minimum element in x - called vmin to avoid conflict with min.
Definition: Vmath.cpp:1050
T Vmax(int n, const T *x, const int incx)
Return the maximum element in x – called vmax to avoid conflict with max.
Definition: Vmath.cpp:945

References Nektar::eBothEnds, Nektar::eCenter, Nektar::eLeft, Nektar::eLeftBottomCorner, Nektar::ePoint, Nektar::eSpiralDock, Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, m_InitPtx, m_InitPty, m_InitPtz, m_InitWaveType, Nektar::LibUtilities::rad(), tinysimd::sqrt(), Vmath::Vmax(), and Vmath::Vmin().

Referenced by v_SetInitialConditions().

◆ TestCubeProblem()

void Nektar::MMFDiffusion::TestCubeProblem ( const NekDouble  time,
Array< OneD, NekDouble > &  outfield 
)
protected

Definition at line 549 of file MMFDiffusion.cpp.

552 {
553  int nq = GetTotPoints();
554 
558 
559  m_fields[0]->GetCoords(x, y, z);
560 
561  outfield = Array<OneD, NekDouble>(nq);
562  for (int k = 0; k < nq; k++)
563  {
564  outfield[k] = exp(-1.0 * m_pi * m_pi * time) * sin(m_pi * x[k]) *
565  sin(m_pi * y[k]) * sin(m_pi * z[k]);
566  }
567 }

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::SolverUtils::MMFSystem::m_pi.

Referenced by v_EvaluateExactSolution(), and v_SetInitialConditions().

◆ TestPlaneProblem()

void Nektar::MMFDiffusion::TestPlaneProblem ( const NekDouble  time,
Array< OneD, NekDouble > &  outfield 
)
protected

Definition at line 529 of file MMFDiffusion.cpp.

532 {
533  int nq = GetTotPoints();
534 
538 
539  m_fields[0]->GetCoords(x, y, z);
540 
541  outfield = Array<OneD, NekDouble>(nq);
542  for (int k = 0; k < nq; k++)
543  {
544  outfield[k] = exp(-1.0 * m_pi * m_pi * time) * sin(m_pi * x[k]) *
545  cos(m_pi * y[k]);
546  }
547 }

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::SolverUtils::MMFSystem::m_pi.

Referenced by v_EvaluateExactSolution(), and v_SetInitialConditions().

◆ v_EvaluateExactSolution()

void Nektar::MMFDiffusion::v_EvaluateExactSolution ( unsigned int  field,
Array< OneD, NekDouble > &  outfield,
const NekDouble  time 
)
protectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 834 of file MMFDiffusion.cpp.

837 {
838  switch (m_TestType)
839  {
840  case eTestPlane:
841  {
842  TestPlaneProblem(time, outfield);
843  }
844  break;
845 
846  case eTestCube:
847  {
848  TestCubeProblem(time, outfield);
849  }
850  break;
851 
852  case eTestLinearSphere:
854  {
855  Morphogenesis(time, field, outfield);
856  }
857  break;
858 
859  case eFHNStandard:
860  case eFHNRogers:
861  case eFHNAlievPanf:
862  {
863  int nq = GetTotPoints();
864  outfield = Array<OneD, NekDouble>(nq, 0.0);
865  }
866  /* Falls through. */
867  default:
868  {
869  EquationSystem::v_EvaluateExactSolution(field, outfield, time);
870  }
871  break;
872  }
873 }
void Morphogenesis(const NekDouble time, unsigned int field, Array< OneD, NekDouble > &outfield)
void TestCubeProblem(const NekDouble time, Array< OneD, NekDouble > &outfield)
void TestPlaneProblem(const NekDouble time, Array< OneD, NekDouble > &outfield)
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution(unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)

References Nektar::eFHNAlievPanf, Nektar::eFHNRogers, Nektar::eFHNStandard, Nektar::eTestCube, Nektar::eTestLinearSphere, Nektar::eTestNonlinearSphere, Nektar::eTestPlane, Nektar::SolverUtils::EquationSystem::GetTotPoints(), m_TestType, Morphogenesis(), TestCubeProblem(), TestPlaneProblem(), and Nektar::SolverUtils::EquationSystem::v_EvaluateExactSolution().

◆ v_GenerateSummary()

void Nektar::MMFDiffusion::v_GenerateSummary ( SolverUtils::SummaryList s)
protectedvirtual

Prints a summary of the model parameters.

Reimplemented from Nektar::SolverUtils::MMFSystem.

Definition at line 875 of file MMFDiffusion.cpp.

876 {
879  SolverUtils::AddSummaryItem(s, "epsilon0", m_epsilon[0]);
880  SolverUtils::AddSummaryItem(s, "epsilon1", m_epsilon[1]);
881  SolverUtils::AddSummaryItem(s, "epsilon2", m_epsilon[2]);
883  {
884  SolverUtils::AddSummaryItem(s, "epsilon for u", m_epsu[0]);
885  SolverUtils::AddSummaryItem(s, "epsilon for v", m_epsu[1]);
886  }
887 }
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s)
Print a summary of time stepping parameters.
Definition: MMFSystem.cpp:2469
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
const char *const TestTypeMap[]
Definition: MMFDiffusion.h:58

References Nektar::SolverUtils::AddSummaryItem(), Nektar::eTestLinearSphere, m_epsilon, m_epsu, m_TestType, Nektar::TestTypeMap, and Nektar::SolverUtils::MMFSystem::v_GenerateSummary().

◆ v_InitObject()

void Nektar::MMFDiffusion::v_InitObject ( bool  DeclareField = true)
protectedvirtual

Init object for UnsteadySystem class.

Initialization object for UnsteadySystem class.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 63 of file MMFDiffusion.cpp.

64 {
65  UnsteadySystem::v_InitObject(DeclareFields);
66 
67  int nq = m_fields[0]->GetNpoints();
68  int nvar = m_fields.size();
69  int MFdim = 3;
70 
71  // Diffusivity coefficient for e^j
73  m_session->LoadParameter("epsilon0", m_epsilon[0], 1.0);
74  m_session->LoadParameter("epsilon1", m_epsilon[1], 1.0);
75  m_session->LoadParameter("epsilon2", m_epsilon[2], 1.0);
76 
77  // Diffusivity coefficient for u^j
78  m_epsu = Array<OneD, NekDouble>(nvar + 1);
79  m_session->LoadParameter("epsu0", m_epsu[0], 1.0);
80  m_session->LoadParameter("epsu1", m_epsu[1], 1.0);
81 
82  m_session->LoadParameter("InitPtx", m_InitPtx, 0.0);
83  m_session->LoadParameter("InitPty", m_InitPty, 0.0);
84  m_session->LoadParameter("InitPtz", m_InitPtz, 0.0);
85 
86  int shapedim = m_fields[0]->GetShapeDimension();
87  Array<OneD, Array<OneD, NekDouble>> Anisotropy(shapedim);
88  for (int j = 0; j < shapedim; ++j)
89  {
90  Anisotropy[j] = Array<OneD, NekDouble>(nq, 1.0);
91  Vmath::Fill(nq, sqrt(m_epsilon[j]), &Anisotropy[j][0], 1);
92  }
93 
94  MMFSystem::MMFInitObject(Anisotropy);
95 
96  // Define ProblemType
97  if (m_session->DefinesSolverInfo("TESTTYPE"))
98  {
99  std::string TestTypeStr = m_session->GetSolverInfo("TESTTYPE");
100  int i;
101  for (i = 0; i < (int)SIZE_TestType; ++i)
102  {
103  if (boost::iequals(TestTypeMap[i], TestTypeStr))
104  {
105  m_TestType = (TestType)i;
106  break;
107  }
108  }
109  }
110  else
111  {
112  m_TestType = (TestType)0;
113  }
114 
115  if (m_session->DefinesSolverInfo("INITWAVETYPE"))
116  {
117  std::string InitWaveTypeStr = m_session->GetSolverInfo("INITWAVETYPE");
118  for (int i = 0; i < (int)SIZE_TestType; ++i)
119  {
120  if (boost::iequals(InitWaveTypeMap[i], InitWaveTypeStr))
121  {
123  break;
124  }
125  }
126  }
127  else
128  {
130  }
131 
132  StdRegions::VarCoeffType MMFCoeffs[15] = {
141 
142  int indx;
143  Array<OneD, NekDouble> tmp(nq);
144  for (int k = 0; k < MFdim; ++k)
145  {
146  // For Moving Frames
147  indx = 5 * k;
148 
149  for (int j = 0; j < m_spacedim; ++j)
150  {
151  m_varcoeff[MMFCoeffs[indx + j]] = Array<OneD, NekDouble>(nq, 0.0);
152  Vmath::Vcopy(nq, &m_movingframes[k][j * nq], 1,
153  &m_varcoeff[MMFCoeffs[indx + j]][0], 1);
154  }
155 
156  // m_DivMF
157  m_varcoeff[MMFCoeffs[indx + 3]] = Array<OneD, NekDouble>(nq, 0.0);
158  Vmath::Vcopy(nq, &m_DivMF[k][0], 1, &m_varcoeff[MMFCoeffs[indx + 3]][0],
159  1);
160 
161  // \| e^k \|
162  m_varcoeff[MMFCoeffs[indx + 4]] = Array<OneD, NekDouble>(nq, 0.0);
163  tmp = Array<OneD, NekDouble>(nq, 0.0);
164  for (int i = 0; i < m_spacedim; ++i)
165  {
166  Vmath::Vvtvp(nq, &m_movingframes[k][i * nq], 1,
167  &m_movingframes[k][i * nq], 1, &tmp[0], 1, &tmp[0], 1);
168  }
169 
170  Vmath::Vcopy(nq, &tmp[0], 1, &m_varcoeff[MMFCoeffs[indx + 4]][0], 1);
171  }
172 
173  if (!m_explicitDiffusion)
174  {
176  }
177 
179 }
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)
Computes the reaction terms and .
void DoImplicitSolve(const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, NekDouble time, NekDouble lambda)
Solve for the diffusion term.
int m_spacedim
Spatial dimension (>= expansion dim).
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Array< OneD, Array< OneD, NekDouble > > m_DivMF
Definition: MMFSystem.h:195
Array< OneD, Array< OneD, NekDouble > > m_movingframes
Definition: MMFSystem.h:186
SOLVER_UTILS_EXPORT void MMFInitObject(const Array< OneD, const Array< OneD, NekDouble >> &Anisotropy, const int TangentXelem=-1)
Definition: MMFSystem.cpp:53
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
virtual SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareField=true)
Init object for UnsteadySystem class.
const char *const InitWaveTypeMap[]
Definition: MMFDiffusion.h:74
@ SIZE_TestType
Length of enum list.
Definition: MMFDiffusion.h:55
void Vvtvp(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)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:574
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:45
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255

References Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), DoImplicitSolve(), DoOdeRhs(), Nektar::StdRegions::eVarCoeffMF1Div, Nektar::StdRegions::eVarCoeffMF1Mag, Nektar::StdRegions::eVarCoeffMF1x, Nektar::StdRegions::eVarCoeffMF1y, Nektar::StdRegions::eVarCoeffMF1z, Nektar::StdRegions::eVarCoeffMF2Div, Nektar::StdRegions::eVarCoeffMF2Mag, Nektar::StdRegions::eVarCoeffMF2x, Nektar::StdRegions::eVarCoeffMF2y, Nektar::StdRegions::eVarCoeffMF2z, Nektar::StdRegions::eVarCoeffMF3Div, Nektar::StdRegions::eVarCoeffMF3Mag, Nektar::StdRegions::eVarCoeffMF3x, Nektar::StdRegions::eVarCoeffMF3y, Nektar::StdRegions::eVarCoeffMF3z, Vmath::Fill(), Nektar::InitWaveTypeMap, Nektar::SolverUtils::MMFSystem::m_DivMF, m_epsilon, m_epsu, Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion, Nektar::SolverUtils::EquationSystem::m_fields, m_InitPtx, m_InitPty, m_InitPtz, m_InitWaveType, Nektar::SolverUtils::MMFSystem::m_movingframes, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, m_TestType, m_varcoeff, Nektar::SolverUtils::MMFSystem::MMFInitObject(), Nektar::SIZE_TestType, tinysimd::sqrt(), Nektar::TestTypeMap, Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Vmath::Vcopy(), and Vmath::Vvtvp().

◆ v_SetInitialConditions()

void Nektar::MMFDiffusion::v_SetInitialConditions ( NekDouble  initialtime,
bool  dumpInitialConditions,
const int  domain 
)
protectedvirtual

Sets a custom initial condition.

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 448 of file MMFDiffusion.cpp.

451 {
452  boost::ignore_unused(domain);
453 
454  int nq = GetTotPoints();
455 
456  switch (m_TestType)
457  {
458  case eTestPlane:
459  {
461 
462  TestPlaneProblem(initialtime, u);
463  m_fields[0]->SetPhys(u);
464  }
465  break;
466 
467  case eTestCube:
468  {
470 
471  TestCubeProblem(initialtime, u);
472  m_fields[0]->SetPhys(u);
473  /*for (int k=0; k<nq; ++k)
474  {
475  //for (int j=0; j<m_spacedim; ++j)
476  //{
477  cout << "_varcoeff" << u[k] <<endl;
478  // }
479  }*/
480  }
481  break;
482 
483  case eTestLinearSphere:
485  {
488 
489  Morphogenesis(initialtime, 0, u);
490  Morphogenesis(initialtime, 1, v);
491 
492  m_fields[0]->SetPhys(u);
493  m_fields[1]->SetPhys(v);
494  }
495  break;
496 
497  case eFHNStandard:
498  case eFHNRogers:
499  case eFHNAlievPanf:
500  {
501  Array<OneD, NekDouble> Zero(nq, 0.0);
502  m_fields[0]->SetPhys(PlanePhiWave());
503  m_fields[1]->SetPhys(Zero);
504  }
505  break;
506 
507  default:
508  {
509  EquationSystem::v_SetInitialConditions(initialtime, false);
510  }
511  break;
512  }
513 
514  // forward transform to fill the modal coeffs
515  for (int i = 0; i < m_fields.size(); ++i)
516  {
517  m_fields[i]->SetPhysState(true);
518  m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
519  m_fields[i]->UpdateCoeffs());
520  }
521 
522  if (dumpInitialConditions)
523  {
524  std::string outname = m_sessionName + "_initial.chk";
525  WriteFld(outname);
526  }
527 }
Array< OneD, NekDouble > PlanePhiWave()
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
SOLVER_UTILS_EXPORT void WriteFld(const std::string &outname)
Write field data to the given filename.
std::string m_sessionName
Name of the session.
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:492

References Nektar::eFHNAlievPanf, Nektar::eFHNRogers, Nektar::eFHNStandard, Nektar::eTestCube, Nektar::eTestLinearSphere, Nektar::eTestNonlinearSphere, Nektar::eTestPlane, Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_sessionName, m_TestType, Morphogenesis(), PlanePhiWave(), TestCubeProblem(), TestPlaneProblem(), Nektar::SolverUtils::EquationSystem::v_SetInitialConditions(), Nektar::SolverUtils::EquationSystem::WriteFld(), and Vmath::Zero().

Friends And Related Function Documentation

◆ MemoryManager< MMFDiffusion >

friend class MemoryManager< MMFDiffusion >
friend

Definition at line 74 of file MMFDiffusion.h.

Member Data Documentation

◆ className

string Nektar::MMFDiffusion::className
static
Initial value:
=
"MMFDiffusion", MMFDiffusion::create, "MMFDiffusion equation.")
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.
Definition: MMFDiffusion.h:85
EquationSystemFactory & GetEquationSystemFactory()

Name of class.

Definition at line 96 of file MMFDiffusion.h.

◆ m_epsilon

Array<OneD, NekDouble> Nektar::MMFDiffusion::m_epsilon
private

Definition at line 152 of file MMFDiffusion.h.

Referenced by DoOdeRhs(), v_GenerateSummary(), and v_InitObject().

◆ m_epsu

Array<OneD, NekDouble> Nektar::MMFDiffusion::m_epsu
private

Definition at line 153 of file MMFDiffusion.h.

Referenced by DoImplicitSolve(), v_GenerateSummary(), and v_InitObject().

◆ m_InitPtx

NekDouble Nektar::MMFDiffusion::m_InitPtx
protected

Definition at line 146 of file MMFDiffusion.h.

Referenced by PlanePhiWave(), and v_InitObject().

◆ m_InitPty

NekDouble Nektar::MMFDiffusion::m_InitPty
protected

Definition at line 146 of file MMFDiffusion.h.

Referenced by PlanePhiWave(), and v_InitObject().

◆ m_InitPtz

NekDouble Nektar::MMFDiffusion::m_InitPtz
protected

Definition at line 146 of file MMFDiffusion.h.

Referenced by PlanePhiWave(), and v_InitObject().

◆ m_InitWaveType

InitWaveType Nektar::MMFDiffusion::m_InitWaveType
protected

Definition at line 108 of file MMFDiffusion.h.

Referenced by PlanePhiWave(), and v_InitObject().

◆ m_TestType

TestType Nektar::MMFDiffusion::m_TestType

◆ m_varcoeff

StdRegions::VarCoeffMap Nektar::MMFDiffusion::m_varcoeff
private

Variable diffusivity.

Definition at line 150 of file MMFDiffusion.h.

Referenced by DoImplicitSolve(), and v_InitObject().