18static auto cmp_uid_lo(
const boost::weak_ptr<FieldEntity> &a,
const UId &b) {
19 if (
auto a_ptr =
a.lock()) {
20 if (a_ptr->getLocalUniqueId() < b)
29static auto cmp_uid_hi(
const UId &b,
const boost::weak_ptr<FieldEntity> &a) {
30 if (
auto a_ptr =
a.lock()) {
31 if (b < a_ptr->getLocalUniqueId())
43 mField(m_field), getRuleHook(0), setRuleHook(0),
61 dataOnElement[
HCURL]),
67 dataNoField(*dataOnElement[
NOFIELD].get()),
68 dataH1(*dataOnElement[
H1].get()), dataHcurl(*dataOnElement[
HCURL].get()),
69 dataHdiv(*dataOnElement[
HDIV].get()), dataL2(*dataOnElement[
L2].get()),
70 lastEvaluatedElementEntityType(MBMAXTYPE), sidePtrFE(nullptr),
71 refinePtrFE(nullptr) {
86 boost::ptr_vector<EntitiesFieldData::EntData> &data)
const {
91 if (sit != side_table.end()) {
93 for (; sit != hi_sit; ++sit) {
94 if (
const auto side_number = (*sit)->side_number; side_number >= 0) {
95 const int brother_side_number = (*sit)->brother_side_number;
96 const int sense = (*sit)->sense;
98 data[side_number].getSense() = sense;
99 if (brother_side_number != -1)
100 data[brother_side_number].getSense() = sense;
109template <
typename ENTMULTIINDEX>
112 for (
auto ent_field_weak_ptr : multi_index)
113 if (
auto e = ent_field_weak_ptr.lock()) {
114 const int order = e->getMaxOrder();
115 max_order = (max_order <
order) ?
order : max_order;
123 if (
auto ptr = e.lock()) {
124 const int order = ptr->getMaxOrder();
125 max_order = (max_order <
order) ?
order : max_order;
141 boost::ptr_vector<EntitiesFieldData::EntData> &data)
const {
144 auto set_order = [&]() {
148 for (
unsigned int s = 0; s != data.size(); ++s)
149 data[s].getOrder() = 0;
154 r.first != r.second; ++r.first) {
156 const auto field_bit_number = (*r.first)->getBitNumber();
159 auto lo = std::lower_bound(data_field_ent.begin(), data_field_ent.end(),
161 if (lo != data_field_ent.end()) {
165 std::upper_bound(lo, data_field_ent.end(), hi_uid,
cmp_uid_hi);
166 for (; lo != hi; ++lo) {
168 if (
auto ptr = lo->lock()) {
171 auto sit = side_table.find(e.getEnt());
172 if (sit != side_table.end()) {
174 if (
const auto side_number = side->side_number;
177 auto &dat = data[side_number];
179 dat.getOrder() > ent_order ? dat.getOrder() : ent_order;
183 "Entity on side of the element not found");
192 auto set_order_on_brother = [&]() {
197 if (sit != side_table.end()) {
199 for (; sit != hi_sit; ++sit) {
200 const int brother_side_number = (*sit)->brother_side_number;
201 if (brother_side_number != -1) {
202 const int side_number = (*sit)->side_number;
203 data[brother_side_number].getOrder() = data[side_number].getOrder();
211 CHKERR set_order_on_brother();
218template <
typename EXTRACTOR>
222 EXTRACTOR &&extractor)
const {
230 if ((*field_it)->getBitNumber() != bit_number)
234 bit_number, get_id_for_min_type<MBVERTEX>());
235 auto lo = std::lower_bound(ents_field.begin(), ents_field.end(), lo_uid,
237 if (lo != ents_field.end()) {
239 bit_number, get_id_for_max_type<MBVERTEX>());
240 auto hi = std::upper_bound(lo, ents_field.end(), hi_uid,
cmp_uid_hi);
243 const int nb_dofs_on_vert = (*field_it)->getNbOfCoeffs();
244 const int max_nb_dofs = nb_dofs_on_vert * num_nodes;
247 for (
auto it = lo; it != hi; ++it) {
248 if (
auto e = it->lock()) {
249 if (
auto cache = extractor(e).lock()) {
251 nb_dofs += std::distance(
cache->loHi[0],
cache->loHi[1]);
259 nodes_indices.resize(max_nb_dofs,
false);
260 local_nodes_indices.resize(max_nb_dofs,
false);
262 nodes_indices.resize(0,
false);
263 local_nodes_indices.resize(0,
false);
266 if (nb_dofs != max_nb_dofs) {
267 std::fill(nodes_indices.begin(), nodes_indices.end(), -1);
268 std::fill(local_nodes_indices.begin(), local_nodes_indices.end(), -1);
271 for (
auto it = lo; it != hi; ++it) {
272 if (
auto e = it->lock()) {
273 auto side_ptr = e->getSideNumberPtr();
274 if (
const auto side_number = side_ptr->side_number;
276 const auto brother_side_number = side_ptr->brother_side_number;
277 if (
auto cache = extractor(e).lock()) {
278 for (
auto dit =
cache->loHi[0]; dit !=
cache->loHi[1]; ++dit) {
280 const int idx = dof.getPetscGlobalDofIdx();
281 const int local_idx = dof.getPetscLocalDofIdx();
283 side_number * nb_dofs_on_vert + dof.getDofCoeffIdx();
284 nodes_indices[pos] = idx;
285 local_nodes_indices[pos] = local_idx;
286 if (brother_side_number != -1) {
287 const int elem_idx = brother_side_number * nb_dofs_on_vert +
288 (*dit)->getDofCoeffIdx();
289 nodes_indices[elem_idx] = idx;
290 local_nodes_indices[elem_idx] = local_idx;
298 nodes_indices.resize(0,
false);
299 local_nodes_indices.resize(0,
false);
303 nodes_indices.resize(0,
false);
304 local_nodes_indices.resize(0,
false);
312 const int bit_number)
const {
315 boost::weak_ptr<EntityCacheNumeredDofs>
316 operator()(boost::shared_ptr<FieldEntity> &e) {
317 return e->entityCacheRowDofs;
329 const int bit_number)
const {
332 boost::weak_ptr<EntityCacheNumeredDofs>
333 operator()(boost::shared_ptr<FieldEntity> &e) {
334 return e->entityCacheColDofs;
344template <
typename EXTRACTOR>
348 const EntityType type_hi, EXTRACTOR &&extractor)
const {
353 dat.getIndices().resize(0,
false);
354 dat.getLocalIndices().resize(0,
false);
360 auto lo = std::lower_bound(ents_field.begin(), ents_field.end(), lo_uid,
362 if (lo != ents_field.end()) {
365 auto hi = std::upper_bound(lo, ents_field.end(), hi_uid,
cmp_uid_hi);
368 std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;
370 for (
auto it = lo; it != hi; ++it)
371 if (
auto e = it->lock()) {
374 auto side_ptr = e->getSideNumberPtr();
375 if (
const auto side = side_ptr->side_number; side >= 0) {
376 const auto nb_dofs_on_ent = e->getNbDofsOnEnt();
377 const auto brother_side = side_ptr->brother_side_number;
379 auto &ent_field_indices = dat.getIndices();
380 auto &ent_field_local_indices = dat.getLocalIndices();
382 ent_field_indices.resize(nb_dofs_on_ent,
false);
383 ent_field_local_indices.resize(nb_dofs_on_ent,
false);
384 std::fill(ent_field_indices.data().begin(),
385 ent_field_indices.data().end(), -1);
386 std::fill(ent_field_local_indices.data().begin(),
387 ent_field_local_indices.data().end(), -1);
389 if (
auto cache = extractor(e).lock()) {
390 for (
auto dit =
cache->loHi[0]; dit !=
cache->loHi[1]; ++dit) {
391 const int idx = (*dit)->getEntDofIdx();
392 ent_field_indices[idx] = (*dit)->getPetscGlobalDofIdx();
393 ent_field_local_indices[idx] = (*dit)->getPetscLocalDofIdx();
397 if (brother_side != -1) {
399 dat_brother.getIndices().resize(nb_dofs_on_ent,
false);
400 dat_brother.getLocalIndices().resize(nb_dofs_on_ent,
false);
401 noalias(dat_brother.getIndices()) = dat.getIndices();
402 noalias(dat_brother.getLocalIndices()) = dat.getLocalIndices();
417 boost::weak_ptr<EntityCacheNumeredDofs>
418 operator()(boost::shared_ptr<FieldEntity> &e) {
419 return e->entityCacheRowDofs;
432 boost::weak_ptr<EntityCacheNumeredDofs>
433 operator()(boost::shared_ptr<FieldEntity> &e) {
434 return e->entityCacheColDofs;
443 const int bit_number, boost::shared_ptr<FENumeredDofEntity_multiIndex> dofs,
450 indices.resize(std::distance(dit, hi_dit));
451 for (; dit != hi_dit; dit++) {
452 int idx = (*dit)->getPetscGlobalDofIdx();
453 indices[(*dit)->getDofCoeffIdx()] = idx;
460 const int bit_number)
const {
465 "data.dataOnEntities[MBENTITYSET] is empty");
475 const int bit_number)
const {
480 "data.dataOnEntities[MBENTITYSET] is empty");
499 nodes_indices.resize(field_struture->
getNbOfCoeffs() * num_nodes,
false);
500 std::fill(nodes_indices.begin(), nodes_indices.end(), -1);
504 auto siit = side_table.get<1>().lower_bound(boost::make_tuple(MBVERTEX, 0));
506 side_table.get<1>().lower_bound(boost::make_tuple(MBVERTEX, 10000));
509 for (; siit != hi_siit; siit++, nn++) {
510 if (siit->get()->side_number >= 0) {
517 for (; dit != hi_dit; dit++) {
518 nodes_indices[siit->get()->side_number * (*dit)->getNbOfCoeffs() +
519 (*dit)->getDofCoeffIdx()] =
520 (*dit)->getPetscGlobalDofIdx();
525 nodes_indices.resize(0,
false);
541 side_table.get<1>().lower_bound(boost::make_tuple(type, side_number));
543 side_table.get<1>().upper_bound(boost::make_tuple(type, side_number));
545 for (; siit != hi_siit; siit++) {
546 if (siit->get()->side_number >= 0) {
554 indices.resize(std::distance(dit, hi_dit));
555 for (; dit != hi_dit; dit++) {
557 indices[(*dit)->getEntDofIdx()] = (*dit)->getPetscGlobalDofIdx();
576 type, side_number, indices);
590 type, side_number, indices);
600 for (
auto &dat : data->dataOnEntities) {
601 for (
auto &ent_dat : dat) {
602 ent_dat.getEntDataBitRefLevel().clear();
609 for (
auto it : field_ents) {
610 if (
auto e = it.lock()) {
614 const signed char side = e->getSideNumberPtr()->side_number;
617 if (type == MBVERTEX) {
618 auto &dat = data->dataOnEntities[type][0];
620 dat.getEntDataBitRefLevel()[side] = e->getBitRefLevel();
622 auto &dat = data->dataOnEntities[type][side];
623 dat.getEntDataBitRefLevel().resize(1,
false);
624 dat.getEntDataBitRefLevel()[0] = e->getBitRefLevel();
630 auto &dat = data->dataOnEntities[MBENTITYSET][0];
631 dat.getEntDataBitRefLevel().resize(1,
false);
632 dat.getEntDataBitRefLevel()[0] = e->getBitRefLevel();
643 const int bit_number)
const {
645 auto get_nodes_field_data = [&](
VectorDouble &nodes_data,
652 nodes_data.resize(0,
false);
653 nodes_dofs.resize(0,
false);
654 field_entities.resize(0,
false);
661 if ((*field_it)->getBitNumber() != bit_number)
664 const int nb_dofs_on_vert = (*field_it)->getNbOfCoeffs();
665 space = (*field_it)->getSpace();
666 base = (*field_it)->getApproxBase();
670 bit_number, get_id_for_min_type<MBVERTEX>());
671 auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
673 if (lo != field_ents.end()) {
675 bit_number, get_id_for_max_type<MBVERTEX>());
676 auto hi = std::upper_bound(lo, field_ents.end(), hi_uid,
cmp_uid_hi);
680 for (
auto it = lo; it != hi; ++it) {
681 if (
auto e = it->lock()) {
682 if (
auto cache = e->entityCacheDataDofs.lock()) {
684 nb_dofs += std::distance(
cache->loHi[0],
cache->loHi[1]);
694 bb_node_order.resize(num_nodes,
false);
695 bb_node_order.clear();
696 const int max_nb_dofs = nb_dofs_on_vert * num_nodes;
697 nodes_data.resize(max_nb_dofs,
false);
698 nodes_dofs.resize(max_nb_dofs,
false);
699 field_entities.resize(num_nodes,
false);
700 std::fill(nodes_data.begin(), nodes_data.end(), 0);
701 std::fill(nodes_dofs.begin(), nodes_dofs.end(),
nullptr);
702 std::fill(field_entities.begin(), field_entities.end(),
nullptr);
704 std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;
706 for (
auto it = lo; it != hi; ++it) {
707 if (
auto e = it->lock()) {
708 const auto &sn = e->getSideNumberPtr();
711 if (
const auto side_number = sn->side_number;
713 const int brother_side_number = sn->brother_side_number;
715 field_entities[side_number] = e.get();
716 if (brother_side_number != -1) {
717 brother_ents_vec.emplace_back(e);
718 field_entities[side_number] = field_entities[side_number];
721 bb_node_order[side_number] = e->getMaxOrder();
722 int pos = side_number * nb_dofs_on_vert;
723 auto ent_filed_data_vec = e->getEntFieldData();
724 if (
auto cache = e->entityCacheDataDofs.lock()) {
725 for (
auto dit =
cache->loHi[0]; dit !=
cache->loHi[1];
727 const auto dof_idx = (*dit)->getEntDofIdx();
728 nodes_data[pos + dof_idx] = ent_filed_data_vec[dof_idx];
729 nodes_dofs[pos + dof_idx] =
737 for (
auto &it : brother_ents_vec) {
738 if (
const auto e = it.lock()) {
740 const int side_number = sn->side_number;
741 const int brother_side_number = sn->brother_side_number;
742 bb_node_order[brother_side_number] = bb_node_order[side_number];
743 int pos = side_number * nb_dofs_on_vert;
744 int brother_pos = brother_side_number * nb_dofs_on_vert;
745 for (
int ii = 0; ii != nb_dofs_on_vert; ++ii) {
746 nodes_data[brother_pos] = nodes_data[pos];
747 nodes_dofs[brother_pos] = nodes_dofs[pos];
761 return get_nodes_field_data(
779 dat.getFieldData().resize(0,
false);
780 dat.getFieldDofs().resize(0,
false);
781 dat.getFieldEntities().resize(0,
false);
788 auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
790 if (lo != field_ents.end()) {
793 auto hi = std::upper_bound(lo, field_ents.end(), hi_uid,
cmp_uid_hi);
796 std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;
798 for (
auto it = lo; it != hi; ++it)
799 if (
auto e = it->lock()) {
800 auto side_ptr = e->getSideNumberPtr();
801 if (
const auto side = side_ptr->side_number; side >= 0) {
804 auto &ent_field = dat.getFieldEntities();
805 auto &ent_field_dofs = dat.getFieldDofs();
806 auto &ent_field_data = dat.getFieldData();
808 const int brother_side = side_ptr->brother_side_number;
809 if (brother_side != -1)
810 brother_ents_vec.emplace_back(e);
812 dat.getBase() = e->getApproxBase();
813 dat.getSpace() = e->getSpace();
814 const int ent_order = e->getMaxOrder();
816 dat.getOrder() > ent_order ? dat.getOrder() : ent_order;
818 auto ent_data = e->getEntFieldData();
819 ent_field_data.resize(ent_data.size(),
false);
820 noalias(ent_field_data) = ent_data;
821 ent_field_dofs.resize(ent_data.size(),
false);
822 std::fill(ent_field_dofs.begin(), ent_field_dofs.end(),
nullptr);
823 ent_field.resize(1,
false);
824 ent_field[0] = e.get();
825 if (
auto cache = e->entityCacheDataDofs.lock()) {
826 for (
auto dit =
cache->loHi[0]; dit !=
cache->loHi[1]; ++dit) {
827 ent_field_dofs[(*dit)->getEntDofIdx()] =
834 for (
auto &it : brother_ents_vec) {
835 if (
const auto e = it.lock()) {
837 const int side = e->getSideNumberPtr()->side_number;
838 const int brother_side = e->getSideNumberPtr()->brother_side_number;
841 dat_brother.getBase() = dat.getBase();
842 dat_brother.getSpace() = dat.getSpace();
843 dat_brother.getOrder() = dat.getOrder();
844 dat_brother.getFieldData() = dat.getFieldData();
845 dat_brother.getFieldDofs() = dat.getFieldDofs();
846 dat_brother.getFieldEntities() = dat.getFieldEntities();
861 ent_field_data.resize(0,
false);
862 ent_field_dofs.resize(0,
false);
863 ent_field.resize(0,
false);
867 bit_number, get_id_for_min_type<MBVERTEX>());
868 auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
870 if (lo != field_ents.end()) {
872 ent_field.resize(field_ents.size(),
false);
873 std::fill(ent_field.begin(), ent_field.end(),
nullptr);
876 bit_number, get_id_for_max_type<MBENTITYSET>());
877 auto hi = std::upper_bound(lo, field_ents.end(), hi_uid,
cmp_uid_hi);
881 for (
auto it = lo; it != hi; ++it, ++side)
882 if (
auto e = it->lock()) {
884 const auto size = e->getNbDofsOnEnt();
885 ent_field_data.resize(size,
false);
886 ent_field_dofs.resize(size,
false);
887 ent_field[side] = e.get();
888 noalias(ent_field_data) = e->getEntFieldData();
890 if (
auto cache = e->entityCacheDataDofs.lock()) {
891 for (
auto dit =
cache->loHi[0]; dit !=
cache->loHi[1]; ++dit) {
892 ent_field_dofs[(*dit)->getEntDofIdx()] =
905 const int bit_number)
const {
909 "No space to insert data");
929 const auto nb_faces = CN::NumSubEntities(type, 2);
933 auto side_ptr_it = side_table.get<1>().lower_bound(
934 boost::make_tuple(CN::TypeDimensionMap[2].first, 0));
935 auto hi_side_ptr_it = side_table.get<1>().upper_bound(
936 boost::make_tuple(CN::TypeDimensionMap[2].second, 100));
938 for (; side_ptr_it != hi_side_ptr_it; ++side_ptr_it) {
939 const auto side = (*side_ptr_it)->side_number;
940 const auto sense = (*side_ptr_it)->sense;
941 const auto offset = (*side_ptr_it)->offset;
946 CN::SubEntityVertexIndices(type, 2, side, face_type, nb_nodes_face);
947 face_nodes.resize(nb_faces, nb_nodes_face);
948 face_nodes_order.resize(nb_faces, nb_nodes_face);
951 for (
int n = 0;
n != nb_nodes_face; ++
n)
952 face_nodes_order(side,
n) = (
n + offset) % nb_nodes_face;
954 for (
int n = 0;
n != nb_nodes_face; ++
n)
955 face_nodes_order(side,
n) =
956 (nb_nodes_face - (
n - offset) % nb_nodes_face) % nb_nodes_face;
958 for (
int n = 0;
n != nb_nodes_face; ++
n)
959 face_nodes(side,
n) = face_indices[face_nodes_order(side,
n)];
962 const auto face_ent = (*side_ptr_it)->ent;
968 nb_nodes_face,
true);
969 face_nodes.resize(nb_faces, nb_nodes_face);
970 for (
int nn = 0; nn != nb_nodes_face; ++nn) {
971 if (face_nodes(side, nn) !=
974 std::find(conn_ele, &conn_ele[num_nodes_ele], conn_face[nn]))) {
976 "Wrong face numeration");
1010 if (
auto ptr = e.lock()) {
1017 data.
sPace.set(space);
1018 data.
bAse.set(approx);
1027 "data fields ents not allocated on element");
1047 "Functions genrating approximation base not defined");
1049 for (
int space =
H1; space !=
LASTSPACE; ++space) {
1055 boost::make_shared<EntPolynomialBaseCtx>(
1064 "Functions generating user approximation base not defined");
1072 boost::make_shared<EntPolynomialBaseCtx>(
1079 "Base <%s> not yet implemented",
1093 dataOnElement[space]->dataOnEntities[MBVERTEX][0].getDiffNSharedPtr(
1115 auto &bb_node_order = data.
dataOnEntities[MBVERTEX][0].getBBNodeOrder();
1118 auto bit_number = field_ptr->getBitNumber();
1120 bit_number, get_id_for_min_type<MBVERTEX>());
1121 auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
1123 if (lo != field_ents.end()) {
1125 bit_number, get_id_for_max_type<MBVERTEX>());
1126 auto hi = std::upper_bound(lo, field_ents.end(), hi_uid,
cmp_uid_hi);
1129 for (
auto it = lo; it != hi; ++it)
1130 if (
auto first_e = it->lock()) {
1131 space = first_e->getSpace();
1132 base = first_e->getApproxBase();
1134 bb_node_order.resize(num_nodes,
false);
1135 bb_node_order.clear();
1137 std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;
1139 for (; it != hi; ++it) {
1140 if (
auto e = it->lock()) {
1141 const auto &sn = e->getSideNumberPtr();
1142 const int side_number = sn->side_number;
1143 const int brother_side_number = sn->brother_side_number;
1144 if (brother_side_number != -1)
1145 brother_ents_vec.emplace_back(e);
1146 bb_node_order[side_number] = e->getMaxOrder();
1150 for (
auto &it : brother_ents_vec) {
1151 if (
const auto e = it.lock()) {
1152 const auto &sn = e->getSideNumberPtr();
1153 const int side_number = sn->side_number;
1154 const int brother_side_number = sn->brother_side_number;
1155 bb_node_order[brother_side_number] = bb_node_order[side_number];
1176 dat.getFieldData().resize(0,
false);
1177 dat.getFieldDofs().resize(0,
false);
1182 auto bit_number = field_ptr->getBitNumber();
1185 auto lo = std::lower_bound(field_ents.begin(), field_ents.end(), lo_uid,
1187 if (lo != field_ents.end()) {
1190 auto hi = std::upper_bound(lo, field_ents.end(), hi_uid,
cmp_uid_hi);
1192 std::vector<boost::weak_ptr<FieldEntity>> brother_ents_vec;
1193 for (; lo != hi; ++lo) {
1194 if (
auto e = lo->lock()) {
1195 if (
auto cache = e->entityCacheDataDofs.lock()) {
1197 if (
const auto side = e->getSideNumberPtr()->side_number;
1201 const int brother_side =
1202 e->getSideNumberPtr()->brother_side_number;
1203 if (brother_side != -1)
1204 brother_ents_vec.emplace_back(e);
1205 dat.getBase() = e->getApproxBase();
1206 dat.getSpace() = e->getSpace();
1207 const auto ent_order = e->getMaxOrder();
1209 dat.getOrder() > ent_order ? dat.getOrder() : ent_order;
1216 for (
auto &ent_ptr : brother_ents_vec) {
1217 if (
auto e = ent_ptr.lock()) {
1219 const int side = e->getSideNumberPtr()->side_number;
1220 const int brother_side = e->getSideNumberPtr()->brother_side_number;
1223 dat_brother.getBase() = dat.getBase();
1224 dat_brother.getSpace() = dat.getSpace();
1225 dat_brother.getOrder() = dat.getOrder();
1233 if (
auto ent_data_ptr = e.lock()) {
1235 auto space = ent_data_ptr->getSpace();
1238 for (
auto &ptr : dat.getBBAlphaIndicesByOrderArray())
1240 for (
auto &ptr : dat.getBBNByOrderArray())
1242 for (
auto &ptr : dat.getBBDiffNByOrderArray())
1250 auto check_space = [&](
const auto space) {
1253 for (
auto t = MBVERTEX;
t <= ele_type; ++
t) {
1259 for (
auto t = MBEDGE;
t <= ele_type; ++
t) {
1265 for (
auto t = MBTRI;
t <= ele_type; ++
t) {
1278 std::set<string> fields_list;
1280 if (
auto ent_data_ptr = e.lock()) {
1283 if (fields_list.find(
field_name) == fields_list.end()) {
1284 auto field_ptr = ent_data_ptr->getFieldRawPtr();
1285 auto space = ent_data_ptr->getSpace();
1289 if (check_space(space)) {
1291 gaussPts, boost::make_shared<EntPolynomialBaseCtx>(
1309 for (
int space =
H1; space !=
LASTSPACE; ++space) {
1317#define FUNCTION_NAME_WITH_OP_NAME(OP) \
1318 std::ostringstream ss; \
1319 ss << "(Calling user data operator " \
1320 << boost::typeindex::type_id_runtime(OP).pretty_name() << " rowField " \
1321 << (OP).rowFieldName << " colField " << (OP).colFieldName << ") "
1323#define CATCH_OP_ERRORS(OP) \
1324 catch (MoFEMExceptionInitial const &ex) { \
1325 FUNCTION_NAME_WITH_OP_NAME(OP) << PETSC_FUNCTION_NAME; \
1326 return PetscError(PETSC_COMM_SELF, ex.lINE, ss.str().c_str(), __FILE__, \
1327 ex.errorCode, PETSC_ERROR_INITIAL, ex.what()); \
1329 catch (MoFEMExceptionRepeat const &ex) { \
1330 FUNCTION_NAME_WITH_OP_NAME(OP) << PETSC_FUNCTION_NAME; \
1331 return PetscError(PETSC_COMM_SELF, ex.lINE, ss.str().c_str(), __FILE__, \
1332 ex.errorCode, PETSC_ERROR_REPEAT, " "); \
1334 catch (MoFEMException const &ex) { \
1335 FUNCTION_NAME_WITH_OP_NAME(OP) << ex.errorMessage; \
1336 SETERRQ(PETSC_COMM_SELF, ex.errorCode, ss.str().c_str()); \
1338 catch (std::exception const &ex) { \
1339 std::string message("Error: " + std::string(ex.what()) + " at " + \
1340 boost::lexical_cast<std::string>(__LINE__) + " : " + \
1341 std::string(__FILE__) + " in " + \
1342 std::string(PETSC_FUNCTION_NAME)); \
1343 FUNCTION_NAME_WITH_OP_NAME(OP) << message; \
1344 SETERRQ(PETSC_COMM_SELF, MOFEM_STD_EXCEPTION_THROW, ss.str().c_str()); \
1353 std::array<const Field *, 3> field_struture;
1356 std::array<FieldSpace, 2> space;
1357 std::array<FieldApproximationBase, 2> base;
1359 constexpr std::array<UDO::OpType, 2> types = {UDO::OPROW, UDO::OPCOL};
1360 std::array<int, 2> last_eval_field_id = {0, 0};
1362 std::array<boost::shared_ptr<EntitiesFieldData>, 2> op_data;
1364 auto swap_bases = [&](
auto &op) {
1366 for (
size_t ss = 0; ss != 2; ++ss) {
1367 if (op.getOpType() & types[ss] || op.getOpType() & UDO::OPROWCOL) {
1384 auto evaluate_op_space = [&](
auto &op) {
1389 std::fill(last_eval_field_id.begin(), last_eval_field_id.end(), 0);
1409 e.getSpace() = op.sPace;
1419 "Not implemented for this space", op.sPace);
1426 auto set_op_entityties_data = [&](
auto ss,
auto &op) {
1430 if ((op.getNumeredEntFiniteElementPtr()->getBitFieldIdData() &
1434 "no data field < %s > on finite element < %s >",
1442 for (
auto &data : op_data[ss]->dataOnEntities[MBENTITYSET]) {
1443 CHKERR data.resetFieldDependentData();
1446 auto get_data_for_nodes = [&]() {
1457 auto get_data_for_entities = [&]() {
1467 auto get_data_for_meshset = [&]() {
1478 switch (space[ss]) {
1480 CHKERR get_data_for_nodes();
1483 CHKERR get_data_for_entities();
1488 CHKERR get_data_for_nodes();
1491 CHKERR get_data_for_entities();
1498 CHKERR get_data_for_meshset();
1503 "not implemented for this space < %s >",
1510 auto evaluate_op_for_fields = [&](
auto &op) {
1513 if (op.getOpType() & UDO::OPROW) {
1515 CHKERR op.opRhs(*op_data[0],
false);
1520 if (op.getOpType() & UDO::OPCOL) {
1522 CHKERR op.opRhs(*op_data[1],
false);
1527 if (op.getOpType() & UDO::OPROWCOL) {
1529 CHKERR op.opLhs(*op_data[0], *op_data[1]);
1543 for (; oit != hi_oit; oit++) {
1547 CHKERR oit->setPtrFE(
this);
1549 if ((oit->opType & UDO::OPSPACE) == UDO::OPSPACE) {
1552 CHKERR evaluate_op_space(*oit);
1556 (oit->opType & (UDO::OPROW | UDO::OPCOL | UDO::OPROWCOL)) ==
1564 for (
size_t ss = 0; ss != 2; ss++) {
1569 "Not set Field name in operator %d (0-row, 1-column) in "
1572 (boost::typeindex::type_id_runtime(*oit).pretty_name())
1579 space[ss] = field_struture[ss]->getSpace();
1580 base[ss] = field_struture[ss]->getApproxBase();
1585 for (
size_t ss = 0; ss != 2; ss++) {
1587 if (oit->getOpType() & types[ss] ||
1588 oit->getOpType() & UDO::OPROWCOL) {
1589 if (last_eval_field_id[ss] != field_id[ss]) {
1590 CHKERR set_op_entityties_data(ss, *oit);
1591 last_eval_field_id[ss] = field_id[ss];
1599 CHKERR evaluate_op_for_fields(*oit);
1605 for (
int i = 0;
i != 5; ++
i)
1606 if (oit->opType & (1 <<
i))
1607 MOFEM_LOG(
"SELF", Sev::error) << UDO::OpTypeNames[
i];
1609 "Impossible operator type");
1617const char *
const ForcesAndSourcesCore::UserDataOperator::OpTypeNames[] = {
1618 "OPROW",
" OPCOL",
"OPROWCOL",
"OPSPACE",
"OPLAST"};
1674 const auto *problem_ptr = getFEMethod()->problemPtr;
1676 problem_ptr->numeredFiniteElementsPtr->get<
Unique_mi_tag>();
1678 auto fe_miit = ptrFE->mField.get_finite_elements()
1681 if (fe_miit != ptrFE->mField.get_finite_elements()
1687 side_fe->
feName = fe_name;
1700 std::vector<boost::weak_ptr<NumeredEntFiniteElement>> fe_vec;
1701 auto get_numered_fe_ptr = [&](
auto &fe_uid,
Range &&adjacent_ents)
1702 -> std::vector<boost::weak_ptr<NumeredEntFiniteElement>> & {
1703 fe_vec.reserve(adjacent_ents.size());
1704 for (
auto fe_ent : adjacent_ents) {
1705 auto miit = numered_fe.find(
1707 if (miit != numered_fe.end()) {
1708 fe_vec.emplace_back(*miit);
1714 auto get_bit_entity_adjacency = [&]() {
1715 Range adjacent_ents;
1717 ent, side_dim, adjacent_ents);
1718 return adjacent_ents;
1721 auto get_adj = [&](
auto &fe_uid)
1722 -> std::vector<boost::weak_ptr<NumeredEntFiniteElement>> & {
1725 return (*adj_cache).at(ent);
1726 }
catch (
const std::out_of_range &) {
1727 return (*adj_cache)[ent] =
1728 get_numered_fe_ptr(fe_uid, get_bit_entity_adjacency());
1731 return get_numered_fe_ptr(fe_uid, get_bit_entity_adjacency());
1735 auto adj = get_adj((*fe_miit)->getFEUId());
1739 for (
auto fe_weak_ptr : adj) {
1740 if (
auto fe_ptr = fe_weak_ptr.lock()) {
1742 MOFEM_LOG(
"SELF", sev) <<
"Side finite element "
1743 <<
"(" << nn <<
"): " << *fe_ptr;
1763 MOFEM_LOG(
"SELF", sev) <<
"This finite element: "
1764 << *getNumeredEntFiniteElementPtr();
1766 this_fe->
feName = fe_name;
1796 auto fe_miit = fes.find(fe_name);
1797 if (fe_miit != fes.end()) {
1799 const auto *problem_ptr = getFEMethod()->problemPtr;
1801 problem_ptr->numeredFiniteElementsPtr->get<
Unique_mi_tag>();
1804 parent_fe->
feName = fe_name;
1814 const auto parent_ent = getNumeredEntFiniteElementPtr()->getParentEnt();
1816 parent_ent, (*fe_miit)->getFEUId()));
1817 if (miit != numered_fe.end()) {
1819 MOFEM_LOG(
"SELF", sev) <<
"Parent finite element: " << **miit;
1828 MOFEM_LOG(
"SELF", sev) <<
"Parent finite element: no parent";
1844 auto fe_miit = ptrFE->mField.get_finite_elements()
1847 if (fe_miit != ptrFE->mField.get_finite_elements()
1851 const auto *problem_ptr = getFEMethod()->problemPtr;
1852 auto &ref_ents = *getPtrFE()->mField.get_ref_ents();
1854 problem_ptr->numeredFiniteElementsPtr->get<
Unique_mi_tag>();
1856 const auto parent_ent = getNumeredEntFiniteElementPtr()->getEnt();
1857 const auto parent_type = getNumeredEntFiniteElementPtr()->getEntType();
1860 boost::make_tuple(parent_type, parent_ent));
1862 if (
auto size = std::distance(range.first, range.second)) {
1864 std::vector<EntityHandle> childs_vec;
1865 childs_vec.reserve(size);
1866 for (; range.first != range.second; ++range.first)
1867 childs_vec.emplace_back((*range.first)->getEnt());
1871 if ((childs_vec.back() - childs_vec.front() + 1) == size)
1872 childs =
Range(childs_vec.front(), childs_vec.back());
1874 childs.insert_list(childs_vec.begin(), childs_vec.end());
1876 child_fe->
feName = fe_name;
1892 for (
auto p = childs.pair_begin();
p != childs.pair_end(); ++
p) {
1896 p->first, (*fe_miit)->getFEUId()));
1899 p->second, (*fe_miit)->getFEUId()));
1901 for (; miit != hi_miit; ++miit) {
1904 MOFEM_LOG(
"SELF", sev) <<
"Child finite element "
1905 <<
"(" << nn <<
"): " << **miit;
1942ForcesAndSourcesCore::UserDataOperator::UserDataOperator(
const FieldSpace space,
1945 :
DataOperator(symm), opType(type), sPace(space), ptrFE(nullptr) {}
1947ForcesAndSourcesCore::UserDataOperator::UserDataOperator(
1948 const std::string
field_name,
const char type,
const bool symm)
1952ForcesAndSourcesCore::UserDataOperator::UserDataOperator(
1953 const std::string row_field_name,
const std::string col_field_name,
1954 const char type,
const bool symm)
1955 :
DataOperator(symm), opType(type), rowFieldName(row_field_name),
1956 colFieldName(col_field_name), sPace(
LASTSPACE), ptrFE(nullptr) {}
1974 <<
"No method operator() overloaded on element entity on finite "
1976 << boost::typeindex::type_id_runtime(*this).pretty_name() <<
">";
1995 "User operator and finite element do not work together");
#define CATCH_OP_ERRORS(OP)
FieldApproximationBase
approximation base
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
@ USER_BASE
user implemented approximation base
@ AINSWORTH_BERNSTEIN_BEZIER_BASE
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
FieldSpace
approximation spaces
@ L2
field with C-1 continuity
@ LASTSPACE
FieldSpace in [ 0, LASTSPACE )
@ NOFIELD
scalar or vector of scalars describe (no true field)
@ HCURL
field with continuous tangents
@ HDIV
field with continuous normal traction
static const char *const FieldSpaceNames[]
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
@ MOFEM_DATA_INCONSISTENCY
static const char *const ApproximationBaseNames[]
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define THROW_MESSAGE(msg)
Throw MoFEM exception.
FTensor::Index< 'n', SPACE_DIM > n
multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_unique< tag< Unique_mi_tag >, const_mem_fun< NumeredDofEntity::interface_type_DofEntity, UId, &NumeredDofEntity::getLocalUniqueId > >, ordered_non_unique< tag< Part_mi_tag >, member< NumeredDofEntity, unsigned int, &NumeredDofEntity::pArt > >, ordered_non_unique< tag< Idx_mi_tag >, member< NumeredDofEntity, DofIdx, &NumeredDofEntity::dofIdx > >, ordered_non_unique< tag< PetscGlobalIdx_mi_tag >, member< NumeredDofEntity, DofIdx, &NumeredDofEntity::petscGloablDofIdx > >, ordered_non_unique< tag< PetscLocalIdx_mi_tag >, member< NumeredDofEntity, DofIdx, &NumeredDofEntity::petscLocalDofIdx > >, ordered_non_unique< tag< Ent_mi_tag >, const_mem_fun< NumeredDofEntity::interface_type_DofEntity, EntityHandle, &NumeredDofEntity::getEnt > > > > NumeredDofEntity_multiIndex
MultiIndex container keeps NumeredDofEntity.
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< ordered_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, signed char, &SideNumber::side_number > > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
virtual const Field * get_field_structure(const std::string &name, enum MoFEMTypes bh=MF_EXIST) const =0
get field structure
#define MOFEM_LOG(channel, severity)
Log.
SeverityLevel
Severity levels.
FTensor::Index< 'i', SPACE_DIM > i
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
std::bitset< BITFEID_SIZE > BitFEId
Finite element Id.
int ApproximationOrder
Approximation on the entity.
std::bitset< BITFIELDID_SIZE > BitFieldId
Field Id.
UBlasVector< int > VectorInt
implementation of Data Operators for Forces and Sources
static auto cmp_uid_lo(const boost::weak_ptr< FieldEntity > &a, const UId &b)
EntityHandle get_id_for_max_type()
static auto cmp_uid_hi(const UId &b, const boost::weak_ptr< FieldEntity > &a)
EntityHandle get_id_for_min_type()
ublas::vector< FieldEntity *, FieldEntAllocator > VectorFieldEntities
std::vector< boost::weak_ptr< FieldEntity > > FieldEntity_vector_view
Field_multiIndex::index< FieldName_mi_tag >::type::iterator field_it
static int getMaxOrder(const ENTMULTIINDEX &multi_index)
ublas::vector< FEDofEntity *, DofsAllocator > VectorDofs
constexpr double t
plate stiffness
constexpr auto field_name
int loopSize
local number oe methods to process
MoFEMErrorCode copyBasicMethod(const BasicMethod &basic)
Copy data from other base method to this base method.
boost::function< MoFEMErrorCode()> preProcessHook
Hook function for pre-processing.
const Field_multiIndex * fieldsPtr
raw pointer to fields container
int nInTheLoop
number currently of processed method
const Problem * problemPtr
raw pointer to problem
boost::function< MoFEMErrorCode()> operatorHook
Hook function for operator.
boost::weak_ptr< CacheTuple > cacheWeakPtr
int getNinTheLoop() const
get number of evaluated element in the loop
boost::function< MoFEMErrorCode()> postProcessHook
Hook function for post-processing.
virtual FieldBitNumber get_field_bit_number(const std::string name) const =0
get field bit number
virtual moab::Interface & get_moab()=0
virtual BitFieldId get_field_id(const std::string &name) const =0
Get field Id.
virtual MPI_Comm & get_comm() const =0
base operator to do operations at Gauss Pt. level
static bool getDefTypeMap(const EntityType fe_type, const EntityType ent_type)
Deprecated interface functions.
this class derive data form other data structure
UId getLocalUniqueIdCalculate() const
Generate UId for finite element entity.
Data on single entity (This is passed as argument to DataOperator::doWork)
data structure for finite element entity
std::bitset< LASTSPACE > sPace
spaces on element
MatrixInt facesNodes
nodes on finite element faces
std::array< std::bitset< LASTSPACE >, MBMAXTYPE > spacesOnEntities
spaces on entity types
std::bitset< LASTBASE > bAse
bases on element
std::array< boost::ptr_vector< EntData >, MBMAXTYPE > dataOnEntities
std::array< std::bitset< LASTBASE >, LASTSPACE > basesOnSpaces
base on spaces
MatrixInt facesNodesOrder
order of face nodes on element
std::array< std::bitset< LASTBASE >, MBMAXTYPE > basesOnEntities
bases on entity types
keeps information about indexed dofs for the finite element
std::string feName
Name of finite element.
auto & getRowFieldEnts() const
auto getFEName() const
get finite element name
const FieldEntity_vector_view & getDataFieldEnts() const
boost::shared_ptr< FieldEntity_vector_view > & getDataFieldEntsPtr() const
auto getColDofsPtr() const
EntityHandle getFEEntityHandle() const
auto getNumberOfNodes() const
auto getRowDofsPtr() const
boost::shared_ptr< const NumeredEntFiniteElement > numeredEntFiniteElementPtr
auto & getColFieldEnts() const
static UId getHiBitNumberUId(const FieldBitNumber bit_number)
UId getLocalUniqueIdCalculate()
Get the Local Unique Id Calculate object.
static UId getLoBitNumberUId(const FieldBitNumber bit_number)
static UId getLoLocalEntityBitNumber(const char bit_number, const EntityHandle ent)
static UId getHiLocalEntityBitNumber(const char bit_number, const EntityHandle ent)
Provide data structure for (tensor) field approximation.
FieldCoefficientsNumber getNbOfCoeffs() const
Get number of field coefficients.
FieldSpace getSpace() const
Get field approximation space.
FieldBitNumber getBitNumber() const
Get number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for giv...
ForcesAndSourcesCore * ptrFE
std::map< EntityHandle, std::vector< boost::weak_ptr< NumeredEntFiniteElement > > > AdjCache
structure to get information form mofem into EntitiesFieldData
MoFEMErrorCode loopOverOperators()
Iterate user data operators.
MoFEMErrorCode getProblemNodesRowIndices(const std::string &field_name, VectorInt &nodes_indices) const
MoFEMErrorCode getEntityIndices(EntitiesFieldData &data, const int bit_number, FieldEntity_vector_view &ents_field, const EntityType type_lo, const EntityType type_hi, EXTRACTOR &&extractor) const
MoFEMErrorCode getEntityRowIndices(EntitiesFieldData &data, const int bit_number, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
MoFEMErrorCode getRowNodesIndices(EntitiesFieldData &data, const int bit_number) const
get row node indices from FENumeredDofEntity_multiIndex
int getMaxRowOrder() const
Get max order of approximation for field in rows.
auto & getUserPolynomialBase()
Get the User Polynomial Base object.
MoFEMErrorCode getSpacesAndBaseOnEntities(EntitiesFieldData &data) const
Get field approximation space and base on entities.
MoFEMErrorCode getProblemTypeColIndices(const std::string &field_name, EntityType type, int side_number, VectorInt &indices) const
MoFEMErrorCode getNoFieldIndices(const int bit_number, boost::shared_ptr< FENumeredDofEntity_multiIndex > dofs, VectorInt &nodes_indices) const
get NoField indices
virtual MoFEMErrorCode operator()()
function is run for every finite element
MoFEMErrorCode getFaceNodes(EntitiesFieldData &data) const
Get nodes on faces.
const std::array< boost::shared_ptr< EntitiesFieldData >, LASTSPACE > derivedDataOnElement
Entity data on element entity columns fields.
MoFEMErrorCode getNoFieldRowIndices(EntitiesFieldData &data, const int bit_number) const
get col NoField indices
virtual MoFEMErrorCode setGaussPts(int order_row, int order_col, int order_data)
set user specific integration rule
MoFEMErrorCode getNodesIndices(const int bit_number, FieldEntity_vector_view &ents_field, VectorInt &nodes_indices, VectorInt &local_nodes_indices, EXTRACTOR &&extractor) const
get node indices
MoFEMErrorCode getEntityFieldData(EntitiesFieldData &data, const int bit_number, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
MoFEMErrorCode setRefineFEPtr(const ForcesAndSourcesCore *refine_fe_ptr)
Set the pointer to face element refined.
auto & getElementPolynomialBase()
Get the Entity Polynomial Base object.
ForcesAndSourcesCore * sidePtrFE
Element to integrate on the sides.
ForcesAndSourcesCore(Interface &m_field)
virtual int getRule(int order_row, int order_col, int order_data)
another variant of getRule
boost::ptr_deque< UserDataOperator > opPtrVector
Vector of finite element users data operators.
MoFEMErrorCode getEntitySense(const EntityType type, boost::ptr_vector< EntitiesFieldData::EntData > &data) const
get sense (orientation) of entity
const std::array< boost::shared_ptr< EntitiesFieldData >, LASTSPACE > dataOnElement
Entity data on element entity rows fields.
MoFEMErrorCode getProblemNodesColIndices(const std::string &field_name, VectorInt &nodes_indices) const
MoFEMErrorCode calHierarchicalBaseFunctionsOnElement()
Calculate base functions.
MatrixDouble gaussPts
Matrix of integration points.
MoFEMErrorCode calBernsteinBezierBaseFunctionsOnElement()
Calculate Bernstein-Bezier base.
virtual MoFEMErrorCode preProcess()
function is run at the beginning of loop
MoFEMErrorCode getColNodesIndices(EntitiesFieldData &data, const int bit_number) const
get col node indices from FENumeredDofEntity_multiIndex
MoFEMErrorCode setSideFEPtr(const ForcesAndSourcesCore *side_fe_ptr)
Set the pointer to face element on the side.
int getMaxColOrder() const
Get max order of approximation for field in columns.
MoFEMErrorCode getProblemNodesIndices(const std::string &field_name, const NumeredDofEntity_multiIndex &dofs, VectorInt &nodes_indices) const
get indices of nodal indices which are declared for problem but not this particular element
GaussHookFun setRuleHook
Set function to calculate integration rule.
MoFEMErrorCode getBitRefLevelOnData()
MoFEMErrorCode getNodesFieldData(EntitiesFieldData &data, const int bit_number) const
Get data on nodes.
MoFEMErrorCode getEntityColIndices(EntitiesFieldData &data, const int bit_number, const EntityType type_lo=MBVERTEX, const EntityType type_hi=MBPOLYHEDRON) const
MoFEMErrorCode getEntityDataOrder(const EntityType type, const FieldSpace space, boost::ptr_vector< EntitiesFieldData::EntData > &data) const
Get the entity data order.
ForcesAndSourcesCore * refinePtrFE
Element to integrate parent or child.
MoFEMErrorCode getNoFieldColIndices(EntitiesFieldData &data, const int bit_number) const
get col NoField indices
int getMaxDataOrder() const
Get max order of approximation for data fields.
MoFEMErrorCode getNoFieldFieldData(const int bit_number, VectorDouble &ent_field_data, VectorDofs &ent_field_dofs, VectorFieldEntities &ent_field) const
Get field data on nodes.
MoFEMErrorCode getProblemTypeRowIndices(const std::string &field_name, EntityType type, int side_number, VectorInt &indices) const
MoFEMErrorCode getProblemTypeIndices(const std::string &field_name, const NumeredDofEntity_multiIndex &dofs, EntityType type, int side_number, VectorInt &indices) const
get indices by type (generic function) which are declared for problem but not this particular element
RuleHookFun getRuleHook
Hook to get rule.
MoFEMErrorCode createDataOnElement(EntityType type)
Create a entity data on element object.
virtual MoFEMErrorCode postProcess()
function is run at the end of loop
MoFEMErrorCode copyKsp(const KspMethod &ksp)
copy data form another method
MoFEMErrorCode copyPetscData(const PetscData &petsc_data)
boost::shared_ptr< NumeredDofEntity_multiIndex > numeredRowDofsPtr
store DOFs on rows for this problem
boost::shared_ptr< NumeredDofEntity_multiIndex > numeredColDofsPtr
store DOFs on columns for this problem
MoFEMErrorCode copySnes(const SnesMethod &snes)
Copy snes data.
MoFEMErrorCode copyTs(const TSMethod &ts)
Copy TS solver data.
boost::shared_ptr< SideNumber > getSideNumberPtr() const