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 50 of file DiffusionSolverTimeInt.cpp.

Constructor & Destructor Documentation

Diffusion()

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

Definition at line 86 of file DiffusionSolverTimeInt.cpp.

{
    // Create session reader.
    session     = LibUtilities::SessionReader::CreateInstance(argc, argv);
 
    // Read the geometry and the expansion information
    graph       = SpatialDomains::MeshGraph::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());
}

~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 164 of file DiffusionSolverTimeInt.cpp.

{
    boost::ignore_unused(time);
 
    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, and Vmath::Smul().

Referenced by TimeIntegrate().

ExactSolution()

void Diffusion::ExactSolution ( )

private

Definition at line 207 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;
    }
 
}

TimeIntegrate()

void Diffusion::TimeIntegrate

(

)

Definition at line 138 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, ode );
    }
 
    Vmath::Vcopy(field->GetNpoints(), fields[0], 1, field->UpdatePhys(), 1);
 
    WriteSolution();
    ExactSolution();
}

References DoImplicitSolve(), Nektar::LibUtilities::GetTimeIntegrationSchemeFactory(), Vmath::Vcopy(), and Vmath::Zero().

WriteSolution()

void Diffusion::WriteSolution ( )

private

Definition at line 191 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);
 
}

Member Data Documentation

delta_t

NekDouble Diffusion::delta_t

private

Definition at line 77 of file DiffusionSolverTimeInt.cpp.

epsilon

NekDouble Diffusion::epsilon

private

Definition at line 78 of file DiffusionSolverTimeInt.cpp.

field

MultiRegions::ContFieldSharedPtr Diffusion::field

private

Definition at line 69 of file DiffusionSolverTimeInt.cpp.

fields

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

private

Definition at line 73 of file DiffusionSolverTimeInt.cpp.

fld

LibUtilities::FieldIOSharedPtr Diffusion::fld

private

Definition at line 66 of file DiffusionSolverTimeInt.cpp.

graph

SpatialDomains::MeshGraphSharedPtr Diffusion::graph

private

Definition at line 68 of file DiffusionSolverTimeInt.cpp.

intScheme

LibUtilities::TimeIntegrationSchemeSharedPtr Diffusion::intScheme

private

Definition at line 71 of file DiffusionSolverTimeInt.cpp.

lambda

NekDouble Diffusion::lambda

private

Definition at line 79 of file DiffusionSolverTimeInt.cpp.

nSteps

unsigned int Diffusion::nSteps

private

Definition at line 76 of file DiffusionSolverTimeInt.cpp.

ode

LibUtilities::TimeIntegrationSchemeOperators Diffusion::ode

private

Definition at line 72 of file DiffusionSolverTimeInt.cpp.

session

LibUtilities::SessionReaderSharedPtr Diffusion::session

private

Definition at line 65 of file DiffusionSolverTimeInt.cpp.

sessionName

string Diffusion::sessionName

private

Definition at line 67 of file DiffusionSolverTimeInt.cpp.

timeInt

LibUtilities::TimeIntScheme Diffusion::timeInt

private

Definition at line 75 of file DiffusionSolverTimeInt.cpp.