void
Albany::SolutionAverageResponseFunction::
evaluateSGGradient(
const double current_time,
const Stokhos::EpetraVectorOrthogPoly* sg_xdot,
const Stokhos::EpetraVectorOrthogPoly& sg_x,
const Teuchos::Array<ParamVec>& p,
const Teuchos::Array<int>& sg_p_index,
const Teuchos::Array< Teuchos::Array<SGType> >& sg_p_vals,
ParamVec* deriv_p,
Stokhos::EpetraVectorOrthogPoly* sg_g,
Stokhos::EpetraMultiVectorOrthogPoly* sg_dg_dx,
Stokhos::EpetraMultiVectorOrthogPoly* sg_dg_dxdot,
Stokhos::EpetraMultiVectorOrthogPoly* sg_dg_dp)
{
// Evaluate response g
if (sg_g != NULL)
for (int i=0; i<sg_x.size(); i++)
sg_x[i].MeanValue(&(*sg_g)[i][0]);
// Evaluate dg/dx
if (sg_dg_dx != NULL)
(*sg_dg_dx)[0].PutScalar(1.0 / sg_x[0].GlobalLength());
// Evaluate dg/dxdot
if (sg_dg_dxdot != NULL)
sg_dg_dxdot->init(0.0);
// Evaluate dg/dp
if (sg_dg_dp != NULL)
sg_dg_dp->init(0.0);
}
void
Albany::SolutionAverageResponseFunction::
evaluateSGResponse(
const double current_time,
const Stokhos::EpetraVectorOrthogPoly* sg_xdot,
const Stokhos::EpetraVectorOrthogPoly& sg_x,
const Teuchos::Array<ParamVec>& p,
const Teuchos::Array<int>& sg_p_index,
const Teuchos::Array< Teuchos::Array<SGType> >& sg_p_vals,
Stokhos::EpetraVectorOrthogPoly& sg_g)
{
for (int i=0; i<sg_x.size(); i++)
sg_x[i].MeanValue(&sg_g[i][0]);
}
void
Albany::SolutionResponseFunction::
evaluateSGResponse(const double curr_time,
const Stokhos::EpetraVectorOrthogPoly* sg_xdot,
const Stokhos::EpetraVectorOrthogPoly* sg_xdotdot,
const Stokhos::EpetraVectorOrthogPoly& sg_x,
const Teuchos::Array<ParamVec>& p,
const Teuchos::Array<int>& sg_p_index,
const Teuchos::Array< Teuchos::Array<SGType> >& sg_p_vals,
Stokhos::EpetraVectorOrthogPoly& sg_g)
{
// Note that by doing the culling this way, instead of importing into
// sg_g directly using a product importer, it doesn't really matter that
// the product maps between sg_x and sg_g aren't consistent
for (int i=0; i<sg_g.size(); i++)
cullSolution(sg_x[i], sg_g[i]);
}
/** Copy from an adaptive vector to a set of blocked vectors
*/
void Stokhos::AdaptivityManager::copyFromAdaptiveVector(const Epetra_Vector & x,Stokhos::EpetraVectorOrthogPoly & x_sg) const
{
int numBlocks = x_sg.size();
Teuchos::RCP<EpetraExt::BlockVector> x_sg_bv = x_sg.getBlockVector();
// zero out determinstic vectors
for(int blk=0;blk<numBlocks;blk++)
x_sg_bv->GetBlock(blk)->PutScalar(0.0);
// copy from adapted vector to deterministic
for(std::size_t i=0;i<sg_basis_row_dof_.size();i++) {
int P_i = getRowStochasticBasisSize(i);
int localId = rowMap_->LID(getGlobalRowId(i,0));
for(int j=0;j<P_i;j++,localId++) {
int blk = sg_master_basis_->index(sg_basis_row_dof_[i]->term(j));
x_sg_bv->GetBlock(blk)->operator[](i) = x[localId];
}
}
}
void
Albany::SolutionAverageResponseFunction::
evaluateSGTangent(
const double alpha,
const double beta,
const double omega,
const double current_time,
bool sum_derivs,
const Stokhos::EpetraVectorOrthogPoly* sg_xdot,
const Stokhos::EpetraVectorOrthogPoly* sg_xdotdot,
const Stokhos::EpetraVectorOrthogPoly& sg_x,
const Teuchos::Array<ParamVec>& p,
const Teuchos::Array<int>& sg_p_index,
const Teuchos::Array< Teuchos::Array<SGType> >& sg_p_vals,
ParamVec* deriv_p,
const Epetra_MultiVector* Vx,
const Epetra_MultiVector* Vxdot,
const Epetra_MultiVector* Vxdotdot,
const Epetra_MultiVector* Vp,
Stokhos::EpetraVectorOrthogPoly* sg_g,
Stokhos::EpetraMultiVectorOrthogPoly* sg_JV,
Stokhos::EpetraMultiVectorOrthogPoly* sg_gp)
{
// Evaluate response g
if (sg_g != NULL)
for (int i=0; i<sg_x.size(); i++)
sg_x[i].MeanValue(&(*sg_g)[i][0]);
// Evaluate tangent of g = dg/dx*Vx + dg/dxdot*Vxdot + dg/dp*Vp
// If Vx == NULL, Vx is the identity
if (sg_JV != NULL) {
sg_JV->init(0.0);
if (Vx != NULL)
for (int j=0; j<Vx->NumVectors(); j++)
(*Vx)(j)->MeanValue(&(*sg_JV)[0][j][0]);
else
(*sg_JV)[0].PutScalar(alpha/sg_x[0].GlobalLength());
}
if (sg_gp != NULL)
sg_gp->init(0.0);
}