void performNodalMeshReduction( stk::mesh::Part &samplePart, stk::mesh::BulkData& bulkData) { const stk::mesh::EntityRank nodeEntityRank(0); const stk::mesh::MetaData &metaData = stk::mesh::MetaData::get(bulkData); std::vector<stk::mesh::Entity *> sampleNodes; stk::mesh::get_selected_entities(samplePart, bulkData.buckets(nodeEntityRank), sampleNodes); const stk::mesh::Selector locallyOwned = stk::mesh::MetaData::get(bulkData).locally_owned_part(); std::vector<stk::mesh::Entity *> relatedEntities; typedef boost::indirect_iterator<std::vector<stk::mesh::Entity *>::const_iterator> EntityIterator; for (EntityIterator it(sampleNodes.begin()), it_end(sampleNodes.end()); it != it_end; ++it) { const stk::mesh::PairIterRelation relations = it->relations(); typedef stk::mesh::PairIterRelation::first_type RelationIterator; for (RelationIterator rel_it = relations.first, rel_it_end = relations.second; rel_it != rel_it_end; ++rel_it) { const Teuchos::Ptr<stk::mesh::Entity> relatedEntity(rel_it->entity()); if (Teuchos::nonnull(relatedEntity) && locallyOwned(*relatedEntity)) { relatedEntities.push_back(relatedEntity.get()); } } } std::sort(relatedEntities.begin(), relatedEntities.end(), stk::mesh::EntityLess()); relatedEntities.erase( std::unique(relatedEntities.begin(), relatedEntities.end(), stk::mesh::EntityEqual()), relatedEntities.end()); std::vector<stk::mesh::Entity *> sampleClosure; stk::mesh::find_closure(bulkData, relatedEntities, sampleClosure); // Keep only the closure, remove the rest, by decreasing entityRanks { const stk::mesh::Selector ownedOrShared = metaData.locally_owned_part() | metaData.globally_shared_part(); typedef boost::indirect_iterator<std::vector<stk::mesh::Entity *>::const_iterator> EntityIterator; EntityIterator allKeepersEnd(sampleClosure.end()); const EntityIterator allKeepersBegin(sampleClosure.begin()); for (stk::mesh::EntityRank candidateRankCount = metaData.entity_rank_count(); candidateRankCount > 0; --candidateRankCount) { const stk::mesh::EntityRank candidateRank = candidateRankCount - 1; const EntityIterator keepersBegin = std::lower_bound(allKeepersBegin, allKeepersEnd, stk::mesh::EntityKey(candidateRank, 0), stk::mesh::EntityLess()); const EntityIterator keepersEnd = allKeepersEnd; std::vector<stk::mesh::Entity *> candidates; stk::mesh::get_selected_entities(ownedOrShared, bulkData.buckets(candidateRank), candidates); { BulkModification modification(bulkData); std::set_difference(candidates.begin(), candidates.end(), keepersBegin.base(), keepersEnd.base(), EntityDestructor(modification), stk::mesh::EntityLess()); } allKeepersEnd = keepersBegin; } } }
void initializePrec( const PreconditionerFactoryBase<Scalar> &precFactory, const Teuchos::RCP<const LinearOpBase<Scalar> > &fwdOp, const Teuchos::Ptr<PreconditionerBase<Scalar> > &prec, const ESupportSolveUse supportSolveUse = SUPPORT_SOLVE_UNSPECIFIED ) { precFactory.initializePrec(defaultLinearOpSource(fwdOp), prec.get(), supportSolveUse); }
void ObserverImpl::observeSolution ( double stamp, const Epetra_Vector& nonOverlappedSolution, const Teuchos::Ptr<const Epetra_Vector>& nonOverlappedSolutionDot) { // If solution == "Steady" or "Continuation", we need to update the solution // from the initial guess prior to writing it out, or we will not get the // proper state of things like "Stress" in the Exodus file. { // Evaluate state field manager if(nonOverlappedSolutionDot != Teuchos::null) app_->evaluateStateFieldManager(stamp, nonOverlappedSolutionDot.get(), NULL, nonOverlappedSolution); else app_->evaluateStateFieldManager(stamp, NULL, NULL, nonOverlappedSolution); // Renames the New state as the Old state in preparation for the next step app_->getStateMgr().updateStates(); #ifdef ALBANY_PERIDIGM #if defined(ALBANY_EPETRA) const Teuchos::RCP<LCM::PeridigmManager>& peridigmManager = LCM::PeridigmManager::self(); if (Teuchos::nonnull(peridigmManager)) { peridigmManager->writePeridigmSubModel(stamp); peridigmManager->updateState(); } #endif #endif } //! update distributed parameters in the mesh Teuchos::RCP<DistParamLib> distParamLib = app_->getDistParamLib(); distParamLib->scatter(); DistParamLib::const_iterator it; Teuchos::RCP<const Epetra_Comm> comm = app_->getEpetraComm(); for(it = distParamLib->begin(); it != distParamLib->end(); ++it) { app_->getDiscretization()->setFieldT(*it->second->overlapped_vector(), it->second->name(), /*overlapped*/ true); } StatelessObserverImpl::observeSolution(stamp, nonOverlappedSolution, nonOverlappedSolutionDot); }
void Piro::MatrixFreeLinearOp<Scalar>::applyImpl( const Thyra::EOpTransp M_trans, const Thyra::MultiVectorBase<Scalar> &X, const Teuchos::Ptr<Thyra::MultiVectorBase<Scalar> > &Y, const Scalar alpha, const Scalar beta) const { using Teuchos::RCP; using Teuchos::Ptr; TEUCHOS_TEST_FOR_EXCEPTION( !this->opSupported(M_trans), Thyra::Exceptions::OpNotSupported, this->description() << " does not support operation " << Thyra::toString(M_trans)); TEUCHOS_TEST_FOR_EXCEPTION( !X.range()->isCompatible(*this->domain()), Thyra::Exceptions::IncompatibleVectorSpaces, "Domain of " << this->description() << ": " << this->domain()->description() << " is not compatible with column space of " << X.description() << ": " << X.range()->description()); TEUCHOS_TEST_FOR_EXCEPTION( !Y->range()->isCompatible(*this->range()), Thyra::Exceptions::IncompatibleVectorSpaces, "Range of " << this->description() << ": " << this->range()->description() << " is not compatible with column space of " << Y->description() << ": " << Y->range()->description()); TEUCHOS_TEST_FOR_EXCEPTION( !Y->domain()->isCompatible(*X.domain()), Thyra::Exceptions::IncompatibleVectorSpaces, "Row space of " << Y->description() << ": " << Y->domain()->description() << " is not compatible with row space of " << X.description() << ": " << X.domain()->description()); TEUCHOS_TEST_FOR_EXCEPTION( &X == Y.get(), std::logic_error, "X and Y arguments are both aliases of " << X.description()); if (alpha == Teuchos::ScalarTraits<Scalar>::zero()) { // Y <- beta * Y Thyra::Vt_S(Y, beta); return; } typedef typename Teuchos::ScalarTraits<Scalar>::magnitudeType ScalarMagnitude; RCP<const Thyra::VectorBase<Scalar> > x_dot_base; if (basePoint_.supports(Thyra::ModelEvaluatorBase::IN_ARG_x_dot)) x_dot_base = basePoint_.get_x_dot(); RCP<const Thyra::VectorBase<Scalar> > x_base = basePoint_.get_x(); if (Teuchos::is_null(x_base)) { x_base = model_->getNominalValues().get_x(); } x_base.assert_not_null(); const ScalarMagnitude norm_x_base = Thyra::norm_2(*x_base); // Number of columns common to both vectors X and Y // (X and Y have compatible row spaces) const Thyra::Ordinal colCount = X.domain()->dim(); for (Teuchos::Ordinal j = Teuchos::Ordinal(); j < colCount; ++j) { const RCP<const Thyra::VectorBase<Scalar> > X_vec = X.col(j); const RCP<Thyra::VectorBase<Scalar> > Y_vec = Y->col(j); const ScalarMagnitude norm_dx = Thyra::norm_2(*X_vec); if (norm_dx == Teuchos::ScalarTraits<ScalarMagnitude>::zero()) { if (beta == Teuchos::ScalarTraits<Scalar>::zero()) { // Y_vec <- 0 Thyra::put_scalar(Teuchos::ScalarTraits<ScalarMagnitude>::zero(), Y_vec.ptr()); } else { // Y_vec <- beta * Y_vec Thyra::scale(beta, Y_vec.ptr()); } } else { // Scalar perturbation const ScalarMagnitude relative_pert_ratio = static_cast<ScalarMagnitude>(lambda_); const ScalarMagnitude eta = (relative_pert_ratio * ((norm_x_base / norm_dx) + relative_pert_ratio)); // Compute perturbed residual // Dynamic: f_pert <- f(x_dot_base + eta * (W_alpha * X), x_base + eta * (W_beta * X)) // Static: f_pert <- f(x_base + eta * X) const RCP<Thyra::VectorBase<Scalar> > f_pert = Thyra::createMember(this->range()); { Thyra::ModelEvaluatorBase::InArgs<Scalar> pertInArgs = model_->createInArgs(); { pertInArgs.setArgs(basePoint_); const bool isDynamic = Teuchos::nonnull(x_dot_base); if (isDynamic) { const RCP<Thyra::VectorBase<Scalar> > x_dot_pert = Thyra::createMember(this->domain()); const Scalar W_alpha = pertInArgs.get_alpha(); Thyra::V_VpStV<Scalar>(x_dot_pert.ptr(), *x_dot_base, W_alpha * eta, *X_vec); pertInArgs.set_x_dot(x_dot_pert); } const RCP<Thyra::VectorBase<Scalar> > x_pert = Thyra::createMember(this->domain()); const Scalar W_beta = isDynamic ? pertInArgs.get_beta() : Teuchos::ScalarTraits<Scalar>::one(); Thyra::V_VpStV<Scalar>(x_pert.ptr(), *x_base, W_beta * eta, *X_vec); pertInArgs.set_x(x_pert); } Thyra::ModelEvaluatorBase::OutArgs<Scalar> pertOutArgs = model_->createOutArgs(); { pertOutArgs.set_f(f_pert); } model_->evalModel(pertInArgs, pertOutArgs); } // Y <- alpha * (1/eta) * (f_pert - f_base) + beta * Y const Scalar alpha_over_eta = alpha / eta; if (beta == Teuchos::ScalarTraits<Scalar>::zero()) { // Y <- alpha * (1/eta) * (f_pert - f_base) Thyra::V_StVpStV<Scalar>(Y_vec.ptr(), alpha_over_eta, *f_pert, -alpha_over_eta, *f_base_); } else { // Aliasing f_pert and alpha_op_X (f_pert == alpha_op_X) const RCP<Thyra::VectorBase<Scalar> > alpha_op_X = f_pert; // alpha_op_X <- alpha * (1/eta) * (f_pert - f_base) Thyra::Vp_StV(alpha_op_X.ptr(), -Teuchos::ScalarTraits<Scalar>::one(), *f_base_); const Scalar alpha_over_eta = alpha / eta; Thyra::Vt_S(alpha_op_X.ptr(), alpha_over_eta); // Y <- alpha_op_X + beta * Y Thyra::Vp_V<Scalar>(Y_vec.ptr(), *alpha_op_X, beta); } } } }