Diffusion Class Reference

Public Member Functions
	Diffusion (int argc, char *argv[])
	~Diffusion ()
void	TimeIntegrate ()
void	DoImplicitSolve (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const NekDouble lambda)

Private Member Functions
void	WriteSolution ()
void	ExactSolution ()

Private Attributes
LibUtilities::SessionReaderSharedPtr	session
LibUtilities::FieldIOSharedPtr	fld
string	sessionName
SpatialDomains::MeshGraphSharedPtr	graph
MultiRegions::ContFieldSharedPtr	field
LibUtilities::TimeIntegrationSchemeSharedPtr	intScheme
LibUtilities::TimeIntegrationSchemeOperators	ode
Array< OneD, Array< OneD, NekDouble > >	fields
LibUtilities::TimeIntScheme	timeInt
unsigned int	nSteps
NekDouble	delta_t
NekDouble	epsilon
NekDouble	lambda

Detailed Description

Definition at line 48 of file DiffusionSolverTimeInt.cpp.

Constructor & Destructor Documentation

Diffusion()

Diffusion::Diffusion	(	int	argc,
		char *	argv[]
	)

Definition at line 82 of file DiffusionSolverTimeInt.cpp.

{
    // Create session reader.
    session = LibUtilities::SessionReader::CreateInstance(argc, argv);
 
    // Read the geometry and the expansion information
    graph = SpatialDomains::MeshGraphIO::Read(session);
 
    // Create Field I/O object.
    fld = LibUtilities::FieldIO::CreateDefault(session);
 
    // Get some information from the session
    sessionName = session->GetSessionName();
 
    // Create time integration scheme.
    if (session->DefinesTimeIntScheme())
    {
        timeInt = session->GetTimeIntScheme();
    }
    else
    {
        timeInt.method = session->GetSolverInfo("TimeIntegrationMethod");
    }
 
    nSteps  = session->GetParameter("NumSteps");
    delta_t = session->GetParameter("TimeStep");
    epsilon = session->GetParameter("epsilon");
    lambda  = 1.0 / delta_t / epsilon;
 
    // Set up the field
    field = MemoryManager<MultiRegions::ContField>::AllocateSharedPtr(
        session, graph, session->GetVariable(0));
 
    fields    = Array<OneD, Array<OneD, NekDouble>>(1);
    fields[0] = field->UpdatePhys();
 
    // Get coordinates of physical points
    unsigned int nq = field->GetNpoints();
    Array<OneD, NekDouble> x0(nq), x1(nq), x2(nq);
    field->GetCoords(x0, x1, x2);
 
    // Evaluate initial condition
    LibUtilities::EquationSharedPtr icond =
        session->GetFunction("InitialConditions", "u");
    icond->Evaluate(x0, x1, x2, 0.0, field->UpdatePhys());
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::LibUtilities::SessionReader::CreateInstance(), FilterPython_Function::field, and Nektar::SpatialDomains::MeshGraphIO::Read().

~Diffusion()

Diffusion::~Diffusion

(

)

Member Function Documentation

DoImplicitSolve()

void Diffusion::DoImplicitSolve	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray,
		const NekDouble	time,
		const NekDouble	lambda
	)

Definition at line 158 of file DiffusionSolverTimeInt.cpp.

{
    StdRegions::ConstFactorMap factors;
    factors[StdRegions::eFactorLambda] = 1.0 / lambda / epsilon;
 
    for (int i = 0; i < inarray.size(); ++i)
    {
        // Multiply RHS by 1.0/timestep/lambda
        Vmath::Smul(field->GetNpoints(), -factors[StdRegions::eFactorLambda],
                    inarray[i], 1, outarray[i], 1);
 
        // Solve a system of equations with Helmholtz solver
        field->HelmSolve(outarray[i], field->UpdateCoeffs(), factors);
 
        // Transform to physical space and store in solution vector
        field->BwdTrans(field->GetCoeffs(), outarray[i]);
    }
}

References Nektar::StdRegions::eFactorLambda, Nektar::VarcoeffHashingTest::factors, FilterPython_Function::field, and Vmath::Smul().

Referenced by TimeIntegrate().

ExactSolution()

void Diffusion::ExactSolution ( )

private

Definition at line 194 of file DiffusionSolverTimeInt.cpp.

