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.

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

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

SOLVER_UTILS_EXPORT	~DriverParareal () override=default
	Destructor.

SOLVER_UTILS_EXPORT void	v_InitObject (std::ostream &out=std::cout) override
	Virtual function for initialisation implementation.

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

Protected Member Functions inherited from Nektar::SolverUtils::DriverParallelInTime
SOLVER_UTILS_EXPORT	DriverParallelInTime (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
	Constructor.

SOLVER_UTILS_EXPORT	~DriverParallelInTime () override=default
	Destructor.

void	SetParallelInTimeEquationSystem (std::string AdvectiveType)

void	GetParametersFromSession (void)

void	InitialiseEqSystem (bool turnoff_output)

void	InitialiseInterpolationField (void)

void	PrintSolverInfo (std::ostream &out=std::cout)

void	PrintHeader (const std::string &title, const char c)

void	RecvFromPreviousProc (Array< OneD, Array< OneD, NekDouble > > &array, int &convergence)

void	RecvFromPreviousProc (Array< OneD, NekDouble > &array)

void	SendToNextProc (Array< OneD, Array< OneD, NekDouble > > &array, int &convergence)

void	SendToNextProc (Array< OneD, NekDouble > &array)

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

void	CopyFromPhysField (const size_t timeLevel, Array< OneD, Array< OneD, NekDouble > > &out)

void	CopyToPhysField (const size_t timeLevel, const Array< OneD, const Array< OneD, NekDouble > > &in)

void	UpdateFieldCoeffs (const size_t timeLevel, const Array< OneD, const Array< OneD, NekDouble > > &in=NullNekDoubleArrayOfArray)

void	EvaluateExactSolution (const size_t timeLevel, const NekDouble &time)

void	SolutionConvergenceMonitoring (const size_t timeLevel, const size_t iter)

void	SolutionConvergenceSummary (const size_t timeLevel)

void	UpdateErrorNorm (const size_t timeLevel, const bool normalized)

void	PrintErrorNorm (const size_t timeLevel, const bool normalized)

NekDouble	vL2ErrorMax (void)

NekDouble	EstimateCommunicationTime (Array< OneD, Array< OneD, NekDouble > > &buffer1, Array< OneD, Array< OneD, NekDouble > > &buffer2)

void	Interpolate (const Array< OneD, MultiRegions::ExpListSharedPtr > &infield, const Array< OneD, MultiRegions::ExpListSharedPtr > &outfield, const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)

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

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

void	AssertParameters (void)

void	UpdateInitialConditionFromSolver (const size_t timeLevel)

void	UpdateSolverInitialCondition (const size_t timeLevel)

void	UpdateSolution (const size_t timeLevel, const NekDouble time, const size_t nstep, const size_t wd, const size_t iter)

void	CorrectionWithOldCoarseSolution (void)

void	CorrectionWithNewCoarseSolution (void)

void	InterpolateCoarseSolution (void)

void	ApplyWindowing (const size_t w)

void	CopyConvergedCheckPoints (const size_t w, const size_t k)

void	WriteTimeChunkOuput (void)

Private Attributes
Array< OneD, Array< OneD, NekDouble > >	m_initialCondition

Array< OneD, Array< OneD, NekDouble > >	m_fineSolution

Array< OneD, Array< OneD, NekDouble > >	m_coarseSolution

Static Private Attributes
static constexpr size_t	m_fineLevel = 0

static constexpr size_t	m_coarseLevel = 1

Friends
class	MemoryManager< DriverParareal >

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

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

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

SOLVER_UTILS_EXPORT Array< OneD, EquationSystemSharedPtr >	GetEqu ()

Protected Attributes inherited from Nektar::SolverUtils::DriverParallelInTime
NekDouble	m_totalTime
	Total time integration interval.

NekDouble	m_chunkTime
	Time integration interval per chunk.

NekDouble	m_time
	Local time.

NekDouble	m_time0

size_t	m_numChunks
	Number of time chunks.

size_t	m_chunkRank
	Rank in time.

size_t	m_iterMaxPIT
	Maximum number of parallel-in-time iteration.

size_t	m_numWindowsPIT

bool	m_exactSolution
	Using exact solution to compute error norms.

NekDouble	m_tolerPIT
	ParallelInTime tolerance.

size_t	m_nVar
	Number of variables.

size_t	m_nTimeLevel
	Number of time levels.

Array< OneD, size_t >	m_nsteps
	Number of time steps for each time level.

Array< OneD, NekDouble >	m_timestep
	Time step for each time level.

Array< OneD, size_t >	m_npts
	Number of dof for each time level.

Array< OneD, std::shared_ptr< UnsteadySystem > >	m_EqSys
	Equation system to solve.

Array< OneD, NekDouble >	m_vL2Errors
	Storage for parallel-in-time iteration.

Array< OneD, NekDouble >	m_vLinfErrors

Array< OneD, Array< OneD, NekDouble > >	m_exactsoln

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

LibUtilities::SessionReaderSharedPtr	m_session
	Session reader object.

LibUtilities::SessionReaderSharedPtr	session_LinNS
	Coupling between SFD and arnoldi.

SpatialDomains::MeshGraphSharedPtr	m_graph
	MeshGraph object.

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

int	m_nequ
	number of equations

enum EvolutionOperatorType	m_EvolutionOperator
	Evolution Operator.

Detailed Description

Base class for the development of solvers.

Definition at line 44 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 52 of file DriverParareal.cpp.

    : DriverParallelInTime(pSession, pGraph)
{
}

◆ ~DriverParareal()

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

overrideprotecteddefault

Destructor.

Member Function Documentation

◆ AllocateMemory()

void Nektar::SolverUtils::DriverParareal::AllocateMemory ( void )

private

Definition at line 279 of file DriverParareal.cpp.

{
    // Allocate storage for Parareal solver.
    m_initialCondition = Array<OneD, Array<OneD, NekDouble>>(m_nVar);
    m_fineSolution     = Array<OneD, Array<OneD, NekDouble>>(m_nVar);
    m_coarseSolution   = Array<OneD, Array<OneD, NekDouble>>(m_nVar);
    for (size_t i = 0; i < m_nVar; ++i)
    {
        m_initialCondition[i] =
            Array<OneD, NekDouble>(m_npts[m_fineLevel], 0.0);
        m_fineSolution[i] = m_EqSys[m_fineLevel]->UpdatePhysField(i);
        m_coarseSolution[i] =
            (m_npts[m_fineLevel] == m_npts[m_coarseLevel])
                ? m_EqSys[m_coarseLevel]->UpdatePhysField(i)
                : Array<OneD, NekDouble>(m_npts[m_fineLevel], 0.0);
    }
}

References m_coarseLevel, m_coarseSolution, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, m_fineSolution, m_initialCondition, Nektar::SolverUtils::DriverParallelInTime::m_npts, and Nektar::SolverUtils::DriverParallelInTime::m_nVar.

Referenced by v_InitObject().

◆ ApplyWindowing()

void Nektar::SolverUtils::DriverParareal::ApplyWindowing ( const size_t w )

private

Definition at line 475 of file DriverParareal.cpp.

{
    if (w == m_numWindowsPIT - 1)
    {
        // No windowing required for the last window.
        return;
    }
 
    // Use last chunk solution as initial condition for the next
    // window.
    if (m_chunkRank == m_numChunks - 1)
    {
        for (size_t i = 0; i < m_nVar; ++i)
        {
            Vmath::Vcopy(m_npts[m_fineLevel],
                         m_EqSys[m_fineLevel]->UpdatePhysField(i), 1,
                         m_initialCondition[i], 1);
        }
    }
 
    // Broadcast I.C. for windowing.
    for (size_t i = 0; i < m_nVar; ++i)
    {
        m_comm->GetTimeComm()->Bcast(m_initialCondition[i], m_numChunks - 1);
    }
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkRank, Nektar::SolverUtils::Driver::m_comm, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, m_initialCondition, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, Nektar::SolverUtils::DriverParallelInTime::m_numWindowsPIT, Nektar::SolverUtils::DriverParallelInTime::m_nVar, and Vmath::Vcopy().

Referenced by v_Execute().

◆ AssertParameters()

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

private

Definition at line 300 of file DriverParareal.cpp.

{
    // Assert time-stepping parameters
    ASSERTL0(
        m_nsteps[m_fineLevel] % m_numChunks == 0,
        "Total number of fine step should be divisible by number of chunks.");
 
    ASSERTL0(
        m_nsteps[m_coarseLevel] % m_numChunks == 0,
        "Total number of coarse step should be divisible by number of chunks.");
 
    ASSERTL0(m_nsteps[m_fineLevel] % (m_numChunks * m_numWindowsPIT) == 0,
             "Total number of fine step should be divisible by number of "
             "windows times number of chunks.");
 
    ASSERTL0(m_nsteps[m_coarseLevel] % (m_numChunks * m_numWindowsPIT) == 0,
             "Total number of coarse step should be divisible by number of "
             "windows times number of chunks.");
 
    ASSERTL0(fabs(m_timestep[m_coarseLevel] * m_nsteps[m_coarseLevel] -
                  m_timestep[m_fineLevel] * m_nsteps[m_fineLevel]) < 1e-12,
             "Fine and coarse total computational times do not match");
 
    ASSERTL0(m_EqSys[m_fineLevel]
                     ->GetTimeIntegrationScheme()
                     ->GetNumIntegrationPhases() == 1,
             "Only single step time-integration schemes currently supported "
             "for Parareal");
 
    ASSERTL0(m_EqSys[m_coarseLevel]
                     ->GetTimeIntegrationScheme()
                     ->GetNumIntegrationPhases() == 1,
             "Only single step time-integration schemes currently supported "
             "for Parareal");
 
    // Assert I/O parameters
    if (m_EqSys[m_fineLevel]->GetInfoSteps())
    {
        ASSERTL0(m_nsteps[m_fineLevel] % (m_EqSys[m_fineLevel]->GetInfoSteps() *
                                          m_numChunks * m_numWindowsPIT) ==
                     0,
                 "number of IO_InfoSteps should divide number of fine steps "
                 "per time chunk");
    }
 
    if (m_EqSys[m_coarseLevel]->GetInfoSteps())
    {
        ASSERTL0(m_nsteps[m_coarseLevel] %
                         (m_EqSys[m_coarseLevel]->GetInfoSteps() * m_numChunks *
                          m_numWindowsPIT) ==
                     0,
                 "number of IO_InfoSteps should divide number of coarse steps "
                 "per time chunk");
    }
 
    if (m_EqSys[m_fineLevel]->GetCheckpointSteps())
    {
        ASSERTL0(m_nsteps[m_fineLevel] %
                         (m_EqSys[m_fineLevel]->GetCheckpointSteps() *
                          m_numChunks * m_numWindowsPIT) ==
                     0,
                 "number of IO_CheckSteps should divide number of fine steps "
                 "per time chunk");
    }
 
    if (m_EqSys[m_coarseLevel]->GetCheckpointSteps())
    {
        ASSERTL0(m_nsteps[m_coarseLevel] %
                         (m_EqSys[m_coarseLevel]->GetCheckpointSteps() *
                          m_numChunks * m_numWindowsPIT) ==
                     0,
                 "number of IO_CheckSteps should divide number of coarse steps "
                 "per time chunk");
    }
}

References ASSERTL0, m_coarseLevel, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, Nektar::SolverUtils::DriverParallelInTime::m_nsteps, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, Nektar::SolverUtils::DriverParallelInTime::m_numWindowsPIT, and Nektar::SolverUtils::DriverParallelInTime::m_timestep.

Referenced by v_Execute().

◆ CopyConvergedCheckPoints()

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

private

Output directory name.

Definition at line 505 of file DriverParareal.cpp.

{
    // Determine max number of iteration.
    size_t kmax = k;
    m_comm->GetTimeComm()->AllReduce(kmax, Nektar::LibUtilities::ReduceMax);
 
    if (m_comm->GetSpaceComm()->GetRank() == 0)
    {
        for (size_t j = k; j < kmax; j++)
        {
            // Copy converged solution files from directory corresponding to
            // iteration j - 1 to the directory corresponding to iteration j.
 
            auto sessionName = m_EqSys[m_fineLevel]->GetSessionName();
 
            // Input directory name.
            std::string indir =
                sessionName + "_" + std::to_string(j - 1) + ".pit";
 
            /// Output directory name.
            std::string outdir = sessionName + "_" + std::to_string(j) + ".pit";
 
            for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
            {
                // Number of checkpoint by chunk.
                size_t nChkPts =
                    m_EqSys[timeLevel]->GetCheckpointSteps()
                        ? m_nsteps[timeLevel] /
                              m_EqSys[timeLevel]->GetCheckpointSteps()
                        : 0;
 
                // Checkpoint index.
                size_t iChkPts = (m_chunkRank + w * m_numChunks) * nChkPts;
 
                for (size_t i = 1; i <= nChkPts; i++)
                {
                    // Filename corresponding to checkpoint iChkPts.
                    std::string filename = sessionName + "_timeLevel" +
                                           std::to_string(timeLevel) + "_" +
                                           std::to_string(iChkPts + i) + ".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 Nektar::SolverUtils::DriverParallelInTime::m_chunkRank, Nektar::SolverUtils::Driver::m_comm, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, Nektar::SolverUtils::DriverParallelInTime::m_nsteps, Nektar::SolverUtils::DriverParallelInTime::m_nTimeLevel, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, and Nektar::LibUtilities::ReduceMax.

Referenced by v_Execute().

◆ CorrectionWithNewCoarseSolution()

void Nektar::SolverUtils::DriverParareal::CorrectionWithNewCoarseSolution ( void )

private

Definition at line 445 of file DriverParareal.cpp.

{
    // Interpolate coarse solution.
    InterpolateCoarseSolution();
 
    // Correct solution F -> F + Gnew.
    for (size_t i = 0; i < m_nVar; ++i)
    {
        Vmath::Vadd(m_npts[m_fineLevel], m_fineSolution[i], 1,
                    m_coarseSolution[i], 1, m_fineSolution[i], 1);
    }
}

References InterpolateCoarseSolution(), m_coarseSolution, m_fineLevel, m_fineSolution, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, and Vmath::Vadd().

Referenced by v_Execute().

◆ CorrectionWithOldCoarseSolution()

void Nektar::SolverUtils::DriverParareal::CorrectionWithOldCoarseSolution ( void )

private

Definition at line 432 of file DriverParareal.cpp.

{
    // Correct solution F -> F - Gold.
    for (size_t i = 0; i < m_nVar; ++i)
    {
        Vmath::Vsub(m_npts[m_fineLevel], m_fineSolution[i], 1,
                    m_coarseSolution[i], 1, m_fineSolution[i], 1);
    }
}

References m_coarseSolution, m_fineLevel, m_fineSolution, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, and Vmath::Vsub().

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 50 of file DriverParareal.h.

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

◆ InterpolateCoarseSolution()

void Nektar::SolverUtils::DriverParareal::InterpolateCoarseSolution ( void )

private

Definition at line 461 of file DriverParareal.cpp.

{
    if (m_npts[m_fineLevel] != m_npts[m_coarseLevel])
    {
        // Interpolate coarse solution to fine field.
        Interpolate(m_EqSys[m_coarseLevel]->UpdateFields(),
                    m_EqSys[m_fineLevel]->UpdateFields(),
                    NullNekDoubleArrayOfArray, m_coarseSolution);
    }
}

References Nektar::SolverUtils::DriverParallelInTime::Interpolate(), m_coarseLevel, m_coarseSolution, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, Nektar::SolverUtils::DriverParallelInTime::m_npts, and Nektar::NullNekDoubleArrayOfArray.

Referenced by CorrectionWithNewCoarseSolution(), and v_Execute().

◆ UpdateInitialConditionFromSolver()

void Nektar::SolverUtils::DriverParareal::UpdateInitialConditionFromSolver ( const size_t timeLevel )

private

Definition at line 379 of file DriverParareal.cpp.

{
    // Interpolate solution to fine field.
    Interpolate(m_EqSys[timeLevel]->UpdateFields(),
                m_EqSys[m_fineLevel]->UpdateFields(), NullNekDoubleArrayOfArray,
                m_initialCondition);
}

References Nektar::SolverUtils::DriverParallelInTime::Interpolate(), Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, m_initialCondition, and Nektar::NullNekDoubleArrayOfArray.

Referenced by v_Execute().

◆ UpdateSolution()

void Nektar::SolverUtils::DriverParareal::UpdateSolution	(	const size_t	timeLevel,
		const NekDouble	time,
		const size_t	nstep,
		const size_t	wd,
		const size_t	iter
	)

private

Definition at line 401 of file DriverParareal.cpp.

{
    // Number of checkpoint by chunk.
    size_t nChkPts =
        m_EqSys[timeLevel]->GetCheckpointSteps()
            ? m_nsteps[timeLevel] / m_EqSys[timeLevel]->GetCheckpointSteps()
            : 1;
 
    // Checkpoint index.
    size_t iChkPts = (m_chunkRank + wd * m_numChunks) * nChkPts + 1;
 
    // Reinitialize check point number for each parallel-in-time
    // iteration.
    m_EqSys[timeLevel]->SetCheckpointNumber(iChkPts);
 
    // Update parallel-in-time iteration number.
    m_EqSys[timeLevel]->SetIterationNumberPIT(iter);
 
    // Update parallel-in-time window number.
    m_EqSys[timeLevel]->SetWindowNumberPIT(wd);
 
    m_EqSys[timeLevel]->SetTime(time);
    m_EqSys[timeLevel]->SetSteps(nstep);
    m_EqSys[timeLevel]->DoSolve();
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkRank, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, Nektar::SolverUtils::DriverParallelInTime::m_nsteps, and Nektar::SolverUtils::DriverParallelInTime::m_numChunks.

Referenced by v_Execute().

◆ UpdateSolverInitialCondition()

void Nektar::SolverUtils::DriverParareal::UpdateSolverInitialCondition ( const size_t timeLevel )

private

Definition at line 390 of file DriverParareal.cpp.

{
    // Restrict fine field to coarse solution.
    Interpolate(m_EqSys[m_fineLevel]->UpdateFields(),
                m_EqSys[timeLevel]->UpdateFields(), m_initialCondition,
                NullNekDoubleArrayOfArray);
}

References Nektar::SolverUtils::DriverParallelInTime::Interpolate(), Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, m_initialCondition, and Nektar::NullNekDoubleArrayOfArray.

Referenced by v_Execute().

◆ 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 74 of file DriverParareal.cpp.

{
    // Timing.
    Nektar::LibUtilities::Timer timer;
    NekDouble totalTime = 0.0, predictorTime = 0.0, coarseSolveTime = 0.0,
              fineSolveTime = 0.0, correctionTime = 0.0;
 
    // Get and assert parameters from session file.
    AssertParameters();
 
    // Initialie time step parameters.
    m_totalTime = m_timestep[m_fineLevel] * m_nsteps[m_fineLevel];
    m_chunkTime = m_totalTime / m_numChunks / m_numWindowsPIT;
    m_nsteps[m_fineLevel] /= m_numChunks * m_numWindowsPIT;
    m_nsteps[m_coarseLevel] /= m_numChunks * m_numWindowsPIT;
 
    // Pre-solve for one time-step to initialize preconditioner.
    UpdateSolution(m_coarseLevel, m_time0, 1, 0, 0);
 
    // Start iteration windows.
    m_comm->GetTimeComm()->Block();
    UpdateInitialConditionFromSolver(m_fineLevel);
    for (size_t w = 0; w < m_numWindowsPIT; w++)
    {
        timer.Start();
        // Initialize time for the current window.
        m_time = m_time0 + (w * m_numChunks) * m_chunkTime +
                 m_chunkRank * m_chunkTime;
 
        // Print window number.
        PrintHeader((boost::format("WINDOWS #%1%") % (w + 1)).str(), '*');
 
        // Update coarse initial condition.
        UpdateSolverInitialCondition(m_coarseLevel);
 
        // Run predictor.
        for (size_t i = 0; i < m_nVar; ++i)
        {
            RecvFromPreviousProc(m_EqSys[m_coarseLevel]->UpdatePhysField(i));
        }
        if (m_chunkRank > 0)
        {
            UpdateInitialConditionFromSolver(m_coarseLevel);
        }
        UpdateSolution(m_coarseLevel, m_time, m_nsteps[m_coarseLevel], w, 0);
        for (size_t i = 0; i < m_nVar; ++i)
        {
            SendToNextProc(m_EqSys[m_coarseLevel]->UpdatePhysField(i));
        }
 
        // Interpolate coarse solution.
        InterpolateCoarseSolution();
 
        // Compute exact solution, if necessary.
        if (m_exactSolution)
        {
            EvaluateExactSolution(m_fineLevel, m_time + m_chunkTime);
        }
        timer.Stop();
        predictorTime += timer.Elapsed().count();
        totalTime += timer.Elapsed().count();
 
        // Solution convergence monitoring.
        timer.Start();
        CopyToPhysField(m_fineLevel, m_coarseSolution);
        SolutionConvergenceMonitoring(m_fineLevel, 0);
        timer.Stop();
        totalTime += timer.Elapsed().count();
        if (m_chunkRank == m_numChunks - 1 &&
            m_comm->GetSpaceComm()->GetRank() == 0)
        {
            std::cout << "Total Computation Time : " << totalTime << "s"
                      << std::endl
                      << std::flush;
        }
 
        // Start Parareal iteration.
        size_t iter         = 1;
        int convergenceCurr = false;
        int convergencePrev = (m_chunkRank == 0);
        while (iter <= m_iterMaxPIT && !convergenceCurr)
        {
            // Use previous parareal solution as "exact solution", if necessary.
            timer.Start();
            if (!m_exactSolution)
            {
                CopyFromPhysField(m_fineLevel, m_exactsoln);
            }
            timer.Stop();
            totalTime += timer.Elapsed().count();
 
            // Calculate fine solution (parallel-in-time).
            timer.Start();
            UpdateSolverInitialCondition(m_fineLevel);
            UpdateSolution(m_fineLevel, m_time, m_nsteps[m_fineLevel], w, iter);
            timer.Stop();
            fineSolveTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
 
            // Compute F -> F - Gold
            timer.Start();
            CorrectionWithOldCoarseSolution();
            timer.Stop();
            correctionTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
 
            // Receive coarse solution from previous processor.
            timer.Start();
            RecvFromPreviousProc(m_initialCondition, convergencePrev);
            timer.Stop();
            totalTime += timer.Elapsed().count();
 
            // Calculate coarse solution (serial-in-time).
            timer.Start();
            UpdateSolverInitialCondition(m_coarseLevel);
            UpdateSolution(m_coarseLevel, m_time, m_nsteps[m_coarseLevel], w,
                           iter);
            timer.Stop();
            coarseSolveTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
 
            // Compute F -> F + Gnew
            timer.Start();
            CorrectionWithNewCoarseSolution();
            timer.Stop();
            correctionTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
 
            // Solution convergence monitoring.
            CopyToPhysField(m_fineLevel, m_fineSolution);
            SolutionConvergenceMonitoring(m_fineLevel, iter);
            if (m_chunkRank == m_numChunks - 1 &&
                m_comm->GetSpaceComm()->GetRank() == 0)
            {
                std::cout << "Total Computation Time : " << totalTime << "s"
                          << std::endl
                          << std::flush;
                std::cout << " - Predictor Time : " << predictorTime << "s"
                          << std::endl
                          << std::flush;
                std::cout << " - Coarse Solve Time : " << coarseSolveTime << "s"
                          << std::endl
                          << std::flush;
                std::cout << " - Fine Solve Time : " << fineSolveTime << "s"
                          << std::endl
                          << std::flush;
                std::cout << " - Correction Time : " << correctionTime << "s"
                          << std::endl
                          << std::flush;
            }
 
            // Check convergence of L2 error for each time chunk.
            convergenceCurr = (vL2ErrorMax() < m_tolerPIT && convergencePrev) ||
                              (m_chunkRank + 1 == iter);
 
            // Send solution to next processor.
            timer.Start();
            SendToNextProc(m_fineSolution, convergenceCurr);
            timer.Stop();
            totalTime += timer.Elapsed().count();
 
            // Increment iteration index.
            iter++;
        }
 
        // Copy converged check points.
        CopyConvergedCheckPoints(w, iter);
 
        // Write time chunk solution to files.
        WriteTimeChunkOuput();
 
        // Apply windowing.
        timer.Start();
        ApplyWindowing(w);
        timer.Stop();
        totalTime += timer.Elapsed().count();
    }
 
    m_comm->GetTimeComm()->Block();
    PrintHeader("SUMMARY", '*');
    EvaluateExactSolution(m_fineLevel, m_time + m_chunkTime);
    SolutionConvergenceSummary(m_fineLevel);
    if (m_chunkRank == m_numChunks - 1 &&
        m_comm->GetSpaceComm()->GetRank() == 0)
    {
        std::cout << "Total Computation Time : " << totalTime << "s"
                  << std::endl
                  << std::flush;
        std::cout << " - Predictor Time : " << predictorTime << "s" << std::endl
                  << std::flush;
        std::cout << " - Coarse Solve Time : " << coarseSolveTime << "s"
                  << std::endl
                  << std::flush;
        std::cout << " - Fine Solve Time : " << fineSolveTime << "s"
                  << std::endl
                  << std::flush;
        std::cout << " - Correction Time : " << correctionTime << "s"
                  << std::endl
                  << std::flush;
    }
}

◆ 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 62 of file DriverParareal.cpp.

{
    DriverParallelInTime::v_InitObject(out);
    DriverParallelInTime::GetParametersFromSession();
    DriverParallelInTime::PrintSolverInfo(out);
    DriverParallelInTime::InitialiseEqSystem(false);
    AllocateMemory();
}

References AllocateMemory(), Nektar::SolverUtils::DriverParallelInTime::GetParametersFromSession(), Nektar::SolverUtils::DriverParallelInTime::InitialiseEqSystem(), Nektar::SolverUtils::DriverParallelInTime::PrintSolverInfo(), and Nektar::SolverUtils::DriverParallelInTime::v_InitObject().

◆ WriteTimeChunkOuput()

void Nektar::SolverUtils::DriverParareal::WriteTimeChunkOuput ( void )

private

Definition at line 566 of file DriverParareal.cpp.

{
    PrintHeader("PRINT SOLUTION FILES", '-');
 
    // Update field coefficients.
    UpdateFieldCoeffs(m_fineLevel);
 
    // Output solution files.
    m_EqSys[m_fineLevel]->Output();
}

References Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_fineLevel, Nektar::SolverUtils::DriverParallelInTime::PrintHeader(), and Nektar::SolverUtils::DriverParallelInTime::UpdateFieldCoeffs().

Referenced by v_Execute().

Friends And Related Symbol 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 61 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:580

Definition at line 79 of file DriverParareal.h.

◆ m_coarseLevel

constexpr size_t Nektar::SolverUtils::DriverParareal::m_coarseLevel = 1

staticconstexprprivate

Definition at line 106 of file DriverParareal.h.

Referenced by AllocateMemory(), AssertParameters(), InterpolateCoarseSolution(), and v_Execute().

◆ m_coarseSolution

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverParareal::m_coarseSolution

private

Definition at line 109 of file DriverParareal.h.

Referenced by AllocateMemory(), CorrectionWithNewCoarseSolution(), CorrectionWithOldCoarseSolution(), InterpolateCoarseSolution(), and v_Execute().

◆ m_fineLevel

constexpr size_t Nektar::SolverUtils::DriverParareal::m_fineLevel = 0

staticconstexprprivate

Definition at line 105 of file DriverParareal.h.

Referenced by AllocateMemory(), ApplyWindowing(), AssertParameters(), CopyConvergedCheckPoints(), CorrectionWithNewCoarseSolution(), CorrectionWithOldCoarseSolution(), InterpolateCoarseSolution(), UpdateInitialConditionFromSolver(), UpdateSolverInitialCondition(), v_Execute(), and WriteTimeChunkOuput().

◆ m_fineSolution

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverParareal::m_fineSolution

private

Definition at line 108 of file DriverParareal.h.

Referenced by AllocateMemory(), CorrectionWithNewCoarseSolution(), CorrectionWithOldCoarseSolution(), and v_Execute().

◆ m_initialCondition

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverParareal::m_initialCondition

private

Definition at line 107 of file DriverParareal.h.

Referenced by AllocateMemory(), ApplyWindowing(), UpdateInitialConditionFromSolver(), UpdateSolverInitialCondition(), and v_Execute().

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DriverParareal()

◆ ~DriverParareal()

Member Function Documentation

◆ AllocateMemory()

◆ ApplyWindowing()

◆ AssertParameters()

◆ CopyConvergedCheckPoints()

◆ CorrectionWithNewCoarseSolution()

◆ CorrectionWithOldCoarseSolution()

◆ create()

◆ InterpolateCoarseSolution()

◆ UpdateInitialConditionFromSolver()

◆ UpdateSolution()

◆ UpdateSolverInitialCondition()

◆ v_Execute()

◆ v_InitObject()

◆ WriteTimeChunkOuput()

Friends And Related Symbol Documentation

◆ MemoryManager< DriverParareal >

Member Data Documentation

◆ className

◆ driverLookupId

◆ m_coarseLevel

◆ m_coarseSolution

◆ m_fineLevel

◆ m_fineSolution

◆ m_initialCondition