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

#include <DriverAdaptive.h>

Inheritance diagram for Nektar::SolverUtils::DriverAdaptive:

Static Public Member Functions
static DriverSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
	Creates an instance of this class. More...

Static Public Attributes
static std::string	className
	Name of the class. More...

Protected Member Functions
SOLVER_UTILS_EXPORT	DriverAdaptive (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
	Constructor. More...

virtual SOLVER_UTILS_EXPORT	~DriverAdaptive ()
	Destructor. More...

virtual SOLVER_UTILS_EXPORT void	v_InitObject (std::ostream &out=std::cout)
	Second-stage initialisation. More...

virtual SOLVER_UTILS_EXPORT void	v_Execute (std::ostream &out=std::cout)
	Virtual function for solve implementation. More...

SOLVER_UTILS_EXPORT void	ReplaceExpansion (Array< OneD, MultiRegions::ExpListSharedPtr > &fields, std::map< int, int > deltaP)
	Update EXPANSIONS tag inside XML schema to reflect new polynomial order distribution. More...

Protected Member Functions inherited from Nektar::SolverUtils::Driver
	Driver (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
	Initialises EquationSystem class members. More...

virtual SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	v_GetRealEvl (void)

virtual SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	v_GetImagEvl (void)

Static Protected Attributes
static std::string	driverLookupId

Static Protected Attributes inherited from Nektar::SolverUtils::Driver
static std::string	evolutionOperatorLookupIds []

static std::string	evolutionOperatorDef

static std::string	driverDefault

Friends
class	MemoryManager< DriverAdaptive >

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::Driver
virtual	~Driver ()
	Destructor. More...

SOLVER_UTILS_EXPORT void	InitObject (std::ostream &out=std::cout)
	Initialise Object. More...

SOLVER_UTILS_EXPORT void	Execute (std::ostream &out=std::cout)
	Execute driver. More...

SOLVER_UTILS_EXPORT Array< OneD, EquationSystemSharedPtr >	GetEqu ()

SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	GetRealEvl (void)

SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	GetImagEvl (void)

Protected Attributes inherited from Nektar::SolverUtils::Driver
LibUtilities::CommSharedPtr	m_comm
	Communication object. More...

LibUtilities::SessionReaderSharedPtr	m_session
	Session reader object. More...

LibUtilities::SessionReaderSharedPtr	session_LinNS
	I the Coupling between SFD and arnoldi. More...

SpatialDomains::MeshGraphSharedPtr	m_graph
	MeshGraph object. More...

Array< OneD, EquationSystemSharedPtr >	m_equ
	Equation system to solve. More...

int	m_nequ
	number of equations More...

enum EvolutionOperatorType	m_EvolutionOperator
	Evolution Operator. More...

Detailed Description

Base class for the adaptive polynomial order driver.

Definition at line 47 of file DriverAdaptive.h.

Constructor & Destructor Documentation

◆ DriverAdaptive()

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

protected

Constructor.

Definition at line 62 of file DriverAdaptive.cpp.

     : Driver(pSession, pGraph)
 {
 }

◆ ~DriverAdaptive()

Nektar::SolverUtils::DriverAdaptive::~DriverAdaptive ( )

protectedvirtual

Destructor.

Definition at line 72 of file DriverAdaptive.cpp.

73 {

74 }

Member Function Documentation

◆ create()

static DriverSharedPtr Nektar::SolverUtils::DriverAdaptive::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const SpatialDomains::MeshGraphSharedPtr &	pGraph
	)

inlinestatic

Creates an instance of this class.

Definition at line 53 of file DriverAdaptive.h.

     {
         DriverSharedPtr p =
             MemoryManager<DriverAdaptive>::AllocateSharedPtr(pSession, pGraph);
         p->InitObject();
         return p;
     }

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

◆ ReplaceExpansion()

void Nektar::SolverUtils::DriverAdaptive::ReplaceExpansion	(	Array< OneD, MultiRegions::ExpListSharedPtr > &	fields,
		std::map< int, int >	deltaP
	)

protected

Update EXPANSIONS tag inside XML schema to reflect new polynomial order distribution.

Parameters

fields	Input fields.
deltaP	Map of polynomial order expansions

Definition at line 447 of file DriverAdaptive.cpp.

 {
     int nExp, nDim;
     int  expdim   = m_equ[0]->UpdateFields()[0]->GetGraph()->GetMeshDimension();
  
     // Get field definitions
     std::vector<LibUtilities::FieldDefinitionsSharedPtr> fielddefs =
         fields[0]->GetFieldDefinitions();
  
     if (fielddefs[0]->m_numHomogeneousDir == 1)
     {
         nDim = expdim+1;
     }
     else
     {
         nDim = expdim;
     }
  
     // Add variables to field definition
     for (int i = 0; i < fielddefs.size(); ++i)
     {
         for (int j = 0; j < fields.size(); ++j)
         {
             fielddefs[i]->m_fields.push_back(m_session->GetVariable(j));
         }
     }
  
     // Get tinyxml objects
     TiXmlElement *exp_tag = m_session->GetElement("NEKTAR/EXPANSIONS");
  
     // Clear current expansions
     exp_tag->Clear();
  
     // Write new expansion information
     for (int f = 0; f < fielddefs.size(); ++f)
     {
         nExp = fielddefs[f]->m_elementIDs.size();
  
         //---------------------------------------------
         // Write ELEMENTS
         TiXmlElement *elemTag = new TiXmlElement("ELEMENTS");
         exp_tag->LinkEndChild(elemTag);
  
         // Write FIELDS
         std::string fieldsString;
         {
             std::stringstream fieldsStringStream;
             bool first = true;
             for (std::vector<int>::size_type i = 0;
                  i < fielddefs[f]->m_fields.size(); i++)
             {
                 if (!first)
                 {
                     fieldsStringStream << ",";
                 }
                 fieldsStringStream << fielddefs[f]->m_fields[i];
                 first = false;
             }
             fieldsString = fieldsStringStream.str();
         }
         elemTag->SetAttribute("FIELDS", fieldsString);
  
         // Write SHAPE
         std::string shapeString;
         {
             std::stringstream shapeStringStream;
             shapeStringStream
                 << LibUtilities::ShapeTypeMap[fielddefs[f]->m_shapeType];
             if (fielddefs[f]->m_numHomogeneousDir == 1)
             {
                 shapeStringStream << "-HomogenousExp1D";
             }
             else if (fielddefs[f]->m_numHomogeneousDir == 2)
             {
                 shapeStringStream << "-HomogenousExp2D";
             }
  
             shapeString = shapeStringStream.str();
         }
         elemTag->SetAttribute("SHAPE", shapeString);
  
         // Write BASIS
         std::string basisString;
         {
             std::stringstream basisStringStream;
             bool first = true;
             for (std::vector<LibUtilities::BasisType>::size_type i = 0;
                  i < fielddefs[f]->m_basis.size(); i++)
             {
                 if (!first)
                 {
                     basisStringStream << ",";
                 }
                 basisStringStream
                     << LibUtilities::BasisTypeMap[fielddefs[f]->m_basis[i]];
                 first = false;
             }
             basisString = basisStringStream.str();
         }
         elemTag->SetAttribute("BASIS", basisString);
  
         // Write homogeneuous length details
         if (fielddefs[f]->m_numHomogeneousDir)
         {
             std::string homoLenString;
             {
                 std::stringstream homoLenStringStream;
                 bool first = true;
                 for (int i = 0; i < fielddefs[f]->m_numHomogeneousDir; ++i)
                 {
                     if (!first)
                     {
                         homoLenStringStream << ",";
                     }
                     homoLenStringStream
                         << fielddefs[f]->m_homogeneousLengths[i];
                     first = false;
                 }
                 homoLenString = homoLenStringStream.str();
             }
             elemTag->SetAttribute("HOMOGENEOUSLENGTHS", homoLenString);
         }
  
         // Write homogeneuous planes/lines details
         if (fielddefs[f]->m_numHomogeneousDir)
         {
             if (fielddefs[f]->m_homogeneousYIDs.size() > 0)
             {
                 std::string homoYIDsString;
                 {
                     std::stringstream homoYIDsStringStream;
                     bool first = true;
                     for (int i = 0; i < fielddefs[f]->m_homogeneousYIDs.size();
                          i++)
                     {
                         if (!first)
                         {
                             homoYIDsStringStream << ",";
                         }
                         homoYIDsStringStream
                             << fielddefs[f]->m_homogeneousYIDs[i];
                         first = false;
                     }
                     homoYIDsString = homoYIDsStringStream.str();
                 }
                 elemTag->SetAttribute("HOMOGENEOUSYIDS", homoYIDsString);
             }
  
             if (fielddefs[f]->m_homogeneousZIDs.size() > 0)
             {
                 std::string homoZIDsString;
                 {
                     std::stringstream homoZIDsStringStream;
                     bool first = true;
                     for (int i = 0; i < fielddefs[f]->m_homogeneousZIDs.size();
                          i++)
                     {
                         if (!first)
                         {
                             homoZIDsStringStream << ",";
                         }
                         homoZIDsStringStream
                             << fielddefs[f]->m_homogeneousZIDs[i];
                         first = false;
                     }
                     homoZIDsString = homoZIDsStringStream.str();
                 }
                 elemTag->SetAttribute("HOMOGENEOUSZIDS", homoZIDsString);
             }
         }
  
         // Write NUMMODESPERDIR
         std::string numModesString;
         {
             std::stringstream numModesStringStream;
  
             numModesStringStream << "MIXORDER:";
             bool first = true;
             int eId;
             Array<OneD, int> order(nDim, 0);
             for (int n = 0; n < nExp; n++)
             {
                 eId = fielddefs[f]->m_elementIDs[n];
  
                 for (int i = 0; i < expdim; i++)
                 {
                     order[i] = deltaP[eId];
                 }
  
                 for (int i = 0; i < nDim; i++)
                 {
                     if (fielddefs[f]->m_uniOrder)
                     {
                         order[i] += fielddefs[f]->m_numModes[i];
                     }
                     else
                     {
                         order[i] += fielddefs[f]->m_numModes[n * nDim + i];
                     }
  
                     if (!first)
                     {
                         numModesStringStream << ",";
                     }
  
                     numModesStringStream << order[i];
                     first = false;
                 }
             }
             numModesString = numModesStringStream.str();
         }
         elemTag->SetAttribute("NUMMODESPERDIR", numModesString);
  
         // Write IDs. Should ideally look at ways of compressing this stream if
         // just sequential.
         elemTag->SetAttribute(
             "ID", ParseUtils::GenerateSeqString(fielddefs[f]->m_elementIDs));
     }
 }

References Nektar::LibUtilities::BasisTypeMap, Nektar::ParseUtils::GenerateSeqString(), Nektar::SolverUtils::Driver::m_equ, Nektar::SolverUtils::Driver::m_session, and Nektar::LibUtilities::ShapeTypeMap.

Referenced by v_Execute().

◆ v_Execute()

void Nektar::SolverUtils::DriverAdaptive::v_Execute ( std::ostream & out = std::cout )

protectedvirtual

Virtual function for solve implementation.

Implements Nektar::SolverUtils::Driver.

Definition at line 84 of file DriverAdaptive.cpp.

 {
     time_t starttime, endtime;
     NekDouble CPUtime;
  
     m_equ[0]->PrintSummary(out);
  
     // First run using original order
     time(&starttime);
     m_equ[0]->DoInitialise();
  
     // Obtain initial time in case a restart was used
     NekDouble startTime = m_equ[0]->GetFinalTime();
     m_equ[0]->DoSolve();
  
     // Load session parameters and solver info
     bool isHomogeneous1D;
     int nRuns, minP, maxP, sensorVar;
     NekDouble lowerTol, upperTol;
     m_session->LoadParameter  ("NumRuns",                nRuns,     1);
     m_session->LoadParameter  ("AdaptiveMinModes",       minP,      4);
     m_session->LoadParameter  ("AdaptiveMaxModes",       maxP,      12);
     m_session->LoadParameter  ("AdaptiveLowerTolerance", lowerTol,  1e-8);
     m_session->LoadParameter  ("AdaptiveUpperTolerance", upperTol,  1e-6);
     m_session->LoadParameter  ("AdaptiveSensorVariable", sensorVar, 0);
     m_session->MatchSolverInfo("Homogeneous", "1D", isHomogeneous1D, false);
  
     // Get number of elements and planes
     int nExp, nPlanes;
     if (isHomogeneous1D)
     {
         nExp    = m_equ[0]->UpdateFields()[0]->GetPlane(0)->GetExpSize();
         nPlanes = m_equ[0]->UpdateFields()[0]->GetZIDs().size();
     }
     else
     {
         nExp    = m_equ[0]->UpdateFields()[0]->GetExpSize();
         nPlanes = 1;
     }
     int  expdim   = m_equ[0]->UpdateFields()[0]->GetGraph()->GetMeshDimension();
  
     int       nFields  = m_equ[0]->UpdateFields().size();
     int       numSteps = m_session->GetParameter("NumSteps");
     NekDouble period   = m_session->GetParameter("TimeStep") * numSteps;
  
     Array<OneD, NekDouble> coeffs, phys, physReduced, tmpArray;
  
     // Get mapping
     GlobalMapping::MappingSharedPtr mapping;
     mapping = GlobalMapping::Mapping::Load(m_session,
                                            m_equ[0]->UpdateFields());
  
     // Adaptive loop
     Array<OneD, int> P(expdim);
     Array<OneD, int> numPoints(expdim);
     Array<OneD, LibUtilities::PointsKey> ptsKey(expdim);
     LocalRegions::ExpansionSharedPtr Exp;
     for (int i = 1; i < nRuns; i++)
     {
         // Get field expansions
         Array<OneD, MultiRegions::ExpListSharedPtr> fields =
             m_equ[0]->UpdateFields();
  
         // Determine the change to be applied in the order
         map<int, int> deltaP;
         int offset = 0;
         for (int n = 0; n < nExp; n++)
         {
             offset = fields[sensorVar]->GetPhys_Offset(n);
             Exp    = fields[sensorVar]->GetExp(n);
  
             for( int k = 0; k < expdim; ++k)
             {
                 P[k]         = Exp->GetBasis(k)->GetNumModes();
                 numPoints[k] = Exp->GetBasis(k)->GetNumPoints();
                 ptsKey[k]    = LibUtilities::PointsKey (numPoints[k],
                                Exp->GetBasis(k)->GetPointsType());
             }
  
             // Declare orthogonal basis.
             StdRegions::StdExpansionSharedPtr OrthoExp;
             switch (Exp->GetGeom()->GetShapeType())
             {
                 case LibUtilities::eQuadrilateral:
                 {
                     LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, P[0] - 1,
                                               ptsKey[0]);
                     LibUtilities::BasisKey Bb(LibUtilities::eOrtho_A, P[1] - 1,
                                               ptsKey[1]);
                     OrthoExp = MemoryManager<
                         StdRegions::StdQuadExp>::AllocateSharedPtr(Ba, Bb);
                     break;
                 }
                 case LibUtilities::eTriangle:
                 {
                     LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, P[0] - 1,
                                               ptsKey[0]);
                     LibUtilities::BasisKey Bb(LibUtilities::eOrtho_B, P[1] - 1,
                                               ptsKey[1]);
                     OrthoExp =
                         MemoryManager<StdRegions::StdTriExp>::AllocateSharedPtr(
                             Ba, Bb);
                     break;
                 }
                 case LibUtilities::eTetrahedron:
                 {
                     LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, P[0] - 1,
                                               ptsKey[0]);
                     LibUtilities::BasisKey Bb(LibUtilities::eOrtho_B, P[1] - 1,
                                               ptsKey[1]);
                     LibUtilities::BasisKey Bc(LibUtilities::eOrtho_C, P[2] - 1,
                                               ptsKey[2]);
                     OrthoExp =
                         MemoryManager<StdRegions::StdTetExp>::AllocateSharedPtr(
                             Ba, Bb, Bc);
                     break;
                 }
                 case LibUtilities::ePyramid:
                 {
                     LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, P[0] - 1,
                                               ptsKey[0]);
                     LibUtilities::BasisKey Bb(LibUtilities::eOrtho_A, P[1] - 1,
                                               ptsKey[1]);
                     LibUtilities::BasisKey Bc(LibUtilities::eOrtho_C, P[2] - 1,
                                               ptsKey[2]);
                     OrthoExp =
                         MemoryManager<StdRegions::StdPyrExp>::AllocateSharedPtr(
                             Ba, Bb, Bc);
                     break;
                 }
                 case LibUtilities::ePrism:
                 {
                     LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, P[0] - 1,
                                               ptsKey[0]);
                     LibUtilities::BasisKey Bb(LibUtilities::eOrtho_A, P[1] - 1,
                                               ptsKey[1]);
                     LibUtilities::BasisKey Bc(LibUtilities::eOrtho_B, P[2] - 1,
                                               ptsKey[2]);
                     OrthoExp =
                         MemoryManager<StdRegions::StdPrismExp>::AllocateSharedPtr(
                             Ba, Bb, Bc);
                     break;
                 }
                 case LibUtilities::eHexahedron:
                 {
                     LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, P[0] - 1,
                                               ptsKey[0]);
                     LibUtilities::BasisKey Bb(LibUtilities::eOrtho_A, P[1] - 1,
                                               ptsKey[1]);
                     LibUtilities::BasisKey Bc(LibUtilities::eOrtho_A, P[2] - 1,
                                               ptsKey[2]);
                     OrthoExp =
                         MemoryManager<StdRegions::StdHexExp>::AllocateSharedPtr(
                             Ba, Bb, Bc);
                     break;
                 }
                 default:
                     ASSERTL0(false, "Shape not supported.");
                     break;
             }
  
             int nq = OrthoExp->GetTotPoints();
  
             NekDouble error = 0;
             NekDouble fac   = 0;
             NekDouble tmp   = 0;
  
             coeffs      = Array<OneD, NekDouble>(OrthoExp->GetNcoeffs());
             physReduced = Array<OneD, NekDouble>(OrthoExp->GetTotPoints());
             tmpArray    = Array<OneD, NekDouble>(OrthoExp->GetTotPoints(), 0.0);
  
             // Refinement based only on one variable
             for (int plane = 0; plane < nPlanes; plane++)
             {
                 if (isHomogeneous1D)
                 {
                     phys =
                         fields[sensorVar]->GetPlane(plane)->GetPhys() + offset;
                 }
                 else
                 {
                     phys = fields[sensorVar]->GetPhys() + offset;
                 }
  
                 // Project solution to lower order
                 OrthoExp->FwdTrans(phys, coeffs);
                 OrthoExp->BwdTrans(coeffs, physReduced);
  
                 // Calculate error =||phys-physReduced||^2 / ||phys||^2
                 Vmath::Vsub(nq, phys,     1, physReduced, 1, tmpArray, 1);
                 Vmath::Vmul(nq, tmpArray, 1, tmpArray,    1, tmpArray, 1);
                 tmp = Exp->Integral(tmpArray);
  
                 Vmath::Vmul(nq, phys, 1, phys, 1, tmpArray, 1);
                 fac = Exp->Integral(tmpArray);
  
                 tmp = abs(tmp / fac);
  
                 if (tmp != tmp)
                 {
                     ASSERTL0(false,
                              "Adaptive procedure encountered NaN value.");
                 }
  
                 // Get maximum value along planes
                 error = (tmp > error) ? tmp : error;
             }
  
             // Combine planes from different processes
             m_session->GetComm()->GetColumnComm()->AllReduce(
                 error, LibUtilities::ReduceMax);
  
             // Override tolerances if function is defined
             if (m_session->DefinesFunction("AdaptiveLowerTolerance"))
             {
                 int nq = Exp->GetTotPoints();
  
                 // Obtain points from the the element
                 Array<OneD, NekDouble> xc0, xc1, xc2;
                 xc0 = Array<OneD, NekDouble>(nq, 0.0);
                 xc1 = Array<OneD, NekDouble>(nq, 0.0);
                 xc2 = Array<OneD, NekDouble>(nq, 0.0);
                 Exp->GetCoords(xc0, xc1, xc2);
  
                 // Evaluate function from session file
                 Array<OneD, NekDouble> tolerance(nq, 0.0);
                 LibUtilities::EquationSharedPtr ffunc =
                     m_session->GetFunction("AdaptiveLowerTolerance", 0);
                 ffunc->Evaluate(xc0, xc1, xc2, tolerance);
                 lowerTol = Vmath::Vsum(nq, tolerance, 1) / nq;
             }
  
             if (m_session->DefinesFunction("AdaptiveUpperTolerance"))
             {
                 int nq = Exp->GetTotPoints();
  
                 // Obtain points from the the element
                 Array<OneD, NekDouble> xc0, xc1, xc2;
                 xc0 = Array<OneD, NekDouble>(nq, 0.0);
                 xc1 = Array<OneD, NekDouble>(nq, 0.0);
                 xc2 = Array<OneD, NekDouble>(nq, 0.0);
                 Exp->GetCoords(xc0, xc1, xc2);
  
                 // Evaluate function from session file
                 Array<OneD, NekDouble> tolerance(nq, 0.0);
                 LibUtilities::EquationSharedPtr ffunc =
                     m_session->GetFunction("AdaptiveUpperTolerance", 0);
                 ffunc->Evaluate(xc0, xc1, xc2, tolerance);
                 upperTol = Vmath::Vsum(nq, tolerance, 1) / nq;
             }
  
             // Determine what to do with the polynomial order
             if ((error > upperTol) && (P[0] < maxP))
             {
                 deltaP[Exp->GetGeom()->GetGlobalID()] = 1;
             }
             else if ((error < lowerTol) && P[0] > minP)
             {
                 deltaP[Exp->GetGeom()->GetGlobalID()] = -1;
             }
             else
             {
                 deltaP[Exp->GetGeom()->GetGlobalID()] = 0;
             }
         }
  
         // Write new expansion section to the session reader and re-read graph.
         ReplaceExpansion(fields, deltaP);
         m_graph->ReadExpansionInfo();
  
         // Reset GlobalLinSys Manager to avoid using too much memory
         //
         // @todo This could be made better by replacing individual matrices
         //       within the linear system.
         if (LibUtilities::NekManager<MultiRegions::GlobalLinSysKey,
                                      MultiRegions::GlobalLinSys>::
                 PoolCreated(std::string("GlobalLinSys")))
         {
             LibUtilities::NekManager<MultiRegions::GlobalLinSysKey,
                                      MultiRegions::GlobalLinSys>::
                 ClearManager(std::string("GlobalLinSys"));
         }
  
         int chkNumber = m_equ[0]->GetCheckpointNumber();
         int chkSteps  = m_equ[0]->GetCheckpointSteps();
  
         // Initialise driver again
         Driver::v_InitObject(out);
  
         // Update mapping (must be before m_equ[0]->DoInitialise();)
         mapping->ReplaceField(m_equ[0]->UpdateFields());
  
         // Set chkSteps to zero to avoid writing initial condition
         m_equ[0]->SetCheckpointSteps(0);
  
         // Initialise equation
         m_equ[0]->DoInitialise();
         m_equ[0]->SetInitialStep(i * numSteps);
         m_equ[0]->SetSteps(i * numSteps + numSteps);
         m_equ[0]->SetTime(startTime + i * period);
         m_equ[0]->SetBoundaryConditions(startTime + i * period);
         m_equ[0]->SetCheckpointNumber(chkNumber);
         m_equ[0]->SetCheckpointSteps(chkSteps);
  
         // Project solution to new expansion
         for (int n = 0; n < nFields; n++)
         {
             m_equ[0]->UpdateFields()[n]->ExtractCoeffsToCoeffs(
                 fields[n], fields[n]->GetCoeffs(),
                 m_equ[0]->UpdateFields()[n]->UpdateCoeffs());
             m_equ[0]->UpdateFields()[n]->BwdTrans_IterPerExp(
                 m_equ[0]->UpdateFields()[n]->GetCoeffs(),
                 m_equ[0]->UpdateFields()[n]->UpdatePhys());
         }
  
         // Solve equation
         m_equ[0]->DoSolve();
     }
  
     time(&endtime);
  
     m_equ[0]->Output();
  
     if (m_comm->GetRank() == 0)
     {
         CPUtime = difftime(endtime, starttime);
         cout << "-------------------------------------------" << endl;
         cout << "Total Computation Time = " << CPUtime << "s" << endl;
         cout << "-------------------------------------------" << endl;
     }
  
     // Evaluate and output computation time and solution accuracy.
     // The specific format of the error output is essential for the
     // regression tests to work.
  
     // Evaluate L2 Error
     for (int i = 0; i < m_equ[0]->GetNvariables(); ++i)
     {
         Array<OneD, NekDouble> exactsoln(m_equ[0]->GetTotPoints(), 0.0);
  
         // Evaluate "ExactSolution" function, or zero array
         m_equ[0]->EvaluateExactSolution(i, exactsoln, m_equ[0]->GetFinalTime());
  
         NekDouble vL2Error   = m_equ[0]->L2Error  (i, exactsoln);
         NekDouble vLinfError = m_equ[0]->LinfError(i, exactsoln);
  
         if (m_comm->GetRank() == 0)
         {
             out << "L 2 error (variable " << m_equ[0]->GetVariable(i)
                 << ") : " << vL2Error << endl;
             out << "L inf error (variable " << m_equ[0]->GetVariable(i)
                 << ") : " << vLinfError << endl;
         }
     }
 }

