arma::Mat<ResultType>
ElementaryPotentialOperator<BasisFunctionType, KernelType, ResultType>::
evaluateAtPoints(
const GridFunction<BasisFunctionType, ResultType> &argument,
const arma::Mat<CoordinateType> &evaluationPoints,
const QuadratureStrategy &quadStrategy,
const EvaluationOptions &options) const {
if (evaluationPoints.n_rows != argument.grid()->dimWorld())
throw std::invalid_argument(
"ElementaryPotentialOperator::evaluateAtPoints(): "
"the number of coordinates of each evaluation point must be "
"equal to the dimension of the space containing the surface "
"on which the grid function 'argument' is defined");
if (options.evaluationMode() == EvaluationOptions::DENSE) {
std::unique_ptr<Evaluator> evaluator =
makeEvaluator(argument, quadStrategy, options);
// right now we don't bother about far and near field
// (this might depend on evaluation options)
arma::Mat<ResultType> result;
evaluator->evaluate(Evaluator::FAR_FIELD, evaluationPoints, result);
return result;
} else if (options.evaluationMode() == EvaluationOptions::ACA) {
AssembledPotentialOperator<BasisFunctionType, ResultType> assembledOp =
assemble(argument.space(), make_shared_from_ref(evaluationPoints),
quadStrategy, options);
return assembledOp.apply(argument);
} else
throw std::invalid_argument(
"ElementaryPotentialOperator::evaluateAtPoints(): "
"Invalid evaluation mode");
}
std::auto_ptr<typename ElementaryPotentialOperator<
BasisFunctionType, KernelType, ResultType>::Evaluator>
ElementaryPotentialOperator<BasisFunctionType, KernelType, ResultType>::
makeEvaluator(
const GridFunction<BasisFunctionType, ResultType>& argument,
const QuadratureStrategy& quadStrategy,
const EvaluationOptions& options) const
{
// Collect the standard set of data necessary for construction of
// evaluators and assemblers
typedef Fiber::RawGridGeometry<CoordinateType> RawGridGeometry;
typedef std::vector<const Fiber::Shapeset<BasisFunctionType>*> ShapesetPtrVector;
typedef std::vector<std::vector<ResultType> > CoefficientsVector;
typedef LocalAssemblerConstructionHelper Helper;
shared_ptr<RawGridGeometry> rawGeometry;
shared_ptr<GeometryFactory> geometryFactory;
shared_ptr<Fiber::OpenClHandler> openClHandler;
shared_ptr<ShapesetPtrVector> shapesets;
const Space<BasisFunctionType>& space = *argument.space();
shared_ptr<const Grid> grid = space.grid();
Helper::collectGridData(space,
rawGeometry, geometryFactory);
Helper::makeOpenClHandler(options.parallelizationOptions().openClOptions(),
rawGeometry, openClHandler);
Helper::collectShapesets(space, shapesets);
// In addition, get coefficients of argument's expansion in each element
const GridView& view = space.gridView();
const int elementCount = view.entityCount(0);
shared_ptr<CoefficientsVector> localCoefficients =
boost::make_shared<CoefficientsVector>(elementCount);
std::auto_ptr<EntityIterator<0> > it = view.entityIterator<0>();
for (int i = 0; i < elementCount; ++i) {
const Entity<0>& element = it->entity();
argument.getLocalCoefficients(element, (*localCoefficients)[i]);
it->next();
}
// Now create the evaluator
return quadStrategy.makeEvaluatorForIntegralOperators(
geometryFactory, rawGeometry,
shapesets,
make_shared_from_ref(kernels()),
make_shared_from_ref(trialTransformations()),
make_shared_from_ref(integral()),
localCoefficients,
openClHandler,
options.parallelizationOptions());
}