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

#include <DriverParareal.h>

Inheritance diagram for Nektar::SolverUtils::DriverParareal:

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	DriverParareal (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
	Constructor. More...

virtual SOLVER_UTILS_EXPORT	~DriverParareal ()=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) override

virtual NekDouble	v_EstimateRestrictionTime (void) override

virtual NekDouble	v_EstimateInterpolationTime (void) override

virtual NekDouble	v_EstimateCoarseSolverTime (void) override

virtual NekDouble	v_EstimateFineSolverTime (void) override

virtual NekDouble	v_EstimatePredictorTime (void) override

virtual NekDouble	v_EstimateOverheadTime (void) override

virtual NekDouble	v_ComputeSpeedUp (const size_t iter, NekDouble fineSolveTime, NekDouble coarseSolveTime, NekDouble restTime, NekDouble interTime, NekDouble commTime, NekDouble predictorOverheadTime, NekDouble overheadTime) override

Protected Member Functions inherited from Nektar::SolverUtils::DriverParallelInTime
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...

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

Private Member Functions
void	AssertParameters (void)

void	RunCoarseSolve (const NekDouble time, const size_t nstep, const Array< OneD, const Array< OneD, NekDouble > > &input, Array< OneD, Array< OneD, NekDouble > > &output)

void	RunFineSolve (const NekDouble time, const size_t nstep, const size_t iter, const size_t wd, const Array< OneD, const Array< OneD, NekDouble > > &input, Array< OneD, Array< OneD, NekDouble > > &output)

void	PararealCorrection (const Array< OneD, const Array< OneD, NekDouble > > &coarse_new, const Array< OneD, const Array< OneD, NekDouble > > &coarse_old, Array< OneD, Array< OneD, NekDouble > > &fine)

void	PrintSolutionFile (void)

void	ApplyWindowing (const Array< OneD, const Array< OneD, NekDouble > > &in, Array< OneD, Array< OneD, NekDouble > > &out)

void	CopyConvergedCheckPoints (const size_t w, const size_t k, size_t kmax)

Friends
class	MemoryManager< DriverParareal >

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 ()

Protected Attributes inherited from Nektar::SolverUtils::DriverParallelInTime
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...

Detailed Description

Base class for the development of solvers.

Definition at line 46 of file DriverParareal.h.

Constructor & Destructor Documentation

◆ DriverParareal()

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

protected

Constructor.

Definition at line 54 of file DriverParareal.cpp.

    : DriverParallelInTime(pSession, pGraph)
{
}

◆ ~DriverParareal()

virtual SOLVER_UTILS_EXPORT Nektar::SolverUtils::DriverParareal::~DriverParareal ( )

protectedvirtualdefault

Destructor.

Member Function Documentation

◆ ApplyWindowing()

void Nektar::SolverUtils::DriverParareal::ApplyWindowing	(	const Array< OneD, const Array< OneD, NekDouble > > &	in,
		Array< OneD, Array< OneD, NekDouble > > &	out
	)

private

Definition at line 560 of file DriverParareal.cpp.

