Homec4science
Diffusion LibMultiScale (master) Browse

libmultiscale/src/coupling/arlequin_template_tmpl.cc
84079b53ef6bmaster

Last Change
Raw File

arlequin_template_tmpl.cc
View Options

#include "arlequin_template.hh"
/* -------------------------------------------------------------------------- */
__BEGIN_LIBMULTISCALE__
INSTANCIATE_DISPATCH(ArlequinTemplate::buildAtomsRHS)
template <typename ContA>
void ArlequinTemplate::buildAtomsRHS(ContA &pointList) {
UInt at_index = 0;
constexpr UInt Dim = ContA::Dim;
for (auto &&at : pointList) {
VectorView<Dim>(&rhs[Dim * at_index]) -= at.velocity();
++at_index;
}
}
/* -------------------------------------------------------------------------- */
void ArlequinTemplate::solveConstraint() {
UInt Dim = spatial_dimension;
LM_ASSERT(size_constraint <= A.size(),
"overflow detected" << size_constraint << " > " << A.size());
LM_ASSERT(size_constraint * Dim <= rhs.size(), "overflow detected "
<< size_constraint * Dim
<< " > " << rhs.size());
for (UInt i = 0; i < size_constraint; ++i) {
rhs(i) /= A[i];
}
}
/* -------------------------------------------------------------------------- */
INSTANCIATE_DISPATCH(ArlequinTemplate::applyAtomsCorrection)
template <typename ContA>
void ArlequinTemplate::applyAtomsCorrection(ContA &pointList) {
constexpr UInt Dim = ContA::Dim;
LM_ASSERT(size_constraint == pointList.size(), "something bad is happening "
<< size_constraint << " "
<< pointList.size());
LM_ASSERT(pointList.size() == lambdas_point.size(),
"overflow detected " << pointList.size()
<< " != " << lambdas_point.size());
LM_ASSERT(pointList.size() * Dim == rhs.size(), "overflowdetected "
<< pointList.size() * Dim
<< " != " << rhs.size());
UInt i = 0;
for (auto &&at : pointList) {
LM_ASSERT(lambdas_point[i],
"weight associated with atom " << i << " is zero : abort");
at.velocity() += Vector<Dim>(rhs(i) / lambdas_point[i]);
++i;
}
}
/* --------------------------------------------------------------------------*/
INSTANCIATE_DISPATCH(ArlequinTemplate::computeContinuumWeights)
template <typename ContC>
[[gnu::noinline]] void ArlequinTemplate::computeContinuumWeights(ContC &mesh) {
this->weight_mesh.compute(mesh);
}
/* -------------------------------------------------------------------------- */
INSTANCIATE_DISPATCH(ArlequinTemplate::correctContinuumWeights)
template <typename ContC>
void ArlequinTemplate::correctContinuumWeights(ContC &meshList) {
lambdas_mesh.assign(weight_mesh.evalArrayOutput().size(), 0);
UInt j = 0;
for (auto &&n : meshList.getContainerNodes()) {
lambdas_mesh[j] = weight_mesh.evalArrayOutput()[j] * n.mass();
++j;
}
}
/* -------------------------------------------------------------------------- */
INSTANCIATE_DISPATCH(ArlequinTemplate::computeAtomWeights)
template <typename ContA>
void ArlequinTemplate::computeAtomWeights(ContA &points) {
this->weight_point.compute(points);
bridging_zone.attachVector(this->weight_point.evalArrayOutput());
}
/* -------------------------------------------------------------------------- */
INSTANCIATE_DISPATCH(ArlequinTemplate::correctAtomWeights)
template <typename ContA>
void ArlequinTemplate::correctAtomWeights(ContA &pointList) {
lambdas_point.assign(weight_point.evalArrayOutput().size(), 0);
this->bridging_zone.attachVector(lambdas_point);
LM_ASSERT(pointList.size() == lambdas_point.size(), "overflow detected");
LM_ASSERT(pointList.size() == weight_point.evalArrayOutput().size(),
"overflow detected");
UInt at_index = 0;
for (auto &&at : pointList) {
lambdas_point[at_index] =
weight_point.evalArrayOutput()[at_index] * at.mass();
++at_index;
}
}
/* -------------------------------------------------------------------------- */
__END_LIBMULTISCALE__
c4science · Help