void assembleIRKState( const int stageIndex, const Teuchos::SerialDenseMatrix<int,Scalar> &A_in, const Scalar dt, const Thyra::VectorBase<Scalar> &x_base, const Thyra::ProductVectorBase<Scalar> &x_stage_bar, Teuchos::Ptr<Thyra::VectorBase<Scalar> > x_out_ptr ) { typedef ScalarTraits<Scalar> ST; const int numStages_in = A_in.numRows(); TEUCHOS_ASSERT_IN_RANGE_UPPER_EXCLUSIVE( stageIndex, 0, numStages_in ); TEUCHOS_ASSERT_EQUALITY( A_in.numRows(), numStages_in ); TEUCHOS_ASSERT_EQUALITY( A_in.numCols(), numStages_in ); TEUCHOS_ASSERT_EQUALITY( x_stage_bar.productSpace()->numBlocks(), numStages_in ); Thyra::VectorBase<Scalar>& x_out = *x_out_ptr; V_V( outArg(x_out), x_base ); for ( int j = 0; j < numStages_in; ++j ) { Vp_StV( outArg(x_out), dt * A_in(stageIndex,j), *x_stage_bar.getVectorBlock(j) ); } }
// ============================================================================ void BorderingHelpers:: dissect(const Tpetra::MultiVector<double,int,int> & x, Tpetra::MultiVector<double,int,int> & xSmall, double * lambda ) { #ifndef NDEBUG TEUCHOS_ASSERT_EQUALITY(x.NumVectors(), xSmall.NumVectors()); // Make sure the maps are matching. std::shared_ptr<const Tpetra::Map<int,int>> extendedMap = nosh::BorderingHelpers::extendMapBy1(xSmall.getMap()); TEUCHOS_ASSERT(x.getMap().SameAs(*extendedMap)); #endif Epetra_Import importer(xSmall.getMap(), x.getMap()); // Strip off the phase constraint variable. xSmall.Import(x, importer, Insert); // TODO Check if we need lambda on all procs. if (x.getMap().Comm().MyPID() == 0) { const int n = x.MyLength(); for (int k = 0; k < x.NumVectors(); k++) lambda[k] = (*(x(k)))[n - 1]; } return; }
// ============================================================================ void BorderingHelpers:: merge(const Tpetra::MultiVector<double,int,int> & x, const double * lambda, Tpetra::MultiVector<double,int,int> & out ) { #ifndef NDEBUG // Check if the maps are matching. std::shared_ptr<const Tpetra::Map<int,int>> extendedMap = nosh::BorderingHelpers::extendMapBy1(x.getMap()); TEUCHOS_ASSERT(out.getMap().SameAs(*extendedMap)); #endif Epetra_Import importer(out.getMap(), x.getMap()); TEUCHOS_ASSERT_EQUALITY(0, out.Import(x, importer, Insert)); // Set last entry on proc 0. if (x.getMap().Comm().MyPID() == 0) { const int numMyElems = x.getMap().NumMyElements(); for (int k = 0; k < x.NumVectors(); k++) (*out(k))[numMyElems] = lambda[k]; } return; }
TestLagrPolyMeritFunc1D<Scalar>::TestLagrPolyMeritFunc1D( const ArrayView<const Scalar> &alpha, const ArrayView<const Scalar> &phi ) : alpha_(alpha), phi_(phi) { TEUCHOS_ASSERT_EQUALITY(alpha.size(), phi.size()); }
void TableFormat::writeWholeTable( std::ostream& out, const std::string& header, const Array<std::string>& columnNames, const Array<TableColumn>& columns ) const { /* compute the total width */ int pgWidth = 0; for (Array<TableColumn>::size_type i=0; i<columnNames.size(); i++) { int cw = defaultColumnWidth(); if (columnWidths_.size() != 0) cw = columnWidths_[i]; pgWidth += cw; } setPageWidth(std::max(pageWidth_, pgWidth)); /* write the header */ out << thickline() << std::endl; out << std::endl; int numBlanks = (pageWidth_ - header.length())/2; out << blanks(numBlanks) << header << std::endl; out << std::endl; /* write the column titles */ for (Array<std::string>::size_type i=0; i<columnNames.size(); i++) { int cw = defaultColumnWidth(); if (columnWidths_.size() != 0) cw = columnWidths_[i]; out << std::left << std::setw(cw) << columnNames[i]; } out << std::endl; /* ensure that all columns have the same number of rows */ int numRows = columns[0].numRows(); for (Array<TableColumn>::size_type i=1; i<columns.size(); i++) { TEUCHOS_ASSERT_EQUALITY(columns[i].numRows(), numRows); } /* write the table data */ for (int i=0; i<numRows; i++) { if (i % lineInterval_ == 0) out << std::left << thinline() << std::endl; writeRow(out, i, columns); } /* write the footer */ out << thickline() << std::endl; }
void GlobalMPISession::allGather(int localVal, const ArrayView<int> &allVals) { justInTimeInitialize(); TEUCHOS_ASSERT_EQUALITY(allVals.size(), getNProc()); #ifdef HAVE_MPI MPI_Allgather( &localVal, 1, MPI_INT, allVals.getRawPtr(), 1, MPI_INT, MPI_COMM_WORLD); #else allVals[0] = localVal; #endif }
/*! \brief Evaluate the function and derivatives at a given local coordinate \param xi (in) : Local coordinate where to evaluate the function \param val (out) : Function values at xi \param valdim (in) : Dimension of val \param deriv (out) : Derivative of functions at xi */ void EvaluateFunction( const double* xi, double* val, const int valdim, double* deriv) { TEUCHOS_ASSERT_EQUALITY(valdim, traits_type::valdim); TEUCHOS_ASSERT(!xi); traits_type::EvaluateFunction(xi, val, valdim, deriv); }
void assembleIRKSolution( const Teuchos::SerialDenseVector<int,Scalar> &b_in, const Scalar dt, const Thyra::VectorBase<Scalar> &x_base, const Thyra::ProductVectorBase<Scalar> &x_stage_bar, Teuchos::Ptr<Thyra::VectorBase<Scalar> > x_out_ptr ) { typedef ScalarTraits<Scalar> ST; const int numStages_in = b_in.length(); TEUCHOS_ASSERT_EQUALITY( b_in.length(), numStages_in ); TEUCHOS_ASSERT_EQUALITY( x_stage_bar.productSpace()->numBlocks(), numStages_in ); Thyra::VectorBase<Scalar>& x_out = *x_out_ptr; V_V( outArg(x_out), x_base ); for ( int j = 0; j < numStages_in; ++j ) { Vp_StV( outArg(x_out), dt * b_in(j), *x_stage_bar.getVectorBlock(j) ); } }
// ============================================================================= Teuchos::RCP<Epetra_Vector> VIO::EpetraMesh::Reader:: extractStateData_ ( const vtkSmartPointer<vtkDataSet> & vtkData, const Teuchos::RCP<const Epetra_Comm> & comm ) const { vtkIdType numArrays = vtkData->GetPointData()->GetNumberOfArrays(); TEUCHOS_ASSERT_EQUALITY ( numArrays, 1 ); const vtkSmartPointer<vtkDataArray> & array = vtkData->GetPointData()->GetArray(0); vtkIdType numComponents = array->GetNumberOfComponents(); TEUCHOS_ASSERT_EQUALITY ( numComponents, 2 ); // for *complex* values // this is the total number of grid points vtkIdType numPoints = array->GetNumberOfTuples(); // Create maps. // TODO They are created at another spot already. Avoid the work. Teuchos::RCP<Epetra_Map> nodesMap = Teuchos::rcp( new Epetra_Map( numPoints, 0, *comm ) ); Teuchos::RCP<Epetra_Map> complexValuesMap = createComplexValuesMap_ ( *nodesMap ); Teuchos::RCP<Epetra_Vector> z = Teuchos::rcp ( new Epetra_Vector ( *complexValuesMap ) ); // fill z double val[2]; for ( int k = 0; k < nodesMap->NumMyElements(); k++ ) { array->GetTuple( nodesMap->GID(k), val ); z->ReplaceMyValue( 2*k , 0, val[0] ); z->ReplaceMyValue( 2*k+1, 0, val[1] ); } return z; }
// ============================================================================= void VIO::EpetraMesh::Writer:: setValues( const Epetra_MultiVector & x, const Teuchos::Array<std::string> & scalarsNames ) { unsigned int numVecs = x.NumVectors(); unsigned int numVariables = x.GlobalLength(); unsigned int numNodes = mesh_->getNodesMap()->NumGlobalElements(); // make sure the sizes match the mesh if ( !mesh_.is_null() ) TEUCHOS_ASSERT_EQUALITY( numVariables, 2*numNodes ); // cast into a vtkUnstructuredGrid vtkSmartPointer<vtkUnstructuredGrid> vtkMesh = dynamic_cast<vtkUnstructuredGrid*> ( vtkDataSet_.GetPointer() ); TEUCHOS_ASSERT_INEQUALITY( 0, !=, vtkMesh ); // get scalarsNames, and insert default names if empty Teuchos::Array<std::string> scNames ( scalarsNames ); if ( scNames.empty() ) { scNames.resize ( numVecs ); for ( int vec=0; vec<numVecs; vec++ ) scNames[vec] = "x" + EpetraExt::toString ( vec ); } // fill the scalar field vtkSmartPointer<vtkDoubleArray> scalars = vtkSmartPointer<vtkDoubleArray>::New(); // real and imaginary part scalars->SetNumberOfComponents ( 2 ); for ( int vec=0; vec<numVecs; vec++ ) { scalars->SetName ( scNames[vec].c_str() ); for ( int k=0; k<numNodes; k++ ) { // const unsigned int dof_id = libmeshMesh_->node(k).dof_number(0,k,0); scalars->InsertNextValue ( x[vec][2*k] ); scalars->InsertNextValue ( x[vec][2*k+1] ); } vtkMesh->GetPointData()->AddArray ( scalars ); } return; }
// ============================================================================= Eigen::VectorXd mesh_tri:: edge_coefficients_numerically_( const std::vector<Eigen::Vector3d> & edges ) const { size_t num_edges = edges.size(); TEUCHOS_ASSERT_EQUALITY(num_edges, 3); // Build an equation system for the edge coefficients alpha_k. // They fulfill // // |simplex| * <u,v> = \sum_{edges e_i} alpha_i <u,e_i> <e_i,v> // // for any pair of vectors u, v in the plane of the triangle. // const double vol = 0.5 * (edges[0].cross(edges[1])).norm(); Eigen::Matrix3d A; Eigen::Vector3d rhs; // Build the equation system: // The equation // // |simplex| ||u||^2 = \sum_i \alpha_i <u,e_i> <e_i,u> // // has to hold for all vectors u in the plane spanned by the edges, // particularly by the edges themselves. // for (size_t i = 0; i < num_edges; i++) { double alpha = edges[i].dot(edges[i]); rhs(i) = vol * alpha; A(i, i) = alpha * alpha; for (size_t j = i+1; j < num_edges; j++) { A(i, j) = edges[i].dot(edges[j]) * edges[j].dot(edges[i]); A(j, i) = A(i, j); } } // Solve the equation system for the alpha_i. The system is symmetric and, // if the simplex is not degenerate, positive definite. //return A.ldlt().solve(rhs); const auto x = A.fullPivLu().solve(rhs); //auto x = A.colPivHouseholderQr().solve(rhs); return x; }
// ============================================================================= // Compute result_p = alpha * dg/dx * input_x. NOX::Abstract::Group::ReturnType Ginla::FDM::Constraint::MinDist:: multiplyDX ( double alpha, const NOX::Abstract::MultiVector & input_x, NOX::Abstract::MultiVector::DenseMatrix & result_p ) const { TEUCHOS_ASSERT( komplex_.is_valid_ptr() && !komplex_.is_null() ); TEUCHOS_ASSERT_EQUALITY( result_p.numCols(), input_x.numVectors() ); for ( int k=0; k<input_x.numVectors(); k++ ) { const Epetra_Vector & xE = Teuchos::dyn_cast<const NOX::Epetra::Vector>( input_x[0] ).getEpetraVector(); Teuchos::RCP<ComplexVector> xPsi = komplex_->real2complex( xE ); result_p(0,k) = alpha * std::imag( psiRef_->dot(*xPsi) ); } return NOX::Abstract::Group::Ok; }
template<class T> inline void ArrayRCP<T>::resize(const size_type n, const T &val) { #ifdef TEUCHOS_DEBUG TEUCHOS_ASSERT_EQUALITY(lowerOffset(), 0); #endif if (n == 0) { clear(); return; } const size_type orig_n = size(); if (n != orig_n) { ArrayRCP<T> tmp = *this; *this = arcp<T>(n); const size_type small_n = std::min(n, orig_n); for (size_type i = 0; i < small_n; ++i) (*this)[i] = tmp[i]; for (size_type i = orig_n; i < n; ++i) (*this)[i] = val; upperOffset_ = n-1; } }
// ============================================================================ void Bordered:: eval_mdel(const InArgs &in_args, const OutArgs &out_args ) const { // First, dissect x_in into vector and bordering. const Teuchos::RCP<const Tpetra::Vector<double,int,int>> &x_in = in_args.get_x(); #ifndef NDEBUG TEUCHOS_ASSERT(!x_in.is_null()); #endif const Teuchos::RCP<Tpetra::Vector<double,int,int>> inner_x_in = Teuchos::rcp(new Tpetra::Vector<double,int,int>(*innerModelEval_->get_x_map())); double lambda[1]; nosh::BorderingHelpers::dissect(*x_in, *inner_x_in, lambda); // Get i*x. This assumes a particular data layout in x_in. Tpetra::Vector<double,int,int> ix(inner_x_in->Map()); for (int k = 0; k < ix.getMap().NumMyElements()/2; k++) { ix[2*k] = - (*x_in)[2*k+1]; ix[2*k+1] = (*x_in)[2*k]; } // Copy over the args for use in innerModelEval. InArgs inner_in_args = in_args; inner_in_args.set_x(inner_x_in); OutArgs inner_out_args = out_args; const Tpetra::Vector<double,int,int> & bordering = ix; // Compute F(x). const Teuchos::RCP<Tpetra::Vector<double,int,int>> &f_out = out_args.get_f(); if (!f_out.is_null()) { // Create new temporary f_out. const Teuchos::RCP<Tpetra::Vector<double,int,int>> inner_f_out = Teuchos::rcp(new Tpetra::Vector<double,int,int>(*innerModelEval_->get_f_map())); inner_out_args.set_f(inner_f_out); innerModelEval_->eval_mdel(inner_in_args, inner_out_args); // Add lambda * x0. TEUCHOS_ASSERT_EQUALITY(0, inner_f_out->Update(lambda[0], bordering, 1.0)); // Append <psi0, x> to f_out. double r[1]; TEUCHOS_ASSERT_EQUALITY(0, bordering.Dot(*inner_x_in, r)); //r = lambda; nosh::BorderingHelpers::merge(*inner_f_out, r, *f_out); } // Compute df/dp. const EpetraExt::ModelEvaluator::DerivativeMultiVector &derivMv = out_args.get_DfDp(0).getDerivativeMultiVector(); const Teuchos::RCP<Tpetra::MultiVector<double,int,int>> &dfdp_out = derivMv.multi_vector(); if (!dfdp_out.is_null()) { // Create temporary DerivativeMultiVector inner_dfdp_out. const int numParams = derivMv.get_paramIndexes().length(); const Teuchos::RCP<Tpetra::MultiVector<double,int,int>> inner_dfdp_out = Teuchos::rcp(new Tpetra::MultiVector<double,int,int>(*innerModelEval_->get_f_map(), numParams)); const EpetraExt::ModelEvaluator::DerivativeMultiVector innerDerivMv(inner_dfdp_out, derivMv.getOrientation(), derivMv.get_paramIndexes()); inner_out_args.set_DfDp(0, innerDerivMv); innerModelEval_->eval_mdel(inner_in_args, inner_out_args); // Append last entry and merge into dfdp_out. std::vector<double> r(numParams); for (int k = 0; k < numParams; k++) r[k] = 0.0; nosh::BorderingHelpers::merge(*inner_dfdp_out, &r[0], *dfdp_out); } // Fill Jacobian. const Teuchos::RCP<Tpetra::Operator<double,int,int>> & W_out = out_args.get_W(); if(!W_out.is_null()) { const Teuchos::RCP<nosh::BorderedOperator> & borderedW = Teuchos::rcp_dynamic_cast<nosh::BorderedOperator>(W_out, true); // Fill inner Jacobian. inner_out_args.set_W(Teuchos::rcp(borderedW->getInnerOperator())); innerModelEval_->eval_mdel(inner_in_args, inner_out_args); // Reset bordering. borderedW->resetBordering(bordering, bordering, 0.0); } // Fill preconditioner. const Teuchos::RCP<Tpetra::Operator<double,int,int>> & WPrec_out = out_args.get_WPrec(); if(!WPrec_out.is_null()) { const Teuchos::RCP<nosh::BorderedOperator> & borderedPrec = Teuchos::rcp_dynamic_cast<nosh::BorderedOperator>(WPrec_out, true); // Fill inner preconditioner. inner_out_args.set_WPrec(Teuchos::rcp(borderedPrec->getInnerOperator())); innerModelEval_->eval_mdel(inner_in_args, inner_out_args); // Reset bordering. borderedPrec->resetBordering(bordering, bordering, 0.0); } return; }
void panzer::ScatterResidual_Epetra<panzer::Traits::Hessian, TRAITS,LO,GO>:: evaluateFields(typename TRAITS::EvalData workset) { std::vector<int> cLIDs, rLIDs; std::vector<double> jacRow; bool useColumnIndexer = colGlobalIndexer_!=Teuchos::null; // for convenience pull out some objects from workset std::string blockId = this->wda(workset).block_id; const std::vector<std::size_t> & localCellIds = this->wda(workset).cell_local_ids; Teuchos::RCP<Epetra_Vector> r = epetraContainer_->get_f(); Teuchos::RCP<Epetra_CrsMatrix> Jac = epetraContainer_->get_A(); const Teuchos::RCP<const panzer::UniqueGlobalIndexer<LO,GO> >& colGlobalIndexer = useColumnIndexer ? colGlobalIndexer_ : globalIndexer_; // NOTE: A reordering of these loops will likely improve performance // The "getGIDFieldOffsets" may be expensive. However the // "getElementGIDs" can be cheaper. However the lookup for LIDs // may be more expensive! // scatter operation for each cell in workset for(std::size_t worksetCellIndex=0;worksetCellIndex<localCellIds.size();++worksetCellIndex) { std::size_t cellLocalId = localCellIds[worksetCellIndex]; rLIDs = globalIndexer_->getElementLIDs(cellLocalId); cLIDs = colGlobalIndexer->getElementLIDs(cellLocalId); if (Teuchos::nonnull(workset.other)) { const std::size_t other_cellLocalId = workset.other->cell_local_ids[worksetCellIndex]; const std::vector<int> other_cLIDs = colGlobalIndexer->getElementLIDs(other_cellLocalId); cLIDs.insert(cLIDs.end(), other_cLIDs.begin(), other_cLIDs.end()); } // loop over each field to be scattered for(std::size_t fieldIndex = 0; fieldIndex < scatterFields_.size(); fieldIndex++) { int fieldNum = fieldIds_[fieldIndex]; const std::vector<int> & elmtOffset = globalIndexer_->getGIDFieldOffsets(blockId,fieldNum); // loop over the basis functions (currently they are nodes) for(std::size_t rowBasisNum = 0; rowBasisNum < elmtOffset.size(); rowBasisNum++) { const ScalarT scatterField = (scatterFields_[fieldIndex])(worksetCellIndex,rowBasisNum); int rowOffset = elmtOffset[rowBasisNum]; int row = rLIDs[rowOffset]; // loop over the sensitivity indices: all DOFs on a cell jacRow.resize(scatterField.size()); for(int sensIndex=0;sensIndex<scatterField.size();++sensIndex) jacRow[sensIndex] = scatterField.fastAccessDx(sensIndex).fastAccessDx(0); { int err = Jac->SumIntoMyValues( row, std::min(cLIDs.size(), static_cast<size_t>(scatterField.size())), panzer::ptrFromStlVector(jacRow), panzer::ptrFromStlVector(cLIDs)); TEUCHOS_ASSERT_EQUALITY(err,0); } } // end rowBasisNum } // end fieldIndex } }
int main(int argc, char* argv[]) { std::cout << Teuchos::Teuchos_Version() << std::endl << std::endl; // Creating a double-precision matrix can be done in several ways: // Create an empty matrix with no dimension Teuchos::SerialSymDenseMatrix<int,double> Empty_Matrix; // Create an empty 4x4 matrix Teuchos::SerialSymDenseMatrix<int,double> My_Matrix( 4 ); // Basic copy of My_Matrix Teuchos::SerialSymDenseMatrix<int,double> My_Copy1( My_Matrix ), // (Deep) Copy of principle 3x3 submatrix of My_Matrix My_Copy2( Teuchos::Copy, My_Matrix, 3 ), // (Shallow) Copy of 3x3 submatrix of My_Matrix My_Copy3( Teuchos::View, My_Matrix, 3, 1 ); // The matrix dimensions and strided storage information can be obtained: int rows, cols, stride; rows = My_Copy3.numRows(); // number of rows cols = My_Copy3.numCols(); // number of columns stride = My_Copy3.stride(); // storage stride TEUCHOS_ASSERT_EQUALITY(rows, 3); TEUCHOS_ASSERT_EQUALITY(cols, 3); TEUCHOS_ASSERT_EQUALITY(stride, 4); // Matrices can change dimension: Empty_Matrix.shape( 3 ); // size non-dimensional matrices My_Matrix.reshape( 3 ); // resize matrices and save values // Filling matrices with numbers can be done in several ways: My_Matrix.random(); // random numbers My_Copy1.putScalar( 1.0 ); // every entry is 1.0 My_Copy1 = 1.0; // every entry is 1.0 (still) My_Copy2(1,1) = 10.0; // individual element access Empty_Matrix = My_Matrix; // copy My_Matrix to Empty_Matrix // Basic matrix arithmetic can be performed: Teuchos::SerialDenseMatrix<int,double> My_Prod( 4, 3 ), My_GenMatrix( 4, 3 ); My_GenMatrix = 1.0; // Matrix multiplication ( My_Prod = 1.0*My_GenMatrix*My_Matrix ) My_Prod.multiply( Teuchos::RIGHT_SIDE, 1.0, My_Matrix, My_GenMatrix, 0.0 ); My_Copy2 += My_Matrix; // Matrix addition My_Copy2 *= 0.5; // Matrix scaling // Matrices can be compared: // Check if the matrices are equal in dimension and values if (Empty_Matrix == My_Matrix) { std::cout<< "The matrices are the same!" <<std::endl; } // Check if the matrices are different in dimension or values if (My_Copy2 != My_Matrix) { std::cout<< "The matrices are different!" <<std::endl; } // The norm of a matrix can be computed: double norm_one, norm_inf, norm_fro; norm_one = My_Matrix.normOne(); // one norm norm_inf = My_Matrix.normInf(); // infinity norm norm_fro = My_Matrix.normFrobenius(); // frobenius norm std::cout << std::endl << "|| My_Matrix ||_1 = " << norm_one << std::endl; std::cout << "|| My_Matrix ||_Inf = " << norm_inf << std::endl; std::cout << "|| My_Matrix ||_F = " << norm_fro << std::endl << std::endl; // A matrix can be factored and solved using Teuchos::SerialDenseSolver. Teuchos::SerialSpdDenseSolver<int,double> My_Solver; Teuchos::SerialSymDenseMatrix<int,double> My_Matrix2( 3 ); My_Matrix2.random(); Teuchos::SerialDenseMatrix<int,double> X(3,1), B(3,1); X = 1.0; B.multiply( Teuchos::LEFT_SIDE, 1.0, My_Matrix2, X, 0.0 ); X = 0.0; // Make sure the computed answer is correct. int info = 0; My_Solver.setMatrix( Teuchos::rcp( &My_Matrix2, false ) ); My_Solver.setVectors( Teuchos::rcp( &X, false ), Teuchos::rcp( &B, false ) ); info = My_Solver.factor(); if (info != 0) std::cout << "Teuchos::SerialSpdDenseSolver::factor() returned : " << info << std::endl; info = My_Solver.solve(); if (info != 0) std::cout << "Teuchos::SerialSpdDenseSolver::solve() returned : " << info << std::endl; // A matrix triple-product can be computed: C = alpha*W'*A*W double alpha=0.5; Teuchos::SerialDenseMatrix<int,double> W(3,2); Teuchos::SerialSymDenseMatrix<int,double> A1(2), A2(3); A1(0,0) = 1.0, A1(1,1) = 2.0; A2(0,0) = 1.0, A2(1,1) = 2.0, A2(2,2) = 3.00; W = 1.0; Teuchos::SerialSymDenseMatrix<int,double> C1(3), C2(2); Teuchos::symMatTripleProduct<int,double>( Teuchos::NO_TRANS, alpha, A1, W, C1); Teuchos::symMatTripleProduct<int,double>( Teuchos::TRANS, alpha, A2, W, C2 ); // A matrix can be sent to the output stream: std::cout<< My_Matrix << std::endl; std::cout<< X << std::endl; return 0; }
virtual void evalModelImpl( const Thyra::ModelEvaluatorBase::InArgs<double> &in_args, const Thyra::ModelEvaluatorBase::OutArgs<double> &out_args ) const { const double alpha = in_args.get_alpha(); double beta = in_args.get_beta(); // From packages/piro/test/MockModelEval_A.cpp if (alpha == 0.0 && beta == 0.0) { // beta = 1.0; } #ifndef NDEBUG TEUCHOS_ASSERT_EQUALITY(alpha, 0.0); TEUCHOS_ASSERT_EQUALITY(beta, 1.0); #endif const auto & x_in = in_args.get_x(); #ifndef NDEBUG TEUCHOS_ASSERT(!x_in.is_null()); #endif // create corresponding tpetra vector auto x_in_tpetra = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getConstTpetraVector( x_in ); // Dissect in_args.get_p(0) into parameter sublists. const auto & p_in = in_args.get_p(0); #ifndef NDEBUG TEUCHOS_ASSERT(!p_in.is_null()); #endif #ifndef NDEBUG // Make sure the parameters aren't NaNs. for (int k = 0; k < p_in->space()->dim(); k++) { TEUCHOS_ASSERT(!std::isnan(Thyra::get_ele(*p_in, k))); } #endif // Fill the parameters into a std::map. const auto param_names = this->get_p_names(0); std::map<std::string, double> params; for (int k = 0; k < p_in->space()->dim(); k++) { params[(*param_names)[k]] = Thyra::get_ele(*p_in, k); } // compute F const auto & f_out = out_args.get_f(); if (!f_out.is_null()) { auto f_out_tpetra = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getTpetraVector( f_out ); this->f_->set_parameters(params, {}); this->f_->apply( *x_in_tpetra, *f_out_tpetra ); } // Compute df/dp. const auto & derivMv = out_args.get_DfDp(0).getDerivativeMultiVector(); const auto & dfdp_out = derivMv.getMultiVector(); if (!dfdp_out.is_null()) { auto dfdp_out_tpetra = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getTpetraMultiVector( dfdp_out ); const int numAllParams = this->get_p_space(0)->dim(); TEUCHOS_ASSERT_EQUALITY( numAllParams, dfdp_out_tpetra->getNumVectors() ); // Compute all derivatives. this->dfdp_->set_parameters(params, {}); for (int k = 0; k < numAllParams; k++) { this->dfdp_->apply( *x_in_tpetra, *dfdp_out_tpetra->getVectorNonConst(k) ); } } // Fill Jacobian. const auto & W_out = out_args.get_W_op(); if(!W_out.is_null()) { auto W_outT = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getTpetraOperator( W_out ); const auto & jac = Teuchos::rcp_dynamic_cast<nosh::fvm_operator>(W_outT, true); std::shared_ptr<const Tpetra::Vector<double,int,int>> x_std = Teuchos::get_shared_ptr(x_in_tpetra); jac->set_parameters(params, {{"u0", x_std}}); } // // Fill preconditioner. // const auto & WPrec_out = out_args.get_W_prec(); // if(!WPrec_out.is_null()) { // auto WPrec_outT = // Thyra::TpetraOperatorVectorExtraction<double,int,int>::getTpetraOperator( // WPrec_out->getNonconstUnspecifiedPrecOp() // ); // const auto & keoPrec = // Teuchos::rcp_dynamic_cast<nosh::keo_regularized>(WPrec_outT, true); // keoPrec->rebuild( // params, // *x_in_tpetra // ); // } return; }
virtual void evalModelImpl( const Thyra::ModelEvaluatorBase::InArgs<double> &in_args, const Thyra::ModelEvaluatorBase::OutArgs<double> &out_args ) const { const auto & x_in = in_args.get_x(); #ifndef NDEBUG TEUCHOS_ASSERT(!x_in.is_null()); #endif // create corresponding tpetra vector auto x_in_tpetra = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getConstTpetraVector( x_in ); // compute F const auto & f_out = out_args.get_f(); if (!f_out.is_null()) { // Dissect in_args.get_p(0) into parameter sublists. const auto & p_in = in_args.get_p(0); #ifndef NDEBUG TEUCHOS_ASSERT(!p_in.is_null()); // Make sure the parameters aren't NaNs. for (int k = 0; k < p_in->space()->dim(); k++) { TEUCHOS_ASSERT(!std::isnan(Thyra::get_ele(*p_in, k))); } #endif // Fill the parameters into a std::map. const auto param_names = this->get_p_names(0); const double alph = Thyra::get_ele(*p_in, 0); auto f_out_tpetra = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getTpetraVector( f_out ); const auto x_data = x_in_tpetra->getData(); auto f_data = f_out_tpetra->getDataNonConst(); for (size_t i = 0; i < f_data.size(); i++) { f_data[i] = x_data[i] * x_data[i] - alph; } } // Compute df/dp. const auto & derivMv = out_args.get_DfDp(0).getDerivativeMultiVector(); const auto & dfdp_out = derivMv.getMultiVector(); if (!dfdp_out.is_null()) { auto dfdp_out_tpetra = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getTpetraMultiVector( dfdp_out ); TEUCHOS_ASSERT_EQUALITY(dfdp_out_tpetra->getNumVectors(), 1); auto out = dfdp_out_tpetra->getVectorNonConst(0); auto out_data = out->getDataNonConst(); for (size_t k = 0; k < out_data.size(); k++) { out_data[k] = -1.0; } } // Fill Jacobian. const auto & W_out = out_args.get_W_op(); if(!W_out.is_null()) { auto W_outT = Thyra::TpetraOperatorVectorExtraction<double,int,int>::getTpetraOperator( W_out ); const auto & jac = Teuchos::rcp_dynamic_cast<jac_sqrt_alpha>(W_outT, true); jac->set_x0(*x_in_tpetra); } return; }
void panzer::ScatterResidual_Epetra<panzer::Traits::Jacobian, Traits,LO,GO>:: evaluateFields(typename Traits::EvalData workset) { std::vector<int> cLIDs, rLIDs; std::vector<double> jacRow; bool useColumnIndexer = colGlobalIndexer_!=Teuchos::null; // for convenience pull out some objects from workset std::string blockId = workset.block_id; const std::vector<std::size_t> & localCellIds = workset.cell_local_ids; Teuchos::RCP<Epetra_Vector> r = epetraContainer_->get_f(); Teuchos::RCP<Epetra_CrsMatrix> Jac = epetraContainer_->get_A(); // NOTE: A reordering of these loops will likely improve performance // The "getGIDFieldOffsets" may be expensive. However the // "getElementGIDs" can be cheaper. However the lookup for LIDs // may be more expensive! // scatter operation for each cell in workset for(std::size_t worksetCellIndex=0;worksetCellIndex<localCellIds.size();++worksetCellIndex) { std::size_t cellLocalId = localCellIds[worksetCellIndex]; rLIDs = globalIndexer_->getElementLIDs(cellLocalId); if(useColumnIndexer) cLIDs = colGlobalIndexer_->getElementLIDs(cellLocalId); else cLIDs = rLIDs; // loop over each field to be scattered for(std::size_t fieldIndex = 0; fieldIndex < scatterFields_.size(); fieldIndex++) { int fieldNum = fieldIds_[fieldIndex]; const std::vector<int> & elmtOffset = globalIndexer_->getGIDFieldOffsets(blockId,fieldNum); // loop over the basis functions (currently they are nodes) for(std::size_t rowBasisNum = 0; rowBasisNum < elmtOffset.size(); rowBasisNum++) { const ScalarT & scatterField = (scatterFields_[fieldIndex])(worksetCellIndex,rowBasisNum); int rowOffset = elmtOffset[rowBasisNum]; int row = rLIDs[rowOffset]; // Sum residual if(r!=Teuchos::null) r->SumIntoMyValue(row,0,scatterField.val()); // Sum Jacobian if(useDiscreteAdjoint_) { // loop over the sensitivity indices: all DOFs on a cell jacRow.resize(scatterField.size()); for(int sensIndex=0;sensIndex<scatterField.size();++sensIndex) jacRow[sensIndex] = scatterField.fastAccessDx(sensIndex); for(std::size_t c=0;c<cLIDs.size();c++) { int err = Jac->SumIntoMyValues(cLIDs[c], 1, &jacRow[c],&row); TEUCHOS_ASSERT_EQUALITY(err,0); } } else { int err = Jac->SumIntoMyValues(row, scatterField.size(), scatterField.dx(), panzer::ptrFromStlVector(cLIDs)); TEUCHOS_ASSERT_EQUALITY(err,0); } } // end rowBasisNum } // end fieldIndex } }
// ============================================================================= void VIO::Image::Writer::Abstract:: setImageData ( const Epetra_MultiVector & x, const Teuchos::Tuple<unsigned int,2> & Nx, const Point & h, const Teuchos::Array<int> & p, const Teuchos::Array<std::string> & scalarsNames ) { int numVecs = x.NumVectors(); int numPoints = ( Nx[0]+1 ) * ( Nx[1]+1 ); // get scalarsNames, and insert default names if empty Teuchos::Array<std::string> scNames ( scalarsNames ); if ( scNames.empty() ) { scNames.resize ( numVecs ); for ( int vec=0; vec<numVecs; vec++ ) scNames[vec] = "x" + EpetraExt::toString ( vec ); } // cast into vtkImageData vtkSmartPointer<vtkImageData> imageData = dynamic_cast<vtkImageData*> ( vtkDataSet_.GetPointer() ); TEUCHOS_ASSERT_INEQUALITY( 0, !=, imageData ); // set other image data imageData->SetDimensions ( Nx[0]+1, Nx[1]+1, 1 ); imageData->SetOrigin ( 0.0, 0.0, 0.0 ); imageData->SetSpacing ( h[0], h[1], 0.0 ); // fill the scalar field vtkSmartPointer<vtkDoubleArray> scalars = vtkSmartPointer<vtkDoubleArray>::New(); bool isScrambled = !p.empty(); if ( isScrambled ) { TEUCHOS_ASSERT_EQUALITY ( numPoints, p.length() ); addFieldData ( p, "p" ); } // fill the scalars vector and add it to imageData_ if ( isScrambled ) { double dummy = 0.0; for ( int vec=0; vec<numVecs; vec++ ) { scalars->SetName ( scNames[vec].c_str() ); for ( int k=0; k<numPoints; k++ ) scalars->InsertNextValue ( p[k]>=0 ? x[vec][p[k]] : dummy ); imageData->GetPointData()->AddArray ( scalars ); } } else for ( int vec=0; vec<numVecs; vec++ ) { scalars->SetName ( scNames[vec].c_str() ); for ( int k=0; k<numPoints; k++ ) scalars->InsertNextValue ( x[vec][k] ); imageData->GetPointData()->AddArray ( scalars ); } return; }
// ============================================================================= void VIO::Image::Writer::Abstract:: setImageData ( const ComplexMultiVector & x, const Teuchos::Tuple<unsigned int,2> & Nx, const Point & h, const Teuchos::Array<int> & p, const Teuchos::Array<std::string> & scalarsNames ) { int numVecs = x.getNumVectors(); int numPoints = ( Nx[0]+1 ) * ( Nx[1]+1 ); // get scalarsNames, and insert default names if empty Teuchos::Array<std::string> scNames ( scalarsNames ); if ( scNames.empty() ) { scNames.resize ( numVecs ); for ( int vec=0; vec<numVecs; vec++ ) scNames[vec] = "z" + EpetraExt::toString ( vec ); } // cast into vtkImageData vtkSmartPointer<vtkImageData> imageData = dynamic_cast<vtkImageData*> ( vtkDataSet_.GetPointer() ); TEUCHOS_ASSERT_INEQUALITY( 0, !=, imageData ); // set other image data imageData->SetDimensions ( Nx[0]+1, Nx[1]+1, 1 ); imageData->SetOrigin ( 0.0, 0.0, 0.0 ); imageData->SetSpacing ( h[0], h[1], 0.0 ); // fill the scalar field vtkSmartPointer<vtkDoubleArray> scalars = vtkSmartPointer<vtkDoubleArray>::New(); double dummy = 0.0; bool isScrambled = !p.empty(); if ( isScrambled ) { TEUCHOS_ASSERT_EQUALITY ( numPoints, p.length() ); addFieldData ( p, "p" ); } // real and imaginary part scalars->SetNumberOfComponents ( 2 ); // fill the scalars vector and add it to imageData_ Teuchos::ArrayRCP<const std::complex<double> > xView; for ( int vec=0; vec<numVecs; vec++ ) { xView = x.getVector ( vec )->get1dView(); scalars->SetName ( scNames[vec].c_str() ); for ( int k=0; k<numPoints; k++ ) { if ( isScrambled ) { // TODO replace by InsertNextTuple scalars->InsertNextValue ( p[k]>=0 ? std::real ( xView[p[k]] ) : dummy ); scalars->InsertNextValue ( p[k]>=0 ? std::imag ( xView[p[k]] ) : dummy ); } else { scalars->InsertNextValue ( std::real ( xView[k] ) ); scalars->InsertNextValue ( std::imag ( xView[k] ) ); } } imageData->GetPointData()->AddArray ( scalars ); } return; }