C++ (Cpp) resetIsValid示例

示例#1

文件： NOX_LAPACK_Group.C 项目： gitter-badger/quinoa

NOX::LAPACK::Group::Group(const NOX::LAPACK::Group& source, NOX::CopyType type) :
  xVector(source.xVector, type), 
  fVector(source.fVector, type),  
  newtonVector(source.newtonVector, type),
  gradientVector(source.gradientVector, type),
  jacSolver(source.jacSolver),   
  problemInterface(source.problemInterface)	
{
 
  switch (type) {
    
  case NOX::DeepCopy:
    
    isValidF = source.isValidF;
    isValidGradient = source.isValidGradient;
    isValidNewton = source.isValidNewton;
    isValidJacobian = source.isValidJacobian;
    break;

  case NOX::ShapeCopy:
    resetIsValid();
    break;

  default:
    std::cerr << "NOX:LAPACK::Group - invalid CopyType for copy constructor." << std::endl;
    throw "NOX LAPACK Error";
  }

}

示例#2

void
LOCA::Homotopy::DeflatedGroup::
setHomotopyParam(double val) 
{
  xVec->getScalar(0) = val;
  paramVec[conParamID] = val;

  resetIsValid();
}

示例#3

void
LOCA::Homotopy::DeflatedGroup::
setParams(const LOCA::ParameterVector& p)
{
  grpPtr->setParams(p);
  xVec->getScalar(0) = p[conParamID];

  resetIsValid();
}

示例#4

文件： NOX_Belos_Group.C 项目： gitter-badger/quinoa

void
NOX::Belos::Group::computeX(const NOX::Abstract::Group& g, 
			     const NOX::Abstract::Vector& d,
			     double step) 
{
  const NOX::Belos::Group& belos_g = dynamic_cast<const NOX::Belos::Group&>(g);
  grpPtr->computeX(*(belos_g.grpPtr),d,step);
  resetIsValid();
}

示例#5

文件： NOX_LAPACK_Group.C 项目： gitter-badger/quinoa

NOX::LAPACK::Group::Group(NOX::LAPACK::Interface& interface):
  xVector(interface.getInitialGuess()),	// deep copy      
  fVector(xVector, ShapeCopy),	// new vector of same size
  newtonVector(xVector, ShapeCopy),	// new vector of same size
  gradientVector(xVector, ShapeCopy),   // new vector of same size
  jacSolver(xVector.length()),	// create a Jacobian matrix
  problemInterface(interface) // set reference to the problem interface
{
  resetIsValid();
}

示例#6

void
LOCA::Hopf::MinimallyAugmented::ExtendedGroup::
setBifParam(double val) 
{
  grpPtr->setParam(bifParamID, val);
  xVec->getScalar(0) = val;
  constraintsPtr->setParam(bifParamID, val);

  resetIsValid();
}

示例#7

文件： LOCA_MultiContinuation_ConstrainedGroup.C 项目： gitter-badger/quinoa

void
LOCA::MultiContinuation::ConstrainedGroup::setConstraintParameter(int i,
								  double val) 
{
  grpPtr->setParam(constraintParamIDs[i],val);
  xVec->getScalar(i) = val;
  constraintsPtr->setParam(constraintParamIDs[i],val);

  resetIsValid();
}

示例#8

void
LOCA::Hopf::MinimallyAugmented::ExtendedGroup::
setParams(const LOCA::ParameterVector& p)
{
  grpPtr->setParams(p);
  for (int i=0; i<p.length(); i++)
    constraintsPtr->setParam(i, p[i]);
  xVec->getScalar(0) = p[bifParamID];

  resetIsValid();
}

示例#9

void
LOCA::Homotopy::DeflatedGroup::
setParam(int paramID, double val)
{
  grpPtr->setParam(paramID, val);
  paramVec[paramID] = val;
  if (paramID == conParamID)
    conParam = val;

  resetIsValid();
}

示例#10

void
LOCA::Homotopy::DeflatedGroup::
setX(const NOX::Abstract::Vector& y)  
{
  const LOCA::MultiContinuation::ExtendedVector& my = 
    dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(y);

  grpPtr->setX( *(my.getXVec()) );
  *xVec = my;

  resetIsValid();
}

示例#11

文件： LOCA_MultiContinuation_ConstrainedGroup.C 项目： gitter-badger/quinoa

void
LOCA::MultiContinuation::ConstrainedGroup::setParam(int paramID, double val)
{
  grpPtr->setParam(paramID, val);
  constraintsPtr->setParam(paramID, val);

  for (unsigned int j=0; j<constraintParamIDs.size(); j++)
    if (paramID == constraintParamIDs[j])
      xVec->getScalar(j) = val;

  resetIsValid();
}

示例#12