{
    unsigned int nq = field->GetNpoints();
    Array<OneD, NekDouble> x0(nq), x1(nq), x2(nq);
    field->GetCoords(x0, x1, x2);
 
    LibUtilities::EquationSharedPtr ex_sol =
        session->GetFunction("ExactSolution", 0);
 
    if (ex_sol)
    {
        // evaluate exact solution
        Array<OneD, NekDouble> exact(nq);
        ex_sol->Evaluate(x0, x1, x2, (nSteps)*delta_t, exact);
 
        // Calculate errors
        cout << "L inf error:      " << field->Linf(field->GetPhys(), exact)
             << endl;
        cout << "L 2 error:        " << field->L2(field->GetPhys(), exact)
             << endl;
        cout << "H 1 error:        " << field->H1(field->GetPhys(), exact)
             << endl;
    }
}

References FilterPython_Function::field.

TimeIntegrate()

void Diffusion::TimeIntegrate

(

)

Definition at line 134 of file DiffusionSolverTimeInt.cpp.

{
    intScheme = LibUtilities::GetTimeIntegrationSchemeFactory().CreateInstance(
        timeInt.method, timeInt.variant, timeInt.order, timeInt.freeParams);
 
    ode.DefineImplicitSolve(&Diffusion::DoImplicitSolve, this);
 
    // Initialise the scheme for actual time integration scheme
    intScheme->InitializeScheme(delta_t, fields, 0.0, ode);
 
    // Zero field coefficients for initial guess for linear solver.
    Vmath::Zero(field->GetNcoeffs(), field->UpdateCoeffs(), 1);
 
    for (int n = 0; n < nSteps; ++n)
    {
        fields = intScheme->TimeIntegrate(n, delta_t);
    }
 
    Vmath::Vcopy(field->GetNpoints(), fields[0], 1, field->UpdatePhys(), 1);
 
    WriteSolution();
    ExactSolution();
}

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), DoImplicitSolve(), FilterPython_Function::field, Nektar::LibUtilities::GetTimeIntegrationSchemeFactory(), Vmath::Vcopy(), and Vmath::Zero().

WriteSolution()

void Diffusion::WriteSolution ( )

private

Definition at line 180 of file DiffusionSolverTimeInt.cpp.

{
    // Write solution to file
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
        field->GetFieldDefinitions();
    std::vector<std::vector<NekDouble>> FieldData(FieldDef.size());
    for (int i = 0; i < FieldDef.size(); ++i)
    {
        FieldDef[i]->m_fields.push_back("u");
        field->AppendFieldData(FieldDef[i], FieldData[i]);
    }
    fld->Write(session->GetSessionName() + ".fld", FieldDef, FieldData);
}

References FilterPython_Function::field.

Member Data Documentation

delta_t

NekDouble Diffusion::delta_t

private

Definition at line 74 of file DiffusionSolverTimeInt.cpp.

epsilon

NekDouble Diffusion::epsilon

private

Definition at line 75 of file DiffusionSolverTimeInt.cpp.

field

MultiRegions::ContFieldSharedPtr Diffusion::field

private

Definition at line 66 of file DiffusionSolverTimeInt.cpp.

Referenced by FilterPython_Class.TestVTKFilter::Initialise(), and FilterPython_Class.TestVTKFilter::Update().

fields

Array<OneD, Array<OneD, NekDouble> > Diffusion::fields

private

Definition at line 70 of file DiffusionSolverTimeInt.cpp.

fld

LibUtilities::FieldIOSharedPtr Diffusion::fld

private

Definition at line 63 of file DiffusionSolverTimeInt.cpp.

graph

SpatialDomains::MeshGraphSharedPtr Diffusion::graph

private

Definition at line 65 of file DiffusionSolverTimeInt.cpp.

intScheme

LibUtilities::TimeIntegrationSchemeSharedPtr Diffusion::intScheme

private

Definition at line 68 of file DiffusionSolverTimeInt.cpp.

lambda

NekDouble Diffusion::lambda

private

Definition at line 76 of file DiffusionSolverTimeInt.cpp.

nSteps

unsigned int Diffusion::nSteps

private

Definition at line 73 of file DiffusionSolverTimeInt.cpp.

ode

LibUtilities::TimeIntegrationSchemeOperators Diffusion::ode

private

Definition at line 69 of file DiffusionSolverTimeInt.cpp.

session

LibUtilities::SessionReaderSharedPtr Diffusion::session

private

Definition at line 62 of file DiffusionSolverTimeInt.cpp.

sessionName

string Diffusion::sessionName

private

Definition at line 64 of file DiffusionSolverTimeInt.cpp.

timeInt

LibUtilities::TimeIntScheme Diffusion::timeInt

private

Definition at line 72 of file DiffusionSolverTimeInt.cpp.