Epetra_CrsMatrix * NOX::Epetra::DebugTools::compute_matrix_using_operator( const Epetra_Operator * op) { const Epetra_Map & rowMap = op->OperatorDomainMap(); Epetra_CrsMatrix * p_mat = new Epetra_CrsMatrix(Copy, rowMap, 0); Epetra_Vector * tempVec = new Epetra_Vector(rowMap); Epetra_Vector * tempRes = new Epetra_Vector(rowMap); // Show progress on what could be a long operation if( 0 == op->Comm().MyPID() ) { std::cout << "**************** CREATING MATRIX FROM OPERATOR ************************ " << std::endl; std::cout << NOX::Utils::fill(72) << std::endl; } int totalPerturbations = tempVec->GlobalLength(); int outFreq = totalPerturbations / 71; if( 1 > outFreq ) outFreq = 1; for( int col = 0; col < tempVec->GlobalLength(); ++col ) { tempVec->PutScalar(0.0); if( rowMap.MyGID(col) ) (*tempVec)[col] = 1.0; op->Apply(*tempVec, *tempRes); // Fill in only the nonzero entries from the apply for( int row = 0; row < p_mat->NumMyRows(); ++row) { if( fabs( (*tempRes)[row] ) > 1.e-12 ) { int ierr = p_mat->InsertGlobalValues( rowMap.GID(row), 1, &(*tempRes)[row], &col ); if( ierr < 0 ) { std::string msg = //"ERROR (" + ierr + ") : " "NOX::Epetra::DebugTools::compute_matrix_using_operator crsMatrix.ExtractGlobalRowView(...) failed for row : ";// + row; throw msg; } } } if( (0 == op->Comm().MyPID()) && (0 == (col % outFreq)) ) std::cout << "-" << std::flush; } if( 0 == op->Comm().MyPID() ) std::cout << "*" << std::endl; p_mat->FillComplete(); delete tempRes; delete tempVec; return p_mat; }
/*----------------------------------------------------------------------* | restrict from this to next coarser level (public) m.gee 3/06| *----------------------------------------------------------------------*/ Epetra_Vector* NLNML::NLNML_CoarseLevelNoxInterface::restrict_to_next_coarser_level( Epetra_Vector* thisvec, int current, int next) { Epetra_Vector* xfineP = 0; if (current==0) { xfineP = new Epetra_Vector((*P_)[1]->RowMap(),false); if (thisvec->MyLength() != xfineP->MyLength() || thisvec->GlobalLength() != xfineP->GlobalLength()) { cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::restrict_to_next_coarser_level:\n" << "**ERR**: mismatch in dimension of thisvec and xfineP\n" << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1; } const int mylength = thisvec->MyLength(); for (int i=0; i<mylength; i++) (*xfineP)[i] = (*thisvec)[i]; } else { xfineP = thisvec; } Epetra_Vector* cvec = new Epetra_Vector((*P_)[next]->OperatorDomainMap(),false); (*P_)[next]->Multiply(true,*xfineP,*cvec); if (current==0) delete xfineP; return cvec; }
void Albany::SolutionMaxValueResponseFunction:: computeMaxValue(const Epetra_Vector& x, double& global_max, int& global_index) { double my_max = -Epetra_MaxDouble; int my_index = -1, index; // Loop over nodes to find max value for equation eq int num_my_nodes = x.MyLength() / neq; for (int node=0; node<num_my_nodes; node++) { if (interleavedOrdering) index = node*neq+eq; else index = node + eq*num_my_nodes; if (x[index] > my_max) { my_max = x[index]; my_index = index; } } // Get max value across all proc's x.Comm().MaxAll(&my_max, &global_max, 1); // Compute min of all global indices equal to max value if (my_max == global_max) my_index = x.Map().GID(my_index); else my_index = x.GlobalLength(); x.Comm().MinAll(&my_index, &global_index, 1); }
/*----------------------------------------------------------------------* | prolongate from this level to fine (public) m.gee 3/06| *----------------------------------------------------------------------*/ Epetra_Vector* NLNML::NLNML_CoarseLevelNoxInterface::prolong_this_to_fine( const Epetra_Vector& xcoarse) { if (!Level()) return new Epetra_Vector(xcoarse); else { Epetra_Vector* cvec = const_cast<Epetra_Vector*>(&xcoarse); for (int i=Level(); i>0; i--) { // allocate a vector matching level i-1 Epetra_Vector* fvec = wvec_[i-1].get(); // multiply (*P_)[i]->Multiply(false,*cvec,*fvec); cvec = fvec; } // Note that the GIDs in cvec do NOT match those of the fineinterface as // they match the P_[1]->RangeMap. // The LIDs match, so we have to copy cvec to xfine_fineinterface // using LIDs Epetra_Vector* xfine_fineinterface = new Epetra_Vector(fineinterface_->getGraph()->RowMap(),false); if (cvec->MyLength() != xfine_fineinterface->MyLength() || cvec->GlobalLength() != xfine_fineinterface->GlobalLength()) { cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::prolong_this_to_fine:\n" << "**ERR**: mismatch in dimension of cvec and xfine_fineinterface\n" << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1; } const int mylength = cvec->MyLength(); for (int i=0; i<mylength; i++) (*xfine_fineinterface)[i] = (*cvec)[i]; return xfine_fineinterface; } }
void Albany::SolutionAverageResponseFunction:: evaluateGradient(const double current_time, const Epetra_Vector* xdot, const Epetra_Vector& x, const Teuchos::Array<ParamVec>& p, ParamVec* deriv_p, Epetra_Vector* g, Epetra_MultiVector* dg_dx, Epetra_MultiVector* dg_dxdot, Epetra_MultiVector* dg_dp) { // Evaluate response g if (g != NULL) x.MeanValue(&(*g)[0]); // Evaluate dg/dx if (dg_dx != NULL) dg_dx->PutScalar(1.0 / x.GlobalLength()); // Evaluate dg/dxdot if (dg_dxdot != NULL) dg_dxdot->PutScalar(0.0); // Evaluate dg/dp if (dg_dp != NULL) dg_dp->PutScalar(0.0); }
void Albany::SolutionAverageResponseFunction:: evaluateTangent(const double alpha, const double beta, const double current_time, bool sum_derivs, const Epetra_Vector* xdot, const Epetra_Vector& x, const Teuchos::Array<ParamVec>& p, ParamVec* deriv_p, const Epetra_MultiVector* Vxdot, const Epetra_MultiVector* Vx, const Epetra_MultiVector* Vp, Epetra_Vector* g, Epetra_MultiVector* gx, Epetra_MultiVector* gp) { // Evaluate response g if (g != NULL) x.MeanValue(&(*g)[0]); // Evaluate tangent of g = dg/dx*Vx + dg/dxdot*Vxdot + dg/dp*Vp // If Vx == NULL, Vx is the identity if (gx != NULL) { if (Vx != NULL) for (int j=0; j<Vx->NumVectors(); j++) (*Vx)(j)->MeanValue(&(*gx)[j][0]); else gx->PutScalar(1.0/x.GlobalLength()); gx->Scale(alpha); } if (gp != NULL) gp->PutScalar(0.0); }
//============================================================================= int Epetra_PETScAIJMatrix::RightScale(const Epetra_Vector& X) { // // This function scales the jth row of A by x[j]. // double *xptr; X.ExtractView(&xptr); Vec petscX; # ifdef HAVE_MPI int ierr=VecCreateMPIWithArray(Comm_->Comm(),X.MyLength(),X.GlobalLength(),xptr,&petscX); CHKERRQ(ierr); # else //FIXME untested int ierr=VecCreateSeqWithArray(Comm_->Comm(),X.MyLength(),X.GlobalLength(),xptr,&petscX); CHKERRQ(ierr); # endif MatDiagonalScale(Amat_, PETSC_NULL, petscX); ierr=VecDestroy(petscX); CHKERRQ(ierr); return(0); } //RightScale()
/*----------------------------------------------------------------------* | prolongate from next coarser level to this level (public) m.gee 3/06| *----------------------------------------------------------------------*/ Epetra_Vector* NLNML::NLNML_CoarseLevelNoxInterface::prolong_to_this_level( Epetra_Vector* coarsevec, int current, int next) { Epetra_Vector* fvec = new Epetra_Vector((*P_)[next]->OperatorRangeMap(),false); (*P_)[next]->Multiply(false,*coarsevec,*fvec); if (current==0) { Epetra_Vector* fine = new Epetra_Vector(fineinterface_->getMap(),false); if (fvec->MyLength() != fine->MyLength() || fvec->GlobalLength() != fine->GlobalLength()) { cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::prolong_to_this_level:\n" << "**ERR**: mismatch in dimension of fvec and fine\n" << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1; } const int mylength = fvec->MyLength(); for (int i=0; i<mylength; ++i) (*fine)[i] = (*fvec)[i]; delete fvec; return fine; } else return fvec; }
bool Vector2MATLAB( const Epetra_Vector & v, const Epetra_Map & Map) { int MyPID = Map.Comm().MyPID(); int NumProc = Map.Comm().NumProc(); int MyLength = v.MyLength(); int GlobalLength = v.GlobalLength(); // print out on cout if no filename is provided // write on file the dimension of the matrix if( MyPID == 0 ) cout << "v = zeros(" << GlobalLength << ")\n"; // get update list int * MyGlobalElements = Map.MyGlobalElements( ); int Row; for( int Proc=0 ; Proc<NumProc ; ++Proc ) { if( MyPID == Proc ) { cout << "% On proc " << Proc << ": "; cout << MyLength << " rows of "; cout << GlobalLength << " elements\n"; for( Row=0 ; Row<MyLength ; ++Row ) { cout << "b(" << MyGlobalElements[Row] << ") = " << v[Row] << ";\n"; } if( MyPID == NumProc-1 ) { cout << "% End of vector\n"; } } Map.Comm().Barrier(); } return true; } /* Vector2MATLAB */
/*----------------------------------------------------------------------* | restrict from fine to this level (public) m.gee 3/06| *----------------------------------------------------------------------*/ Epetra_Vector* NLNML::NLNML_CoarseLevelNoxInterface::restrict_fine_to_this( const Epetra_Vector& xfine) { if (!Level()) { Epetra_Vector* xcoarse = new Epetra_Vector(xfine); return xcoarse; } else { // Note that the GIDs in xfine match those of the fineinterface and // might be different from those in P_[1]->OperatorRangeMap(). // The LIDs and the map match, so we have to copy xfine to xfineP // using LIDs Epetra_Vector* xfineP = wvec_[0].get(); // RangeMap of P_[1] if (xfine.MyLength() != xfineP->MyLength() || xfine.GlobalLength() != xfineP->GlobalLength()) { cout << "**ERR**: NLNML::NLNML_CoarseLevelNoxInterface::restrict_fine_to_this:\n" << "**ERR**: mismatch in dimension of xfine and xfineP\n" << "**ERR**: file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw -1; } const int mylength = xfine.MyLength(); for (int i=0; i<mylength; i++) (*xfineP)[i] = xfine[i]; // loop from the finest level to this level and // apply series of restrictions (that is transposed prolongations) Epetra_Vector* fvec = xfineP; for (int i=0; i<Level()-1; i++) { Epetra_Vector* cvec = wvec_[i+1].get(); (*P_)[i+1]->Multiply(true,*fvec,*cvec); fvec = cvec; } Epetra_Vector* out = new Epetra_Vector((*P_)[Level()]->OperatorDomainMap(),false); (*P_)[Level()]->Multiply(true,*fvec,*out); return out; } }