Classes
class	Advection
	Defines a callback function which evaluates the flux vector. More...

class	Advection3DHomogeneous1D

class	AdvectionFR

class	AdvectionNonConservative

class	AdvectionSystem
	A base class for PDEs which include an advection component. More...

class	AdvectionWeakDG

class	Diffusion

class	Diffusion3DHomogeneous1D

class	DiffusionLDG

class	DiffusionLDGNS

class	DiffusionLFR

class	DiffusionLFRNS

class	Driver
	Base class for the development of solvers. More...

class	DriverAdaptive
	Base class for the adaptive polynomial order driver. More...

class	DriverArnoldi
	Base class for the development of solvers. More...

class	DriverArpack
	Base class for the development of solvers. More...

class	DriverModifiedArnoldi

class	DriverStandard
	Base class for the development of solvers. More...

class	DriverSteadyState

class	EquationSystem
	A base class for describing how to solve specific equations. More...

class	Filter

class	FilterAeroForces

class	FilterAverageFields

class	FilterCheckpoint

class	FilterEnergy1D
	Filter for one-dimensional energy spectrum. More...

class	FilterEnergyBase

class	FilterHistoryPoints

class	FilterModalEnergy

class	FilterMovingAverage

class	FilterReynoldsStresses
	Append Reynolds stresses to the average fields. More...

class	FilterSampler

class	FilterThresholdMax

class	FilterThresholdMin

class	Forcing
	Defines a forcing term to be explicitly applied. More...

class	ForcingAbsorption

class	ForcingBody

class	ForcingNoise

class	ForcingProgrammatic

class	HomoRSScalar
	Wrapper class for Riemann solver scalars. More...

class	HomoRSVector
	Wrapper class for Riemann solver scalars. More...

class	RiemannSolver
	The RiemannSolver class provides an abstract interface under which solvers for various Riemann problems can be implemented. More...

class	UnsteadySystem
	Base class for unsteady solvers. More...

class	UpwindLDGSolver
	Upwind scheme Riemann solver for LDG. More...

class	UpwindSolver
	Upwind scheme Riemann solver. More...

Typedefs
typedef boost::shared_ptr < Advection >	AdvectionSharedPtr
	A shared pointer to an Advection object. More...

typedef LibUtilities::NekFactory < std::string, Advection, std::string >	AdvectionFactory
	Datatype of the NekFactory used to instantiate classes derived from the Advection class. More...

typedef boost::shared_ptr < AdvectionSystem >	AdvectionSystemSharedPtr
	Shared pointer to an AdvectionSystem class. More...

typedef std::vector< std::pair < std::string, std::string > >	SummaryList

typedef boost::function< void(const int, const int, const Array < OneD, Array< OneD, NekDouble > > &, Array< OneD, Array< OneD, NekDouble > > &, Array< OneD, Array< OneD, NekDouble > > &)>	DiffusionFluxVecCB

typedef boost::function< void(const Array< OneD, Array< OneD, NekDouble > > &, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &)>	DiffusionFluxVecCBNS

typedef boost::function< void(const Array< OneD, Array< OneD, NekDouble > > &, Array< OneD, NekDouble > &)>	DiffusionArtificialDiffusion

typedef boost::shared_ptr < Diffusion >	DiffusionSharedPtr
	A shared pointer to an EquationSystem object. More...

typedef LibUtilities::NekFactory < std::string, Diffusion, std::string >	DiffusionFactory
	Datatype of the NekFactory used to instantiate classes derived from the Diffusion class. More...

typedef boost::shared_ptr < DiffusionLDGNS >	DiffusionLDGNSSharedPtr

typedef boost::shared_ptr < DiffusionLFRNS >	DiffusionLFRNSSharedPtr

typedef boost::shared_ptr< Driver >	DriverSharedPtr
	A shared pointer to a Driver object. More...

typedef LibUtilities::NekFactory < std::string, Driver, const LibUtilities::SessionReaderSharedPtr & >	DriverFactory
	Datatype of the NekFactory used to instantiate classes derived from the Driver class. More...

typedef boost::shared_ptr < EquationSystem >	EquationSystemSharedPtr
	A shared pointer to an EquationSystem object. More...

