v0.16.0
Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | List of all members
ConvectiveMassElement::OpMassJacobian Struct Reference
User modules » Mass Element

#include "users_modules/basic_finite_elements/src/ConvectiveMassElement.hpp"

Inheritance diagram for ConvectiveMassElement::OpMassJacobian:
[legend]
Collaboration diagram for ConvectiveMassElement::OpMassJacobian:
[legend]

Public Member Functions

 OpMassJacobian (const std::string field_name, BlockData &data, CommonData &common_data, boost::ptr_vector< MethodForForceScaling > &methods_op, int tag, bool linear=false)
 
MoFEMErrorCode doWork (int row_side, EntityType row_type, EntitiesFieldData::EntData &row_data)
 

Public Attributes

BlockData & dAta
 
CommonData & commonData
 
int tAg
 
bool jAcobian
 
bool & lInear
 
bool fieldDisp
 
boost::ptr_vector< MethodForForceScaling > & methodsOp
 
FTensor::Index< 'i', 3 > i
 
FTensor::Index< 'j', 3 > j
 
FTensor::Index< 'k', 3 > k
 
VectorBoundedArray< adouble, 3 > a
 
VectorBoundedArray< adouble, 3 > dot_W
 
VectorBoundedArray< adouble, 3 > dp_dt
 
VectorBoundedArray< adouble, 3 > a_res
 
MatrixBoundedArray< adouble, 9 > h
 
MatrixBoundedArray< adouble, 9 > H
 
MatrixBoundedArray< adouble, 9 > invH
 
MatrixBoundedArray< adouble, 9 > F
 
MatrixBoundedArray< adouble, 9 > g
 
MatrixBoundedArray< adouble, 9 > G
 
std::vector< double > active
 

Detailed Description

Definition at line 177 of file ConvectiveMassElement.hpp.

Constructor & Destructor Documentation

◆ OpMassJacobian()

ConvectiveMassElement::OpMassJacobian::OpMassJacobian ( const std::string  field_name,
BlockData &  data,
CommonData &  common_data,
boost::ptr_vector< MethodForForceScaling > &  methods_op,
int  tag,
bool  linear = false 
)

Definition at line 153 of file ConvectiveMassElement.cpp.

157 : VolumeElementForcesAndSourcesCore::UserDataOperator(
158 field_name, ForcesAndSourcesCore::UserDataOperator::OPROW),
159 dAta(data), commonData(common_data), tAg(tag), jAcobian(jacobian),
160 lInear(commonData.lInear), fieldDisp(false), methodsOp(methods_op) {}
field_name
constexpr auto field_name
Definition poisson_2d_homogeneous.cpp:13
ConvectiveMassElement::OpMassJacobian::methodsOp
boost::ptr_vector< MethodForForceScaling > & methodsOp
Definition ConvectiveMassElement.hpp:188
MoFEM::ForcesAndSourcesCore::UserDataOperator::OPROW
@ OPROW
operator doWork function is executed on FE rows
Definition ForcesAndSourcesCore.hpp:602

Member Function Documentation

◆ doWork()

MoFEMErrorCode ConvectiveMassElement::OpMassJacobian::doWork ( int  row_side,
EntityType  row_type,
EntitiesFieldData::EntData &  row_data 
)

Definition at line 162 of file ConvectiveMassElement.cpp.

