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

#include <DriverParallelInTime.h>

Inheritance diagram for Nektar::SolverUtils::DriverParallelInTime:

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

SOLVER_UTILS_EXPORT	~DriverParallelInTime () 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.

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.

Protected Attributes
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.

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

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 45 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 55 of file DriverParallelInTime.cpp.

    : Driver(pSession, pGraph)
{
}

◆ ~DriverParallelInTime()

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

overrideprotecteddefault

Destructor.

Member Function Documentation

◆ CopyFromPhysField()

void Nektar::SolverUtils::DriverParallelInTime::CopyFromPhysField	(	const size_t	timeLevel,
		Array< OneD, Array< OneD, NekDouble > > &	out
	)

protected

Definition at line 429 of file DriverParallelInTime.cpp.

{
    for (size_t i = 0; i < m_nVar; ++i)
    {
        m_EqSys[timeLevel]->CopyFromPhysField(i, out[i]);
    }
}

References m_EqSys, and m_nVar.

Referenced by 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 416 of file DriverParallelInTime.cpp.

{
    for (size_t i = 0; i < m_nVar; ++i)
    {
        Vmath::Vcopy(in[i].size(), in[i], 1, out[i], 1);
    }
}

References m_nVar, and Vmath::Vcopy().

Referenced by Nektar::SolverUtils::DriverPFASST::RestrictResidual(), and Nektar::SolverUtils::DriverPFASST::RestrictSolution().

◆ CopyToPhysField()

void Nektar::SolverUtils::DriverParallelInTime::CopyToPhysField	(	const size_t	timeLevel,
		const Array< OneD, const Array< OneD, NekDouble > > &	in
	)

protected

Definition at line 441 of file DriverParallelInTime.cpp.

{
    for (size_t i = 0; i < m_nVar; ++i)
    {
        m_EqSys[timeLevel]->CopyToPhysField(i, in[i]);
        m_EqSys[timeLevel]->UpdateFields()[i]->SetPhysState(true);
    }
}

References m_EqSys, and m_nVar.

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 568 of file DriverParallelInTime.cpp.

{
    if (m_numChunks == 1)
    {
        return 0.0;
    }
    else
    {
        // Average communication time over niter iteration.
        size_t niter = 20;
        Nektar::LibUtilities::Timer timer;
        for (size_t n = 0; n <= niter; n++)
        {
            if (n == 1)
            {
                timer.Start(); // Ignore the first iteration
            }
 
            if (m_chunkRank == 0)
            {
                for (size_t i = 0; i < buffer1.size(); ++i)
                {
                    m_comm->GetTimeComm()->Send(m_numChunks - 1, buffer1[i]);
                }
            }
 
            if (m_chunkRank == m_numChunks - 1)
            {
                for (size_t i = 0; i < buffer2.size(); ++i)
                {
                    m_comm->GetTimeComm()->Recv(0, buffer2[i]);
                }
            }
        }
        timer.Stop();
        return timer.Elapsed().count() / niter;
    }
}

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

◆ EvaluateExactSolution()

void Nektar::SolverUtils::DriverParallelInTime::EvaluateExactSolution	(	const size_t	timeLevel,
		const NekDouble &	time
	)

protected

Definition at line 472 of file DriverParallelInTime.cpp.

{
    for (size_t i = 0; i < m_nVar; ++i)
    {
        m_EqSys[timeLevel]->EvaluateExactSolution(i, m_exactsoln[i], time);
    }
}

References m_EqSys, m_exactsoln, and m_nVar.

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

◆ GetParametersFromSession()

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

protected

Definition at line 251 of file DriverParallelInTime.cpp.

{
    // Parallel-in-Time iteration parameters.
    m_tolerPIT      = m_session->DefinesParameter("PITToler")
                          ? m_session->GetParameter("PITToler")
                          : 1.0E-16;
    m_iterMaxPIT    = m_session->DefinesParameter("PITIterMax")
                          ? m_session->GetParameter("PITIterMax")
                          : m_numChunks;
    m_numWindowsPIT = m_session->DefinesParameter("NumWindows")
                          ? m_session->GetParameter("NumWindows")
                          : 1;
 
    // Other parameters.
    m_exactSolution = m_session->DefinesParameter("ExactSolution")
                          ? m_session->GetParameter("ExactSolution")
                          : 0;
}

