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

#include <DriverPFASST.h>

Inheritance diagram for Nektar::SolverUtils::DriverPFASST:

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

SOLVER_UTILS_EXPORT	~DriverPFASST () override=default
	Destructor. More...

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

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

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

SOLVER_UTILS_EXPORT	~DriverParallelInTime () override=default
	Destructor. More...

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

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

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. 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	InitialiseSDCScheme (void)

void	SetTimeInterpolator (void)

bool	IsNotInitialCondition (const size_t n)

void	PropagateQuadratureSolutionAndResidual (const size_t timeLevel, const size_t index)

void	UpdateFirstQuadrature (const size_t timeLevel)

void	RunSweep (const NekDouble time, const size_t timeLevel, const bool update=false)

void	ResidualEval (const NekDouble time, const size_t timeLevel, const size_t n)

void	ResidualEval (const NekDouble time, const size_t timeLevel)

void	IntegratedResidualEval (const size_t timeLevel)

void	Interpolate (const size_t coarseLevel, const SDCarray &in, const size_t fineLevel, SDCarray &out, bool forced)

void	InterpolateSolution (const size_t timeLevel)

void	InterpolateResidual (const size_t timeLevel)

void	Restrict (const size_t fineLevel, const SDCarray &in, const size_t coarseLevel, SDCarray &out)

void	RestrictSolution (const size_t timeLevel)

void	RestrictResidual (const size_t timeLevel)

void	ComputeFASCorrection (const size_t timeLevel)

void	Correct (const size_t coarseLevel, const Array< OneD, Array< OneD, NekDouble > > &in, const size_t fineLevel, Array< OneD, Array< OneD, NekDouble > > &out, bool forced)

void	CorrectInitialSolution (const size_t timeLevel)

void	CorrectInitialResidual (const size_t timeLevel)

void	Correct (const size_t coarseLevel, const SDCarray &rest, const SDCarray &in, const size_t fineLevel, SDCarray &out, bool forced)

void	CorrectSolution (const size_t timeLevel)

void	CorrectResidual (const size_t timeLevel)

void	ApplyWindowing (void)

void	EvaluateSDCResidualNorm (const size_t timeLevel)

void	WriteOutput (const size_t step, const NekDouble time)

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)

Private Attributes
Array< OneD, size_t >	m_QuadPts

Array< OneD, Array< OneD, NekDouble > >	m_ImatFtoC

Array< OneD, Array< OneD, NekDouble > >	m_ImatCtoF

Array< OneD, SDCarray >	m_solutionRest

Array< OneD, SDCarray >	m_residualRest

Array< OneD, SDCarray >	m_integralRest

Array< OneD, SDCarray >	m_correction

Array< OneD, SDCarray >	m_storage

Array< OneD, std::shared_ptr< LibUtilities::TimeIntegrationSchemeSDC > >	m_SDCSolver

bool	m_updateResidual = false

Friends
class	MemoryManager< DriverPFASST >

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_totalTime
	Total time integration interval. More...

NekDouble	m_chunkTime
	Time integration interval per chunk. More...

NekDouble	m_time
	Local time. More...

size_t	m_numChunks
	Number of time chunks. More...

size_t	m_chunkRank
	Rank in time. More...

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

size_t	m_numWindowsPIT

bool	m_exactSolution
	Using exact solution to compute error norms. More...

NekDouble	m_tolerPIT
	ParallelInTime tolerance. More...

size_t	m_nVar
	Number of variables. More...

size_t	m_nTimeLevel
	Number of time levels. More...

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

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

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

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

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

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. 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 48 of file DriverPFASST.h.

Constructor & Destructor Documentation

◆ DriverPFASST()

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

protected

Constructor.

Definition at line 52 of file DriverPFASST.cpp.

    : DriverParallelInTime(pSession, pGraph)
{
}

◆ ~DriverPFASST()

SOLVER_UTILS_EXPORT Nektar::SolverUtils::DriverPFASST::~DriverPFASST ( )

overrideprotecteddefault

Destructor.

Member Function Documentation

◆ ApplyWindowing()

void Nektar::SolverUtils::DriverPFASST::ApplyWindowing ( void )

private

Definition at line 891 of file DriverPFASST.cpp.

{
    // Use last chunk solution as initial condition for the next window.
    if (m_chunkRank == m_numChunks - 1)
    {
        UpdateFirstQuadrature(0);
        for (size_t timeLevel = 0; timeLevel < m_nTimeLevel - 1; timeLevel++)
        {
            Interpolate(m_EqSys[timeLevel]->UpdateFields(),
                        m_EqSys[timeLevel + 1]->UpdateFields(),
                        m_SDCSolver[timeLevel]->GetSolutionVector()[0],
                        m_SDCSolver[timeLevel + 1]->UpdateSolutionVector()[0]);
        }
    }
 
    // Broadcast I.C. for windowing.
    for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
    {
        for (size_t i = 0; i < m_nVar; ++i)
        {
            m_comm->GetTimeComm()->Bcast(
                m_SDCSolver[timeLevel]->UpdateSolutionVector()[0][i],
                m_numChunks - 1);
        }
    }
}

References Interpolate(), Nektar::SolverUtils::DriverParallelInTime::m_chunkRank, Nektar::SolverUtils::Driver::m_comm, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, Nektar::SolverUtils::DriverParallelInTime::m_nTimeLevel, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_SDCSolver, and UpdateFirstQuadrature().

Referenced by v_Execute().

◆ AssertParameters()

void Nektar::SolverUtils::DriverPFASST::AssertParameters ( void )

private

Definition at line 280 of file DriverPFASST.cpp.

{
    // Assert time-stepping parameters.
    for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
    {
        ASSERTL0(
            m_nsteps[timeLevel] % m_numChunks == 0,
            "Total number of steps should be divisible by number of chunks.");
 
        ASSERTL0(m_timestep[0] == m_timestep[timeLevel],
                 "All SDC levels should have the same timestep");
 
        ASSERTL0(m_nsteps[0] == m_nsteps[timeLevel],
                 "All SDC levels should have the same timestep");
    }
 
    // Assert I/O parameters.
    if (m_EqSys[0]->GetCheckpointSteps())
    {
        ASSERTL0(m_nsteps[0] % m_EqSys[0]->GetCheckpointSteps() == 0,
                 "number of IO_CheckSteps should divide number of steps "
                 "per time chunk");
    }
 
    if (m_EqSys[0]->GetInfoSteps())
    {
        ASSERTL0(m_nsteps[0] % m_EqSys[0]->GetInfoSteps() == 0,
                 "number of IO_InfoSteps should divide number of steps "
                 "per time chunk");
    }
}

