/** * @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()); }
FilterAeroForces::FilterAeroForces( const LibUtilities::SessionReaderSharedPtr &pSession, const std::map<std::string, std::string> &pParams) : Filter(pSession) { if (pParams.find("OutputFile") == pParams.end()) { m_outputFile = m_session->GetSessionName(); } else { ASSERTL0(!(pParams.find("OutputFile")->second.empty()), "Missing parameter 'OutputFile'."); m_outputFile = pParams.find("OutputFile")->second; } if (!(m_outputFile.length() >= 4 && m_outputFile.substr(m_outputFile.length() - 4) == ".fce")) { m_outputFile += ".fce"; } if (pParams.find("OutputFrequency") == pParams.end()) { m_outputFrequency = 1; } else { m_outputFrequency = atoi(pParams.find("OutputFrequency")->second.c_str()); } m_session->MatchSolverInfo("Homogeneous", "1D", m_isHomogeneous1D, false); if(m_isHomogeneous1D) { if (pParams.find("OutputPlane") == pParams.end()) { m_outputPlane = 0; } else { m_outputPlane = atoi(pParams.find("OutputPlane")->second.c_str()); } } //specify the boundary to calculate the forces if (pParams.find("Boundary") == pParams.end()) { ASSERTL0(false, "Missing parameter 'Boundary'."); } else { ASSERTL0(!(pParams.find("Boundary")->second.empty()), "Missing parameter 'Boundary'."); m_BoundaryString = pParams.find("Boundary")->second; } }
StdNodalTetExp::StdNodalTetExp( const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const LibUtilities::BasisKey &Bc, LibUtilities::PointsType Ntype): StdExpansion (LibUtilities::StdTetData::getNumberOfCoefficients( Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()), 3,Ba,Bb,Bc), StdExpansion3D(LibUtilities::StdTetData::getNumberOfCoefficients( Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()), Ba,Bb,Bc), StdTetExp (Ba,Bb,Bc), m_nodalPointsKey(Ba.GetNumModes(),Ntype) { ASSERTL0(Ba.GetNumModes() <= Bb.GetNumModes(), "order in 'a' direction is higher than order " "in 'b' direction"); ASSERTL0(Ba.GetNumModes() <= Bc.GetNumModes(), "order in 'a' direction is higher than order " "in 'c' direction"); ASSERTL0(Bb.GetNumModes() <= Bc.GetNumModes(), "order in 'b' direction is higher than order " "in 'c' direction"); }
/** * @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()); }
void EulerADCFE::DoOdeProjection( const Array<OneD, const Array<OneD, NekDouble> > &inarray, Array<OneD, Array<OneD, NekDouble> > &outarray, const NekDouble time) { int i; int nvariables = inarray.num_elements(); switch(m_projectionType) { case MultiRegions::eDiscontinuous: { // Just copy over array int npoints = GetNpoints(); for(i = 0; i < nvariables; ++i) { Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1); } SetBoundaryConditions(outarray, time); break; } case MultiRegions::eGalerkin: case MultiRegions::eMixed_CG_Discontinuous: { ASSERTL0(false, "No Continuous Galerkin for Euler equations"); break; } default: ASSERTL0(false, "Unknown projection scheme"); break; } }
/** * @brief Initialize filter. */ void FilterEnergy1D::v_Initialise( const Array<OneD, const MultiRegions::ExpListSharedPtr> &pFields, const NekDouble &time) { ASSERTL0(pFields[0]->GetExp(0)->GetNumBases() == 1, "The Energy 1D filter is only valid in 1D."); }
void EulerADCFE::SetBoundaryConditions( Array<OneD, Array<OneD, NekDouble> > &inarray, NekDouble time) { std::string varName; int cnt = 0; // loop over Boundary Regions for (int n = 0; n < m_fields[0]->GetBndConditions().num_elements(); ++n) { std::string type = m_fields[0]->GetBndConditions()[n]->GetUserDefined(); // Wall Boundary Condition if (boost::iequals(type,"WallViscous")) { // Wall Boundary Condition ASSERTL0(false, "WallViscous is a wrong bc for the " "Euler equations"); } else { SetCommonBC(type,n,time, cnt,inarray); } // no User Defined conditions provided so skip cnt // this line is left in case solver specific condition is added. cnt += m_fields[0]->GetBndCondExpansions()[n]->GetExpSize(); } }
void StdNodalTriExp::v_GetEdgeInteriorMap( const int eid, const Orientation edgeOrient, Array<OneD, unsigned int> &maparray, Array<OneD, int> &signarray) { ASSERTL0(eid >= 0 && eid <= 2, "Local Edge ID must be between 0 and 2"); const int nEdgeIntCoeffs = GetEdgeNcoeffs(eid)-2; if (maparray.num_elements() != nEdgeIntCoeffs) { maparray = Array<OneD, unsigned int>(nEdgeIntCoeffs); } if (signarray.num_elements() != nEdgeIntCoeffs) { signarray = Array<OneD, int>(nEdgeIntCoeffs,1); } else { fill(signarray.get(), signarray.get()+nEdgeIntCoeffs, 1); } for (int i = 0; i < nEdgeIntCoeffs; i++) { maparray[i] = eid*nEdgeIntCoeffs+3+i; } if (edgeOrient == eBackwards) { reverse(maparray.get(), maparray.get()+nEdgeIntCoeffs); } }
/// Solve the linear system for given input and output vectors /// using a specified local to global map. void GlobalLinSysXxt::v_Solve( const Array<OneD, const NekDouble> &in, Array<OneD, NekDouble> &out, const AssemblyMapSharedPtr &pLocToGloMap, const Array<OneD, const NekDouble> &pDirForcing) { ASSERTL0(false, "Not implemented for this GlobalLinSys type."); }
void FilterEnergyBase::v_GetVelocity( const Array<OneD, const MultiRegions::ExpListSharedPtr> &pFields, const int i, Array<OneD, NekDouble> &velocity) { ASSERTL0(false, "Needs to implemented by subclass"); }
int StdNodalTetExp::v_GetVertexMap(const int localVertexId, bool useCoeffPacking) { ASSERTL0(localVertexId >= 0 && localVertexId <= 3, "Local Vertex ID must be between 0 and 3"); return localVertexId; }
/** * @return Shared pointer to the created ThreadManager. * * An error occurs if this is called before SetThreadingType. */ ThreadManagerSharedPtr ThreadMaster::CreateInstance(const ThreadManagerName t, unsigned int nThr) { ASSERTL0(!m_threadingType.empty(), "Trying to create a ThreadManager before SetThreadingType called"); return m_threadManagers[t] = Thread::GetThreadManagerFactory().CreateInstance(m_threadingType, nThr); }
const NormalVector & StdExpansion1D::v_GetVertexNormal(const int vertex) const { std::map<int, NormalVector>::const_iterator x; x = m_vertexNormals.find(vertex); ASSERTL0 (x != m_vertexNormals.end(), "vertex normal not computed."); return x->second; }
void EulerADCFE::v_InitObject() { CompressibleFlowSystem::v_InitObject(); if (m_shockCaptureType == "Smooth") { ASSERTL0(m_fields.num_elements() == m_spacedim + 3, "Not enough variables for smooth shock capturing; " "make sure you have added eps to variable list."); m_smoothDiffusion = true; } m_diffusion->SetArtificialDiffusionVector( &EulerADCFE::GetArtificialDynamicViscosity, this); if(m_session->DefinesSolverInfo("PROBLEMTYPE")) { std::string ProblemTypeStr = m_session->GetSolverInfo("PROBLEMTYPE"); int i; for(i = 0; i < (int) SIZE_ProblemType; ++i) { if(boost::iequals(ProblemTypeMap[i], ProblemTypeStr)) { m_problemType = (ProblemType)i; break; } } } else { m_problemType = (ProblemType)0; } if (m_explicitAdvection) { m_ode.DefineOdeRhs (&EulerADCFE:: DoOdeRhs, this); m_ode.DefineProjection(&EulerADCFE:: DoOdeProjection, this); } else { ASSERTL0(false, "Implicit CFE not set up."); } }
void FilterCheckpointCellModel::v_Initialise(const Array<OneD, const MultiRegions::ExpListSharedPtr> &pFields, const NekDouble &time) { ASSERTL0(m_cell.get(), "Cell model has not been set by EquationSystem " "class. Use SetCellModel on this filter to achieve this."); m_index = 0; m_outputIndex = 0; v_Update(pFields, 0.0); }
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()); }
ProcessAddFld::ProcessAddFld(FieldSharedPtr f) : ProcessModule(f) { m_config["scale"] = ConfigOption(false, "1.0", "scale factor"); m_config["fromfld"] = ConfigOption(false, "NotSet", "Fld file form which to interpolate field"); ASSERTL0(m_config["fromfld"].as<string>().compare("NotSet") != 0, "Need to specify fromfld=file.fld "); }
void Bidomain::v_GenerateSummary(SummaryList& s) { UnsteadySystem::v_GenerateSummary(s); /// @TODO Update summary ASSERTL0(false, "Update the generate summary"); // // out << "\tChi : " << m_chi << endl; // out << "\tCm : " << m_capMembrane << endl; // if (m_session->DefinesFunction("IntracellularConductivity", "AnisotropicConductivityX") && // m_session->GetFunctionType("IntracellularConductivity", "AnisotropicConductivityX") == LibUtilities::eFunctionTypeExpression) // { // out << "\tIntra-Diffusivity-x : " // << m_session->GetFunction("IntracellularConductivity", "AnisotropicConductivityX")->GetExpression() // << endl; // } // if (m_session->DefinesFunction("IntracellularConductivity", "AnisotropicConductivityY") && // m_session->GetFunctionType("IntracellularConductivity", "AnisotropicConductivityY") == LibUtilities::eFunctionTypeExpression) // { // out << "\tIntra-Diffusivity-y : " // << m_session->GetFunction("IntracellularConductivity", "AnisotropicConductivityY")->GetExpression() // << endl; // } // if (m_session->DefinesFunction("IntracellularConductivity", "AnisotropicConductivityZ") && // m_session->GetFunctionType("IntracellularConductivity", "AnisotropicConductivityZ") == LibUtilities::eFunctionTypeExpression) // { // out << "\tIntra-Diffusivity-z : " // << m_session->GetFunction("IntracellularConductivity", "AnisotropicConductivityZ")->GetExpression() // << endl; // } // if (m_session->DefinesFunction("ExtracellularConductivity", "AnisotropicConductivityX") && // m_session->GetFunctionType("ExtracellularConductivity", "AnisotropicConductivityX") == LibUtilities::eFunctionTypeExpression) // { // out << "\tExtra-Diffusivity-x : " // << m_session->GetFunction("ExtracellularConductivity", "AnisotropicConductivityX")->GetExpression() // << endl; // } // if (m_session->DefinesFunction("ExtracellularConductivity", "AnisotropicConductivityY") && // m_session->GetFunctionType("ExtracellularConductivity", "AnisotropicConductivityY") == LibUtilities::eFunctionTypeExpression) // { // out << "\tExtra-Diffusivity-y : " // << m_session->GetFunction("ExtracellularConductivity", "AnisotropicConductivityY")->GetExpression() // << endl; // } // if (m_session->DefinesFunction("ExtracellularConductivity", "AnisotropicConductivityZ") && // m_session->GetFunctionType("ExtracellularConductivity", "AnisotropicConductivityZ") == LibUtilities::eFunctionTypeExpression) // { // out << "\tExtra-Diffusivity-z : " // << m_session->GetFunction("ExtracellularConductivity", "AnisotropicConductivityZ")->GetExpression() // << endl; // } m_cell->GenerateSummary(s); }
FilterCheckpointCellModel::FilterCheckpointCellModel( const LibUtilities::SessionReaderSharedPtr &pSession, const std::map<std::string, std::string> &pParams) : Filter(pSession) { if (pParams.find("OutputFile") == pParams.end()) { m_outputFile = m_session->GetSessionName(); } else { ASSERTL0(!(pParams.find("OutputFile")->second.empty()), "Missing parameter 'OutputFile'."); m_outputFile = pParams.find("OutputFile")->second; } ASSERTL0(pParams.find("OutputFrequency") != pParams.end(), "Missing parameter 'OutputFrequency'."); m_outputFrequency = atoi(pParams.find("OutputFrequency")->second.c_str()); m_outputIndex = 0; m_index = 0; m_fld = MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(m_session->GetComm()); }
/** * @brief Compute the projection for the linear advection equation. * * @param inarray Given fields. * @param outarray Calculated solution. * @param time Time. */ void UnsteadyAdvection::DoOdeProjection( const Array<OneD, const Array<OneD, NekDouble> >&inarray, Array<OneD, Array<OneD, NekDouble> >&outarray, const NekDouble time) { // Counter variable int i; // Number of fields (variables of the problem) int nVariables = inarray.num_elements(); // Set the boundary conditions SetBoundaryConditions(time); // Switch on the projection type (Discontinuous or Continuous) switch(m_projectionType) { // Discontinuous projection case MultiRegions::eDiscontinuous: { // Number of quadrature points int nQuadraturePts = GetNpoints(); // Just copy over array for(i = 0; i < nVariables; ++i) { Vmath::Vcopy(nQuadraturePts, inarray[i], 1, outarray[i], 1); } break; } // Continuous projection case MultiRegions::eGalerkin: case MultiRegions::eMixed_CG_Discontinuous: { Array<OneD, NekDouble> coeffs(m_fields[0]->GetNcoeffs(),0.0); for(i = 0; i < nVariables; ++i) { m_fields[i]->FwdTrans(inarray[i], coeffs); m_fields[i]->BwdTrans_IterPerExp(coeffs, outarray[i]); } break; } default: ASSERTL0(false,"Unknown projection scheme"); break; } }
/** * Calculates the second term of the weak form (1): \f$ * \left( \frac{\partial \mathbf{F(\mathbf{U})}^{\delta} * }{\partial x}, \mathbf{\psi}^{\delta} \right)_{\Omega_e} * \f$ * The variables of the system are $\mathbf{U} = [A,u]^T$ * physfield[0] = A physfield[1] = u * flux[0] = F[0] = A*u flux[1] = F[1] = u^2/2 + p/rho * p-A-relationship: p = p_ext + beta*(sqrt(A)-sqrt(A_0)) */ void PulseWavePropagation::v_GetFluxVector(const int i, Array<OneD, Array<OneD, NekDouble> > &physfield, Array<OneD, Array<OneD, NekDouble> > &flux) { int nq = m_vessels[m_currentDomain*m_nVariables]->GetTotPoints(); NekDouble p = 0.0; NekDouble p_t = 0.0; switch (i) { case 0: // Flux for A equation { for (int j = 0; j < nq; j++) { flux[0][j] = physfield[0][j]*physfield[1][j]; } } break; case 1: // Flux for u equation { for (int j = 0; j < nq; j++) { ASSERTL0(physfield[0][j]>=0,"Negative A not allowed."); p = m_pext + m_beta[m_currentDomain][j]* (sqrt(physfield[0][j]) - sqrt(m_A_0[m_currentDomain][j])); p_t = (physfield[1][j]*physfield[1][j])/2 + p/m_rho; flux[0][j] = p_t; } } break; default: ASSERTL0(false,"GetFluxVector: illegal vector index"); break; } }
/** * Calculates the third term of the weak form (1): numerical flux * at boundary \f$ \left[ \mathbf{\psi}^{\delta} \cdot \{ * \mathbf{F}^u - \mathbf{F}(\mathbf{U}^{\delta}) \} * \right]_{x_e^l}^{x_eû} \f$ */ void PulseWavePropagation::v_NumericalFlux(Array<OneD, Array<OneD, NekDouble> > &physfield, Array<OneD, Array<OneD, NekDouble> > &numflux) { int i; int nTracePts = GetTraceTotPoints(); Array<OneD, Array<OneD, NekDouble> > Fwd(m_nVariables); Array<OneD, Array<OneD, NekDouble> > Bwd(m_nVariables); for (i = 0; i < m_nVariables; ++i) { Fwd[i] = Array<OneD, NekDouble>(nTracePts); Bwd[i] = Array<OneD, NekDouble>(nTracePts); } // Get the physical values at the trace for (i = 0; i < m_nVariables; ++i) { m_vessels[m_currentDomain*m_nVariables+ i]-> GetFwdBwdTracePhys(physfield[i],Fwd[i],Bwd[i]); } // Solve the upwinding Riemann problem within one arterial // segment by calling the upwinding Riemann solver implemented // in this file NekDouble Aflux, uflux; for (i = 0; i < nTracePts; ++i) { switch(m_upwindTypePulse) { case eUpwindPulse: { RiemannSolverUpwind(Fwd[0][i],Fwd[1][i],Bwd[0][i],Bwd[1][i], Aflux, uflux, m_A_0_trace[m_currentDomain][i], m_beta_trace[m_currentDomain][i], m_trace_fwd_normal[m_currentDomain][i]); } break; default: { ASSERTL0(false,"populate switch statement for upwind flux"); } break; } numflux[0][i] = Aflux; numflux[1][i] = uflux; } }
void LinearSWESolver::v_Solve( const Array<OneD, const Array<OneD, NekDouble> > &Fwd, const Array<OneD, const Array<OneD, NekDouble> > &Bwd, Array<OneD, Array<OneD, NekDouble> > &flux) { // extract the forward and backward trace of the depth const Array<OneD, NekDouble> &dFwd = m_scalars["depthFwd"](); const Array<OneD, NekDouble> &dBwd = m_scalars["depthBwd"](); if (m_pointSolve) { int expDim = Fwd.num_elements()-1; NekDouble vf; if (expDim == 1) { for (int i = 0; i < Fwd[0].num_elements(); ++i) { v_PointSolve( Fwd [0][i], Fwd [1][i], 0.0, dFwd[i], Bwd [0][i], Bwd [1][i], 0.0, dBwd[i], flux[0][i], flux[1][i], vf); } } else if (expDim == 2) { for (int i = 0; i < Fwd[0].num_elements(); ++i) { v_PointSolve( Fwd [0][i], Fwd [1][i], Fwd [2][i], dFwd[i], Bwd [0][i], Bwd [1][i], Bwd [2][i], dBwd[i], flux[0][i], flux[1][i], flux[2][i]); } } else if (expDim == 3) { ASSERTL0(false, "No 3D Shallow water supported."); } } else { v_ArraySolve(Fwd, Bwd, flux); } }
void BLPoints::CalculatePoints() { // Allocate the storage for points. PointsBaseType::CalculatePoints(); unsigned int npts = m_pointsKey.GetNumPoints(); // Derived power coefficient. NekDouble r = m_pointsKey.GetFactor(); ASSERTL0(r != NekConstants::kNekUnsetDouble, "Must set factor in BLPoints key"); if (fabs(r-1.0) < 1e-6) { NekDouble tmp = 2.0/(npts-1.0); for (unsigned int i = 0; i < npts; ++i) { m_points[0][i] = -1.0 + i * tmp; } } else { NekDouble a = 2.0 * (1.0-r) / (1.0 - pow(r,(double)npts)); m_points[0][0] = -1.0; for (unsigned int i = 1; i < npts; ++i) { m_points[0][i] = m_points[0][i-1] + a*pow(r,(double)i); } m_points[0][npts-1] = 1.0; } if (m_pointsKey.GetPointsType() == eBoundaryLayerPointsRev) { vector<NekDouble> tmp(npts); for (unsigned int i = 0; i < npts; ++i) { tmp[i] = - m_points[0][npts-1-i]; } for (unsigned int i = 0; i < npts; ++i) { m_points[0][i] = tmp[i]; } } }
void PulseWavePropagation::v_InitObject() { PulseWaveSystem::v_InitObject(); m_pressureArea=GetPressureAreaFactory().CreateInstance("Lymphatic",m_vessels,m_session); m_pressureArea->DoPressure(); if (m_explicitAdvection) { m_ode.DefineOdeRhs (&PulseWavePropagation::DoOdeRhs, this); m_ode.DefineProjection (&PulseWavePropagation::DoOdeProjection, this); } else { ASSERTL0(false, "Implicit Pulse Wave Propagation not set up."); } }
void PreconditionerDiagonal::v_BuildPreconditioner() { GlobalSysSolnType solvertype = m_locToGloMap->GetGlobalSysSolnType(); if (solvertype == eIterativeFull) { DiagonalPreconditionerSum(); } else if(solvertype == eIterativeStaticCond || solvertype == eIterativeMultiLevelStaticCond) { StaticCondDiagonalPreconditionerSum(); } else { ASSERTL0(0,"Unsupported solver type"); } }
void DriverArnoldi::ArnoldiSummary(std::ostream &out) { if (m_comm->GetRank() == 0) { if(m_session->DefinesSolverInfo("SingleMode")) { out << "\tSingle Fourier mode : true " << endl; ASSERTL0(m_session->DefinesSolverInfo("Homogeneous"), "Expected a homogeneous expansion to be defined " "with single mode"); } else { out << "\tSingle Fourier mode : false " << endl; } if(m_session->DefinesSolverInfo("BetaZero")) { out << "\tBeta set to Zero : true (overrides LHom)" << endl; } else { out << "\tBeta set to Zero : false " << endl; } if(m_timeSteppingAlgorithm) { out << "\tEvolution operator : " << m_session->GetSolverInfo("EvolutionOperator") << endl; } else { out << "\tShift (Real,Imag) : " << m_realShift << "," << m_imagShift << endl; } out << "\tKrylov-space dimension : " << m_kdim << endl; out << "\tNumber of vectors : " << m_nvec << endl; out << "\tMax iterations : " << m_nits << endl; out << "\tEigenvalue tolerance : " << m_evtol << endl; out << "======================================================" << endl; } }
// \brief Read segments (and general MeshGraph) given TiXmlDocument. void MeshGraph2D::ReadGeometry(TiXmlDocument &doc) { // Read mesh first MeshGraph::ReadGeometry(doc); TiXmlHandle docHandle(&doc); TiXmlElement* mesh = NULL; /// Look for all geometry related data in GEOMETRY block. mesh = docHandle.FirstChildElement("NEKTAR").FirstChildElement("GEOMETRY").Element(); ASSERTL0(mesh, "Unable to find GEOMETRY tag in file."); ReadCurves(doc); ReadEdges(doc); ReadElements(doc); ReadComposites(doc); ReadDomain(doc); }
StdNodalTriExp::StdNodalTriExp( const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, LibUtilities::PointsType Ntype): StdExpansion (LibUtilities::StdTriData::getNumberOfCoefficients( Ba.GetNumModes(), Bb.GetNumModes()), 2,Ba,Bb), StdExpansion2D(LibUtilities::StdTriData::getNumberOfCoefficients( Ba.GetNumModes(), Bb.GetNumModes()), Ba,Bb), StdTriExp (Ba,Bb), m_nodalPointsKey(Ba.GetNumModes(),Ntype) { ASSERTL0(m_base[0]->GetNumModes() == m_base[1]->GetNumModes(), "Nodal basis initiated with different orders in the a " "and b directions"); }
/** * Initialisation for the transient growth */ void DriverArnoldi::CopyFwdToAdj() { Array<OneD, MultiRegions::ExpListSharedPtr> fields; if(m_timeSteppingAlgorithm) { fields = m_equ[0]->UpdateFields(); int nq = fields[0]->GetNcoeffs(); for (int k=0 ; k < m_nfields; ++k) { Vmath::Vcopy(nq, &fields[k]->GetCoeffs()[0], 1,&m_equ[1]->UpdateFields()[k]->UpdateCoeffs()[0], 1); } } else { ASSERTL0(false,"Transient Growth non available for Coupled Solver"); } };