Teuchos::RCP<LinearProblem<Scalar, MV, OP> >
problemWithNewRHS (const Teuchos::RCP<const LinearProblem<Scalar, MV, OP> >& problem,
const Teuchos::RCP<const MV>& B)
{
using Teuchos::is_null;
using Teuchos::nonnull;
using Teuchos::null;
using Teuchos::RCP;
using Teuchos::rcp;
typedef LinearProblem<Scalar, MV, OP> lp_type;
typedef MultiVecTraits<Scalar, MV> MVT;
RCP<const OP> A = problem->getOperator ();
RCP<MV> X_orig = problem->getLHS ();
TEUCHOS_TEST_FOR_EXCEPTION(is_null (X_orig), std::invalid_argument,
"problemWithNewRHS(): The original LinearProblem's "
"initial guess / current approximate solution (getLHS())"
" is null. We need an initial guess or current approxim"
"ate solution in order to know the domain of the (right-"
"preconditioned, if applicable) operator. This is "
"because Belos::MultiVecTraits does not include the idea"
" of the domain and range of an operator, or the space "
"to which a vector belongs.");
TEUCHOS_TEST_FOR_EXCEPTION(is_null (B), std::invalid_argument,
"problemWithNewRHS(): the given new right-hand side B "
"is null.");
RCP<MV> X = MVT::CloneCopy (problem->getLHS ());
RCP<lp_type> lp (new lp_type (A, X, B));
lp->setLeftPrec (problem->getLeftPrec ());
lp->setRightPrec (problem->getRightPrec ());
// Compute initial residual(s) and prepare the problem for solution.
lp->setProblem ();
return lp;
}
TEUCHOS_UNIT_TEST( DefaultAddedLinearOp, defaultConstruct )
{
typedef double Scalar;
const RCP<DefaultAddedLinearOp<Scalar> > M = defaultAddedLinearOp<Scalar>();
TEST_ASSERT(is_null(M->range()));
TEST_ASSERT(is_null(M->domain()));
TEST_ASSERT(isFullyUninitialized(*M));
TEST_ASSERT(!isPartiallyInitialized(*M));
TEST_ASSERT(!isFullyInitialized(*M));
# if defined(HAVE_GCC_ABI_DEMANGLE) && defined(HAVE_TEUCHOS_DEMANGLE)
const std::string M_description = M->description();
TEST_EQUALITY_CONST(M_description, "Thyra::DefaultAddedLinearOp<double>{numOps=0,rangeDim=0,domainDim=0}");
{
std::ostringstream describe_msg;
describe_msg << "'";
M->describe(*fancyOStream(rcpFromRef(describe_msg)), Teuchos::VERB_LOW);
describe_msg << "'";
std::ostringstream expected_msg;
expected_msg
<< "' " << M_description << "\n'";
TEST_EQUALITY_CONST( describe_msg.str(), expected_msg.str() );
}
{
std::ostringstream describe_msg;
describe_msg << "'";
M->describe(*fancyOStream(rcpFromRef(describe_msg)), Teuchos::VERB_EXTREME);
describe_msg << "'";
std::ostringstream expected_msg;
expected_msg
<< "' " << M_description << "\n"
<< " Constituent LinearOpBase objects for M = Op[0]*...*Op[numOps-1]:\n'";
TEST_EQUALITY_CONST( describe_msg.str(), expected_msg.str() );
}
# endif // defined(HAVE_GCC_ABI_DEMANGLE) && defined(HAVE_TEUCHOS_DEMANGLE)
}
void DefaultSerialDenseLinearOpWithSolveFactory<Scalar>::uninitializeOp(
LinearOpWithSolveBase<Scalar> *Op,
RCP<const LinearOpSourceBase<Scalar> > *fwdOpSrc,
RCP<const PreconditionerBase<Scalar> > *prec,
RCP<const LinearOpSourceBase<Scalar> > *approxFwdOpSrc,
ESupportSolveUse *supportSolveUse
) const
{
using Teuchos::dyn_cast;
using Teuchos::is_null;
#ifdef TEUCHOS_DEBUG
TEUCHOS_TEST_FOR_EXCEPT(0==Op);
#endif // TEUCHOS_DEBUG
typedef DefaultSerialDenseLinearOpWithSolve<Scalar> DSDLOWS;
DSDLOWS &dsdlows = dyn_cast<DSDLOWS>(*Op);
if (fwdOpSrc) {
// find a valid fwdOp
const RCP<const LinearOpBase<Scalar> > fwdOp = dsdlows.getFwdOp();
// pass out a valid fwsOpSrc
if (!is_null(fwdOp)) {
*fwdOpSrc = defaultLinearOpSource<Scalar>(fwdOp);
} else {
*fwdOpSrc = Teuchos::null;
}
}
if (prec) *prec = Teuchos::null;
if (approxFwdOpSrc) *approxFwdOpSrc = Teuchos::null;
}
bool DefaultSerialDenseLinearOpWithSolveFactory<Scalar>::isCompatible(
const LinearOpSourceBase<Scalar> &fwdOpSrc
) const
{
return !is_null(
Teuchos::rcp_dynamic_cast<const MultiVectorBase<Scalar> >(fwdOpSrc.getOp()));
}
TEUCHOS_UNIT_TEST( Rythmos_ExplicitRKStepper, clone ) {
RCP<SinCosModel> model = sinCosModel(false);
RCP<RKButcherTableauBase<double> > rkbt = createRKBT<double>("Explicit 4 Stage");
RCP<ExplicitRKStepper<double> > stepper = explicitRKStepper<double>(model,rkbt);
TEST_ASSERT( !is_null(stepper) );
TEST_ASSERT( stepper->supportsCloning() );
RCP<StepperBase<double> > otherStepper = stepper->cloneStepperAlgorithm();
TEST_ASSERT( !is_null(otherStepper) );
TEST_ASSERT( otherStepper.ptr() != stepper.ptr() );
{
RCP<ExplicitRKStepper<double> > erkStepper = Teuchos::rcp_dynamic_cast<ExplicitRKStepper<double> >(otherStepper,false);
TEST_ASSERT( !is_null(erkStepper) );
RCP<const RKButcherTableauBase<double> > rkbt_out = erkStepper->getRKButcherTableau();
TEST_ASSERT( rkbt.ptr() == rkbt_out.ptr() );
}
}
TEUCHOS_UNIT_TEST( Rythmos_ExplicitRKStepper, setgetRKButcherTableau ) {
RCP<SinCosModel> model = sinCosModel(false);
RCP<RKButcherTableauBase<double> > rkbt = createRKBT<double>("Explicit 4 Stage");
RCP<ExplicitRKStepper<double> > stepper = explicitRKStepper<double>(model,rkbt);
TEST_EQUALITY_CONST( is_null(stepper), false );
RCP<const RKButcherTableauBase<double> > rkbt_out = stepper->getRKButcherTableau();
TEST_EQUALITY_CONST( *rkbt == *rkbt_out, true );
}
TEUCHOS_UNIT_TEST( Rythmos_ExplicitRKStepper, basePoint ) {
RCP<SinCosModel> model = sinCosModel(false);
{
RCP<ParameterList> pl = Teuchos::parameterList();
pl->set("Accept model parameters",true);
model->setParameterList(pl);
}
Thyra::ModelEvaluatorBase::InArgs<double> ic = model->getNominalValues();
// t_ic
double t_ic = 1.0; // not used
// x_ic
RCP<VectorBase<double> > x_ic = Thyra::createMember(*model->get_x_space());
{
Thyra::DetachedVectorView<double> x_ic_view( *x_ic );
x_ic_view[0] = 5.0;
x_ic_view[1] = 6.0;
}
// parameter 0 ic
RCP<VectorBase<double> > p_ic = Thyra::createMember(*model->get_p_space(0));
{
Thyra::DetachedVectorView<double> p_ic_view( *p_ic );
p_ic_view[0] = 2.0; // a
p_ic_view[1] = 3.0; // f
p_ic_view[2] = 4.0; // L
}
ic.set_p(0,p_ic);
ic.set_x(x_ic);
ic.set_t(t_ic);
RCP<ExplicitRKStepper<double> > stepper = explicitRKStepper<double>();
stepper->setModel(model);
stepper->setInitialCondition(ic);
stepper->setRKButcherTableau(createRKBT<double>("Forward Euler"));
double dt = 0.2;
double dt_taken;
dt_taken = stepper->takeStep(dt,STEP_TYPE_FIXED);
TEST_EQUALITY_CONST( dt_taken, 0.2 );
const StepStatus<double> status = stepper->getStepStatus();
TEST_ASSERT( !is_null(status.solution) );
double tol = 1.0e-10;
{
Thyra::ConstDetachedVectorView<double> x_new_view( *(status.solution) );
TEST_FLOATING_EQUALITY( x_new_view[0], 5.0 + 0.2*(6.0), tol );
TEST_FLOATING_EQUALITY( x_new_view[1], 6.0 + 0.2*( (3.0/4.0)*(3.0/4.0)*(2.0-5.0) ), tol );
}
}
void
TpetraLinearObjFactory<Traits,ScalarT,LocalOrdinalT,GlobalOrdinalT,NodeT>::
globalToGhostContainer(const LinearObjContainer & in,
LinearObjContainer & out,int mem) const
{
using Teuchos::is_null;
typedef LinearObjContainer LOC;
const ContainerType & t_in = Teuchos::dyn_cast<const ContainerType>(in);
ContainerType & t_out = Teuchos::dyn_cast<ContainerType>(out);
// Operations occur if the GLOBAL container has the correct targets!
// Users set the GLOBAL continer arguments
if ( !is_null(t_in.get_x()) && !is_null(t_out.get_x()) && ((mem & LOC::X)==LOC::X))
globalToGhostTpetraVector(*t_in.get_x(),*t_out.get_x());
if ( !is_null(t_in.get_dxdt()) && !is_null(t_out.get_dxdt()) && ((mem & LOC::DxDt)==LOC::DxDt))
globalToGhostTpetraVector(*t_in.get_dxdt(),*t_out.get_dxdt());
if ( !is_null(t_in.get_f()) && !is_null(t_out.get_f()) && ((mem & LOC::F)==LOC::F))
globalToGhostTpetraVector(*t_in.get_f(),*t_out.get_f());
}
TEUCHOS_UNIT_TEST( Rythmos_ExplicitRKStepper, create ) {
RCP<SinCosModel> model = sinCosModel(false);
RCP<ExplicitRKStepper<double> > stepper = explicitRKStepper<double>(model);
TEST_EQUALITY_CONST( is_null(stepper), false );
}
