void Piro::Epetra::MatrixFreeDecorator::evalModel( const InArgs& inArgs,
const OutArgs& outArgs ) const
{
using Teuchos::RCP;
using Teuchos::rcp;
RCP<Epetra_Operator> W_out = outArgs.get_W();
if (W_out == Teuchos::null) {
// Just pass through as is: nothing to Decorate
model->evalModel(inArgs, outArgs);
}
else {
RCP<Piro::Epetra::MatrixFreeOperator> W_mfo =
Teuchos::rcp_dynamic_cast<Piro::Epetra::MatrixFreeOperator>(W_out);
TEUCHOS_TEST_FOR_EXCEPTION(W_mfo==Teuchos::null, std::logic_error,
"Epetra_Operator sent as W to Piro::Epetra::MatrixFreeDecorator\n"
"be of type Piro::Epetra::MatrixFreeOperator");
// Do base case for MatrixFree: set f instead of W
OutArgs modelOutArgs(outArgs);
InArgs modelInArgs(inArgs);
// Store f_out in case it was also requested
RCP<Epetra_Vector> f_out = outArgs.get_f();
modelOutArgs.set_f(fBase);
modelOutArgs.set_W(Teuchos::null);
//Evaluate the underlying model
model->evalModel(modelInArgs, modelOutArgs);
// If f_out was requested, return it.
if (f_out != Teuchos::null) *f_out = *fBase;
// Save unperturbed solution (deep copy inArgs, shallow f)
InArgs clonedInArgs = inArgs;
for (int l = 0; l < inArgs.Np(); ++l) {
const RCP<const Epetra_Vector> p_l = inArgs.get_p(l);
if (nonnull(p_l))
clonedInArgs.set_p(l, Teuchos::rcp(new Epetra_Vector(*p_l)));
}
clonedInArgs.set_x(Teuchos::rcp(new Epetra_Vector(*inArgs.get_x())));
bool haveXdot = false;
if (inArgs.supports(IN_ARG_x_dot)) {
RCP<const Epetra_Vector> xdot = inArgs.get_x_dot();
if (nonnull(xdot)) {
clonedInArgs.set_x_dot(Teuchos::rcp(new Epetra_Vector(*inArgs.get_x_dot())));
haveXdot = true;
}
}
W_mfo->setBase(clonedInArgs, fBase, haveXdot);
}
}
void
Stokhos::SGQuadModelEvaluator::
evalModel(const InArgs& inArgs, const OutArgs& outArgs) const
{
// Create underlying inargs
InArgs me_inargs = me->createInArgs();
if (me_inargs.supports(IN_ARG_x))
me_inargs.set_x(inArgs.get_x());
if (me_inargs.supports(IN_ARG_x_dot))
me_inargs.set_x_dot(inArgs.get_x_dot());
if (me_inargs.supports(IN_ARG_alpha))
me_inargs.set_alpha(inArgs.get_alpha());
if (me_inargs.supports(IN_ARG_beta))
me_inargs.set_beta(inArgs.get_beta());
if (me_inargs.supports(IN_ARG_t))
me_inargs.set_t(inArgs.get_t());
for (int i=0; i<num_p; i++)
me_inargs.set_p(i, inArgs.get_p(i));
// Create underlying outargs
OutArgs me_outargs = me->createOutArgs();
if (me_outargs.supports(OUT_ARG_f))
me_outargs.set_f(outArgs.get_f());
if (me_outargs.supports(OUT_ARG_W))
me_outargs.set_W(outArgs.get_W());
for (int j=0; j<num_p; j++)
if (!outArgs.supports(OUT_ARG_DfDp, j).none())
me_outargs.set_DfDp(j, outArgs.get_DfDp(j));
for (int i=0; i<num_g; i++) {
me_outargs.set_g(i, outArgs.get_g(i));
if (!outArgs.supports(OUT_ARG_DgDx, i).none())
me_outargs.set_DgDx(i, outArgs.get_DgDx(i));
if (!outArgs.supports(OUT_ARG_DgDx_dot, i).none())
me_outargs.set_DgDx(i, outArgs.get_DgDx_dot(i));
for (int j=0; j<num_p; j++)
if (!outArgs.supports(OUT_ARG_DgDp, i, j).none())
me_outargs.set_DgDp(i, j, outArgs.get_DgDp(i,j));
}
bool do_quad = false;
InArgs::sg_const_vector_t x_sg;
InArgs::sg_const_vector_t x_dot_sg;
Teuchos::Array<InArgs::sg_const_vector_t> p_sg(num_p);
OutArgs::sg_vector_t f_sg;
OutArgs::sg_operator_t W_sg;
Teuchos::Array<SGDerivative> dfdp_sg(num_p);
Teuchos::Array<OutArgs::sg_vector_t> g_sg(num_g);
Teuchos::Array<SGDerivative> dgdx_sg(num_g);
Teuchos::Array<SGDerivative> dgdx_dot_sg(num_g);
Teuchos::Array< Teuchos::Array<SGDerivative> > dgdp_sg(num_g);
TEUCHOS_TEST_FOR_EXCEPTION(inArgs.get_sg_basis() == Teuchos::null,
std::logic_error,
"Error! Stokhos::SGQuadModelEvaluator::evalModel(): " <<
"SG basis inArg cannot be null!");
TEUCHOS_TEST_FOR_EXCEPTION(inArgs.get_sg_quadrature() == Teuchos::null,
std::logic_error,
"Error! Stokhos::SGQuadModelEvaluator::evalModel(): " <<
"SG quadrature inArg cannot be null!");
Teuchos::RCP<const Stokhos::OrthogPolyBasis<int,double> > basis =
inArgs.get_sg_basis();
Teuchos::RCP< const Stokhos::Quadrature<int,double> > quad =
inArgs.get_sg_quadrature();
if (inArgs.supports(IN_ARG_x_sg)) {
x_sg = inArgs.get_x_sg();
if (x_sg != Teuchos::null) {
do_quad = true;
}
}
if (inArgs.supports(IN_ARG_x_dot_sg)) {
x_dot_sg = inArgs.get_x_dot_sg();
if (x_dot_sg != Teuchos::null) {
do_quad = true;
}
}
for (int i=0; i<num_p; i++) {
p_sg[i] = inArgs.get_p_sg(i);
if (p_sg[i] != Teuchos::null) {
do_quad = true;
}
}
if (outArgs.supports(OUT_ARG_f_sg)) {
f_sg = outArgs.get_f_sg();
if (f_sg != Teuchos::null)
f_sg->init(0.0);
}
if (outArgs.supports(OUT_ARG_W_sg)) {
W_sg = outArgs.get_W_sg();
if (W_sg != Teuchos::null)
W_sg->init(0.0);
}
for (int i=0; i<num_p; i++) {
if (!outArgs.supports(OUT_ARG_DfDp_sg, i).none()) {
dfdp_sg[i] = outArgs.get_DfDp_sg(i);
if (dfdp_sg[i].getMultiVector() != Teuchos::null)
dfdp_sg[i].getMultiVector()->init(0.0);
else if (dfdp_sg[i].getLinearOp() != Teuchos::null)
dfdp_sg[i].getLinearOp()->init(0.0);
}
}
for (int i=0; i<num_g; i++) {
g_sg[i] = outArgs.get_g_sg(i);
if (g_sg[i] != Teuchos::null)
g_sg[i]->init(0.0);
if (!outArgs.supports(OUT_ARG_DgDx_sg, i).none()) {
dgdx_sg[i] = outArgs.get_DgDx_sg(i);
if (dgdx_sg[i].getMultiVector() != Teuchos::null)
dgdx_sg[i].getMultiVector()->init(0.0);
else if (dgdx_sg[i].getLinearOp() != Teuchos::null)
dgdx_sg[i].getLinearOp()->init(0.0);
}
if (!outArgs.supports(OUT_ARG_DgDx_dot_sg, i).none()) {
dgdx_dot_sg[i] = outArgs.get_DgDx_dot_sg(i);
if (dgdx_dot_sg[i].getMultiVector() != Teuchos::null)
dgdx_dot_sg[i].getMultiVector()->init(0.0);
else if (dgdx_dot_sg[i].getLinearOp() != Teuchos::null)
dgdx_dot_sg[i].getLinearOp()->init(0.0);
}
dgdp_sg[i].resize(num_p);
for (int j=0; j<num_p; j++) {
if (!outArgs.supports(OUT_ARG_DgDp_sg, i, j).none()) {
dgdp_sg[i][j] = outArgs.get_DgDp_sg(i,j);
if (dgdp_sg[i][j].getMultiVector() != Teuchos::null)
dgdp_sg[i][j].getMultiVector()->init(0.0);
else if (dgdp_sg[i][j].getLinearOp() != Teuchos::null)
dgdp_sg[i][j].getLinearOp()->init(0.0);
}
}
}
if (do_quad) {
// Get quadrature data
const Teuchos::Array< Teuchos::Array<double> >& quad_points =
quad->getQuadPoints();
const Teuchos::Array<double>& quad_weights =
quad->getQuadWeights();
const Teuchos::Array< Teuchos::Array<double> > & quad_values =
quad->getBasisAtQuadPoints();
const Teuchos::Array<double>& basis_norms = basis->norm_squared();
// Perform integrations
for (int qp=0; qp<quad_points.size(); qp++) {
// StieltjesPCEBasis can introduce quadrature points with zero weight
// Don't do those evaluations, since the model might not like the
// quadrature points (i.e., zero)
if (quad_weights[qp] == 0.0)
continue;
{
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR_DIFF("Stokhos: SGQuadModelEvaluator -- Polynomial Evaluation",
PolyEvaluation);
#endif
// Evaluate inputs at quadrature points
if (x_sg != Teuchos::null) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos: SGQuadModelEvaluator -- X Evaluation");
#endif
x_sg->evaluate(quad_values[qp], *x_qp);
me_inargs.set_x(x_qp);
}
if (x_dot_sg != Teuchos::null) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos: SGQuadModelEvaluator -- X_dot Evaluation");
#endif
x_dot_sg->evaluate(quad_values[qp], *x_dot_qp);
me_inargs.set_x_dot(x_qp);
}
for (int i=0; i<num_p; i++) {
if (p_sg[i] != Teuchos::null) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos: SGQuadModelEvaluator -- P Evaluation");
#endif
p_sg[i]->evaluate(quad_values[qp], *(p_qp[i]));
me_inargs.set_p(i, p_qp[i]);
}
}
if (f_sg != Teuchos::null)
me_outargs.set_f(f_qp);
if (W_sg != Teuchos::null)
me_outargs.set_W(W_qp);
for (int i=0; i<num_p; i++) {
if (!dfdp_sg[i].isEmpty())
me_outargs.set_DfDp(i, dfdp_qp[i]);
}
for (int i=0; i<num_g; i++) {
if (g_sg[i] != Teuchos::null)
me_outargs.set_g(i, g_qp[i]);
if (!dgdx_dot_sg[i].isEmpty())
me_outargs.set_DgDx_dot(i, dgdx_dot_qp[i]);
if (!dgdx_sg[i].isEmpty())
me_outargs.set_DgDx(i, dgdx_qp[i]);
for (int j=0; j<num_p; j++)
if (!dgdp_sg[i][j].isEmpty())
me_outargs.set_DgDp(i, j, dgdp_qp[i][j]);
}
}
{
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos: SGQuadModelEvaluator -- Model Evaluation");
#endif
// Evaluate model at quadrature points
me->evalModel(me_inargs, me_outargs);
}
{
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR_DIFF(
"Stokhos: SGQuadModelEvaluator -- Polynomial Integration", Integration);
#endif
// Sum in results
if (f_sg != Teuchos::null) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos: SGQuadModelEvaluator -- F Integration");
#endif
f_sg->sumIntoAllTerms(quad_weights[qp], quad_values[qp], basis_norms,
*f_qp);
}
if (W_sg != Teuchos::null) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos: SGQuadModelEvaluator -- W Integration");
#endif
W_sg->sumIntoAllTerms(quad_weights[qp], quad_values[qp], basis_norms,
*W_qp);
}
for (int j=0; j<num_p; j++) {
if (!dfdp_sg[j].isEmpty()) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR(
"Stokhos: SGQuadModelEvaluator -- df/dp Integration");
#endif
if (dfdp_sg[j].getMultiVector() != Teuchos::null) {
dfdp_sg[j].getMultiVector()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dfdp_qp[j].getMultiVector()));
}
else if (dfdp_sg[j].getLinearOp() != Teuchos::null) {
dfdp_sg[j].getLinearOp()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dfdp_qp[j].getLinearOp()));
}
}
}
for (int i=0; i<num_g; i++) {
if (g_sg[i] != Teuchos::null) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR("Stokhos: SGQuadModelEvaluator -- G Integration");
#endif
g_sg[i]->sumIntoAllTerms(quad_weights[qp], quad_values[qp],
basis_norms, *g_qp[i]);
}
if (!dgdx_dot_sg[i].isEmpty()) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR(
"Stokhos: SGQuadModelEvaluator -- dg/dx_dot Integration");
#endif
if (dgdx_dot_sg[i].getMultiVector() != Teuchos::null) {
dgdx_dot_sg[i].getMultiVector()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dgdx_dot_qp[i].getMultiVector()));
}
else if (dgdx_dot_sg[i].getLinearOp() != Teuchos::null) {
dgdx_dot_sg[i].getLinearOp()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dgdx_dot_qp[i].getLinearOp()));
}
}
if (!dgdx_sg[i].isEmpty()) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR(
"Stokhos: SGQuadModelEvaluator -- dg/dx Integration");
#endif
if (dgdx_sg[i].getMultiVector() != Teuchos::null) {
dgdx_sg[i].getMultiVector()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dgdx_qp[i].getMultiVector()));
}
else if (dgdx_sg[i].getLinearOp() != Teuchos::null) {
dgdx_sg[i].getLinearOp()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dgdx_qp[i].getLinearOp()));
}
}
for (int j=0; j<num_p; j++) {
if (!dgdp_sg[i][j].isEmpty()) {
#ifdef STOKHOS_TEUCHOS_TIME_MONITOR
TEUCHOS_FUNC_TIME_MONITOR(
"Stokhos: SGQuadModelEvaluator -- dg/dp Integration");
#endif
if (dgdp_sg[i][j].getMultiVector() != Teuchos::null) {
dgdp_sg[i][j].getMultiVector()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dgdp_qp[i][j].getMultiVector()));
}
else if (dgdp_sg[i][j].getLinearOp() != Teuchos::null) {
dgdp_sg[i][j].getLinearOp()->sumIntoAllTerms(
quad_weights[qp], quad_values[qp], basis_norms,
*(dgdp_qp[i][j].getLinearOp()));
}
}
}
}
}
}
}
else {
// Compute the non-SG functions
me->evalModel(me_inargs, me_outargs);
}
}