References m_exactSolution, m_iterMaxPIT, m_numChunks, m_numWindowsPIT, Nektar::SolverUtils::Driver::m_session, and m_tolerPIT.

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

◆ InitialiseEqSystem()

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

protected

Definition at line 273 of file DriverParallelInTime.cpp.

{
    m_nVar = m_EqSys[0]->GetNvariables();
 
    // Initialize fine solver.
    if (turnoff_output)
    {
        for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
        {
            m_EqSys[timeLevel]->SetInfoSteps(0);
            m_EqSys[timeLevel]->SetCheckpointSteps(0);
        }
    }
    m_EqSys[0]->DoInitialise(true);
 
    // Initialize coarse solver(s).
    for (size_t timeLevel = 1; timeLevel < m_nTimeLevel; timeLevel++)
    {
        m_EqSys[timeLevel]->DoInitialise(false);
    }
 
    // Initialize time stepping parameters.
    m_time0    = m_EqSys[0]->GetTime();
    m_timestep = Array<OneD, NekDouble>(m_nTimeLevel);
    m_nsteps   = Array<OneD, size_t>(m_nTimeLevel);
    m_npts     = Array<OneD, size_t>(m_nTimeLevel);
    for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
    {
        m_timestep[timeLevel] =
            m_EqSys[timeLevel]->EquationSystem::GetTimeStep();
        m_nsteps[timeLevel] = m_EqSys[timeLevel]->EquationSystem::GetSteps();
        m_npts[timeLevel]   = m_EqSys[timeLevel]->EquationSystem::GetNpoints();
    }
 
    // Initialize errors.
    m_exactsoln = Array<OneD, Array<OneD, NekDouble>>(m_nVar);
    for (size_t i = 0; i < m_nVar; ++i)
    {
        m_exactsoln[i] = Array<OneD, NekDouble>(m_npts[0], 0.0);
    }
    m_vL2Errors   = Array<OneD, NekDouble>(m_nVar, 0.0);
    m_vLinfErrors = Array<OneD, NekDouble>(m_nVar, 0.0);
}

References m_EqSys, m_exactsoln, m_npts, m_nsteps, m_nTimeLevel, m_nVar, m_time0, m_timestep, m_vL2Errors, and m_vLinfErrors.

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

◆ InitialiseInterpolationField()

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

protected

◆ Interpolate()

void Nektar::SolverUtils::DriverParallelInTime::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

Definition at line 612 of file DriverParallelInTime.cpp.