typedef LibUtilities::NekFactory < std::string, EquationSystem, const LibUtilities::SessionReaderSharedPtr & >	EquationSystemFactory
	Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...

typedef boost::shared_ptr< Filter >	FilterSharedPtr
	A shared pointer to a Driver object. More...

typedef LibUtilities::NekFactory < std::string, Filter, const LibUtilities::SessionReaderSharedPtr &, const std::map< std::string, std::string > & >	FilterFactory
	Datatype of the NekFactory used to instantiate classes derived from the Driver class. More...

typedef boost::shared_ptr < FilterAeroForces >	FilterAeroForcesSharedPtr

typedef LibUtilities::NekFactory < std::string, Forcing, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const unsigned int &, const TiXmlElement * >	ForcingFactory
	Declaration of the forcing factory. More...

typedef boost::function< const Array< OneD, const NekDouble > &()>	RSScalarFuncType

typedef boost::function< const Array< OneD, const Array< OneD, NekDouble > > &()>	RSVecFuncType

typedef boost::function < NekDouble()>	RSParamFuncType

typedef boost::shared_ptr < RiemannSolver >	RiemannSolverSharedPtr
	A shared pointer to an EquationSystem object. More...

typedef LibUtilities::NekFactory < std::string, RiemannSolver >	RiemannSolverFactory
	Datatype of the NekFactory used to instantiate classes derived from the RiemannSolver class. More...

Enumerations
enum	EvolutionOperatorType { eNonlinear, eDirect, eAdjoint, eTransientGrowth, eSkewSymmetric, eAdaptiveSFD }

Functions
AdvectionFactory &	GetAdvectionFactory ()
	Gets the factory for initialising advection objects. More...

void	UpdateGeometry (SpatialDomains::MeshGraphSharedPtr graph, Array< OneD, MultiRegions::ExpListSharedPtr > &fields, bool modal)
	Update geometry according to displacement that is in current fields. More...

void	AddSummaryItem (SummaryList &l, const std::string &name, const std::string &value)
	Adds a summary item to the summary info list. More...

void	AddSummaryItem (SummaryList &l, const std::string &name, const int &value)
	Adds a summary item to the summary info list. More...

void	AddSummaryItem (SummaryList &l, const std::string &name, const NekDouble &value)
	Adds a summary item to the summary info list. More...

DiffusionFactory &	GetDiffusionFactory ()

DriverFactory &	GetDriverFactory ()

EquationSystemFactory &	GetEquationSystemFactory ()

FilterFactory &	GetFilterFactory ()

ForcingFactory &	GetForcingFactory ()
	Declaration of the forcing factory singleton. More...

RiemannSolverFactory &	GetRiemannSolverFactory ()

Variables
SOLVER_UTILS_EXPORT typedef boost::shared_ptr< Forcing >	ForcingSharedPtr
	A shared pointer to an EquationSystem object. More...

SOLVER_UTILS_EXPORT typedef boost::shared_ptr < ForcingProgrammatic >	ForcingProgrammaticSharedPtr
	A shared pointer to an EquationSystem object. More...

Typedef Documentation

typedef LibUtilities::NekFactory<std::string, Advection,std::string> Nektar::SolverUtils::AdvectionFactory

Datatype of the NekFactory used to instantiate classes derived from the Advection class.

Definition at line 163 of file Advection.h.

typedef boost::shared_ptr<Advection> Nektar::SolverUtils::AdvectionSharedPtr

A shared pointer to an Advection object.

Definition at line 158 of file Advection.h.

typedef boost::shared_ptr<AdvectionSystem> Nektar::SolverUtils::AdvectionSystemSharedPtr

Shared pointer to an AdvectionSystem class.

Definition at line 68 of file AdvectionSystem.h.

typedef boost::function<void ( const Array<OneD, Array<OneD, NekDouble> >&, Array<OneD, NekDouble >&)> Nektar::SolverUtils::DiffusionArtificialDiffusion

Definition at line 69 of file Diffusion.h.

typedef LibUtilities::NekFactory<std::string, Diffusion, std::string> Nektar::SolverUtils::DiffusionFactory