{
    LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
 
    // Use last chunk solution as initial condition for the next
    // window.
    if (m_chunkRank == m_numChunks - 1)
    {
        for (size_t i = 0; i < in.size(); ++i)
        {
            Vmath::Vcopy(in[i].size(), in[i], 1, out[i], 1);
        }
    }
 
    // Broadcast I.C. for windowing.
    for (size_t i = 0; i < out.size(); ++i)
    {
        tComm->Bcast(out[i], m_numChunks - 1);
    }
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkRank, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, Nektar::SolverUtils::Driver::m_session, and Vmath::Vcopy().

Referenced by v_Execute().

◆ AssertParameters()

void Nektar::SolverUtils::DriverParareal::AssertParameters ( void )

private

Definition at line 415 of file DriverParareal.cpp.

{
    // Assert time-stepping parameters
    ASSERTL0(
        m_fineSteps % m_numChunks == 0,
        "Total number of fine step should be divisible by number of chunks.");
 
    ASSERTL0(
        m_coarseSteps % m_numChunks == 0,
        "Total number of coarse step should be divisible by number of chunks.");
 
    ASSERTL0(m_fineSteps % (m_numChunks * m_numWindowsPIT) == 0,
             "Total number of fine step should be divisible by number of "
             "windows times number of chunks.");
 
    ASSERTL0(m_coarseSteps % (m_numChunks * m_numWindowsPIT) == 0,
             "Total number of coarse step should be divisible by number of "
             "windows times number of chunks.");
 
    ASSERTL0(fabs(m_coarseTimeStep * m_coarseSteps -
                  m_fineTimeStep * m_fineSteps) < 1e-12,
             "Fine and coarse total computational times do not match");
 
    // Assert I/O parameters
    if (m_infoSteps)
    {
        ASSERTL0(m_fineSteps % (m_infoSteps * m_numChunks * m_numWindowsPIT) ==
                     0,
                 "number of IO_InfoSteps should divide number of fine steps "
                 "per time chunk");
    }
 
    if (m_checkSteps)
    {
        ASSERTL0(m_fineSteps % (m_checkSteps * m_numChunks * m_numWindowsPIT) ==
                     0,
                 "number of IO_CheckSteps should divide number of fine steps "
                 "per time chunk");
    }
}

References ASSERTL0, Nektar::SolverUtils::DriverParallelInTime::m_checkSteps, Nektar::SolverUtils::DriverParallelInTime::m_coarseSteps, Nektar::SolverUtils::DriverParallelInTime::m_coarseTimeStep, Nektar::SolverUtils::DriverParallelInTime::m_fineSteps, Nektar::SolverUtils::DriverParallelInTime::m_fineTimeStep, Nektar::SolverUtils::DriverParallelInTime::m_infoSteps, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, and Nektar::SolverUtils::DriverParallelInTime::m_numWindowsPIT.

Referenced by v_Execute().

◆ CopyConvergedCheckPoints()

void Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints	(	const size_t	w,
		const size_t	k,
		size_t	kmax
	)

private

Output directory name.

Definition at line 586 of file DriverParareal.cpp.

{
    // Determine max number of iteration.
    LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
    tComm->AllReduce(kmax, Nektar::LibUtilities::ReduceMax);
 
    if (m_comm->GetSpaceComm()->GetRank() == 0 && m_checkSteps)
    {
        for (size_t j = k; j < kmax; j++)
        {
            // Copy converged solution files from directory corresponding to
            // iteration j to the directory corresponding to iteration j + 1.
 
            // Input directory name.
            std::string indir = m_fineEqSys->GetSessionName() + "_" +
                                boost::lexical_cast<std::string>(j) + ".pit";
 
            /// Output directory name.
            std::string outdir = m_fineEqSys->GetSessionName() + "_" +
                                 boost::lexical_cast<std::string>(j + 1) +
                                 ".pit";
 
            // Number of checkpoint by chunk.
            size_t nChkPts = m_fineSteps / m_checkSteps;
 
            // Checkpoint index.
            size_t iChkPts = (m_chunkRank + w * m_numChunks) * nChkPts + 1;
 
            for (size_t i = 0; i < nChkPts; i++)
            {
                // Filename corresponding to checkpoint iChkPts.
                std::string filename =
                    m_fineEqSys->GetSessionName() + "_" +
                    boost::lexical_cast<std::string>(iChkPts) + ".chk";
 
                // Intput full file name.
                std::string infullname = indir + "/" + filename;
 
                // Output full file name.
                std::string outfullname = outdir + "/" + filename;
 
                // Remove output file if already existing.
                fs::remove_all(outfullname);
 
                // Copy converged solution files.
                fs::copy(infullname, outfullname);
            }
        }
    }
}

References CellMLToNektar.pycml::copy(), Nektar::SolverUtils::DriverParallelInTime::m_checkSteps, Nektar::SolverUtils::DriverParallelInTime::m_chunkRank, Nektar::SolverUtils::Driver::m_comm, Nektar::SolverUtils::DriverParallelInTime::m_fineEqSys, Nektar::SolverUtils::DriverParallelInTime::m_fineSteps, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, Nektar::SolverUtils::Driver::m_session, Nektar::LibUtilities::ReduceMax, and Nektar::UnitTests::w().

Referenced by v_Execute().

◆ create()

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

inlinestatic

Creates an instance of this class.

Definition at line 52 of file DriverParareal.h.

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

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

◆ PararealCorrection()

void Nektar::SolverUtils::DriverParareal::PararealCorrection	(	const Array< OneD, const Array< OneD, NekDouble > > &	coarse_new,
		const Array< OneD, const Array< OneD, NekDouble > > &	coarse_old,
		Array< OneD, Array< OneD, NekDouble > > &	fine
	)

private

Definition at line 536 of file DriverParareal.cpp.

{
    for (size_t i = 0; i < fine.size(); ++i)
    {
        Vmath::Vadd(fine[i].size(), fine[i], 1, coarse_new[i], 1, fine[i], 1);
        Vmath::Vsub(fine[i].size(), fine[i], 1, coarse_old[i], 1, fine[i], 1);
    }
}

References Vmath::Vadd(), and Vmath::Vsub().

Referenced by v_Execute().

◆ PrintSolutionFile()

void Nektar::SolverUtils::DriverParareal::PrintSolutionFile ( void )

private

Definition at line 551 of file DriverParareal.cpp.

{
    PrintHeaderTitle2("PRINT SOLUTION FILES");
    m_fineEqSys->Output();
}

References Nektar::SolverUtils::DriverParallelInTime::m_fineEqSys, and Nektar::SolverUtils::DriverParallelInTime::PrintHeaderTitle2().

Referenced by v_Execute().

◆ RunCoarseSolve()

void Nektar::SolverUtils::DriverParareal::RunCoarseSolve	(	const NekDouble	time,
		const size_t	nstep,
		const Array< OneD, const Array< OneD, NekDouble > > &	input,
		Array< OneD, Array< OneD, NekDouble > > &	output
	)

private

Definition at line 459 of file DriverParareal.cpp.

{
    // Set to coarse timestep.
    m_coarseEqSys->SetTime(time);
    m_coarseEqSys->SetSteps(nstep);
 
    // Restrict initial condition from input.
    Interpolator(input, m_tmpcoarse);
 
    // Copy initial condition.
    for (size_t i = 0; i < m_fineEqSys->GetNvariables(); ++i)
    {
        m_coarseEqSys->CopyToPhysField(i, m_tmpcoarse[i]);
    }
 
    // Solve equations.
    m_coarseEqSys->DoSolve();
 
    // Copy solution.
    for (size_t i = 0; i < m_coarseEqSys->GetNvariables(); ++i)
    {
        m_coarseEqSys->CopyFromPhysField(i, m_tmpcoarse[i]);
    }
 
    // Interpolate solution to output.
    Interpolator(m_tmpcoarse, output);
}

References Nektar::SolverUtils::DriverParallelInTime::Interpolator(), Nektar::SolverUtils::DriverParallelInTime::m_coarseEqSys, Nektar::SolverUtils::DriverParallelInTime::m_fineEqSys, and Nektar::SolverUtils::DriverParallelInTime::m_tmpcoarse.

Referenced by v_Execute().

◆ RunFineSolve()

void Nektar::SolverUtils::DriverParareal::RunFineSolve	(	const NekDouble	time,
		const size_t	nstep,
		const size_t	iter,
		const size_t	wd,
		const Array< OneD, const Array< OneD, NekDouble > > &	input,
		Array< OneD, Array< OneD, NekDouble > > &	output
	)

private

Definition at line 493 of file DriverParareal.cpp.

{
    // Number of checkpoint by chunk.
    size_t nChkPts = m_checkSteps ? m_fineSteps / m_checkSteps : 1;
 
    // Checkpoint index.
    size_t iChkPts = (m_chunkRank + wd * m_numChunks) * nChkPts + 1;
 
    // Set to fine timestep.
    m_fineEqSys->SetTime(time);
    m_fineEqSys->SetSteps(nstep);
 
    // Reinitialize check point number for each parallel-in-time iteration.
    m_fineEqSys->SetCheckpointNumber(iChkPts);
 
    // Update parallel-in-time iteration number.
    m_fineEqSys->SetIterationNumberPIT(iter + 1);
 
    // Update parallel-in-time window number.
    m_fineEqSys->SetWindowNumberPIT(wd);
 
    // Copy initial condition from input.
    for (size_t i = 0; i < m_fineEqSys->GetNvariables(); ++i)
    {
        m_fineEqSys->CopyToPhysField(i, input[i]);
    }
 
    // Solve equations.
    m_fineEqSys->DoSolve();
 
    // Copy solution to output.
    for (size_t i = 0; i < m_fineEqSys->GetNvariables(); ++i)
    {
        m_fineEqSys->CopyFromPhysField(i, output[i]);
    }
}

References Nektar::SolverUtils::DriverParallelInTime::m_checkSteps, Nektar::SolverUtils::DriverParallelInTime::m_chunkRank, Nektar::SolverUtils::DriverParallelInTime::m_fineEqSys, Nektar::SolverUtils::DriverParallelInTime::m_fineSteps, and Nektar::SolverUtils::DriverParallelInTime::m_numChunks.

Referenced by v_EstimateFineSolverTime(), and v_Execute().

◆ v_ComputeSpeedUp()

NekDouble Nektar::SolverUtils::DriverParareal::v_ComputeSpeedUp	(	const size_t	iter,
		NekDouble	fineSolveTime,
		NekDouble	coarseSolveTime,
		NekDouble	restTime,
		NekDouble	interTime,
		NekDouble	commTime,
		NekDouble	predictorOverheadTime,
		NekDouble	overheadTime
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 390 of file DriverParareal.cpp.

{
    // The speed-up estimate is based on "Lunet, T., Bodart, J., Gratton, S., &
    // Vasseur, X. (2018). Time-parallel simulation of the decay of homogeneous
    // turbulence using parareal with spatial coarsening. Computing and
    // Visualization in Science, 19, 31-44".
 
    size_t nComm             = (iter * (2 * m_numChunks - iter - 1)) / 2;
    NekDouble ratio          = double(iter) / m_numChunks;
    NekDouble ratioPredictor = predictorTime / fineSolveTime;
    NekDouble ratioSolve     = coarseSolveTime / fineSolveTime;
    NekDouble ratioInterp    = (restTime + interTime) / fineSolveTime;
    NekDouble ratioComm      = commTime / fineSolveTime;
    NekDouble ratioOverhead  = overheadTime / fineSolveTime;
 
    return 1.0 / (ratioPredictor + ratio * (1.0 + ratioSolve + ratioInterp) +
                  (ratioComm * nComm + ratioOverhead) / m_numChunks);
}

References Nektar::SolverUtils::DriverParallelInTime::m_numChunks.

◆ v_EstimateCoarseSolverTime()

NekDouble Nektar::SolverUtils::DriverParareal::v_EstimateCoarseSolverTime ( void )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 301 of file DriverParareal.cpp.

{
    // Allocate memory.
    Array<OneD, Array<OneD, NekDouble>> sol(m_nVar);
    for (size_t i = 0; i < m_nVar; ++i)
    {
        sol[i] = Array<OneD, NekDouble>(m_coarseNpts);
    }
 
    // Turnoff I/O.
    m_coarseEqSys->SetInfoSteps(0);
    m_coarseEqSys->SetCheckpointSteps(0);
 
    // Get initial condition.
    CopyFromFinePhysField(sol);
 
    // Estimate coarse solver time.
    Nektar::LibUtilities::Timer timer;
    timer.Start();
 
    // Set to coarse timestep.
    m_coarseEqSys->SetTime(m_time + m_chunkTime);
    m_coarseEqSys->SetSteps(10);
 
    // Copy initial condition.
    for (size_t i = 0; i < m_fineEqSys->GetNvariables(); ++i)
    {
        m_coarseEqSys->CopyToPhysField(i, sol[i]);
    }
 
    // Solve equations.
    m_coarseEqSys->DoSolve();
 
    // Copy solution.
    for (size_t i = 0; i < m_coarseEqSys->GetNvariables(); ++i)
    {
        m_coarseEqSys->CopyFromPhysField(i, sol[i]);
    }
 
    timer.Stop();
    return 0.1 * timer.Elapsed().count() * m_coarseSteps;
}

Referenced by v_EstimatePredictorTime().

◆ v_EstimateCommunicationTime()

NekDouble Nektar::SolverUtils::DriverParareal::v_EstimateCommunicationTime ( void )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 235 of file DriverParareal.cpp.

{
    // Allocate memory.
    Array<OneD, Array<OneD, NekDouble>> buffer1(m_nVar);
    Array<OneD, Array<OneD, NekDouble>> buffer2(m_nVar);
    for (size_t i = 0; i < m_nVar; ++i)
    {
        buffer1[i] = Array<OneD, NekDouble>(m_fineNpts, 0.0);
        buffer2[i] = Array<OneD, NekDouble>(m_fineNpts, 0.0);
    }
 
    // Estimate communication time.
    return EstimateCommunicationTime(buffer1, buffer2);
}

References Nektar::SolverUtils::DriverParallelInTime::EstimateCommunicationTime(), Nektar::SolverUtils::DriverParallelInTime::m_fineNpts, and Nektar::SolverUtils::DriverParallelInTime::m_nVar.

◆ v_EstimateFineSolverTime()

NekDouble Nektar::SolverUtils::DriverParareal::v_EstimateFineSolverTime ( void )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 347 of file DriverParareal.cpp.

{
    // Allocate memory.
    Array<OneD, Array<OneD, NekDouble>> sol(m_nVar);
    for (size_t i = 0; i < m_nVar; ++i)
    {
        sol[i] = Array<OneD, NekDouble>(m_fineNpts);
    }
 
    // Turnoff I/O.
    m_fineEqSys->SetInfoSteps(0);
    m_fineEqSys->SetCheckpointSteps(0);
 
    // Get initial condition.
    CopyFromFinePhysField(sol);
 
    // Estimate fine solver time.
    Nektar::LibUtilities::Timer timer;
    timer.Start();
    RunFineSolve(m_time + m_chunkTime, 100, 0, 0, sol, sol);
    timer.Stop();
    return 0.01 * timer.Elapsed().count() * m_fineSteps;
}

References Nektar::SolverUtils::DriverParallelInTime::CopyFromFinePhysField(), Nektar::LibUtilities::Timer::Elapsed(), Nektar::SolverUtils::DriverParallelInTime::m_chunkTime, Nektar::SolverUtils::DriverParallelInTime::m_fineEqSys, Nektar::SolverUtils::DriverParallelInTime::m_fineNpts, Nektar::SolverUtils::DriverParallelInTime::m_fineSteps, Nektar::SolverUtils::DriverParallelInTime::m_nVar, Nektar::SolverUtils::DriverParallelInTime::m_time, RunFineSolve(), Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

◆ v_EstimateInterpolationTime()

NekDouble Nektar::SolverUtils::DriverParareal::v_EstimateInterpolationTime ( void )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 277 of file DriverParareal.cpp.

{
    if (m_fineNpts == m_coarseNpts)
    {
        return 0.0; // No interpolation
    }
    else
    {
        // Average interpolation time over niter iteration.
        size_t niter = 20;
        Nektar::LibUtilities::Timer timer;
        timer.Start();
        for (size_t n = 0; n < niter; n++)
        {
            Interpolator(m_tmpcoarse, m_tmpfine);
        }
        timer.Stop();
        return timer.Elapsed().count() / niter;
    }
}

References Nektar::LibUtilities::Timer::Elapsed(), Nektar::SolverUtils::DriverParallelInTime::Interpolator(), Nektar::SolverUtils::DriverParallelInTime::m_coarseNpts, Nektar::SolverUtils::DriverParallelInTime::m_fineNpts, Nektar::SolverUtils::DriverParallelInTime::m_tmpcoarse, Nektar::SolverUtils::DriverParallelInTime::m_tmpfine, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

◆ v_EstimateOverheadTime()

NekDouble Nektar::SolverUtils::DriverParareal::v_EstimateOverheadTime ( void )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 382 of file DriverParareal.cpp.

{
    return 0.0;
}

◆ v_EstimatePredictorTime()

NekDouble Nektar::SolverUtils::DriverParareal::v_EstimatePredictorTime ( void )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 374 of file DriverParareal.cpp.

{
    return v_EstimateCoarseSolverTime();
}

References v_EstimateCoarseSolverTime().

◆ v_EstimateRestrictionTime()

NekDouble Nektar::SolverUtils::DriverParareal::v_EstimateRestrictionTime ( void )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 253 of file DriverParareal.cpp.

{
    if (m_fineNpts == m_coarseNpts)
    {
        return 0.0; // No restriction necessary
    }
    else
    {
        // Average restriction time over niter iteration.
        size_t niter = 20;
        Nektar::LibUtilities::Timer timer;
        timer.Start();
        for (size_t n = 0; n < niter; n++)
        {
            Interpolator(m_tmpfine, m_tmpcoarse);
        }
        timer.Stop();
        return timer.Elapsed().count() / niter;
    }
}

References Nektar::LibUtilities::Timer::Elapsed(), Nektar::SolverUtils::DriverParallelInTime::Interpolator(), Nektar::SolverUtils::DriverParallelInTime::m_coarseNpts, Nektar::SolverUtils::DriverParallelInTime::m_fineNpts, Nektar::SolverUtils::DriverParallelInTime::m_tmpcoarse, Nektar::SolverUtils::DriverParallelInTime::m_tmpfine, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

◆ v_Execute()

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

overrideprotectedvirtual

Virtual function for solve implementation.

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 72 of file DriverParareal.cpp.

{
    // Set timer.
    Nektar::LibUtilities::Timer timer;
    NekDouble CPUtime = 0.0;
 
    // Set time communication parameters.
    LibUtilities::CommSharedPtr tComm = m_session->GetComm()->GetTimeComm();
    m_numChunks                       = tComm->GetSize();
    m_chunkRank                       = tComm->GetRank();
 
    // Get and assert parameters from session file.
    GetParametersFromSession();
    AssertParameters();
 
    // Print solver info.
    PrintFineSolverInfo(out);
    PrintCoarseSolverInfo(out);
 
    // Initialization.
    InitialiseEqSystem(false);
    AllocateMemory();
    InitialiseInterpolationField();
 
    // Allocate storage for Parareal solver.
    Array<OneD, Array<OneD, NekDouble>> solutionCoarseCurr(m_nVar);
    Array<OneD, Array<OneD, NekDouble>> solutionCoarsePrev(m_nVar);
    Array<OneD, Array<OneD, NekDouble>> ic(m_nVar);
    Array<OneD, Array<OneD, NekDouble>> solution(m_nVar);
    for (size_t i = 0; i < m_nVar; ++i)
    {
        solutionCoarseCurr[i] = Array<OneD, NekDouble>(m_fineNpts, 0.0);
        solutionCoarsePrev[i] = Array<OneD, NekDouble>(m_fineNpts, 0.0);
        ic[i]                 = Array<OneD, NekDouble>(m_fineNpts, 0.0);
        solution[i]           = Array<OneD, NekDouble>(m_fineNpts, 0.0);
    }
 
    // Get initial condition from fields.
    CopyFromFinePhysField(ic);
 
    // Start iteration windows.
    tComm->Block();
    m_totalTime = m_fineTimeStep * m_fineSteps;
    m_chunkTime = m_totalTime / m_numChunks / m_numWindowsPIT;
    m_fineSteps /= m_numChunks * m_numWindowsPIT;
    m_coarseSteps /= m_numChunks * m_numWindowsPIT;
    for (size_t w = 0; w < m_numWindowsPIT; w++)
    {
        timer.Start();
 
        // Initialize time for the current window.
        m_time = (w * m_numChunks) * m_chunkTime;
 
        // Print window number.
        PrintHeaderTitle1((boost::format("WINDOWS #%1%") % (w + 1)).str());
 
        // Run coarse solver.
        if (m_chunkRank > 0)
        {
            RunCoarseSolve(m_time, m_chunkRank * m_coarseSteps, ic, ic);
            m_time += m_chunkRank * m_chunkTime;
        }
        RunCoarseSolve(m_time, m_coarseSteps, ic, solutionCoarsePrev);
        CopySolutionVector(solutionCoarsePrev, solution);
 
        // Update fields with solution.
        CopyToFinePhysField(solution);
 
        // Compute exact solution, if necessary.
        if (m_exactSolution)
        {
            EvaluateExactSolution(m_time + m_chunkTime);
        }
 
        // Solution convergence monitoring.
        timer.Stop();
        CPUtime += timer.Elapsed().count();
        PrintHeaderTitle2((boost::format("ITERATION %1%") % 0).str());
        SolutionConvergenceMonitoring(CPUtime);
        timer.Start();
 
        // Start Parareal iteration.
        size_t k            = 0;
        size_t kmax         = 0;
        int convergenceCurr = false;
        int convergencePrev = (m_chunkRank == 0);
        while (k < m_iterMaxPIT && !convergenceCurr)
        {
            // Use previous parareal solution as "exact solution", if necessary.
            if (!m_exactSolution)
            {
                CopySolutionVector(solution, m_exactsoln);
            }
 
            // Calculate fine solution (parallel-in-time).
            RunFineSolve(m_time, m_fineSteps, k, w, ic, solution);
 
            // Receive coarse solution from previous processor.
            RecvInitialConditionFromPreviousProc(ic, convergencePrev);
 
            // Calculate coarse solution (serial-in-time).
            RunCoarseSolve(m_time, m_coarseSteps, ic, solutionCoarseCurr);
 
            // Calculate corrected solution.
            PararealCorrection(solutionCoarseCurr, solutionCoarsePrev,
                               solution);
 
            // Save current coarse solution.
            CopySolutionVector(solutionCoarseCurr, solutionCoarsePrev);
 
            // Update fields with corrected solution.
            CopyToFinePhysField(solution);
 
            // Solution convergence monitoring.
            timer.Stop();
            CPUtime += timer.Elapsed().count();
            PrintHeaderTitle2((boost::format("ITERATION %1%") % (k + 1)).str());
            SolutionConvergenceMonitoring(CPUtime);
            timer.Start();
 
            // Check convergence of L2 error for each time chunk.
            if ((vL2ErrorMax() < m_tolerPIT && convergencePrev) ||
                m_chunkRank == k)
            {
                convergenceCurr = true;
            }
 
            // Send coarse solution to next processor.
            SendSolutionToNextProc(solution, convergenceCurr);
 
            // Increment index.
            k++;
            kmax = k;
        }
        timer.Stop();
 
        // Copy converged check points.
        CopyConvergedCheckPoints(w, k, kmax);
 
        // Update solution before printing solution.
        UpdateSolution(solution);
 
        // Print solution files.
        PrintSolutionFile();
 
        // Windowing.
        if (w != m_numWindowsPIT - 1)
        {
            ApplyWindowing(solution, ic);
        }
    }
 
    // Post-processing.
    tComm->Block();
    PrintHeaderTitle1("SUMMARY");
    EvaluateExactSolution(m_time + m_chunkTime);
    SolutionConvergenceSummary(CPUtime);
    SpeedUpAnalysis();
}

◆ v_InitObject()

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

overrideprotectedvirtual

Virtual function for initialisation implementation.

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 64 of file DriverParareal.cpp.

{
    DriverParallelInTime::v_InitObject(out);
}

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

Friends And Related Function Documentation

◆ MemoryManager< DriverParareal >

friend class MemoryManager< DriverParareal >

friend

Definition at line 1 of file DriverParareal.h.

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::DriverParareal::className

static

Initial value:

=
    GetDriverFactory().RegisterCreatorFunction("Parareal",
                                               DriverParareal::create)

Name of the class.

Definition at line 63 of file DriverParareal.h.

◆ driverLookupId

std::string Nektar::SolverUtils::DriverParareal::driverLookupId

staticprotected

Initial value:

=

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

Nektar::LibUtilities::SessionReader::RegisterEnumValue

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

Registers an enumeration value.

Definition: SessionReader.h:583

Definition at line 101 of file DriverParareal.h.

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DriverParareal()

◆ ~DriverParareal()

Member Function Documentation

◆ ApplyWindowing()

◆ AssertParameters()

◆ CopyConvergedCheckPoints()

◆ create()

◆ PararealCorrection()

◆ PrintSolutionFile()

◆ RunCoarseSolve()

◆ RunFineSolve()

◆ v_ComputeSpeedUp()

◆ v_EstimateCoarseSolverTime()

◆ v_EstimateCommunicationTime()

◆ v_EstimateFineSolverTime()

◆ v_EstimateInterpolationTime()

◆ v_EstimateOverheadTime()

◆ v_EstimatePredictorTime()

◆ v_EstimateRestrictionTime()

◆ v_Execute()

◆ v_InitObject()

Friends And Related Function Documentation

◆ MemoryManager< DriverParareal >

Member Data Documentation

◆ className

◆ driverLookupId