{
    if (infield.size() != outfield.size())
    {
        NEKERROR(ErrorUtil::efatal, "not the same number of variables")
    }
 
    for (size_t n = 0; n < infield.size(); ++n)
    {
        // Interpolation from infield -> outfield assuming that infield and
        // outfield are the same explists, but at potentially different
        // polynomial orders.
        if (infield[n]->GetExpSize() != outfield[n]->GetExpSize())
        {
            NEKERROR(ErrorUtil::efatal, "not the same mesh")
        }
 
        // Assign input/output array.
        auto inphys  = (inarray == NullNekDoubleArrayOfArray)
                           ? infield[n]->UpdatePhys()
                           : inarray[n];
        auto outphys = (outarray == NullNekDoubleArrayOfArray)
                           ? outfield[n]->UpdatePhys()
                           : outarray[n];
 
        // If same polynomial orders, simply copy solution.
        if (infield[n]->GetTotPoints() == outfield[n]->GetTotPoints())
        {
            Vmath::Vcopy(infield[n]->GetTotPoints(), inphys, 1, outphys, 1);
        }
        // If different polynomial orders, interpolate solution.
        else
        {
            for (size_t i = 0; i < infield[n]->GetExpSize(); ++i)
            {
                // Get the elements.
                auto inElmt  = infield[n]->GetExp(i);
                auto outElmt = outfield[n]->GetExp(i);
 
                // Get the offset of elements in the storage arrays.
                size_t inoffset  = infield[n]->GetPhys_Offset(i);
                size_t outoffset = outfield[n]->GetPhys_Offset(i);
 
                // Transform solution from physical to coefficient space.
                Array<OneD, NekDouble> incoeff(inElmt->GetNcoeffs());
                inElmt->FwdTrans(inphys + inoffset, incoeff);
 
                // Interpolate elements.
                StdRegions::StdExpansionSharedPtr expPtr;
                if (inElmt->DetShapeType() == LibUtilities::Seg)
                {
                    expPtr = std::make_shared<StdRegions::StdSegExp>(
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(0)->GetBasisType(),
                            inElmt->GetBasis(0)->GetNumModes(),
                            outElmt->GetBasis(0)->GetPointsKey()));
                }
                else if (inElmt->DetShapeType() == LibUtilities::Quad)
                {
                    expPtr = std::make_shared<StdRegions::StdQuadExp>(
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(0)->GetBasisType(),
                            inElmt->GetBasis(0)->GetNumModes(),
                            outElmt->GetBasis(0)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(1)->GetBasisType(),
                            inElmt->GetBasis(1)->GetNumModes(),
                            outElmt->GetBasis(1)->GetPointsKey()));
                }
                else if (inElmt->DetShapeType() == LibUtilities::Tri)
                {
                    expPtr = std::make_shared<StdRegions::StdTriExp>(
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(0)->GetBasisType(),
                            inElmt->GetBasis(0)->GetNumModes(),
                            outElmt->GetBasis(0)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(1)->GetBasisType(),
                            inElmt->GetBasis(1)->GetNumModes(),
                            outElmt->GetBasis(1)->GetPointsKey()));
                }
                else if (inElmt->DetShapeType() == LibUtilities::Hex)
                {
                    expPtr = std::make_shared<StdRegions::StdHexExp>(
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(0)->GetBasisType(),
                            inElmt->GetBasis(0)->GetNumModes(),
                            outElmt->GetBasis(0)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(1)->GetBasisType(),
                            inElmt->GetBasis(1)->GetNumModes(),
                            outElmt->GetBasis(1)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(2)->GetBasisType(),
                            inElmt->GetBasis(2)->GetNumModes(),
                            outElmt->GetBasis(2)->GetPointsKey()));
                }
                else if (inElmt->DetShapeType() == LibUtilities::Prism)
                {
                    expPtr = std::make_shared<StdRegions::StdPrismExp>(
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(0)->GetBasisType(),
                            inElmt->GetBasis(0)->GetNumModes(),
                            outElmt->GetBasis(0)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(1)->GetBasisType(),
                            inElmt->GetBasis(1)->GetNumModes(),
                            outElmt->GetBasis(1)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(2)->GetBasisType(),
                            inElmt->GetBasis(2)->GetNumModes(),
                            outElmt->GetBasis(2)->GetPointsKey()));
                }
                else if (inElmt->DetShapeType() == LibUtilities::Pyr)
                {
                    expPtr = std::make_shared<StdRegions::StdPyrExp>(
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(0)->GetBasisType(),
                            inElmt->GetBasis(0)->GetNumModes(),
                            outElmt->GetBasis(0)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(1)->GetBasisType(),
                            inElmt->GetBasis(1)->GetNumModes(),
                            outElmt->GetBasis(1)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(2)->GetBasisType(),
                            inElmt->GetBasis(2)->GetNumModes(),
                            outElmt->GetBasis(2)->GetPointsKey()));
                }
                else if (inElmt->DetShapeType() == LibUtilities::Tet)
                {
                    expPtr = std::make_shared<StdRegions::StdTetExp>(
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(0)->GetBasisType(),
                            inElmt->GetBasis(0)->GetNumModes(),
                            outElmt->GetBasis(0)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(1)->GetBasisType(),
                            inElmt->GetBasis(1)->GetNumModes(),
                            outElmt->GetBasis(1)->GetPointsKey()),
                        LibUtilities::BasisKey(
                            inElmt->GetBasis(2)->GetBasisType(),
                            inElmt->GetBasis(2)->GetNumModes(),
                            outElmt->GetBasis(2)->GetPointsKey()));
                }
 
                // Transform solution from coefficient to physical space.
                Array<OneD, NekDouble> tmp = outphys + outoffset;
                expPtr->BwdTrans(incoeff, tmp);
            }
        }
    }
}

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::Hex, NEKERROR, Nektar::NullNekDoubleArrayOfArray, Nektar::LibUtilities::Prism, Nektar::LibUtilities::Pyr, Nektar::LibUtilities::Quad, Nektar::LibUtilities::Seg, Nektar::LibUtilities::Tet, Nektar::LibUtilities::Tri, and Vmath::Vcopy().