References ASSERTL0, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, Nektar::SolverUtils::DriverParallelInTime::m_nsteps, Nektar::SolverUtils::DriverParallelInTime::m_nTimeLevel, Nektar::SolverUtils::DriverParallelInTime::m_numChunks, and Nektar::SolverUtils::DriverParallelInTime::m_timestep.

◆ ComputeFASCorrection()

void Nektar::SolverUtils::DriverPFASST::ComputeFASCorrection ( const size_t timeLevel )

private

Definition at line 682 of file DriverPFASST.cpp.

{
    size_t fineLevel   = timeLevel - 1;
    size_t coarseLevel = timeLevel;
 
    if (fineLevel != 0)
    {
        // Restrict fine FAS correction term
        Restrict(fineLevel, m_SDCSolver[fineLevel]->UpdateFAScorrectionVector(),
                 coarseLevel,
                 m_SDCSolver[coarseLevel]->UpdateFAScorrectionVector());
 
        // Restrict fine integrated residual.
        Restrict(fineLevel,
                 m_SDCSolver[fineLevel]->GetIntegratedResidualVector(),
                 coarseLevel, m_integralRest[fineLevel]);
    }
    else
    {
        // Restrict fine integrated residual.
        Restrict(
            fineLevel, m_SDCSolver[fineLevel]->GetIntegratedResidualVector(),
            coarseLevel, m_SDCSolver[coarseLevel]->UpdateFAScorrectionVector());
    }
 
    // Compute coarse FAS correction terms.
    for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
    {
        for (size_t i = 0; i < m_nVar; ++i)
        {
            if (fineLevel != 0)
            {
                Vmath::Vadd(
                    m_npts[coarseLevel],
                    m_SDCSolver[coarseLevel]->GetFAScorrectionVector()[n][i], 1,
                    m_integralRest[fineLevel][n][i], 1,
                    m_SDCSolver[coarseLevel]->UpdateFAScorrectionVector()[n][i],
                    1);
            }
 
            Vmath::Vsub(
                m_npts[coarseLevel],
                m_SDCSolver[coarseLevel]->GetFAScorrectionVector()[n][i], 1,
                m_SDCSolver[coarseLevel]->GetIntegratedResidualVector()[n][i],
                1, m_SDCSolver[coarseLevel]->UpdateFAScorrectionVector()[n][i],
                1);
        }
    }
}

References m_integralRest, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_QuadPts, m_SDCSolver, Restrict(), Vmath::Vadd(), and Vmath::Vsub().

Referenced by v_Execute().

◆ Correct() [1/2]

void Nektar::SolverUtils::DriverPFASST::Correct	(	const size_t	coarseLevel,
		const Array< OneD, Array< OneD, NekDouble > > &	in,
		const size_t	fineLevel,
		Array< OneD, Array< OneD, NekDouble > > &	out,
		bool	forced
	)

private

Definition at line 735 of file DriverPFASST.cpp.

{
    if (forced || IsNotInitialCondition(0))
    {
        // Compute difference between coarse solution and restricted
        // solution.
        Interpolate(m_EqSys[fineLevel]->UpdateFields(),
                    m_EqSys[coarseLevel]->UpdateFields(), out,
                    m_correction[fineLevel][0]);
        for (size_t i = 0; i < m_nVar; ++i)
        {
            Vmath::Vsub(m_npts[coarseLevel], in[i], 1,
                        m_correction[fineLevel][0][i], 1,
                        m_correction[fineLevel][0][i], 1);
        }
 
        // Add correction to fine solution.
        Interpolate(m_EqSys[coarseLevel]->UpdateFields(),
                    m_EqSys[fineLevel]->UpdateFields(),
                    m_correction[fineLevel][0], m_storage[fineLevel][0]);
        for (size_t i = 0; i < m_nVar; ++i)
        {
            Vmath::Vadd(m_npts[fineLevel], m_storage[fineLevel][0][i], 1,
                        out[i], 1, out[i], 1);
        }
    }
}

References Interpolate(), IsNotInitialCondition(), m_correction, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_storage, Vmath::Vadd(), and Vmath::Vsub().

Referenced by CorrectInitialResidual(), CorrectInitialSolution(), CorrectResidual(), and CorrectSolution().

◆ Correct() [2/2]

void Nektar::SolverUtils::DriverPFASST::Correct	(	const size_t	coarseLevel,
		const SDCarray &	rest,
		const SDCarray &	in,
		const size_t	fineLevel,
		SDCarray &	out,
		bool	forced
	)

private

Definition at line 796 of file DriverPFASST.cpp.

{
    // Compute difference between coarse solution and restricted
    // solution.
    for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
    {
        if (forced || IsNotInitialCondition(n))
        {
            for (size_t i = 0; i < m_nVar; ++i)
            {
                Vmath::Vsub(m_npts[coarseLevel], in[n][i], 1, rest[n][i], 1,
                            m_correction[fineLevel][n][i], 1);
            }
        }
        else
        {
            for (size_t i = 0; i < m_nVar; ++i)
            {
                Vmath::Zero(m_npts[coarseLevel], m_correction[fineLevel][n][i],
                            1);
            }
        }
    }
 
    // Interpolate coarse solution delta in space.
    for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
    {
        Interpolate(m_EqSys[coarseLevel]->UpdateFields(),
                    m_EqSys[fineLevel]->UpdateFields(),
                    m_correction[fineLevel][n], m_storage[fineLevel][n]);
    }
 
    // Interpolate coarse solution delta in time and correct fine solution.
    for (size_t n = 0; n < m_QuadPts[fineLevel]; ++n)
    {
        if (forced || IsNotInitialCondition(n))
        {
            for (size_t i = 0; i < m_nVar; ++i)
            {
                for (size_t k = 0; k < m_QuadPts[coarseLevel]; ++k)
                {
                    size_t index = k * m_QuadPts[fineLevel] + n;
                    Vmath::Svtvp(m_npts[fineLevel],
                                 m_ImatCtoF[fineLevel][index],
                                 m_storage[fineLevel][k][i], 1, out[n][i], 1,
                                 out[n][i], 1);
                }
            }
        }
    }
}