◆ v_InitObject()

void Nektar::SolverUtils::DriverAdaptive::v_InitObject ( std::ostream & out = std::cout )

protectedvirtual

Second-stage initialisation.

Reimplemented from Nektar::SolverUtils::Driver.

Definition at line 79 of file DriverAdaptive.cpp.

 {
     Driver::v_InitObject(out);
 }

References Nektar::SolverUtils::Driver::v_InitObject().

Friends And Related Function Documentation

◆ MemoryManager< DriverAdaptive >

friend class MemoryManager< DriverAdaptive >

friend

Definition at line 1 of file DriverAdaptive.h.

Member Data Documentation

◆ className

string Nektar::SolverUtils::DriverAdaptive::className

static

Initial value:

= GetDriverFactory().RegisterCreatorFunction(

"Adaptive", DriverAdaptive::create)

Nektar::LibUtilities::NekFactory::RegisterCreatorFunction

tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")

Register a class with the factory.

Definition: NekFactory.hpp:200

Nektar::SolverUtils::DriverAdaptive::create

static DriverSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)

Creates an instance of this class.

Definition: DriverAdaptive.h:53

Nektar::SolverUtils::GetDriverFactory

DriverFactory & GetDriverFactory()

Definition: Driver.cpp:65

Name of the class.

Definition at line 64 of file DriverAdaptive.h.

◆ driverLookupId

string Nektar::SolverUtils::DriverAdaptive::driverLookupId

staticprotected

Initial value:

=

LibUtilities::SessionReader::RegisterEnumValue("Driver", "Adaptive", 0)

Nektar::LibUtilities::SessionReader::RegisterEnumValue

static std::string RegisterEnumValue(std::string pEnum, std::string pString, int pEnumValue)

Registers an enumeration value.

Definition: SessionReader.h:625

Definition at line 85 of file DriverAdaptive.h.

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DriverAdaptive()

◆ ~DriverAdaptive()

Member Function Documentation

◆ create()

◆ ReplaceExpansion()

◆ v_Execute()

◆ v_InitObject()

Friends And Related Function Documentation

◆ MemoryManager< DriverAdaptive >

Member Data Documentation

◆ className

◆ driverLookupId