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 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::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]); }
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 ); }
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]); }
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::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 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); }
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 TpetraVector::set_local(const std::vector<double>& values) { dolfin_assert(!_x.is_null()); const std::size_t num_values = local_size(); if (values.size() != num_values) { dolfin_error("TpetraVector.cpp", "set local values of Tpetra vector", "Size of values array is not equal to local vector size"); } if (num_values == 0) return; Teuchos::ArrayRCP<double> arr = _x->getDataNonConst(0); std::copy(values.begin(), values.end(), arr.get()); }
void Filtered_UniqueGlobalIndexer<LocalOrdinalT,GlobalOrdinalT>:: getOwnedAndGhostedNotFilteredIndicator(std::vector<int> & indicator) const { using Teuchos::RCP; typedef GlobalOrdinalT GO; typedef LocalOrdinalT LO; typedef panzer::TpetraNodeType Node; typedef Tpetra::Map<LO, GO, Node> Map; typedef Tpetra::Vector<GO,LO,GO,Node> Vector; typedef Tpetra::Import<LO,GO,Node> Import; std::vector<GlobalOrdinalT> ownedIndices; std::vector<GlobalOrdinalT> ghostedIndices; // build owned and ghosted maps getOwnedIndices(ownedIndices); getOwnedAndGhostedIndices(ghostedIndices); RCP<const Map> ownedMap = Tpetra::createNonContigMap<LO,GO>(ownedIndices,getComm()); RCP<const Map> ghostedMap = Tpetra::createNonContigMap<LO,GO>(ghostedIndices,getComm()); // allocate the owned vector, mark those GIDs as unfiltered // (they are by definition) Vector ownedActive(ownedMap); ownedActive.putScalar(1); // Initialize all indices to zero Vector ghostedActive(ghostedMap); ghostedActive.putScalar(0); // do communication, marking unfiltered indices as 1 (filtered // indices locally are marked as zero) Import importer(ownedMap,ghostedMap); ghostedActive.doImport(ownedActive,importer,Tpetra::INSERT); Teuchos::ArrayRCP<const GO> data = ghostedActive.getData(); // copy communicated data (clear it out first) indicator.clear(); indicator.insert(indicator.end(),data.begin(),data.end()); }
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; }
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(); }
//----------------------------------------------------------------------------- void TpetraVector::gather_on_zero(std::vector<double>& v) const { dolfin_assert(!_x.is_null()); if (_x->getMap()->getComm()->getRank() == 0) v.resize(size()); else v.resize(0); // Create map with elements only on process zero Teuchos::RCP<map_type> ymap(new map_type(size(), v.size(), 0, _x->getMap()->getComm())); Teuchos::RCP<vector_type> y(new vector_type(ymap, 1)); // Export from vector x to vector y Tpetra::Export<vector_type::local_ordinal_type, vector_type::global_ordinal_type, vector_type::node_type> exporter(_x->getMap(), ymap); y->doExport(*_x, exporter, Tpetra::INSERT); Teuchos::ArrayRCP<const double> yarr = y->getData(0); std::copy(yarr.get(), yarr.get() + v.size(), v.begin()); }
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]); }
//! 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]); }
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); } }
int main_(Teuchos::CommandLineProcessor &clp, int argc, char *argv[]) { #include <MueLu_UseShortNames.hpp> using Teuchos::RCP; using Teuchos::rcp; using Teuchos::TimeMonitor; // ========================================================================= // MPI initialization using Teuchos // ========================================================================= Teuchos::GlobalMPISession mpiSession(&argc, &argv, NULL); RCP< const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm(); int numProc = comm->getSize(); int myRank = comm->getRank(); // ========================================================================= // Parameters initialization // ========================================================================= ::Xpetra::Parameters xpetraParameters(clp); bool runHeavyTests = false; clp.setOption("heavytests", "noheavytests", &runHeavyTests, "whether to exercise tests that take a long time to run"); clp.recogniseAllOptions(true); switch (clp.parse(argc,argv)) { case Teuchos::CommandLineProcessor::PARSE_HELP_PRINTED: return EXIT_SUCCESS; case Teuchos::CommandLineProcessor::PARSE_ERROR: case Teuchos::CommandLineProcessor::PARSE_UNRECOGNIZED_OPTION: return EXIT_FAILURE; case Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL: break; } Xpetra::UnderlyingLib lib = xpetraParameters.GetLib(); // ========================================================================= // Problem construction // ========================================================================= ParameterList matrixParameters; matrixParameters.set("nx", Teuchos::as<GO>(9999)); matrixParameters.set("matrixType", "Laplace1D"); RCP<Matrix> A = MueLuTests::TestHelpers::TestFactory<SC, LO, GO, NO>::Build1DPoisson(matrixParameters.get<GO>("nx"), lib); RCP<MultiVector> coordinates = Galeri::Xpetra::Utils::CreateCartesianCoordinates<SC,LO,GO,Map,MultiVector>("1D", A->getRowMap(), matrixParameters); std::string outDir = "Output/"; std::vector<std::string> dirList; if (runHeavyTests) { dirList.push_back("EasyParameterListInterpreter-heavy/"); dirList.push_back("FactoryParameterListInterpreter-heavy/"); } else { dirList.push_back("EasyParameterListInterpreter/"); dirList.push_back("FactoryParameterListInterpreter/"); } #if defined(HAVE_MPI) && defined(HAVE_MUELU_ISORROPIA) && defined(HAVE_AMESOS2_KLU2) // The ML interpreter have internal ifdef, which means that the resulting // output would depend on configuration (reguarl interpreter does not have // that). Therefore, we need to stabilize the configuration here. // In addition, we run ML parameter list tests only if KLU is available dirList.push_back("MLParameterListInterpreter/"); dirList.push_back("MLParameterListInterpreter2/"); #endif int numLists = dirList.size(); bool failed = false; Teuchos::Time timer("Interpreter timer"); //double lastTime = timer.wallTime(); for (int k = 0; k < numLists; k++) { Teuchos::ArrayRCP<std::string> fileList = MueLuTests::TestHelpers::GetFileList(dirList[k], (numProc == 1 ? std::string(".xml") : std::string("_np" + Teuchos::toString(numProc) + ".xml"))); for (int i = 0; i < fileList.size(); i++) { // Set seed std::srand(12345); // Reset (potentially) cached value of the estimate A->SetMaxEigenvalueEstimate(-Teuchos::ScalarTraits<SC>::one()); std::string xmlFile = dirList[k] + fileList[i]; std::string outFile = outDir + fileList[i]; std::string baseFile = outFile.substr(0, outFile.find_last_of('.')); std::size_t found = baseFile.find("_np"); if (numProc == 1 && found != std::string::npos) { #ifdef HAVE_MPI baseFile = baseFile.substr(0, found); #else std::cout << "Skipping \"" << xmlFile << "\" as MPI is not enabled" << std::endl; continue; #endif } baseFile = baseFile + (lib == Xpetra::UseEpetra ? "_epetra" : "_tpetra"); std::string goldFile = baseFile + ".gold"; std::ifstream f(goldFile.c_str()); if (!f.good()) { if (myRank == 0) std::cout << "Warning: comparison file " << goldFile << " not found. Skipping test" << std::endl; continue; } std::filebuf buffer; std::streambuf* oldbuffer = NULL; if (myRank == 0) { // Redirect output buffer.open((baseFile + ".out").c_str(), std::ios::out); oldbuffer = std::cout.rdbuf(&buffer); } // NOTE: we cannot use ParameterListInterpreter(xmlFile, comm), because we want to update the ParameterList // first to include "test" verbosity Teuchos::ParameterList paramList; Teuchos::updateParametersFromXmlFileAndBroadcast(xmlFile, Teuchos::Ptr<Teuchos::ParameterList>(¶mList), *comm); if (dirList[k] == "EasyParameterListInterpreter/" || dirList[k] == "EasyParameterListInterpreter-heavy/") paramList.set("verbosity", "test"); else if (dirList[k] == "FactoryParameterListInterpreter/" || dirList[k] == "FactoryParameterListInterpreter-heavy/") paramList.sublist("Hierarchy").set("verbosity", "Test"); else if (dirList[k] == "MLParameterListInterpreter/") paramList.set("ML output", 42); else if (dirList[k] == "MLParameterListInterpreter2/") paramList.set("ML output", 10); try { timer.start(); Teuchos::RCP<HierarchyManager> mueluFactory; // create parameter list interpreter // here we have to distinguish between the general MueLu parameter list interpreter // and the ML parameter list interpreter. Note that the ML paramter interpreter also // works with Tpetra matrices. if (dirList[k] == "EasyParameterListInterpreter/" || dirList[k] == "EasyParameterListInterpreter-heavy/" || dirList[k] == "FactoryParameterListInterpreter/" || dirList[k] == "FactoryParameterListInterpreter-heavy/") { mueluFactory = Teuchos::rcp(new ParameterListInterpreter(paramList)); } else if (dirList[k] == "MLParameterListInterpreter/") { mueluFactory = Teuchos::rcp(new MLParameterListInterpreter(paramList)); } else if (dirList[k] == "MLParameterListInterpreter2/") { //std::cout << "ML ParameterList: " << std::endl; //std::cout << paramList << std::endl; RCP<ParameterList> mueluParamList = Teuchos::getParametersFromXmlString(MueLu::ML2MueLuParameterTranslator::translate(paramList,"SA")); //std::cout << "MueLu ParameterList: " << std::endl; //std::cout << *mueluParamList << std::endl; mueluFactory = Teuchos::rcp(new ParameterListInterpreter(*mueluParamList)); } RCP<Hierarchy> H = mueluFactory->CreateHierarchy(); H->GetLevel(0)->template Set<RCP<Matrix> >("A", A); if (dirList[k] == "MLParameterListInterpreter/") { // MLParameterInterpreter needs the nullspace information if rebalancing is active! // add default constant null space vector RCP<MultiVector> nullspace = MultiVectorFactory::Build(A->getRowMap(), 1); nullspace->putScalar(1.0); H->GetLevel(0)->Set("Nullspace", nullspace); } H->GetLevel(0)->Set("Coordinates", coordinates); mueluFactory->SetupHierarchy(*H); if (strncmp(fileList[i].c_str(), "reuse", 5) == 0) { // Build the Hierarchy the second time // Should be faster if we actually do the reuse A->SetMaxEigenvalueEstimate(-Teuchos::ScalarTraits<SC>::one()); mueluFactory->SetupHierarchy(*H); } timer.stop(); } catch (Teuchos::ExceptionBase& e) { std::string msg = e.what(); msg = msg.substr(msg.find_last_of('\n')+1); if (myRank == 0) { std::cout << "Caught exception: " << msg << std::endl; // Redirect output back std::cout.rdbuf(oldbuffer); buffer.close(); } if (msg == "Zoltan interface is not available" || msg == "Zoltan2 interface is not available" || msg == "MueLu::FactoryFactory:BuildFactory(): Cannot create a Zoltan2Interface object: Zoltan2 is disabled: HAVE_MUELU_ZOLTAN2 && HAVE_MPI == false.") { if (myRank == 0) std::cout << xmlFile << ": skipped (missing library)" << std::endl; continue; } } std::string cmd; if (myRank == 0) { // Redirect output back std::cout.rdbuf(oldbuffer); buffer.close(); // Create a copy of outputs cmd = "cp -f "; system((cmd + baseFile + ".gold " + baseFile + ".gold_filtered").c_str()); system((cmd + baseFile + ".out " + baseFile + ".out_filtered").c_str()); // Tpetra produces different eigenvalues in Chebyshev due to using // std::rand() for generating random vectors, which may be initialized // using different seed, and may have different algorithm from one // gcc version to another, or to anogther compiler (like clang) // This leads to us always failing this test. // NOTE1 : Epetra, on the other hand, rolls out its out random number // generator, which always produces same results // Ignore the value of "lambdaMax" run_sed("'s/lambdaMax: [0-9]*.[0-9]*/lambdaMax = <ignored>/'", baseFile); // Ignore the value of "lambdaMin" run_sed("'s/lambdaMin: [0-9]*.[0-9]*/lambdaMin = <ignored>/'", baseFile); // Ignore the value of "chebyshev: max eigenvalue" // NOTE: we skip lines with default value ([default]) run_sed("'/[default]/! s/chebyshev: max eigenvalue = [0-9]*.[0-9]*/chebyshev: max eigenvalue = <ignored>/'", baseFile); // Ignore the exact type of direct solver (it is selected semi-automatically // depending on how Trilinos was configured run_sed("'s/Amesos\\([2]*\\)Smoother{type = .*}/Amesos\\1Smoother{type = <ignored>}/'", baseFile); run_sed("'s/SuperLU solver interface, direct solve/<Direct> solver interface/'", baseFile); run_sed("'s/KLU2 solver interface/<Direct> solver interface/'", baseFile); run_sed("'s/Basker solver interface/<Direct> solver interface/'", baseFile); // Strip template args for some classes std::vector<std::string> classes; classes.push_back("Xpetra::Matrix"); classes.push_back("MueLu::Constraint"); classes.push_back("MueLu::SmootherPrototype"); for (size_t q = 0; q < classes.size(); q++) run_sed("'s/" + classes[q] + "<.*>/" + classes[q] + "<ignored> >/'", baseFile); #ifdef __APPLE__ // Some Macs print outs ptrs as 0x0 instead of 0, fix that run_sed("'/RCP/ s/=0x0/=0/g'", baseFile); #endif // Run comparison (ignoring whitespaces) cmd = "diff -u -w -I\"^\\s*$\" " + baseFile + ".gold_filtered " + baseFile + ".out_filtered"; int ret = system(cmd.c_str()); if (ret) failed = true; //std::ios_base::fmtflags ff(std::cout.flags()); //std::cout.precision(2); //std::cout << xmlFile << " (" << std::setiosflags(std::ios::fixed) // << timer.wallTime() - lastTime << " sec.) : " << (ret ? "failed" : "passed") << std::endl; //lastTime = timer.wallTime(); //std::cout.flags(ff); // reset flags to whatever they were prior to printing time std::cout << xmlFile << " : " << (ret ? "failed" : "passed") << std::endl; } } } if (myRank == 0) std::cout << std::endl << "End Result: TEST " << (failed ? "FAILED" : "PASSED") << std::endl; return (failed ? EXIT_FAILURE : EXIT_SUCCESS); }
int testNormalizeMat(RCP<MatOrthoManager<ST,MV,OP> > OM, RCP<const MV> S) { typedef MultiVecTraits<double,MV> MVT; typedef OperatorTraits<double,MV,OP> OPT; typedef ScalarTraits<double> SCT; typedef SCT::magnitudeType MT; const ST ONE = SCT::one(); const MT ZERO = SCT::magnitude(SCT::zero()); const int sizeS = MVT::GetNumberVecs(*S); int numerr = 0; bool hasM = (OM->getOp() != null); std::ostringstream sout; // // output tests: // <S_out,S_out> = I // S_in = S_out B // // we will loop over an integer specifying the test combinations // the bit pattern for the different tests is listed in parenthesis // // for each of the following, we should test B // // if hasM: // with and without MS (1) // // as hasM controls the upper level bits, we need only run test case 0 if hasM==false // otherwise, we run test cases 0-1 // int numtests; RCP<MV> MS; if (hasM) { MS = MVT::Clone(*S,sizeS); OPT::Apply(*(OM->getOp()),*S ,*MS); numtests = 2; } else { numtests = 1; } for (int t=0; t<numtests; t++) { // pointers to simplify calls below RCP<MV> lclMS; if ( t & 1 ) { lclMS = MS; } Teuchos::ArrayRCP<ST> Bdata = Teuchos::arcp<ST>(sizeS*sizeS); RCP<SerialDenseMatrix<int,ST> > B = rcp( new SerialDenseMatrix<int,ST>(Teuchos::View,Bdata.getRawPtr(),sizeS,sizeS,sizeS) ); try { // call routine // test all outputs for correctness // here is where the outputs go RCP<MV> Scopy, MScopy; int ret; // copies of S,MS Scopy = MVT::CloneCopy(*S); if (lclMS != Teuchos::null) { MScopy = MVT::CloneCopy(*lclMS); } // randomize this data, it should be overwritten B->random(); // run test ret = OM->normalizeMat(*Scopy,B,MScopy); sout << "normalizeMat() returned rank " << ret << endl; if (ret == 0) { sout << " Cannot continue." << endl; numerr++; break; } // normalizeMat() is only required to return a // basis of rank "ret" // this is what we will test: // the first "ret" columns in Scopy, MScopy // the first "ret" rows in B // get pointers to the parts that we want if (ret < sizeS) { vector<int> ind(ret); for (int i=0; i<ret; i++) { ind[i] = i; } Scopy = MVT::CloneViewNonConst(*Scopy,ind); if (MScopy != null) { MScopy = MVT::CloneViewNonConst(*MScopy,ind); } B = rcp( new SerialDenseMatrix<int,ST>(Teuchos::View,Bdata.getRawPtr(),ret,ret,sizeS) ); } // test all outputs for correctness // MS == M*S if (MScopy != null) { RCP<MV> tmp = MVT::Clone(*Scopy,ret); OPT::Apply(*(OM->getOp()),*Scopy,*tmp); MT err = MVDiff(*tmp,*MScopy); if (err > TOL) { sout << " vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv tolerance exceeded! test failed!" << endl; numerr++; } sout << " " << t << "|| MS - M*S || : " << err << endl; } // S^T M S == I { MT err = OM->orthonormError(*Scopy); if (err > TOL) { sout << " vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv tolerance exceeded! test failed!" << endl; numerr++; } sout << " || <S,S> - I || after : " << err << endl; } // S_in = S_out*B { RCP<MV> tmp = MVT::Clone(*S,sizeS); MVT::MvTimesMatAddMv(ONE,*Scopy,*B,ZERO,*tmp); MT err = MVDiff(*tmp,*S); if (err > ATOL*TOL) { sout << " vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv tolerance exceeded! test failed!" << endl; numerr++; } sout << " " << t << "|| S_in - S_out*B || : " << err << endl; } } catch (const OrthoError &e) { sout << " ------------------------------------------- normalizeMat() threw exception" << endl; sout << " Error: " << e.what() << endl; numerr++; } } // test for MsgType type = Warnings; if (numerr>0) type = Errors; MyOM->stream(type) << sout.str(); MyOM->stream(type) << endl; return numerr; }