References Interpolate(), IsNotInitialCondition(), m_correction, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_ImatCtoF, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_QuadPts, m_storage, Vmath::Svtvp(), Vmath::Vsub(), and Vmath::Zero().

◆ CorrectInitialResidual()

void Nektar::SolverUtils::DriverPFASST::CorrectInitialResidual ( const size_t timeLevel )

private

Definition at line 783 of file DriverPFASST.cpp.

{
    size_t fineLevel   = timeLevel;
    size_t coarseLevel = timeLevel + 1;
 
    Correct(coarseLevel, m_SDCSolver[coarseLevel]->GetResidualVector()[0],
            fineLevel, m_SDCSolver[fineLevel]->UpdateResidualVector()[0],
            false);
}

References Correct(), and m_SDCSolver.

◆ CorrectInitialSolution()

void Nektar::SolverUtils::DriverPFASST::CorrectInitialSolution ( const size_t timeLevel )

private

Definition at line 770 of file DriverPFASST.cpp.

{
    size_t fineLevel   = timeLevel;
    size_t coarseLevel = timeLevel + 1;
 
    Correct(coarseLevel, m_SDCSolver[coarseLevel]->GetSolutionVector()[0],
            fineLevel, m_SDCSolver[fineLevel]->UpdateSolutionVector()[0],
            false);
}

References Correct(), and m_SDCSolver.

◆ CorrectResidual()

void Nektar::SolverUtils::DriverPFASST::CorrectResidual ( const size_t timeLevel )

private

Definition at line 866 of file DriverPFASST.cpp.

{
    size_t coarseLevel = timeLevel + 1;
    size_t fineLevel   = timeLevel;
 
    // Evaluate fine residual.
    if (m_updateResidual)
    {
        for (size_t n = 1; n < m_QuadPts[fineLevel]; ++n)
        {
            ResidualEval(fineLevel, n);
        }
    }
    // Correct fine residual.
    else
    {
        Correct(coarseLevel, m_residualRest[fineLevel],
                m_SDCSolver[coarseLevel]->GetResidualVector(), fineLevel,
                m_SDCSolver[fineLevel]->UpdateResidualVector(), false);
    }
}

References Correct(), m_QuadPts, m_residualRest, m_SDCSolver, m_updateResidual, and ResidualEval().

Referenced by v_Execute().

◆ CorrectSolution()

void Nektar::SolverUtils::DriverPFASST::CorrectSolution ( const size_t timeLevel )

private

Definition at line 853 of file DriverPFASST.cpp.

{
    size_t coarseLevel = timeLevel + 1;
    size_t fineLevel   = timeLevel;
 
    Correct(coarseLevel, m_solutionRest[fineLevel],
            m_SDCSolver[coarseLevel]->GetSolutionVector(), fineLevel,
            m_SDCSolver[fineLevel]->UpdateSolutionVector(), false);
}

References Correct(), m_SDCSolver, and m_solutionRest.

Referenced by v_Execute().

◆ create()

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

inlinestatic

Creates an instance of this class.

Definition at line 54 of file DriverPFASST.h.

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

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

◆ EvaluateSDCResidualNorm()

void Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm ( const size_t timeLevel )

private

Definition at line 921 of file DriverPFASST.cpp.

{
    // Compute SDC residual norm
    for (size_t i = 0; i < m_nVar; ++i)
    {
        Vmath::Vadd(
            m_npts[timeLevel],
            m_SDCSolver[timeLevel]->GetSolutionVector()[0][i], 1,
            m_SDCSolver[timeLevel]
                ->GetIntegratedResidualVector()[m_QuadPts[timeLevel] - 1][i],
            1, m_exactsoln[i], 1);
        m_EqSys[timeLevel]->CopyToPhysField(
            i, m_SDCSolver[timeLevel]
                   ->GetSolutionVector()[m_QuadPts[timeLevel] - 1][i]);
        m_vL2Errors[i]   = m_EqSys[timeLevel]->L2Error(i, m_exactsoln[i], 1);
        m_vLinfErrors[i] = m_EqSys[timeLevel]->LinfError(i, m_exactsoln[i]);
    }
}

References Nektar::SolverUtils::DriverParallelInTime::m_EqSys, Nektar::SolverUtils::DriverParallelInTime::m_exactsoln, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_QuadPts, m_SDCSolver, Nektar::SolverUtils::DriverParallelInTime::m_vL2Errors, Nektar::SolverUtils::DriverParallelInTime::m_vLinfErrors, and Vmath::Vadd().

Referenced by v_Execute().

◆ InitialiseSDCScheme()

void Nektar::SolverUtils::DriverPFASST::InitialiseSDCScheme ( void )

private

Definition at line 315 of file DriverPFASST.cpp.