Datatype of the NekFactory used to instantiate classes derived from the Diffusion class.

Definition at line 168 of file Diffusion.h.

typedef boost::function<void ( const int, const int, const Array<OneD, Array<OneD, NekDouble> >&, Array<OneD, Array<OneD, NekDouble> >&, Array<OneD, Array<OneD, NekDouble> >&)> Nektar::SolverUtils::DiffusionFluxVecCB

Definition at line 58 of file Diffusion.h.

typedef boost::function<void ( const Array<OneD, Array<OneD, NekDouble> >&, Array<OneD, Array<OneD, Array<OneD, NekDouble> > >&, Array<OneD, Array<OneD, Array<OneD, NekDouble> > >&)> Nektar::SolverUtils::DiffusionFluxVecCBNS

Definition at line 64 of file Diffusion.h.

typedef boost::shared_ptr<DiffusionLDGNS> Nektar::SolverUtils::DiffusionLDGNSSharedPtr

Definition at line 125 of file DiffusionLDGNS.h.

typedef boost::shared_ptr<DiffusionLFRNS> Nektar::SolverUtils::DiffusionLFRNSSharedPtr

Definition at line 201 of file DiffusionLFRNS.h.

typedef boost::shared_ptr<Diffusion> Nektar::SolverUtils::DiffusionSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 164 of file Diffusion.h.

typedef LibUtilities::NekFactory<std::string, Driver, const LibUtilities::SessionReaderSharedPtr&> Nektar::SolverUtils::DriverFactory

Datatype of the NekFactory used to instantiate classes derived from the Driver class.

Definition at line 60 of file Driver.h.

typedef boost::shared_ptr<Driver> Nektar::SolverUtils::DriverSharedPtr

A shared pointer to a Driver object.

Definition at line 52 of file Driver.h.

typedef LibUtilities::NekFactory< std::string, EquationSystem, const LibUtilities::SessionReaderSharedPtr& > Nektar::SolverUtils::EquationSystemFactory

Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

Definition at line 65 of file EquationSystem.h.

typedef boost::shared_ptr<EquationSystem> Nektar::SolverUtils::EquationSystemSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 56 of file EquationSystem.h.

typedef boost::shared_ptr<FilterAeroForces> Nektar::SolverUtils::FilterAeroForcesSharedPtr

Definition at line 131 of file FilterAeroForces.h.

typedef LibUtilities::NekFactory< std::string, Filter, const LibUtilities::SessionReaderSharedPtr&, const std::map<std::string, std::string>& > Nektar::SolverUtils::FilterFactory

Datatype of the NekFactory used to instantiate classes derived from the Driver class.

Definition at line 61 of file Filter.h.

typedef boost::shared_ptr<Filter> Nektar::SolverUtils::FilterSharedPtr

A shared pointer to a Driver object.

Definition at line 50 of file Filter.h.

typedef LibUtilities::NekFactory<std::string, Forcing, const LibUtilities::SessionReaderSharedPtr&, const Array<OneD, MultiRegions::ExpListSharedPtr>&, const unsigned int&, const TiXmlElement*> Nektar::SolverUtils::ForcingFactory

Declaration of the forcing factory.

Definition at line 61 of file Forcing.h.

typedef LibUtilities::NekFactory<std::string, RiemannSolver> Nektar::SolverUtils::RiemannSolverFactory

Datatype of the NekFactory used to instantiate classes derived from the RiemannSolver class.

Definition at line 198 of file RiemannSolver.h.

typedef boost::shared_ptr<RiemannSolver> Nektar::SolverUtils::RiemannSolverSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 194 of file RiemannSolver.h.

typedef boost::function< NekDouble ()> Nektar::SolverUtils::RSParamFuncType

Definition at line 60 of file RiemannSolver.h.

typedef boost::function< const Array<OneD, const NekDouble>& ()> Nektar::SolverUtils::RSScalarFuncType

Definition at line 56 of file RiemannSolver.h.

typedef boost::function< const Array<OneD, const Array<OneD, NekDouble> >& ()> Nektar::SolverUtils::RSVecFuncType

Definition at line 58 of file RiemannSolver.h.