Referenced by Nektar::SolverUtils::DriverParareal::InterpolateCoarseSolution(), Nektar::SolverUtils::DriverParareal::UpdateInitialConditionFromSolver(), and Nektar::SolverUtils::DriverParareal::UpdateSolverInitialCondition().

◆ PrintErrorNorm()

void Nektar::SolverUtils::DriverParallelInTime::PrintErrorNorm	(	const size_t	timeLevel,
		const bool	normalized
	)

protected

Definition at line 518 of file DriverParallelInTime.cpp.

{
    if (m_chunkRank == m_numChunks - 1 &&
        m_comm->GetSpaceComm()->GetRank() == 0)
    {
        for (size_t i = 0; i < m_nVar; ++i)
        {
            if (normalized)
            {
                std::cout << "L2 error (variable "
                          << m_EqSys[timeLevel]->GetVariable(i)
                          << ") : " << m_vL2Errors[i] << std::endl
                          << std::flush;
                std::cout << "Linf error (variable "
                          << m_EqSys[timeLevel]->GetVariable(i)
                          << ") : " << m_vLinfErrors[i] << std::endl
                          << std::flush;
            }
            else
            {
                std::cout << "L 2 error (variable "
                          << m_EqSys[timeLevel]->GetVariable(i)
                          << ") : " << m_vL2Errors[i] << std::endl
                          << std::flush;
                std::cout << "L inf error (variable "
                          << m_EqSys[timeLevel]->GetVariable(i)
                          << ") : " << m_vLinfErrors[i] << std::endl
                          << std::flush;
            }
        }
    }
}

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

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

◆ PrintHeader()

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

protected

Definition at line 344 of file DriverParallelInTime.cpp.

{
    if (m_chunkRank == m_numChunks - 1 &&
        m_comm->GetSpaceComm()->GetRank() == 0)
    {
        std::cout << std::endl;
        std::cout << std::string(43, c) << std::endl << std::flush;
        std::cout << title << std::endl << std::flush;
        std::cout << std::string(43, c) << std::endl << std::flush;
    }
}

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

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

◆ PrintSolverInfo()

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

protected

Definition at line 320 of file DriverParallelInTime.cpp.

{
    if (m_chunkRank == 0 && m_comm->GetSpaceComm()->GetRank() == 0)
    {
        for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
        {
            std::cout << std::string(71, '=') << std::endl << std::flush;
            std::cout << "=========================== TIME LEVEL " +
                             std::to_string(timeLevel) +
                             " INFO "
                             "========================="
                      << std::endl
                      << std::flush;
 
            m_EqSys[timeLevel]->PrintSummary(out);
 
            std::cout << std::endl << std::flush;
        }
    }
}

References m_chunkRank, Nektar::SolverUtils::Driver::m_comm, m_EqSys, and m_nTimeLevel.

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

◆ RecvFromPreviousProc() [1/2]

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

protected

Definition at line 359 of file DriverParallelInTime.cpp.

{
    if (m_chunkRank > 0)
    {
        if (!convergence)
        {
            m_comm->GetTimeComm()->Recv(m_chunkRank - 1, convergence);
            for (size_t i = 0; i < m_nVar; ++i)
            {
                m_comm->GetTimeComm()->Recv(m_chunkRank - 1, array[i]);
            }
        }
    }
}

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

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

◆ RecvFromPreviousProc() [2/2]

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

protected

Definition at line 378 of file DriverParallelInTime.cpp.

{
    if (m_chunkRank > 0)
    {
        m_comm->GetTimeComm()->Recv(m_chunkRank - 1, array);
    }
}

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

◆ SendToNextProc() [1/2]

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

protected

Definition at line 389 of file DriverParallelInTime.cpp.

{
    if (m_chunkRank < m_numChunks - 1)
    {
        m_comm->GetTimeComm()->Send(m_chunkRank + 1, convergence);
        for (size_t i = 0; i < m_nVar; ++i)
        {
            m_comm->GetTimeComm()->Send(m_chunkRank + 1, array[i]);
        }
    }
}

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

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

◆ SendToNextProc() [2/2]

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

protected

Definition at line 405 of file DriverParallelInTime.cpp.