{
    m_SDCSolver =
        Array<OneD, std::shared_ptr<LibUtilities::TimeIntegrationSchemeSDC>>(
            m_nTimeLevel);
    for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
    {
        // Cast pointer for TimeIntegrationSchemeSDC.
        m_SDCSolver[timeLevel] =
            std::dynamic_pointer_cast<LibUtilities::TimeIntegrationSchemeSDC>(
                m_EqSys[timeLevel]->GetTimeIntegrationScheme());
 
        // Assert if a SDC time-integration is used.
        ASSERTL0(m_SDCSolver[timeLevel] != nullptr,
                 "Should only be run with a SDC method");
 
        // Order storage to list time-integrated fields first.
        Array<OneD, Array<OneD, NekDouble>> fields(m_nVar);
        for (size_t i = 0; i < m_nVar; ++i)
        {
            fields[i] = m_EqSys[timeLevel]->UpdatePhysField(i);
        }
 
        // Initialize SDC scheme.
        m_SDCSolver[timeLevel]->SetPFASST(timeLevel != 0);
        m_SDCSolver[timeLevel]->InitializeScheme(
            m_timestep[timeLevel], fields, 0.0,
            m_EqSys[timeLevel]->GetTimeIntegrationSchemeOperators());
    }
 
    // Alocate memory.
    m_QuadPts = Array<OneD, size_t>(m_nTimeLevel);
    for (size_t timeLevel = 0; timeLevel < m_nTimeLevel; timeLevel++)
    {
        m_QuadPts[timeLevel] = m_SDCSolver[timeLevel]->GetQuadPtsNumber();
    }
 
    m_solutionRest = Array<OneD, SDCarray>(m_nTimeLevel - 1);
    m_residualRest = Array<OneD, SDCarray>(m_nTimeLevel - 1);
    m_integralRest = Array<OneD, SDCarray>(m_nTimeLevel - 1);
    m_correction   = Array<OneD, SDCarray>(m_nTimeLevel - 1);
    m_storage      = Array<OneD, SDCarray>(m_nTimeLevel - 1);
    for (size_t timeLevel = 0; timeLevel < m_nTimeLevel - 1; timeLevel++)
    {
        m_solutionRest[timeLevel] = SDCarray(m_QuadPts[timeLevel + 1]);
        m_residualRest[timeLevel] = SDCarray(m_QuadPts[timeLevel + 1]);
        m_integralRest[timeLevel] = SDCarray(m_QuadPts[timeLevel + 1]);
        m_correction[timeLevel]   = SDCarray(m_QuadPts[timeLevel + 1]);
        m_storage[timeLevel]      = SDCarray(m_QuadPts[timeLevel + 1]);
        for (size_t n = 0; n < m_QuadPts[timeLevel + 1]; ++n)
        {
            m_solutionRest[timeLevel][n] =
                Array<OneD, Array<OneD, NekDouble>>(m_nVar);
            m_residualRest[timeLevel][n] =
                Array<OneD, Array<OneD, NekDouble>>(m_nVar);
            m_integralRest[timeLevel][n] =
                Array<OneD, Array<OneD, NekDouble>>(m_nVar);
            m_correction[timeLevel][n] =
                Array<OneD, Array<OneD, NekDouble>>(m_nVar);
            m_storage[timeLevel][n] =
                Array<OneD, Array<OneD, NekDouble>>(m_nVar);
            for (size_t i = 0; i < m_nVar; ++i)
            {
                m_solutionRest[timeLevel][n][i] =
                    Array<OneD, NekDouble>(m_npts[timeLevel + 1], 0.0);
                m_residualRest[timeLevel][n][i] =
                    Array<OneD, NekDouble>(m_npts[timeLevel + 1], 0.0);
                m_integralRest[timeLevel][n][i] =
                    Array<OneD, NekDouble>(m_npts[timeLevel + 1], 0.0);
                m_correction[timeLevel][n][i] =
                    Array<OneD, NekDouble>(m_npts[timeLevel + 1], 0.0);
                m_storage[timeLevel][n][i] =
                    Array<OneD, NekDouble>(m_npts[timeLevel], 0.0);
            }
        }
    }
}

References ASSERTL0, m_correction, Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_integralRest, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nTimeLevel, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_QuadPts, m_residualRest, m_SDCSolver, m_solutionRest, m_storage, and Nektar::SolverUtils::DriverParallelInTime::m_timestep.

Referenced by v_InitObject().

◆ IntegratedResidualEval()

void Nektar::SolverUtils::DriverPFASST::IntegratedResidualEval ( const size_t timeLevel )

private

Definition at line 541 of file DriverPFASST.cpp.

{
    m_SDCSolver[timeLevel]->UpdateIntegratedResidualQFint(m_chunkTime);
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkTime, and m_SDCSolver.

Referenced by v_Execute().

◆ Interpolate() [1/2]

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
	)

private

Definition at line 116 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
        {
            // Assign memory for coefficient space.
            Array<OneD, NekDouble> incoeff(infield[n]->GetNcoeffs());
 
            // Transform solution from physical to coefficient space.
            infield[n]->FwdTransLocalElmt(inphys, incoeff);
 
            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]->GetCoeff_Offset(i);
                size_t outoffset = outfield[n]->GetPhys_Offset(i);
 
                // Interpolate elements.
                Array<OneD, NekDouble> tmp;
                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()));
                }
                expPtr->BwdTrans(incoeff + inoffset, tmp = outphys + outoffset);
            }
        }
    }
}

◆ Interpolate() [2/2]

void Nektar::SolverUtils::DriverPFASST::Interpolate	(	const size_t	coarseLevel,
		const SDCarray &	in,
		const size_t	fineLevel,
		SDCarray &	out,
		bool	forced
	)

private

Definition at line 549 of file DriverPFASST.cpp.

{
    // Interpolate solution in space.
    for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
    {
        Interpolate(m_EqSys[coarseLevel]->UpdateFields(),
                    m_EqSys[fineLevel]->UpdateFields(), in[n],
                    m_storage[fineLevel][n]);
    }
 
    // Interpolate solution in time.
    for (size_t n = 0; n < m_QuadPts[fineLevel]; ++n)
    {
        if (forced || IsNotInitialCondition(n))
        {
            for (size_t i = 0; i < m_nVar; ++i)
            {
                Vmath::Smul(m_npts[fineLevel], m_ImatCtoF[fineLevel][n],
                            m_storage[fineLevel][0][i], 1, out[n][i], 1);
                for (size_t k = 1; k < m_QuadPts[coarseLevel]; ++k)
                {
                    size_t index = k * m_QuadPts[fineLevel] + n;
                    Vmath::Svtvp(m_npts[fineLevel],
                                 m_ImatCtoF[fineLevel][index],
                                 m_storage[fineLevel][k][i], 1, out[n][i], 1,
                                 out[n][i], 1);
                }
            }
        }
    }
}

References Interpolate(), IsNotInitialCondition(), Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_ImatCtoF, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_QuadPts, m_storage, Vmath::Smul(), and Vmath::Svtvp().

Referenced by ApplyWindowing(), Correct(), Interpolate(), InterpolateResidual(), InterpolateSolution(), and Restrict().

◆ InterpolateResidual()

void Nektar::SolverUtils::DriverPFASST::InterpolateResidual ( const size_t timeLevel )

private

Definition at line 599 of file DriverPFASST.cpp.

{
    size_t coarseLevel = timeLevel;
    size_t fineLevel   = timeLevel - 1;
 
    Interpolate(coarseLevel, m_SDCSolver[coarseLevel]->GetResidualVector(),
                fineLevel, m_SDCSolver[fineLevel]->UpdateResidualVector(),
                true);
}

