static char help[] =
"...\n\n";
};
GAUSS>::OpGradGradSymTensorGradGrad<1, 1, SPACE_DIM, 0>;
-1;
auto source = [](
const double x,
const double y,
const double) {
return cos(2 * x * M_PI) * sin(2 * y * M_PI);
};
auto mat_D_ptr = boost::make_shared<MatrixDouble>(
a *
a, 1);
auto t_D = getFTensor4DdgFromMat<2, 2, 0>(*(mat_D_ptr));
constexpr
double t3 =
t *
t *
t;
constexpr
double A =
mu * t3 / 12;
constexpr
double B =
lambda * t3 / 12;
return mat_D_ptr;
};
std::array<std::vector<VectorInt>, 2>
std::array<std::vector<MatrixDouble>, 2>
std::array<std::vector<MatrixDouble>, 2>
};
public:
boost::shared_ptr<MatrixDouble> d_mat_ptr);
private:
boost::shared_ptr<FaceSideEle>
sideFEPtr;
boost::shared_ptr<MatrixDouble> dMatPtr;
};
private:
};
}
PETSC_NULL);
PETSC_NULL);
}
auto get_skin = [&]() {
MOAB_THROW(skin.find_skin(0, body_ents,
false, skin_ents));
skin_ents.merge(verts);
return skin_ents;
};
auto remove_dofs_from_problem = [&](
Range &&skin) {
CHKERR problem_mng->removeDofsOnEntities(
simple->getProblemName(),
"U",
skin, 0, 1);
};
CHKERR remove_dofs_from_problem(get_skin());
}
auto rule_lhs = [](
int,
int,
int p) ->
int {
return 2 * p; };
auto rule_rhs = [](
int,
int,
int p) ->
int {
return 2 * p; };
CHKERR pipeline_mng->setDomainLhsIntegrationRule(rule_lhs);
CHKERR pipeline_mng->setDomainRhsIntegrationRule(rule_rhs);
CHKERR pipeline_mng->setSkeletonLhsIntegrationRule(rule_2);
CHKERR pipeline_mng->setSkeletonRhsIntegrationRule(rule_2);
CHKERR pipeline_mng->setBoundaryLhsIntegrationRule(rule_2);
CHKERR pipeline_mng->setBoundaryRhsIntegrationRule(rule_2);
auto det_ptr = boost::make_shared<VectorDouble>();
auto jac_ptr = boost::make_shared<MatrixDouble>();
auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
auto base_mass_ptr = boost::make_shared<MatrixDouble>();
auto data_l2_ptr = boost::make_shared<EntitiesFieldData>(MBENTITYSET);
auto push_ho_direcatives = [&](auto &pipeline) {
BaseDerivatives::SecondDerivative, base_mass_ptr, data_l2_ptr,
};
auto push_jacobian = [&](auto &pipeline) {
pipeline.push_back(
};
push_ho_direcatives(pipeline_mng->getOpDomainLhsPipeline());
push_jacobian(pipeline_mng->getOpDomainLhsPipeline());
pipeline_mng->getOpDomainLhsPipeline().push_back(
pipeline_mng->getOpDomainRhsPipeline().push_back(
auto side_fe_ptr = boost::make_shared<FaceSideEle>(mField);
push_ho_direcatives(side_fe_ptr->getOpPtrVector());
push_jacobian(side_fe_ptr->getOpPtrVector());
pipeline_mng->getOpSkeletonLhsPipeline().push_back(
}
auto ksp_solver = pipeline_mng->createKSP();
CHKERR KSPSetFromOptions(ksp_solver);
CHKERR VecGhostUpdateBegin(
D, INSERT_VALUES, SCATTER_FORWARD);
CHKERR VecGhostUpdateEnd(
D, INSERT_VALUES, SCATTER_FORWARD);
}
pipeline_mng->getDomainLhsFE().reset();
pipeline_mng->getSkeletonRhsFE().reset();
pipeline_mng->getSkeletonLhsFE().reset();
pipeline_mng->getBoundaryRhsFE().reset();
pipeline_mng->getBoundaryLhsFE().reset();
auto post_proc_fe = boost::make_shared<PostProcEle>(mField);
auto u_ptr = boost::make_shared<VectorDouble>();
post_proc_fe->getOpPtrVector().push_back(
post_proc_fe->getOpPtrVector().push_back(
new OpPPMap(post_proc_fe->getPostProcMesh(),
post_proc_fe->getMapGaussPts(),
{{"U", u_ptr}},
{}, {}, {}
)
);
pipeline_mng->getDomainRhsFE() = post_proc_fe;
CHKERR pipeline_mng->loopFiniteElements();
CHKERR post_proc_fe->writeFile(
"out_result.h5m");
}
}
int main(
int argc,
char *argv[]) {
const char param_file[] = "param_file.petsc";
auto core_log = logging::core::get();
core_log->add_sink(LogManager::createSink(LogManager::getStrmWorld(), "PL"));
LogManager::setLog("PL");
try {
DMType dm_name = "DMMOFEM";
}
}
std::string col_field_name)
const auto nb_in_loop = getFEMethod()->nInTheLoop;
auto clear = [](auto nb) {
};
areaMap[nb_in_loop] = getMeasure();
if (!nb_in_loop) {
clear(0);
clear(1);
}
}
if (nb_dofs) {
data.
getN(BaseDerivatives::FirstDerivative));
data.
getN(BaseDerivatives::SecondDerivative));
}
}
template <
typename T>
inline auto get_ntensor(T &base_mat) {
&*base_mat.data().begin());
};
template <
typename T>
inline auto get_ntensor(T &base_mat,
int gg,
int bb) {
double *ptr = &base_mat(gg, bb);
};
double *ptr = &*base_mat.data().begin();
return getFTensor1FromPtr<2>(ptr);
};
template <typename T>
double *ptr = &base_mat(gg, 2 * bb);
return getFTensor1FromPtr<2>(ptr);
};
double *ptr = &*base_mat.data().begin();
};
template <typename T>
double *ptr = &base_mat(gg, 4 * bb);
};
boost::shared_ptr<MatrixDouble> mat_d_ptr)
dMatPtr(mat_d_ptr) {}
const auto in_the_loop =
auto t_normal = getFTensor1Normal();
auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*
dMatPtr);
const size_t nb_integration_pts = getGaussPts().size2();
const double beta =
static_cast<double>(
nitsche) / (in_the_loop + 1);
auto integrate = [&](auto sense_row, auto &row_ind, auto &row_diff,
auto &row_diff2, auto sense_col, auto &col_ind,
auto &col_diff, auto &col_diff2) {
const auto nb_rows = row_ind.size();
const auto nb_cols = col_ind.size();
const auto nb_row_base_functions = row_diff.size2() /
SPACE_DIM;
if (nb_cols) {
locMat.resize(nb_rows, nb_cols,
false);
auto t_w = getFTensor0IntegrationWeight();
for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
const double alpha = getMeasure() * t_w;
auto t_mat =
locMat.data().begin();
size_t rr = 0;
for (; rr != nb_rows; ++rr) {
t_mv(
i,
j) = t_D(
i,
j,
k,
l) * t_diff2_row_base(
k,
l);
t_vn_plus(
i,
j) = beta * (
phi * t_mv(
i,
j) / p);
t_vn(
i,
j) = (t_diff_row_base(
j) * (t_normal(
i) * sense_row)) -
for (size_t cc = 0; cc != nb_cols; ++cc) {
t_mu(
i,
j) = t_D(
i,
j,
k,
l) * t_diff2_col_base(
k,
l);
t_un(
i,
j) = -p * ((t_diff_col_base(
j) * (t_normal(
i) * sense_col) -
*t_mat -= alpha * (t_vn(
i,
j) * t_un(
i,
j));
*t_mat -= alpha * (t_vn_plus(
i,
j) * (beta * t_mu(
i,
j)));
++t_diff_col_base;
++t_diff2_col_base;
++t_mat;
}
++t_diff_row_base;
++t_diff2_row_base;
}
for (; rr < nb_row_base_functions; ++rr) {
++t_diff_row_base;
++t_diff2_row_base;
}
++t_w;
}
col_ind.size(), &*col_ind.begin(),
&*
locMat.data().begin(), ADD_VALUES);
}
};
);
}
}
}
}
}