/**
* @brief Set up filter with output file and frequency parameters.
*
* @param pSession Current session.
* @param pParams Map of parameters defined in XML file.
*/
FilterEnergy1D::FilterEnergy1D(
const LibUtilities::SessionReaderSharedPtr &pSession,
const std::map<std::string, std::string> &pParams) :
Filter(pSession),
m_index(0)
{
std::string outName;
if (pParams.find("OutputFile") == pParams.end())
{
outName = m_session->GetSessionName();
}
else
{
ASSERTL0(!(pParams.find("OutputFile")->second.empty()),
"Missing parameter 'OutputFile'.");
outName = pParams.find("OutputFile")->second;
}
if (pParams.find("OutputFrequency") == pParams.end())
{
m_outputFrequency = 1;
}
else
{
m_outputFrequency =
atoi(pParams.find("OutputFrequency")->second.c_str());
}
outName += ".eny";
ASSERTL0(pSession->GetComm()->GetSize() == 1,
"The 1D energy filter currently only works in serial.");
m_out.open(outName.c_str());
}
/**
* @param pSession Session reader for IO
* @param pParams Parameters of filter
*/
FilterBenchmark::FilterBenchmark(
const LibUtilities::SessionReaderSharedPtr &pSession,
const std::map<std::string, std::string> &pParams)
: Filter(pSession)
{
ASSERTL0(pParams.find("ThresholdValue") != pParams.end(),
"Missing parameter 'ThresholdValue'.");
m_thresholdValue = atof(pParams.find("ThresholdValue")->second.c_str());
ASSERTL0(pParams.find("InitialValue") != pParams.end(),
"Missing parameter 'InitialValue'.");
m_initialValue = atof(pParams.find("InitialValue")->second.c_str());
ASSERTL0(!(pParams.find("OutputFile")->second.empty()),
"Missing parameter 'OutputFile'.");
m_outputFile = pParams.find("OutputFile")->second;
m_startTime = 0.0;
if (pParams.find("StartTime") != pParams.end())
{
m_startTime = atof(pParams.find("StartTime")->second.c_str());
}
m_fld = MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(
pSession->GetComm());
}
FilterEnergyBase::FilterEnergyBase(
const LibUtilities::SessionReaderSharedPtr &pSession,
const std::map<std::string, std::string> &pParams,
const bool pConstDensity)
: Filter (pSession),
m_index (-1),
m_homogeneous (false),
m_planes (),
m_constDensity(pConstDensity)
{
std::string outName;
if (pParams.find("OutputFile") == pParams.end())
{
outName = m_session->GetSessionName();
}
else
{
ASSERTL0(!(pParams.find("OutputFile")->second.empty()),
"Missing parameter 'OutputFile'.");
outName = pParams.find("OutputFile")->second;
}
m_comm = pSession->GetComm();
outName += ".eny";
if (m_comm->GetRank() == 0)
{
m_outFile.open(outName.c_str());
ASSERTL0(m_outFile.good(), "Unable to open: '" + outName + "'");
m_outFile.setf(ios::scientific, ios::floatfield);
m_outFile << "# Time Kinetic energy "
<< "Enstrophy"
<< endl
<< "# ---------------------------------------------"
<< "--------------"
<< endl;
}
pSession->LoadParameter("LZ", m_homogeneousLength, 0.0);
ASSERTL0(pParams.find("OutputFrequency") != pParams.end(),
"Missing parameter 'OutputFrequency'.");
m_outputFrequency = atoi(
pParams.find("OutputFrequency")->second.c_str());
}
Driver::Driver(const LibUtilities::SessionReaderSharedPtr pSession)
: m_comm(pSession->GetComm()),
m_session(pSession)
{
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession = LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
MultiRegions::ContField3DHomogeneous1DSharedPtr Exp_u, Exp_v, Exp_w;
StdRegions::ConstFactorMap factors;
FlagList flags;
if( (argc != 2) && (argc != 3))
{
fprintf(stderr,"Usage: Deriv3DHomo2D meshfile [SysSolnType] \n");
exit(1);
}
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph2D = MemoryManager<SpatialDomains::MeshGraph2D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int nzpoints;
NekDouble lz;
int FFT;
vSession->LoadParameter("HomModesZ", nzpoints);
vSession->LoadParameter("LZ", lz);
vSession->LoadParameter("USEFFT", FFT);
bool useFFT = false;
bool deal = false;
if(FFT==1){useFFT = true;}
const LibUtilities::PointsKey PkeyZ(nzpoints,LibUtilities::eFourierSingleModeSpaced);
const LibUtilities::BasisKey BkeyZ(LibUtilities::eFourierHalfModeRe,nzpoints,PkeyZ);
Exp_u = MemoryManager<MultiRegions::ContField3DHomogeneous1D>::AllocateSharedPtr(vSession,BkeyZ,lz,useFFT,deal,graph2D,vSession->GetVariable(0));
Exp_v = MemoryManager<MultiRegions::ContField3DHomogeneous1D>::AllocateSharedPtr(vSession,BkeyZ,lz,useFFT,deal,graph2D,vSession->GetVariable(1));
Exp_w = MemoryManager<MultiRegions::ContField3DHomogeneous1D>::AllocateSharedPtr(vSession,BkeyZ,lz,useFFT,deal,graph2D,vSession->GetVariable(2));
//----------------------------------------------
// Print summary of solution details
flags.set(eUseGlobal, false);
const SpatialDomains::ExpansionMap &expansions = graph2D->GetExpansions();
LibUtilities::BasisKey bkey0 = expansions.begin()->second->m_basisKeyVector[0];
cout << "Calculating Derivatives (Homogeneous in z-plane):" << endl;
cout << " Lz : " << lz << endl;
cout << " N.modes : " << bkey0.GetNumModes() << endl;
cout << " N.Z h**o modes : " << BkeyZ.GetNumModes() << endl;
cout << endl;
//----------------------------------------------
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
int nq = Exp_u->GetTotPoints();
Array<OneD,NekDouble> xc0,xc1,xc2;
xc0 = Array<OneD,NekDouble>(nq,0.0);
xc1 = Array<OneD,NekDouble>(nq,0.0);
xc2 = Array<OneD,NekDouble>(nq,0.0);
Exp_u->GetCoords(xc0,xc1,xc2);
//----------------------------------------------
Array<OneD,NekDouble> dudx,dvdy,dwdz;
Array<OneD,NekDouble> dump;
dump = Array<OneD,NekDouble>(nq,0.0);
dudx = Array<OneD,NekDouble>(nq,0.0);
dvdy = Array<OneD,NekDouble>(nq,0.0);
dwdz = Array<OneD,NekDouble>(nq,0.0);
//----------------------------------------------
// Define initial fields
LibUtilities::EquationSharedPtr ffunc_u = vSession->GetFunction("InitialCondition", 0);
LibUtilities::EquationSharedPtr ffunc_v = vSession->GetFunction("InitialCondition", 1);
LibUtilities::EquationSharedPtr ffunc_w = vSession->GetFunction("InitialCondition", 2);
LibUtilities::EquationSharedPtr exac_u = vSession->GetFunction("ExactSolution", 0);
LibUtilities::EquationSharedPtr exac_v = vSession->GetFunction("ExactSolution", 1);
LibUtilities::EquationSharedPtr exac_w = vSession->GetFunction("ExactSolution", 2);
ffunc_u->Evaluate(xc0,xc1,xc2,Exp_u->UpdatePhys());
ffunc_v->Evaluate(xc0,xc1,xc2,Exp_v->UpdatePhys());
ffunc_w->Evaluate(xc0,xc1,xc2,Exp_w->UpdatePhys());
exac_u->Evaluate(xc0,xc1,xc2,dudx);
exac_v->Evaluate(xc0,xc1,xc2,dvdy);
exac_w->Evaluate(xc0,xc1,xc2,dwdz);
//----------------------------------------------
//Taking derivative and printing the error
cout << "Deriv u" << endl;
Exp_u->PhysDeriv(Exp_u->GetPhys(),Exp_u->UpdatePhys(),dump,dump);
cout << "Deriv u done" << endl;
cout << "L infinity error: " << Exp_u->Linf(Exp_u->GetPhys(), dudx) << endl;
cout << "L 2 error : " << Exp_u->L2 (Exp_u->GetPhys(), dudx) << endl;
Exp_v->PhysDeriv(Exp_v->GetPhys(),dump,Exp_v->UpdatePhys(),dump);
cout << "L infinity error: " << Exp_v->Linf(Exp_v->GetPhys(), dvdy) << endl;
cout << "L 2 error : " << Exp_v->L2 (Exp_v->GetPhys(), dvdy) << endl;
Exp_w->PhysDeriv(Exp_w->GetPhys(),dump,dump,Exp_w->UpdatePhys());
cout << "L infinity error: " << Exp_w->Linf(Exp_w->GetPhys(), dwdz) << endl;
cout << "L 2 error : " << Exp_w->L2 (Exp_w->GetPhys(), dwdz) << endl;
return 0;
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
MultiRegions::ExpList1DSharedPtr Exp,Sol;
int i,j;
int nq;
int coordim;
Array<OneD, NekDouble> sol;
Array<OneD, NekDouble> xc0,xc1,xc2;
// read in mesh
SpatialDomains::MeshGraphSharedPtr graph1D = MemoryManager<SpatialDomains::MeshGraph1D>::AllocateSharedPtr(vSession);
// Define Expansion
const SpatialDomains::ExpansionMap &expansions = graph1D->GetExpansions();
LibUtilities::BasisKey bkey0 = expansions.begin()->second->m_basisKeyVector[0];
int nmodes = bkey0.GetNumModes();
Exp = MemoryManager<MultiRegions::ExpList1D>::AllocateSharedPtr(vSession,bkey0,graph1D);
//----------------------------------------------
// Define solution to be projected
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
// define coordinates and solution
sol = Array<OneD, NekDouble>(nq);
xc0 = Array<OneD, NekDouble>(nq);
xc1 = Array<OneD, NekDouble>(nq);
xc2 = Array<OneD, NekDouble>(nq);
switch(coordim)
{
case 1:
Exp->GetCoords(xc0);
Vmath::Zero(nq,&xc1[0],1);
Vmath::Zero(nq,&xc2[0],1);
break;
case 2:
Exp->GetCoords(xc0,xc1);
Vmath::Zero(nq,&xc2[0],1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
}
for(i = 0; i < nq; ++i)
{
sol[i] = 0.0;
for(j = 0; j < nmodes; ++j)
{
sol[i] += pow(xc0[i],j);
sol[i] += pow(xc1[i],j);
sol[i] += pow(xc2[i],j);
}
}
//---------------------------------------------
// Set up ExpList1D containing the solution
Sol = MemoryManager<MultiRegions::ExpList1D>::AllocateSharedPtr(*Exp);
Sol->SetPhys(sol);
//---------------------------------------------
//---------------------------------------------
// Project onto Expansion
Exp->FwdTrans(Sol->GetPhys(), Exp->UpdateCoeffs());
//---------------------------------------------
//-------------------------------------------
// Backward Transform Solution to get projected values
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//-------------------------------------------
//--------------------------------------------
// Calculate L_inf error
if (vSession->GetComm()->GetRank() == 0)
{
cout << "L infinity error: " << Exp->Linf(Sol->GetPhys()) << endl;
cout << "L 2 error: " << Exp->L2 (Sol->GetPhys()) << endl;
}
//--------------------------------------------
vSession->Finalise();
return 0;
}
/**
* Main function.
*
* Usage: VtkToFld session.xml input.vtk output.fld [options]
*/
int main(int argc, char* argv[])
{
// Set up available options
po::options_description desc("Available options");
desc.add_options()
("help,h", "Produce this help message.")
("name,n", po::value<string>()->default_value("Intensity"),
"Name of field in VTK file to use for intensity.")
("outname,m", po::value<string>()->default_value("intensity"),
"Name of field in output FLD file.")
("precision,p", po::value<double>()->default_value(1),
"Precision of vertex matching.");
po::options_description hidden("Hidden options");
hidden.add_options()
("file", po::value<vector<string> >(), "Input filename");
po::options_description cmdline_options;
cmdline_options.add(desc).add(hidden);
po::positional_options_description p;
p.add("file", -1);
po::variables_map vm;
// Parse command-line options
try
{
po::store(po::command_line_parser(argc, argv).
options(cmdline_options).positional(p).run(), vm);
po::notify(vm);
}
catch (const std::exception& e)
{
cerr << e.what() << endl;
cerr << desc;
return 1;
}
if ( vm.count("help") || vm.count("file") == 0 ||
vm["file"].as<vector<string> >().size() != 3) {
cerr << "Usage: VtkToFld session.xml intensity.vtk output.fld [options]"
<< endl;
cerr << desc;
return 1;
}
// Extract command-line argument values
std::vector<std::string> vFiles = vm["file"].as<vector<string> >();
const string infile = vFiles[1];
const string outfile = vFiles[2];
const double factor = vm["precision"].as<double>();
const string name = vm["name"].as<string>();
const string outname = vm["outname"].as<string>();
std::vector<std::string> vFilenames;
LibUtilities::SessionReaderSharedPtr vSession;
SpatialDomains::MeshGraphSharedPtr graph2D;
MultiRegions::ExpList2DSharedPtr Exp;
vFilenames.push_back(vFiles[0]);
vSession = LibUtilities::SessionReader::CreateInstance(2, argv, vFilenames);
try
{
//----------------------------------------------
// Read in mesh from input file
graph2D = MemoryManager<SpatialDomains::MeshGraph2D>::
AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::ExpList2D>::
AllocateSharedPtr(vSession,graph2D);
//----------------------------------------------
//----------------------------------------------
// Set up coordinates of mesh
int coordim = Exp->GetCoordim(0);
int nq = Exp->GetNpoints();
Array<OneD, NekDouble> xc0(nq,0.0);
Array<OneD, NekDouble> xc1(nq,0.0);
Array<OneD, NekDouble> xc2(nq,0.0);
switch(coordim)
{
case 2:
Exp->GetCoords(xc0,xc1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
default:
ASSERTL0(false,"Coordim not valid");
break;
}
//----------------------------------------------
vtkPolyDataReader *vtkMeshReader = vtkPolyDataReader::New();
vtkMeshReader->SetFileName(infile.c_str());
vtkMeshReader->Update();
vtkPolyData *vtkMesh = vtkMeshReader->GetOutput();
vtkCellDataToPointData* c2p = vtkCellDataToPointData::New();
#if VTK_MAJOR_VERSION <= 5
c2p->SetInput(vtkMesh);
#else
c2p->SetInputData(vtkMesh);
#endif
c2p->PassCellDataOn();
c2p->Update();
vtkPolyData *vtkDataAtPoints = c2p->GetPolyDataOutput();
vtkPoints *vtkPoints = vtkMesh->GetPoints();
ASSERTL0(vtkPoints, "ERROR: cannot get points from mesh.");
vtkCellArray *vtkPolys = vtkMesh->GetPolys();
ASSERTL0(vtkPolys, "ERROR: cannot get polygons from mesh.");
vtkPointData *vtkPData = vtkDataAtPoints->GetPointData();
ASSERTL0(vtkPolys, "ERROR: cannot get point data from file.");
VertexSet points;
VertexSet::iterator vIter;
double p[3];
double val;
double x, y, z;
int coeff_idx;
int i,j,n;
if (!vtkDataAtPoints->GetPointData()->HasArray(name.c_str())) {
n = vtkDataAtPoints->GetPointData()->GetNumberOfArrays();
cerr << "Input file '" << infile
<< "' does not have a field named '"
<< name << "'" << endl;
cerr << "There are " << n << " arrays in this file." << endl;
for (int i = 0; i < n; ++i)
{
cerr << " "
<< vtkDataAtPoints->GetPointData()->GetArray(i)->GetName()
<< endl;
}
return 1;
}
// Build up an unordered set of vertices from the VTK file. For each
// vertex a hashed value of the coordinates is generated to within a
// given tolerance.
n = vtkPoints->GetNumberOfPoints();
for (i = 0; i < n; ++i)
{
vtkPoints->GetPoint(i,p);
val = vtkPData->GetScalars(name.c_str())->GetTuple1(i);
boost::shared_ptr<Vertex> v(new Vertex(p[0],p[1],p[2],val,factor));
points.insert(v);
}
// Now process each vertex of each element in the mesh
SpatialDomains::PointGeomSharedPtr vert;
for (i = 0; i < Exp->GetNumElmts(); ++i)
{
StdRegions::StdExpansionSharedPtr e = Exp->GetExp(i);
for (j = 0; j < e->GetNverts(); ++j)
{
// Get the index of the coefficient corresponding to this vertex
coeff_idx = Exp->GetCoeff_Offset(i) + e->GetVertexMap(j);
// Get the coordinates of the vertex
vert = e->as<LocalRegions::Expansion2D>()->GetGeom2D()
->GetVertex(j);
vert->GetCoords(x,y,z);
// Look up the vertex in the VertexSet
boost::shared_ptr<Vertex> v(new Vertex(x,y,z,0.0,factor));
vIter = points.find(v);
// If not found, maybe the tolerance should be reduced?
// If found, record the scalar value from the VTK file in the
// corresponding coefficient.
if (vIter == points.end())
{
cerr << "Vertex " << i << " not found. Looking for ("
<< x << ", " << y << ", " << z << ")" << endl;
}
else
{
Exp->UpdateCoeffs()[coeff_idx] = (*vIter)->scalar;
}
}
}
Exp->SetPhysState(false);
//-----------------------------------------------
// Write solution to file
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back(outname);
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
}
LibUtilities::FieldIO vFld(vSession->GetComm());
vFld.Write(outfile, FieldDef, FieldData);
//-----------------------------------------------
}
catch (...) {
cout << "An error occurred." << endl;
}
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
string meshfile(argv[1]);
MultiRegions::DisContField3DHomogeneous1DSharedPtr Exp,Fce;
MultiRegions::ExpListSharedPtr DerExp1,DerExp2,DerExp3;
int i, nq;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
StdRegions::ConstFactorMap factors;
NekDouble lz;
if(argc != 2)
{
fprintf(stderr,"Usage: Helmholtz2D meshfile\n");
exit(1);
}
LibUtilities::FieldIOSharedPtr fld = MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(vComm);
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph2D = MemoryManager<SpatialDomains::MeshGraph2D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int nplanes = vSession->GetParameter("HomModesZ");
lz = vSession->GetParameter("LZ");
bool useFFT = false;
bool deal = false;
const LibUtilities::PointsKey Pkey(nplanes,LibUtilities::eFourierEvenlySpaced);
const LibUtilities::BasisKey Bkey(LibUtilities::eFourier,nplanes,Pkey);
Exp = MemoryManager<MultiRegions::DisContField3DHomogeneous1D>::
AllocateSharedPtr(vSession,Bkey,lz,useFFT,deal,graph2D,vSession->GetVariable(0));
//----------------------------------------------
Timing("Read files and define exp ..");
//----------------------------------------------
// Print summary of solution details
factors[StdRegions::eFactorLambda] = vSession->GetParameter("Lambda");
factors[StdRegions::eFactorTau] = 1.0;
const SpatialDomains::ExpansionMap &expansions = graph2D->GetExpansions();
LibUtilities::BasisKey bkey0
= expansions.begin()->second->m_basisKeyVector[0];
cout << "Solving 3D Helmholtz (Homogeneous in z-direction):" << endl;
cout << " Lambda : " << factors[StdRegions::eFactorLambda] << endl;
cout << " Lz : " << lz << endl;
cout << " No. modes : " << bkey0.GetNumModes() << endl;
cout << " No. hom. modes : " << Bkey.GetNumModes() << endl;
cout << endl;
//----------------------------------------------
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
nq = Exp->GetTotPoints();
xc0 = Array<OneD,NekDouble>(nq,0.0);
xc1 = Array<OneD,NekDouble>(nq,0.0);
xc2 = Array<OneD,NekDouble>(nq,0.0);
Exp->GetCoords(xc0,xc1,xc2);
//----------------------------------------------
//----------------------------------------------
// Define forcing function for first variable defined in file
fce = Array<OneD,NekDouble>(nq);
LibUtilities::EquationSharedPtr ffunc
= vSession->GetFunction("Forcing", 0);
ffunc->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::DisContField3DHomogeneous1D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
Timing("Define forcing ..");
//----------------------------------------------
// Helmholtz solution taking physical forcing
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
//----------------------------------------------
Timing("Helmholtz Solve ..");
#ifdef TIMING
for(i = 0; i < 100; ++i)
{
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
}
Timing("100 Helmholtz Solves:... ");
#endif
//-----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//-----------------------------------------------
Timing("Backard Transform ..");
//-----------------------------------------------
// Write solution to file
string out = meshfile.substr(0, meshfile.find_last_of(".")) + ".fld";
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back("u");
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
}
fld->Write(out, FieldDef, FieldData);
//-----------------------------------------------
//-----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol =
vSession->GetFunction("ExactSolution", 0);
if(ex_sol)
{
//----------------------------------------------
// evaluate exact solution
ex_sol->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//--------------------------------------------
// Calculate error
Fce->SetPhys(fce);
Fce->SetPhysState(true);
cout << "L infinity error: " << Exp->Linf(Exp->GetPhys(), Fce->GetPhys()) << endl;
cout << "L 2 error : " << Exp->L2 (Exp->GetPhys(), Fce->GetPhys()) << endl;
//--------------------------------------------
}
Timing("Output ..");
//----------------------------------------------
return 0;
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
MultiRegions::DisContField3DSharedPtr Exp,Fce;
int i, nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
StdRegions::ConstFactorMap factors;
if(argc < 2)
{
fprintf(stderr,"Usage: PostProcHDG3D meshfile [solntype]\n");
exit(1);
}
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph3D = MemoryManager<SpatialDomains::MeshGraph3D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
factors[StdRegions::eFactorLambda] = vSession->GetParameter("Lambda");
factors[StdRegions::eFactorTau] = 1.0;
const SpatialDomains::ExpansionMap &expansions = graph3D->GetExpansions();
LibUtilities::BasisKey bkey0
= expansions.begin()->second->m_basisKeyVector[0];
//MAY NEED ADJUSTMENT FOR VARIOUS ELEMENT TYPES
int num_modes = bkey0.GetNumModes();
int num_points = bkey0.GetNumPoints();
if (vComm->GetRank() == 0)
{
cout << "Solving 3D Helmholtz:" << endl;
cout << " Lambda : " << factors[StdRegions::eFactorLambda] << endl;
cout << " No. modes : " << num_modes << endl;
cout << " No. points : " << num_points << endl;
cout << endl;
}
//----------------------------------------------
// Define Expansion
//----------------------------------------------
Exp = MemoryManager<MultiRegions::DisContField3D>::
AllocateSharedPtr(vSession,graph3D,vSession->GetVariable(0));
//----------------------------------------------
Timing("Read files and define exp ..");
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
xc0 = Array<OneD,NekDouble>(nq,0.0);
xc1 = Array<OneD,NekDouble>(nq,0.0);
xc2 = Array<OneD,NekDouble>(nq,0.0);
switch(coordim)
{
case 1:
Exp->GetCoords(xc0);
break;
case 2:
Exp->GetCoords(xc0,xc1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
}
//----------------------------------------------
//----------------------------------------------
// Define forcing function for first variable defined in file
fce = Array<OneD,NekDouble>(nq);
LibUtilities::EquationSharedPtr ffunc
= vSession->GetFunction("Forcing", 0);
ffunc->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::DisContField3D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
Timing("Define forcing ..");
//----------------------------------------------
// Helmholtz solution taking physical forcing
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
//----------------------------------------------
Timing("Helmholtz Solve ..");
//-----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//-----------------------------------------------
Timing("Backward Transform ..");
//-----------------------------------------------
// Write solution to file
//string out = vSession->GetSessionName() + ".fld";
//std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
// = Exp->GetFieldDefinitions();
//std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
//for(i = 0; i < FieldDef.size(); ++i)
//{
// FieldDef[i]->m_fields.push_back("u");
// Exp->AppendFieldData(FieldDef[i], FieldData[i]);
//}
//LibUtilities::Write(out, FieldDef, FieldData);
//--------------------------------------------
//-----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol =
vSession->GetFunction("ExactSolution", 0);
//----------------------------------------------
// evaluate exact solution
ex_sol->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//Tetrahedron
const LibUtilities::PointsKey PkeyT1(num_points+1,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyT2(num_points,LibUtilities::eGaussRadauMAlpha1Beta0);//need to doublecheck this one
const LibUtilities::PointsKey PkeyT3(num_points,LibUtilities::eGaussRadauMAlpha2Beta0);//need to doublecheck this one
LibUtilities::BasisKeyVector BkeyT;
BkeyT.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyT1));
BkeyT.push_back(LibUtilities::BasisKey(LibUtilities::eModified_B, num_modes+1, PkeyT2));
BkeyT.push_back(LibUtilities::BasisKey(LibUtilities::eModified_C, num_modes+1, PkeyT3));
//Prism
const LibUtilities::PointsKey PkeyP1(num_points+1,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyP2(num_points+1,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyP3(num_points,LibUtilities::eGaussRadauMAlpha1Beta0);//need to doublecheck this one
LibUtilities::BasisKeyVector BkeyP;
BkeyP.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyP1));
BkeyP.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyP2));
BkeyP.push_back(LibUtilities::BasisKey(LibUtilities::eModified_B, num_modes+1, PkeyP3));
//Hexahedron
const LibUtilities::PointsKey PkeyH(num_points+1,LibUtilities::eGaussLobattoLegendre);
LibUtilities::BasisKeyVector BkeyH;
BkeyH.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyH));
BkeyH.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyH));
BkeyH.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyH));
graph3D->SetBasisKey(LibUtilities::eTetrahedron, BkeyT);
graph3D->SetBasisKey(LibUtilities::ePrism, BkeyP);
graph3D->SetBasisKey(LibUtilities::eHexahedron, BkeyH);
MultiRegions::DisContField3DSharedPtr PostProc =
MemoryManager<MultiRegions::DisContField3D>::AllocateSharedPtr(vSession,graph3D,vSession->GetVariable(0));
int ErrorCoordim = PostProc->GetCoordim(0);
int ErrorNq = PostProc->GetTotPoints();
Array<OneD,NekDouble> ErrorXc0(ErrorNq,0.0);
Array<OneD,NekDouble> ErrorXc1(ErrorNq,0.0);
Array<OneD,NekDouble> ErrorXc2(ErrorNq,0.0);
switch(ErrorCoordim)
{
case 1:
PostProc->GetCoords(ErrorXc0);
break;
case 2:
PostProc->GetCoords(ErrorXc0,ErrorXc1);
break;
case 3:
PostProc->GetCoords(ErrorXc0,ErrorXc1,ErrorXc2);
break;
}
// evaluate exact solution
Array<OneD,NekDouble> ppSol(ErrorNq);
ex_sol->Evaluate(ErrorXc0,ErrorXc1,ErrorXc2,ppSol);
// calcualte spectral/hp approximation on the quad points of this new
// expansion basis
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
std::string fieldstr = "u";
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back(fieldstr);
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
PostProc->ExtractDataToCoeffs(FieldDef[i],FieldData[i],fieldstr,PostProc->UpdateCoeffs());
}
// Interpolation of trace
std::vector<LibUtilities::FieldDefinitionsSharedPtr> TraceDef
= Exp->GetTrace()->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > TraceData(TraceDef.size());
for(i = 0; i < TraceDef.size(); ++i)
{
TraceDef[i]->m_fields.push_back(fieldstr);
Exp->GetTrace()->AppendFieldData(TraceDef[i], TraceData[i]);
PostProc->GetTrace()->ExtractDataToCoeffs(TraceDef[i],TraceData[i],fieldstr,PostProc->GetTrace()->UpdateCoeffs());
}
PostProc->BwdTrans_IterPerExp(PostProc->GetCoeffs(),PostProc->UpdatePhys());
PostProc->EvaluateHDGPostProcessing(PostProc->UpdateCoeffs());
PostProc->BwdTrans_IterPerExp(PostProc->GetCoeffs(),PostProc->UpdatePhys());
NekDouble vLinfError = Exp->Linf(Exp->GetPhys(), fce);
NekDouble vL2Error = Exp->L2 (Exp->GetPhys(), fce);
NekDouble L2ErrorPostProc = PostProc->L2(PostProc->GetPhys(), ppSol);
NekDouble LinfErrorPostProc = PostProc->Linf(PostProc->GetPhys(), ppSol);
if (vSession->GetComm()->GetRank() == 0)
{
cout << "L infinity error : " << vLinfError << endl;
cout << "L 2 error : " << vL2Error << endl;
cout << "Postprocessed L infinity error : " << LinfErrorPostProc << endl;
cout << "Postprocessed L 2 error : " << L2ErrorPostProc << endl;
}
vSession->Finalise();
return 0;
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
MultiRegions::DisContField3DSharedPtr Exp, Fce;
int i, nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
StdRegions::ConstFactorMap factors;
if(argc < 2)
{
fprintf(stderr,"Usage: HDGHelmholtz3D meshfile [solntype]\n");
exit(1);
}
LibUtilities::FieldIOSharedPtr fld = MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(vComm);
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph3D =
MemoryManager<SpatialDomains::MeshGraph3D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
factors[StdRegions::eFactorLambda] = vSession->GetParameter("Lambda");
factors[StdRegions::eFactorTau] = 1.0;
const SpatialDomains::ExpansionMap &expansions = graph3D->GetExpansions();
LibUtilities::BasisKey bkey0
= expansions.begin()->second->m_basisKeyVector[0];
if (vComm->GetRank() == 0)
{
cout << "Solving 3D Helmholtz:" << endl;
cout << " - Communication: "
<< vSession->GetComm()->GetType() << " ("
<< vSession->GetComm()->GetSize()
<< " processes)" << endl;
cout << " - Solver type : "
<< vSession->GetSolverInfo("GlobalSysSoln") << endl;
cout << " - Lambda : "
<< factors[StdRegions::eFactorLambda] << endl;
cout << " - No. modes : "
<< bkey0.GetNumModes() << endl;
cout << endl;
}
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::DisContField3D>::
AllocateSharedPtr(vSession,graph3D,vSession->GetVariable(0));
//----------------------------------------------
Timing("Read files and define exp ..");
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
xc0 = Array<OneD,NekDouble>(nq,0.0);
xc1 = Array<OneD,NekDouble>(nq,0.0);
xc2 = Array<OneD,NekDouble>(nq,0.0);
switch(coordim)
{
case 1:
Exp->GetCoords(xc0);
break;
case 2:
Exp->GetCoords(xc0,xc1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
}
//----------------------------------------------
//----------------------------------------------
// Define forcing function for first variable defined in file
fce = Array<OneD,NekDouble>(nq);
LibUtilities::EquationSharedPtr ffunc = vSession->GetFunction("Forcing", 0);
ffunc->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::DisContField3D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
Timing("Define forcing ..");
//----------------------------------------------
// Helmholtz solution taking physical forcing
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
//----------------------------------------------
Timing("Helmholtz Solve ..");
#if 0
for(i = 0; i < 100; ++i)
{
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
}
Timing("100 Helmholtz Solves:... ");
#endif
//----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//----------------------------------------------
Timing("Backward Transform ..");
//-----------------------------------------------
// Write solution to file
string out = vSession->GetSessionName() + ".fld";
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back("u");
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
}
fld->Write(out, FieldDef, FieldData);
//-----------------------------------------------
//----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol =
vSession->GetFunction("ExactSolution", 0);
if(ex_sol)
{
//----------------------------------------------
// evaluate exact solution
ex_sol->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//--------------------------------------------
// Calculate L_inf error
Fce->SetPhys(fce);
Fce->SetPhysState(true);
NekDouble vLinfError = Exp->Linf(Exp->GetPhys(), Fce->GetPhys());
NekDouble vL2Error = Exp->L2 (Exp->GetPhys(), Fce->GetPhys());
NekDouble vH1Error = Exp->H1 (Exp->GetPhys(), Fce->GetPhys());
if (vComm->GetRank() == 0)
{
cout << "L infinity error: " << vLinfError << endl;
cout << "L 2 error : " << vL2Error << endl;
cout << "H 1 error : " << vH1Error << endl;
}
//--------------------------------------------
}
Timing("Output ..");
//----------------------------------------------
vSession->Finalise();
return 0;
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
MultiRegions::ContField1DSharedPtr Exp,Fce;
int i, nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
StdRegions::ConstFactorMap factors;
if( (argc != 2) && (argc != 3) && (argc != 4))
{
fprintf(stderr,"Usage: Helmholtz1D meshfile \n");
exit(1);
}
try
{
LibUtilities::FieldIOSharedPtr fld =
MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(vComm);
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph1D =
SpatialDomains::MeshGraph::Read(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
factors[StdRegions::eFactorLambda] = vSession->GetParameter("Lambda");
const SpatialDomains::ExpansionMap &expansions = graph1D->GetExpansions();
LibUtilities::BasisKey bkey0 = expansions.begin()->second->m_basisKeyVector[0];
if (vComm->GetRank() ==0)
{
cout << "Solving 1D Helmholtz: " << endl;
cout << " Communication: " << vComm->GetType() << endl;
cout << " Solver type : " << vSession->GetSolverInfo("GlobalSysSoln") << endl;
cout << " Lambda : " << factors[StdRegions::eFactorLambda] << endl;
cout << " No. modes : " << bkey0.GetNumModes() << endl;
}
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::ContField1D>::
AllocateSharedPtr(vSession,graph1D,vSession->GetVariable(0));
//----------------------------------------------
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
xc0 = Array<OneD,NekDouble>(nq);
xc1 = Array<OneD,NekDouble>(nq);
xc2 = Array<OneD,NekDouble>(nq);
switch(coordim)
{
case 1:
Exp->GetCoords(xc0);
Vmath::Zero(nq,&xc1[0],1);
Vmath::Zero(nq,&xc2[0],1);
break;
case 2:
Exp->GetCoords(xc0,xc1);
Vmath::Zero(nq,&xc2[0],1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
}
//----------------------------------------------
//----------------------------------------------
// Define forcing function for first variable defined in file
fce = Array<OneD,NekDouble>(nq);
LibUtilities::EquationSharedPtr ffunc
= vSession->GetFunction("Forcing", 0);
ffunc->Evaluate(xc0,xc1,xc2, fce);
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::ContField1D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
//----------------------------------------------
//Helmholtz solution taking physical forcing after setting
//initial condition to zero
Vmath::Zero(Exp->GetNcoeffs(),Exp->UpdateCoeffs(),1);
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
//----------------------------------------------
//----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//----------------------------------------------
//----------------------------------------------
// Write solution
string out(strtok(argv[1],"."));
string endfile(".fld");
out += endfile;
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back("u");
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
}
fld->Write(out, FieldDef, FieldData);
//----------------------------------------------
//----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol
= vSession->GetFunction("ExactSolution", 0);
if(ex_sol)
{
//----------------------------------------------
// evaluate exact solution
ex_sol->Evaluate(xc0,xc1,xc2, fce);
Fce->SetPhys(fce);
//----------------------------------------------
//--------------------------------------------
// Calculate errors
NekDouble vLinfError = Exp->Linf(Exp->GetPhys(), Fce->GetPhys());
NekDouble vL2Error = Exp->L2(Exp->GetPhys(), Fce->GetPhys());
NekDouble vH1Error = Exp->H1(Exp->GetPhys(), Fce->GetPhys());
if (vComm->GetRank() == 0)
{
cout << "L infinity error: " << vLinfError << endl;
cout << "L 2 error: " << vL2Error << endl;
cout << "H 1 error: " << vH1Error << endl;
}
//--------------------------------------------
}
//----------------------------------------------
}
catch (const std::runtime_error&)
{
cerr << "Caught exception." << endl;
return 1;
}
vComm->Finalise();
return 0;
}