文件： LOCA_MultiContinuation_ConstrainedGroup.C 项目： gitter-badger/quinoa

void
LOCA::MultiContinuation::ConstrainedGroup::setParams(
					       const LOCA::ParameterVector& p)
{
  grpPtr->setParams(p);
  for (int i=0; i<p.length(); i++)
    constraintsPtr->setParam(i, p[i]);
  for (int i=0; i<numParams; i++)
    xVec->getScalar(i) = p[constraintParamIDs[i]];

  resetIsValid();
}

示例#13

void
LOCA::Hopf::MinimallyAugmented::ExtendedGroup::
setParamsMulti(const vector<int>& paramIDs, 
	       const NOX::Abstract::MultiVector::DenseMatrix& vals)
{
  grpPtr->setParamsMulti(paramIDs, vals);
  constraintsPtr->setParams(paramIDs, vals);

  for (unsigned int i=0; i<paramIDs.size(); i++)
    if (paramIDs[i] == bifParamID)
	xVec->getScalar(0) = vals(i,0);

  resetIsValid();
}

示例#14

文件： LOCA_MultiContinuation_ConstrainedGroup.C 项目： gitter-badger/quinoa

void
LOCA::MultiContinuation::ConstrainedGroup::setParamsMulti(
		     const std::vector<int>& paramIDs, 
		     const NOX::Abstract::MultiVector::DenseMatrix& vals)
{
  grpPtr->setParamsMulti(paramIDs, vals);
  constraintsPtr->setParams(paramIDs, vals);

  for (unsigned int i=0; i<paramIDs.size(); i++)
    for (unsigned int j=0; j<constraintParamIDs.size(); j++)
      if (paramIDs[i] == constraintParamIDs[j])
	xVec->getScalar(j) = vals(i,0);

  resetIsValid();
}

示例#15

文件： LOCA_MultiContinuation_ConstrainedGroup.C 项目： gitter-badger/quinoa

void
LOCA::MultiContinuation::ConstrainedGroup::setX(
					     const NOX::Abstract::Vector& y)  
{
  const LOCA::MultiContinuation::ExtendedVector& my = 
    dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(y);

  grpPtr->setX( *(my.getXVec()) );
  grpPtr->setParamsMulti(constraintParamIDs, *my.getScalars());
  *xVec = my;
  constraintsPtr->setX( *(my.getXVec()) );
  constraintsPtr->setParams(constraintParamIDs, *my.getScalars());

  resetIsValid();
}

示例#16

void
LOCA::Homotopy::DeflatedGroup::
setParamsMulti(const vector<int>& paramIDs, 
	       const NOX::Abstract::MultiVector::DenseMatrix& vals)
{
  grpPtr->setParamsMulti(paramIDs, vals);

  for (unsigned int i=0; i<paramIDs.size(); i++) {
    paramVec[paramIDs[i]] = vals(i,0);
    if (paramIDs[i] == conParamID)
      conParam = vals(i,0);
  }

  resetIsValid();
}

示例#17

void
LOCA::Homotopy::DeflatedGroup::
computeX(const NOX::Abstract::Group& g, 
	 const NOX::Abstract::Vector& d,
	 double step) 
{
  const LOCA::Homotopy::DeflatedGroup& mg = 
    dynamic_cast<const LOCA::Homotopy::DeflatedGroup&>(g);
  const LOCA::MultiContinuation::ExtendedVector& md = 
    dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(d);

  grpPtr->computeX(*(mg.grpPtr), *(md.getXVec()), step);
  xVec->update(1.0, mg.getX(), step, md, 0.0);

  resetIsValid();
}

示例#18

void
LOCA::Hopf::MinimallyAugmented::ExtendedGroup::
setX(const NOX::Abstract::Vector& y)  
{
  const LOCA::MultiContinuation::ExtendedVector& my = 
    dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(y);

  grpPtr->setX( *(my.getXVec()) );
  grpPtr->setParam(bifParamID, my.getScalar(0));
  *xVec = my;
  constraintsPtr->setX( *(my.getXVec()) );
  constraintsPtr->setParam(bifParamID, my.getScalar(0));
  constraintsPtr->setFrequency(my.getScalar(1));

  resetIsValid();
}

示例#19

文件： NOX_Multiphysics_Group.C 项目： KineticTheory/Trilinos

NOX::Multiphysics::Group::Group(
          const Teuchos::RCP<std::vector<Teuchos::RCP<NOX::Solver::Generic> > >& solvers,
          const Teuchos::RCP<NOX::StatusTest::Generic>& t,
          const Teuchos::RCP<Teuchos::ParameterList>& p) :
  solversVecPtr(solvers),
  normRHS(0.0)
{
  // Create our version of the composite solution vector
  std::vector<const NOX::Abstract::Vector*> vecPtrs;

  for( unsigned int i = 0; i < solvers->size(); ++i )
  {
    std::cout << " .. .. .. received solver # " << i << std::endl;
    vecPtrs.push_back( &((*solvers)[i]->getSolutionGroup().getX()) );
  }

  resetIsValid();
}

