/*----------------------------------------------------------------------* | 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; } }
//---------------------------------------------------------------------------- // // Transfer solution between meshes. // void AAdapt::CopyRemesh:: solutionTransfer(const Epetra_Vector& oldSolution, Epetra_Vector& newSolution) { TEUCHOS_TEST_FOR_EXCEPT(oldSolution.MyLength() != newSolution.MyLength()); newSolution = oldSolution; }
int Ifpack_AnalyzeVectorElements(const Epetra_Vector& Diagonal, const bool abs, const int steps) { bool verbose = (Diagonal.Comm().MyPID() == 0); double min_val = DBL_MAX; double max_val = -DBL_MAX; for (int i = 0 ; i < Diagonal.MyLength() ; ++i) { double v = Diagonal[i]; if (abs) if (v < 0) v = -v; if (v > max_val) max_val = v; if (v < min_val) min_val = v; } if (verbose) { cout << endl; Ifpack_PrintLine(); cout << "Vector label = " << Diagonal.Label() << endl; cout << endl; } double delta = (max_val - min_val) / steps; for (int k = 0 ; k < steps ; ++k) { double below = delta * k + min_val; double above = below + delta; int MyBelow = 0, GlobalBelow; for (int i = 0 ; i < Diagonal.MyLength() ; ++i) { double v = Diagonal[i]; if (v < 0) v = -v; if (v >= below && v < above) MyBelow++; } Diagonal.Comm().SumAll(&MyBelow, &GlobalBelow, 1); if (verbose) { printf("Elements in [%+7e, %+7e) = %10d ( = %5.2f %%)\n", below, above, GlobalBelow, 100.0 * GlobalBelow / Diagonal.GlobalLength64()); } } if (verbose) { Ifpack_PrintLine(); cout << endl; } return(0); }
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); }
/*----------------------------------------------------------------------* | 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; }
EpetraVector<Scalar>::EpetraVector(const Epetra_Vector &v) { this->vec = (Epetra_Vector *)&v; this->vec_im = nullptr; this->std_map = (Epetra_BlockMap *)&v.Map(); this->size = v.MyLength(); this->owner = false; }
//============================================================================= 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 */
void XferOp::transferField(Epetra_Vector& vecTo, Epetra_Vector& vecFrom) { // Do the transfer using Epetra_Vectors for( int i = 0; i < vecTo.MyLength(); i++) { vecTo[i] = 0.0; pair< multimap<int, int>::iterator, multimap<int, int>::iterator > rangeN = dependentNodes.equal_range(i); pair< multimap<int, double>::iterator, multimap<int, double>::iterator > rangeW = dependentWeights.equal_range(i); multimap<int, int>::iterator iterN; multimap<int, double>::iterator iterW; int j; for( j = 0, iterN = rangeN.first, iterW = rangeW.first; iterN != rangeN.second; j++, iterN++, iterW++) vecTo[i] += (*iterW).second * vecFrom[(*iterN).second]; } }
/*----------------------------------------------------------------------* | 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; } }
/****************************************************************** Compute weight balance ******************************************************************/ int compute_balance(const Epetra_Vector &wgts, double myGoalWeight, double &min, double &max, double &avg) { if ((myGoalWeight < 0) || (myGoalWeight > 1.0)){ std::cerr << "compute_balance: Goal weight should be in the range [0, 1]" << std::endl; return -1; } double weightTotal; wgts.Norm1(&weightTotal); double weightLocal = 0.0; for (int i=0; i < wgts.MyLength(); i++){ weightLocal += wgts[i]; } /* My degree of imbalance. * If myGoalWeight is zero, I'm in perfect balance since I got what I wanted. */ double goalWeight = myGoalWeight * weightTotal; double imbalance = 1.0; if (myGoalWeight > 0.0){ if (weightLocal >= goalWeight) imbalance += (weightLocal - goalWeight) / goalWeight; else imbalance += (goalWeight - weightLocal) / goalWeight; } const Epetra_Comm &comm = wgts.Comm(); comm.MaxAll(&imbalance, &max, 1); comm.MinAll(&imbalance, &min, 1); comm.SumAll(&imbalance, &avg, 1); avg /= comm.NumProc(); return 0; }
/*----------------------------------------------------------------------* | solve problem (public) mwgee 12/05| *----------------------------------------------------------------------*/ bool MOERTEL::Manager::Solve(Epetra_Vector& sol, const Epetra_Vector& rhs) { // test for solver parameters if (solverparams_==Teuchos::null) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** No solver parameters set, use SetSolverParameters(ParameterList& params)\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } // test for problemmap_ if (problemmap_==Teuchos::null) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** No problem map set, use SetProblemMap(Epetra_Map* map)\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } // test for inputmatrix if (inputmatrix_==Teuchos::null) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** No inputmatrix set, use SetInputMatrix(Epetra_CrsMatrix* inputmatrix, bool DeepCopy = false)\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } // test whether problemmap_ matches RangeMap() of inputmatrix if (!problemmap_->PointSameAs(inputmatrix_->RangeMap())) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** problem map does not match range map of input matrix\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } // test whether maps of rhs and sol are ok if (!problemmap_->PointSameAs(rhs.Map()) || !problemmap_->PointSameAs(sol.Map()) ) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** problem map does not match map of rhs and/or sol\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } // test whether interfaces are complete and have been integrated std::map<int,Teuchos::RCP<MOERTEL::Interface> >::iterator curr; for (curr=interface_.begin(); curr != interface_.end(); ++curr) { if (curr->second->IsComplete() == false) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** interface " << curr->second->Id() << " is not IsComplete()\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } if (curr->second->IsIntegrated() == false) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** interface " << curr->second->Id() << " is not integrated yet\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } } // test whether we have M and D matrix if (D_==Teuchos::null || M_==Teuchos::null) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** Matrix M or D is NULL\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } //--------------------------------------------------------------------------- // make solution and rhs vector matching the system Teuchos::RCP<Epetra_Vector> b = Teuchos::rcp(const_cast<Epetra_Vector*>(&rhs)); b.release(); Teuchos::RCP<Epetra_Vector> x = Teuchos::rcp(&sol); x.release(); //--------------------------------------------------------------------------- // get type of system to be used/generated Teuchos::RCP<Epetra_CrsMatrix> matrix = Teuchos::null; string system = solverparams_->get("System","None"); if (system=="None") { cout << "***WRN*** MOERTEL::Manager::Solve:\n" << "***WRN*** parameter 'System' was not chosen, using default\n" << "***WRN*** which is 'SaddleSystem'\n" << "***WRN*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; solverparams_->set("System","SaddleSystem"); system = "SaddleSystem"; } //--------------------------------------------------------------------------- // build a saddle point system if (system=="SaddleSystem" || system=="saddlesystem" || system=="SADDLESYSTEM" || system=="Saddle_System" || system=="saddle_system" || system=="SADDLE_SYSTEM") { if (saddlematrix_==Teuchos::null) { Epetra_CrsMatrix* tmp = MakeSaddleProblem(); if (!tmp) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** MakeSaddleProblem() returned NULL\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } } matrix = saddlematrix_; b = Teuchos::rcp(new Epetra_Vector(*saddlemap_,true)); b.set_has_ownership(); x = Teuchos::rcp(new Epetra_Vector(*saddlemap_,false)); x.set_has_ownership(); for (int i=0; i<rhs.MyLength(); ++i) { (*b)[i] = rhs[i]; (*x)[i] = sol[i]; } } //--------------------------------------------------------------------------- // build a spd system else if (system=="SPDSystem" || system=="spdsystem" || system=="spd_system" || system=="SPD_System" || system=="SPDSYSTEM" || system=="SPD_SYSTEM") { if (spdmatrix_==Teuchos::null) { Epetra_CrsMatrix* tmp = MakeSPDProblem(); if (!tmp) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** MakeSPDProblem() returned NULL\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } } matrix = spdmatrix_; // we have to multiply the rhs vector b with spdrhs_ to fit with spdmatrix_ if (spdrhs_==Teuchos::null) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** Cannot build righthandside for spd problem\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } Epetra_Vector *tmp = new Epetra_Vector(b->Map(),false); int err = spdrhs_->Multiply(false,*b,*tmp); if (err) { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** spdrhs_->Multiply returned err = " << err << endl << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } b = Teuchos::rcp(tmp); b.set_has_ownership(); } //--------------------------------------------------------------------------- // unknown parameter "System" else { cout << "***ERR*** MOERTEL::Manager::Solve:\n" << "***ERR*** Unknown type of parameter 'System': " << system << "\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return false; } //--------------------------------------------------------------------------- // create a mortar solver class instance if (solver_==Teuchos::null) solver_ = Teuchos::rcp(new MOERTEL::Solver(Comm(),OutLevel())); //--------------------------------------------------------------------------- // solve bool ok = solver_->Solve(solverparams_,matrix,x,b,*this); if (!ok) { if (Comm().MyPID()==0) cout << "***WRN*** MOERTEL::Manager::Solve:\n" << "***WRN*** MOERTEL::Solver::Solve returned an error\n" << "***WRN*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; } //--------------------------------------------------------------------------- // copy solution back to sol if neccessary if (x.has_ownership()) { for (int i=0; i<sol.MyLength(); ++i) sol[i] = (*x)[i]; } return ok; }
void AZOO_iterate(double * xsolve, double * b, int * options, double * params, double * status, int *proc_config, AZ_MATRIX * Amat, AZ_PRECOND *precond, struct AZ_SCALING *scaling) { (void)precond; (void)scaling; bool verbose = (options[AZ_output]!=AZ_none); // Print info unless all output is turned off Epetra_Comm * comm; Epetra_BlockMap * map; Epetra_RowMatrix * A; Epetra_Vector * px; Epetra_Vector * pb; int * global_indices; int ierr = Aztec2Petra(proc_config, Amat, xsolve, b, comm, map, A, px, pb, &global_indices); if (ierr!=0) { cerr << "Error detected in Aztec2Petra. Value = " << ierr << endl; exit(1); } Epetra_LinearProblem problem(A, px, pb); Epetra_Vector * leftScaleVec = 0; Epetra_Vector * rightScaleVec = 0; bool doRowScaling = false; bool doColScaling = false; if ((options[AZ_scaling]==AZ_Jacobi) || options[AZ_scaling]==AZ_BJacobi) { doRowScaling = true; leftScaleVec = new Epetra_Vector(*map); A->ExtractDiagonalCopy(*leftScaleVec); // Extract diagonal of matrix leftScaleVec->Reciprocal(*leftScaleVec); // invert it } else if (options[AZ_scaling]==AZ_row_sum) { doRowScaling = true; leftScaleVec = new Epetra_Vector(*map); A->InvRowSums(*leftScaleVec); } else if (options[AZ_scaling]==AZ_sym_diag) { doRowScaling = true; doColScaling = true; leftScaleVec = new Epetra_Vector(*map); A->ExtractDiagonalCopy(*leftScaleVec); // Extract diagonal of matrix int length = leftScaleVec->MyLength(); for (int i=0; i<length; i++) (*leftScaleVec)[i] = sqrt(fabs((*leftScaleVec)[i])); // Take its sqrt rightScaleVec = leftScaleVec; // symmetric, so left and right the same leftScaleVec->Reciprocal(*leftScaleVec); // invert it } else if (options[AZ_scaling]==AZ_sym_row_sum) { doRowScaling = true; doColScaling = true; leftScaleVec = new Epetra_Vector(*map); A->InvRowSums(*leftScaleVec); int length = leftScaleVec->MyLength(); for (int i=0; i<length; i++) (*leftScaleVec)[i] = sqrt(fabs((*leftScaleVec)[i])); // Take its sqrt rightScaleVec = leftScaleVec; // symmetric, so left and right the same } if ((doRowScaling || doColScaling) && verbose) { double norminf = A->NormInf(); double normone = A->NormOne(); if (comm->MyPID()==0) cout << "\n Inf-norm of A before scaling = " << norminf << "\n One-norm of A before scaling = " << normone<< endl << endl; } if (doRowScaling) problem.LeftScale(*leftScaleVec); if (doColScaling) problem.RightScale(*rightScaleVec); if ((doRowScaling || doColScaling) && verbose) { double norminf = A->NormInf(); double normone = A->NormOne(); if (comm->MyPID()==0) cout << "\n Inf-norm of A after scaling = " << norminf << "\n One-norm of A after scaling = " << normone << endl << endl; } AztecOO solver(problem); solver.SetAllAztecParams(params); // set all AztecOO params with user-provided params solver.SetAllAztecOptions(options); // set all AztecOO options with user-provided options solver.CheckInput(); solver.SetAztecOption(AZ_scaling, AZ_none); // Always must have scaling off solver.Iterate(options[AZ_max_iter], params[AZ_tol]); solver.GetAllAztecStatus(status); if (doColScaling) { rightScaleVec->Reciprocal(*rightScaleVec); problem.RightScale(*rightScaleVec); } if (doRowScaling) { leftScaleVec->Reciprocal(*leftScaleVec); problem.LeftScale(*leftScaleVec); } if ((rightScaleVec!=0) && (rightScaleVec!=leftScaleVec)) delete rightScaleVec; if (leftScaleVec!=0) delete leftScaleVec; delete pb; // These are all objects created here and we have to delete them delete px; delete A; delete map; delete comm; if (global_indices!=0) AZ_free((void *) global_indices); // Note: we used a special version of free here return; }
void HMX_PDE::computeSourceTerm(map<string, Epetra_Vector*> fields, Epetra_Vector& result) { // All dependent variables should be in place before now // We assume all other registered dependent problems are species which // affect the reaction rate of this specie Epetra_Vector *TvecPtr = 0; map<string, Epetra_Vector*>::iterator iter = fields.find(tempFieldName); if( iter == fields.end() ) { std::cout << "ERROR: Cannot find Temperature field \"" << tempFieldName << "\" for use in computeSourceTerm for problem \"" << getName() << std::endl; throw "HMX_PDE ERROR"; } else TvecPtr = (*iter).second; Epetra_Vector &T = *TvecPtr; // If this problem is the temperature equation, don't compute a source // term. This would be where a volumetric heating term would go. if( getName() == tempFieldName ) { result.PutScalar(0.0); return; } else { double rateK; map<string, double>::iterator requiredFieldIter; map<string, double>::iterator requiredFieldEnd = SrcTermExponent.end(); for( int i = 0; i<result.MyLength(); i++ ) { rateK = pow(T[i],StericCoef) * PreExp_A * exp( -ActEnergy / (Const_R * T[i]) ); result[i] = 1.0; // Start point for product // Loop over all required fields and contribute to product for( requiredFieldIter = SrcTermExponent.begin(); requiredFieldIter != requiredFieldEnd; requiredFieldIter++) { iter = fields.find( (*requiredFieldIter).first ); if( iter == fields.end() ) { std::cout << "ERROR: Cannot find required field \"" << (*requiredFieldIter).first << "\" for use in computeSourceTerm for problem \"" << getName() << std::endl; throw "HMX_PDE ERROR"; } Epetra_Vector &reqFieldVec = *((*iter).second); result[i] *= pow( reqFieldVec[i], (*requiredFieldIter).second ); } result[i] *= rateK; } } }
virtual int ExtractDiagonalCopy(Epetra_Vector & Diagonal) const { for (int i = 0 ; i < Diagonal.MyLength() ; ++i) Diagonal[i] = 7.0; return(0); }