163 {
164 MoFEMFunctionBeginHot;
165
166 if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
167 dAta.tEts.end()) {
168 MoFEMFunctionReturnHot(0);
169 }
170
171 // do it only once, no need to repeat this for edges,faces or tets
172 if (row_type != MBVERTEX)
173 MoFEMFunctionReturnHot(0);
174
175 int nb_dofs = row_data.getIndices().size();
176 if (nb_dofs == 0)
177 MoFEMFunctionReturnHot(0);
178
179 {
180
181 if (a.size() != 3) {
182 a.resize(3, false);
183 dot_W.resize(3, false);
184 a_res.resize(3, false);
185 g.resize(3, 3, false);
186 G.resize(3, 3, false);
187 h.resize(3, 3, false);
188 H.resize(3, 3, false);
189 invH.resize(3, 3, false);
190 F.resize(3, 3, false);
191 }
192
193 std::fill(dot_W.begin(), dot_W.end(), 0);
194 std::fill(H.data().begin(), H.data().end(), 0);
195 std::fill(invH.data().begin(), invH.data().end(), 0);
196 for (int ii = 0; ii != 3; ii++) {
197 H(ii, ii) = 1;
198 invH(ii, ii) = 1;
199 }
200
201 int nb_gauss_pts = row_data.getN().size1();
202 commonData.valMass.resize(nb_gauss_pts);
203 commonData.jacMassRowPtr.resize(nb_gauss_pts);
204 commonData.jacMass.resize(nb_gauss_pts);
205
206 const std::vector<VectorDouble> &dot_spacial_vel =
207 commonData.dataAtGaussPts["DOT_" + commonData.spatialVelocities];
208
209 const std::vector<MatrixDouble> &spatial_positions_grad =
210 commonData.gradAtGaussPts[commonData.spatialPositions];
211
212 const std::vector<MatrixDouble> &spatial_velocities_grad =
213 commonData.gradAtGaussPts[commonData.spatialVelocities];
214
215 const std::vector<VectorDouble> &meshpos_vel =
216 commonData.dataAtGaussPts["DOT_" + commonData.meshPositions];
217
218 const std::vector<MatrixDouble> &mesh_positions_gradient =
219 commonData.gradAtGaussPts[commonData.meshPositions];
220
221 int nb_active_vars = 0;
222 for (int gg = 0; gg < nb_gauss_pts; gg++) {
223
224 if (gg == 0) {
225
226 trace_on(tAg);
227
228 for (int nn1 = 0; nn1 < 3; nn1++) { // 0
229 // commonData.dataAtGaussPts["DOT_"+commonData.spatialVelocities]
230 a[nn1] <<= dot_spacial_vel[gg][nn1];
231 nb_active_vars++;
232 }
233 for (int nn1 = 0; nn1 < 3; nn1++) { // 3
234 for (int nn2 = 0; nn2 < 3; nn2++) {
235 // commonData.gradAtGaussPts[commonData.spatialPositions][gg]
236 h(nn1, nn2) <<= spatial_positions_grad[gg](nn1, nn2);
237 if (fieldDisp) {
238 if (nn1 == nn2) {
239 h(nn1, nn2) += 1;
240 }
241 }
242 nb_active_vars++;
243 }
244 }
245 if (commonData.dataAtGaussPts["DOT_" + commonData.meshPositions]
246 .size() > 0) {
247 for (int nn1 = 0; nn1 < 3; nn1++) { // 3+9=12
248 for (int nn2 = 0; nn2 < 3; nn2++) {
249 // commonData.gradAtGaussPts[commonData.spatialVelocities]
250 g(nn1, nn2) <<= spatial_velocities_grad[gg](nn1, nn2);
251 nb_active_vars++;
252 }
253 }
254 for (int nn1 = 0; nn1 < 3; nn1++) { // 3+9+9=21
255 // commonData.dataAtGaussPts["DOT_"+commonData.meshPositions]
256 dot_W(nn1) <<= meshpos_vel[gg][nn1];
257 nb_active_vars++;
258 }
259 for (int nn1 = 0; nn1 < 3; nn1++) { // 3+9+9+3=24
260 for (int nn2 = 0; nn2 < 3; nn2++) {
261 // commonData.gradAtGaussPts[commonData.meshPositions][gg]
262 H(nn1, nn2) <<= mesh_positions_gradient[gg](nn1, nn2);
263 nb_active_vars++;
264 }
265 }
266 }
267
268 auto a0 = dAta.a0;
269 CHKERR MethodForForceScaling::applyScale(getFEMethod(), methodsOp, a0);
270
271 auto t_a_res =
272 FTensor::Tensor1<adouble *, 3>{&a_res[0], &a_res[1], &a_res[2]};
273 auto t_a = FTensor::Tensor1<adouble *, 3>{&a[0], &a[1], &a[2]};
274 auto t_a0 = FTensor::Tensor1<double *, 3>{&a0[0], &a0[1], &a0[2]};
275 auto t_dotW =
276 FTensor::Tensor1<adouble *, 3>{&dot_W[0], &dot_W[1], &dot_W[2]};
277 using ActiveMat3 = MatrixBoundedArray<adouble, 9>;
278 auto t_g = GetFTensor2FromArrayImpl<3, 3, 0, ActiveMat3>::get(g, 0, 0);
279 auto t_G = GetFTensor2FromArrayImpl<3, 3, 0, ActiveMat3>::get(G, 0, 0);
280 auto t_invH =
281 GetFTensor2FromArrayImpl<3, 3, 0, ActiveMat3>::get(invH, 0, 0);
282 auto t_F = GetFTensor2FromArrayImpl<3, 3, 0, ActiveMat3>::get(F, 0, 0);
283 auto t_h = GetFTensor2FromArrayImpl<3, 3, 0, ActiveMat3>::get(h, 0, 0);
284
285 const double rho0 = dAta.rho0;
286
287 adouble detH = determinantTensor3by3(H);
288 CHKERR invertTensor3by3(H, detH, invH);
289
290 t_G(i, j) = t_g(i, k) * t_invH(k, j);
291 t_a_res(i) = t_a(i) - t_a0(i) + t_G(i, j) * t_dotW(j);
292
293 // FIXME: there is error somewhere for nonlinear case
294 // test dam example with -is_linear 0
295 if (!lInear) {
296
297 t_F(i, j) = t_h(i, k) * t_invH(k, j);
298 t_a_res(i) *= rho0 * detH;
299 t_a_res(i) *= determinantTensor3by3(t_F);
300
301 } else {
302
303 t_a_res(i) *= rho0 * detH;
304 }
305
306 // dependant
307 VectorDouble &res = commonData.valMass[gg];
308 res.resize(3);
309 for (int rr = 0; rr < 3; rr++) {
310 a_res[rr] >>= res[rr];
311 }
312
313 trace_off();
314 }
315
316 active.resize(nb_active_vars);
317 int aa = 0;
318 for (int nn1 = 0; nn1 < 3; nn1++) { // 0
319 active[aa++] = dot_spacial_vel[gg][nn1];
320 }
321 for (int nn1 = 0; nn1 < 3; nn1++) { // 3
322 for (int nn2 = 0; nn2 < 3; nn2++) {
323 if (fieldDisp && nn1 == nn2) {
324 active[aa++] = spatial_positions_grad[gg](nn1, nn2) + 1;
325 } else {
326 active[aa++] = spatial_positions_grad[gg](nn1, nn2);
327 }
328 }
329 }
330 if (commonData.dataAtGaussPts["DOT_" + commonData.meshPositions].size() >
331 0) {
332 for (int nn1 = 0; nn1 < 3; nn1++) { // 3+9=12
333 for (int nn2 = 0; nn2 < 3; nn2++) {
334 active[aa++] = spatial_velocities_grad[gg](nn1, nn2);
335 }
336 }
337 for (int nn1 = 0; nn1 < 3; nn1++) { // 3+9+9=21
338 active[aa++] = meshpos_vel[gg][nn1];
339 }
340 for (int nn1 = 0; nn1 < 3; nn1++) { // 3+9+9+3=24
341 for (int nn2 = 0; nn2 < 3; nn2++) {
342 active[aa++] = mesh_positions_gradient[gg](nn1, nn2);
343 }
344 }
345 }
346
347 if (!jAcobian) {
348 VectorDouble &res = commonData.valMass[gg];
349 if (gg > 0) {
350 res.resize(3);
351 int r;
352 r = ::function(tAg, 3, nb_active_vars, &active[0], &res[0]);
353 if (r != 3) { // function is locally analytic
354 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
355 "ADOL-C function evaluation with error r = %d", r);
356 }
357 }
358 double val = getVolume() * getGaussPts()(3, gg);
359 res *= val;
360 // cout << "my res " << res << endl;
361 } else {
362 commonData.jacMassRowPtr[gg].resize(3);
363 commonData.jacMass[gg].resize(3, nb_active_vars);
364 for (int nn1 = 0; nn1 < 3; nn1++) {
365 (commonData.jacMassRowPtr[gg])[nn1] =
366 &(commonData.jacMass[gg](nn1, 0));
367 }
368 int r;
369 r = jacobian(tAg, 3, nb_active_vars, &active[0],
370 &(commonData.jacMassRowPtr[gg])[0]);
371 if (r != 3) {
372 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
373 "ADOL-C function evaluation with error");
374 }
375 double val = getVolume() * getGaussPts()(3, gg);
376 commonData.jacMass[gg] *= val;
377 }
378 }
379 }
380
381 MoFEMFunctionReturnHot(0);
382}
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:463
MOFEM_OPERATION_UNSUCCESSFUL
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition definitions.h:34
CHKERR
#define CHKERR
Inline error check.
Definition definitions.h:551
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:456
a0
constexpr double a0
Definition hcurl_check_approx_in_2d.cpp:37
MoFEM::Types::MatrixBoundedArray
ublas::matrix< T, ublas::row_major, ublas::bounded_array< T, N > > MatrixBoundedArray
Definition Types.hpp:104
MoFEM::invertTensor3by3
MoFEMErrorCode invertTensor3by3(ublas::matrix< T, L, A > &jac_data, ublas::vector< T, A > &det_data, ublas::matrix< T, L, A > &inv_jac_data)
Calculate inverse of tensor rank 2 at integration points.
Definition Templates.hpp:2276
MoFEM::determinantTensor3by3
static auto determinantTensor3by3(T &t)
Calculate the determinant of a 3x3 matrix or a tensor of rank 2.
Definition Templates.hpp:2228
sdf.r
int r
Definition sdf.py:205
ConvectiveMassElement::BlockData::a0
VectorDouble a0
constant acceleration
Definition ConvectiveMassElement.hpp:118
ConvectiveMassElement::CommonData::dataAtGaussPts
std::map< std::string, std::vector< VectorDouble > > dataAtGaussPts
Definition ConvectiveMassElement.hpp:133
ConvectiveMassElement::CommonData::gradAtGaussPts
std::map< std::string, std::vector< MatrixDouble > > gradAtGaussPts
Definition ConvectiveMassElement.hpp:134
ConvectiveMassElement::CommonData::jacMassRowPtr
std::vector< std::vector< double * > > jacMassRowPtr
Definition ConvectiveMassElement.hpp:142
ConvectiveMassElement::OpMassJacobian::invH
MatrixBoundedArray< adouble, 9 > invH
Definition ConvectiveMassElement.hpp:200
ConvectiveMassElement::OpMassJacobian::a_res
VectorBoundedArray< adouble, 3 > a_res
Definition ConvectiveMassElement.hpp:199
ConvectiveMassElement::OpMassJacobian::dot_W
VectorBoundedArray< adouble, 3 > dot_W
Definition ConvectiveMassElement.hpp:199
MethodForForceScaling::applyScale
static MoFEMErrorCode applyScale(const FEMethod *fe, boost::ptr_vector< MethodForForceScaling > &methods_op, VectorDouble &nf)
Definition MethodForForceScaling.hpp:21
MoFEM::EntitiesFieldData::EntData::getN
MatrixDouble & getN(const FieldApproximationBase base)
get base functions this return matrix (nb. of rows is equal to nb. of Gauss pts, nb....
Definition EntitiesFieldData.hpp:1600
MoFEM::EntitiesFieldData::EntData::getIndices
const VectorInt & getIndices() const
Get global indices of degrees of freedom on entity.
Definition EntitiesFieldData.hpp:1523
MoFEM::GetFTensor2FromArrayImpl
Get FTensor2 from array.
Definition Templates.hpp:660

Member Data Documentation

◆ a

VectorBoundedArray<adouble, 3> ConvectiveMassElement::OpMassJacobian::a

Definition at line 199 of file ConvectiveMassElement.hpp.

◆ a_res

VectorBoundedArray<adouble, 3> ConvectiveMassElement::OpMassJacobian::a_res

Definition at line 199 of file ConvectiveMassElement.hpp.

◆ active

std::vector<double> ConvectiveMassElement::OpMassJacobian::active

Definition at line 201 of file ConvectiveMassElement.hpp.

◆ commonData

CommonData& ConvectiveMassElement::OpMassJacobian::commonData

Definition at line 182 of file ConvectiveMassElement.hpp.

◆ dAta

BlockData& ConvectiveMassElement::OpMassJacobian::dAta

Definition at line 181 of file ConvectiveMassElement.hpp.

◆ dot_W

VectorBoundedArray<adouble, 3> ConvectiveMassElement::OpMassJacobian::dot_W

Definition at line 199 of file ConvectiveMassElement.hpp.

◆ dp_dt

VectorBoundedArray<adouble, 3> ConvectiveMassElement::OpMassJacobian::dp_dt

Definition at line 199 of file ConvectiveMassElement.hpp.

◆ F

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpMassJacobian::F

Definition at line 200 of file ConvectiveMassElement.hpp.

◆ fieldDisp

bool ConvectiveMassElement::OpMassJacobian::fieldDisp

Definition at line 186 of file ConvectiveMassElement.hpp.

◆ g

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpMassJacobian::g

Definition at line 200 of file ConvectiveMassElement.hpp.

◆ G

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpMassJacobian::G

Definition at line 200 of file ConvectiveMassElement.hpp.

◆ h

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpMassJacobian::h

Definition at line 200 of file ConvectiveMassElement.hpp.

◆ H

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpMassJacobian::H

Definition at line 200 of file ConvectiveMassElement.hpp.

◆ i

FTensor::Index<'i', 3> ConvectiveMassElement::OpMassJacobian::i

Definition at line 195 of file ConvectiveMassElement.hpp.

◆ invH

MatrixBoundedArray<adouble, 9> ConvectiveMassElement::OpMassJacobian::invH

Definition at line 200 of file ConvectiveMassElement.hpp.

◆ j

FTensor::Index<'j', 3> ConvectiveMassElement::OpMassJacobian::j

Definition at line 196 of file ConvectiveMassElement.hpp.

◆ jAcobian

bool ConvectiveMassElement::OpMassJacobian::jAcobian

Definition at line 184 of file ConvectiveMassElement.hpp.

◆ k

FTensor::Index<'k', 3> ConvectiveMassElement::OpMassJacobian::k

Definition at line 197 of file ConvectiveMassElement.hpp.

◆ lInear

bool& ConvectiveMassElement::OpMassJacobian::lInear

Definition at line 185 of file ConvectiveMassElement.hpp.

◆ methodsOp

boost::ptr_vector<MethodForForceScaling>& ConvectiveMassElement::OpMassJacobian::methodsOp

Definition at line 188 of file ConvectiveMassElement.hpp.

◆ tAg

int ConvectiveMassElement::OpMassJacobian::tAg

Definition at line 183 of file ConvectiveMassElement.hpp.

The documentation for this struct was generated from the following files:
Generated by Doxygen 1.9.8 and hosted at University of Glasgow