Functions
void	createSessionFile (boost::filesystem::path &ph)

void	setupContFieldSolve (boost::filesystem::path &ph, LibUtilities::SessionReaderSharedPtr &Session, MultiRegions::ContFieldSharedPtr &Exp, MultiRegions::ContFieldSharedPtr &Fce)

	BOOST_AUTO_TEST_CASE (TestVarcoeffHashing)

	BOOST_AUTO_TEST_CASE (TestUnsetGlobalLinSys)

Variables
boost::filesystem::path	pathGlobal

LibUtilities::SessionReaderSharedPtr	lsession

MultiRegions::ContFieldSharedPtr	contfield

MultiRegions::ContFieldSharedPtr	forcefield

StdRegions::ConstFactorMap	factors

StdRegions::VarCoeffMap	varcoeffs1

StdRegions::VarCoeffMap	varcoeffs2

static const std::string	sessionfile

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/2]

Nektar::VarcoeffHashingTest::BOOST_AUTO_TEST_CASE ( TestUnsetGlobalLinSys )

Definition at line 297 of file TestVarcoeffHashing.cpp.

{
    // Check that the test setup is clear i.e. count == 0
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 0);
 
    // Create 1st GlobalLinSys
    auto gkey1 = contfield->LinearAdvectionDiffusionReactionSolve(
        forcefield->GetPhys(), contfield->UpdateCoeffs(), factors, varcoeffs1);
 
    // Check count == 1
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 1);
 
    // Create 2nd GlobalLinSys
    auto gkey2 = contfield->LinearAdvectionDiffusionReactionSolve(
        forcefield->GetPhys(), contfield->UpdateCoeffs(), factors, varcoeffs2);
 
    // Check count == 2
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 2);
 
    // Unset GlobalLinSys1
    contfield->UnsetGlobalLinSys(gkey1, true);
 
    // Check count == 1
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 1);
 
    // Unset GlobalLinSys2
    contfield->UnsetGlobalLinSys(gkey2, true);
 
    // Check count == 0
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 0);
 
    // Clear for next tests
    contfield->ClearGlobalLinSysManager();
}

References contfield, factors, forcefield, varcoeffs1, and varcoeffs2.

◆ BOOST_AUTO_TEST_CASE() [2/2]

Nektar::VarcoeffHashingTest::BOOST_AUTO_TEST_CASE ( TestVarcoeffHashing )

Definition at line 256 of file TestVarcoeffHashing.cpp.

{
    // Create session file and setup Contfield
    createSessionFile(pathGlobal);
    setupContFieldSolve(pathGlobal, lsession, contfield, forcefield);
 
    // Check no initial GlobalLinSys i.e. count == 0
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 0);
 
    // Create GlobalLinSys(varcoeff1)
    contfield->HelmSolve(forcefield->GetPhys(), contfield->UpdateCoeffs(),
                         factors, varcoeffs1);
 
    // Check count == 1
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 1);
 
    // Create new GlobalLinSys(varcoeff2)
    contfield->HelmSolve(forcefield->GetPhys(), contfield->UpdateCoeffs(),
                         factors, varcoeffs2);
 
    // Check count == 2
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 2);
 
    // Again use 2nd GlobalLinSys(varcoeff2)
    contfield->HelmSolve(forcefield->GetPhys(), contfield->UpdateCoeffs(),
                         factors, varcoeffs2);
 
    // Check count still == 2
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 2);
 
    // Again use 1st GlobalLinSys(varcoeff1)
    contfield->HelmSolve(forcefield->GetPhys(), contfield->UpdateCoeffs(),
                         factors, varcoeffs1);
 
    // Check count still == 2
    BOOST_CHECK_EQUAL(contfield->GetPoolCount("GlobalLinSys"), 2);
 
    // Clear for next tests
    contfield->ClearGlobalLinSysManager();
}

References contfield, createSessionFile(), factors, forcefield, lsession, pathGlobal, setupContFieldSolve(), varcoeffs1, and varcoeffs2.

◆ createSessionFile()

void Nektar::VarcoeffHashingTest::createSessionFile ( boost::filesystem::path & ph )

