int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr session;
string vDriverModule;
DriverSharedPtr drv;
try
{
// Create session reader.
session = LibUtilities::SessionReader::CreateInstance(argc, argv);
// Create driver
session->LoadSolverInfo("Driver", vDriverModule, "Standard");
drv = GetDriverFactory().CreateInstance(vDriverModule, session);
// Execute driver
drv->Execute();
// Finalise session
session->Finalise();
}
catch (const std::runtime_error& e)
{
return 1;
}
catch (const std::string& eStr)
{
cout << "Error: " << eStr << endl;
}
return 0;
}
vector<ForcingSharedPtr> Forcing::Load(
const LibUtilities::SessionReaderSharedPtr& pSession,
const Array<OneD, MultiRegions::ExpListSharedPtr>& pFields,
const unsigned int& pNumForcingFields)
{
vector<ForcingSharedPtr> vForceList;
if (!pSession->DefinesElement("Nektar/Forcing"))
{
return vForceList;
}
TiXmlElement* vForcing = pSession->GetElement("Nektar/Forcing");
if (vForcing)
{
unsigned int vNumForcingFields = pNumForcingFields;
if (!pNumForcingFields)
{
vNumForcingFields = pFields.num_elements();
}
TiXmlElement* vForce = vForcing->FirstChildElement("FORCE");
while (vForce)
{
string vType = vForce->Attribute("TYPE");
vForceList.push_back(GetForcingFactory().CreateInstance(
vType, pSession, pFields,
vNumForcingFields, vForce));
vForce = vForce->NextSiblingElement("FORCE");
}
}
return vForceList;
}
/**
* @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());
}
/**
* @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());
}
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());
}
int main(int argc, char *argv[])
{
if(argc != 2)
{
fprintf(stderr,"Usage: ./Aliasing file.xml \n");
fprintf(stderr,"\t Method will read intiial conditions section of .xml file for input \n");
exit(1);
}
LibUtilities::SessionReaderSharedPtr session;
string vDriverModule;
DriverSharedPtr drv;
try
{
// Create session reader.
session = LibUtilities::SessionReader::CreateInstance(argc, argv);
// Create driver
session->LoadSolverInfo("Driver", vDriverModule, "Standard");
drv = GetDriverFactory().CreateInstance(vDriverModule, session);
EquationSystemSharedPtr EqSys = drv->GetEqu()[0];
IncNavierStokesSharedPtr IncNav = EqSys->as<IncNavierStokes>();
IncNav->SetInitialConditions(0.0,false);
Array<OneD, MultiRegions::ExpListSharedPtr> fields = IncNav->UpdateFields();
int i;
int nConvectiveFields = IncNav->GetNConvectiveFields();
int nphys = fields[0]->GetTotPoints();
Array<OneD, Array<OneD, NekDouble> > VelFields(nConvectiveFields);
Array<OneD, Array<OneD, NekDouble> > NonLinear(nConvectiveFields);
Array<OneD, Array<OneD, NekDouble> > NonLinearDealiased(nConvectiveFields);
for(i = 0; i < nConvectiveFields; ++i)
{
VelFields[i] = fields[i]->UpdatePhys();
NonLinear[i] = Array<OneD, NekDouble> (nphys);
NonLinearDealiased[i] = Array<OneD, NekDouble> (nphys);
}
boost::shared_ptr<NavierStokesAdvection> A
= boost::dynamic_pointer_cast<NavierStokesAdvection>(IncNav->GetAdvObject());
if (!A)
{
cout << "Must use non-linear Navier-Stokes advection" << endl;
exit(-1);
}
// calculate non-linear terms without dealiasing
A->SetSpecHPDealiasing(false);
A->Advect(nConvectiveFields, fields,
VelFields, VelFields,
NonLinear, 0.0);
// calculate non-linear terms with dealiasing
A->SetSpecHPDealiasing(true);
A->Advect(nConvectiveFields, fields,
VelFields, VelFields,
NonLinearDealiased, 0.0);
// Evaulate Difference and put into fields;
for(i = 0; i < nConvectiveFields; ++i)
{
Vmath::Vsub(nphys,NonLinearDealiased[i],1,NonLinear[i],1,NonLinear[i],1);
fields[i]->FwdTrans_IterPerExp(NonLinear[i],fields[i]->UpdateCoeffs());
// Need to reset varibale name for output
string name = "NL_Aliasing_"+session->GetVariable(i);
session->SetVariable(i,name.c_str());
}
// Reset session name for output file
std::string outname = IncNav->GetSessionName();
outname += "_NonLinear_Aliasing";
IncNav->ResetSessionName(outname);
IncNav->Output();
}
catch (const std::runtime_error&)
{
return 1;
}
catch (const std::string& eStr)
{
cout << "Error: " << eStr << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
if(argc < 2)
{
fprintf(stderr,"Usage: XmlToTecplot meshfile\n");
exit(1);
}
LibUtilities::SessionReader::RegisterCmdLineFlag(
"multi-zone", "m", "Output multi-zone format (one element per zone).");
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
//----------------------------------------------
// Read in mesh from input file
string meshfile(argv[argc-1]);
SpatialDomains::MeshGraphSharedPtr graphShPt
= SpatialDomains::MeshGraph::Read(vSession);
//----------------------------------------------
//----------------------------------------------
// Set up Expansion information
SpatialDomains::ExpansionMap emap = graphShPt->GetExpansions();
SpatialDomains::ExpansionMapIter it;
for (it = emap.begin(); it != emap.end(); ++it)
{
for (int i = 0; i < it->second->m_basisKeyVector.size(); ++i)
{
LibUtilities::BasisKey tmp1 = it->second->m_basisKeyVector[i];
LibUtilities::PointsKey tmp2 = tmp1.GetPointsKey();
it->second->m_basisKeyVector[i] = LibUtilities::BasisKey(
tmp1.GetBasisType(), tmp1.GetNumModes(),
LibUtilities::PointsKey(tmp1.GetNumModes(),
LibUtilities::ePolyEvenlySpaced));
}
}
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int expdim = graphShPt->GetMeshDimension();
Array<OneD, MultiRegions::ExpListSharedPtr> Exp(1);
switch(expdim)
{
case 1:
{
MultiRegions::ExpList1DSharedPtr Exp1D;
Exp1D = MemoryManager<MultiRegions::ExpList1D>::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp1D;
break;
}
case 2:
{
if(vSession->DefinesSolverInfo("HOMOGENEOUS"))
{
std::string HomoStr = vSession->GetSolverInfo("HOMOGENEOUS");
MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
ASSERTL0(
HomoStr == "HOMOGENEOUS1D" || HomoStr == "Homogeneous1D" ||
HomoStr == "1D" || HomoStr == "Homo1D",
"Only 3DH1D supported for XML output currently.");
int nplanes;
vSession->LoadParameter("HomModesZ", nplanes);
// choose points to be at evenly spaced points at nplanes + 1
// points
const LibUtilities::PointsKey Pkey(
nplanes + 1, LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(
LibUtilities::eFourier, nplanes, Pkey);
NekDouble lz = vSession->GetParameter("LZ");
Exp3DH1 = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>
::AllocateSharedPtr(
vSession, Bkey, lz, false, false, graphShPt);
Exp[0] = Exp3DH1;
}
else
{
MultiRegions::ExpList2DSharedPtr Exp2D;
Exp2D = MemoryManager<MultiRegions::ExpList2D>::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp2D;
}
break;
}
case 3:
{
MultiRegions::ExpList3DSharedPtr Exp3D;
Exp3D = MemoryManager<MultiRegions::ExpList3D>::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp3D;
break;
}
default:
ASSERTL0(false,"Expansion dimension not recognised");
break;
}
//-----------------------------------------------
//----------------------------------------------
// Write solution depending on #define
string outfile(strtok(argv[argc-1],"."));
outfile += ".dat";
ofstream outstrm(outfile.c_str());
Exp[0]->WriteTecplotHeader(outstrm);
if (vSession->DefinesCmdLineArgument("multi-zone"))
{
int nExp = Exp[0]->GetExpSize();
for (int i = 0; i < nExp; ++i)
{
Exp[0]->WriteTecplotZone (outstrm, i);
Exp[0]->WriteTecplotConnectivity(outstrm, i);
}
}
else
{
Exp[0]->WriteTecplotZone (outstrm);
Exp[0]->WriteTecplotConnectivity(outstrm);
}
outstrm.close();
//----------------------------------------------
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;
}
void Forcing::EvaluateFunction(
Array<OneD, MultiRegions::ExpListSharedPtr> pFields,
LibUtilities::SessionReaderSharedPtr pSession,
std::string pFieldName,
Array<OneD, NekDouble>& pArray,
const std::string& pFunctionName,
NekDouble pTime)
{
ASSERTL0(pSession->DefinesFunction(pFunctionName),
"Function '" + pFunctionName + "' does not exist.");
unsigned int nq = pFields[0]->GetNpoints();
if (pArray.num_elements() != nq)
{
pArray = Array<OneD, NekDouble> (nq);
}
LibUtilities::FunctionType vType;
vType = pSession->GetFunctionType(pFunctionName, pFieldName);
if (vType == LibUtilities::eFunctionTypeExpression)
{
Array<OneD, NekDouble> x0(nq);
Array<OneD, NekDouble> x1(nq);
Array<OneD, NekDouble> x2(nq);
pFields[0]->GetCoords(x0, x1, x2);
LibUtilities::EquationSharedPtr ffunc =
pSession->GetFunction(pFunctionName, pFieldName);
ffunc->Evaluate(x0, x1, x2, pTime, pArray);
}
else if (vType == LibUtilities::eFunctionTypeFile)
{
std::string filename = pSession->GetFunctionFilename(
pFunctionName,
pFieldName);
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
std::vector<std::vector<NekDouble> > FieldData;
Array<OneD, NekDouble> vCoeffs(pFields[0]->GetNcoeffs());
Vmath::Zero(vCoeffs.num_elements(), vCoeffs, 1);
LibUtilities::FieldIOSharedPtr fld =
MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(m_session->GetComm());
fld->Import(filename, FieldDef, FieldData);
int idx = -1;
for (int i = 0; i < FieldDef.size(); ++i)
{
for (int j = 0; j < FieldDef[i]->m_fields.size(); ++j)
{
if (FieldDef[i]->m_fields[j] == pFieldName)
{
idx = j;
}
}
if (idx >= 0)
{
pFields[0]->ExtractDataToCoeffs(
FieldDef[i],
FieldData[i],
FieldDef[i]->m_fields[idx],
vCoeffs);
}
else
{
cout << "Field " + pFieldName + " not found." << endl;
}
}
pFields[0]->BwdTrans_IterPerExp(vCoeffs, pArray);
}
}
/**
* Read global optimisation parameters from a file and set up flags.
* @param fileName File to read parameters from.
*/
GlobalOptParam::GlobalOptParam(const LibUtilities::SessionReaderSharedPtr& pSession, const int dim,
const Array<OneD, const int> &NumShapeElements):
m_doGlobalMatOp(SIZE_OptimizeOperationType,false)
{
int i;
int numShapes = 0;
TiXmlDocument& doc = pSession->GetDocument();
m_shapeNumElements = NumShapeElements;
switch (dim)
{
case 1:
numShapes = 1;
ASSERTL0(false,"Needs setting up for dimension 1");
break;
case 2:
numShapes = 2;
m_shapeList = Array<OneD, LibUtilities::ShapeType>(numShapes);
m_shapeList[0] = LibUtilities::eTriangle;
m_shapeList[1] = LibUtilities::eQuadrilateral;
break;
case 3:
numShapes = 4;
m_shapeList = Array<OneD, LibUtilities::ShapeType>(numShapes);
m_shapeList[0] = LibUtilities::eTetrahedron;
m_shapeList[1] = LibUtilities::ePyramid;
m_shapeList[2] = LibUtilities::ePrism;
m_shapeList[3] = LibUtilities::eHexahedron;
break;
}
m_doBlockMatOp = Array<OneD, Array<OneD,bool> > (SIZE_OptimizeOperationType);
for(i = 0; i < SIZE_OptimizeOperationType; ++i)
{
m_doBlockMatOp[i] = Array<OneD, bool> (numShapes,false);
}
TiXmlHandle docHandle(&doc);
TiXmlElement* master
= docHandle.FirstChildElement("NEKTAR").Element();
ASSERTL0(master , "Unable to find NEKTAR tag in file.");
TiXmlElement* paramList
= docHandle.FirstChildElement("NEKTAR")
.FirstChildElement("GLOBALOPTIMIZATIONPARAMETERS")
.Element();
// If no global optimisation parameters set, we're done
if (!paramList)
{
return;
}
// Check if there is a reference an external file and if so, load it
TiXmlElement* source
= paramList->FirstChildElement("SOURCE");
if (source)
{
std::string sourceFile = source->Attribute("FILE");
TiXmlDocument docSource;
bool loadOkay = docSource.LoadFile(sourceFile);
ASSERTL0(loadOkay, (std::string("Unable to load file: ") +
sourceFile).c_str());
TiXmlHandle docSourceHandle(&docSource);
master = docHandle.FirstChildElement("NEKTAR").Element();
ASSERTL0(master , "Unable to find NEKTAR tag in file.");
paramList = docHandle.FirstChildElement("NEKTAR")
.FirstChildElement("GLOBALOPTIMIZATIONPARAMETERS")
.Element();
ASSERTL0(paramList, std::string("Specified source file '"
+ sourceFile + "' is missing an "
"GLOBALOPTIMIZATIONPARAMETERS tag.").c_str());
}
int n;
for(n = 0; n < SIZE_OptimizeOperationType; n++)
{
TiXmlElement* operationType = paramList->FirstChildElement(
OptimizationOperationTypeMap[n]);
if(operationType)
{
TiXmlElement* arrayElement = operationType
->FirstChildElement("DO_GLOBAL_MAT_OP");
if(arrayElement)
{
int value;
int err;
err = arrayElement->QueryIntAttribute("VALUE", &value);
ASSERTL0(err == TIXML_SUCCESS,(
std::string("Unable to read DO_GLOBAL_MAT_OP "
"attribute VALUE for ")
+ std::string(OptimizationOperationTypeMap[n])
+ std::string(".")
));
m_doGlobalMatOp[n] = (bool) value;
}
arrayElement
= operationType->FirstChildElement("DO_BLOCK_MAT_OP");
if(arrayElement)
{
int value;
int err;
switch (dim)
{
case 1:
break;
case 2:
err = arrayElement->QueryIntAttribute("TRI", &value);
ASSERTL0(err == TIXML_SUCCESS, (
std::string("Unable to read DO_BLOCK_MAT_OP "
"attribute TRI for ")
+ std::string(OptimizationOperationTypeMap[n])
+ std::string(".")));
m_doBlockMatOp[n][0] = (bool) value;
err = arrayElement->QueryIntAttribute("QUAD", &value);
ASSERTL0(err == TIXML_SUCCESS, (
std::string("Unable to read DO_BLOCK_MAT_OP "
"attribute QUAD for ")
+ std::string(OptimizationOperationTypeMap[n])
+ std::string(".")));
m_doBlockMatOp[n][1] = (bool) value;
break;
case 3:
err = arrayElement->QueryIntAttribute("TET", &value);
ASSERTL0(err == TIXML_SUCCESS, (
std::string("Unable to read DO_BLOCK_MAT_OP "
"attribute TET for ")
+ std::string(OptimizationOperationTypeMap[n])
+ std::string(".")));
m_doBlockMatOp[n][0] = (bool) value;
err = arrayElement->QueryIntAttribute("PYR", &value);
ASSERTL0(err == TIXML_SUCCESS, (
std::string("Unable to read DO_BLOCK_MAT_OP "
"attribute PYR for ")
+ std::string(OptimizationOperationTypeMap[n])
+ std::string(".")));
m_doBlockMatOp[n][1] = (bool) value;
err = arrayElement->QueryIntAttribute("PRISM", &value);
ASSERTL0(err == TIXML_SUCCESS, (
std::string("Unable to read DO_BLOCK_MAT_OP "
"attribute PRISM for ")
+ std::string(OptimizationOperationTypeMap[n])
+ std::string(".")));
m_doBlockMatOp[n][2] = (bool) value;
err = arrayElement->QueryIntAttribute("HEX", &value);
ASSERTL0(err == TIXML_SUCCESS, (
std::string("Unable to read DO_BLOCK_MAT_OP "
"attribute HEX for ")
+ std::string(OptimizationOperationTypeMap[n])
+ std::string(".")));
m_doBlockMatOp[n][3] = (bool) value;
break;
break;
}
}
}
}
}
int main(int argc, char *argv[])
{
string fname = std::string(argv[2]);
int fdot = fname.find_last_of('.');
if (fdot != std::string::npos)
{
string ending = fname.substr(fdot);
// If .chk or .fld we exchange the extension in the output file.
// For all other files (e.g. .bse) we append the extension to avoid
// conflicts.
if (ending == ".chk" || ending == ".fld")
{
fname = fname.substr(0,fdot);
}
}
fname = fname + ".txt";
int cnt;
int id1, id2;
int i, j, n, e, b;
Array<OneD, NekDouble> auxArray;
int nBndEdgePts, nBndEdges, nBndRegions;
if (argc < 3)
{
fprintf(stderr,
"Usage: ExtractSurface3DCFS meshfile fieldFile\n");
fprintf(stderr,
"Extracts a surface from a 3D fld file"
"(only for CompressibleFlowSolver and purely 3D .fld files)\n");
exit(1);
}
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(3, argv);
std::string m_ViscosityType;
NekDouble m_gamma;
NekDouble m_pInf;
NekDouble m_rhoInf;
NekDouble m_uInf;
NekDouble m_vInf;
NekDouble m_wInf;
NekDouble m_gasConstant;
NekDouble m_Twall;
NekDouble m_mu;
NekDouble m_thermalConductivity;
int m_spacedim = 3;
int nDimensions = m_spacedim;
int phys_offset;
// Get gamma parameter from session file.
ASSERTL0(vSession->DefinesParameter("Gamma"),
"Compressible flow sessions must define a Gamma parameter.");
vSession->LoadParameter("Gamma", m_gamma, 1.4);
// Get E0 parameter from session file.
ASSERTL0(vSession->DefinesParameter("pInf"),
"Compressible flow sessions must define a pInf parameter.");
vSession->LoadParameter("pInf", m_pInf, 101325);
// Get rhoInf parameter from session file.
ASSERTL0(vSession->DefinesParameter("rhoInf"),
"Compressible flow sessions must define a rhoInf parameter.");
vSession->LoadParameter("rhoInf", m_rhoInf, 1.225);
// Get uInf parameter from session file.
ASSERTL0(vSession->DefinesParameter("uInf"),
"Compressible flow sessions must define a uInf parameter.");
vSession->LoadParameter("uInf", m_uInf, 0.1);
// Get vInf parameter from session file.
if (m_spacedim == 2 || m_spacedim == 3)
{
ASSERTL0(vSession->DefinesParameter("vInf"),
"Compressible flow sessions must define a vInf parameter"
"for 2D/3D problems.");
vSession->LoadParameter("vInf", m_vInf, 0.0);
}
// Get wInf parameter from session file.
if (m_spacedim == 3)
{
ASSERTL0(vSession->DefinesParameter("wInf"),
"Compressible flow sessions must define a wInf parameter"
"for 3D problems.");
vSession->LoadParameter("wInf", m_wInf, 0.0);
}
vSession->LoadParameter ("GasConstant", m_gasConstant, 287.058);
vSession->LoadParameter ("Twall", m_Twall, 300.15);
vSession->LoadSolverInfo("ViscosityType", m_ViscosityType, "Constant");
vSession->LoadParameter ("mu", m_mu, 1.78e-05);
vSession->LoadParameter ("thermalConductivity",
m_thermalConductivity, 0.0257);
//--------------------------------------------------------------------------
// Read in mesh from input file
string meshfile(argv[1]);
SpatialDomains::MeshGraphSharedPtr graphShPt =
SpatialDomains::MeshGraph::Read(vSession);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Import field file
string fieldFile(argv[2]);
vector<LibUtilities::FieldDefinitionsSharedPtr> fieldDef;
vector<vector<NekDouble> > fieldData;
LibUtilities::Import(fieldFile, fieldDef, fieldData);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Set up Expansion information
vector< vector<LibUtilities::PointsType> > pointsType;
for (i = 0; i < fieldDef.size(); ++i)
{
vector<LibUtilities::PointsType> ptype;
for (j = 0; j < 3; ++j)
{
ptype.push_back(LibUtilities::ePolyEvenlySpaced);
}
pointsType.push_back(ptype);
}
graphShPt->SetExpansions(fieldDef, pointsType);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Define Expansion
int nfields = fieldDef[0]->m_fields.size();
Array<OneD, MultiRegions::ExpListSharedPtr> Exp(nfields);
Array<OneD, MultiRegions::ExpListSharedPtr> pFields(nfields);
for(i = 0; i < pFields.num_elements(); i++)
{
pFields[i] = MemoryManager<MultiRegions
::DisContField3D>::AllocateSharedPtr(vSession, graphShPt,
vSession->GetVariable(i));
}
MultiRegions::ExpList3DSharedPtr Exp3D;
Exp3D = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(vSession, graphShPt);
Exp[0] = Exp3D;
for (i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(*Exp3D);
}
// Count of the point on the surface
int nSurfacePts = 0;
if (pFields[0]->GetBndCondExpansions().num_elements())
{
nSurfacePts = 0;
cnt = 0;
nBndRegions = pFields[0]->GetBndCondExpansions().num_elements();
for (b = 0; b < nBndRegions; ++b)
{
nBndEdges = pFields[0]->GetBndCondExpansions()[b]->GetExpSize();
for (e = 0; e < nBndEdges; ++e)
{
nBndEdgePts = pFields[0]->
GetBndCondExpansions()[b]->GetExp(e)->GetTotPoints();
if (pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "WallViscous" ||
pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "WallAdiabatic" ||
pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "Wall")
{
nSurfacePts += nBndEdgePts;
}
}
}
}
int nSolutionPts = pFields[0]->GetNpoints();
int nTracePts = pFields[0]->GetTrace()->GetTotPoints();
int nElements = pFields[0]->GetExpSize();
Array<OneD, NekDouble> tmp(nSolutionPts, 0.0);
Array<OneD, NekDouble> x(nSolutionPts);
Array<OneD, NekDouble> y(nSolutionPts);
Array<OneD, NekDouble> z(nSolutionPts);
Array<OneD, NekDouble> traceX(nTracePts);
Array<OneD, NekDouble> traceY(nTracePts);
Array<OneD, NekDouble> traceZ(nTracePts);
Array<OneD, NekDouble> surfaceX(nSurfacePts);
Array<OneD, NekDouble> surfaceY(nSurfacePts);
Array<OneD, NekDouble> surfaceZ(nSurfacePts);
pFields[0]->GetCoords(x, y, z);
pFields[0]->ExtractTracePhys(x, traceX);
pFields[0]->ExtractTracePhys(y, traceY);
pFields[0]->ExtractTracePhys(z, traceZ);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Copy data from field file
Array<OneD, Array<OneD, NekDouble> > uFields(nfields);
Array<OneD, Array<OneD, NekDouble> > traceFields(nfields);
Array<OneD, Array<OneD, NekDouble> > surfaceFields(nfields);
// Extract the physical values of the solution at the boundaries
for (j = 0; j < nfields; ++j)
{
uFields[j] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
traceFields[j] = Array<OneD, NekDouble>(nTracePts, 0.0);
surfaceFields[j] = Array<OneD, NekDouble>(nSurfacePts, 0.0);
for (i = 0; i < fieldData.size(); ++i)
{
Exp[j]->ExtractDataToCoeffs(fieldDef[i], fieldData[i],
fieldDef[i]->m_fields[j],
Exp[j]->UpdateCoeffs());
}
Exp[j]->BwdTrans(Exp[j]->GetCoeffs(), Exp[j]->UpdatePhys());
Vmath::Vcopy(nSolutionPts, Exp[j]->GetPhys(), 1, uFields[j], 1);
pFields[0]->ExtractTracePhys(uFields[j], traceFields[j]);
}
//Fields to add in the output file
int nfieldsAdded = 34;
Array<OneD, Array<OneD, NekDouble> > traceFieldsAdded(nfieldsAdded);
Array<OneD, Array<OneD, NekDouble> > surfaceFieldsAdded(nfieldsAdded);
for (j = 0; j < nfieldsAdded; ++j)
{
traceFieldsAdded[j] = Array<OneD, NekDouble>(nTracePts, 0.0);
surfaceFieldsAdded[j] = Array<OneD, NekDouble>(nSurfacePts, 0.0);
}
/******** Evaluation of normals and tangents on the trace *****************
* nx -> traceFieldsAdded[0];
* ny -> traceFieldsAdded[1];
* nz -> traceFieldsAdded[2];
* bx -> traceFieldsAdded[3];
* by -> traceFieldsAdded[4];
* bz -> traceFieldsAdded[5];
* tx -> traceFieldsAdded[6];
* ty -> traceFieldsAdded[7];
* tz -> traceFieldsAdded[8];
***************************************************************************/
Array<OneD, Array<OneD, NekDouble> > m_traceNormals (nDimensions);
for(i = 0; i < nDimensions; ++i)
{
m_traceNormals[i] = Array<OneD, NekDouble> (nTracePts, 0.0);
}
pFields[0]->GetTrace()->GetNormals(m_traceNormals);
Array<OneD, Array<OneD, NekDouble> > m_traceTangents (nDimensions);
Array<OneD, Array<OneD, NekDouble> > m_traceBinormals (nDimensions);
Array<OneD, Array<OneD, NekDouble> > h (nDimensions);
Array<OneD, NekDouble > tmpNorm (nTracePts, 1.0);
Array<OneD, NekDouble > NormH (nTracePts, 0.0);
Array<OneD, NekDouble > tmpTrace (nTracePts, 0.0);
for(i = 0; i < nDimensions; ++i)
{
m_traceTangents[i] = Array<OneD, NekDouble> (nTracePts, 0.0);
m_traceBinormals[i] = Array<OneD, NekDouble> (nTracePts, 0.0);
h[i] = Array<OneD, NekDouble> (nTracePts, 0.0);
}
// Normals
// nx
Vmath::Vcopy(nTracePts,
&m_traceNormals[0][0], 1,
&traceFieldsAdded[0][0], 1);
// ny
Vmath::Vcopy(nTracePts,
&m_traceNormals[1][0], 1,
&traceFieldsAdded[1][0], 1);
// nz
Vmath::Vcopy(nTracePts,
&m_traceNormals[2][0], 1,
&traceFieldsAdded[2][0], 1);
// Tangents and Binormals
// h1
Vmath::Vadd(nTracePts,
&m_traceNormals[0][0], 1,
&tmpNorm[0], 1,
&h[0][0], 1);
// h2
Vmath::Vcopy(nTracePts,
&m_traceNormals[1][0], 1,
&h[1][0], 1);
// h3
Vmath::Vcopy(nTracePts,
&m_traceNormals[2][0], 1,
&h[2][0], 1);
// Norm of h
for (i = 0; i < m_spacedim; i++)
{
Vmath::Vvtvp (nTracePts, &h[i][0], 1, &h[i][0], 1,
&NormH[0],1, &NormH[0],1);
}
//b1
Vmath::Vmul(nTracePts,
&h[0][0], 1,
&h[1][0], 1,
&tmpTrace[0],1);
Vmath::Vdiv(nTracePts,
&tmpTrace[0],1,
&NormH[0], 1,
&tmpTrace[0],1);
Vmath::Smul(nTracePts, -2.0,
&tmpTrace[0], 1,
&m_traceBinormals[0][0], 1);
Vmath::Vcopy(nTracePts,
&m_traceBinormals[0][0], 1,
&traceFieldsAdded[3][0], 1);
//b2
Vmath::Vmul(nTracePts,
&h[1][0], 1,
&h[1][0], 1,
&tmpTrace[0],1);
Vmath::Vdiv(nTracePts,
&tmpTrace[0],1,
&NormH[0], 1,
&tmpTrace[0],1);
Vmath::Smul(nTracePts, -2.0,
&tmpTrace[0], 1,
&tmpTrace[0], 1);
Vmath::Vadd(nTracePts,
&tmpTrace[0], 1,
&tmpNorm[0], 1,
&m_traceBinormals[1][0], 1);
Vmath::Vcopy(nTracePts,
&m_traceBinormals[1][0], 1,
&traceFieldsAdded[4][0], 1);
//b3
Vmath::Vmul(nTracePts,
&h[1][0], 1,
&h[2][0], 1,
&tmpTrace[0],1);
Vmath::Vdiv(nTracePts,
&tmpTrace[0],1,
&NormH[0], 1,
&tmpTrace[0],1);
Vmath::Smul(nTracePts, -2.0,
&tmpTrace[0], 1,
&m_traceBinormals[2][0], 1);
Vmath::Vcopy(nTracePts,
&m_traceBinormals[2][0], 1,
&traceFieldsAdded[5][0], 1);
//t1
Vmath::Vmul(nTracePts,
&h[0][0], 1,
&h[2][0], 1,
&tmpTrace[0],1);
Vmath::Vdiv(nTracePts,
&tmpTrace[0],1,
&NormH[0], 1,
&tmpTrace[0],1);
Vmath::Smul(nTracePts, -2.0,
&tmpTrace[0], 1,
&m_traceTangents[0][0], 1);
Vmath::Vcopy(nTracePts,
&m_traceTangents[0][0], 1,
&traceFieldsAdded[6][0], 1);
//t2
Vmath::Vcopy(nTracePts,
&m_traceBinormals[2][0], 1,
&m_traceTangents[1][0], 1);
Vmath::Vcopy(nTracePts,
&m_traceTangents[1][0], 1,
&traceFieldsAdded[7][0], 1);
//t3
Vmath::Vmul(nTracePts,
&h[2][0], 1,
&h[2][0], 1,
&tmpTrace[0],1);
Vmath::Vdiv(nTracePts,
&tmpTrace[0],1,
&NormH[0], 1,
&tmpTrace[0],1);
Vmath::Smul(nTracePts, -2.0,
&tmpTrace[0], 1,
&tmpTrace[0], 1);
Vmath::Vadd(nTracePts,
&tmpTrace[0], 1,
&tmpNorm[0], 1,
&m_traceTangents[2][0], 1);
Vmath::Vcopy(nTracePts,
&m_traceTangents[2][0], 1,
&traceFieldsAdded[8][0], 1);
/******** Evaluation of the pressure ***************************************
* P = (E-1/2.*rho.*((rhou./rho).^2+(rhov./rho).^2))*(gamma - 1);
* P -> traceFieldsAdded[9];
***************************************************************************/
Array<OneD, NekDouble> pressure(nSolutionPts, 0.0);
NekDouble gammaMinusOne = m_gamma - 1.0;
for (i = 0; i < m_spacedim; i++)
{
Vmath::Vmul(nSolutionPts,
&uFields[i + 1][0], 1,
&uFields[i + 1][0], 1,
&tmp[0],1);
Vmath::Smul(nSolutionPts, 0.5,
&tmp[0], 1,
&tmp[0], 1);
Vmath::Vadd(nSolutionPts,
&pressure[0], 1,
&tmp[0], 1,
&pressure[0], 1);
}
Vmath::Vdiv(nSolutionPts,
&pressure[0], 1,
&uFields[0][0], 1,
&pressure[0],1);
Vmath::Vsub(nSolutionPts,
&uFields[nfields - 1][0], 1,
&pressure[0], 1,
&pressure[0],1);
Vmath::Smul(nSolutionPts, gammaMinusOne,
&pressure[0], 1,
&pressure[0], 1);
// Extract trace
pFields[0]->ExtractTracePhys(pressure, traceFieldsAdded[9]);
/******** Evaluation of the temperature ************************************
* T = P/(R*rho);
* T -> traceFieldsAdded[10];
***************************************************************************/
Array<OneD, NekDouble> temperature(nSolutionPts, 0.0);
Vmath::Vdiv(nSolutionPts,
&pressure[0], 1,
&uFields[0][0], 1,
&temperature[0],1);
NekDouble GasConstantInv = 1.0/m_gasConstant;
Vmath::Smul(nSolutionPts, GasConstantInv,
&temperature[0], 1,
&temperature[0], 1);
// Extract trace
pFields[0]->ExtractTracePhys(temperature, traceFieldsAdded[10]);
/*** Evaluation of the temperature gradient in the normal direction ********
* DT_n -> traceFieldsAdded[11]
***************************************************************************/
Array<OneD, Array<OneD, NekDouble> > Dtemperature(nDimensions);
Array<OneD, Array<OneD, NekDouble> > traceDtemperature(nDimensions);
for (i = 0; i < nDimensions; ++ i)
{
Dtemperature[i] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
traceDtemperature[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
}
for (i = 0; i < nDimensions; ++ i)
{
for (n = 0; n < nElements; n++)
{
phys_offset = pFields[0]->GetPhys_Offset(n);
pFields[i]->GetExp(n)->PhysDeriv(
i, temperature + phys_offset,
auxArray = Dtemperature[i] + phys_offset);
}
// Extract trace
pFields[0]->ExtractTracePhys(Dtemperature[i], traceDtemperature[i]);
}
for(i = 0; i < nDimensions; ++i)
{
Vmath::Vmul(nTracePts,
&m_traceNormals[i][0], 1,
&traceDtemperature[i][0], 1,
&tmp[0],1);
Vmath::Vadd(nTracePts,
&traceFieldsAdded[11][0], 1,
&tmp[0], 1,
&traceFieldsAdded[11][0], 1);
}
/*** Evaluation of the pressure gradient ***********************************
* DP_t -> traceFieldsAdded[12] tangent direction
* DP_b -> traceFieldsAdded[13] binormal direction
* DP_x -> traceFieldsAdded[14]
* DP_y -> traceFieldsAdded[15]
* DP_z -> traceFieldsAdded[16]
***************************************************************************/
Array<OneD, Array<OneD, NekDouble> > Dpressure(nDimensions);
Array<OneD, Array<OneD, NekDouble> > traceDpressure(nDimensions);
for (i = 0; i < nDimensions; ++ i)
{
Dpressure[i] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
traceDpressure[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
}
for (i = 0; i < nDimensions; ++ i)
{
for (n = 0; n < nElements; n++)
{
phys_offset = pFields[0]->GetPhys_Offset(n);
pFields[i]->GetExp(n)->PhysDeriv(
i, pressure + phys_offset,
auxArray = Dpressure[i] + phys_offset);
}
// Extract trace
pFields[0]->ExtractTracePhys(Dpressure[i], traceDpressure[i]);
}
// Dp_t
for(i = 0; i < nDimensions; ++i)
{
Vmath::Vmul(nTracePts,
&m_traceTangents[i][0], 1,
&traceDpressure[i][0], 1,
&tmp[0],1);
Vmath::Vadd(nTracePts,
&traceFieldsAdded[12][0], 1,
&tmp[0], 1,
&traceFieldsAdded[12][0], 1);
}
// Dp_b
for(i = 0; i < nDimensions; ++i)
{
Vmath::Vmul(nTracePts,
&m_traceBinormals[i][0], 1,
&traceDpressure[i][0], 1,
&tmp[0],1);
Vmath::Vadd(nTracePts,
&traceFieldsAdded[13][0], 1,
&tmp[0], 1,
&traceFieldsAdded[13][0], 1);
}
// Dp_x
Vmath::Vcopy(nTracePts,
&traceDpressure[0][0], 1,
&traceFieldsAdded[14][0], 1);
// Dp_y
Vmath::Vcopy(nTracePts,
&traceDpressure[1][0], 1,
&traceFieldsAdded[15][0], 1);
// Dp_z
Vmath::Vcopy(nTracePts,
&traceDpressure[2][0], 1,
&traceFieldsAdded[16][0], 1);
/** Evaluation of the velocity gradient in the cartesian directions
* Du_x: traceFieldsAdded[17]
* Du_y: traceFieldsAdded[18]
* Du_z: traceFieldsAdded[19]
* Dv_x: traceFieldsAdded[20]
* Dv_y: traceFieldsAdded[21]
* Dv_z: traceFieldsAdded[22]
* Dw_x: traceFieldsAdded[23]
* Dw_y: traceFieldsAdded[24]
* Dw_z: traceFieldsAdded[25]
**/
Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Dvelocity(nDimensions);
Array<OneD, Array<OneD, Array<OneD, NekDouble> > > traceDvelocity(nDimensions);
Array<OneD, Array<OneD, NekDouble> > velocity(nDimensions);
for (i = 0; i < nDimensions; ++ i)
{
Dvelocity[i] = Array<OneD, Array<OneD, NekDouble> >(nDimensions);
traceDvelocity[i] = Array<OneD, Array<OneD, NekDouble> >(nDimensions);
velocity[i] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
Vmath::Vdiv(nSolutionPts, uFields[i+1], 1, uFields[0], 1,
velocity[i], 1);
for (j = 0; j < nDimensions; ++j)
{
Dvelocity[i][j] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
traceDvelocity[i][j] = Array<OneD, NekDouble>(nTracePts, 0.0);
}
}
for (i = 0; i < nDimensions; ++i)
{
for (j = 0; j < nDimensions; ++j)
{
for (n = 0; n < nElements; n++)
{
phys_offset = pFields[0]->GetPhys_Offset(n);
pFields[i]->GetExp(n)->PhysDeriv(
j, velocity[i] + phys_offset,
auxArray = Dvelocity[i][j] + phys_offset);
}
// Extract trace
pFields[0]->ExtractTracePhys(Dvelocity[i][j], traceDvelocity[i][j]);
}
}
Vmath::Vcopy(nTracePts,
&traceDvelocity[0][0][0], 1,
&traceFieldsAdded[17][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[0][1][0], 1,
&traceFieldsAdded[18][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[0][2][0], 1,
&traceFieldsAdded[19][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[1][0][0], 1,
&traceFieldsAdded[20][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[1][1][0], 1,
&traceFieldsAdded[21][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[1][2][0], 1,
&traceFieldsAdded[22][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[2][0][0], 1,
&traceFieldsAdded[23][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[2][1][0], 1,
&traceFieldsAdded[24][0], 1);
Vmath::Vcopy(nTracePts,
&traceDvelocity[2][2][0], 1,
&traceFieldsAdded[25][0], 1);
/*** Evaluation of shear stresses ******************************************
* tau_xx -> traceFieldsAdded[26]
* tau_yy -> traceFieldsAdded[27]
* tau_zz -> traceFieldsAdded[28]
* tau_xy -> traceFieldsAdded[29]
* tau_xz -> traceFieldsAdded[30]
* tau_yz -> traceFieldsAdded[31]
***************************************************************************/
// Stokes hypotesis
const NekDouble lambda = -2.0/3.0;
// Auxiliary variables
Array<OneD, NekDouble > mu (nSolutionPts, 0.0);
Array<OneD, NekDouble > mu2 (nSolutionPts, 0.0);
Array<OneD, NekDouble > divVel(nSolutionPts, 0.0);
// Variable viscosity through the Sutherland's law
if (m_ViscosityType == "Variable")
{
NekDouble mu_star = m_mu;
NekDouble T_star = m_pInf / (m_rhoInf * m_gasConstant);
NekDouble ratio;
for (int i = 0; i < nSolutionPts; ++i)
{
ratio = temperature[i] / T_star;
mu[i] = mu_star * ratio * sqrt(ratio) *
(T_star + 110.0) / (temperature[i] + 110.0);
}
}
else
{
Vmath::Fill(nSolutionPts, m_mu, &mu[0], 1);
}
// Computing diagonal terms of viscous stress tensor
Array<OneD, Array<OneD, NekDouble> > temp(m_spacedim);
Array<OneD, Array<OneD, NekDouble> > Sgg(m_spacedim);
// mu2 = 2 * mu
Vmath::Smul(nSolutionPts, 2.0, &mu[0], 1, &mu2[0], 1);
// Velocity divergence
Vmath::Vadd(nSolutionPts, &divVel[0], 1,
&Dvelocity[0][0][0], 1, &divVel[0], 1);
Vmath::Vadd(nSolutionPts, &divVel[0], 1,
&Dvelocity[1][1][0], 1, &divVel[0], 1);
// Velocity divergence scaled by lambda * mu
Vmath::Smul(nSolutionPts, lambda, &divVel[0], 1, &divVel[0], 1);
Vmath::Vmul(nSolutionPts, &mu[0], 1, &divVel[0], 1, &divVel[0], 1);
// Diagonal terms of viscous stress tensor (Sxx, Syy)
// Sjj = 2 * mu * du_j/dx_j - (2 / 3) * mu * sum_j(du_j/dx_j)
for (j = 0; j < m_spacedim; ++j)
{
temp[j] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
Sgg[j] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
Vmath::Vmul(nSolutionPts, &mu2[0], 1, &Dvelocity[j][j][0], 1,
&temp[j][0], 1);
Vmath::Vadd(nSolutionPts, &temp[j][0], 1, &divVel[0], 1, &Sgg[j][0], 1);
}
// Extra diagonal terms of viscous stress tensor
Array<OneD, NekDouble > Sxy(nSolutionPts, 0.0);
Array<OneD, NekDouble > Sxz(nSolutionPts, 0.0);
Array<OneD, NekDouble > Syz(nSolutionPts, 0.0);
// Sxy = (du/dy + dv/dx)
Vmath::Vadd(nSolutionPts, &Dvelocity[0][1][0], 1,
&Dvelocity[1][0][0], 1, &Sxy[0], 1);
// Sxz = (du/dz + dw/dx)
Vmath::Vadd(nSolutionPts, &Dvelocity[0][2][0], 1,
&Dvelocity[2][0][0], 1, &Sxz[0], 1);
// Syz = (dv/dz + dw/dy)
Vmath::Vadd(nSolutionPts, &Dvelocity[1][2][0], 1,
&Dvelocity[2][1][0], 1, &Syz[0], 1);
// Sxy = mu * (du/dy + dv/dx)
Vmath::Vmul(nSolutionPts, &mu[0], 1, &Sxy[0], 1, &Sxy[0], 1);
// Sxz = mu * (du/dy + dv/dx)
Vmath::Vmul(nSolutionPts, &mu[0], 1, &Sxz[0], 1, &Sxz[0], 1);
// Syz = mu * (du/dy + dv/dx)
Vmath::Vmul(nSolutionPts, &mu[0], 1, &Syz[0], 1, &Syz[0], 1);
pFields[0]->ExtractTracePhys(Sgg[0], traceFieldsAdded[26]);
pFields[0]->ExtractTracePhys(Sgg[1], traceFieldsAdded[27]);
pFields[0]->ExtractTracePhys(Sgg[2], traceFieldsAdded[28]);
pFields[0]->ExtractTracePhys(Sxy, traceFieldsAdded[29]);
pFields[0]->ExtractTracePhys(Sxz, traceFieldsAdded[30]);
pFields[0]->ExtractTracePhys(Syz, traceFieldsAdded[31]);
/*** Evaluation of dinamic viscosity ***************************************
* mu -> traceFieldsAdded[32]
***************************************************************************/
pFields[0]->ExtractTracePhys(mu, traceFieldsAdded[32]);
/*** Evaluation of Mach number *********************************************
* M -> traceFieldsAdded[33]
***************************************************************************/
NekDouble gamma = m_gamma;
// Speed of sound
Array<OneD, NekDouble> soundspeed(nSolutionPts, 0.0);
Vmath::Vdiv (nSolutionPts, pressure, 1, uFields[0], 1, soundspeed, 1);
Vmath::Smul (nSolutionPts, gamma, soundspeed, 1, soundspeed, 1);
Vmath::Vsqrt(nSolutionPts, soundspeed, 1, soundspeed, 1);
// Mach
Array<OneD, NekDouble> mach(nSolutionPts, 0.0);
for (int i = 0; i < m_spacedim; ++i)
{
Vmath::Vvtvp(nSolutionPts,
uFields[i + 1], 1,
uFields[i + 1], 1,
mach, 1, mach, 1);
}
Vmath::Vdiv(nSolutionPts, mach, 1, uFields[0], 1, mach, 1);
Vmath::Vdiv(nSolutionPts, mach, 1, uFields[0], 1, mach, 1);
Vmath::Vsqrt(nSolutionPts, mach, 1, mach, 1);
Vmath::Vdiv(nSolutionPts, mach, 1, soundspeed, 1, mach, 1);
pFields[0]->ExtractTracePhys(mach, traceFieldsAdded[33]);
/**************************************************************************/
// Extract coordinates
if (pFields[0]->GetBndCondExpansions().num_elements())
{
id1 = 0;
cnt = 0;
nBndRegions = pFields[0]->GetBndCondExpansions().num_elements();
for (b = 0; b < nBndRegions; ++b)
{
nBndEdges = pFields[0]->GetBndCondExpansions()[b]->GetExpSize();
for (e = 0; e < nBndEdges; ++e)
{
nBndEdgePts = pFields[0]->
GetBndCondExpansions()[b]->GetExp(e)->GetTotPoints();
id2 = pFields[0]->GetTrace()->
GetPhys_Offset(pFields[0]->GetTraceMap()->
GetBndCondTraceToGlobalTraceMap(cnt++));
if (pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "WallViscous" ||
pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "WallAdiabatic" ||
pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "Wall")
{
Vmath::Vcopy(nBndEdgePts, &traceX[id2], 1,
&surfaceX[id1], 1);
Vmath::Vcopy(nBndEdgePts, &traceY[id2], 1,
&surfaceY[id1], 1);
Vmath::Vcopy(nBndEdgePts, &traceZ[id2], 1,
&surfaceZ[id1], 1);
id1 += nBndEdgePts;
}
}
}
}
// Extract fields
if (pFields[0]->GetBndCondExpansions().num_elements())
{
for (j = 0; j < nfields; ++j)
{
cout << "field " << j << endl;
id1 = 0;
cnt = 0;
nBndRegions = pFields[j]->GetBndCondExpansions().num_elements();
for (b = 0; b < nBndRegions; ++b)
{
nBndEdges = pFields[j]->GetBndCondExpansions()[b]->GetExpSize();
for (e = 0; e < nBndEdges; ++e)
{
nBndEdgePts = pFields[j]->
GetBndCondExpansions()[b]->GetExp(e)->GetTotPoints();
id2 = pFields[j]->GetTrace()->
GetPhys_Offset(pFields[j]->GetTraceMap()->
GetBndCondTraceToGlobalTraceMap(cnt++));
if (pFields[j]->GetBndConditions()[b]->
GetUserDefined() == "WallViscous" ||
pFields[j]->GetBndConditions()[b]->
GetUserDefined() == "WallAdiabatic" ||
pFields[j]->GetBndConditions()[b]->
GetUserDefined() == "Wall")
{
Vmath::Vcopy(nBndEdgePts, &traceFields[j][id2], 1,
&surfaceFields[j][id1], 1);
id1 += nBndEdgePts;
}
}
}
}
}
// Extract fields added
if (pFields[0]->GetBndCondExpansions().num_elements())
{
for (j = 0; j < nfieldsAdded; ++j)
{
cout << "field added " << j << endl;
id1 = 0;
cnt = 0;
nBndRegions = pFields[0]->GetBndCondExpansions().num_elements();
for (b = 0; b < nBndRegions; ++b)
{
nBndEdges = pFields[0]->GetBndCondExpansions()[b]->GetExpSize();
for (e = 0; e < nBndEdges; ++e)
{
nBndEdgePts = pFields[0]->
GetBndCondExpansions()[b]->GetExp(e)->GetTotPoints();
id2 = pFields[0]->GetTrace()->
GetPhys_Offset(pFields[0]->GetTraceMap()->
GetBndCondTraceToGlobalTraceMap(cnt++));
if (pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "WallViscous" ||
pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "WallAdiabatic" ||
pFields[0]->GetBndConditions()[b]->
GetUserDefined() == "Wall")
{
Vmath::Vcopy(nBndEdgePts, &traceFieldsAdded[j][id2], 1,
&surfaceFieldsAdded[j][id1], 1);
id1 += nBndEdgePts;
}
}
}
}
}
//==========================================================================
//==========================================================================
//==========================================================================
// Print the surface coordinates and the surface solution in a .txt file
ofstream outfile;
outfile.open(fname.c_str());
outfile << "% x[m] " << " \t"
<< "y[m] " << " \t"
<< "z[m] " << " \t"
<< "nx[] " << " \t"
<< "ny[] " << " \t"
<< "nz[] " << " \t"
<< "bx[] " << " \t"
<< "by[] " << " \t"
<< "bz[] " << " \t"
<< "tx[] " << " \t"
<< "ty[] " << " \t"
<< "tz[] " << " \t"
<< "rho[kg/m^3] " << " \t"
<< "rhou[kg/(m^2 s)] " << " \t"
<< "rhov[kg/(m^2 s)] " << " \t"
<< "rhow[kg/(m^2 s)] " << " \t"
<< "E[Pa] " << " \t"
<< "p[Pa] " << " \t"
<< "T[k] " << " \t"
<< "dT/dn[k/m] " << " \t"
<< "dp/dT[Pa/m] " << " \t"
<< "dp/dB[Pa/m] " << " \t"
<< "dp/dx[Pa/m] " << " \t"
<< "dp/dy[Pa/m] " << " \t"
<< "dp/dz[Pa/m] " << " \t"
<< "du/dx[s^-1] " << " \t"
<< "du/dy[s^-1] " << " \t"
<< "du/dz[s^-1] " << " \t"
<< "dv/dx[s^-1] " << " \t"
<< "dv/dy[s^-1] " << " \t"
<< "dv/dz[s^-1] " << " \t"
<< "dw/dx[s^-1] " << " \t"
<< "dw/dy[s^-1] " << " \t"
<< "dw/dz[s^-1] " << " \t"
<< "tau_xx[Pa] " << " \t"
<< "tau_yy[Pa] " << " \t"
<< "tau_zz[Pa] " << " \t"
<< "tau_xy[Pa] " << " \t"
<< "tau_xz[Pa] " << " \t"
<< "tau_yz[Pa] " << " \t"
<< "mu[Pa s] " << " \t"
<< "M[] " << " \t"
<< endl;
for (i = 0; i < nSurfacePts; ++i)
{
outfile << scientific
<< setw (17)
<< setprecision(16)
<< surfaceX[i] << " \t "
<< surfaceY[i] << " \t "
<< surfaceZ[i] << " \t "
<< surfaceFieldsAdded[0][i] << " \t "
<< surfaceFieldsAdded[1][i] << " \t "
<< surfaceFieldsAdded[2][i] << " \t "
<< surfaceFieldsAdded[3][i] << " \t "
<< surfaceFieldsAdded[4][i] << " \t "
<< surfaceFieldsAdded[5][i] << " \t "
<< surfaceFieldsAdded[6][i] << " \t "
<< surfaceFieldsAdded[7][i] << " \t "
<< surfaceFieldsAdded[8][i] << " \t "
<< surfaceFields[0][i] << " \t "
<< surfaceFields[1][i] << " \t "
<< surfaceFields[2][i] << " \t "
<< surfaceFields[3][i] << " \t "
<< surfaceFields[4][i] << " \t "
<< surfaceFieldsAdded[9][i] << " \t "
<< surfaceFieldsAdded[10][i] << " \t "
<< surfaceFieldsAdded[11][i] << " \t "
<< surfaceFieldsAdded[12][i] << " \t "
<< surfaceFieldsAdded[13][i] << " \t "
<< surfaceFieldsAdded[14][i] << " \t "
<< surfaceFieldsAdded[15][i] << " \t "
<< surfaceFieldsAdded[16][i] << " \t "
<< surfaceFieldsAdded[17][i] << " \t "
<< surfaceFieldsAdded[18][i] << " \t "
<< surfaceFieldsAdded[19][i] << " \t "
<< surfaceFieldsAdded[20][i] << " \t "
<< surfaceFieldsAdded[21][i] << " \t "
<< surfaceFieldsAdded[22][i] << " \t "
<< surfaceFieldsAdded[23][i] << " \t "
<< surfaceFieldsAdded[24][i] << " \t "
<< surfaceFieldsAdded[25][i] << " \t "
<< surfaceFieldsAdded[26][i] << " \t "
<< surfaceFieldsAdded[27][i] << " \t "
<< surfaceFieldsAdded[28][i] << " \t "
<< surfaceFieldsAdded[29][i] << " \t "
<< surfaceFieldsAdded[30][i] << " \t "
<< surfaceFieldsAdded[31][i] << " \t "
<< surfaceFieldsAdded[32][i] << " \t "
<< surfaceFieldsAdded[33][i] << " \t "
<< endl;
}
outfile << endl << endl;
outfile.close();
return 0;
}
int main(int argc, char *argv[])
{
unsigned int i,j;
if(argc < 3)
{
fprintf(stderr,"Usage: FldToPts meshfile fieldfile(s)\n");
exit(1);
}
int nExtraPoints;
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
vSession->LoadParameter("OutputExtraPoints",nExtraPoints,0);
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graphShPt = SpatialDomains::MeshGraph::Read(vSession);//->GetFilename(), false);
//----------------------------------------------
for (int n = 2; n < argc; ++n)
{
string fname = std::string(argv[n]);
int fdot = fname.find_last_of('.');
if (fdot != std::string::npos)
{
string ending = fname.substr(fdot);
if (ending == ".chk" || ending == ".fld")
{
fname = fname.substr(0,fdot);
}
}
fname = fname + ".pts";
if (argc > 3)
{
if (fexist(fname.c_str()))
{
cout << "Skipping converted file: " << argv[n] << endl;
continue;
}
cout << "Processing " << argv[n] << endl;
}
//----------------------------------------------
// Import field file.
string fieldfile(argv[n]);
vector<SpatialDomains::FieldDefinitionsSharedPtr> fielddef;
vector<vector<NekDouble> > fielddata;
graphShPt->Import(fieldfile,fielddef,fielddata);
bool useFFT = false;
bool dealiasing = false;
//----------------------------------------------
//----------------------------------------------
// Set up Expansion information
for(i = 0; i < fielddef.size(); ++i)
{
vector<LibUtilities::PointsType> ptype;
for(j = 0; j < 3; ++j)
{
ptype.push_back(LibUtilities::ePolyEvenlySpaced);
}
fielddef[i]->m_pointsDef = true;
fielddef[i]->m_points = ptype;
vector<unsigned int> porder;
if(fielddef[i]->m_numPointsDef == false)
{
for(j = 0; j < fielddef[i]->m_numModes.size(); ++j)
{
porder.push_back(fielddef[i]->m_numModes[j]+nExtraPoints);
}
fielddef[i]->m_numPointsDef = true;
}
else
{
for(j = 0; j < fielddef[i]->m_numPoints.size(); ++j)
{
porder.push_back(fielddef[i]->m_numPoints[j]+nExtraPoints);
}
}
fielddef[i]->m_numPoints = porder;
}
graphShPt->SetExpansions(fielddef);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int expdim = graphShPt->GetMeshDimension();
int nfields = fielddef[0]->m_fields.size();
Array<OneD, MultiRegions::ExpListSharedPtr> Exp(nfields);
switch(expdim)
{
case 1:
{
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 2,"NumHomogeneousDir is only set up for 1 or 2");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
// Define Homogeneous expansion
//int nplanes = fielddef[0]->m_numModes[1];
int nplanes;
vSession->LoadParameter("HomModesZ",nplanes,fielddef[0]->m_numModes[1]);
// choose points to be at evenly spaced points at
const LibUtilities::PointsKey Pkey(nplanes+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[1],nplanes,Pkey);
NekDouble ly = fielddef[0]->m_homogeneousLengths[0];
Exp2DH1 = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(vSession,Bkey,ly,useFFT,dealiasing,graphShPt);
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(*Exp2DH1);
}
}
else if(fielddef[0]->m_numHomogeneousDir == 2)
{
MultiRegions::ExpList3DHomogeneous2DSharedPtr Exp3DH2;
// Define Homogeneous expansion
//int nylines = fielddef[0]->m_numModes[1];
//int nzlines = fielddef[0]->m_numModes[2];
int nylines;
int nzlines;
vSession->LoadParameter("HomModesY",nylines,fielddef[0]->m_numModes[1]);
vSession->LoadParameter("HomModesZ",nzlines,fielddef[0]->m_numModes[2]);
// choose points to be at evenly spaced points at
const LibUtilities::PointsKey PkeyY(nylines+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey BkeyY(fielddef[0]->m_basis[1],nylines,PkeyY);
const LibUtilities::PointsKey PkeyZ(nzlines+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey BkeyZ(fielddef[0]->m_basis[2],nzlines,PkeyZ);
NekDouble ly = fielddef[0]->m_homogeneousLengths[0];
NekDouble lz = fielddef[0]->m_homogeneousLengths[1];
Exp3DH2 = MemoryManager<MultiRegions::ExpList3DHomogeneous2D>::AllocateSharedPtr(vSession,BkeyY,BkeyZ,ly,lz,useFFT,dealiasing,graphShPt);
Exp[0] = Exp3DH2;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3DHomogeneous2D>::AllocateSharedPtr(*Exp3DH2);
}
}
else
{
MultiRegions::ExpList1DSharedPtr Exp1D;
Exp1D = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp1D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(*Exp1D);
}
}
}
break;
case 2:
{
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 1,"NumHomogeneousDir is only set up for 1");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
// Define Homogeneous expansion
//int nplanes = fielddef[0]->m_numModes[2];
int nplanes;
vSession->LoadParameter("HomModesZ",nplanes,fielddef[0]->m_numModes[2]);
// choose points to be at evenly spaced points at
// nplanes + 1 points
const LibUtilities::PointsKey Pkey(nplanes+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[2],nplanes,Pkey);
NekDouble lz = fielddef[0]->m_homogeneousLengths[0];
Exp3DH1 = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(vSession,Bkey,lz,useFFT,dealiasing,graphShPt);
Exp[0] = Exp3DH1;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(*Exp3DH1);
}
}
else
{
MultiRegions::ExpList2DSharedPtr Exp2D;
Exp2D = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp2D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(*Exp2D);
}
}
}
break;
case 3:
{
MultiRegions::ExpList3DSharedPtr Exp3D;
Exp3D = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp3D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(*Exp3D);
}
}
break;
default:
ASSERTL0(false,"Expansion dimension not recognised");
break;
}
//----------------------------------------------
//----------------------------------------------
// Copy data from field file
for(j = 0; j < nfields; ++j)
{
for(int i = 0; i < fielddata.size(); ++i)
{
Exp[j]->ExtractDataToCoeffs(fielddef [i],
fielddata[i],
fielddef [i]->m_fields[j],
Exp[j]->UpdateCoeffs());
}
Exp[j]->BwdTrans(Exp[j]->GetCoeffs(),Exp[j]->UpdatePhys());
}
//----------------------------------------------
//----------------------------------------------
// Write solution
//string outname(strtok(argv[n],"."));
//outname += ".vtu";
ofstream outfile(fname.c_str());
// For each field write out field data for each expansion.
outfile << "Fields: x y ";
for(i = 0; i < Exp.num_elements(); ++i)
{
outfile << fielddef[0]->m_fields[i];
}
outfile << endl;
Array<OneD,NekDouble> x(Exp[0]->GetNpoints());
Array<OneD,NekDouble> y(Exp[0]->GetNpoints());
Exp[0]->GetCoords(x,y);
for(i = 0; i < Exp[0]->GetNpoints(); ++i)
{
outfile << x[i] << " " << y[i] << " ";
for(j = 0; j < Exp.num_elements(); ++j)
{
outfile << (Exp[j]->GetPhys())[i] << " ";
}
outfile << endl;
}
cout << "Written file: " << fname << endl;
//----------------------------------------------
}
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);
MultiRegions::ContField2DSharedPtr Exp,Fce;
int nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
NekDouble lambda;
NekDouble ax,ay;
if((argc != 2)&&(argc != 3))
{
fprintf(stderr,"Usage: SteadyLinearAdvectionReaction2D meshfile [SysSolnType]\n");
exit(1);
}
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph2D = MemoryManager<SpatialDomains::MeshGraph2D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Get Advection Velocity
ax = vSession->GetParameter("Advection_x");
ay = vSession->GetParameter("Advection_y");
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
lambda = vSession->GetParameter("Lambda");
cout << " Lambda : " << lambda << endl;
const SpatialDomains::ExpansionMap &expansions = graph2D->GetExpansions();
LibUtilities::BasisKey bkey0
= expansions.begin()->second->m_basisKeyVector[0];
LibUtilities::BasisKey bkey1
= expansions.begin()->second->m_basisKeyVector[1];
cout << "Solving Steady 2D LinearAdvection :" << endl;
cout << " Advection_x : " << ax << endl;
cout << " Advection_y : " << ay << endl;
cout << " Expansion : (" << LibUtilities::BasisTypeMap[bkey0.GetBasisType()] <<","<< LibUtilities::BasisTypeMap[bkey1.GetBasisType()] << ")" << endl;
cout << " No. modes : " << bkey0.GetNumModes() << endl;
cout << endl;
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::ContField2D>::
AllocateSharedPtr(vSession,graph2D,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;
}
Array<OneD, Array< OneD, NekDouble> > Vel(2);
Vel[0] = Array<OneD, NekDouble> (nq,ax);
Vel[1] = Array<OneD, NekDouble> (nq,ay);
//----------------------------------------------
//----------------------------------------------
// 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::ContField2D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
Timing("Define forcing ..");
//----------------------------------------------
// Helmholtz solution taking physical forcing
Exp->LinearAdvectionReactionSolve(Vel, Fce->GetPhys(), Exp->UpdateCoeffs(), lambda, MultiRegions::eGlobal);
//----------------------------------------------
Timing("Linear Advection Solve ..");
//----------------------------------------------
// Backward Transform Solution to get solved values
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys(), MultiRegions::eGlobal);
//----------------------------------------------
//----------------------------------------------
// 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);
cout << "L infinity error: " << Exp->Linf(Fce->GetPhys()) << endl;
cout << "L 2 error: " << Exp->L2 (Fce->GetPhys()) << endl;
//--------------------------------------------
}
//----------------------------------------------
vSession->Finalise();
return 0;
}
int main(int argc, char *argv[])
{
int cnt;
int id1, id2;
int i, j, e, b;
int nBndEdgePts, nBndEdges, nBndRegions;
if (argc < 3)
{
fprintf(stderr,
"Usage: ExtractSurface2DCFS meshfile fieldFile\n");
fprintf(stderr,
"Extracts a surface from a 2D fld file"
"(only for CompressibleFlowSolver and purely 2D .fld files)\n");
exit(1);
}
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(3, argv);
//--------------------------------------------------------------------------
// Read in mesh from input file
string meshfile(argv[1]);
SpatialDomains::MeshGraphSharedPtr graphShPt =
SpatialDomains::MeshGraph::Read(vSession);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Import field file
string fieldFile(argv[2]);
vector<LibUtilities::FieldDefinitionsSharedPtr> fieldDef;
vector<vector<NekDouble> > fieldData;
LibUtilities::Import(fieldFile, fieldDef, fieldData);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Set up Expansion information
vector< vector<LibUtilities::PointsType> > pointsType;
for (i = 0; i < fieldDef.size(); ++i)
{
vector<LibUtilities::PointsType> ptype;
for (j = 0; j < 2; ++j)
{
ptype.push_back(LibUtilities::ePolyEvenlySpaced);
}
pointsType.push_back(ptype);
}
graphShPt->SetExpansions(fieldDef, pointsType);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Define Expansion
int nfields = fieldDef[0]->m_fields.size();
Array<OneD, MultiRegions::ExpListSharedPtr> Exp(nfields);
Array<OneD, MultiRegions::ExpListSharedPtr> pFields(nfields);
for(i = 0; i < pFields.num_elements(); i++)
{
pFields[i] = MemoryManager<MultiRegions
::DisContField2D>::AllocateSharedPtr(vSession, graphShPt,
vSession->GetVariable(i));
}
MultiRegions::ExpList2DSharedPtr Exp2D;
Exp2D = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(vSession, graphShPt);
Exp[0] = Exp2D;
for (i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(*Exp2D);
}
int nSolutionPts = pFields[0]->GetNpoints();
int nTracePts = pFields[0]->GetTrace()->GetTotPoints();
Array<OneD, NekDouble> x(nSolutionPts);
Array<OneD, NekDouble> y(nSolutionPts);
Array<OneD, NekDouble> z(nSolutionPts);
Array<OneD, NekDouble> traceX(nTracePts);
Array<OneD, NekDouble> traceY(nTracePts);
Array<OneD, NekDouble> traceZ(nTracePts);
Array<OneD, NekDouble> surfaceX(nTracePts);
Array<OneD, NekDouble> surfaceY(nTracePts);
Array<OneD, NekDouble> surfaceZ(nTracePts);
pFields[0]->GetCoords(x, y, z);
pFields[0]->ExtractTracePhys(x, traceX);
pFields[0]->ExtractTracePhys(y, traceY);
pFields[0]->ExtractTracePhys(z, traceZ);
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// Copy data from field file
Array<OneD, Array<OneD, NekDouble> > uFields(nfields);
Array<OneD, Array<OneD, NekDouble> > traceFields(nfields);
Array<OneD, Array<OneD, NekDouble> > surfaceFields(nfields);
// Extract the physical values of the solution at the boundaries
for (j = 0; j < nfields; ++j)
{
uFields[j] = Array<OneD, NekDouble>(nSolutionPts, 0.0);
traceFields[j] = Array<OneD, NekDouble>(nTracePts, 0.0);
surfaceFields[j] = Array<OneD, NekDouble>(nTracePts, 0.0);
for (i = 0; i < fieldData.size(); ++i)
{
Exp[j]->ExtractDataToCoeffs(fieldDef[i], fieldData[i],
fieldDef[i]->m_fields[j],
Exp[j]->UpdateCoeffs());
}
Exp[j]->BwdTrans(Exp[j]->GetCoeffs(), Exp[j]->UpdatePhys());
Vmath::Vcopy(nSolutionPts, Exp[j]->GetPhys(), 1, uFields[j], 1);
pFields[0]->ExtractTracePhys(uFields[j], traceFields[j]);
}
//--------------------------------------------------------------------------
if (pFields[0]->GetBndCondExpansions().num_elements())
{
id1 = 0;
cnt = 0;
nBndRegions = pFields[0]->GetBndCondExpansions().num_elements();
for (b = 0; b < nBndRegions; ++b)
{
nBndEdges = pFields[0]->GetBndCondExpansions()[b]->GetExpSize();
for (e = 0; e < nBndEdges; ++e)
{
nBndEdgePts = pFields[0]->
GetBndCondExpansions()[b]->GetExp(e)->GetNumPoints(0);
id2 = pFields[0]->GetTrace()->
GetPhys_Offset(pFields[0]->GetTraceMap()->
GetBndCondTraceToGlobalTraceMap(cnt++));
if (pFields[0]->GetBndConditions()[b]->
GetUserDefined() == SpatialDomains::eWallViscous ||
pFields[0]->GetBndConditions()[b]->
GetUserDefined() == SpatialDomains::eWall)
{
Vmath::Vcopy(nBndEdgePts, &traceX[id2], 1,
&surfaceX[id1], 1);
Vmath::Vcopy(nBndEdgePts, &traceY[id2], 1,
&surfaceY[id1], 1);
Vmath::Vcopy(nBndEdgePts, &traceZ[id2], 1,
&surfaceZ[id1], 1);
id1 += nBndEdgePts;
}
}
}
}
if (pFields[0]->GetBndCondExpansions().num_elements())
{
for (j = 0; j < nfields; ++j)
{
id1 = 0;
cnt = 0;
nBndRegions = pFields[j]->GetBndCondExpansions().num_elements();
for (b = 0; b < nBndRegions; ++b)
{
nBndEdges = pFields[j]->GetBndCondExpansions()[b]->GetExpSize();
for (e = 0; e < nBndEdges; ++e)
{
nBndEdgePts = pFields[j]->
GetBndCondExpansions()[b]->GetExp(e)->GetNumPoints(0);
id2 = pFields[j]->GetTrace()->
GetPhys_Offset(pFields[j]->GetTraceMap()->
GetBndCondTraceToGlobalTraceMap(cnt++));
if (pFields[j]->GetBndConditions()[b]->
GetUserDefined() == SpatialDomains::eWallViscous ||
pFields[j]->GetBndConditions()[b]->
GetUserDefined() == SpatialDomains::eWall)
{
Vmath::Vcopy(nBndEdgePts, &traceFields[j][id2], 1,
&surfaceFields[j][id1], 1);
id1 += nBndEdgePts;
}
}
}
}
}
// Print the surface coordinates and the surface solution in a .txt file
ofstream outfile;
outfile.open("surfaceQuantities.txt");
for (i = 0; i < id1; ++i)
{
outfile << scientific
<< setw (17)
<< setprecision(16)
<< surfaceX[i] << " \t "
<< surfaceY[i] << " \t "
<< surfaceZ[i] << " \t "
<< surfaceFields[0][i] << " \t "
<< surfaceFields[1][i] << " \t "
<< surfaceFields[2][i] << " \t "
<< surfaceFields[3][i] << " \t "
<< endl;
}
outfile << endl << endl;
outfile.close();
/*
//--------------------------------------------------------------------------
// Copy data from field file
// Extract the physical values of the solution at the boundaries
for (j = 0; j < nfields; ++j)
{
cnt = 0;
nBndRegions = Exp[j]->GetBndCondExpansions().num_elements();
for (b = 0; b < nBndRegions; ++b)
{
nBndEdges = Exp[j]->GetBndCondExpansions()[b]->GetExpSize();
for (e = 0; e < nBndEdges; ++e)
{
nBndEdgePts = Exp[j]->
GetBndCondExpansions()[b]->GetExp(e)->GetNumPoints(0);
id1 = Exp[j]->GetBndCondExpansions()[b]->GetPhys_Offset(e);
id2 = Exp[0]->GetTrace()->
GetPhys_Offset(Exp[0]->GetTraceMap()->
GetBndCondTraceToGlobalTraceMap(cnt++));
for (i = 0; i < fieldData.size(); ++i)
{
if (Exp[j]->GetBndConditions()[b]->
GetUserDefined() == SpatialDomains::eWallViscous ||
Exp[j]->GetBndConditions()[b]->
GetUserDefined() == SpatialDomains::eWall)
{
Exp[j]->ExtractDataToCoeffs(fieldDef[i], fieldData[i],
fieldDef[i]->m_fields[j],
Exp[j]->UpdateCoeffs());
}
}
}
}
Exp[j]->BwdTrans(Exp[j]->GetCoeffs(), Exp[j]->UpdatePhys());
}
//--------------------------------------------------------------------------
*/
/*
//----------------------------------------------
// Probe data fields
Array<OneD, Array<OneD, NekDouble> > gloCoord();
for (int i = 0; i < N; ++i)
{
gloCoord[0] = x0 + i*dx;
gloCoord[1] = y0 + i*dy;
gloCoord[2] = z0 + i*dz;
cout << gloCoord[0] << " " << gloCoord[1] << " " << gloCoord[2];
int ExpId = Exp[0]->GetExpIndex(gloCoord, NekConstants::kGeomFactorsTol);
for (int j = 0; j < nfields; ++j)
{
Exp[j]->PutPhysInToElmtExp();
cout << " " << Exp[j]->GetExp(ExpId)->PhysEvaluate(gloCoord);
}
cout << endl;
}
*/
//----------------------------------------------
return 0;
}
int main(int argc, char *argv[])
{
int i;
NekDouble cr = 0;
if(argc !=3)
{
fprintf(stderr,"Usage: ./ExtractCriticalLayer meshfile fieldfile \n");
exit(1);
}
//------------------------------------------------------------
// Create Session file.
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
//-----------------------------------------------------------
//-------------------------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graphShPt = SpatialDomains::MeshGraph::Read(vSession);
//------------------------------------------------------------
//-------------------------------------------------------------
// Define Streak Expansion
MultiRegions::ExpListSharedPtr streak;
streak = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(vSession,graphShPt);
//---------------------------------------------------------------
//----------------------------------------------
// Import field file.
string fieldfile(argv[argc-1]);
vector<LibUtilities::FieldDefinitionsSharedPtr> fielddef;
vector<vector<NekDouble> > fielddata;
LibUtilities::Import(fieldfile,fielddef,fielddata);
//----------------------------------------------
//----------------------------------------------
// Copy data from field file
string streak_field("w");
for(unsigned int i = 0; i < fielddata.size(); ++i)
{
streak->ExtractDataToCoeffs(fielddef [i],
fielddata[i],
streak_field,
streak->UpdateCoeffs());
}
//----------------------------------------------
int npts;
vSession->LoadParameter("NumCriticalLayerPts",npts,30);
Array<OneD, NekDouble> x_c(npts);
Array<OneD, NekDouble> y_c(npts);
NekDouble trans;
vSession->LoadParameter("WidthOfLayers",trans,0.1);
Computestreakpositions(streak,x_c, y_c,cr,trans);
cout << "# x_c y_c" << endl;
for(i = 0; i < npts; ++i)
{
fprintf(stdout,"%12.10lf %12.10lf \n",x_c[i],y_c[i]);
//cout << x_c[i] << " " << y_c[i] << 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);
MultiRegions::ContField3DSharedPtr Exp,Fce;
int i, j, nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
if(argc != 2)
{
fprintf(stderr,"Usage: ProjectCont3D meshfile \n");
exit(1);
}
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph3D = MemoryManager<SpatialDomains::MeshGraph3D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
const SpatialDomains::ExpansionMap &expansions = graph3D->GetExpansions();
LibUtilities::BasisKey bkey
= expansions.begin()->second->m_basisKeyVector[0];
int nmodes = bkey.GetNumModes();
cout << "Solving 3D C0 continuous Projection" << endl;
cout << " No. modes : " << nmodes << endl;
cout << endl;
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::ContField3D>
::AllocateSharedPtr(vSession,graph3D,vSession->GetVariable(0));
//----------------------------------------------
//----------------------------------------------
// 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
fce = Array<OneD,NekDouble>(nq);
for(i = 0; i < nq; ++i)
{
fce[i] = 0.0;
for(j = 0; j < nmodes; ++j)
{
fce[i] += pow(xc0[i],j);
fce[i] += pow(xc1[i],j);
fce[i] += pow(xc2[i],j);
}
}
//---------------------------------------------
// Set up ExpList1D containing the solution
Fce = MemoryManager<MultiRegions::ContField3D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//---------------------------------------------
//----------------------------------------------
// Write solution
//ofstream outfile("ProjectContFileOrig3D.dat");
//Fce->WriteToFile(outfile,eGnuplot);
//outfile.close();
//----------------------------------------------
//---------------------------------------------
// Project onto Expansion
Exp->FwdTrans(Fce->GetPhys(), Exp->UpdateCoeffs(), MultiRegions::eGlobal);
//---------------------------------------------
//-------------------------------------------
// Backward Transform Solution to get projected values
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys(), MultiRegions::eGlobal);
//-------------------------------------------
//----------------------------------------------
// Write solution
//ofstream outfile2("ProjectContFile3D.dat");
//Exp->WriteToFile(outfile2,eGnuplot);
//outfile2.close();
//----------------------------------------------
//--------------------------------------------
// Calculate L_inf error
cout << "L infinity error: " << Exp->Linf(Fce->GetPhys()) << endl;
cout << "L 2 error: " << Exp->L2 (Fce->GetPhys()) << 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::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);
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[])
{
int i,j;
int surfID;
if(argc != 5)
{
fprintf(stderr,"Usage: FldAddScalGrad meshfile infld outfld BoundaryID\n");
exit(1);
}
surfID = boost::lexical_cast<int>(argv[argc - 1]);
argv[argc -1] = argv[argc - 2];
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
//----------------------------------------------
// Read in mesh from input file
string meshfile(argv[argc-4]);
SpatialDomains::MeshGraphSharedPtr graphShPt = SpatialDomains::MeshGraph::Read(vSession);
//----------------------------------------------
//----------------------------------------------
// Import field file.
string fieldfile(argv[argc-3]);
vector<LibUtilities::FieldDefinitionsSharedPtr> fielddef;
vector<vector<NekDouble> > fielddata;
LibUtilities::Import(fieldfile,fielddef,fielddata);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int expdim = graphShPt->GetMeshDimension();
int nfields = 1;
int addfields = 7;
Array<OneD, MultiRegions::ExpListSharedPtr> exp(nfields + addfields);
MultiRegions::AssemblyMapCGSharedPtr m_locToGlobalMap;
switch(expdim)
{
case 1:
{
ASSERTL0(false,"Expansion dimension not recognised");
}
break;
case 2:
{
ASSERTL0(false,"Expansion dimension not recognised");
}
break;
case 3:
{
MultiRegions::ContField3DSharedPtr originalfield =
MemoryManager<MultiRegions::ContField3D>
::AllocateSharedPtr(vSession, graphShPt,
vSession->GetVariable(0));
m_locToGlobalMap = originalfield->GetLocalToGlobalMap();
exp[0] = originalfield;
for (i=0; i<addfields; i++)
{
exp[i+1] = MemoryManager<MultiRegions::ContField3D>
::AllocateSharedPtr(*originalfield, graphShPt,
vSession->GetVariable(0));
}
}
break;
default:
ASSERTL0(false,"Expansion dimension not recognised");
break;
}
//----------------------------------------------
//----------------------------------------------
// Copy data from field file
for(j = 0; j < nfields+addfields; ++j)
{
for(int i = 0; i < fielddata.size(); ++i)
{
exp[j]->ExtractDataToCoeffs(fielddef [i],
fielddata[i],
fielddef [i]->m_fields[0],
exp[j]->UpdateCoeffs());
}
exp[j]->BwdTrans(exp[j]->GetCoeffs(),exp[j]->UpdatePhys());
}
//----------------------------------------------
//----------------------------------------------
int n, cnt, elmtid, nq, offset, nt, boundary, nfq;
nt = exp[0]->GetNpoints();
Array<OneD, Array<OneD, NekDouble> > grad(expdim);
Array<OneD, Array<OneD, NekDouble> > fgrad(expdim);
Array<OneD, Array<OneD, NekDouble> > values(addfields);
// Set up mapping from Boundary condition to element details.
StdRegions::StdExpansionSharedPtr elmt;
StdRegions::StdExpansion2DSharedPtr bc;
Array<OneD, int> BoundarytoElmtID;
Array<OneD, int> BoundarytoTraceID;
Array<OneD, Array<OneD, MultiRegions::ExpListSharedPtr> > BndExp(addfields);
Array<OneD, const NekDouble> U(nt);
Array<OneD, NekDouble> outvalues;
exp[0]->GetBoundaryToElmtMap(BoundarytoElmtID,BoundarytoTraceID);
//get boundary expansions for each field
for (i = 0; i<addfields; i++)
{
BndExp[i] = exp[i]->GetBndCondExpansions();
}
// loop over the types of boundary conditions
for(cnt = n = 0; n < BndExp[0].num_elements(); ++n)
{
// identify boundary which the user wanted
if(n == surfID)
{
for(i = 0; i < BndExp[0][n]->GetExpSize(); ++i, cnt++)
{
// find element and face of this expansion.
elmtid = BoundarytoElmtID[cnt];
elmt = exp[0]->GetExp(elmtid);
nq = elmt->GetTotPoints();
offset = exp[0]->GetPhys_Offset(elmtid);
// Initialise local arrays for the velocity gradients
// size of total number of quadrature points for each element (hence local).
for(j = 0; j < expdim; ++j)
{
grad[j] = Array<OneD, NekDouble>(nq);
}
if(expdim == 2)
{
}
else
{
for (j = 0; j< addfields; j++)
{
values[j] = BndExp[j][n]->UpdateCoeffs() + BndExp[j][n]->GetCoeff_Offset(i);
}
// Get face 2D expansion from element expansion
bc = boost::dynamic_pointer_cast<StdRegions::StdExpansion2D> (BndExp[0][n]->GetExp(i));
// Number of face quadrature points
nfq = bc->GetTotPoints();
//identify boundary of element
boundary = BoundarytoTraceID[cnt];
//Extract scalar field
U = exp[0]->GetPhys() + offset;
//Compute gradients
elmt->PhysDeriv(U,grad[0],grad[1],grad[2]);
if(i ==0)
{
for (j = 0; j< nq; j++)
{
cout << "element grad: " << grad[0][j] << endl;
}
}
for(j = 0; j < expdim; ++j)
{
fgrad[j] = Array<OneD, NekDouble>(nfq);
}
// Get gradient at the quadrature points of the face
for(j = 0; j < expdim; ++j)
{
elmt->GetFacePhysVals(boundary,bc,grad[j],fgrad[j]);
bc->FwdTrans(fgrad[j],values[j]);
}
if(i ==0)
{
for (j = 0; j< nfq; j++)
{
cout << "face grad: " << fgrad[0][j] << endl;
}
}
const SpatialDomains::GeomFactorsSharedPtr m_metricinfo=bc->GetMetricInfo();
const Array<OneD, const Array<OneD, NekDouble> > normals
= elmt->GetFaceNormal(boundary);
Array<OneD, NekDouble> gradnorm(nfq);
if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
{
Vmath::Vvtvvtp(nfq,normals[0],1,fgrad[0],1,
normals[1],1,fgrad[1],1,gradnorm,1);
Vmath::Vvtvp (nfq,normals[2],1,fgrad[2],1,gradnorm,1,gradnorm,1);
}
else
{
Vmath::Svtsvtp(nfq,normals[0][0],fgrad[0],1,
normals[1][0],fgrad[1],1,gradnorm,1);
Vmath::Svtvp(nfq,normals[2][0],fgrad[2],1,gradnorm,1,gradnorm,1);
}
for(j = 0; j<expdim; j++)
{
bc->FwdTrans(normals[j],values[j+expdim]);
}
//gradient (grad(u) n)
Vmath::Smul(nfq,-1.0,gradnorm,1,gradnorm,1);
bc->FwdTrans(gradnorm,values[expdim*2]);
}
}
}
else
{
cnt += BndExp[0][n]->GetExpSize();
}
}
for(int j = 0; j < addfields; ++j)
{
int ncoeffs = exp[0]->GetNcoeffs();
Array<OneD, NekDouble> output(ncoeffs);
output=exp[j+1]->UpdateCoeffs();
int nGlobal=m_locToGlobalMap->GetNumGlobalCoeffs();
Array<OneD, NekDouble> outarray(nGlobal,0.0);
int bndcnt=0;
const Array<OneD,const int>& map = m_locToGlobalMap->GetBndCondCoeffsToGlobalCoeffsMap();
NekDouble sign;
for(int i = 0; i < BndExp[j].num_elements(); ++i)
{
if(i==surfID)
{
const Array<OneD,const NekDouble>& coeffs = BndExp[j][i]->GetCoeffs();
for(int k = 0; k < (BndExp[j][i])->GetNcoeffs(); ++k)
{
sign = m_locToGlobalMap->GetBndCondCoeffsToGlobalCoeffsSign(bndcnt);
outarray[map[bndcnt++]] = sign * coeffs[k];
}
}
else
{
bndcnt += BndExp[j][i]->GetNcoeffs();
}
}
m_locToGlobalMap->GlobalToLocal(outarray,output);
}
//-----------------------------------------------
// Write solution to file with additional computed fields
string out(argv[argc-2]);
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= exp[0]->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
vector<string > outname;
outname.push_back("du/dx");
outname.push_back("du/dy");
outname.push_back("du/dz");
outname.push_back("nx");
outname.push_back("ny");
outname.push_back("nz");
outname.push_back("gradient");
for(j = 0; j < nfields+addfields; ++j)
{
for(i = 0; i < FieldDef.size(); ++i)
{
if (j >= nfields)
{
FieldDef[i]->m_fields.push_back(outname[j-nfields]);
}
else
{
FieldDef[i]->m_fields.push_back(fielddef[i]->m_fields[j]);
}
exp[j]->AppendFieldData(FieldDef[i], FieldData[i]);
}
}
LibUtilities::Write(out, FieldDef, FieldData);
//-----------------------------------------------
return 0;
}
Driver::Driver(const LibUtilities::SessionReaderSharedPtr pSession)
: m_comm(pSession->GetComm()),
m_session(pSession)
{
}
/**
* Allocates a new DNekSparseMat object from the given specification.
* @param rows Number of rows in matrix.
* @param columns Number of columns in matrix.
* @param cooMat ?
*/
GlobalMatrix::GlobalMatrix(
const LibUtilities::SessionReaderSharedPtr& pSession,
unsigned int rows,
unsigned int columns,
const COOMatType &cooMat,
const MatrixStorage& matStorage):
m_smvbsrmatrix(),
m_rows(rows),
m_mulCallsCounter(0)
{
MatrixStorageType storageType = pSession->
GetSolverInfoAsEnum<MatrixStorageType>("GlobalMatrixStorageType");
unsigned int brows, bcols;
// Size of dense matrix sub-blocks
int block_size = 1;
BCOMatType bcoMat;
// assuming current sparse format allows
// block-sparse data representation
if(pSession->DefinesParameter("SparseBlockSize"))
{
pSession->LoadParameter("SparseBlockSize", block_size);
ASSERTL1(block_size > 0,"SparseBlockSize parameter must to be positive");
}
brows = rows / block_size + (rows % block_size > 0);
bcols = columns / block_size + (columns % block_size > 0);
if (rows % block_size > 0) m_copyOp = true;
if (m_copyOp)
{
m_tmpin = Array<OneD, NekDouble> (brows*block_size, 0.0);
m_tmpout = Array<OneD, NekDouble> (brows*block_size, 0.0);
}
convertCooToBco(brows, bcols, block_size, cooMat, bcoMat);
size_t matBytes;
switch(storageType)
{
case eSmvBSR:
{
// Create zero-based Smv-multiply BSR sparse storage holder
DNekSmvBsrMat::SparseStorageSharedPtr sparseStorage =
MemoryManager<DNekSmvBsrMat::StorageType>::
AllocateSharedPtr(
brows, bcols, block_size, bcoMat, matStorage );
// Create sparse matrix
m_smvbsrmatrix = MemoryManager<DNekSmvBsrMat>::
AllocateSharedPtr( sparseStorage );
matBytes = m_smvbsrmatrix->GetMemoryFootprint();
}
break;
default:
NEKERROR(ErrorUtil::efatal,"Unsupported sparse storage type chosen");
}
cout << "Global matrix storage type: "
<< MatrixStorageTypeMap[storageType] << endl;
std::cout << "Global matrix memory, bytes = " << matBytes;
if (matBytes/(1024*1024) > 0)
{
std::cout << " ("<< matBytes/(1024*1024) <<" MB)" << std::endl;
}
else
{
std::cout << " ("<< matBytes/1024 <<" KB)" << std::endl;
}
std::cout << "Sparse storage block size = " << block_size << std::endl;
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
MultiRegions::ContField1DSharedPtr Exp,Sol;
int i,j;
int order, nq;
int coordim;
Array<OneD,NekDouble> sol;
Array<OneD,NekDouble> xc0,xc1,xc2;
if(argc != 2)
{
fprintf(stderr,"Usage: ProjectCont1D mesh \n");
exit(1);
}
//----------------------------------------------
// read the problem parameters from input file
SpatialDomains::MeshGraphSharedPtr graph1D = MemoryManager<SpatialDomains::MeshGraph1D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
const SpatialDomains::ExpansionMap &expansions = graph1D->GetExpansions();
LibUtilities::BasisKey bkey0
= expansions.begin()->second->m_basisKeyVector[0];
int nmodes = bkey0.GetNumModes();
cout << "Solving 1D Continuous Projection" << endl;
cout << " Expansion : (" << LibUtilities::BasisTypeMap[bkey0.GetBasisType()] <<")" << endl;
cout << " No. modes : " << nmodes << endl;
cout << endl;
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::ContField1D>
::AllocateSharedPtr(vSession,graph1D,vSession->GetVariable(0));
//----------------------------------------------
//----------------------------------------------
// Define solution to be projected
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
order = Exp->GetExp(0)->GetNcoeffs();
// 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 < order; ++j)
{
sol[i] += pow(xc0[i],j);
sol[i] += pow(xc1[i],j);
sol[i] += pow(xc2[i],j);
}
}
//----------------------------------------------
//----------------------------------------------
// Setup Temporary expansion and put in solution
Sol = MemoryManager<MultiRegions::ContField1D>
::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
cout << "L infinity error: " << Exp->Linf(Sol->GetPhys()) << endl;
cout << "L 2 error: " << Exp->L2 (Sol->GetPhys()) << 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::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;
}
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;
}
int main(int argc, char *argv[])
{
MultiRegions::ContField3DSharedPtr Exp,Fce,Sol;
int i, nq, coordim;
Array<OneD,NekDouble> fce,sol;
Array<OneD,NekDouble> xc0,xc1,xc2;
NekDouble lambda;
vector<string> vFilenames;
if(argc != 6)
{
fprintf(stderr,"Usage: TimingCGHelmSolve3D Type MeshSize NumModes OptimisationLevel OperatorToTest\n");
fprintf(stderr," where: - Type is one of the following:\n");
fprintf(stderr," 1: Regular Hexahedrons \n");
fprintf(stderr," 2: Deformed Hexahedrons (may not be supported) \n");
fprintf(stderr," 3: Regular Tetrahedrons \n");
fprintf(stderr," where: - MeshSize is 1/h \n");
fprintf(stderr," where: - NumModes is the number of 1D modes of the expansion \n");
fprintf(stderr," where: - OptimisationLevel is one of the following:\n");
fprintf(stderr," 0: Use elemental sum-factorisation evaluation \n");
fprintf(stderr," 2: Use elemental matrix evaluation using blockmatrices \n");
fprintf(stderr," 3: Use global matrix evaluation \n");
fprintf(stderr," 4: Use optimal evaluation (this option requires optimisation-files being set-up) \n");
fprintf(stderr," where: - OperatorToTest is one of the following:\n");
fprintf(stderr," 0: BwdTrans \n");
fprintf(stderr," 1: Inner Product \n");
fprintf(stderr," 2: Mass Matrix \n");
exit(1);
}
boost::filesystem::path basePath(BASE_PATH);
int Type = atoi(argv[1]);
int MeshSize = atoi(argv[2]);
int NumModes = atoi(argv[3]);
int optLevel = atoi(argv[4]);
int opToTest = atoi(argv[5]);
//----------------------------------------------
// Retrieve the necessary input files
stringstream MeshFileName;
stringstream MeshFileDirectory;
stringstream BCfileName;
stringstream ExpansionsFileName;
stringstream GlobOptFileName;
switch(Type)
{
case 1:
{
MeshFileDirectory << "RegularHexMeshes";
MeshFileName << "UnitCube_RegularHexMesh_h_1_" << MeshSize << ".xml";
}
break;
case 2:
{
MeshFileDirectory << "DeformedHexMeshes";
MeshFileName << "UnitCube_DeformedHexMesh_h_1_" << MeshSize << ".xml";
}
break;
case 3:
{
MeshFileDirectory << "RegularTetMeshes";
MeshFileName << "UnitCube_RegularTetMesh_h_1_" << MeshSize << ".xml";
}
break;
default:
{
cerr << "Type should be equal to one of the following values: "<< endl;
cerr << " 1: Regular Hexahedrons" << endl;
cerr << " 2: Deformed Hexahedrons" << endl;
cerr << " 3: Regular Tetrahedrons" << endl;
exit(1);
}
}
BCfileName << "UnitCube_DirichletBoundaryConditions.xml";
ExpansionsFileName << "NektarExpansionsNummodes" << NumModes << ".xml";
switch(optLevel)
{
case 0:
{
GlobOptFileName << "NoGlobalMat.xml";
}
break;
case 2:
{
GlobOptFileName << "DoBlockMat.xml";
}
break;
case 3:
{
GlobOptFileName << "DoGlobalMat.xml";
}
break;
case 4:
{
ASSERTL0(false,"Optimisation level not set up");
}
break;
default:
{
ASSERTL0(false,"Unrecognised optimisation level");
}
}
boost::filesystem::path MeshFilePath = basePath /
boost::filesystem::path("InputFiles") /
boost::filesystem::path("Geometry") /
boost::filesystem::path(MeshFileDirectory.str()) /
boost::filesystem::path(MeshFileName.str());
vFilenames.push_back(PortablePath(MeshFilePath));
boost::filesystem::path BCfilePath = basePath /
boost::filesystem::path("InputFiles") /
boost::filesystem::path("Conditions") /
boost::filesystem::path(BCfileName.str());
vFilenames.push_back(PortablePath(BCfilePath));
boost::filesystem::path ExpansionsFilePath = basePath /
boost::filesystem::path("InputFiles") /
boost::filesystem::path("Expansions") /
boost::filesystem::path(ExpansionsFileName.str());
vFilenames.push_back(PortablePath(ExpansionsFilePath));
boost::filesystem::path GlobOptFilePath = basePath /
boost::filesystem::path("InputFiles") /
boost::filesystem::path("Optimisation") /
boost::filesystem::path(GlobOptFileName.str());
vFilenames.push_back(PortablePath(GlobOptFilePath));
//----------------------------------------------
StdRegions::MatrixType type;
switch (opToTest)
{
case 0:
type = StdRegions::eBwdTrans;
break;
case 1:
type = StdRegions::eIProductWRTBase;
break;
case 2:
type = StdRegions::eMass;
break;
case 3:
type = StdRegions::eHelmholtz;
break;
default:
cout << "Operator " << opToTest << " not defined." << endl;
}
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv, vFilenames);
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph3D = MemoryManager<SpatialDomains::MeshGraph3D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
lambda = vSession->GetParameter("Lambda");
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::ContField3D>
::AllocateSharedPtr(vSession, graph3D, vSession->GetVariable(0));
//----------------------------------------------
int NumElements = Exp->GetExpSize();
//----------------------------------------------
// 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);
for(i = 0; i < nq; ++i)
{
fce[i] = ffunc->Evaluate(xc0[i],xc1[i],xc2[i]);
}
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::ContField3D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
//----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol = vSession->GetFunction("ExactSolution",0);
//----------------------------------------------
// evaluate exact solution
sol = Array<OneD,NekDouble>(nq);
for(i = 0; i < nq; ++i)
{
sol[i] = ex_sol->Evaluate(xc0[i],xc1[i],xc2[i]);
}
Sol = MemoryManager<MultiRegions::ContField3D>::AllocateSharedPtr(*Exp);
Sol->SetPhys(sol);
Sol->SetPhysState(true);
//----------------------------------------------
NekDouble L2Error;
NekDouble LinfError;
if (type == StdRegions::eHelmholtz)
{
FlagList flags;
flags.set(eUseGlobal, true);
StdRegions::ConstFactorMap factors;
factors[StdRegions::eFactorLambda] = lambda;
//----------------------------------------------
// Helmholtz solution taking physical forcing
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(),flags,factors);
// GeneralMatrixOp does not impose boundary conditions.
// MultiRegions::GlobalMatrixKey key(type, lambda, Exp->GetLocalToGlobalMap());
// Exp->GeneralMatrixOp (key, Fce->GetPhys(),Exp->UpdateContCoeffs(), true);
//----------------------------------------------
//----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys(),
MultiRegions::eGlobal);
//----------------------------------------------
L2Error = Exp->L2 (Sol->GetPhys());
LinfError = Exp->Linf(Sol->GetPhys());
}
else
{
Exp->FwdTrans(Sol->GetPhys(), Exp->UpdateCoeffs(),
MultiRegions::eGlobal);
//----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys(),
MultiRegions::eGlobal);
//----------------------------------------------
L2Error = Exp->L2 (Sol->GetPhys());
LinfError = Exp->Linf(Sol->GetPhys());
}
//--------------------------------------------
// alternative error calculation
/* const LibUtilities::PointsKey PkeyT1(30,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyT2(30,LibUtilities::eGaussRadauMAlpha1Beta0);
const LibUtilities::PointsKey PkeyQ1(30,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyQ2(30,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::BasisKey BkeyT1(LibUtilities::eModified_A,NumModes,PkeyT1);
const LibUtilities::BasisKey BkeyT2(LibUtilities::eModified_B,NumModes,PkeyT2);
const LibUtilities::BasisKey BkeyQ1(LibUtilities::eModified_A,NumModes,PkeyQ1);
const LibUtilities::BasisKey BkeyQ2(LibUtilities::eModified_A,NumModes,PkeyQ2);
MultiRegions::ExpList3DSharedPtr ErrorExp =
MemoryManager<MultiRegions::ExpList3D>::AllocateSharedPtr(BkeyT1,BkeyT2,BkeyT3,BkeyQ1,BkeyQ2,BkeyQ3,graph3D);
int ErrorCoordim = ErrorExp->GetCoordim(0);
int ErrorNq = ErrorExp->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:
ErrorExp->GetCoords(ErrorXc0);
break;
case 2:
ErrorExp->GetCoords(ErrorXc0,ErrorXc1);
break;
case 3:
ErrorExp->GetCoords(ErrorXc0,ErrorXc1,ErrorXc2);
break;
}
// evaluate exact solution
Array<OneD,NekDouble> ErrorSol(ErrorNq);
for(i = 0; i < ErrorNq; ++i)
{
ErrorSol[i] = ex_sol->Evaluate(ErrorXc0[i],ErrorXc1[i],ErrorXc2[i]);
}
// calcualte spectral/hp approximation on the quad points of this new
// expansion basis
Exp->GlobalToLocal(Exp->GetContCoeffs(),ErrorExp->UpdateCoeffs());
ErrorExp->BwdTrans_IterPerExp(ErrorExp->GetCoeffs(),ErrorExp->UpdatePhys());
NekDouble L2ErrorBis = ErrorExp->L2 (ErrorSol);
NekDouble LinfErrorBis = ErrorExp->Linf(ErrorSol);
*/
//--------------------------------------------
#if 0
cout << "L infinity error: " << LinfErrorBis << endl;
cout << "L 2 error: " << L2ErrorBis << endl;
#endif
//----------------------------------------------
NekDouble exeTime;
int NumCalls;
exeTime = TimeMatrixOp(type, Exp, Fce, NumCalls, lambda);
int nLocCoeffs = Exp->GetLocalToGlobalMap()->GetNumLocalCoeffs();
int nGlobCoeffs = Exp->GetLocalToGlobalMap()->GetNumGlobalCoeffs();
int nLocBndCoeffs = Exp->GetLocalToGlobalMap()->GetNumLocalBndCoeffs();
int nGlobBndCoeffs = Exp->GetLocalToGlobalMap()->GetNumGlobalBndCoeffs();
int nLocDirCoeffs = Exp->GetLocalToGlobalMap()->GetNumLocalDirBndCoeffs();
int nGlobDirCoeffs = Exp->GetLocalToGlobalMap()->GetNumGlobalDirBndCoeffs();
// MultiRegions::GlobalMatrixKey key(StdRegions::eHelmholtz,lambda,Exp->GetLocalToGlobalMap());
// int nnz = Exp->GetGlobalMatrixNnz(key);
ostream &outfile = cout;
outfile.precision(0);
outfile << setw(10) << Type << " ";
outfile << setw(10) << NumElements << " ";
outfile << setw(10) << NumModes << " ";
outfile << setw(10) << NumCalls << " ";
outfile << setw(10) << fixed << noshowpoint << exeTime << " ";
outfile << setw(10) << fixed << noshowpoint << ((NekDouble) (exeTime/((NekDouble)NumCalls))) << " ";
outfile.precision(7);
outfile << setw(15) << scientific << noshowpoint << L2Error << " ";
outfile << setw(15) << scientific << noshowpoint << "- "; // << L2ErrorBis << " ";
outfile << setw(15) << scientific << noshowpoint << LinfError << " ";
outfile << setw(15) << scientific << noshowpoint << "- ";// << LinfErrorBis << " ";
outfile << setw(10) << nLocCoeffs << " ";
outfile << setw(10) << nGlobCoeffs << " ";
outfile << setw(10) << nLocBndCoeffs << " ";
outfile << setw(10) << nGlobBndCoeffs << " ";
outfile << setw(10) << nLocDirCoeffs << " ";
outfile << setw(10) << nGlobDirCoeffs << " ";
outfile << setw(10) << "- "; // << nnz << " ";
outfile << setw(10) << optLevel << " ";
outfile << endl;
//----------------------------------------------
return 0;
}
int main(int argc, char *argv[])
{
SpatialDomains::PointGeomSharedPtr vPoint;
MultiRegions::ExpListSharedPtr vExp;
LibUtilities::SessionReaderSharedPtr vSession;
std::string vCellModel;
CellModelSharedPtr vCell;
std::vector<StimulusSharedPtr> vStimulus;
Array<OneD, Array<OneD, NekDouble> > vWsp(1);
Array<OneD, Array<OneD, NekDouble> > vSol(1);
NekDouble vDeltaT;
NekDouble vTime;
unsigned int nSteps;
// Create a session reader to read pacing parameters
vSession = LibUtilities::SessionReader::CreateInstance(argc, argv);
try
{
// Construct a field consisting of a single vertex
vPoint = MemoryManager<SpatialDomains::PointGeom>
::AllocateSharedPtr(3, 0, 0.0, 0.0, 0.0);
vExp = MemoryManager<MultiRegions::ExpList0D>
::AllocateSharedPtr(vPoint);
// Get cell model name and create it
vSession->LoadSolverInfo("CELLMODEL", vCellModel, "");
ASSERTL0(vCellModel != "", "Cell Model not specified.");
vCell = GetCellModelFactory().CreateInstance(
vCellModel, vSession, vExp);
vCell->Initialise();
// Load the stimuli
vStimulus = Stimulus::LoadStimuli(vSession, vExp);
// Set up solution arrays, workspace and read in parameters
vSol[0] = Array<OneD, NekDouble>(1, 0.0);
vWsp[0] = Array<OneD, NekDouble>(1, 0.0);
vDeltaT = vSession->GetParameter("TimeStep");
vTime = 0.0;
nSteps = vSession->GetParameter("NumSteps");
LibUtilities::EquationSharedPtr e =
vSession->GetFunction("InitialConditions", "u");
vSol[0][0] = e->Evaluate(0.0, 0.0, 0.0, 0.0);
// Time integrate cell model
for (unsigned int i = 0; i < nSteps; ++i)
{
// Compute J_ion
vCell->TimeIntegrate(vSol, vWsp, vTime);
// Add stimuli J_stim
for (unsigned int i = 0; i < vStimulus.size(); ++i)
{
vStimulus[i]->Update(vWsp, vTime);
}
// Time-step with forward Euler
Vmath::Svtvp(1, vDeltaT, vWsp[0], 1, vSol[0], 1, vSol[0], 1);
// Increment time
vTime += vDeltaT;
// Output current solution to stdout
cout << vTime << " " << vSol[0][0] << endl;
}
for (unsigned int i = 0; i < vCell->GetNumCellVariables(); ++i)
{
cout << "# " << vCell->GetCellVarName(i) << " "
<< vCell->GetCellSolution(i)[0] << endl;
}
}
catch (...)
{
cerr << "An error occured" << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
int i,j;
if(argc != 4)
{
fprintf(stderr,"Usage: FldAddVort meshfile infld outfld\n");
exit(1);
}
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
//----------------------------------------------
// Read in mesh from input file
string meshfile(argv[argc-3]);
SpatialDomains::MeshGraphSharedPtr graphShPt = SpatialDomains::MeshGraph::Read(vSession);//meshfile);
//----------------------------------------------
//----------------------------------------------
// Import field file.
string fieldfile(argv[argc-2]);
vector<LibUtilities::FieldDefinitionsSharedPtr> fielddef;
vector<vector<NekDouble> > fielddata;
LibUtilities::Import(fieldfile,fielddef,fielddata);
bool useFFT = false;
bool dealiasing = false;
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int expdim = graphShPt->GetMeshDimension();
int nfields = fielddef[0]->m_fields.size();
int addfields = (nfields == 4)? 3:1;
Array<OneD, MultiRegions::ExpListSharedPtr> Exp(nfields + addfields);
switch(expdim)
{
case 1:
{
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 2,"Quasi-3D approach is only set up for 1 or 2 homogeneous directions");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
// Define Homogeneous expansion
//int nplanes = fielddef[0]->m_numModes[1];
int nplanes;
vSession->LoadParameter("HomModesZ",nplanes,fielddef[0]->m_numModes[1]);
// choose points to be at evenly spaced points at
// nplanes points
const LibUtilities::PointsKey Pkey(nplanes,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[1],nplanes,Pkey);
NekDouble ly = fielddef[0]->m_homogeneousLengths[0];
Exp2DH1 = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(vSession,Bkey,ly,useFFT,dealiasing,graphShPt);
Exp[0] = Exp2DH1;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(*Exp2DH1);
}
}
else if(fielddef[0]->m_numHomogeneousDir == 2)
{
MultiRegions::ExpList3DHomogeneous2DSharedPtr Exp3DH2;
// Define Homogeneous expansion
//int nylines = fielddef[0]->m_numModes[1];
//int nzlines = fielddef[0]->m_numModes[2];
int nylines;
int nzlines;
vSession->LoadParameter("HomModesY",nylines,fielddef[0]->m_numModes[1]);
vSession->LoadParameter("HomModesZ",nzlines,fielddef[0]->m_numModes[2]);
// choose points to be at evenly spaced points at
// nplanes points
const LibUtilities::PointsKey PkeyY(nylines,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey BkeyY(fielddef[0]->m_basis[1],nylines,PkeyY);
const LibUtilities::PointsKey PkeyZ(nzlines,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey BkeyZ(fielddef[0]->m_basis[2],nzlines,PkeyZ);
NekDouble ly = fielddef[0]->m_homogeneousLengths[0];
NekDouble lz = fielddef[0]->m_homogeneousLengths[1];
Exp3DH2 = MemoryManager<MultiRegions::ExpList3DHomogeneous2D>::AllocateSharedPtr(vSession,BkeyY,BkeyZ,ly,lz,useFFT,dealiasing,graphShPt);
Exp[0] = Exp3DH2;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3DHomogeneous2D>::AllocateSharedPtr(*Exp3DH2);
}
}
else
{
MultiRegions::ExpList1DSharedPtr Exp1D;
Exp1D = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp1D;
for(i = 1; i < nfields + addfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(*Exp1D);
}
}
}
break;
case 2:
{
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 1,"NumHomogeneousDir is only set up for 1");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
// Define Homogeneous expansion
//int nplanes = fielddef[0]->m_numModes[2];
int nplanes;
vSession->LoadParameter("HomModesZ",nplanes,fielddef[0]->m_numModes[2]);
// choose points to be at evenly spaced points at
// nplanes points
const LibUtilities::PointsKey Pkey(nplanes,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[2],nplanes,Pkey);
NekDouble lz = fielddef[0]->m_homogeneousLengths[0];
Exp3DH1 = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(vSession,Bkey,lz,useFFT,dealiasing,graphShPt);
Exp[0] = Exp3DH1;
for(i = 1; i < nfields + addfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(*Exp3DH1);
}
}
else
{
MultiRegions::ExpList2DSharedPtr Exp2D;
Exp2D = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp2D;
for(i = 1; i < nfields + addfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(*Exp2D);
}
}
}
break;
case 3:
{
MultiRegions::ExpList3DSharedPtr Exp3D;
Exp3D = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(vSession,graphShPt);
Exp[0] = Exp3D;
for(i = 1; i < nfields + addfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(*Exp3D);
}
}
break;
default:
ASSERTL0(false,"Expansion dimension not recognised");
break;
}
//----------------------------------------------
//----------------------------------------------
// Copy data from field file
for(j = 0; j < nfields; ++j)
{
for(int i = 0; i < fielddata.size(); ++i)
{
Exp[j]->ExtractDataToCoeffs(fielddef [i],
fielddata[i],
fielddef [i]->m_fields[j],
Exp[j]->UpdateCoeffs());
}
Exp[j]->BwdTrans(Exp[j]->GetCoeffs(),Exp[j]->UpdatePhys());
}
//----------------------------------------------
//----------------------------------------------
// Compute gradients of fields
ASSERTL0(nfields >= 3, "Need two fields (u,v) to add reentricity");
int nq = Exp[0]->GetNpoints();
Array<OneD, Array<OneD, NekDouble> > grad(nfields*nfields);
Array<OneD, Array<OneD, NekDouble> > outfield(addfields);
for(i = 0; i < nfields*nfields; ++i)
{
grad[i] = Array<OneD, NekDouble>(nq);
}
for(i = 0; i < addfields; ++i)
{
outfield[i] = Array<OneD, NekDouble>(nq);
}
// Calculate Gradient & Vorticity
if(nfields == 3)
{
for(i = 0; i < nfields; ++i)
{
Exp[i]->PhysDeriv(Exp[i]->GetPhys(), grad[i*nfields],grad[i*nfields+1]);
}
// W_z = Vx - Uy
Vmath::Vsub(nq,grad[1*nfields+0],1,grad[0*nfields+1],1,outfield[0],1);
}
else
{
for(i = 0; i < nfields; ++i)
{
Exp[i]->PhysDeriv(Exp[i]->GetPhys(), grad[i*nfields],grad[i*nfields+1],grad[i*nfields+2]);
}
// W_x = Wy - Vz
Vmath::Vsub(nq,grad[2*nfields+1],1,grad[1*nfields+2],1,outfield[0],1);
// W_y = Uz - Wx
Vmath::Vsub(nq,grad[0*nfields+2],1,grad[2*nfields+0],1,outfield[1],1);
// W_z = Vx - Uy
Vmath::Vsub(nq,grad[1*nfields+0],1,grad[0*nfields+1],1,outfield[2],1);
}
for (i = 0; i < addfields; ++i)
{
Exp[nfields + i]->FwdTrans(outfield[i], Exp[nfields+i]->UpdateCoeffs());
}
//-----------------------------------------------
// Write solution to file with additional computed fields
string out(argv[argc-1]);
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp[0]->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
vector<string > outname;
if(addfields == 1)
{
outname.push_back("W_z");
}
else
{
outname.push_back("W_x");
outname.push_back("W_y");
outname.push_back("W_z");
}
for(j = 0; j < nfields + addfields; ++j)
{
for(i = 0; i < FieldDef.size(); ++i)
{
if (j >= nfields)
{
FieldDef[i]->m_fields.push_back(outname[j-nfields]);
}
else
{
FieldDef[i]->m_fields.push_back(fielddef[i]->m_fields[j]);
}
Exp[j]->AppendFieldData(FieldDef[i], FieldData[i]);
}
}
LibUtilities::Write(out, FieldDef, FieldData);
//-----------------------------------------------
return 0;
}