void
Albany::ModelEvaluator::evalModel(const InArgs& inArgs,
const OutArgs& outArgs) const
{
Teuchos::TimeMonitor Timer(*timer); //start timer
//
// Get the input arguments
//
Teuchos::RCP<const Epetra_Vector> x = inArgs.get_x();
Teuchos::RCP<const Epetra_Vector> x_dot;
Teuchos::RCP<const Epetra_Vector> x_dotdot;
double alpha = 0.0;
double omega = 0.0;
double beta = 1.0;
double curr_time = 0.0;
x_dot = inArgs.get_x_dot();
x_dotdot = inArgs.get_x_dotdot();
if (x_dot != Teuchos::null || x_dotdot != Teuchos::null) {
alpha = inArgs.get_alpha();
omega = inArgs.get_omega();
beta = inArgs.get_beta();
curr_time = inArgs.get_t();
}
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP<const Epetra_Vector> p = inArgs.get_p(i);
if (p != Teuchos::null) {
for (unsigned int j=0; j<sacado_param_vec[i].size(); j++)
sacado_param_vec[i][j].baseValue = (*p)[j];
}
}
for (int i=0; i<num_dist_param_vecs; i++) {
Teuchos::RCP<const Epetra_Vector> p = inArgs.get_p(i+num_param_vecs);
if (p != Teuchos::null) {
*(distParamLib->get(dist_param_names[i])->vector()) = *p;
}
}
//
// Get the output arguments
//
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> f_out = outArgs.get_f();
Teuchos::RCP<Epetra_Operator> W_out = outArgs.get_W();
// Cast W to a CrsMatrix, throw an exception if this fails
Teuchos::RCP<Epetra_CrsMatrix> W_out_crs;
if (W_out != Teuchos::null)
W_out_crs = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_out, true);
int test_var = 0;
if(test_var != 0){
std::cout << "The current solution length is: " << x->MyLength() << std::endl;
x->Print(std::cout);
}
// Get preconditioner operator, if requested
Teuchos::RCP<Epetra_Operator> WPrec_out;
if (outArgs.supports(OUT_ARG_WPrec)) WPrec_out = outArgs.get_WPrec();
//
// Compute the functions
//
bool f_already_computed = false;
// W matrix
if (W_out != Teuchos::null) {
app->computeGlobalJacobian(alpha, beta, omega, curr_time, x_dot.get(), x_dotdot.get(),*x,
sacado_param_vec, f_out.get(), *W_out_crs);
f_already_computed=true;
if(test_var != 0){
//std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
//f_out->Print(std::cout);
std::cout << "The current Jacobian length is: " << W_out_crs->NumGlobalRows() << std::endl;
W_out_crs->Print(std::cout);
}
}
if (WPrec_out != Teuchos::null) {
app->computeGlobalJacobian(alpha, beta, omega, curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, f_out.get(), *Extra_W_crs);
f_already_computed=true;
if(test_var != 0){
//std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
//f_out->Print(std::cout);
std::cout << "The current preconditioner length is: " << Extra_W_crs->NumGlobalRows() << std::endl;
Extra_W_crs->Print(std::cout);
}
app->computeGlobalPreconditioner(Extra_W_crs, WPrec_out);
}
// scalar df/dp
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP<Epetra_MultiVector> dfdp_out =
outArgs.get_DfDp(i).getMultiVector();
if (dfdp_out != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DfDp(i).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[i],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int j=0; j<p_indexes.size(); j++)
p_vec->addParam(sacado_param_vec[i][p_indexes[j]].family,
sacado_param_vec[i][p_indexes[j]].baseValue);
}
app->computeGlobalTangent(0.0, 0.0, 0.0, curr_time, false, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, p_vec.get(),
NULL, NULL, NULL, NULL, f_out.get(), NULL,
dfdp_out.get());
f_already_computed=true;
if(test_var != 0){
std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
f_out->Print(std::cout);
}
}
}
// distributed df/dp
for (int i=0; i<num_dist_param_vecs; i++) {
Teuchos::RCP<Epetra_Operator> dfdp_out =
outArgs.get_DfDp(i+num_param_vecs).getLinearOp();
if (dfdp_out != Teuchos::null) {
Teuchos::RCP<DistributedParameterDerivativeOp> dfdp_op =
Teuchos::rcp_dynamic_cast<DistributedParameterDerivativeOp>(dfdp_out);
dfdp_op->set(curr_time, x_dot, x_dotdot, x,
Teuchos::rcp(&sacado_param_vec,false));
}
}
// f
if (app->is_adjoint) {
Derivative f_deriv(f_out, DERIV_TRANS_MV_BY_ROW);
int response_index = 0; // need to add capability for sending this in
app->evaluateResponseDerivative(response_index, curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, NULL,
NULL, f_deriv, Derivative(), Derivative(), Derivative());
}
else {
if (f_out != Teuchos::null && !f_already_computed) {
app->computeGlobalResidual(curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, *f_out);
if(test_var != 0){
std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
f_out->Print(std::cout);
}
}
}
// Response functions
for (int i=0; i<outArgs.Ng(); i++) {
Teuchos::RCP<Epetra_Vector> g_out = outArgs.get_g(i);
bool g_computed = false;
Derivative dgdx_out = outArgs.get_DgDx(i);
Derivative dgdxdot_out = outArgs.get_DgDx_dot(i);
Derivative dgdxdotdot_out = outArgs.get_DgDx_dotdot(i);
// dg/dx, dg/dxdot
if (!dgdx_out.isEmpty() || !dgdxdot_out.isEmpty() || !dgdxdotdot_out.isEmpty() ) {
app->evaluateResponseDerivative(i, curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, NULL,
g_out.get(), dgdx_out,
dgdxdot_out, dgdxdotdot_out, Derivative());
g_computed = true;
}
// dg/dp
for (int j=0; j<num_param_vecs; j++) {
Teuchos::RCP<Epetra_MultiVector> dgdp_out =
outArgs.get_DgDp(i,j).getMultiVector();
if (dgdp_out != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DgDp(i,j).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[j],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int k=0; k<p_indexes.size(); k++)
p_vec->addParam(sacado_param_vec[j][p_indexes[k]].family,
sacado_param_vec[j][p_indexes[k]].baseValue);
}
app->evaluateResponseTangent(i, alpha, beta, omega, curr_time, false,
x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, p_vec.get(),
NULL, NULL, NULL, NULL, g_out.get(), NULL,
dgdp_out.get());
g_computed = true;
}
}
// Need to handle dg/dp for distributed p
if (g_out != Teuchos::null && !g_computed)
app->evaluateResponse(i, curr_time, x_dot.get(), x_dotdot.get(), *x, sacado_param_vec,
*g_out);
}
//
// Stochastic Galerkin
//
#ifdef ALBANY_SG_MP
InArgs::sg_const_vector_t x_sg = inArgs.get_x_sg();
if (x_sg != Teuchos::null) {
app->init_sg(inArgs.get_sg_basis(),
inArgs.get_sg_quadrature(),
inArgs.get_sg_expansion(),
x_sg->productComm());
InArgs::sg_const_vector_t x_dot_sg = inArgs.get_x_dot_sg();
InArgs::sg_const_vector_t x_dotdot_sg = inArgs.get_x_dotdot_sg();
if (x_dot_sg != Teuchos::null || x_dotdot_sg != Teuchos::null) {
alpha = inArgs.get_alpha();
omega = inArgs.get_omega();
beta = inArgs.get_beta();
curr_time = inArgs.get_t();
}
InArgs::sg_const_vector_t epetra_p_sg = inArgs.get_p_sg(0);
Teuchos::Array<int> p_sg_index;
for (int i=0; i<num_param_vecs; i++) {
InArgs::sg_const_vector_t p_sg = inArgs.get_p_sg(i);
if (p_sg != Teuchos::null) {
p_sg_index.push_back(i);
for (int j=0; j<p_sg_vals[i].size(); j++) {
int num_sg_blocks = p_sg->size();
p_sg_vals[i][j].reset(app->getStochasticExpansion(), num_sg_blocks);
p_sg_vals[i][j].copyForWrite();
for (int l=0; l<num_sg_blocks; l++) {
p_sg_vals[i][j].fastAccessCoeff(l) = (*p_sg)[l][j];
}
}
}
}
OutArgs::sg_vector_t f_sg = outArgs.get_f_sg();
OutArgs::sg_operator_t W_sg = outArgs.get_W_sg();
bool f_sg_computed = false;
// W_sg
if (W_sg != Teuchos::null) {
Stokhos::VectorOrthogPoly<Epetra_CrsMatrix> W_sg_crs(W_sg->basis(),
W_sg->map());
for (int i=0; i<W_sg->size(); i++)
W_sg_crs.setCoeffPtr(
i,
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_sg->getCoeffPtr(i)));
app->computeGlobalSGJacobian(alpha, beta, omega, curr_time,
x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
f_sg.get(), W_sg_crs);
f_sg_computed = true;
}
// df/dp_sg
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > dfdp_sg
= outArgs.get_DfDp_sg(i).getMultiVector();
if (dfdp_sg != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DfDp_sg(i).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[i],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int j=0; j<p_indexes.size(); j++)
p_vec->addParam(sacado_param_vec[i][p_indexes[j]].family,
sacado_param_vec[i][p_indexes[j]].baseValue);
}
app->computeGlobalSGTangent(0.0, 0.0, 0.0, curr_time, false,
x_dot_sg.get(), x_dotdot_sg.get(),*x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
p_vec.get(), NULL, NULL, NULL, NULL,
f_sg.get(), NULL, dfdp_sg.get());
f_sg_computed = true;
}
}
if (f_sg != Teuchos::null && !f_sg_computed)
app->computeGlobalSGResidual(curr_time, x_dot_sg.get(), x_dotdot_sg.get(),*x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
*f_sg);
// Response functions
for (int i=0; i<outArgs.Ng(); i++) {
OutArgs::sg_vector_t g_sg = outArgs.get_g_sg(i);
bool g_sg_computed = false;
SGDerivative dgdx_sg = outArgs.get_DgDx_sg(i);
SGDerivative dgdxdot_sg = outArgs.get_DgDx_dot_sg(i);
SGDerivative dgdxdotdot_sg = outArgs.get_DgDx_dotdot_sg(i);
// dg/dx, dg/dxdot
if (!dgdx_sg.isEmpty() || !dgdxdot_sg.isEmpty() || !dgdxdotdot_sg.isEmpty()) {
app->evaluateSGResponseDerivative(
i, curr_time, x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
NULL, g_sg.get(), dgdx_sg,
dgdxdot_sg, dgdxdotdot_sg, SGDerivative());
g_sg_computed = true;
}
// dg/dp
for (int j=0; j<num_param_vecs; j++) {
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > dgdp_sg =
outArgs.get_DgDp_sg(i,j).getMultiVector();
if (dgdp_sg != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DgDp_sg(i,j).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[j],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int k=0; k<p_indexes.size(); k++)
p_vec->addParam(sacado_param_vec[j][p_indexes[k]].family,
sacado_param_vec[j][p_indexes[k]].baseValue);
}
app->evaluateSGResponseTangent(i, alpha, beta, omega, curr_time, false,
x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index,
p_sg_vals, p_vec.get(),
NULL, NULL, NULL, NULL, g_sg.get(),
NULL, dgdp_sg.get());
g_sg_computed = true;
}
}
if (g_sg != Teuchos::null && !g_sg_computed)
app->evaluateSGResponse(i, curr_time, x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
*g_sg);
}
}
//
// Multi-point evaluation
//
mp_const_vector_t x_mp = inArgs.get_x_mp();
if (x_mp != Teuchos::null) {
mp_const_vector_t x_dot_mp = inArgs.get_x_dot_mp();
mp_const_vector_t x_dotdot_mp = inArgs.get_x_dotdot_mp();
if (x_dot_mp != Teuchos::null || x_dotdot_mp != Teuchos::null) {
alpha = inArgs.get_alpha();
omega = inArgs.get_omega();
beta = inArgs.get_beta();
curr_time = inArgs.get_t();
}
Teuchos::Array<int> p_mp_index;
for (int i=0; i<num_param_vecs; i++) {
mp_const_vector_t p_mp = inArgs.get_p_mp(i);
if (p_mp != Teuchos::null) {
p_mp_index.push_back(i);
for (int j=0; j<p_mp_vals[i].size(); j++) {
int num_mp_blocks = p_mp->size();
p_mp_vals[i][j].reset(num_mp_blocks);
p_mp_vals[i][j].copyForWrite();
for (int l=0; l<num_mp_blocks; l++) {
p_mp_vals[i][j].fastAccessCoeff(l) = (*p_mp)[l][j];
}
}
}
}
mp_vector_t f_mp = outArgs.get_f_mp();
mp_operator_t W_mp = outArgs.get_W_mp();
bool f_mp_computed = false;
// W_mp
if (W_mp != Teuchos::null) {
Stokhos::ProductContainer<Epetra_CrsMatrix> W_mp_crs(W_mp->map());
for (int i=0; i<W_mp->size(); i++)
W_mp_crs.setCoeffPtr(
i,
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_mp->getCoeffPtr(i)));
app->computeGlobalMPJacobian(alpha, beta, omega, curr_time,
x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
f_mp.get(), W_mp_crs);
f_mp_computed = true;
}
// df/dp_mp
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP< Stokhos::ProductEpetraMultiVector > dfdp_mp
= outArgs.get_DfDp_mp(i).getMultiVector();
if (dfdp_mp != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DfDp_mp(i).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[i],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int j=0; j<p_indexes.size(); j++)
p_vec->addParam(sacado_param_vec[i][p_indexes[j]].family,
sacado_param_vec[i][p_indexes[j]].baseValue);
}
app->computeGlobalMPTangent(0.0, 0.0, 0.0, curr_time, false,
x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
p_vec.get(), NULL, NULL, NULL, NULL,
f_mp.get(), NULL, dfdp_mp.get());
f_mp_computed = true;
}
}
if (f_mp != Teuchos::null && !f_mp_computed)
app->computeGlobalMPResidual(curr_time, x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
*f_mp);
// Response functions
for (int i=0; i<outArgs.Ng(); i++) {
mp_vector_t g_mp = outArgs.get_g_mp(i);
bool g_mp_computed = false;
MPDerivative dgdx_mp = outArgs.get_DgDx_mp(i);
MPDerivative dgdxdot_mp = outArgs.get_DgDx_dot_mp(i);
MPDerivative dgdxdotdot_mp = outArgs.get_DgDx_dotdot_mp(i);
// dg/dx, dg/dxdot
if (!dgdx_mp.isEmpty() || !dgdxdot_mp.isEmpty() || !dgdxdotdot_mp.isEmpty() ) {
app->evaluateMPResponseDerivative(
i, curr_time, x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
NULL, g_mp.get(), dgdx_mp,
dgdxdot_mp, dgdxdotdot_mp, MPDerivative());
g_mp_computed = true;
}
// dg/dp
for (int j=0; j<num_param_vecs; j++) {
Teuchos::RCP< Stokhos::ProductEpetraMultiVector > dgdp_mp =
outArgs.get_DgDp_mp(i,j).getMultiVector();
if (dgdp_mp != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DgDp_mp(i,j).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[j],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int k=0; k<p_indexes.size(); k++)
p_vec->addParam(sacado_param_vec[j][p_indexes[k]].family,
sacado_param_vec[j][p_indexes[k]].baseValue);
}
app->evaluateMPResponseTangent(i, alpha, beta, omega, curr_time, false,
x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index,
p_mp_vals, p_vec.get(),
NULL, NULL, NULL, NULL, g_mp.get(),
NULL, dgdp_mp.get());
g_mp_computed = true;
}
}
if (g_mp != Teuchos::null && !g_mp_computed)
app->evaluateMPResponse(i, curr_time, x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
*g_mp);
}
}
#endif //ALBANY_SG_MP
}
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);
}
}
void
Albany::ModelEvaluator::evalModel(const InArgs& inArgs,
const OutArgs& outArgs) const
{
Teuchos::TimeMonitor Timer(*timer); //start timer
//
// Get the input arguments
//
Teuchos::RCP<const Epetra_Vector> x = inArgs.get_x();
Teuchos::RCP<const Epetra_Vector> x_dot;
Teuchos::RCP<const Epetra_Vector> x_dotdot;
//create comm and node objects for Epetra -> Tpetra conversions
Teuchos::RCP<const Teuchos::Comm<int> > commT = app->getComm();
Teuchos::RCP<Epetra_Comm> comm = Albany::createEpetraCommFromTeuchosComm(commT);
//Create Tpetra copy of x, call it xT
Teuchos::RCP<const Tpetra_Vector> xT;
if (x != Teuchos::null)
xT = Petra::EpetraVector_To_TpetraVectorConst(*x, commT);
double alpha = 0.0;
double omega = 0.0;
double beta = 1.0;
double curr_time = 0.0;
if(num_time_deriv > 0)
x_dot = inArgs.get_x_dot();
if(num_time_deriv > 1)
x_dotdot = inArgs.get_x_dotdot();
//Declare and create Tpetra copy of x_dot, call it x_dotT
Teuchos::RCP<const Tpetra_Vector> x_dotT;
if (Teuchos::nonnull(x_dot))
x_dotT = Petra::EpetraVector_To_TpetraVectorConst(*x_dot, commT);
//Declare and create Tpetra copy of x_dotdot, call it x_dotdotT
Teuchos::RCP<const Tpetra_Vector> x_dotdotT;
if (Teuchos::nonnull(x_dotdot))
x_dotdotT = Petra::EpetraVector_To_TpetraVectorConst(*x_dotdot, commT);
if (Teuchos::nonnull(x_dot)){
alpha = inArgs.get_alpha();
beta = inArgs.get_beta();
curr_time = inArgs.get_t();
}
if (Teuchos::nonnull(x_dotdot)) {
omega = inArgs.get_omega();
}
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP<const Epetra_Vector> p = inArgs.get_p(i);
if (p != Teuchos::null) {
for (unsigned int j=0; j<sacado_param_vec[i].size(); j++) {
sacado_param_vec[i][j].baseValue = (*p)[j];
}
}
}
for (int i=0; i<num_dist_param_vecs; i++) {
Teuchos::RCP<const Epetra_Vector> p = inArgs.get_p(i+num_param_vecs);
//create Tpetra copy of p
Teuchos::RCP<const Tpetra_Vector> pT;
if (p != Teuchos::null) {
pT = Petra::EpetraVector_To_TpetraVectorConst(*p, commT);
//*(distParamLib->get(dist_param_names[i])->vector()) = *p;
*(distParamLib->get(dist_param_names[i])->vector()) = *pT;
}
}
//
// Get the output arguments
//
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> f_out = outArgs.get_f();
Teuchos::RCP<Epetra_Operator> W_out = outArgs.get_W();
// Cast W to a CrsMatrix, throw an exception if this fails
Teuchos::RCP<Epetra_CrsMatrix> W_out_crs;
#ifdef WRITE_MASS_MATRIX_TO_MM_FILE
//IK, 7/15/14: adding object to hold mass matrix to be written to matrix market file
Teuchos::RCP<Epetra_CrsMatrix> Mass;
//IK, 7/15/14: needed for writing mass matrix out to matrix market file
EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> ftmp = outArgs.get_f();
#endif
if (W_out != Teuchos::null) {
W_out_crs = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_out, true);
#ifdef WRITE_MASS_MATRIX_TO_MM_FILE
//IK, 7/15/14: adding object to hold mass matrix to be written to matrix market file
Mass = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_out, true);
#endif
}
int test_var = 0;
if(test_var != 0){
std::cout << "The current solution length is: " << x->MyLength() << std::endl;
x->Print(std::cout);
}
// Get preconditioner operator, if requested
Teuchos::RCP<Epetra_Operator> WPrec_out;
if (outArgs.supports(OUT_ARG_WPrec)) WPrec_out = outArgs.get_WPrec();
//
// Compute the functions
//
bool f_already_computed = false;
// W matrix
if (W_out != Teuchos::null) {
app->computeGlobalJacobian(alpha, beta, omega, curr_time, x_dot.get(), x_dotdot.get(),*x,
sacado_param_vec, f_out.get(), *W_out_crs);
#ifdef WRITE_MASS_MATRIX_TO_MM_FILE
//IK, 7/15/14: write mass matrix to matrix market file
//Warning: to read this in to MATLAB correctly, code must be run in serial.
//Otherwise Mass will have a distributed Map which would also need to be read in to MATLAB for proper
//reading in of Mass.
app->computeGlobalJacobian(1.0, 0.0, 0.0, curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, ftmp.get(), *Mass);
EpetraExt::RowMatrixToMatrixMarketFile("mass.mm", *Mass);
EpetraExt::BlockMapToMatrixMarketFile("rowmap.mm", Mass->RowMap());
EpetraExt::BlockMapToMatrixMarketFile("colmap.mm", Mass->ColMap());
Teuchos::RCP<Teuchos::FancyOStream> out = Teuchos::VerboseObjectBase::getDefaultOStream();
#endif
f_already_computed=true;
if(test_var != 0){
//std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
//f_out->Print(std::cout);
std::cout << "The current Jacobian length is: " << W_out_crs->NumGlobalRows() << std::endl;
W_out_crs->Print(std::cout);
}
}
if (WPrec_out != Teuchos::null) {
app->computeGlobalJacobian(alpha, beta, omega, curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, f_out.get(), *Extra_W_crs);
f_already_computed=true;
if(test_var != 0){
//std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
//f_out->Print(std::cout);
std::cout << "The current preconditioner length is: " << Extra_W_crs->NumGlobalRows() << std::endl;
Extra_W_crs->Print(std::cout);
}
app->computeGlobalPreconditioner(Extra_W_crs, WPrec_out);
}
// scalar df/dp
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP<Epetra_MultiVector> dfdp_out =
outArgs.get_DfDp(i).getMultiVector();
if (dfdp_out != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DfDp(i).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[i],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int j=0; j<p_indexes.size(); j++)
p_vec->addParam(sacado_param_vec[i][p_indexes[j]].family,
sacado_param_vec[i][p_indexes[j]].baseValue);
}
app->computeGlobalTangent(0.0, 0.0, 0.0, curr_time, false, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, p_vec.get(),
NULL, NULL, NULL, NULL, f_out.get(), NULL,
dfdp_out.get());
f_already_computed=true;
if(test_var != 0){
std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
f_out->Print(std::cout);
}
}
}
// distributed df/dp
for (int i=0; i<num_dist_param_vecs; i++) {
Teuchos::RCP<Epetra_Operator> dfdp_out =
outArgs.get_DfDp(i+num_param_vecs).getLinearOp();
if (dfdp_out != Teuchos::null) {
Teuchos::RCP<DistributedParameterDerivativeOp> dfdp_op =
Teuchos::rcp_dynamic_cast<DistributedParameterDerivativeOp>(dfdp_out);
dfdp_op->set(curr_time, x_dotT, x_dotdotT, xT,
Teuchos::rcp(&sacado_param_vec,false));
}
}
// f
if (app->is_adjoint) {
Derivative f_deriv(f_out, DERIV_TRANS_MV_BY_ROW);
int response_index = 0; // need to add capability for sending this in
app->evaluateResponseDerivative(response_index, curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, NULL,
NULL, f_deriv, Derivative(), Derivative(), Derivative());
}
else {
if (f_out != Teuchos::null && !f_already_computed) {
app->computeGlobalResidual(curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, *f_out);
if(test_var != 0){
std::cout << "The current rhs length is: " << f_out->MyLength() << std::endl;
f_out->Print(std::cout);
}
}
}
// Response functions
for (int i=0; i<outArgs.Ng(); i++) {
//Set curr_time to final time at which response occurs.
if(num_time_deriv > 0)
curr_time = inArgs.get_t();
Teuchos::RCP<Epetra_Vector> g_out = outArgs.get_g(i);
//Declare Tpetra_Vector copy of g_out
Teuchos::RCP<Tpetra_Vector> g_outT;
bool g_computed = false;
Derivative dgdx_out = outArgs.get_DgDx(i);
Derivative dgdxdot_out = outArgs.get_DgDx_dot(i);
Derivative dgdxdotdot_out = outArgs.get_DgDx_dotdot(i);
// dg/dx, dg/dxdot
if (!dgdx_out.isEmpty() || !dgdxdot_out.isEmpty() || !dgdxdotdot_out.isEmpty() ) {
app->evaluateResponseDerivative(i, curr_time, x_dot.get(), x_dotdot.get(), *x,
sacado_param_vec, NULL,
g_out.get(), dgdx_out,
dgdxdot_out, dgdxdotdot_out, Derivative());
g_computed = true;
}
// dg/dp
for (int j=0; j<num_param_vecs; j++) {
Teuchos::RCP<Epetra_MultiVector> dgdp_out =
outArgs.get_DgDp(i,j).getMultiVector();
//Declare Tpetra copy of dgdp_out
Teuchos::RCP<Tpetra_MultiVector> dgdp_outT;
if (dgdp_out != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DgDp(i,j).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[j],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int k=0; k<p_indexes.size(); k++)
p_vec->addParam(sacado_param_vec[j][p_indexes[k]].family,
sacado_param_vec[j][p_indexes[k]].baseValue);
}
//create Tpetra copy of g_out, call it g_outT
if (g_out != Teuchos::null)
g_outT = Petra::EpetraVector_To_TpetraVectorNonConst(*g_out, commT);
//create Tpetra copy of dgdp_out, call it dgdp_outT
if (dgdp_out != Teuchos::null)
dgdp_outT = Petra::EpetraMultiVector_To_TpetraMultiVector(*dgdp_out, commT);
app->evaluateResponseTangentT(i, alpha, beta, omega, curr_time, false,
x_dotT.get(), x_dotdotT.get(), *xT,
sacado_param_vec, p_vec.get(),
NULL, NULL, NULL, NULL, g_outT.get(), NULL,
dgdp_outT.get());
//convert g_outT to Epetra_Vector g_out
if (g_out != Teuchos::null)
Petra::TpetraVector_To_EpetraVector(g_outT, *g_out, comm);
//convert dgdp_outT to Epetra_MultiVector dgdp_out
if (dgdp_out != Teuchos::null)
Petra::TpetraMultiVector_To_EpetraMultiVector(dgdp_outT, *dgdp_out, comm);
g_computed = true;
}
}
// Need to handle dg/dp for distributed p
for(int j=0; j<num_dist_param_vecs; j++) {
Derivative dgdp_out = outArgs.get_DgDp(i,j+num_param_vecs);
if (!dgdp_out.isEmpty()) {
dgdp_out.getMultiVector()->PutScalar(0.);
app->evaluateResponseDistParamDeriv(i, curr_time, x_dot.get(), x_dotdot.get(), *x, sacado_param_vec, dist_param_names[j], dgdp_out.getMultiVector().get());
}
}
if (g_out != Teuchos::null && !g_computed) {
//create Tpetra copy of g_out, call it g_outT
g_outT = Petra::EpetraVector_To_TpetraVectorNonConst(*g_out, commT);
app->evaluateResponseT(i, curr_time, x_dotT.get(), x_dotdotT.get(), *xT, sacado_param_vec,
*g_outT);
//convert g_outT to Epetra_Vector g_out
Petra::TpetraVector_To_EpetraVector(g_outT, *g_out, comm);
}
}
//
// Stochastic Galerkin
//
#ifdef ALBANY_SG
InArgs::sg_const_vector_t x_sg = inArgs.get_x_sg();
if (x_sg != Teuchos::null) {
app->init_sg(inArgs.get_sg_basis(),
inArgs.get_sg_quadrature(),
inArgs.get_sg_expansion(),
x_sg->productComm());
InArgs::sg_const_vector_t x_dot_sg = Teuchos::null;
InArgs::sg_const_vector_t x_dot_sg = Teuchos::null;
if(num_time_deriv > 0)
x_dotdot_sg = inArgs.get_x_dotdot_sg();
if(num_time_deriv > 1)
x_dotdot_sg = inArgs.get_x_dotdot_sg();
if (x_dot_sg != Teuchos::null || x_dotdot_sg != Teuchos::null) {
alpha = inArgs.get_alpha();
beta = inArgs.get_beta();
curr_time = inArgs.get_t();
}
if (x_dotdot_sg != Teuchos::null) {
omega = inArgs.get_omega();
}
InArgs::sg_const_vector_t epetra_p_sg = inArgs.get_p_sg(0);
Teuchos::Array<int> p_sg_index;
for (int i=0; i<num_param_vecs; i++) {
InArgs::sg_const_vector_t p_sg = inArgs.get_p_sg(i);
if (p_sg != Teuchos::null) {
p_sg_index.push_back(i);
for (int j=0; j<p_sg_vals[i].size(); j++) {
int num_sg_blocks = p_sg->size();
p_sg_vals[i][j].reset(app->getStochasticExpansion(), num_sg_blocks);
p_sg_vals[i][j].copyForWrite();
for (int l=0; l<num_sg_blocks; l++) {
p_sg_vals[i][j].fastAccessCoeff(l) = (*p_sg)[l][j];
}
}
}
}
OutArgs::sg_vector_t f_sg = outArgs.get_f_sg();
OutArgs::sg_operator_t W_sg = outArgs.get_W_sg();
bool f_sg_computed = false;
// W_sg
if (W_sg != Teuchos::null) {
Stokhos::VectorOrthogPoly<Epetra_CrsMatrix> W_sg_crs(W_sg->basis(),
W_sg->map());
for (int i=0; i<W_sg->size(); i++)
W_sg_crs.setCoeffPtr(
i,
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_sg->getCoeffPtr(i)));
app->computeGlobalSGJacobian(alpha, beta, omega, curr_time,
x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
f_sg.get(), W_sg_crs);
f_sg_computed = true;
}
// df/dp_sg
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > dfdp_sg
= outArgs.get_DfDp_sg(i).getMultiVector();
if (dfdp_sg != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DfDp_sg(i).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[i],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int j=0; j<p_indexes.size(); j++)
p_vec->addParam(sacado_param_vec[i][p_indexes[j]].family,
sacado_param_vec[i][p_indexes[j]].baseValue);
}
app->computeGlobalSGTangent(0.0, 0.0, 0.0, curr_time, false,
x_dot_sg.get(), x_dotdot_sg.get(),*x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
p_vec.get(), NULL, NULL, NULL, NULL,
f_sg.get(), NULL, dfdp_sg.get());
f_sg_computed = true;
}
}
if (f_sg != Teuchos::null && !f_sg_computed)
app->computeGlobalSGResidual(curr_time, x_dot_sg.get(), x_dotdot_sg.get(),*x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
*f_sg);
// Response functions
for (int i=0; i<outArgs.Ng(); i++) {
OutArgs::sg_vector_t g_sg = outArgs.get_g_sg(i);
bool g_sg_computed = false;
SGDerivative dgdx_sg = outArgs.get_DgDx_sg(i);
SGDerivative dgdxdot_sg = outArgs.get_DgDx_dot_sg(i);
SGDerivative dgdxdotdot_sg = outArgs.get_DgDx_dotdot_sg(i);
// dg/dx, dg/dxdot
if (!dgdx_sg.isEmpty() || !dgdxdot_sg.isEmpty() || !dgdxdotdot_sg.isEmpty()) {
app->evaluateSGResponseDerivative(
i, curr_time, x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
NULL, g_sg.get(), dgdx_sg,
dgdxdot_sg, dgdxdotdot_sg, SGDerivative());
g_sg_computed = true;
}
// dg/dp
for (int j=0; j<num_param_vecs; j++) {
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > dgdp_sg =
outArgs.get_DgDp_sg(i,j).getMultiVector();
if (dgdp_sg != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DgDp_sg(i,j).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[j],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int k=0; k<p_indexes.size(); k++)
p_vec->addParam(sacado_param_vec[j][p_indexes[k]].family,
sacado_param_vec[j][p_indexes[k]].baseValue);
}
app->evaluateSGResponseTangent(i, alpha, beta, omega, curr_time, false,
x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index,
p_sg_vals, p_vec.get(),
NULL, NULL, NULL, NULL, g_sg.get(),
NULL, dgdp_sg.get());
g_sg_computed = true;
}
}
if (g_sg != Teuchos::null && !g_sg_computed)
app->evaluateSGResponse(i, curr_time, x_dot_sg.get(), x_dotdot_sg.get(), *x_sg,
sacado_param_vec, p_sg_index, p_sg_vals,
*g_sg);
}
}
#endif
#ifdef ALBANY_ENSEMBLE
//
// Multi-point evaluation
//
mp_const_vector_t x_mp = inArgs.get_x_mp();
if (x_mp != Teuchos::null) {
mp_const_vector_t x_dot_mp = Teuchos::null;
mp_const_vector_t x_dotdot_mp = Teuchos::null;
if(num_time_deriv > 0)
x_dot_mp = inArgs.get_x_dot_mp();
if(num_time_deriv > 1)
x_dotdot_mp = inArgs.get_x_dotdot_mp();
if (x_dot_mp != Teuchos::null || x_dotdot_mp != Teuchos::null) {
alpha = inArgs.get_alpha();
//omega = inArgs.get_omega();
beta = inArgs.get_beta();
curr_time = inArgs.get_t();
}
if (x_dotdot_mp != Teuchos::null) {
omega = inArgs.get_omega();
}
Teuchos::Array<int> p_mp_index;
for (int i=0; i<num_param_vecs; i++) {
mp_const_vector_t p_mp = inArgs.get_p_mp(i);
if (p_mp != Teuchos::null) {
p_mp_index.push_back(i);
for (int j=0; j<p_mp_vals[i].size(); j++) {
int num_mp_blocks = p_mp->size();
p_mp_vals[i][j].reset(num_mp_blocks);
p_mp_vals[i][j].copyForWrite();
for (int l=0; l<num_mp_blocks; l++) {
p_mp_vals[i][j].fastAccessCoeff(l) = (*p_mp)[l][j];
}
}
}
}
mp_vector_t f_mp = outArgs.get_f_mp();
mp_operator_t W_mp = outArgs.get_W_mp();
bool f_mp_computed = false;
// W_mp
if (W_mp != Teuchos::null) {
Stokhos::ProductContainer<Epetra_CrsMatrix> W_mp_crs(W_mp->map());
for (int i=0; i<W_mp->size(); i++)
W_mp_crs.setCoeffPtr(
i,
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_mp->getCoeffPtr(i)));
app->computeGlobalMPJacobian(alpha, beta, omega, curr_time,
x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
f_mp.get(), W_mp_crs);
f_mp_computed = true;
}
// df/dp_mp
for (int i=0; i<num_param_vecs; i++) {
Teuchos::RCP< Stokhos::ProductEpetraMultiVector > dfdp_mp
= outArgs.get_DfDp_mp(i).getMultiVector();
if (dfdp_mp != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DfDp_mp(i).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[i],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int j=0; j<p_indexes.size(); j++)
p_vec->addParam(sacado_param_vec[i][p_indexes[j]].family,
sacado_param_vec[i][p_indexes[j]].baseValue);
}
app->computeGlobalMPTangent(0.0, 0.0, 0.0, curr_time, false,
x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
p_vec.get(), NULL, NULL, NULL, NULL,
f_mp.get(), NULL, dfdp_mp.get());
f_mp_computed = true;
}
}
if (f_mp != Teuchos::null && !f_mp_computed)
app->computeGlobalMPResidual(curr_time, x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
*f_mp);
// Response functions
for (int i=0; i<outArgs.Ng(); i++) {
mp_vector_t g_mp = outArgs.get_g_mp(i);
bool g_mp_computed = false;
MPDerivative dgdx_mp = outArgs.get_DgDx_mp(i);
MPDerivative dgdxdot_mp = outArgs.get_DgDx_dot_mp(i);
MPDerivative dgdxdotdot_mp = outArgs.get_DgDx_dotdot_mp(i);
// dg/dx, dg/dxdot
if (!dgdx_mp.isEmpty() || !dgdxdot_mp.isEmpty() || !dgdxdotdot_mp.isEmpty() ) {
app->evaluateMPResponseDerivative(
i, curr_time, x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
NULL, g_mp.get(), dgdx_mp,
dgdxdot_mp, dgdxdotdot_mp, MPDerivative());
g_mp_computed = true;
}
// dg/dp
for (int j=0; j<num_param_vecs; j++) {
Teuchos::RCP< Stokhos::ProductEpetraMultiVector > dgdp_mp =
outArgs.get_DgDp_mp(i,j).getMultiVector();
if (dgdp_mp != Teuchos::null) {
Teuchos::Array<int> p_indexes =
outArgs.get_DgDp_mp(i,j).getDerivativeMultiVector().getParamIndexes();
Teuchos::RCP<ParamVec> p_vec;
if (p_indexes.size() == 0)
p_vec = Teuchos::rcp(&sacado_param_vec[j],false);
else {
p_vec = Teuchos::rcp(new ParamVec);
for (int k=0; k<p_indexes.size(); k++)
p_vec->addParam(sacado_param_vec[j][p_indexes[k]].family,
sacado_param_vec[j][p_indexes[k]].baseValue);
}
app->evaluateMPResponseTangent(i, alpha, beta, omega, curr_time, false,
x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index,
p_mp_vals, p_vec.get(),
NULL, NULL, NULL, NULL, g_mp.get(),
NULL, dgdp_mp.get());
g_mp_computed = true;
}
}
if (g_mp != Teuchos::null && !g_mp_computed)
app->evaluateMPResponse(i, curr_time, x_dot_mp.get(), x_dotdot_mp.get(), *x_mp,
sacado_param_vec, p_mp_index, p_mp_vals,
*g_mp);
}
}
#endif
}
void
MockModelEval_D::
evalModel(const InArgs& inArgs, const OutArgs& outArgs) const
{
int proc = comm->MyPID();
//
// Deterministic calculation
//
// Parse InArgs
RCP<const Epetra_Vector> p1_in = inArgs.get_p(0);
if (p1_in == Teuchos::null)
p1_in = p1_init;
RCP<const Epetra_Vector> p2_in = inArgs.get_p(1);
if (p2_in == Teuchos::null)
p2_in = p2_init;
RCP<const Epetra_Vector> x_in = inArgs.get_x();
// Parse OutArgs
RCP<Epetra_Vector> f_out = outArgs.get_f();
if (f_out != Teuchos::null) {
double p = (*p1_in)[0];
double xi = (*p2_in)[0];
if (proc == 0) {
double x = (*x_in)[0];
(*f_out)[0] = x - p + xi;
}
}
RCP<Epetra_CrsMatrix> W_out =
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(outArgs.get_W());
if (W_out != Teuchos::null) {
if (proc == 0) {
double val = 1.0;
int i = 0;
W_out->ReplaceMyValues(i, 1, &val, &i);
}
}
RCP<Epetra_MultiVector> dfdp1 = outArgs.get_DfDp(0).getMultiVector();
if (dfdp1 != Teuchos::null) {
if (proc == 0)
(*dfdp1)[0][0] = -1.0;
}
RCP<Epetra_MultiVector> dfdp2 = outArgs.get_DfDp(1).getMultiVector();
if (dfdp2 != Teuchos::null) {
if (proc == 0)
(*dfdp2)[0][0] = 1.0;
}
RCP<Epetra_Vector> g_out = outArgs.get_g(0);
if (g_out != Teuchos::null) {
if (proc == 0) {
double x = (*x_in)[0];
(*g_out)[0] = 1.0 / x;
}
}
RCP<Epetra_MultiVector> dgdx = outArgs.get_DgDx(0).getMultiVector();
if (dgdx != Teuchos::null) {
if (proc == 0) {
double x = (*x_in)[0];
(*dgdx)[0][0] = -1.0 / (x*x);
}
}
RCP<Epetra_MultiVector> dgdp1 = outArgs.get_DgDp(0,0).getMultiVector();
if (dgdp1 != Teuchos::null) {
if (proc == 0) {
(*dgdp1)[0][0] = 0.0;
}
}
RCP<Epetra_MultiVector> dgdp2 = outArgs.get_DgDp(0,1).getMultiVector();
if (dgdp2 != Teuchos::null) {
if (proc == 0) {
(*dgdp2)[0][0] = 0.0;
}
}
//
// Stochastic calculation
//
#ifdef Piro_ENABLE_Stokhos
// Parse InArgs
RCP<const Stokhos::OrthogPolyBasis<int,double> > basis =
inArgs.get_sg_basis();
RCP<Stokhos::OrthogPolyExpansion<int,double> > expn =
inArgs.get_sg_expansion();
InArgs::sg_const_vector_t x_sg = inArgs.get_x_sg();
InArgs::sg_const_vector_t p1_sg = inArgs.get_p_sg(0);
InArgs::sg_const_vector_t p2_sg = inArgs.get_p_sg(1);
// Parse OutArgs
OutArgs::sg_vector_t f_sg = outArgs.get_f_sg();
if (f_sg != Teuchos::null && proc == 0) {
for (int block=0; block<f_sg->size(); block++) {
(*f_sg)[block][0] =
(*x_sg)[block][0] - (*p1_sg)[block][0] + (*p2_sg)[block][0];
}
}
OutArgs::sg_operator_t W_sg = outArgs.get_W_sg();
if (W_sg != Teuchos::null) {
W_sg->init(0.0);
Teuchos::RCP<Epetra_CrsMatrix> W =
Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_sg->getCoeffPtr(0),
true);
if (proc == 0) {
int i = 0;
double val = 1.0;
W->ReplaceMyValues(i, 1, &val, &i);
}
}
RCP<Stokhos::EpetraMultiVectorOrthogPoly> dfdp1_sg =
outArgs.get_DfDp_sg(0).getMultiVector();
if (dfdp1_sg != Teuchos::null) {
dfdp1_sg->init(0.0);
if (proc == 0) {
(*dfdp1_sg)[0][0][0] = -1.0;
}
}
RCP<Stokhos::EpetraMultiVectorOrthogPoly> dfdp2_sg =
outArgs.get_DfDp_sg(1).getMultiVector();
if (dfdp2_sg != Teuchos::null) {
dfdp2_sg->init(0.0);
if (proc == 0) {
(*dfdp2_sg)[0][0][0] = 1.0;
}
}
Stokhos::OrthogPolyApprox<int,double> x(basis);
if (x_sg != Teuchos::null && proc == 0) {
for (int i=0; i<basis->size(); i++) {
x[i] = (*x_sg)[i][0];
}
}
OutArgs::sg_vector_t g_sg = outArgs.get_g_sg(0);
if (g_sg != Teuchos::null && proc == 0) {
Stokhos::OrthogPolyApprox<int,double> xinv(basis);
expn->divide(xinv, 1.0, x);
for (int block=0; block<g_sg->size(); block++) {
(*g_sg)[block][0] = xinv[block];
}
}
RCP<Stokhos::EpetraMultiVectorOrthogPoly> dgdx_sg =
outArgs.get_DgDx_sg(0).getMultiVector();
if (dgdx_sg != Teuchos::null && proc == 0) {
Stokhos::OrthogPolyApprox<int,double> x2(basis), x2inv(basis);
expn->times(x2, x, x);
expn->divide(x2inv, -1.0, x2);
for (int block=0; block<dgdx_sg->size(); block++) {
(*dgdx_sg)[block][0][0] = x2inv[block];
}
}
RCP<Stokhos::EpetraMultiVectorOrthogPoly> dgdp1_sg =
outArgs.get_DgDp_sg(0,0).getMultiVector();
if (dgdp1_sg != Teuchos::null) {
dgdp1_sg->init(0.0);
}
RCP<Stokhos::EpetraMultiVectorOrthogPoly> dgdp2_sg =
outArgs.get_DgDp_sg(0,1).getMultiVector();
if (dgdp2_sg != Teuchos::null) {
dgdp2_sg->init(0.0);
}
#endif
}