Definition at line 168 of file TestVarcoeffHashing.cpp.

{
    // Create temporary directory
    using namespace boost::filesystem;
    ph = temp_directory_path() / unique_path();
    create_directories(ph);
 
    // Create file in working directory
    ph /= "TestVarcoeffHashing.xml"; // append filename
    boost::filesystem::ofstream sfile(ph);
    sfile << sessionfile;
    sfile.close();
}

References sessionfile.

Referenced by BOOST_AUTO_TEST_CASE().

◆ setupContFieldSolve()

void Nektar::VarcoeffHashingTest::setupContFieldSolve	(	boost::filesystem::path &	ph,
		LibUtilities::SessionReaderSharedPtr &	Session,
		MultiRegions::ContFieldSharedPtr &	Exp,
		MultiRegions::ContFieldSharedPtr &	Fce
	)

Definition at line 187 of file TestVarcoeffHashing.cpp.

{
#ifdef _WIN32
    // Prepare input file name - convert wstring to string to support Windows
    const std::wstring input_file_wstr(ph.c_str());
    const std::string input_file_str(input_file_wstr.begin(),
                                     input_file_wstr.end());
    char *input_file = (char *)input_file_str.c_str();
#else
    char *input_file = (char *)ph.c_str();
#endif
 
    // Setup parameters for call to IncNavierStokesSolver
    int argc     = 2;
    char *argv[] = {(char *)("IncNavierStokesSolver"), input_file, nullptr};
 
    // Read Session, MeshGraph and create ContField
    Session = LibUtilities::SessionReader::CreateInstance(argc, argv);
    SpatialDomains::MeshGraphSharedPtr Graph =
        SpatialDomains::MeshGraph::Read(Session);
    Exp = MemoryManager<MultiRegions::ContField>::AllocateSharedPtr(
        Session, Graph, Session->GetVariable(0));
    Fce = MemoryManager<MultiRegions::ContField>::AllocateSharedPtr(*Exp);
 
    // Read functons for varcoeffs and Forcing
    LibUtilities::EquationSharedPtr d00func  = Session->GetFunction("d00", 0);
    LibUtilities::EquationSharedPtr d00Bfunc = Session->GetFunction("d00B", 0);
    LibUtilities::EquationSharedPtr ffunc = Session->GetFunction("Forcing", 0);
 
    // Get coordinates to evaluate functions
    unsigned int npoints = Exp->GetNpoints();
    unsigned int coordim = Exp->GetCoordim(0);
    Array<OneD, NekDouble> x0(npoints), x1(npoints), x2(npoints);
    Array<OneD, NekDouble> d00(npoints, 0.0), d00B(npoints, 0.0),
        fcePhys(npoints);
 
    // Define lambda
    factors[StdRegions::eFactorLambda] = Session->GetParameter("lambda");
    Exp->GetCoords(x0, x1, x2);
 
    // Define 1st varcoeff
    d00func->Evaluate(x0, x1, x2, d00);
    varcoeffs1[StdRegions::eVarCoeffD00] = d00;
 
    // Define 2nd varcoeff
    d00Bfunc->Evaluate(x0, x1, x2, d00B);
    varcoeffs2[StdRegions::eVarCoeffD00] = d00B;
 
    // Define Forcing
    ffunc->Evaluate(x0, x1, x2, fcePhys);
    Fce->SetPhys(fcePhys);
 
    // Define Advection velocities and add to varcoeff1 or 2
    StdRegions::VarCoeffType varcoefftypes[] = {StdRegions::eVarCoeffVelX,
                                                StdRegions::eVarCoeffVelY,
                                                StdRegions::eVarCoeffVelZ};
    for (int i = 0; i < coordim; i++)
    {
        varcoeffs1[varcoefftypes[i]] = Array<OneD, NekDouble>(npoints, 0.1);
        varcoeffs2[varcoefftypes[i]] = Array<OneD, NekDouble>(npoints, 0.2);
    }
 
    // Clear solution
    Vmath::Zero(Exp->GetNcoeffs(), Exp->UpdateCoeffs(), 1);
}