typedef std::vector<std::pair<std::string, std::string> > Nektar::SolverUtils::SummaryList

Definition at line 47 of file Misc.h.

Enumeration Type Documentation

enum Nektar::SolverUtils::EvolutionOperatorType

Enumerator
eNonlinear
eDirect
eAdjoint
eTransientGrowth
eSkewSymmetric
eAdaptiveSFD

Definition at line 5 of file SolverUtils.hpp.

         {
             eNonlinear,
             eDirect,
             eAdjoint,
             eTransientGrowth,
             eSkewSymmetric,
             eAdaptiveSFD
         };

Function Documentation

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::AddSummaryItem	(	SummaryList &	l,
		const std::string &	name,
		const std::string &	value
	)

Adds a summary item to the summary info list.

Adds an item to a SummaryList

Definition at line 50 of file Misc.cpp.

     {
         l.push_back(std::make_pair(name, value));
     }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::AddSummaryItem	(	SummaryList &	l,
		const std::string &	name,
		const int &	value
	)

Adds a summary item to the summary info list.

Definition at line 59 of file Misc.cpp.

     {
         l.push_back(std::make_pair(name, boost::lexical_cast<std::string>(value)));
     }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::AddSummaryItem	(	SummaryList &	l,
		const std::string &	name,
		const NekDouble &	value
	)

Adds a summary item to the summary info list.

Definition at line 68 of file Misc.cpp.

     {
         l.push_back(std::make_pair(
             name, str(boost::format("%g") % value)));
     }

SOLVER_UTILS_EXPORT AdvectionFactory & Nektar::SolverUtils::GetAdvectionFactory ( )

Gets the factory for initialising advection objects.

Returns: The advection factory.

Definition at line 46 of file Advection.cpp.

 {
     typedef Loki::SingletonHolder<AdvectionFactory,
     Loki::CreateUsingNew,
     Loki::NoDestroy,
     Loki::SingleThreaded> Type;
     return Type::Instance();
 }

SOLVER_UTILS_EXPORT DiffusionFactory & Nektar::SolverUtils::GetDiffusionFactory ( )

Definition at line 42 of file Diffusion.cpp.

Referenced by Nektar::SolverUtils::Diffusion3DHomogeneous1D::Diffusion3DHomogeneous1D(), Nektar::SolverUtils::EquationSystem::SessionSummary(), Nektar::UnsteadyDiffusion::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), and Nektar::CompressibleFlowSystem::v_InitObject().

         {
             typedef Loki::SingletonHolder<DiffusionFactory,
             Loki::CreateUsingNew,
             Loki::NoDestroy,
             Loki::SingleThreaded> Type;
             return Type::Instance();
         }

SOLVER_UTILS_EXPORT DriverFactory & Nektar::SolverUtils::GetDriverFactory ( )

Definition at line 66 of file Driver.cpp.

Referenced by Nektar::VortexWaveInteraction::ExecuteStreak(), Nektar::VortexWaveInteraction::ExecuteWave(), and main().

 {
     typedef Loki::SingletonHolder<DriverFactory,
     Loki::CreateUsingNew,
     Loki::NoDestroy,
     Loki::SingleThreaded> Type;
     return Type::Instance();
 }

SOLVER_UTILS_EXPORT EquationSystemFactory & Nektar::SolverUtils::GetEquationSystemFactory ( )

Definition at line 83 of file EquationSystem.cpp.

Referenced by Nektar::VortexWaveInteraction::ExecuteRoll(), Nektar::VortexWaveInteraction::ExecuteStreak(), main(), Nektar::SolverUtils::Driver::v_InitObject(), and Nektar::VortexWaveInteraction::VortexWaveInteraction().

         {
             typedef Loki::SingletonHolder<EquationSystemFactory,
                                           Loki::CreateUsingNew,
                                           Loki::NoDestroy,
                                           Loki::ClassLevelLockable> Type;
             return Type::Instance();
         }

SOLVER_UTILS_EXPORT FilterFactory & Nektar::SolverUtils::GetFilterFactory ( )