{
    if (m_chunkRank < m_numChunks - 1)
    {
        m_comm->GetTimeComm()->Send(m_chunkRank + 1, array);
    }
}

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

◆ SetParallelInTimeEquationSystem()

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

protected

Set the ParallelInTime (coarse solver) session file

Definition at line 127 of file DriverParallelInTime.cpp.

{
    // Retrieve the equation system to solve.
    ASSERTL0(m_session->DefinesSolverInfo("EqType"),
             "EqType SolverInfo tag must be defined.");
    std::string vEquation = m_session->DefinesSolverInfo("SolverType")
                                ? m_session->GetSolverInfo("SolverType")
                                : m_session->GetSolverInfo("EqType");
 
    // Check such a module exists for this equation.
    ASSERTL0(GetEquationSystemFactory().ModuleExists(vEquation),
             "EquationSystem '" + vEquation +
                 "' is not defined.\n"
                 "Ensure equation name is correct and module is compiled.\n");
 
    // Set fine parallel-in-time solver.
    ASSERTL0(m_session->DefinesCmdLineArgument("npt"),
             "Number of parallel-in-time processes npt must be specified.");
    m_session->SetTag("AdvectiveType", AdvectiveType);
    m_session->SetTag("ParallelInTimeSolver", "TimeLevel0");
    m_equ[0] = GetEquationSystemFactory().CreateInstance(vEquation, m_session,
                                                         m_graph);
 
    // Define argument for the coarse parallel-in-time solver.
    int npx = m_session->DefinesCmdLineArgument("npx")
                  ? m_session->GetCmdLineArgument<int>("npx")
                  : 1;
    int npy = m_session->DefinesCmdLineArgument("npy")
                  ? m_session->GetCmdLineArgument<int>("npy")
                  : 1;
    int npz = m_session->DefinesCmdLineArgument("npz")
                  ? m_session->GetCmdLineArgument<int>("npz")
                  : 1;
    int nsz = m_session->DefinesCmdLineArgument("nsz")
                  ? m_session->GetCmdLineArgument<int>("nsz")
                  : 1;
    int npt = m_session->GetCmdLineArgument<int>("npt");
 
    // Convert into string.
    std::string npx_string    = std::to_string(npx);
    std::string npy_string    = std::to_string(npy);
    std::string npz_string    = std::to_string(npz);
    std::string nsz_string    = std::to_string(nsz);
    std::string npt_string    = std::to_string(npt);
    std::string driver_string = "Driver=" + m_session->GetSolverInfo("Driver");
 
    // use-opt-file
    bool useOptFile         = m_session->DefinesCmdLineArgument("use-opt-file");
    std::string optfilename = useOptFile ? m_session->GetFilenames()[0] : "";
 
    char *argv[] = {const_cast<char *>("Solver"), // this is just a place holder
                    const_cast<char *>("--solverinfo"),
                    const_cast<char *>(driver_string.c_str()),
                    const_cast<char *>("--npx"),
                    const_cast<char *>(npx_string.c_str()),
                    const_cast<char *>("--npy"),
                    const_cast<char *>(npy_string.c_str()),
                    const_cast<char *>("--npz"),
                    const_cast<char *>(npz_string.c_str()),
                    const_cast<char *>("--nsz"),
                    const_cast<char *>(nsz_string.c_str()),
                    const_cast<char *>("--npt"),
                    const_cast<char *>(npt_string.c_str()),
                    const_cast<char *>("-f"),
                    const_cast<char *>("--use-opt-file"),
                    const_cast<char *>(optfilename.c_str()),
                    nullptr};
 
    size_t argc = useOptFile ? 16 : 14;
 
    // Get list of session file names.
    std::vector<std::string> sessionFileNames;
    for (auto &filename : m_session->GetFilenames())
    {
        // Remove optfile name, if necessary.
        if (filename.substr(filename.find_last_of(".") + 1) != "opt")
        {
            sessionFileNames.push_back(filename);
        }
    }
 
    // Set session for coarse solver.
    for (size_t timeLevel = 1; timeLevel < m_nTimeLevel; timeLevel++)
    {
        auto session = LibUtilities::SessionReader::CreateInstance(
            argc, argv, sessionFileNames, m_session->GetComm(), timeLevel);
 
        // Set graph for coarse solver.
        auto graph = SpatialDomains::MeshGraphIO::Read(
            session, LibUtilities::NullDomainRangeShPtr, true, m_graph);
 
        // Set BndRegionOrdering (necessary for DG with periodic BC) FIXME
        graph->SetBndRegionOrdering(m_graph->GetBndRegionOrdering());
 
        // Set CompositeOrdering (necessary for DG with periodic BC) FIXME
        graph->SetCompositeOrdering(m_graph->GetCompositeOrdering());
 
        // Retrieve the equation system to solve.
        ASSERTL0(session->DefinesSolverInfo("EqType"),
                 "EqType SolverInfo tag must be defined.");
        auto vEquation = session->DefinesSolverInfo("SolverType")
                             ? session->GetSolverInfo("SolverType")
                             : session->GetSolverInfo("EqType");
 
        // Check such a module exists for this equation.
        ASSERTL0(
            GetEquationSystemFactory().ModuleExists(vEquation),
            "EquationSystem '" + vEquation +
                "' is not defined.\n"
                "Ensure equation name is correct and module is compiled.\n");
 
        // Set coarse parallel-in-time solver.
        session->SetTag("AdvectiveType", AdvectiveType);
        session->SetTag("ParallelInTimeSolver",
                        "TimeLevel" + std::to_string(timeLevel));
        m_equ[timeLevel] = GetEquationSystemFactory().CreateInstance(
            vEquation, session, graph);
    }
}

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, m_nTimeLevel, Nektar::SolverUtils::Driver::m_session, Nektar::LibUtilities::NullDomainRangeShPtr, and Nektar::SpatialDomains::MeshGraphIO::Read().

