FunctionalEvaluator::FunctionalEvaluator(const Mesh& mesh,
const Expr& integral,
const Expr& bcs,
const Expr& vars,
const Expr& varEvalPts,
const Expr& fields,
const Expr& fieldValues,
const VectorType<double>& vectorType)
: assembler_(),
varValues_(varEvalPts),
vecType_(vectorType),
gradient_(1)
{
Array<Expr> f = tuple(fields.flatten());
Array<Expr> f0 = tuple(fieldValues.flatten());
Array<Expr> v = tuple(vars.flatten());
Array<Expr> v0 = tuple(varEvalPts.flatten());
Expr params;
RCP<EquationSet> eqnSet
= rcp(new EquationSet(integral, bcs, v, v0, params, params, f, f0));
assembler_ = rcp(new Assembler(mesh, eqnSet, tuple(vectorType), tuple(vectorType), false));
}
DerivSet SymbPreprocessor::setupSensitivities(const Expr& expr,
const Expr& tests,
const Expr& unks,
const Expr& unkEvalPts,
const Expr& unkParams,
const Expr& unkParamEvalPts,
const Expr& fixedParams,
const Expr& fixedParamEvalPts,
const Expr& fixedFields,
const Expr& fixedFieldEvalPts,
const EvalContext& context,
const ComputationType& compType)
{
Expr zero;
Expr v = tests.flatten();
Array<Expr> z(v.size());
for (int i=0; i<v.size(); i++) z[i] = new ZeroExpr();
zero = new ListExpr(z);
return setupVariations(expr,
tests, zero,
unks, unkEvalPts,
unkParams, unkParamEvalPts,
fixedFields, fixedFieldEvalPts,
fixedParams, fixedParamEvalPts,
context, compType);
}
TestEvalMediator::TestEvalMediator(const Expr& fields)
: AbstractEvalMediator(),
x_(),
funcIdToFieldNumberMap_(),
fields_(fields.totalSize()),
fieldNames_(fields.totalSize())
{
EvalManager::stack().setVecSize(1);
Expr f = fields.flatten();
for (int i=0; i<f.size(); i++)
{
const DiscreteFuncElement* u0
= dynamic_cast<const DiscreteFuncElement*>(f[i].ptr().get());
TEUCHOS_TEST_FOR_EXCEPTION(u0 == 0, std::logic_error,
"TestEvalMediator ctor: field argument "
<< f[i] << " is not a discrete function");
funcIdToFieldNumberMap_.put(u0->fid().dofID(), i);
RCP<const DiscreteFuncDataStub> data = u0->commonData();
const TestDiscreteFuncData* tdfd
= dynamic_cast<const TestDiscreteFuncData*>(data.get());
TEUCHOS_TEST_FOR_EXCEPTION(tdfd==0, std::logic_error,
"df " << f[i] << " is not a TestDiscreteFunction");
TEUCHOS_TEST_FOR_EXCEPTION(tdfd==0, std::logic_error,
"TestEvalMediator ctor: field argument "
<< f[i] << " is not a TestDiscreteFunction");
fields_[i] = tdfd->field();
fieldNames_[i] = f[i].toString();
}
}
Expr Expr::flattenSpectral() const
{
Array<Expr> rtn(size());
for (int i=0; i<size(); i++)
{
if ((*this)[i].size() == 1)
{
const SpectralExpr* se
= dynamic_cast<const SpectralExpr*>((*this)[i][0].ptr().get());
if (se != 0)
{
int nt = se->getSpectralBasis().nterms();
Array<Expr> e(nt);
for (int j=0; j<nt; j++)
{
e[j] = se->getCoeff(j);
}
rtn[i] = new ListExpr(e);
}
else
{
rtn[i] = (*this)[i];
}
}
else
{
rtn[i] = (*this)[i].flattenSpectral();
}
}
Expr r = new ListExpr(rtn);
return r.flatten();
}
DerivSet SymbPreprocessor::setupVariations(const Expr& expr,
const Expr& vars,
const Expr& varEvalPts,
const Expr& unks,
const Expr& unkEvalPts,
const Expr& unkParams,
const Expr& unkParamEvalPts,
const Expr& fixedFields,
const Expr& fixedFieldEvalPts,
const Expr& fixedParams,
const Expr& fixedParamEvalPts,
const EvalContext& context,
const ComputationType& compType)
{
TimeMonitor t(preprocTimer());
Tabs tab;
const EvaluatableExpr* e
= dynamic_cast<const EvaluatableExpr*>(expr.ptr().get());
Array<Set<MultiSet<int> > > funcDerivs(3);
Array<Set<MultiIndex> > spatialDerivs(3);
int verb=context.setupVerbosity();
SUNDANCE_BANNER1(verb, tab, "in setupVariations()");
verbosity<EvaluatableExpr>() = verb;
SUNDANCE_MSG1(verb,
tab << "************ setting up variations of expr: "
<< expr
<< std::endl << tab << "context is " << context
<< std::endl << tab << "conp type is " << compType
<< std::endl << tab << "vars are " << vars
<< std::endl << tab << "unks are " << unks
<< std::endl << tab << "unk parameters " << unkParams
<< std::endl << tab << "fixed parameters " << fixedParams
<< std::endl << tab << "the eval points for the vars are "
<< varEvalPts
<< std::endl << tab << "the eval points for the unks are "
<< unkEvalPts
<< std::endl << tab
<< "the eval points for the unknown parameters are "
<< unkParamEvalPts
<< std::endl << tab
<< "the eval points for the fixed parameters are "
<< fixedParamEvalPts
<< tab << std::endl);
TEUCHOS_TEST_FOR_EXCEPTION(e==0, std::logic_error,
"Non-evaluatable expr " << expr.toString()
<< " given to SymbPreprocessor::setupExpr()");
/* make flat lists of variations, unknowns, parameters, and fixed fields */
Expr v = vars.flatten();
Expr v0 = varEvalPts.flatten();
Expr u = unks.flatten();
Expr u0 = unkEvalPts.flatten();
Expr alpha = unkParams.flatten();
Expr alpha0 = unkParamEvalPts.flatten();
Expr beta = fixedParams.flatten();
Expr beta0 = fixedParamEvalPts.flatten();
Expr f = fixedFields.flatten();
Expr f0 = fixedFieldEvalPts.flatten();
Set<int> varID = processInputFuncs<SymbolicFuncElement>(v, v0);
Set<int> unkID = processInputFuncs<UnknownFuncElement>(u, u0);
Set<int> fixedID = processInputFuncs<UnknownFuncElement>(f, f0);
Set<int> unkParamID
= processInputParams<UnknownParameterElement>(alpha, alpha0);
Set<int> fixedParamID
= processInputParams<UnknownParameterElement>(beta, beta0);
/* put together the set of functions that are active differentiation
* variables */
SUNDANCE_MSG2(verb, tab << "forming active set");
Array<Sundance::Set<MultiSet<int> > > activeFuncIDs(3);
if (context.needsDerivOrder(0)) activeFuncIDs[0].put(MultiSet<int>());
if (context.topLevelDiffOrder() >= 1)
{
for (Set<int>::const_iterator i=varID.begin(); i != varID.end(); i++)
{
if (context.needsDerivOrder(1)) activeFuncIDs[1].put(makeMultiSet<int>(*i));
if (context.topLevelDiffOrder()==2)
{
for (Set<int>::const_iterator j=unkID.begin(); j != unkID.end(); j++)
{
activeFuncIDs[2].put(makeMultiSet<int>(*i, *j));
}
if (compType==MatrixAndVector)
{
for (Set<int>::const_iterator
j=unkParamID.begin(); j != unkParamID.end(); j++)
{
activeFuncIDs[2].put(makeMultiSet<int>(*i, *j));
}
}
else if (compType==Sensitivities)
{
for (Set<int>::const_iterator
j=fixedParamID.begin(); j != fixedParamID.end(); j++)
{
activeFuncIDs[2].put(makeMultiSet<int>(*i, *j));
}
}
}
}
}
SUNDANCE_MSG1(verb, tab << std::endl << tab
<< " ************* Finding nonzeros for expr " << std::endl << tab);
for (int i=0; i<=context.topLevelDiffOrder(); i++)
{
Tabs tab2;
SUNDANCE_MSG4(verb, tab2 << "diff order=" << i << ", active funcs="
<< activeFuncIDs[i]);
}
Set<MultiIndex> miSet;
miSet.put(MultiIndex());
e->registerSpatialDerivs(context, miSet);
SUNDANCE_MSG2(verb,
tab << std::endl << tab
<< " ************* finding required functions" << std::endl << tab);
SUNDANCE_MSG2(verb,
tab << "activeFuncIDs are = " << activeFuncIDs);
SUNDANCE_MSG2(verb,
tab << "spatial derivs are = " << spatialDerivs);
Array<Set<MultipleDeriv> > RInput
= e->computeInputR(context, activeFuncIDs, spatialDerivs);
SUNDANCE_MSG3(verb,
tab << std::endl << tab
<< " ************* Top-level required funcs are " << RInput << std::endl << tab);
SUNDANCE_MSG2(verb,
tab << std::endl << tab
<< " ************* Calling determineR()" << std::endl << tab);
e->determineR(context, RInput);
SUNDANCE_MSG1(verb,
tab << std::endl << tab
<< " ************* Finding sparsity structure " << std::endl << tab);
DerivSet derivs = e->sparsitySuperset(context)->derivSet();
SUNDANCE_MSG1(verb,
tab << std::endl << tab
<< "Nonzero deriv set = " << derivs);
SUNDANCE_MSG1(verb,
tab << std::endl << tab
<< " ************* Setting up evaluators for expr " << std::endl << tab);
int saveVerb = context.setupVerbosity();
context.setSetupVerbosity(0);
e->setupEval(context);
if (verb>1)
{
SUNDANCE_MSG1(verb,
tab << std::endl << tab
<< " ************* Nonzeros are:");
e->displayNonzeros(Out::os(), context);
}
context.setSetupVerbosity(saveVerb);
return derivs;
}
