Nektar++
Protected Member Functions | Protected Attributes | List of all members
Nektar::SolverUtils::DriverParallelInTime Class Reference

Base class for the development of parallel-in-time solvers. More...

#include <DriverParallelInTime.h>

Inheritance diagram for Nektar::SolverUtils::DriverParallelInTime:
[legend]

Protected Member Functions

SOLVER_UTILS_EXPORT DriverParallelInTime (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
 Constructor. More...
 
virtual SOLVER_UTILS_EXPORT ~DriverParallelInTime ()=default
 Destructor. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (std::ostream &out=std::cout) override
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_Execute (std::ostream &out=std::cout) override
 Virtual function for solve implementation. More...
 
virtual NekDouble v_EstimateCommunicationTime (void)
 
virtual NekDouble v_EstimateRestrictionTime (void)
 
virtual NekDouble v_EstimateInterpolationTime (void)
 
virtual NekDouble v_EstimateCoarseSolverTime (void)
 
virtual NekDouble v_EstimateFineSolverTime (void)
 
virtual NekDouble v_EstimatePredictorTime (void)
 
virtual NekDouble v_EstimateOverheadTime (void)
 
virtual NekDouble v_ComputeSpeedUp (const size_t iter, NekDouble fineSolveTime, NekDouble coarseSolveTime, NekDouble restTime, NekDouble interTime, NekDouble commTime, NekDouble predictorTime, NekDouble overheadTime)
 
void SetParallelInTimeEquationSystem (std::string AdvectiveType)
 
void GetParametersFromSession (void)
 
void InitialiseEqSystem (bool turnoff_output)
 
void AllocateMemory (void)
 
void InitialiseInterpolationField (void)
 
void PrintCoarseSolverInfo (std::ostream &out=std::cout)
 
void PrintFineSolverInfo (std::ostream &out=std::cout)
 
void PrintHeaderTitle1 (const std::string &title)
 
void PrintHeaderTitle2 (const std::string &title)
 
void PrintComputationalTime (const NekDouble time)
 
void RecvInitialConditionFromPreviousProc (Array< OneD, Array< OneD, NekDouble > > &array, int &convergence)
 
void RecvInitialConditionFromPreviousProc (Array< OneD, Array< OneD, NekDouble > > &array)
 
void SendSolutionToNextProc (Array< OneD, Array< OneD, NekDouble > > &array, int &convergence)
 
void SendSolutionToNextProc (Array< OneD, Array< OneD, NekDouble > > &array)
 
void CopySolutionVector (const Array< OneD, const Array< OneD, NekDouble > > &in, Array< OneD, Array< OneD, NekDouble > > &out)
 
void CopyFromFinePhysField (Array< OneD, Array< OneD, NekDouble > > &out)
 
void CopyFromCoarsePhysField (Array< OneD, Array< OneD, NekDouble > > &out)
 
void CopyToFinePhysField (const Array< OneD, const Array< OneD, NekDouble > > &in)
 
void CopyToCoarsePhysField (const Array< OneD, const Array< OneD, NekDouble > > &in)
 
void UpdateSolution (const Array< OneD, const Array< OneD, NekDouble > > &in)
 
void EvaluateExactSolution (const NekDouble &time)
 
void SolutionConvergenceMonitoring (const NekDouble &time)
 
void SolutionConvergenceSummary (const NekDouble &time)
 
void UpdateErrorNorm (const bool normalized)
 
void PrintErrorNorm (const bool normalized)
 
void Interpolator (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
NekDouble vL2ErrorMax (void)
 
void SpeedUpAnalysis ()
 
void PrintSpeedUp (NekDouble fineSolveTime, NekDouble coarseSolveTime, NekDouble restTime, NekDouble interTime, NekDouble commTime, NekDouble predictorOverheadTime, NekDouble overheadTime)
 
NekDouble EstimateCommunicationTime (Array< OneD, Array< OneD, NekDouble > > &buffer1, Array< OneD, Array< OneD, NekDouble > > &buffer2)
 
- 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 void v_InitObject (std::ostream &out=std::cout)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_Execute (std::ostream &out=std::cout)=0
 Virtual function for solve implementation. More...
 

Protected Attributes

NekDouble m_fineTimeStep
 Timestep for fine solver. More...
 
NekDouble m_coarseTimeStep
 Timestep for coarse solver. More...
 
NekDouble m_totalTime
 Total time integration interval. More...
 
NekDouble m_chunkTime
 Time for chunks. More...
 
NekDouble m_time
 Local time. More...
 
size_t m_infoSteps = 0
 Number of steps for info I/O. More...
 
size_t m_checkSteps = 0
 Number of steps for checkpoint. More...
 
size_t m_fineSteps = 1
 Number of steps for the fine solver. More...
 
size_t m_coarseSteps = 1
 Number of steps for the coarse solver. More...
 
size_t m_numChunks = 1
 Number of time chunks. More...
 
size_t m_chunkRank = 0
 Rank in time. More...
 
size_t m_iterMaxPIT = 0
 Maximum number of parallel-in-time iteration. More...
 
size_t m_numWindowsPIT = 1
 
bool m_exactSolution = 0
 Using exact solution to compute error norms. More...
 
NekDouble m_tolerPIT = 1e-15
 ParallelInTime tolerance. More...
 
size_t m_fineQuadPts
 
size_t m_coarseQuadPts
 
size_t m_fineNpts
 
size_t m_coarseNpts
 
size_t m_nVar
 
std::shared_ptr< SolverUtils::UnsteadySystem > m_fineEqSys
 
std::shared_ptr< SolverUtils::UnsteadySystem > m_coarseEqSys
 
Array< OneD, NekDouble > m_vL2Errors
 
Array< OneD, NekDouble > m_vLinfErrors
 
Array< OneD, Array< OneD, NekDouble > > m_exactsoln
 
Array< OneD, Array< OneD, NekDouble > > m_tmpfine
 
Array< OneD, Array< OneD, NekDouble > > m_tmpcoarse
 
Array< OneD, MultiRegions::ExpListSharedPtr > m_fineFields
 
Array< OneD, MultiRegions::ExpListSharedPtr > m_coarseFields
 
- 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
 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...
 

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 ()
 
- Static Protected Attributes inherited from Nektar::SolverUtils::Driver
static std::string evolutionOperatorLookupIds []
 
static std::string evolutionOperatorDef
 
static std::string driverDefault
 

Detailed Description

Base class for the development of parallel-in-time solvers.

Definition at line 47 of file DriverParallelInTime.h.

Constructor & Destructor Documentation

◆ DriverParallelInTime()

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

Constructor.

Definition at line 49 of file DriverParallelInTime.cpp.

52 : Driver(pSession, pGraph)
53{
54}
Nektar::SolverUtils::Driver::Driver
Driver(const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
Initialises EquationSystem class members.
Definition: Driver.cpp:76

◆ ~DriverParallelInTime()

virtual SOLVER_UTILS_EXPORT Nektar::SolverUtils::DriverParallelInTime::~DriverParallelInTime ( )
protectedvirtualdefault

Destructor.

Member Function Documentation

◆ AllocateMemory()

void Nektar::SolverUtils::DriverParallelInTime::AllocateMemory ( void  )
protected

Definition at line 362 of file DriverParallelInTime.cpp.

363{
364 // Set some member variables.
365 m_nVar = m_fineEqSys->GetNvariables();
366 m_fineNpts = m_fineEqSys->GetNpoints();
367 m_coarseNpts = m_coarseEqSys->GetNpoints();
368
369 // Allocate memory.
370 m_exactsoln = Array<OneD, Array<OneD, NekDouble>>(m_nVar);
371 m_tmpfine = Array<OneD, Array<OneD, NekDouble>>(m_nVar);
372 m_tmpcoarse = Array<OneD, Array<OneD, NekDouble>>(m_nVar);
373 for (size_t i = 0; i < m_nVar; ++i)
374 {
375 m_exactsoln[i] = Array<OneD, NekDouble>(m_fineNpts, 0.0);
376 m_tmpfine[i] = Array<OneD, NekDouble>(m_fineNpts, 0.0);
377 m_tmpcoarse[i] = Array<OneD, NekDouble>(m_coarseNpts, 0.0);
378 }
379 m_vL2Errors = Array<OneD, NekDouble>(m_nVar, 0.0);
380 m_vLinfErrors = Array<OneD, NekDouble>(m_nVar, 0.0);
381}
Nektar::SolverUtils::DriverParallelInTime::m_tmpfine
Array< OneD, Array< OneD, NekDouble > > m_tmpfine
Definition: DriverParallelInTime.h:214
Nektar::SolverUtils::DriverParallelInTime::m_coarseEqSys
std::shared_ptr< SolverUtils::UnsteadySystem > m_coarseEqSys
Definition: DriverParallelInTime.h:210
Nektar::SolverUtils::DriverParallelInTime::m_tmpcoarse
Array< OneD, Array< OneD, NekDouble > > m_tmpcoarse
Definition: DriverParallelInTime.h:215
Nektar::SolverUtils::DriverParallelInTime::m_fineEqSys
std::shared_ptr< SolverUtils::UnsteadySystem > m_fineEqSys
Definition: DriverParallelInTime.h:209
Nektar::SolverUtils::DriverParallelInTime::m_exactsoln
Array< OneD, Array< OneD, NekDouble > > m_exactsoln
Definition: DriverParallelInTime.h:213

References m_coarseEqSys, m_coarseNpts, m_exactsoln, m_fineEqSys, m_fineNpts, m_nVar, m_tmpcoarse, m_tmpfine, m_vL2Errors, and m_vLinfErrors.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ CopyFromCoarsePhysField()

void Nektar::SolverUtils::DriverParallelInTime::CopyFromCoarsePhysField ( Array< OneD, Array< OneD, NekDouble > > &  out)
protected

Definition at line 586 of file DriverParallelInTime.cpp.

588{
589 for (size_t i = 0; i < out.size(); ++i)
590 {
591 m_coarseEqSys->CopyFromPhysField(i, out[i]);
592 }
593}

References m_coarseEqSys.

Referenced by Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme().

◆ CopyFromFinePhysField()

void Nektar::SolverUtils::DriverParallelInTime::CopyFromFinePhysField ( Array< OneD, Array< OneD, NekDouble > > &  out)
protected

Definition at line 574 of file DriverParallelInTime.cpp.

576{
577 for (size_t i = 0; i < out.size(); ++i)
578 {
579 m_fineEqSys->CopyFromPhysField(i, out[i]);
580 }
581}

References m_fineEqSys.

Referenced by Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ CopySolutionVector()

void Nektar::SolverUtils::DriverParallelInTime::CopySolutionVector ( const Array< OneD, const Array< OneD, NekDouble > > &  in,
Array< OneD, Array< OneD, NekDouble > > &  out 
)
protected

Definition at line 561 of file DriverParallelInTime.cpp.

564{
565 for (size_t i = 0; i < in.size(); ++i)
566 {
567 Vmath::Vcopy(in[i].size(), in[i], 1, out[i], 1);
568 }
569}
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1191

References Vmath::Vcopy().

Referenced by Nektar::SolverUtils::DriverPFASST::SaveCoarseResidual(), Nektar::SolverUtils::DriverPFASST::SaveCoarseSolution(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ CopyToCoarsePhysField()

void Nektar::SolverUtils::DriverParallelInTime::CopyToCoarsePhysField ( const Array< OneD, const Array< OneD, NekDouble > > &  in)
protected

Definition at line 610 of file DriverParallelInTime.cpp.

612{
613 for (size_t i = 0; i < in.size(); ++i)
614 {
615 m_coarseEqSys->CopyToPhysField(i, in[i]);
616 }
617}

References m_coarseEqSys.

◆ CopyToFinePhysField()

void Nektar::SolverUtils::DriverParallelInTime::CopyToFinePhysField ( const Array< OneD, const Array< OneD, NekDouble > > &  in)
protected

Definition at line 598 of file DriverParallelInTime.cpp.

600{
601 for (size_t i = 0; i < in.size(); ++i)
602 {
603 m_fineEqSys->CopyToPhysField(i, in[i]);
604 }
605}

References m_fineEqSys.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute().

◆ EstimateCommunicationTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::EstimateCommunicationTime ( Array< OneD, Array< OneD, NekDouble > > &  buffer1,
Array< OneD, Array< OneD, NekDouble > > &  buffer2 
)
protected

Definition at line 859 of file DriverParallelInTime.cpp.

862{
863 if (m_numChunks == 1)
864 {
865 return 0.0;
866 }
867 else
868 {
869 // Average communication time over niter iteration.
870 size_t niter = 20;
871 Nektar::LibUtilities::Timer timer;
872 LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
873 for (size_t n = 0; n <= niter; n++)
874 {
875 if (n == 1)
876 {
877 timer.Start(); // Ignore the first iteration
878 }
879
880 if (m_chunkRank == 0)
881 {
882 for (size_t i = 0; i < buffer1.size(); ++i)
883 {
884 tComm->Send(m_numChunks - 1, buffer1[i]);
885 }
886 }
887
888 if (m_chunkRank == m_numChunks - 1)
889 {
890 for (size_t i = 0; i < buffer2.size(); ++i)
891 {
892 tComm->Recv(0, buffer2[i]);
893 }
894 }
895 }
896 timer.Stop();
897 return timer.Elapsed().count() / niter;
898 }
899}
Nektar::SolverUtils::Driver::m_session
LibUtilities::SessionReaderSharedPtr m_session
Session reader object.
Definition: Driver.h:85
Nektar::LibUtilities::CommSharedPtr
std::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:57

References Nektar::LibUtilities::Timer::Elapsed(), m_chunkRank, m_numChunks, Nektar::SolverUtils::Driver::m_session, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by Nektar::SolverUtils::DriverParareal::v_EstimateCommunicationTime(), and Nektar::SolverUtils::DriverPFASST::v_EstimateCommunicationTime().

◆ EvaluateExactSolution()

void Nektar::SolverUtils::DriverParallelInTime::EvaluateExactSolution ( const NekDouble &  time)
protected

Definition at line 637 of file DriverParallelInTime.cpp.

638{
639 for (size_t i = 0; i < m_exactsoln.size(); ++i)
640 {
641 m_fineEqSys->EvaluateExactSolution(i, m_exactsoln[i], time);
642 }
643}

References m_exactsoln, and m_fineEqSys.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ GetParametersFromSession()

void Nektar::SolverUtils::DriverParallelInTime::GetParametersFromSession ( void  )
protected

Definition at line 315 of file DriverParallelInTime.cpp.

316{
317 // Parallel-in-Time iteration parameters.
318 m_tolerPIT = m_session->GetParameter("PITToler");
319 m_iterMaxPIT = m_session->GetParameter("PITIterMax");
320 m_numWindowsPIT = m_session->DefinesParameter("NumWindows")
321 ? m_session->GetParameter("NumWindows")
322 : m_numWindowsPIT;
323
324 // Time stepping parameters.
325 m_fineTimeStep = m_equ[0]->GetTimeStep();
326 m_coarseTimeStep = m_equ[1]->GetTimeStep();
327 m_fineSteps = m_equ[0]->GetSteps();
328 m_coarseSteps = m_equ[1]->GetSteps();
329
330 // I/O parameters.
331 m_infoSteps = m_fineEqSys->GetInfoSteps();
332 m_checkSteps = m_fineEqSys->GetCheckpointSteps();
333
334 // Other parameters.
335 m_exactSolution = m_session->DefinesParameter("ExactSolution")
336 ? m_session->GetParameter("ExactSolution")
337 : m_exactSolution;
338}
Nektar::SolverUtils::Driver::m_equ
Array< OneD, EquationSystemSharedPtr > m_equ
Equation system to solve.
Definition: Driver.h:94
Nektar::SolverUtils::DriverParallelInTime::m_coarseSteps
size_t m_coarseSteps
Number of steps for the coarse solver.
Definition: DriverParallelInTime.h:183
Nektar::SolverUtils::DriverParallelInTime::m_iterMaxPIT
size_t m_iterMaxPIT
Maximum number of parallel-in-time iteration.
Definition: DriverParallelInTime.h:192
Nektar::SolverUtils::DriverParallelInTime::m_fineSteps
size_t m_fineSteps
Number of steps for the fine solver.
Definition: DriverParallelInTime.h:180
Nektar::SolverUtils::DriverParallelInTime::m_coarseTimeStep
NekDouble m_coarseTimeStep
Timestep for coarse solver.
Definition: DriverParallelInTime.h:162
Nektar::SolverUtils::DriverParallelInTime::m_tolerPIT
NekDouble m_tolerPIT
ParallelInTime tolerance.
Definition: DriverParallelInTime.h:201
Nektar::SolverUtils::DriverParallelInTime::m_fineTimeStep
NekDouble m_fineTimeStep
Timestep for fine solver.
Definition: DriverParallelInTime.h:159
Nektar::SolverUtils::DriverParallelInTime::m_exactSolution
bool m_exactSolution
Using exact solution to compute error norms.
Definition: DriverParallelInTime.h:198
Nektar::SolverUtils::DriverParallelInTime::m_checkSteps
size_t m_checkSteps
Number of steps for checkpoint.
Definition: DriverParallelInTime.h:177
Nektar::SolverUtils::DriverParallelInTime::m_infoSteps
size_t m_infoSteps
Number of steps for info I/O.
Definition: DriverParallelInTime.h:174

References m_checkSteps, m_coarseSteps, m_coarseTimeStep, Nektar::SolverUtils::Driver::m_equ, m_exactSolution, m_fineEqSys, m_fineSteps, m_fineTimeStep, m_infoSteps, m_iterMaxPIT, m_numWindowsPIT, Nektar::SolverUtils::Driver::m_session, and m_tolerPIT.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ InitialiseEqSystem()

void Nektar::SolverUtils::DriverParallelInTime::InitialiseEqSystem ( bool  turnoff_output)
protected

Definition at line 343 of file DriverParallelInTime.cpp.

344{
345 // Initialize fine solver.
346 if (turnoff_output)
347 {
348 m_fineEqSys->SetInfoSteps(0);
349 m_fineEqSys->SetCheckpointSteps(0);
350 }
351 m_fineEqSys->DoInitialise(true);
352
353 // Initialize coarse solver.
354 m_coarseEqSys->SetInfoSteps(0);
355 m_coarseEqSys->SetCheckpointSteps(0);
356 m_coarseEqSys->DoInitialise(false);
357}

References m_coarseEqSys, and m_fineEqSys.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ InitialiseInterpolationField()

void Nektar::SolverUtils::DriverParallelInTime::InitialiseInterpolationField ( void  )
protected

Definition at line 386 of file DriverParallelInTime.cpp.

387{
388 m_fineFields = Array<OneD, MultiRegions::ExpListSharedPtr>(m_nVar);
389 m_coarseFields = Array<OneD, MultiRegions::ExpListSharedPtr>(m_nVar);
390 for (size_t i = 0; i < m_nVar; ++i)
391 {
392 m_fineFields[i] =
393 MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr(
394 m_fineEqSys->UpdateFields()[i], true, false);
395 m_coarseFields[i] =
396 MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr(
397 m_coarseEqSys->UpdateFields()[i], true, false);
398 }
399}
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168
Nektar::SolverUtils::DriverParallelInTime::m_fineFields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fineFields
Definition: DriverParallelInTime.h:216
Nektar::SolverUtils::DriverParallelInTime::m_coarseFields
Array< OneD, MultiRegions::ExpListSharedPtr > m_coarseFields
Definition: DriverParallelInTime.h:217

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), m_coarseEqSys, m_coarseFields, m_fineEqSys, m_fineFields, and m_nVar.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ Interpolator()

void Nektar::SolverUtils::DriverParallelInTime::Interpolator ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray 
)
protected

Definition at line 730 of file DriverParallelInTime.cpp.

733{
734 size_t nVar = inarray.size();
735
736 // Interpolate from fine to coarse
737 if (inarray[0].size() > outarray[0].size())
738 {
739 for (size_t i = 0; i < nVar; ++i)
740 {
741 m_fineFields[i]->UpdatePhys() = inarray[i];
742 m_coarseFields[i]->UpdatePhys() = outarray[i];
743 }
744 InterpExp1ToExp2(m_fineFields, m_coarseFields);
745 }
746 // Interpolate from coarse to fine
747 else
748 {
749 for (size_t i = 0; i < nVar; ++i)
750 {
751 m_coarseFields[i]->UpdatePhys() = inarray[i];
752 m_fineFields[i]->UpdatePhys() = outarray[i];
753 }
754 InterpExp1ToExp2(m_coarseFields, m_fineFields);
755 }
756}
Nektar::SolverUtils::InterpExp1ToExp2
void InterpExp1ToExp2(const Array< OneD, MultiRegions::ExpListSharedPtr > exp1, Array< OneD, MultiRegions::ExpListSharedPtr > &exp2)
Interpolate from an expansion to an expansion.
Definition: DriverParallelInTime.cpp:904

References Nektar::SolverUtils::InterpExp1ToExp2(), m_coarseFields, and m_fineFields.

Referenced by Nektar::SolverUtils::DriverPFASST::ApplyWindowing(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::Interpolate(), Nektar::SolverUtils::DriverPFASST::Restrict(), Nektar::SolverUtils::DriverParareal::RunCoarseSolve(), Nektar::SolverUtils::DriverParareal::v_EstimateInterpolationTime(), and Nektar::SolverUtils::DriverParareal::v_EstimateRestrictionTime().

◆ PrintCoarseSolverInfo()

void Nektar::SolverUtils::DriverParallelInTime::PrintCoarseSolverInfo ( std::ostream &  out = std::cout)
protected

Definition at line 404 of file DriverParallelInTime.cpp.

405{
406 if (m_chunkRank == 0 && m_comm->GetSpaceComm()->GetRank() == 0)
407 {
408 std::cout << "========================================================="
409 "=============="
410 << std::endl
411 << std::flush;
412 std::cout << "======================== COARSE PROPAGATOR INFO "
413 "======================="
414 << std::endl
415 << std::flush;
416
417 m_coarseEqSys->PrintSummary(out);
418
419 std::cout << std::endl << std::flush;
420 }
421}
Nektar::SolverUtils::Driver::m_comm
LibUtilities::CommSharedPtr m_comm
Communication object.
Definition: Driver.h:82

References m_chunkRank, m_coarseEqSys, and Nektar::SolverUtils::Driver::m_comm.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ PrintComputationalTime()

void Nektar::SolverUtils::DriverParallelInTime::PrintComputationalTime ( const NekDouble  time)
protected

Definition at line 481 of file DriverParallelInTime.cpp.

482{
483 if (m_chunkRank == m_numChunks - 1 &&
484 m_comm->GetSpaceComm()->GetRank() == 0)
485 {
486 std::cout << "Total Computation Time : " << time << "s" << std::endl
487 << std::flush;
488 }
489}

References m_chunkRank, Nektar::SolverUtils::Driver::m_comm, and m_numChunks.

Referenced by SolutionConvergenceMonitoring(), and SolutionConvergenceSummary().

◆ PrintErrorNorm()

void Nektar::SolverUtils::DriverParallelInTime::PrintErrorNorm ( const bool  normalized)
protected

Definition at line 681 of file DriverParallelInTime.cpp.

682{
683 if (m_chunkRank == m_numChunks - 1 &&
684 m_comm->GetSpaceComm()->GetRank() == 0)
685 {
686 for (size_t i = 0; i < m_vL2Errors.size(); ++i)
687 {
688 if (normalized)
689 {
690 std::cout << "L2 error (variable "
691 << m_fineEqSys->GetVariable(i)
692 << ") : " << m_vL2Errors[i] << std::endl
693 << std::flush;
694 std::cout << "Linf error (variable "
695 << m_fineEqSys->GetVariable(i)
696 << ") : " << m_vLinfErrors[i] << std::endl
697 << std::flush;
698 }
699 else
700 {
701 std::cout << "L 2 error (variable "
702 << m_fineEqSys->GetVariable(i)
703 << ") : " << m_vL2Errors[i] << std::endl
704 << std::flush;
705 std::cout << "L inf error (variable "
706 << m_fineEqSys->GetVariable(i)
707 << ") : " << m_vLinfErrors[i] << std::endl
708 << std::flush;
709 }
710 }
711 }
712}

References m_chunkRank, Nektar::SolverUtils::Driver::m_comm, m_fineEqSys, m_numChunks, m_vL2Errors, and m_vLinfErrors.

Referenced by SolutionConvergenceMonitoring(), SolutionConvergenceSummary(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ PrintFineSolverInfo()

void Nektar::SolverUtils::DriverParallelInTime::PrintFineSolverInfo ( std::ostream &  out = std::cout)
protected

Definition at line 426 of file DriverParallelInTime.cpp.

427{
428 if (m_chunkRank == 0 && m_comm->GetSpaceComm()->GetRank() == 0)
429 {
430 std::cout << "========================================================="
431 "=============="
432 << std::endl
433 << std::flush;
434 std::cout << "========================= FINE PROPAGATOR INFO "
435 "========================"
436 << std::endl
437 << std::flush;
438
439 m_fineEqSys->PrintSummary(out);
440
441 std::cout << std::endl << std::flush;
442 }
443}

References m_chunkRank, Nektar::SolverUtils::Driver::m_comm, and m_fineEqSys.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ PrintHeaderTitle1()

void Nektar::SolverUtils::DriverParallelInTime::PrintHeaderTitle1 ( const std::string &  title)
protected

Definition at line 448 of file DriverParallelInTime.cpp.

449{
450 if (m_chunkRank == m_numChunks - 1 &&
451 m_comm->GetSpaceComm()->GetRank() == 0)
452 {
453 std::cout << std::endl;
454 std::cout << "*******************************************" << std::endl
455 << std::flush;
456 std::cout << title << std::endl << std::flush;
457 std::cout << "*******************************************" << std::endl
458 << std::flush;
459 }
460}
CG_Iterations.title
string title
Definition: CG_Iterations.py:313

References m_chunkRank, Nektar::SolverUtils::Driver::m_comm, m_numChunks, and CG_Iterations::title.

Referenced by SpeedUpAnalysis(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ PrintHeaderTitle2()

void Nektar::SolverUtils::DriverParallelInTime::PrintHeaderTitle2 ( const std::string &  title)
protected

Definition at line 465 of file DriverParallelInTime.cpp.

466{
467 if (m_chunkRank == m_numChunks - 1 &&
468 m_comm->GetSpaceComm()->GetRank() == 0)
469 {
470 std::cout << "-------------------------------------------" << std::endl
471 << std::flush;
472 std::cout << title << std::endl << std::flush;
473 std::cout << "-------------------------------------------" << std::endl
474 << std::flush;
475 }
476}

References m_chunkRank, Nektar::SolverUtils::Driver::m_comm, m_numChunks, and CG_Iterations::title.

Referenced by Nektar::SolverUtils::DriverParareal::PrintSolutionFile(), PrintSpeedUp(), SpeedUpAnalysis(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ PrintSpeedUp()

void Nektar::SolverUtils::DriverParallelInTime::PrintSpeedUp ( NekDouble  fineSolveTime,
NekDouble  coarseSolveTime,
NekDouble  restTime,
NekDouble  interTime,
NekDouble  commTime,
NekDouble  predictorOverheadTime,
NekDouble  overheadTime 
)
protected

Definition at line 809 of file DriverParallelInTime.cpp.

815{
816 if (m_chunkRank == m_numChunks - 1 &&
817 m_comm->GetSpaceComm()->GetRank() == 0)
818 {
819 // Print maximum theoretical speed-up
820 PrintHeaderTitle2("Maximum Speed-up");
821 for (size_t k = 1; k <= m_numChunks; k++)
822 {
823 NekDouble speedup =
824 v_ComputeSpeedUp(k, fineSolveTime, coarseSolveTime, 0.0, 0.0,
825 0.0, predictOverheadTime, OverheadTime);
826 std::cout << "Speed-up (" << k << ") = " << speedup << std::endl
827 << std::flush;
828 }
829
830 // Print speed-up with interpolation
831 PrintHeaderTitle2("Speed-up with interp.");
832 for (size_t k = 1; k <= m_numChunks; k++)
833 {
834 NekDouble speedup = v_ComputeSpeedUp(
835 k, fineSolveTime, coarseSolveTime, restTime, interTime, 0.0,
836 predictOverheadTime, OverheadTime);
837 std::cout << "Speed-up (" << k << ") = " << speedup << std::endl
838 << std::flush;
839 }
840
841 // Print speed-up with interpolation and communication
842 PrintHeaderTitle2("Speed-up with comm. and interp.");
843 for (size_t k = 1; k <= m_numChunks; k++)
844 {
845 NekDouble speedup = v_ComputeSpeedUp(
846 k, fineSolveTime, coarseSolveTime, restTime, interTime,
847 commTime, predictOverheadTime, OverheadTime);
848 std::cout << "Speed-up (" << k << ") = " << speedup << std::endl
849 << std::flush;
850 }
851 std::cout << "-------------------------------------------" << std::endl
852 << std::flush;
853 }
854}
Nektar::SolverUtils::DriverParallelInTime::PrintHeaderTitle2
void PrintHeaderTitle2(const std::string &title)
Definition: DriverParallelInTime.cpp:465
Nektar::SolverUtils::DriverParallelInTime::v_ComputeSpeedUp
virtual NekDouble v_ComputeSpeedUp(const size_t iter, NekDouble fineSolveTime, NekDouble coarseSolveTime, NekDouble restTime, NekDouble interTime, NekDouble commTime, NekDouble predictorTime, NekDouble overheadTime)
Definition: DriverParallelInTime.cpp:180
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

References m_chunkRank, Nektar::SolverUtils::Driver::m_comm, m_numChunks, PrintHeaderTitle2(), and v_ComputeSpeedUp().

Referenced by SpeedUpAnalysis().

◆ RecvInitialConditionFromPreviousProc() [1/2]

void Nektar::SolverUtils::DriverParallelInTime::RecvInitialConditionFromPreviousProc ( Array< OneD, Array< OneD, NekDouble > > &  array)
protected

Definition at line 512 of file DriverParallelInTime.cpp.

514{
515 LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
516
517 if (m_chunkRank > 0)
518 {
519 for (size_t i = 0; i < array.size(); ++i)
520 {
521 tComm->Recv(m_chunkRank - 1, array[i]);
522 }
523 }
524}

References m_chunkRank, and Nektar::SolverUtils::Driver::m_session.

◆ RecvInitialConditionFromPreviousProc() [2/2]

void Nektar::SolverUtils::DriverParallelInTime::RecvInitialConditionFromPreviousProc ( Array< OneD, Array< OneD, NekDouble > > &  array,
int &  convergence 
)
protected

Definition at line 494 of file DriverParallelInTime.cpp.

496{
497 LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
498
499 if (!convergence)
500 {
501 if (m_chunkRank > 0)
502 {
503 tComm->Recv(m_chunkRank - 1, convergence);
504 RecvInitialConditionFromPreviousProc(array);
505 }
506 }
507}
Nektar::SolverUtils::DriverParallelInTime::RecvInitialConditionFromPreviousProc
void RecvInitialConditionFromPreviousProc(Array< OneD, Array< OneD, NekDouble > > &array, int &convergence)
Definition: DriverParallelInTime.cpp:494

References m_chunkRank, Nektar::SolverUtils::Driver::m_session, and RecvInitialConditionFromPreviousProc().

Referenced by RecvInitialConditionFromPreviousProc(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ SendSolutionToNextProc() [1/2]

void Nektar::SolverUtils::DriverParallelInTime::SendSolutionToNextProc ( Array< OneD, Array< OneD, NekDouble > > &  array)
protected

Definition at line 544 of file DriverParallelInTime.cpp.

546{
547 LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
548
549 if (m_chunkRank < m_numChunks - 1)
550 {
551 for (size_t i = 0; i < array.size(); ++i)
552 {
553 tComm->Send(m_chunkRank + 1, array[i]);
554 }
555 }
556}

References m_chunkRank, m_numChunks, and Nektar::SolverUtils::Driver::m_session.

◆ SendSolutionToNextProc() [2/2]

void Nektar::SolverUtils::DriverParallelInTime::SendSolutionToNextProc ( Array< OneD, Array< OneD, NekDouble > > &  array,
int &  convergence 
)
protected

Definition at line 529 of file DriverParallelInTime.cpp.

531{
532 LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
533
534 if (m_chunkRank < m_numChunks - 1)
535 {
536 tComm->Send(m_chunkRank + 1, convergence);
537 }
538 SendSolutionToNextProc(array);
539}
Nektar::SolverUtils::DriverParallelInTime::SendSolutionToNextProc
void SendSolutionToNextProc(Array< OneD, Array< OneD, NekDouble > > &array, int &convergence)
Definition: DriverParallelInTime.cpp:529

References m_chunkRank, m_numChunks, Nektar::SolverUtils::Driver::m_session, and SendSolutionToNextProc().

Referenced by SendSolutionToNextProc(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ SetParallelInTimeEquationSystem()

void Nektar::SolverUtils::DriverParallelInTime::SetParallelInTimeEquationSystem ( std::string  AdvectiveType)
protected

Set the ParallelInTime (coarse solver) session file

Definition at line 195 of file DriverParallelInTime.cpp.

197{
198 // Retrieve the equation system to solve.
199 ASSERTL0(m_session->DefinesSolverInfo("EqType"),
200 "EqType SolverInfo tag must be defined.");
201 std::string vEquation = m_session->DefinesSolverInfo("SolverType")
202 ? m_session->GetSolverInfo("SolverType")
203 : m_session->GetSolverInfo("EqType");
204
205 // Check such a module exists for this equation.
206 ASSERTL0(GetEquationSystemFactory().ModuleExists(vEquation),
207 "EquationSystem '" + vEquation +
208 "' is not defined.\n"
209 "Ensure equation name is correct and module is compiled.\n");
210
211 // Set fine parallel-in-time solver.
212 m_session->SetTag("AdvectiveType", AdvectiveType);
213 m_session->SetTag("ParallelInTimeSolver", "TimeLevel0");
214 m_equ[0] = GetEquationSystemFactory().CreateInstance(vEquation, m_session,
215 m_graph);
216
217 // Define argument for the coarse parallel-in-time solver.
218 int npx = m_session->DefinesCmdLineArgument("npx")
219 ? m_session->GetCmdLineArgument<int>("npx")
220 : 1;
221 int npy = m_session->DefinesCmdLineArgument("npy")
222 ? m_session->GetCmdLineArgument<int>("npy")
223 : 1;
224 int npz = m_session->DefinesCmdLineArgument("npz")
225 ? m_session->GetCmdLineArgument<int>("npz")
226 : 1;
227 int nsz = m_session->DefinesCmdLineArgument("nsz")
228 ? m_session->GetCmdLineArgument<int>("nsz")
229 : 1;
230 int npt = m_session->DefinesCmdLineArgument("npt")
231 ? m_session->GetCmdLineArgument<int>("npt")
232 : 1;
233
234 // Convert into string.
235 std::string npx_string = std::to_string(npx);
236 std::string npy_string = std::to_string(npy);
237 std::string npz_string = std::to_string(npz);
238 std::string nsz_string = std::to_string(nsz);
239 std::string npt_string = std::to_string(npt);
240
241 // useoptfile
242 bool useoptfile = m_session->DefinesCmdLineArgument("useoptfile");
243 std::string optfilename = useoptfile ? m_session->GetFilenames()[0] : "";
244
245 char *argv[] = {const_cast<char *>("Solver"), // this is just a place holder
246 const_cast<char *>("--npx"),
247 const_cast<char *>(npx_string.c_str()),
248 const_cast<char *>("--npy"),
249 const_cast<char *>(npy_string.c_str()),
250 const_cast<char *>("--npz"),
251 const_cast<char *>(npz_string.c_str()),
252 const_cast<char *>("--nsz"),
253 const_cast<char *>(nsz_string.c_str()),
254 const_cast<char *>("--npt"),
255 const_cast<char *>(npt_string.c_str()),
256 const_cast<char *>("--useoptfile"),
257 const_cast<char *>(optfilename.c_str()),
258 nullptr};
259
260 size_t argc = useoptfile ? 13 : 11;
261
262 // Get list of session file names.
263 std::vector<std::string> sessionFileNames;
264 for (auto &filename : m_session->GetFilenames())
265 {
266 // Remove optfile name, if necessary.
267 if (filename.substr(filename.find_last_of(".") + 1) != "opt")
268 {
269 sessionFileNames.push_back(filename);
270 }
271 }
272
273 // Set session for coarse solver.
274 for (size_t timeLevel = 1; timeLevel < m_nequ; timeLevel++)
275 {
276 auto session = LibUtilities::SessionReader::CreateInstance(
277 argc, argv, sessionFileNames, m_session->GetComm(), timeLevel);
278
279 // Set graph for coarse solver.
280 auto graph = SpatialDomains::MeshGraph::Read(
281 session, LibUtilities::NullDomainRangeShPtr, true, m_graph);
282
283 // Set BndRegionOrdering (necessary for DG with periodic BC) FIXME
284 graph->SetBndRegionOrdering(m_graph->GetBndRegionOrdering());
285
286 // Set CompositeOrdering (necessary for DG with periodic BC) FIXME
287 graph->SetCompositeOrdering(m_graph->GetCompositeOrdering());
288
289 // Retrieve the equation system to solve.
290 ASSERTL0(session->DefinesSolverInfo("EqType"),
291 "EqType SolverInfo tag must be defined.");
292 auto vEquation = session->DefinesSolverInfo("SolverType")
293 ? session->GetSolverInfo("SolverType")
294 : session->GetSolverInfo("EqType");
295
296 // Check such a module exists for this equation.
297 ASSERTL0(
298 GetEquationSystemFactory().ModuleExists(vEquation),
299 "EquationSystem '" + vEquation +
300 "' is not defined.\n"
301 "Ensure equation name is correct and module is compiled.\n");
302
303 // Set coarse parallel-in-time solver.
304 session->SetTag("AdvectiveType", AdvectiveType);
305 session->SetTag("ParallelInTimeSolver",
306 "TimeLevel" + std::to_string(timeLevel));
307 m_equ[timeLevel] = GetEquationSystemFactory().CreateInstance(
308 vEquation, session, graph);
309 }
310}
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
Nektar::LibUtilities::SessionReader::CreateInstance
static SessionReaderSharedPtr CreateInstance(int argc, char *argv[])
Creates an instance of the SessionReader class.
Definition: SessionReader.h:134
Nektar::SolverUtils::Driver::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
MeshGraph object.
Definition: Driver.h:91
Nektar::SolverUtils::Driver::m_nequ
int m_nequ
number of equations
Definition: Driver.h:97
Nektar::SpatialDomains::MeshGraph::Read
static MeshGraphSharedPtr Read(const LibUtilities::SessionReaderSharedPtr pSession, LibUtilities::DomainRangeShPtr rng=LibUtilities::NullDomainRangeShPtr, bool fillGraph=true, SpatialDomains::MeshGraphSharedPtr partitionedGraph=nullptr)
Definition: MeshGraph.cpp:116
Nektar::LibUtilities::NullDomainRangeShPtr
static DomainRangeShPtr NullDomainRangeShPtr
Definition: DomainRange.h:67
Nektar::SolverUtils::GetEquationSystemFactory
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:103

References ASSERTL0, Nektar::LibUtilities::SessionReader::CreateInstance(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::SolverUtils::GetEquationSystemFactory(), Nektar::SolverUtils::Driver::m_equ, Nektar::SolverUtils::Driver::m_graph, Nektar::SolverUtils::Driver::m_nequ, Nektar::SolverUtils::Driver::m_session, Nektar::LibUtilities::NullDomainRangeShPtr, and Nektar::SpatialDomains::MeshGraph::Read().

Referenced by v_InitObject().

◆ SolutionConvergenceMonitoring()

void Nektar::SolverUtils::DriverParallelInTime::SolutionConvergenceMonitoring ( const NekDouble &  time)
protected

Definition at line 648 of file DriverParallelInTime.cpp.

650{
651 UpdateErrorNorm(true);
652 PrintErrorNorm(true);
653 PrintComputationalTime(CPUtime);
654}

References PrintComputationalTime(), PrintErrorNorm(), and UpdateErrorNorm().

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute().

◆ SolutionConvergenceSummary()

void Nektar::SolverUtils::DriverParallelInTime::SolutionConvergenceSummary ( const NekDouble &  time)
protected

Definition at line 659 of file DriverParallelInTime.cpp.

660{
661 UpdateErrorNorm(false);
662 PrintErrorNorm(false);
663 PrintComputationalTime(CPUtime);
664}

References PrintComputationalTime(), PrintErrorNorm(), and UpdateErrorNorm().

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ SpeedUpAnalysis()

void Nektar::SolverUtils::DriverParallelInTime::SpeedUpAnalysis ( )
protected

Definition at line 761 of file DriverParallelInTime.cpp.

762{
763 // Print header.
764 PrintHeaderTitle1("PARAREAL SPEED-UP ANALYSIS");
765
766 // Mean communication time.
767 NekDouble commTime = v_EstimateCommunicationTime();
768 PrintHeaderTitle2("Mean Communication Time = " +
769 (boost::format("%1$.6e") % commTime).str() + "s");
770
771 // Mean restriction time.
772 NekDouble restTime = v_EstimateRestrictionTime();
773 PrintHeaderTitle2("Mean Restriction Time = " +
774 (boost::format("%1$.6f") % restTime).str() + "s");
775
776 // Mean interpolation time.
777 NekDouble interTime = v_EstimateInterpolationTime();
778 PrintHeaderTitle2("Mean Interpolation Time = " +
779 (boost::format("%1$.6f") % interTime).str() + "s");
780
781 // Mean coarse solver time.
782 NekDouble coarseSolveTime = v_EstimateCoarseSolverTime();
783 PrintHeaderTitle2("Mean Coarse Solve Time = " +
784 (boost::format("%1$.6f") % coarseSolveTime).str() + "s");
785
786 // Mean fine solver time.
787 NekDouble fineSolveTime = v_EstimateFineSolverTime();
788 PrintHeaderTitle2("Mean Fine Solve Time = " +
789 (boost::format("%1$.6f") % fineSolveTime).str() + "s");
790
791 // Mean predictor time.
792 NekDouble predictorTime = v_EstimatePredictorTime();
793 PrintHeaderTitle2("Mean Predictor Time = " +
794 (boost::format("%1$.6f") % predictorTime).str() + "s");
795
796 // Mean overhead time.
797 NekDouble OverheadTime = v_EstimateOverheadTime();
798 PrintHeaderTitle2("Mean Overhead Time = " +
799 (boost::format("%1$.6f") % OverheadTime).str() + "s");
800
801 // Print speedup time.
802 PrintSpeedUp(fineSolveTime, coarseSolveTime, restTime, interTime, commTime,
803 predictorTime, OverheadTime);
804}
Nektar::SolverUtils::DriverParallelInTime::PrintSpeedUp
void PrintSpeedUp(NekDouble fineSolveTime, NekDouble coarseSolveTime, NekDouble restTime, NekDouble interTime, NekDouble commTime, NekDouble predictorOverheadTime, NekDouble overheadTime)
Definition: DriverParallelInTime.cpp:809
Nektar::SolverUtils::DriverParallelInTime::PrintHeaderTitle1
void PrintHeaderTitle1(const std::string &title)
Definition: DriverParallelInTime.cpp:448

References CellMLToNektar.pycml::format, PrintHeaderTitle1(), PrintHeaderTitle2(), PrintSpeedUp(), v_EstimateCoarseSolverTime(), v_EstimateCommunicationTime(), v_EstimateFineSolverTime(), v_EstimateInterpolationTime(), v_EstimateOverheadTime(), v_EstimatePredictorTime(), and v_EstimateRestrictionTime().

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ UpdateErrorNorm()

void Nektar::SolverUtils::DriverParallelInTime::UpdateErrorNorm ( const bool  normalized)
protected

Definition at line 669 of file DriverParallelInTime.cpp.

670{
671 for (size_t i = 0; i < m_vL2Errors.size(); ++i)
672 {
673 m_vL2Errors[i] = m_fineEqSys->L2Error(i, m_exactsoln[i], normalized);
674 m_vLinfErrors[i] = m_fineEqSys->LinfError(i, m_exactsoln[i]);
675 }
676}

References m_exactsoln, m_fineEqSys, m_vL2Errors, and m_vLinfErrors.

Referenced by SolutionConvergenceMonitoring(), and SolutionConvergenceSummary().

◆ UpdateSolution()

void Nektar::SolverUtils::DriverParallelInTime::UpdateSolution ( const Array< OneD, const Array< OneD, NekDouble > > &  in)
protected

Definition at line 622 of file DriverParallelInTime.cpp.

624{
625 for (size_t i = 0; i < in.size(); ++i)
626 {
627 m_fineEqSys->CopyToPhysField(i, in[i]);
628 m_fineEqSys->UpdateFields()[i]->FwdTrans(
629 m_fineEqSys->UpdateFields()[i]->GetPhys(),
630 m_fineEqSys->UpdateFields()[i]->UpdateCoeffs());
631 }
632}

References m_fineEqSys.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::WriteOutput().

◆ v_ComputeSpeedUp()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_ComputeSpeedUp ( const size_t  iter,
NekDouble  fineSolveTime,
NekDouble  coarseSolveTime,
NekDouble  restTime,
NekDouble  interTime,
NekDouble  commTime,
NekDouble  predictorTime,
NekDouble  overheadTime 
)
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 180 of file DriverParallelInTime.cpp.

184{
185 boost::ignore_unused(iter, fineSolveTime, coarseSolveTime, restTime,
186 interTime, commTime, predictorOverheadTime,
187 overheadTime);
188 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
189 return 0.0;
190}

References ASSERTL0.

Referenced by PrintSpeedUp().

◆ v_EstimateCoarseSolverTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_EstimateCoarseSolverTime ( void  )
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 144 of file DriverParallelInTime.cpp.

145{
146 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
147 return 0.0;
148}

References ASSERTL0.

Referenced by SpeedUpAnalysis().

◆ v_EstimateCommunicationTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_EstimateCommunicationTime ( void  )
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 117 of file DriverParallelInTime.cpp.

118{
119 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
120 return 0.0;
121}

References ASSERTL0.

Referenced by SpeedUpAnalysis().

◆ v_EstimateFineSolverTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_EstimateFineSolverTime ( void  )
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 153 of file DriverParallelInTime.cpp.

154{
155 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
156 return 0.0;
157}

References ASSERTL0.

Referenced by SpeedUpAnalysis().

◆ v_EstimateInterpolationTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_EstimateInterpolationTime ( void  )
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 135 of file DriverParallelInTime.cpp.

136{
137 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
138 return 0.0;
139}

References ASSERTL0.

Referenced by SpeedUpAnalysis().

◆ v_EstimateOverheadTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_EstimateOverheadTime ( void  )
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 171 of file DriverParallelInTime.cpp.

172{
173 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
174 return 0.0;
175}

References ASSERTL0.

Referenced by SpeedUpAnalysis().

◆ v_EstimatePredictorTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_EstimatePredictorTime ( void  )
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 162 of file DriverParallelInTime.cpp.

163{
164 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
165 return 0.0;
166}

References ASSERTL0.

Referenced by SpeedUpAnalysis().

◆ v_EstimateRestrictionTime()

NekDouble Nektar::SolverUtils::DriverParallelInTime::v_EstimateRestrictionTime ( void  )
protectedvirtual

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 126 of file DriverParallelInTime.cpp.

127{
128 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
129 return 0.0;
130}

References ASSERTL0.

Referenced by SpeedUpAnalysis().

◆ v_Execute()

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

Virtual function for solve implementation.

Implements Nektar::SolverUtils::Driver.

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 107 of file DriverParallelInTime.cpp.

108{
109 boost::ignore_unused(out);
110
111 ASSERTL0(false, "Specific version of Parallel-in-Time not implemented");
112}

References ASSERTL0.

◆ v_InitObject()

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

Virtual function for initialisation implementation.

Reimplemented from Nektar::SolverUtils::Driver.

Reimplemented in Nektar::SolverUtils::DriverParareal, and Nektar::SolverUtils::DriverPFASST.

Definition at line 59 of file DriverParallelInTime.cpp.

60{
61 try
62 {
63 // Retrieve the type of evolution operator to use
64 m_EvolutionOperator =
65 m_session->GetSolverInfoAsEnum<EvolutionOperatorType>(
66 "EvolutionOperator");
67
68 m_nequ = 2; // Only two time levels currently implemented.
69
70 m_equ = Array<OneD, EquationSystemSharedPtr>(m_nequ);
71
72 // Set the AdvectiveType tag and create EquationSystem objects.
73 switch (m_EvolutionOperator)
74 {
75 case eNonlinear:
76 SetParallelInTimeEquationSystem("Convective");
77 break;
78 case eDirect:
79 SetParallelInTimeEquationSystem("Linearised");
80 break;
81 case eAdjoint:
82 SetParallelInTimeEquationSystem("Adjoint");
83 break;
84 case eSkewSymmetric:
85 SetParallelInTimeEquationSystem("SkewSymmetric");
86 break;
87 default:
88 ASSERTL0(false, "Unrecognised evolution operator.");
89 }
90
91 // Set pointers.
92 m_fineEqSys =
93 std::dynamic_pointer_cast<SolverUtils::UnsteadySystem>(m_equ[0]);
94 m_coarseEqSys =
95 std::dynamic_pointer_cast<SolverUtils::UnsteadySystem>(m_equ[1]);
96 }
97 catch (int e)
98 {
99 ASSERTL0(e == -1, "No such class class defined.");
100 out << "An error occurred during driver initialisation." << std::endl;
101 }
102}
Nektar::SolverUtils::Driver::m_EvolutionOperator
enum EvolutionOperatorType m_EvolutionOperator
Evolution Operator.
Definition: Driver.h:100
Nektar::SolverUtils::DriverParallelInTime::SetParallelInTimeEquationSystem
void SetParallelInTimeEquationSystem(std::string AdvectiveType)
Definition: DriverParallelInTime.cpp:195

References ASSERTL0, Nektar::SolverUtils::eAdjoint, Nektar::SolverUtils::eDirect, Nektar::SolverUtils::eNonlinear, Nektar::SolverUtils::eSkewSymmetric, m_coarseEqSys, Nektar::SolverUtils::Driver::m_equ, Nektar::SolverUtils::Driver::m_EvolutionOperator, m_fineEqSys, Nektar::SolverUtils::Driver::m_nequ, Nektar::SolverUtils::Driver::m_session, and SetParallelInTimeEquationSystem().

Referenced by Nektar::SolverUtils::DriverParareal::v_InitObject(), and Nektar::SolverUtils::DriverPFASST::v_InitObject().

◆ vL2ErrorMax()

NekDouble Nektar::SolverUtils::DriverParallelInTime::vL2ErrorMax ( void  )
protected

Definition at line 717 of file DriverParallelInTime.cpp.

718{
719 NekDouble L2Error = 0.0;
720 for (size_t i = 0; i < m_vL2Errors.size(); ++i)
721 {
722 L2Error = std::max(L2Error, m_vL2Errors[i]);
723 }
724 return L2Error;
725}

References m_vL2Errors.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

Member Data Documentation

◆ m_checkSteps

size_t Nektar::SolverUtils::DriverParallelInTime::m_checkSteps = 0
protected

Number of steps for checkpoint.

Definition at line 177 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), GetParametersFromSession(), Nektar::SolverUtils::DriverParareal::RunFineSolve(), and Nektar::SolverUtils::DriverPFASST::WriteOutput().

◆ m_chunkRank

size_t Nektar::SolverUtils::DriverParallelInTime::m_chunkRank = 0
protected

Rank in time.

Definition at line 189 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::ApplyWindowing(), Nektar::SolverUtils::DriverPFASST::ApplyWindowing(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), EstimateCommunicationTime(), Nektar::SolverUtils::DriverPFASST::IsNotInitialCondition(), PrintCoarseSolverInfo(), PrintComputationalTime(), PrintErrorNorm(), PrintFineSolverInfo(), PrintHeaderTitle1(), PrintHeaderTitle2(), PrintSpeedUp(), RecvInitialConditionFromPreviousProc(), Nektar::SolverUtils::DriverParareal::RunFineSolve(), SendSolutionToNextProc(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_chunkTime

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_chunkTime
protected

Time for chunks.

Definition at line 168 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverPFASST::CoarseIntegratedResidualEval(), Nektar::SolverUtils::DriverPFASST::CoarseResidualEval(), Nektar::SolverUtils::DriverPFASST::ComputeCoarseInitialGuess(), Nektar::SolverUtils::DriverPFASST::ComputeFineInitialGuess(), Nektar::SolverUtils::DriverPFASST::FineIntegratedResidualEval(), Nektar::SolverUtils::DriverPFASST::FineResidualEval(), Nektar::SolverUtils::DriverPFASST::RunCoarseSweep(), Nektar::SolverUtils::DriverPFASST::RunFineSweep(), Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_coarseEqSys

std::shared_ptr<SolverUtils::UnsteadySystem> Nektar::SolverUtils::DriverParallelInTime::m_coarseEqSys
protected

Definition at line 210 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), CopyFromCoarsePhysField(), CopyToCoarsePhysField(), InitialiseEqSystem(), InitialiseInterpolationField(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), PrintCoarseSolverInfo(), Nektar::SolverUtils::DriverParareal::RunCoarseSolve(), Nektar::SolverUtils::DriverPFASST::SetTime(), Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), and v_InitObject().

◆ m_coarseFields

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::DriverParallelInTime::m_coarseFields
protected

Definition at line 217 of file DriverParallelInTime.h.

Referenced by InitialiseInterpolationField(), and Interpolator().

◆ m_coarseNpts

size_t Nektar::SolverUtils::DriverParallelInTime::m_coarseNpts
protected

Definition at line 207 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverPFASST::ComputeFASCorrection(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), Nektar::SolverUtils::DriverPFASST::v_EstimateCommunicationTime(), Nektar::SolverUtils::DriverParareal::v_EstimateInterpolationTime(), and Nektar::SolverUtils::DriverParareal::v_EstimateRestrictionTime().

◆ m_coarseQuadPts

size_t Nektar::SolverUtils::DriverParallelInTime::m_coarseQuadPts
protected

Definition at line 205 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverPFASST::ComputeFASCorrection(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverPFASST::Interpolate(), Nektar::SolverUtils::DriverPFASST::Restrict(), Nektar::SolverUtils::DriverPFASST::SaveCoarseResidual(), Nektar::SolverUtils::DriverPFASST::SaveCoarseSolution(), and Nektar::SolverUtils::DriverPFASST::SetTimeInterpolator().

◆ m_coarseSteps

size_t Nektar::SolverUtils::DriverParallelInTime::m_coarseSteps = 1
protected

Number of steps for the coarse solver.

Definition at line 183 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), GetParametersFromSession(), Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ m_coarseTimeStep

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_coarseTimeStep
protected

Timestep for coarse solver.

Definition at line 162 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), GetParametersFromSession(), and Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme().

◆ m_exactsoln

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverParallelInTime::m_exactsoln
protected

Definition at line 213 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), EvaluateExactSolution(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), UpdateErrorNorm(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ m_exactSolution

bool Nektar::SolverUtils::DriverParallelInTime::m_exactSolution = 0
protected

Using exact solution to compute error norms.

Definition at line 198 of file DriverParallelInTime.h.

Referenced by GetParametersFromSession(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ m_fineEqSys

std::shared_ptr<SolverUtils::UnsteadySystem> Nektar::SolverUtils::DriverParallelInTime::m_fineEqSys
protected

Definition at line 209 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), CopyFromFinePhysField(), CopyToFinePhysField(), EvaluateExactSolution(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), GetParametersFromSession(), InitialiseEqSystem(), InitialiseInterpolationField(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), PrintErrorNorm(), PrintFineSolverInfo(), Nektar::SolverUtils::DriverParareal::PrintSolutionFile(), Nektar::SolverUtils::DriverParareal::RunCoarseSolve(), Nektar::SolverUtils::DriverParareal::RunFineSolve(), Nektar::SolverUtils::DriverPFASST::SetTime(), UpdateErrorNorm(), UpdateSolution(), Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime(), v_InitObject(), and Nektar::SolverUtils::DriverPFASST::WriteOutput().

◆ m_fineFields

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::DriverParallelInTime::m_fineFields
protected

Definition at line 216 of file DriverParallelInTime.h.

Referenced by InitialiseInterpolationField(), and Interpolator().

◆ m_fineNpts

size_t Nektar::SolverUtils::DriverParallelInTime::m_fineNpts
protected

Definition at line 206 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverPFASST::Interpolate(), Nektar::SolverUtils::DriverPFASST::Restrict(), Nektar::SolverUtils::DriverParareal::v_EstimateCommunicationTime(), Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime(), Nektar::SolverUtils::DriverParareal::v_EstimateInterpolationTime(), Nektar::SolverUtils::DriverParareal::v_EstimateRestrictionTime(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ m_fineQuadPts

size_t Nektar::SolverUtils::DriverParallelInTime::m_fineQuadPts
protected

Definition at line 204 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::CorrectFineResidual(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverPFASST::Interpolate(), Nektar::SolverUtils::DriverPFASST::Restrict(), and Nektar::SolverUtils::DriverPFASST::SetTimeInterpolator().

◆ m_fineSteps

size_t Nektar::SolverUtils::DriverParallelInTime::m_fineSteps = 1
protected

Number of steps for the fine solver.

Definition at line 180 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), GetParametersFromSession(), Nektar::SolverUtils::DriverParareal::RunFineSolve(), Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime(), Nektar::SolverUtils::DriverParareal::v_Execute(), Nektar::SolverUtils::DriverPFASST::v_Execute(), and Nektar::SolverUtils::DriverPFASST::WriteOutput().

◆ m_fineTimeStep

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_fineTimeStep
protected

Timestep for fine solver.

Definition at line 159 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), GetParametersFromSession(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_infoSteps

size_t Nektar::SolverUtils::DriverParallelInTime::m_infoSteps = 0
protected

Number of steps for info I/O.

Definition at line 174 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), and GetParametersFromSession().

◆ m_iterMaxPIT

size_t Nektar::SolverUtils::DriverParallelInTime::m_iterMaxPIT = 0
protected

Maximum number of parallel-in-time iteration.

Definition at line 192 of file DriverParallelInTime.h.

Referenced by GetParametersFromSession(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_numChunks

size_t Nektar::SolverUtils::DriverParallelInTime::m_numChunks = 1
protected

Number of time chunks.

Definition at line 186 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::ApplyWindowing(), Nektar::SolverUtils::DriverPFASST::ApplyWindowing(), Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), EstimateCommunicationTime(), PrintComputationalTime(), PrintErrorNorm(), PrintHeaderTitle1(), PrintHeaderTitle2(), PrintSpeedUp(), Nektar::SolverUtils::DriverParareal::RunFineSolve(), SendSolutionToNextProc(), Nektar::SolverUtils::DriverParareal::v_ComputeSpeedUp(), Nektar::SolverUtils::DriverPFASST::v_ComputeSpeedUp(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_numWindowsPIT

size_t Nektar::SolverUtils::DriverParallelInTime::m_numWindowsPIT = 1
protected

Definition at line 195 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), GetParametersFromSession(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_nVar

size_t Nektar::SolverUtils::DriverParallelInTime::m_nVar
protected

Definition at line 208 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverPFASST::ApplyWindowing(), Nektar::SolverUtils::DriverPFASST::ComputeFASCorrection(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), InitialiseInterpolationField(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverPFASST::Interpolate(), Nektar::SolverUtils::DriverPFASST::Restrict(), Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), Nektar::SolverUtils::DriverParareal::v_EstimateCommunicationTime(), Nektar::SolverUtils::DriverPFASST::v_EstimateCommunicationTime(), Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime(), and Nektar::SolverUtils::DriverParareal::v_Execute().

◆ m_time

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_time
protected

Local time.

Definition at line 171 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime(), Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_tmpcoarse

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverParallelInTime::m_tmpcoarse
protected

Definition at line 215 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverParareal::RunCoarseSolve(), Nektar::SolverUtils::DriverParareal::v_EstimateInterpolationTime(), and Nektar::SolverUtils::DriverParareal::v_EstimateRestrictionTime().

◆ m_tmpfine

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverParallelInTime::m_tmpfine
protected

Definition at line 214 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), Nektar::SolverUtils::DriverParareal::v_EstimateInterpolationTime(), and Nektar::SolverUtils::DriverParareal::v_EstimateRestrictionTime().

◆ m_tolerPIT

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_tolerPIT = 1e-15
protected

ParallelInTime tolerance.

Definition at line 201 of file DriverParallelInTime.h.

Referenced by GetParametersFromSession(), Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_totalTime

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_totalTime
protected

Total time integration interval.

Definition at line 165 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::v_Execute(), and Nektar::SolverUtils::DriverPFASST::v_Execute().

◆ m_vL2Errors

Array<OneD, NekDouble> Nektar::SolverUtils::DriverParallelInTime::m_vL2Errors
protected

Definition at line 211 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), PrintErrorNorm(), UpdateErrorNorm(), and vL2ErrorMax().

◆ m_vLinfErrors

Array<OneD, NekDouble> Nektar::SolverUtils::DriverParallelInTime::m_vLinfErrors
protected

Definition at line 212 of file DriverParallelInTime.h.

Referenced by AllocateMemory(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), PrintErrorNorm(), and UpdateErrorNorm().

Generated on Wed Jan 31 2024 08:26:59 for Nektar++ by doxygen 1.9.4