示例#20

文件： LOCA_MultiContinuation_ConstrainedGroup.C 项目： gitter-badger/quinoa

void
LOCA::MultiContinuation::ConstrainedGroup::computeX(
					      const NOX::Abstract::Group& g, 
					      const NOX::Abstract::Vector& d,
					      double step) 
{
  const LOCA::MultiContinuation::ConstrainedGroup& mg = 
    dynamic_cast<const LOCA::MultiContinuation::ConstrainedGroup&>(g);
  const LOCA::MultiContinuation::ExtendedVector& md = 
    dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(d);

  grpPtr->computeX(*(mg.grpPtr), *(md.getXVec()), step);
  xVec->update(1.0, mg.getX(), step, md, 0.0);
  grpPtr->setParamsMulti(constraintParamIDs, *xVec->getScalars());
  constraintsPtr->setX( *(xVec->getXVec()) );
  constraintsPtr->setParams(constraintParamIDs, *xVec->getScalars());

  resetIsValid();
}

示例#21

void
LOCA::Hopf::MinimallyAugmented::ExtendedGroup::
computeX(const NOX::Abstract::Group& g, 
	 const NOX::Abstract::Vector& d,
	 double step) 
{
  const LOCA::Hopf::MinimallyAugmented::ExtendedGroup& mg = 
    dynamic_cast<const LOCA::Hopf::MinimallyAugmented::ExtendedGroup&>(g);
  const LOCA::MultiContinuation::ExtendedVector& md = 
    dynamic_cast<const LOCA::MultiContinuation::ExtendedVector&>(d);

  grpPtr->computeX(*(mg.grpPtr), *(md.getXVec()), step);
  xVec->update(1.0, mg.getX(), step, md, 0.0);
  grpPtr->setParam(bifParamID, xVec->getScalar(0));
  constraintsPtr->setX( *(xVec->getXVec()) );
  constraintsPtr->setParam(bifParamID, xVec->getScalar(0));
  constraintsPtr->setFrequency(xVec->getScalar(1));

  resetIsValid();
}

示例#22

文件： NOX_Multiphysics_Group.C 项目： KineticTheory/Trilinos

NOX::Multiphysics::Group::Group( const Group & source, NOX::CopyType type ):
  normRHS(0.0)
{
  switch (type)
  {
    case DeepCopy:

      isValidRHS = source.isValidRHS;
      normRHS = source.normRHS;

      break;

    case ShapeCopy:
      resetIsValid();
      break;

    default:
      std::cerr << "ERROR: Invalid ConstructorType for group copy constructor." << std::endl;
      throw "NOX Error";
  }
}

示例#23

void  LOCA::PhaseTransition::ExtendedGroup::setParam(string paramID, double val)
{ 
  resetIsValid();
  grp->setParam(paramID, val);
}

示例#24

文件： NOX_Multiphysics_Group.C 项目： KineticTheory/Trilinos

void
NOX::Multiphysics::Group::setX(const NOX::Abstract::Vector& y)
{
  resetIsValid();
}

示例#25

文件： NOX_Multiphysics_Group.C 项目： KineticTheory/Trilinos

void
NOX::Multiphysics::Group::computeX(const NOX::Abstract::Group& grp,
             const NOX::Abstract::Vector& d, double step)
{
  resetIsValid();
}

示例#26

文件： LOCA_Epetra_Group.C 项目： gitter-badger/quinoa

void
LOCA::Epetra::Group::setParam(std::string paramID, double val)
{
  resetIsValid();
  params.setValue(paramID, val);
}

示例#27

文件： LOCA_Epetra_Group.C 项目： gitter-badger/quinoa

void 
LOCA::Epetra::Group::setParams(const LOCA::ParameterVector& p)
{
  resetIsValid();
  params = p;
}

示例#28

文件： LOCA_LAPACK_Group.C 项目： haripandey/trilinos

void
LOCA::LAPACK::Group::setParam(string paramID, double val)
{
  resetIsValid();
  params.setValue(paramID, val);
}

示例#29

文件： NOX_LAPACK_Group.C 项目： gitter-badger/quinoa

void NOX::LAPACK::Group::setX(const Vector& y) 
{
  resetIsValid();
  xVector = y;
}

示例#30

文件： NOX_LAPACK_Group.C 项目： gitter-badger/quinoa

void NOX::LAPACK::Group::computeX(const Group& grp, const Vector& d, double step) 
{
  resetIsValid();
  xVector.update(1.0, grp.xVector, step, d);
}