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