Referenced by v_InitObject().

◆ SolutionConvergenceMonitoring()

void Nektar::SolverUtils::DriverParallelInTime::SolutionConvergenceMonitoring	(	const size_t	timeLevel,
		const size_t	iter
	)

protected

Definition at line 484 of file DriverParallelInTime.cpp.

{
    PrintHeader((boost::format("ITERATION %1%") % iter).str(), '-');
    UpdateErrorNorm(timeLevel, true);
    PrintErrorNorm(timeLevel, true);
}

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

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

◆ SolutionConvergenceSummary()

void Nektar::SolverUtils::DriverParallelInTime::SolutionConvergenceSummary ( const size_t timeLevel )

protected

Definition at line 495 of file DriverParallelInTime.cpp.

{
    UpdateErrorNorm(timeLevel, false);
    PrintErrorNorm(timeLevel, false);
}

References PrintErrorNorm(), and UpdateErrorNorm().

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

◆ UpdateErrorNorm()

void Nektar::SolverUtils::DriverParallelInTime::UpdateErrorNorm	(	const size_t	timeLevel,
		const bool	normalized
	)

protected

Definition at line 504 of file DriverParallelInTime.cpp.

{
    for (size_t i = 0; i < m_nVar; ++i)
    {
        m_vL2Errors[i] =
            m_EqSys[timeLevel]->L2Error(i, m_exactsoln[i], normalized);
        m_vLinfErrors[i] = m_EqSys[timeLevel]->LinfError(i, m_exactsoln[i]);
    }
}

References m_EqSys, m_exactsoln, m_nVar, m_vL2Errors, and m_vLinfErrors.

Referenced by SolutionConvergenceMonitoring(), and SolutionConvergenceSummary().

◆ UpdateFieldCoeffs()

void Nektar::SolverUtils::DriverParallelInTime::UpdateFieldCoeffs	(	const size_t	timeLevel,
		const Array< OneD, const Array< OneD, NekDouble > > &	in = `NullNekDoubleArrayOfArray`
	)

protected

Definition at line 454 of file DriverParallelInTime.cpp.

{
    for (size_t i = 0; i < m_nVar; ++i)
    {
        if (in != NullNekDoubleArrayOfArray)
        {
            m_EqSys[timeLevel]->CopyToPhysField(i, in[i]);
        }
        m_EqSys[timeLevel]->UpdateFields()[i]->FwdTrans(
            m_EqSys[timeLevel]->UpdateFields()[i]->GetPhys(),
            m_EqSys[timeLevel]->UpdateFields()[i]->UpdateCoeffs());
    }
}

References m_EqSys, m_nVar, and Nektar::NullNekDoubleArrayOfArray.

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