Definition at line 42 of file Filter.cpp.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_InitObject().

 {
     typedef Loki::SingletonHolder<FilterFactory,
                                   Loki::CreateUsingNew,
                                   Loki::NoDestroy,
                                   Loki::SingleThreaded> Type;
     return Type::Instance();
 }

SOLVER_UTILS_EXPORT ForcingFactory & Nektar::SolverUtils::GetForcingFactory ( )

Declaration of the forcing factory singleton.

Definition at line 44 of file Forcing.cpp.

Referenced by Nektar::VortexWaveInteraction::ExecuteRoll(), and Nektar::SolverUtils::Forcing::Load().

         {
             typedef Loki::SingletonHolder<ForcingFactory,
                                           Loki::CreateUsingNew,
                                           Loki::NoDestroy,
                                           Loki::SingleThreaded> Type;
             return Type::Instance();
         }

SOLVER_UTILS_EXPORT RiemannSolverFactory & Nektar::SolverUtils::GetRiemannSolverFactory ( )

Retrieves the singleton instance of the Riemann solver factory.

Definition at line 63 of file RiemannSolver.cpp.

Referenced by Nektar::LinearSWE::v_InitObject(), Nektar::NonlinearSWE::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::NonlinearPeregrine::v_InitObject(), Nektar::UnsteadyInviscidBurger::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), Nektar::UnsteadyAdvectionDiffusion::v_InitObject(), Nektar::UnsteadyViscousBurgers::v_InitObject(), and Nektar::CompressibleFlowSystem::v_InitObject().

         {
             typedef Loki::SingletonHolder<RiemannSolverFactory,
                                           Loki::CreateUsingNew,
                                           Loki::NoDestroy,
                                           Loki::SingleThreaded> Type;
             return Type::Instance();
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::UpdateGeometry	(	SpatialDomains::MeshGraphSharedPtr	graph,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		bool	modal
	)

Update geometry according to displacement that is in current fields.

Adds a summary item to the summary info list.

Parameters

graph	The MeshGraph of the current geometry.
fields	The fields containing the displacement.

Definition at line 59 of file Deform.cpp.

Referenced by Nektar::Utilities::ProcessDeform::Process(), and Nektar::IterativeElasticSystem::v_DoSolve().

     {
         // Clear existing curvature.
         SpatialDomains::CurveMap &curvedEdges = graph->GetCurvedEdges();
         SpatialDomains::CurveMap &curvedFaces = graph->GetCurvedFaces();
         curvedEdges.clear();
         curvedFaces.clear();
 
         int i, j, k, l, dim;
 
         // Sets to hold IDs of updated vertices to avoid duplicating effort.
         set<int> updatedVerts, updatedEdges, updatedFaces;
 
         dim = graph->GetSpaceDimension();
         Array<OneD, Array<OneD, NekDouble> > phys (dim);
         Array<OneD, Array<OneD, NekDouble> > coord(dim);
 
         for (i = 0; i < fields[0]->GetExpSize(); ++i)
         {
             LocalRegions::ExpansionSharedPtr exp = fields[0]->GetExp(i);
             int offset = fields[0]->GetPhys_Offset(i);
             int nquad  = exp->GetTotPoints();
 
             // Extract displacement for this element, allocate storage for
             // elemental coordinates.
             for (j = 0; j < dim; ++j)
             {
                 phys[j] = Array<OneD, NekDouble>(
                     nquad, fields[j]->UpdatePhys() + offset);
                 coord[j] = Array<OneD, NekDouble>(nquad);
             }
 
             // In 2D loop over edges.
             if (dim == 2)
             {
                 exp->GetCoords(coord[0], coord[1]);
 
                 SpatialDomains::Geometry2DSharedPtr geom =
                     boost::dynamic_pointer_cast<SpatialDomains::Geometry2D>(
                         exp->GetGeom());
 
                 for (j = 0; j < exp->GetNedges(); ++j)
                 {
                     SpatialDomains::Geometry1DSharedPtr edge = geom->GetEdge(j);
 
                     // This edge has already been processed.
                     if (updatedEdges.find(edge->GetGlobalID()) !=
                             updatedEdges.end())
                     {
                         continue;
                     }
 
                     // Extract edge displacement.
                     int nEdgePts = exp->GetEdgeNumPoints(j);
                     Array<OneD, Array<OneD, NekDouble> > edgePhys (dim);
                     Array<OneD, Array<OneD, NekDouble> > edgeCoord(dim);
 
                     const LibUtilities::BasisKey B(
                         LibUtilities::eModified_A, nEdgePts,
                         LibUtilities::PointsKey(
                             nEdgePts, LibUtilities::eGaussLobattoLegendre));
                     StdRegions::StdExpansion1DSharedPtr seg = MemoryManager<
                         StdRegions::StdSegExp>::AllocateSharedPtr(B);
 
                     for (k = 0; k < dim; ++k)
                     {
                         edgePhys [k] = Array<OneD, NekDouble>(nEdgePts);
                         edgeCoord[k] = Array<OneD, NekDouble>(nEdgePts);
                         exp->GetEdgePhysVals(j, seg, phys [k], edgePhys [k]);
                         exp->GetEdgePhysVals(j, seg, coord[k], edgeCoord[k]);
                     }
 
                     // Update verts
                     for (k = 0; k < 2; ++k)
                     {
                         int id = edge->GetVid(k);
                         if (updatedVerts.find(id) != updatedVerts.end())
                         {
                             continue;
                         }
 
                         SpatialDomains::PointGeomSharedPtr pt =
                             edge->GetVertex(k);
 
                         pt->UpdatePosition(
                             (*pt)(0) + edgePhys[0][k*(nEdgePts-1)],
                             (*pt)(1) + edgePhys[1][k*(nEdgePts-1)],
                             (*pt)(2));
 
                         updatedVerts.insert(id);
                     }
 
                     // Update curve
                     SpatialDomains::CurveSharedPtr curve = MemoryManager<
                         SpatialDomains::Curve>::AllocateSharedPtr(
                             edge->GetGlobalID(),
                             LibUtilities::eGaussLobattoLegendre);
 
                     for (k = 0; k < nEdgePts; ++k)
                     {
                         SpatialDomains::PointGeomSharedPtr vert =
                             MemoryManager<SpatialDomains::PointGeom>
                             ::AllocateSharedPtr(
                                 dim, edge->GetGlobalID(),
                                 edgeCoord[0][k] + edgePhys[0][k],
                                 edgeCoord[1][k] + edgePhys[1][k], 0.0);
 
                         curve->m_points.push_back(vert);
                     }
 
                     curvedEdges[edge->GetGlobalID()] = curve;
                     updatedEdges.insert(edge->GetGlobalID());
                 }
             }
             else if (dim == 3)
             {
                 exp->GetCoords(coord[0], coord[1], coord[2]);
 
                 SpatialDomains::Geometry3DSharedPtr geom =
                     boost::dynamic_pointer_cast<SpatialDomains::Geometry3D>(
                         exp->GetGeom());
 
                 for (j = 0; j < exp->GetNfaces(); ++j)
                 {
                     SpatialDomains::Geometry2DSharedPtr face = geom->GetFace(j);
 
                     // This edge has already been processed.
                     if (updatedFaces.find(face->GetGlobalID()) !=
                             updatedFaces.end())
                     {
                         continue;
                     }
 
                     // Extract face displacement.
                     LibUtilities::BasisKey B0 = exp->DetFaceBasisKey(j,0);
                     LibUtilities::BasisKey B1 = exp->DetFaceBasisKey(j,1);
                     int nq0 = B0.GetNumPoints();
                     int nq1 = B1.GetNumPoints();
 
                     ASSERTL1(B0.GetPointsType()
                                  == LibUtilities::eGaussLobattoLegendre &&
                              B1.GetPointsType()
                                  == LibUtilities::eGaussLobattoLegendre,
                              "Deformation requires GLL points in both "
                              "directions on a face.");
 
                     Array<OneD, Array<OneD, NekDouble> > newPos(dim);
 
                     StdRegions::StdExpansion2DSharedPtr faceexp;
                     StdRegions::Orientation orient = exp->GetForient(j);
 
                     if (face->GetShapeType() == LibUtilities::eTriangle)
                     {
                         faceexp = MemoryManager<StdRegions::StdTriExp>::
                             AllocateSharedPtr(B0, B1);
                     }
                     else
                     {
                         faceexp = MemoryManager<StdRegions::StdQuadExp>::
                             AllocateSharedPtr(B0, B1);
                     }
 
                     for (k = 0; k < dim; ++k)
                     {
                         Array<OneD, NekDouble> tmp(nq0*nq1);
                         newPos[k] = Array<OneD, NekDouble>(nq0*nq1);
                         exp->GetFacePhysVals(
                             j, faceexp, phys [k], tmp,       orient);
                         exp->GetFacePhysVals(
                             j, faceexp, coord[k], newPos[k], orient);
                         Vmath::Vadd(
                             nq0*nq1, tmp, 1, newPos[k], 1, newPos[k], 1);
                     }
 
                     // Now interpolate face onto a more reasonable set of
                     // points.
                     int nq = max(nq0, nq1);
                     if(!modal)
                         nq--;
 
                     LibUtilities::PointsKey edgePts(
                         nq, LibUtilities::eGaussLobattoLegendre);
                     LibUtilities::PointsKey triPts(
                         nq, LibUtilities::eNodalTriElec);
 
                     Array<OneD, Array<OneD, NekDouble> > intPos(dim);
 
                     for (k = 0; k < dim; ++k)
                     {
                         intPos[k] = Array<OneD, NekDouble>(nq*nq);
                         LibUtilities::Interp2D(
                             faceexp->GetPointsKeys()[0],
                             faceexp->GetPointsKeys()[1],
                             newPos[k], edgePts, edgePts, intPos[k]);
                     }
 
                     int edgeOff[2][4][2] = {
                         {
                             {0,           1},
                             {nq-1,       nq},
                             {nq*(nq-1), -nq},
                             {-1,-1}
                         },
                         {
                             {0,           1},
                             {nq-1,       nq},
                             {nq*nq-1,    -1},
                             {nq*(nq-1), -nq}
                         }
                     };
 
                     for (k = 0; k < face->GetNumVerts(); ++k)
                     {
                         // Update verts
                         int id = face->GetVid(k);
                         const int o =
                             face->GetShapeType() - LibUtilities::eTriangle;
 
                         if (updatedVerts.find(id) == updatedVerts.end())
                         {
                             SpatialDomains::PointGeomSharedPtr pt =
                                 face->GetVertex(k);
                             pt->UpdatePosition(
                                 intPos[0][edgeOff[o][k][0]],
                                 intPos[1][edgeOff[o][k][0]],
                                 intPos[2][edgeOff[o][k][0]]);
                             updatedVerts.insert(id);
                         }
 
                         // Update edges
                         id = face->GetEid(k);
                         if (updatedEdges.find(id) == updatedEdges.end())
                         {
                             SpatialDomains::Geometry1DSharedPtr edge
                                 = face->GetEdge(k);
                             SpatialDomains::CurveSharedPtr curve =
                                 MemoryManager<SpatialDomains::Curve>
                                 ::AllocateSharedPtr(
                                     edge->GetGlobalID(),
                                     LibUtilities::eGaussLobattoLegendre);
 
                             const int offset = edgeOff[o][k][0];
                             const int pos    = edgeOff[o][k][1];
 
                             if (face->GetEorient(k) == StdRegions::eBackwards)
                             {
                                 for (l = nq-1; l >= 0; --l)
                                 {
                                     int m = offset + pos*l;
                                     SpatialDomains::PointGeomSharedPtr vert =
                                         MemoryManager<SpatialDomains::PointGeom>
                                         ::AllocateSharedPtr(
                                             dim, edge->GetGlobalID(),
                                             intPos[0][m], intPos[1][m],
                                             intPos[2][m]);
                                     curve->m_points.push_back(vert);
                                 }
                             }
                             else
                             {
                                 for (l = 0; l < nq; ++l)
                                 {
                                     int m = offset + pos*l;
                                     SpatialDomains::PointGeomSharedPtr vert =
                                         MemoryManager<SpatialDomains::PointGeom>
                                         ::AllocateSharedPtr(
                                             dim, edge->GetGlobalID(),
                                             intPos[0][m], intPos[1][m],
                                             intPos[2][m]);
                                     curve->m_points.push_back(vert);
                                 }
                             }
 
                             curvedEdges[edge->GetGlobalID()] = curve;
                             updatedEdges.insert(edge->GetGlobalID());
                         }
                     }
 
                     // Update face-interior curvature
                     LibUtilities::PointsType pType =
                         face->GetShapeType() == LibUtilities::eTriangle ?
                         LibUtilities::eNodalTriElec :
                         LibUtilities::eGaussLobattoLegendre;
 
                     SpatialDomains::CurveSharedPtr curve = MemoryManager<
                         SpatialDomains::Curve>::AllocateSharedPtr(
                             face->GetGlobalID(),
                             pType);
 
                     if (face->GetShapeType() == LibUtilities::eTriangle)
                     {
                         // This code is probably pretty crappy. Have to go from
                         // GLL-GLL points -> GLL-Gauss-Radau -> nodal triangle
                         // points.
                         const LibUtilities::BasisKey B0(
                             LibUtilities::eOrtho_A, nq,
                             LibUtilities::PointsKey(
                                 nq, LibUtilities::eGaussLobattoLegendre));
                         const LibUtilities::BasisKey B1(
                             LibUtilities::eOrtho_B, nq,
                             LibUtilities::PointsKey(
                                 nq, LibUtilities::eGaussRadauMAlpha1Beta0));
                         StdRegions::StdNodalTriExp nodalTri(B0, B1, pType);
                         StdRegions::StdTriExp      tri     (B0, B1);
 
                         for (k = 0; k < dim; ++k)
                         {
                             Array<OneD, NekDouble> nodal(nq*nq);
 
                             LibUtilities::Interp2D(
                                 faceexp->GetBasis(0)->GetBasisKey(),
                                 faceexp->GetBasis(1)->GetBasisKey(),
                                 newPos[k], B0, B1, nodal);
 
                             Array<OneD, NekDouble> tmp1(nq*(nq+1)/2);
                             Array<OneD, NekDouble> tmp2(nq*(nq+1)/2);
 
                             tri.FwdTrans(nodal, tmp1);
                             nodalTri.ModalToNodal(tmp1, tmp2);
                             newPos[k] = tmp2;
                         }
 
                         for (l = 0; l < nq*(nq+1)/2; ++l)
                         {
                             SpatialDomains::PointGeomSharedPtr vert =
                                 MemoryManager<SpatialDomains::PointGeom>
                                 ::AllocateSharedPtr(
                                     dim, face->GetGlobalID(),
                                     newPos[0][l], newPos[1][l], newPos[2][l]);
                             curve->m_points.push_back(vert);
                         }
                     }
                     else
                     {
                         for (l = 0; l < nq*nq; ++l)
                         {
                             SpatialDomains::PointGeomSharedPtr vert =
                                 MemoryManager<SpatialDomains::PointGeom>
                                 ::AllocateSharedPtr(
                                     dim, face->GetGlobalID(),
                                     intPos[0][l], intPos[1][l], intPos[2][l]);
                             curve->m_points.push_back(vert);
                         }
                     }
 
                     curvedFaces[face->GetGlobalID()] = curve;
                     updatedFaces.insert(face->GetGlobalID());
                 }
             }
         }
 
         // Reset geometry information
         for (i = 0; i < fields.num_elements(); ++i)
         {
             fields[i]->Reset();
         }
     }

Variable Documentation

SOLVER_UTILS_EXPORT typedef boost::shared_ptr<ForcingProgrammatic> Nektar::SolverUtils::ForcingProgrammaticSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 52 of file ForcingProgrammatic.h.

SOLVER_UTILS_EXPORT typedef boost::shared_ptr<Forcing> Nektar::SolverUtils::ForcingSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 51 of file Forcing.h.

Referenced by Nektar::ForcingStabilityCoupledLNS::create(), Nektar::ForcingMovingBody::create(), Nektar::SolverUtils::ForcingAbsorption::create(), Nektar::SolverUtils::ForcingNoise::create(), Nektar::SolverUtils::ForcingBody::create(), and Nektar::SolverUtils::ForcingProgrammatic::create().

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation