void Ifpack2Smoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>::SetupLineSmoothing(Level& currentLevel) { if (this->IsSetup() == true) this->GetOStream(Warnings0) << "MueLu::Ifpack2Smoother::Setup(): Setup() has already been called" << std::endl; ParameterList& myparamList = const_cast<ParameterList&>(this->GetParameterList()); LO CoarseNumZLayers = Factory::Get<LO>(currentLevel,"CoarseNumZLayers"); if (CoarseNumZLayers > 0) { Teuchos::ArrayRCP<LO> TVertLineIdSmoo = Factory::Get< Teuchos::ArrayRCP<LO> >(currentLevel, "LineDetection_VertLineIds"); // determine number of local parts LO maxPart = 0; for(size_t k = 0; k < Teuchos::as<size_t>(TVertLineIdSmoo.size()); k++) { if(maxPart < TVertLineIdSmoo[k]) maxPart = TVertLineIdSmoo[k]; } size_t numLocalRows = A_->getNodeNumRows(); TEUCHOS_TEST_FOR_EXCEPTION(numLocalRows % TVertLineIdSmoo.size() != 0, Exceptions::RuntimeError, "MueLu::Ifpack2Smoother::Setup(): the number of local nodes is incompatible with the TVertLineIdsSmoo."); if (numLocalRows == Teuchos::as<size_t>(TVertLineIdSmoo.size())) { myparamList.set("partitioner: type","user"); myparamList.set("partitioner: map",TVertLineIdSmoo); myparamList.set("partitioner: local parts",maxPart+1); } else { // we assume a constant number of DOFs per node size_t numDofsPerNode = numLocalRows / TVertLineIdSmoo.size(); // Create a new Teuchos::ArrayRCP<LO> of size numLocalRows and fill it with the corresponding information Teuchos::ArrayRCP<LO> partitionerMap(numLocalRows, Teuchos::OrdinalTraits<LocalOrdinal>::invalid()); for (size_t blockRow = 0; blockRow < Teuchos::as<size_t>(TVertLineIdSmoo.size()); ++blockRow) for (size_t dof = 0; dof < numDofsPerNode; dof++) partitionerMap[blockRow * numDofsPerNode + dof] = TVertLineIdSmoo[blockRow]; myparamList.set("partitioner: type","user"); myparamList.set("partitioner: map",partitionerMap); myparamList.set("partitioner: local parts",maxPart + 1); } if (type_ == "LINESMOOTHING_BANDED_RELAXATION" || type_ == "LINESMOOTHING_BANDED RELAXATION" || type_ == "LINESMOOTHING_BANDEDRELAXATION") type_ = "BANDEDRELAXATION"; else type_ = "BLOCKRELAXATION"; } else { // line detection failed -> fallback to point-wise relaxation this->GetOStream(Runtime0) << "Line detection failed: fall back to point-wise relaxation" << std::endl; myparamList.remove("partitioner: type",false); myparamList.remove("partitioner: map", false); myparamList.remove("partitioner: local parts",false); type_ = "RELAXATION"; } RCP<const Tpetra::RowMatrix<SC, LO, GO, NO> > tpA = Utilities::Op2NonConstTpetraRow(A_); prec_ = Ifpack2::Factory::create(type_, tpA, overlap_); SetPrecParameters(); prec_->initialize(); prec_->compute(); }
bool Tpetra::Utils::parseRfmt(Teuchos::ArrayRCP<char> fmt, int &perline, int &width, int &prec, char &valformat) { TEUCHOS_TEST_FOR_EXCEPT(fmt.size() != 0 && fmt[fmt.size()-1] != '\0'); std::transform(fmt.begin(), fmt.end(), fmt, static_cast < int(*)(int) > (std::toupper)); // find the first left paren '(' and the last right paren ')' Teuchos::ArrayRCP<char>::iterator firstLeftParen = std::find( fmt.begin(), fmt.end(), '('); Teuchos::ArrayRCP<char>::iterator lastRightParen = std::find(std::reverse_iterator<Teuchos::ArrayRCP<char>::iterator>(fmt.end()), std::reverse_iterator<Teuchos::ArrayRCP<char>::iterator>(fmt.begin()), ')').base()-1; // select the substring between the parens, including them // if neither was found, set the string to empty if (firstLeftParen == fmt.end() || lastRightParen == fmt.begin()) { fmt.resize(0 + 1); fmt[0] = '\0'; } else { fmt += (firstLeftParen - fmt.begin()); size_t newLen = lastRightParen - firstLeftParen + 1; fmt.resize(newLen + 1); fmt[newLen] = '\0'; } if (std::find(fmt.begin(),fmt.end(),'P') != fmt.end()) { // not supported return true; } bool error = true; if (std::sscanf(fmt.getRawPtr(),"(%d%c%d.%d)",&perline,&valformat,&width,&prec) == 4) { if (valformat == 'E' || valformat == 'D' || valformat == 'F') { error = false; } } return error; }
bool Tpetra::Utils::parseIfmt(Teuchos::ArrayRCP<char> fmt, int &perline, int &width) { TEUCHOS_TEST_FOR_EXCEPT(fmt.size() != 0 && fmt[fmt.size()-1] != '\0'); // parses integers n and d out of (nId) bool error = true; std::transform(fmt.begin(), fmt.end(), fmt, static_cast < int(*)(int) > (std::toupper)); if (std::sscanf(fmt.getRawPtr(),"(%dI%d)",&perline,&width) == 2) { error = false; } return error; }
void writeToScreen(std::ostream & os,const Thyra::VectorBase<double> & src) { const Thyra::SpmdVectorBase<double> & spmdSrc = Teuchos::dyn_cast<const Thyra::SpmdVectorBase<double> >(src); // get access to data Teuchos::ArrayRCP<const double> srcData; spmdSrc.getLocalData(Teuchos::ptrFromRef(srcData)); os << "Local Size = " << srcData.size() << std::endl; for (int i=0; i < srcData.size(); ++i) { os << " " << srcData[i] << std::endl; } }
void Albany::HMCProblem:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct>> meshSpecs, Albany::StateManager& stateMgr) { /* Construct All Phalanx Evaluators */ TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block"); fm.resize(1); fm[0] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, BUILD_RESID_FM, Teuchos::null); if(meshSpecs[0]->nsNames.size() > 0) // Build a nodeset evaluator if nodesets are present constructDirichletEvaluators(*meshSpecs[0]); if(meshSpecs[0]->ssNames.size() > 0) // Build a sideset evaluator if sidesets are present constructNeumannEvaluators(meshSpecs[0]); #ifdef ALBANY_ATO if( params->isType<Teuchos::RCP<ATO::Topology>>("Topology") ) setupTopOpt(meshSpecs,stateMgr); #endif }
DataTransferKit::FieldContainer<double> MultiAppDTKUserObjectEvaluator::evaluate(const Teuchos::ArrayRCP<GlobalOrdinal>& bids, const Teuchos::ArrayRCP<double>& coords) { Teuchos::RCP<const Teuchos::Comm<int> > comm = Teuchos::rcp(new Teuchos::MpiComm<int>(Teuchos::rcp(new Teuchos::OpaqueWrapper<MPI_Comm>(libMesh::COMM_WORLD)))); int num_values = bids.size(); Teuchos::ArrayRCP<double> evaluated_data(num_values); unsigned int dim = 3; // TODO: REPLACE ME!!!!!!!!! for (GlobalOrdinal i=0; i<num_values; i++) { // See if this app is on this processor if (std::binary_search(_box_ids.begin(), _box_ids.end(), bids[i])) { GlobalOrdinal app = bids[i]; Point p; for(unsigned int j=0; j<dim; j++) p(j) = coords[(j*num_values)+i]; evaluated_data[i] = _multi_app.appUserObjectBase(app, _user_object_name).spatialValue(p); } else evaluated_data[i] = 0.0; } return DataTransferKit::FieldContainer<double>(evaluated_data, 1); }
void Hydrology::buildProblem (Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { // Building cell basis and cubature const CellTopologyData * const cell_top = &meshSpecs[0]->ctd; intrepidBasis = Albany::getIntrepid2Basis(*cell_top); cellType = Teuchos::rcp(new shards::CellTopology (cell_top)); Intrepid2::DefaultCubatureFactory cubFactory; cubature = cubFactory.create<PHX::Device, RealType, RealType>(*cellType, meshSpecs[0]->cubatureDegree); elementBlockName = meshSpecs[0]->ebName; const int worksetSize = meshSpecs[0]->worksetSize; const int numCellVertices = cellType->getNodeCount(); const int numCellNodes = intrepidBasis->getCardinality(); const int numCellQPs = cubature->getNumPoints(); dl = Teuchos::rcp(new Albany::Layouts(worksetSize,numCellVertices,numCellNodes,numCellQPs,numDim)); /* Construct All Phalanx Evaluators */ TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block"); fm.resize(1); fm[0] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM,Teuchos::null); if(meshSpecs[0]->nsNames.size() > 0) { // Build a nodeset evaluator if nodesets are present constructDirichletEvaluators(*meshSpecs[0]); } if(meshSpecs[0]->ssNames.size() > 0) { // Build a sideset evaluator if sidesets are present constructNeumannEvaluators(meshSpecs[0]); } }
void IntrepidKernel<Scalar>::evaluate( Teuchos::ArrayRCP<Scalar> &function_values, const Teuchos::ArrayRCP<Scalar> &coeffs, const Teuchos::ArrayRCP<Scalar> &dfunc_values ) { int dim1 = this->b_cardinality; testPrecondition( dim1 == (int) coeffs.size(), "Function coefficients size does not match basis cardinality" ); MDArray function_coeffs( 1, dim1 ); for ( int m = 0; m < dim1; ++m ) { function_coeffs(0,m) = coeffs[m]; } MDArray basis_eval( 1, dim1, 1 ); for ( int i = 0; i < dim1; ++i ) { basis_eval( 0, i, 0 ) = dfunc_values[i]; } Teuchos::Tuple<int,2> function_dimensions; function_dimensions[0] = 1; function_dimensions[1] = 1; MDArray function_eval( function_dimensions, function_values ); Intrepid::FunctionSpaceTools::evaluate<Scalar>( function_eval, function_coeffs, basis_eval ); }
// ============================================================================= Teuchos::RCP<Epetra_Map> VIO::EpetraMesh::Reader:: createComplexValuesMap_ ( const Epetra_Map & nodesMap ) const { // get view for the global indices of the global elements int numMyElements = nodesMap.NumMyElements(); Teuchos::ArrayRCP<int> myGlobalElements( numMyElements ); nodesMap.MyGlobalElements( myGlobalElements.getRawPtr() ); // Construct the map in such a way that all complex entries on processor K // are split up into real and imaginary part, which will both reside on // processor K again. int numMyComplexElements = 2*numMyElements; Teuchos::ArrayRCP<int> myComplexGlobalElements ( numMyComplexElements ); for ( int k = 0; k < numMyElements; k++ ) { myComplexGlobalElements[2*k ] = 2 * myGlobalElements[k]; myComplexGlobalElements[2*k+1] = 2 * myGlobalElements[k] + 1; } return Teuchos::rcp ( new Epetra_Map ( -1, myComplexGlobalElements.size(), myComplexGlobalElements.getRawPtr(), nodesMap.IndexBase(), nodesMap.Comm() ) ); }
void Albany::PoissonsEquationProblem:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { int physSets = meshSpecs.size(); *out << "Num MeshSpecs: " << physSets << '\n'; fm.resize(physSets); bool haveSidesets = false; *out << "Calling PoissonsEquationProblem::buildEvaluators" << '\n'; for (int ps = 0; ps < physSets; ++ps) { fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM, Teuchos::null); if (meshSpecs[ps]->ssNames.size() > 0) haveSidesets = true; } constructDirichletEvaluators(*meshSpecs[0]); if( haveSidesets ) constructNeumannEvaluators(meshSpecs[0]); if( params->isType<Teuchos::RCP<ATO::Topology> >("Topology") ) setupTopOpt(meshSpecs,stateMgr); }
//------------------------------------------------------------------------------ void Albany::MechanicsProblem:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct>> meshSpecs, Albany::StateManager& stateMgr) { // Construct All Phalanx Evaluators int physSets = meshSpecs.size(); *out << "Num MeshSpecs: " << physSets << '\n'; fm.resize(physSets); bool haveSidesets = false; *out << "Calling MechanicsProblem::buildEvaluators" << '\n'; for (int ps = 0; ps < physSets; ++ps) { fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM, Teuchos::null); if (meshSpecs[ps]->ssNames.size() > 0) haveSidesets = true; } constructDirichletEvaluators(*meshSpecs[0]); if (haveSidesets) constructNeumannEvaluators(meshSpecs[0]); }
MyField evaluate( const Teuchos::ArrayRCP<MyMesh::global_ordinal_type>& elements, const Teuchos::ArrayRCP<double>& coords ) { int num_elements = elements.size(); MyField evaluated_data( num_elements, 3 ); for ( int n = 0; n < num_elements; ++n ) { if ( std::find( d_mesh.elementsBegin(), d_mesh.elementsEnd(), elements[n] ) != d_mesh.elementsEnd() ) { *(evaluated_data.begin() + n ) = d_comm->getRank() + 1.0; *(evaluated_data.begin() + num_elements + n ) = d_comm->getRank() + 1.0; *(evaluated_data.begin() + 2*num_elements + n ) = d_comm->getRank() + 1.0; } else { *(evaluated_data.begin() + n ) = 0.0; *(evaluated_data.begin() + num_elements + n ) = 0.0; *(evaluated_data.begin() + 2*num_elements + n ) = 0.0; } } return evaluated_data; }
void LocalAggregationAlgorithm<LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::RandomReorder(Teuchos::ArrayRCP<LO> list) const { //TODO: replace int int n = list.size(); for(int i=0; i<n-1; i++) { std::swap(list[i], list[RandomOrdinal(i,n-1)]); } }
void Albany::NavierStokes:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { using Teuchos::rcp; /* Construct All Phalanx Evaluators */ TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block"); fm.resize(1); fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, BUILD_RESID_FM, Teuchos::null); if(meshSpecs[0]->nsNames.size() > 0) // Build a nodeset evaluator if nodesets are present constructDirichletEvaluators(meshSpecs[0]->nsNames); if(meshSpecs[0]->ssNames.size() > 0) // Build a sideset evaluator if sidesets are present constructNeumannEvaluators(meshSpecs[0]); }
void Albany::PNPProblem:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { using Teuchos::rcp; /* Construct All Phalanx Evaluators */ int physSets = meshSpecs.size(); std::cout << "PNP Problem Num MeshSpecs: " << physSets << std::endl; fm.resize(physSets); for (int ps=0; ps<physSets; ps++) { fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM, Teuchos::null); } if(meshSpecs[0]->nsNames.size() > 0) // Build a nodeset evaluator if nodesets are present constructDirichletEvaluators(*meshSpecs[0]); if(meshSpecs[0]->ssNames.size() > 0) // Build a sideset evaluator if sidesets are present constructNeumannEvaluators(meshSpecs[0]); }
Teuchos::ArrayRCP<LocalOrdinal> Aggregates<LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::ComputeAggregateSizes(bool forceRecompute, bool cacheSizes) const { if (aggregateSizes_ != Teuchos::null && !forceRecompute) { return aggregateSizes_; } else { //invalidate previous sizes. aggregateSizes_ = Teuchos::null; Teuchos::ArrayRCP<LO> aggregateSizes; aggregateSizes = Teuchos::ArrayRCP<LO>(nAggregates_,0); int myPid = vertex2AggId_->getMap()->getComm()->getRank(); Teuchos::ArrayRCP<LO> procWinner = procWinner_->getDataNonConst(0); Teuchos::ArrayRCP<LO> vertex2AggId = vertex2AggId_->getDataNonConst(0); LO size = procWinner.size(); //for (LO i = 0; i < nAggregates_; ++i) aggregateSizes[i] = 0; for (LO k = 0; k < size; ++k ) { if (procWinner[k] == myPid) aggregateSizes[vertex2AggId[k]]++; } if (cacheSizes) aggregateSizes_ = aggregateSizes; return aggregateSizes; } } //ComputeAggSizesNodes
//----------------------------------------------------------------------------- double TpetraVector::max() const { dolfin_assert(!_x.is_null()); Teuchos::ArrayRCP<const double> arr = _x->getData(0); double max_local = *std::max_element(arr.get(), arr.get() + arr.size()); return MPI::max(mpi_comm(), max_local); }
DataTransferKit::FieldContainer<double> evaluate( const Teuchos::ArrayRCP<int>& gids, const Teuchos::ArrayRCP<double>& coords ) { Teuchos::ArrayRCP<double> evaluated_data( gids.size() ); for ( int n = 0; n < gids.size(); ++n ) { if ( std::find( d_geom_gids.begin(), d_geom_gids.end(), gids[n] ) != d_geom_gids.end() ) { evaluated_data[n] = 1.0 + gids[n]; } else { evaluated_data[n] = 0.0; } } return DataTransferKit::FieldContainer<double>( evaluated_data, 1 ); }
MyField evaluate( const Teuchos::ArrayRCP<int>& gids, const Teuchos::ArrayRCP<double>& coords ) { MyField evaluated_data( gids.size(), 1 ); for ( int n = 0; n < gids.size(); ++n ) { if ( std::find( d_geom_gids.begin(), d_geom_gids.end(), gids[n] ) != d_geom_gids.end() ) { *(evaluated_data.begin() + n ) = 1.0; } else { *(evaluated_data.begin() + n ) = 0.0; } } return evaluated_data; }
MyField evaluate( const Teuchos::ArrayRCP< DataTransferKit::MeshContainer<int>::global_ordinal_type>& elements, const Teuchos::ArrayRCP<double>& coords ) { MyField evaluated_data( elements.size(), 1 ); for ( int n = 0; n < elements.size(); ++n ) { if ( std::find( d_mesh.elementsBegin(), d_mesh.elementsEnd(), elements[n] ) != d_mesh.elementsEnd() ) { *(evaluated_data.begin() + n ) = d_comm->getRank() + 1.0; } else { *(evaluated_data.begin() + n ) = 0.0; } } return evaluated_data; }
LCM:: Schwarz_BoundaryJacobian:: Schwarz_BoundaryJacobian( Teuchos::RCP<Teuchos_Comm const> const & comm, Teuchos::ArrayRCP<Teuchos::RCP<Albany::Application>> const & ca, Teuchos::Array<Teuchos::RCP<Tpetra_CrsMatrix>> jacs, int const this_app_index, int const coupled_app_index) : commT_(comm), coupled_apps_(ca), jacs_(jacs), this_app_index_(this_app_index), coupled_app_index_(coupled_app_index), b_use_transpose_(false), b_initialized_(false), n_models_(0) { assert(0 <= this_app_index && this_app_index < ca.size()); assert(0 <= coupled_app_index && coupled_app_index < ca.size()); domain_map_ = ca[coupled_app_index]->getMapT(); range_map_ = ca[this_app_index]->getMapT(); }
void Albany::Helmholtz2DProblem:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { /* Construct All Phalanx Evaluators */ TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block"); fm.resize(1); fm[0] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, BUILD_RESID_FM, Teuchos::null); constructDirichletEvaluators(*meshSpecs[0]); }
void DiscreteBoundaryOperator<ValueType>::applyImpl( const Thyra::EOpTransp M_trans, const Thyra::MultiVectorBase<ValueType> &X_in, const Teuchos::Ptr<Thyra::MultiVectorBase<ValueType>> &Y_inout, const ValueType alpha, const ValueType beta) const { typedef Thyra::Ordinal Ordinal; // Note: the name is VERY misleading: these asserts don't disappear in // release runs, and in case of failure throw exceptions rather than // abort. TEUCHOS_ASSERT(this->opSupported(M_trans)); TEUCHOS_ASSERT(X_in.range()->isCompatible(*this->domain())); TEUCHOS_ASSERT(Y_inout->range()->isCompatible(*this->range())); TEUCHOS_ASSERT(Y_inout->domain()->isCompatible(*X_in.domain())); const Ordinal colCount = X_in.domain()->dim(); // Loop over the input columns for (Ordinal col = 0; col < colCount; ++col) { // Get access the the elements of X_in's and Y_inout's column #col Thyra::ConstDetachedSpmdVectorView<ValueType> xVec(X_in.col(col)); Thyra::DetachedSpmdVectorView<ValueType> yVec(Y_inout->col(col)); const Teuchos::ArrayRCP<const ValueType> xArray(xVec.sv().values()); const Teuchos::ArrayRCP<ValueType> yArray(yVec.sv().values()); // Wrap the Trilinos array in an Armadillo vector. const_cast is used // because it's more natural to have a const arma::Col<ValueType> array // than an arma::Col<const ValueType> one. const arma::Col<ValueType> xCol(const_cast<ValueType *>(xArray.get()), xArray.size(), false /* copy_aux_mem */); arma::Col<ValueType> yCol(yArray.get(), yArray.size(), false); applyBuiltInImpl(static_cast<TranspositionMode>(M_trans), xCol, yCol, alpha, beta); } }
//! Copy a flat vector into a product vector void copyFlatThyraIntoBlockedThyra(const Thyra::VectorBase<double>& src, const Teuchos::Ptr<Thyra::VectorBase<double> > & dest) const { using Teuchos::RCP; using Teuchos::ArrayView; using Teuchos::rcpFromPtr; using Teuchos::rcp_dynamic_cast; const RCP<Thyra::ProductVectorBase<double> > prodDest = Thyra::castOrCreateNonconstProductVectorBase(rcpFromPtr(dest)); const Thyra::SpmdVectorBase<double> & spmdSrc = Teuchos::dyn_cast<const Thyra::SpmdVectorBase<double> >(src); // get access to flat data Teuchos::ArrayRCP<const double> srcData; spmdSrc.getLocalData(Teuchos::ptrFromRef(srcData)); std::size_t offset = 0; const int numBlocks = prodDest->productSpace()->numBlocks(); for (int b = 0; b < numBlocks; ++b) { const RCP<Thyra::VectorBase<double> > destBlk = prodDest->getNonconstVectorBlock(b); // get access to blocked data const RCP<Thyra::SpmdVectorBase<double> > spmdBlk = rcp_dynamic_cast<Thyra::SpmdVectorBase<double> >(destBlk, true); Teuchos::ArrayRCP<double> destData; spmdBlk->getNonconstLocalData(Teuchos::ptrFromRef(destData)); // perform copy for (int i=0; i < destData.size(); ++i) { destData[i] = srcData[i+offset]; } offset += destData.size(); } }
void Aeras::ShallowWaterProblemNoAD:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { using Teuchos::rcp; /* Construct All Phalanx Evaluators */ TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block"); fm.resize(1); fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM, Teuchos::null); }
void Albany::PeridigmProblem:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct>> meshSpecs, Albany::StateManager& stateMgr) { /* Construct All Phalanx Evaluators */ int physSets = meshSpecs.size(); fm.resize(physSets); for (int ps=0; ps<physSets; ps++) { fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM, Teuchos::null); } constructDirichletEvaluators(*meshSpecs[0]); }
void FELIX::StokesL1L2:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { using Teuchos::rcp; std::cout << "In StokesL1L2 Problem!" << std::endl; /* Construct All Phalanx Evaluators */ TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block"); fm.resize(1); fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM, Teuchos::null); constructDirichletEvaluators(*meshSpecs[0]); }
void Tsunami::Boussinesq:: buildProblem( Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { using Teuchos::rcp; /* Construct All Phalanx Evaluators */ TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block"); fm.resize(1); fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); elementBlockName = meshSpecs[0]->ebName; buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM, Teuchos::null); constructDirichletEvaluators(*meshSpecs[0]); //construct Neumann evaluators constructNeumannEvaluators(meshSpecs[0]); }
Teuchos::RCP<const Teuchos::ParameterList> getValidInitialConditionParameters(const Teuchos::ArrayRCP<std::string>& wsEBNames) { Teuchos::RCP<Teuchos::ParameterList> validPL = rcp(new Teuchos::ParameterList("ValidInitialConditionParams"));; validPL->set<std::string>("Function", "", ""); Teuchos::Array<double> defaultData; validPL->set<Teuchos::Array<double> >("Function Data", defaultData, ""); // Validate element block constant data for(int i = 0; i < wsEBNames.size(); i++) validPL->set<Teuchos::Array<double> >(wsEBNames[i], defaultData, ""); // For EBConstant data, we can optionally randomly perturb the IC on each variable some amount validPL->set<Teuchos::Array<double> >("Perturb IC", defaultData, ""); return validPL; }
//------------------------------------------------------------------------------ void Albany::ConcurrentMultiscaleProblem:: buildProblem(Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs, Albany::StateManager& stateMgr) { // Construct All Phalanx Evaluators int physSets = meshSpecs.size(); std::cout << "Num MeshSpecs: " << physSets << std::endl; fm.resize(physSets); std::cout << "Calling ConcurrentMultiscaleProblem::buildEvaluators" << std::endl; for (int ps=0; ps < physSets; ++ps) { std::string eb_name = meshSpecs[ps]->ebName; if ( material_db_->isElementBlockParam(eb_name,"Lagrange Multiplier Block") ) { lm_overlap_map_.insert(std::make_pair(eb_name, material_db_->getElementBlockParam<bool>(eb_name,"Lagrange Multiplier Block") ) ); } if ( material_db_->isElementBlockParam(eb_name,"Coarse Overlap Block") ) { coarse_overlap_map_.insert(std::make_pair(eb_name, material_db_->getElementBlockParam<bool>(eb_name,"Coarse Overlap Block") ) ); } if ( material_db_->isElementBlockParam(eb_name,"Fine Overlap Block") ) { fine_overlap_map_.insert(std::make_pair(eb_name, material_db_->getElementBlockParam<bool>(eb_name,"Fine Overlap Block") ) ); } fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>); buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM, Teuchos::null); } constructDirichletEvaluators(*meshSpecs[0]); }