◆ 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 120 of file DriverParallelInTime.cpp.

121{

122}

◆ 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 65 of file DriverParallelInTime.cpp.

{
    try
    {
        // Retrieve the type of evolution operator to use
        m_EvolutionOperator =
            m_session->GetSolverInfoAsEnum<EvolutionOperatorType>(
                "EvolutionOperator");
 
        m_nTimeLevel = 2; // Only two time levels currently implemented.
 
        m_equ = Array<OneD, EquationSystemSharedPtr>(m_nTimeLevel);
 
        // Set the AdvectiveType tag and create EquationSystem objects.
        switch (m_EvolutionOperator)
        {
            case eNonlinear:
                SetParallelInTimeEquationSystem("Convective");
                break;
            case eDirect:
                SetParallelInTimeEquationSystem("Linearised");
                break;
            case eAdjoint:
                SetParallelInTimeEquationSystem("Adjoint");
                break;
            case eSkewSymmetric:
                SetParallelInTimeEquationSystem("SkewSymmetric");
                break;
            default:
                ASSERTL0(false, "Unrecognised evolution operator.");
        }
 
        // Set pointers.
        m_EqSys = Array<OneD, std::shared_ptr<UnsteadySystem>>(m_nTimeLevel);
        for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
        {
            m_EqSys[timeLevel] =
                std::dynamic_pointer_cast<SolverUtils::UnsteadySystem>(
                    m_equ[timeLevel]);
        }
 
        // Set time communication parameters.
        m_numChunks = m_comm->GetTimeComm()->GetSize();
        m_chunkRank = m_comm->GetTimeComm()->GetRank();
    }
    catch (int e)
    {
        ASSERTL0(e == -1, "No such class class defined.");
        out << "An error occurred during driver initialisation." << std::endl;
    }
}

References ASSERTL0, Nektar::SolverUtils::eAdjoint, Nektar::SolverUtils::eDirect, Nektar::SolverUtils::eNonlinear, Nektar::SolverUtils::eSkewSymmetric, m_chunkRank, Nektar::SolverUtils::Driver::m_comm, m_EqSys, Nektar::SolverUtils::Driver::m_equ, Nektar::SolverUtils::Driver::m_EvolutionOperator, m_nTimeLevel, m_numChunks, 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 555 of file DriverParallelInTime.cpp.

{
    NekDouble L2Error = 0.0;
    for (size_t i = 0; i < m_nVar; ++i)
    {
        L2Error = std::max(L2Error, m_vL2Errors[i]);
    }
    return L2Error;
}

References m_nVar, and m_vL2Errors.

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

Member Data Documentation

◆ m_chunkRank

size_t Nektar::SolverUtils::DriverParallelInTime::m_chunkRank

protected

Rank in time.

Definition at line 136 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::ApplyWindowing(), Nektar::SolverUtils::DriverPFASST::ApplyWindowing(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), EstimateCommunicationTime(), Nektar::SolverUtils::DriverPFASST::IsNotInitialCondition(), PrintErrorNorm(), PrintHeader(), PrintSolverInfo(), RecvFromPreviousProc(), RecvFromPreviousProc(), SendToNextProc(), SendToNextProc(), Nektar::SolverUtils::DriverParareal::UpdateSolution(), Nektar::SolverUtils::DriverParareal::v_Execute(), Nektar::SolverUtils::DriverPFASST::v_Execute(), and v_InitObject().

◆ m_chunkTime

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_chunkTime

protected

Time integration interval per chunk.

Definition at line 126 of file DriverParallelInTime.h.

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

◆ m_EqSys

Array<OneD, std::shared_ptr<UnsteadySystem> > Nektar::SolverUtils::DriverParallelInTime::m_EqSys

protected

Equation system to solve.

Definition at line 166 of file DriverParallelInTime.h.

◆ m_exactsoln

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

protected

Definition at line 171 of file DriverParallelInTime.h.

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

◆ m_exactSolution

bool Nektar::SolverUtils::DriverParallelInTime::m_exactSolution

protected

Using exact solution to compute error norms.

Definition at line 145 of file DriverParallelInTime.h.

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

◆ m_iterMaxPIT

size_t Nektar::SolverUtils::DriverParallelInTime::m_iterMaxPIT

protected

Maximum number of parallel-in-time iteration.