References Interpolate(), and m_SDCSolver.

Referenced by v_Execute().

◆ InterpolateSolution()

void Nektar::SolverUtils::DriverPFASST::InterpolateSolution ( const size_t timeLevel )

private

Definition at line 586 of file DriverPFASST.cpp.

{
    size_t coarseLevel = timeLevel;
    size_t fineLevel   = timeLevel - 1;
 
    Interpolate(coarseLevel, m_SDCSolver[coarseLevel]->GetSolutionVector(),
                fineLevel, m_SDCSolver[fineLevel]->UpdateSolutionVector(),
                false);
}

References Interpolate(), and m_SDCSolver.

Referenced by v_Execute().

◆ IsNotInitialCondition()

bool Nektar::SolverUtils::DriverPFASST::IsNotInitialCondition ( const size_t n )

private

Definition at line 457 of file DriverPFASST.cpp.

{
    return !(n == 0 && m_chunkRank == 0);
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkRank.

Referenced by Correct(), and Interpolate().

◆ PropagateQuadratureSolutionAndResidual()

void Nektar::SolverUtils::DriverPFASST::PropagateQuadratureSolutionAndResidual	(	const size_t	timeLevel,
		const size_t	index
	)

private

Definition at line 465 of file DriverPFASST.cpp.

{
    for (size_t n = 0; n < m_QuadPts[timeLevel]; ++n)
    {
        if (n != index)
        {
            for (size_t i = 0; i < m_nVar; ++i)
            {
                Vmath::Vcopy(
                    m_npts[timeLevel],
                    m_SDCSolver[timeLevel]->GetSolutionVector()[index][i], 1,
                    m_SDCSolver[timeLevel]->UpdateSolutionVector()[n][i], 1);
                Vmath::Vcopy(
                    m_npts[timeLevel],
                    m_SDCSolver[timeLevel]->GetResidualVector()[index][i], 1,
                    m_SDCSolver[timeLevel]->UpdateResidualVector()[n][i], 1);
            }
        }
    }
}

References Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_QuadPts, m_SDCSolver, and Vmath::Vcopy().

Referenced by v_Execute().

◆ ResidualEval() [1/2]

void Nektar::SolverUtils::DriverPFASST::ResidualEval	(	const NekDouble	time,
		const size_t	timeLevel
	)

private

Definition at line 532 of file DriverPFASST.cpp.

{
    m_SDCSolver[timeLevel]->SetTime(time);
    m_SDCSolver[timeLevel]->ResidualEval(m_chunkTime);
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkTime, and m_SDCSolver.

◆ ResidualEval() [2/2]

void Nektar::SolverUtils::DriverPFASST::ResidualEval	(	const NekDouble	time,
		const size_t	timeLevel,
		const size_t	n
	)

private

Definition at line 522 of file DriverPFASST.cpp.

{
    m_SDCSolver[timeLevel]->SetTime(time);
    m_SDCSolver[timeLevel]->ResidualEval(m_chunkTime, n);
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkTime, and m_SDCSolver.

Referenced by CorrectResidual(), RestrictResidual(), RunSweep(), and v_Execute().

◆ Restrict()

void Nektar::SolverUtils::DriverPFASST::Restrict	(	const size_t	fineLevel,
		const SDCarray &	in,
		const size_t	coarseLevel,
		SDCarray &	out
	)

private

Definition at line 612 of file DriverPFASST.cpp.

{
    // Restrict fine solution in time.
    for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
    {
        for (size_t i = 0; i < m_nVar; ++i)
        {
            Vmath::Smul(m_npts[fineLevel], m_ImatFtoC[fineLevel][n], in[0][i],
                        1, m_storage[fineLevel][n][i], 1);
            for (size_t k = 1; k < m_QuadPts[fineLevel]; ++k)
            {
                size_t index = k * m_QuadPts[coarseLevel] + n;
                Vmath::Svtvp(m_npts[fineLevel], m_ImatFtoC[fineLevel][index],
                             in[k][i], 1, m_storage[fineLevel][n][i], 1,
                             m_storage[fineLevel][n][i], 1);
            }
        }
    }
 
    // Restrict fine solution in space.
    for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
    {
        Interpolate(m_EqSys[fineLevel]->UpdateFields(),
                    m_EqSys[coarseLevel]->UpdateFields(),
                    m_storage[fineLevel][n], out[n]);
    }
}

References Interpolate(), Nektar::SolverUtils::DriverParallelInTime::m_EqSys, m_ImatFtoC, Nektar::SolverUtils::DriverParallelInTime::m_npts, Nektar::SolverUtils::DriverParallelInTime::m_nVar, m_QuadPts, m_storage, Vmath::Smul(), and Vmath::Svtvp().

Referenced by ComputeFASCorrection(), and RestrictSolution().

◆ RestrictResidual()

void Nektar::SolverUtils::DriverPFASST::RestrictResidual ( const size_t timeLevel )

private

Definition at line 662 of file DriverPFASST.cpp.

{
    size_t fineLevel   = timeLevel;
    size_t coarseLevel = timeLevel + 1;
 
    ResidualEval(m_time, coarseLevel);
 
    if (!m_updateResidual)
    {
        for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
        {
            CopySolutionVector(m_SDCSolver[coarseLevel]->GetResidualVector()[n],
                               m_residualRest[fineLevel][n]);
        }
    }
}

References Nektar::SolverUtils::DriverParallelInTime::CopySolutionVector(), m_QuadPts, m_residualRest, m_SDCSolver, Nektar::SolverUtils::DriverParallelInTime::m_time, m_updateResidual, and ResidualEval().

Referenced by v_Execute().

◆ RestrictSolution()

void Nektar::SolverUtils::DriverPFASST::RestrictSolution ( const size_t timeLevel )

private

Definition at line 644 of file DriverPFASST.cpp.

{
    size_t fineLevel   = timeLevel;
    size_t coarseLevel = timeLevel + 1;
 
    Restrict(fineLevel, m_SDCSolver[fineLevel]->GetSolutionVector(),
             coarseLevel, m_SDCSolver[coarseLevel]->UpdateSolutionVector());
 
    for (size_t n = 0; n < m_QuadPts[coarseLevel]; ++n)
    {
        CopySolutionVector(m_SDCSolver[coarseLevel]->GetSolutionVector()[n],
                           m_solutionRest[fineLevel][n]);
    }
}

References Nektar::SolverUtils::DriverParallelInTime::CopySolutionVector(), m_QuadPts, m_SDCSolver, m_solutionRest, and Restrict().

Referenced by v_Execute().

◆ RunSweep()

void Nektar::SolverUtils::DriverPFASST::RunSweep	(	const NekDouble	time,
		const size_t	timeLevel,
		const bool	update = `false`
	)

private

Definition at line 498 of file DriverPFASST.cpp.

{
    size_t niter = m_SDCSolver[timeLevel]->GetOrder();
 
    if (update == true)
    {
        ResidualEval(m_time, timeLevel, 0);
    }
 
    // Start SDC iteration loop.
    m_SDCSolver[timeLevel]->SetTime(time);
    for (size_t k = 0; k < niter; k++)
    {
        m_SDCSolver[timeLevel]->SDCIterationLoop(m_chunkTime);
    }
 
    // Update last quadrature point.
    m_SDCSolver[timeLevel]->UpdateLastQuadrature();
}

References Nektar::SolverUtils::DriverParallelInTime::m_chunkTime, m_SDCSolver, Nektar::SolverUtils::DriverParallelInTime::m_time, and ResidualEval().

Referenced by v_Execute().

◆ SetTimeInterpolator()

void Nektar::SolverUtils::DriverPFASST::SetTimeInterpolator ( void )

private

Definition at line 396 of file DriverPFASST.cpp.

{
    // Initialize time interpolator.
    m_ImatFtoC = Array<OneD, Array<OneD, NekDouble>>(m_nTimeLevel - 1);
    m_ImatCtoF = Array<OneD, Array<OneD, NekDouble>>(m_nTimeLevel - 1);
    for (size_t timeLevel = 0; timeLevel < m_nTimeLevel - 1; timeLevel++)
    {
        LibUtilities::PointsKey fpoints =
            m_SDCSolver[timeLevel]->GetPointsKey();
        LibUtilities::PointsKey cpoints =
            m_SDCSolver[timeLevel + 1]->GetPointsKey();
        DNekMatSharedPtr ImatFtoC =
            LibUtilities::PointsManager()[fpoints]->GetI(cpoints);
        DNekMatSharedPtr ImatCtoF =
            LibUtilities::PointsManager()[cpoints]->GetI(fpoints);
        m_ImatFtoC[timeLevel] = Array<OneD, NekDouble>(
            m_QuadPts[timeLevel] * m_QuadPts[timeLevel + 1], 0.0);
        m_ImatCtoF[timeLevel] = Array<OneD, NekDouble>(
            m_QuadPts[timeLevel] * m_QuadPts[timeLevel + 1], 0.0);
 
        // Determine if Radau quadrature are used.
        size_t i0 = m_SDCSolver[timeLevel]->HasFirstQuadrature() ? 0 : 1;
        size_t j0 = m_SDCSolver[timeLevel + 1]->HasFirstQuadrature() ? 0 : 1;
 
        // Adapt fine to coarse time interpolator.
        for (size_t i = i0; i < m_QuadPts[timeLevel]; ++i)
        {
            for (size_t j = j0; j < m_QuadPts[timeLevel + 1]; ++j)
            {
                m_ImatFtoC[timeLevel][i * m_QuadPts[timeLevel + 1] + j] =
                    (ImatFtoC->GetPtr())[(i - i0) *
                                             (m_QuadPts[timeLevel + 1] - j0) +
                                         (j - j0)];
            }
        }
        if (j0 == 1)
        {
            m_ImatFtoC[timeLevel][0] = 1.0;
        }
 
        // Adapt coarse to fine time interpolator.
        for (size_t j = j0; j < m_QuadPts[timeLevel + 1]; ++j)
        {
            for (size_t i = i0; i < m_QuadPts[timeLevel]; ++i)
            {
                m_ImatCtoF[timeLevel][j * m_QuadPts[timeLevel] + i] =
                    (ImatCtoF
                         ->GetPtr())[(j - j0) * (m_QuadPts[timeLevel] - i0) +
                                     (i - i0)];
            }
        }
        if (i0 == 1)
        {
            m_ImatCtoF[timeLevel][0] = 1.0;
        }
    }
}

References m_ImatCtoF, m_ImatFtoC, Nektar::SolverUtils::DriverParallelInTime::m_nTimeLevel, m_QuadPts, m_SDCSolver, and Nektar::LibUtilities::PointsManager().

Referenced by v_InitObject().

◆ UpdateFirstQuadrature()

void Nektar::SolverUtils::DriverPFASST::UpdateFirstQuadrature ( const size_t timeLevel )

private

Definition at line 490 of file DriverPFASST.cpp.

{
    m_SDCSolver[timeLevel]->UpdateFirstQuadrature();
}

References m_SDCSolver.

Referenced by ApplyWindowing(), and v_Execute().

◆ v_Execute()

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

overrideprotectedvirtual

Virtual function for solve implementation.

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 74 of file DriverPFASST.cpp.

{
    // Timing.
    Nektar::LibUtilities::Timer timer;
    NekDouble totalTime = 0.0, predictorTime = 0.0, fineSolveTime = 0.0,
              coarseSolveTime = 0.0, fasTime = 0.0;
 
    // Initialie time step parameters.
    size_t step     = m_chunkRank;
    m_totalTime     = m_timestep[0] * m_nsteps[0];
    m_numWindowsPIT = m_nsteps[0] / m_numChunks;
    m_chunkTime     = m_timestep[0];
 
    // Start iteration windows.
    m_comm->GetTimeComm()->Block();
    for (size_t w = 0; w < m_numWindowsPIT; w++)
    {
        timer.Start();
        PrintHeader((boost::format("WINDOWS #%1%") % (w + 1)).str(), '*');
 
        // Compute initial guess for coarse solver.
        m_time = (w * m_numChunks) * m_chunkTime;
        ResidualEval(m_time, m_nTimeLevel - 1, 0);
        PropagateQuadratureSolutionAndResidual(m_nTimeLevel - 1, 0);
        for (size_t k = 0; k < m_chunkRank; k++)
        {
            RunSweep(m_time, m_nTimeLevel - 1);
            UpdateFirstQuadrature(m_nTimeLevel - 1);
            PropagateQuadratureSolutionAndResidual(m_nTimeLevel - 1, 0);
            m_time += m_chunkTime;
        }
        RunSweep(m_time, m_nTimeLevel - 1);
 
        // Interpolate coarse solution and residual to fine.
        for (size_t timeLevel = m_nTimeLevel - 1; timeLevel > 0; timeLevel--)
        {
            InterpolateSolution(timeLevel);
            InterpolateResidual(timeLevel);
        }
        timer.Stop();
        predictorTime += timer.Elapsed().count();
        totalTime += timer.Elapsed().count();
 
        // Start CorrectInitialPFASST iteration.
        size_t k            = 0;
        int convergenceCurr = 0;
        std::vector<int> convergencePrev(m_nTimeLevel, m_chunkRank == 0);
        while (k < m_iterMaxPIT && !convergenceCurr)
        {
            // The PFASST implementation follow "Bolten, M., Moser, D., & Speck,
            // R. (2017). A multigrid perspective on the parallel full
            // approximation scheme in space and time. Numerical Linear Algebra
            // with Applications, 24(6)".
 
            if (m_chunkRank == m_numChunks - 1 &&
                m_comm->GetSpaceComm()->GetRank() == 0)
            {
                std::cout << "Iteration " << k + 1 << std::endl << std::flush;
            }
 
            // Performe sweep (parallel-in-time).
            timer.Start();
            RunSweep(m_time, 0, true);
            timer.Stop();
            fineSolveTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
 
            // Fine-to-coarse
            timer.Start();
            for (size_t timeLevel = 0; timeLevel < m_nTimeLevel - 1;
                 timeLevel++)
            {
                // Performe sweep (parallel-in-time).
                if (timeLevel != 0)
                {
                    RunSweep(m_time, timeLevel, true);
                }
 
                // Compute FAS correction (parallel-in-time).
                RestrictSolution(timeLevel);
                RestrictResidual(timeLevel);
                IntegratedResidualEval(timeLevel);
                IntegratedResidualEval(timeLevel + 1);
                ComputeFASCorrection(timeLevel + 1);
 
                // Check convergence.
                if (timeLevel == 0)
                {
                    // Evaluate SDC residual norm.
                    EvaluateSDCResidualNorm(timeLevel);
 
                    // Display L2norm.
                    PrintErrorNorm(timeLevel, true);
                }
            }
            timer.Stop();
            fasTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
 
            // Perform coarse sweep (serial-in-time).
            timer.Start();
            RecvFromPreviousProc(m_SDCSolver[m_nTimeLevel - 1]
                                     ->UpdateFirstQuadratureSolutionVector(),
                                 convergencePrev[m_nTimeLevel - 1]);
            timer.Stop();
            totalTime += timer.Elapsed().count();
            timer.Start();
            RunSweep(m_time, m_nTimeLevel - 1, true);
            timer.Stop();
            coarseSolveTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
            convergenceCurr = (vL2ErrorMax() < m_tolerPIT &&
                               convergencePrev[m_nTimeLevel - 1]);
            timer.Start();
            SendToNextProc(m_SDCSolver[m_nTimeLevel - 1]
                               ->UpdateLastQuadratureSolutionVector(),
                           convergenceCurr);
            timer.Stop();
            totalTime += timer.Elapsed().count();
 
            // Coarse-to-fine.
            timer.Start();
            for (size_t timeLevel = m_nTimeLevel - 1; timeLevel > 0;
                 timeLevel--)
            {
                // Correct solution and residual.
                /*SendToNextProc(m_SDCSolver[timeLevel - 1]
                                   ->UpdateLastQuadratureSolutionVector(),
                               convergenceCurr);*/
                CorrectSolution(timeLevel - 1);
                CorrectResidual(timeLevel - 1);
                /*RecvFromPreviousProc(
                    m_SDCSolver[timeLevel - 1]
                        ->UpdateFirstQuadratureSolutionVector(),
                    convergencePrev[timeLevel - 1]);
                CorrectInitialSolution(timeLevel - 1);*/
                if (timeLevel - 1 != 0)
                {
                    RunSweep(m_time, timeLevel - 1, true);
                }
            }
            timer.Stop();
            fasTime += timer.Elapsed().count();
            totalTime += timer.Elapsed().count();
            k++;
        }
 
        // Apply windowing.
        timer.Start();
        if (w < m_numWindowsPIT - 1)
        {
            ApplyWindowing();
        }
        timer.Stop();
        totalTime += timer.Elapsed().count();
 
        // Update field and write output.
        WriteOutput(step, m_time);
        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 << " - FAS Correction Time = " << fasTime << "s"
                      << std::endl
                      << std::flush;
        }
        step += m_numChunks;
    }
 
    m_comm->GetTimeComm()->Block();
    PrintHeader("SUMMARY", '*');
    EvaluateExactSolution(0, m_time + m_chunkTime);
    SolutionConvergenceSummary(0);
    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 << " - FAS Correction Time = " << fasTime << "s" << std::endl
                  << std::flush;
    }
}

◆ v_InitObject()

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

overrideprotectedvirtual

Virtual function for initialisation implementation.

Reimplemented from Nektar::SolverUtils::DriverParallelInTime.

Definition at line 61 of file DriverPFASST.cpp.

{
    DriverParallelInTime::v_InitObject(out);
    DriverParallelInTime::GetParametersFromSession();
    DriverParallelInTime::PrintSolverInfo(out);
    DriverParallelInTime::InitialiseEqSystem(true);
    InitialiseSDCScheme();
    SetTimeInterpolator();
}

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

◆ WriteOutput()

void Nektar::SolverUtils::DriverPFASST::WriteOutput	(	const size_t	step,
		const NekDouble	time
	)

private

Definition at line 943 of file DriverPFASST.cpp.

{
    size_t timeLevel           = 0;
    static size_t IOChkStep    = m_EqSys[0]->GetCheckpointSteps()
                                     ? m_EqSys[0]->GetCheckpointSteps()
                                     : m_nsteps[timeLevel];
    static std::string dirname = m_session->GetSessionName() + ".pit";
 
    if ((step + 1) % IOChkStep == 0)
    {
        // Compute checkpoint index.
        size_t nchk = (step + 1) / IOChkStep;
 
        // Create directory if does not exist.
        if (!fs::is_directory(dirname))
        {
            fs::create_directory(dirname);
        }
 
        // Update solution field.
        UpdateFieldCoeffs(
            timeLevel,
            m_SDCSolver[timeLevel]->UpdateLastQuadratureSolutionVector());
 
        // Set filename.
        std::string filename = dirname + "/" + m_session->GetSessionName() +
                               "_" + std::to_string(nchk) + ".fld";
 
        // Set time metadata.
        m_EqSys[timeLevel]->SetTime(time);
 
        // Write checkpoint.
        m_EqSys[timeLevel]->WriteFld(filename);
    }
}

References Nektar::SolverUtils::DriverParallelInTime::m_EqSys, Nektar::SolverUtils::DriverParallelInTime::m_nsteps, m_SDCSolver, Nektar::SolverUtils::Driver::m_session, and Nektar::SolverUtils::DriverParallelInTime::UpdateFieldCoeffs().

Referenced by v_Execute().

Friends And Related Function Documentation

◆ MemoryManager< DriverPFASST >

friend class MemoryManager< DriverPFASST >

friend

Definition at line 45 of file DriverPFASST.h.

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::DriverPFASST::className

static

Initial value:

=

GetDriverFactory().RegisterCreatorFunction("PFASST", DriverPFASST::create)

Nektar::LibUtilities::NekFactory::RegisterCreatorFunction

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

Register a class with the factory.

Definition: NekFactory.hpp:197

Nektar::SolverUtils::DriverPFASST::create

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

Creates an instance of this class.

Definition: DriverPFASST.h:54

Nektar::SolverUtils::GetDriverFactory

DriverFactory & GetDriverFactory()

Definition: Driver.cpp:65

Name of the class.

Definition at line 65 of file DriverPFASST.h.

◆ driverLookupId

std::string Nektar::SolverUtils::DriverPFASST::driverLookupId

staticprotected

Initial value:

=

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

Nektar::LibUtilities::SessionReader::RegisterEnumValue

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

Registers an enumeration value.

Definition: SessionReader.h:559

Definition at line 83 of file DriverPFASST.h.

◆ m_correction

Array<OneD, SDCarray> Nektar::SolverUtils::DriverPFASST::m_correction

private

Definition at line 157 of file DriverPFASST.h.

Referenced by Correct(), and InitialiseSDCScheme().

◆ m_ImatCtoF

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverPFASST::m_ImatCtoF

private

Definition at line 153 of file DriverPFASST.h.

Referenced by Correct(), Interpolate(), and SetTimeInterpolator().

◆ m_ImatFtoC

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::DriverPFASST::m_ImatFtoC

private

Definition at line 152 of file DriverPFASST.h.

Referenced by Restrict(), and SetTimeInterpolator().

◆ m_integralRest

Array<OneD, SDCarray> Nektar::SolverUtils::DriverPFASST::m_integralRest

private

Definition at line 156 of file DriverPFASST.h.

Referenced by ComputeFASCorrection(), and InitialiseSDCScheme().

◆ m_QuadPts

Array<OneD, size_t> Nektar::SolverUtils::DriverPFASST::m_QuadPts

private

Definition at line 151 of file DriverPFASST.h.

Referenced by ComputeFASCorrection(), Correct(), CorrectResidual(), EvaluateSDCResidualNorm(), InitialiseSDCScheme(), Interpolate(), PropagateQuadratureSolutionAndResidual(), Restrict(), RestrictResidual(), RestrictSolution(), and SetTimeInterpolator().

◆ m_residualRest

Array<OneD, SDCarray> Nektar::SolverUtils::DriverPFASST::m_residualRest

private

Definition at line 155 of file DriverPFASST.h.

Referenced by CorrectResidual(), InitialiseSDCScheme(), and RestrictResidual().

◆ m_SDCSolver

Array<OneD, std::shared_ptr<LibUtilities::TimeIntegrationSchemeSDC> > Nektar::SolverUtils::DriverPFASST::m_SDCSolver

private

◆ m_solutionRest

Array<OneD, SDCarray> Nektar::SolverUtils::DriverPFASST::m_solutionRest

private

Definition at line 154 of file DriverPFASST.h.

Referenced by CorrectSolution(), InitialiseSDCScheme(), and RestrictSolution().

◆ m_storage

Array<OneD, SDCarray> Nektar::SolverUtils::DriverPFASST::m_storage

private

Definition at line 158 of file DriverPFASST.h.

Referenced by Correct(), InitialiseSDCScheme(), Interpolate(), and Restrict().

◆ m_updateResidual

bool Nektar::SolverUtils::DriverPFASST::m_updateResidual = false

private

Definition at line 162 of file DriverPFASST.h.

Referenced by CorrectResidual(), and RestrictResidual().

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DriverPFASST()

◆ ~DriverPFASST()

Member Function Documentation

◆ ApplyWindowing()

◆ AssertParameters()

◆ ComputeFASCorrection()

◆ Correct() [1/2]

◆ Correct() [2/2]

◆ CorrectInitialResidual()

◆ CorrectInitialSolution()

◆ CorrectResidual()

◆ CorrectSolution()

◆ create()

◆ EvaluateSDCResidualNorm()

◆ InitialiseSDCScheme()

◆ IntegratedResidualEval()

◆ Interpolate() [1/2]

◆ Interpolate() [2/2]

◆ InterpolateResidual()

◆ InterpolateSolution()

◆ IsNotInitialCondition()

◆ PropagateQuadratureSolutionAndResidual()

◆ ResidualEval() [1/2]

◆ ResidualEval() [2/2]

◆ Restrict()

◆ RestrictResidual()

◆ RestrictSolution()

◆ RunSweep()

◆ SetTimeInterpolator()

◆ UpdateFirstQuadrature()

◆ v_Execute()

◆ v_InitObject()

◆ WriteOutput()

Friends And Related Function Documentation

◆ MemoryManager< DriverPFASST >

Member Data Documentation

◆ className

◆ driverLookupId

◆ m_correction

◆ m_ImatCtoF

◆ m_ImatFtoC

◆ m_integralRest

◆ m_QuadPts

◆ m_residualRest

◆ m_SDCSolver

◆ m_solutionRest

◆ m_storage

◆ m_updateResidual