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[]) { 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::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; }