Definition at line 139 of file DriverParallelInTime.h.

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

◆ m_npts

Array<OneD, size_t> Nektar::SolverUtils::DriverParallelInTime::m_npts

protected

Number of dof for each time level.

Definition at line 163 of file DriverParallelInTime.h.

◆ m_nsteps

Array<OneD, size_t> Nektar::SolverUtils::DriverParallelInTime::m_nsteps

protected

Number of time steps for each time level.

Definition at line 157 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::AssertParameters(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), InitialiseEqSystem(), Nektar::SolverUtils::DriverParareal::UpdateSolution(), Nektar::SolverUtils::DriverParareal::v_Execute(), Nektar::SolverUtils::DriverPFASST::v_Execute(), and Nektar::SolverUtils::DriverPFASST::WriteOutput().

◆ m_nTimeLevel

size_t Nektar::SolverUtils::DriverParallelInTime::m_nTimeLevel

protected

Number of time levels.

Definition at line 154 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverPFASST::ApplyWindowing(), Nektar::SolverUtils::DriverPFASST::AssertParameters(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), InitialiseEqSystem(), Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme(), PrintSolverInfo(), SetParallelInTimeEquationSystem(), Nektar::SolverUtils::DriverPFASST::SetTimeInterpolator(), Nektar::SolverUtils::DriverPFASST::v_Execute(), and v_InitObject().

◆ m_numChunks

size_t Nektar::SolverUtils::DriverParallelInTime::m_numChunks

protected

Number of time chunks.

Definition at line 133 of file DriverParallelInTime.h.

◆ m_numWindowsPIT

size_t Nektar::SolverUtils::DriverParallelInTime::m_numWindowsPIT

protected

Definition at line 142 of file DriverParallelInTime.h.

Referenced by Nektar::SolverUtils::DriverParareal::ApplyWindowing(), 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

Number of variables.

Definition at line 151 of file DriverParallelInTime.h.

◆ m_time

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_time

protected

Local time.

Definition at line 129 of file DriverParallelInTime.h.

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

◆ m_time0

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_time0

protected

Definition at line 130 of file DriverParallelInTime.h.

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

◆ m_timestep

Array<OneD, NekDouble> Nektar::SolverUtils::DriverParallelInTime::m_timestep

protected

Time step for each time level.

Definition at line 160 of file DriverParallelInTime.h.

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

◆ m_tolerPIT

NekDouble Nektar::SolverUtils::DriverParallelInTime::m_tolerPIT

protected

ParallelInTime tolerance.

Definition at line 148 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 123 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

Storage for parallel-in-time iteration.

Definition at line 169 of file DriverParallelInTime.h.

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

◆ m_vLinfErrors

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

protected

Definition at line 170 of file DriverParallelInTime.h.

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

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DriverParallelInTime()

◆ ~DriverParallelInTime()

Member Function Documentation

◆ CopyFromPhysField()

◆ CopySolutionVector()

◆ CopyToPhysField()

◆ EstimateCommunicationTime()

◆ EvaluateExactSolution()

◆ GetParametersFromSession()

◆ InitialiseEqSystem()

◆ InitialiseInterpolationField()

◆ Interpolate()

◆ PrintErrorNorm()

◆ PrintHeader()

◆ PrintSolverInfo()

◆ RecvFromPreviousProc() [1/2]

◆ RecvFromPreviousProc() [2/2]

◆ SendToNextProc() [1/2]

◆ SendToNextProc() [2/2]

◆ SetParallelInTimeEquationSystem()

◆ SolutionConvergenceMonitoring()

◆ SolutionConvergenceSummary()

◆ UpdateErrorNorm()

◆ UpdateFieldCoeffs()

◆ v_Execute()

◆ v_InitObject()

◆ vL2ErrorMax()

Member Data Documentation

◆ m_chunkRank

◆ m_chunkTime

◆ m_EqSys

◆ m_exactsoln

◆ m_exactSolution

◆ m_iterMaxPIT

◆ m_npts

◆ m_nsteps

◆ m_nTimeLevel

◆ m_numChunks

◆ m_numWindowsPIT

◆ m_nVar

◆ m_time

◆ m_time0

◆ m_timestep

◆ m_tolerPIT

◆ m_totalTime

◆ m_vL2Errors

◆ m_vLinfErrors