OOFEM  2.4
OOFEM.org - Object Oriented Finite Element Solver
fei3dwedgequad.C
Go to the documentation of this file.
1 /*
2  *
3  * ##### ##### ###### ###### ### ###
4  * ## ## ## ## ## ## ## ### ##
5  * ## ## ## ## #### #### ## # ##
6  * ## ## ## ## ## ## ## ##
7  * ## ## ## ## ## ## ## ##
8  * ##### ##### ## ###### ## ##
9  *
10  *
11  * OOFEM : Object Oriented Finite Element Code
12  *
13  * Copyright (C) 1993 - 2013 Borek Patzak
14  *
15  *
16  *
17  * Czech Technical University, Faculty of Civil Engineering,
18  * Department of Structural Mechanics, 166 29 Prague, Czech Republic
19  *
20  * This library is free software; you can redistribute it and/or
21  * modify it under the terms of the GNU Lesser General Public
22  * License as published by the Free Software Foundation; either
23  * version 2.1 of the License, or (at your option) any later version.
24  *
25  * This program is distributed in the hope that it will be useful,
26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
28  * Lesser General Public License for more details.
29  *
30  * You should have received a copy of the GNU Lesser General Public
31  * License along with this library; if not, write to the Free Software
32  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
33  */
34 
35 #include "fei3dwedgequad.h"
36 #include "floatarray.h"
37 #include "floatmatrix.h"
38 #include "intarray.h"
39 #include "gaussintegrationrule.h"
40 
41 namespace oofem {
42 void
43 FEI3dWedgeQuad :: evalN(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
44 {
45  double x, y, z;
46  answer.resize(15);
47 
48  x = lcoords.at(1);
49  y = lcoords.at(2);
50  z = lcoords.at(3);
51 
52  answer.at(1) = 0.5 * ( ( 1. - x - y ) * ( 2. * ( 1. - x - y ) - 1. ) * ( 1. - z ) - ( 1. - x - y ) * ( 1. - z * z ) );
53  answer.at(2) = 0.5 * ( x * ( 2. * x - 1. ) * ( 1. - z ) - x * ( 1. - z * z ) );
54  answer.at(3) = 0.5 * ( y * ( 2. * y - 1. ) * ( 1. - z ) - y * ( 1. - z * z ) );
55  answer.at(4) = 0.5 * ( ( 1. - x - y ) * ( 2. * ( 1. - x - y ) - 1. ) * ( 1. + z ) - ( 1. - x - y ) * ( 1. - z * z ) );
56  answer.at(5) = 0.5 * ( x * ( 2. * x - 1. ) * ( 1. + z ) - x * ( 1. - z * z ) );
57  answer.at(6) = 0.5 * ( y * ( 2. * y - 1. ) * ( 1. + z ) - y * ( 1. - z * z ) );
58  answer.at(7) = 2. * ( 1. - x - y ) * x * ( 1. - z );
59  answer.at(8) = 2. * x * y * ( 1. - z );
60  answer.at(9) = 2. * y * ( 1. - x - y ) * ( 1. - z );
61  answer.at(10) = 2. * x * ( 1. - x - y ) * ( 1. + z );
62  answer.at(11) = 2. * x * y * ( 1. + z );
63  answer.at(12) = 2. * y * ( 1. - x - y ) * ( 1. + z );
64  answer.at(13) = ( 1. - x - y ) * ( 1. - z * z );
65  answer.at(14) = x * ( 1. - z * z );
66  answer.at(15) = y * ( 1. - z * z );
67 }
68 
69 double
70 FEI3dWedgeQuad :: evaldNdx(FloatMatrix &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
71 {
72  FloatMatrix jacobianMatrix, inv, dNduvw, coords;
73  this->giveLocalDerivative(dNduvw, lcoords);
74  coords.resize(3, 15);
75  for ( int i = 1; i <= 15; i++ ) {
76  coords.setColumn(* cellgeo.giveVertexCoordinates(i), i);
77  }
78  jacobianMatrix.beProductOf(coords, dNduvw);
79  inv.beInverseOf(jacobianMatrix);
80 
81  answer.beProductOf(dNduvw, inv);
82  return jacobianMatrix.giveDeterminant();
83 }
84 
85 
86 void
87 FEI3dWedgeQuad :: giveLocalNodeCoords(FloatMatrix &answer)
88 {
89 
90  answer.resize(3,15);
91  answer.at(1,1) = 1.0; answer.at(2,1) = 0.0; answer.at(3,1) = -1.0;
92  answer.at(1,2) = 0.0; answer.at(2,2) = 1.0; answer.at(3,2) = -1.0;
93  answer.at(1,3) = 0.0; answer.at(2,3) = 0.0; answer.at(3,3) = -1.0;
94  answer.at(1,4) = 1.0; answer.at(2,4) = 0.0; answer.at(3,4) = 1.0;
95  answer.at(1,5) = 0.0; answer.at(2,5) = 1.0; answer.at(3,5) = 1.0;
96  answer.at(1,6) = 0.0; answer.at(2,6) = 0.0; answer.at(3,6) = 1.0;
97  answer.at(1,7) = 0.5; answer.at(2,7) = 0.5; answer.at(3,7) = -1.0;
98  answer.at(1,8) = 0.0; answer.at(2,8) = 0.5; answer.at(3,8) = -1.0;
99  answer.at(1,9) = 0.5; answer.at(2,9) = 0.0; answer.at(3,9) = -1.0;
100  answer.at(1,10) = 0.5; answer.at(2,10) = 0.5; answer.at(3,10) = 1.0;
101  answer.at(1,11) = 0.0; answer.at(2,11) = 0.5; answer.at(3,11) = 1.0;
102  answer.at(1,12) = 0.5; answer.at(2,12) = 0.0; answer.at(3,12) = 1.0;
103  answer.at(1,13) = 1.0; answer.at(2,13) = 0.0; answer.at(3,13) = 0.0;
104  answer.at(1,14) = 0.0; answer.at(2,14) = 1.0; answer.at(3,14) = 0.0;
105  answer.at(1,15) = 0.0; answer.at(2,15) = 0.0; answer.at(3,15) = 0.0;
106 
107 }
108 
109 
110 void
111 FEI3dWedgeQuad :: local2global(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
112 {
113  FloatArray n;
114  this->evalN(n, lcoords, cellgeo);
115 
116  answer.resize(3);
117  answer.zero();
118  for ( int i = 1; i <= 15; i++ ) {
119  answer.at(1) += n.at(i) * cellgeo.giveVertexCoordinates(i)->at(1);
120  answer.at(2) += n.at(i) * cellgeo.giveVertexCoordinates(i)->at(2);
121  answer.at(3) += n.at(i) * cellgeo.giveVertexCoordinates(i)->at(3);
122  }
123 }
124 
125 
126 int
127 FEI3dWedgeQuad :: global2local(FloatArray &answer, const FloatArray &coords, const FEICellGeometry &cellgeo)
128 {
129  OOFEM_ERROR("not implemented");
130  return 1;
131 }
132 
133 
134 double
135 FEI3dWedgeQuad :: giveTransformationJacobian(const FloatArray &lcoords, const FEICellGeometry &cellgeo)
136 {
137  FloatMatrix jacobianMatrix;
138 
139  this->giveJacobianMatrixAt(jacobianMatrix, lcoords, cellgeo);
140  return jacobianMatrix.giveDeterminant() / 2.;
141 }
142 
143 
144 void
145 FEI3dWedgeQuad :: giveJacobianMatrixAt(FloatMatrix &jacobianMatrix, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
146 // Returns the jacobian matrix J (x,y,z)/(ksi,eta,dzeta) of the receiver.
147 {
148  FloatMatrix dNduvw, coords;
149  this->giveLocalDerivative(dNduvw, lcoords);
150  coords.resize(3, 15);
151  for ( int i = 1; i <= 15; i++ ) {
152  coords.setColumn(* cellgeo.giveVertexCoordinates(i), i);
153  }
154  jacobianMatrix.beProductOf(coords, dNduvw);
155 }
156 
157 
158 void
159 FEI3dWedgeQuad :: giveLocalDerivative(FloatMatrix &dN, const FloatArray &lcoords)
160 {
161  double x, y, z;
162  x = lcoords.at(1);
163  y = lcoords.at(2);
164  z = lcoords.at(3);
165 
166  dN.resize(15, 3);
167 
168  dN.at(1, 1) = 1. / 2. - ( z - 1. ) * ( x + y - 1. ) - z * z / 2. - ( ( z - 1. ) * ( 2. * x + 2. * y - 1. ) ) / 2.;
169  dN.at(2, 1) = z * z / 2. - x * ( z - 1. ) - ( ( 2. * x - 1. ) * ( z - 1. ) ) / 2. - 1 / 2.;
170  dN.at(3, 1) = 0.;
171  dN.at(4, 1) = ( ( z + 1. ) * ( 2. * x + 2. * y - 1. ) ) / 2. + ( z + 1. ) * ( x + y - 1. ) - z * z / 2. + 1. / 2.;
172  dN.at(5, 1) = ( ( 2. * x - 1. ) * ( z + 1. ) ) / 2. + x * ( z + 1. ) + z * z / 2. - 1. / 2.;
173  dN.at(6, 1) = 0.;
174  dN.at(7, 1) = ( z - 1. ) * ( 2. * x + 2. * y - 2. ) + 2. * x * ( z - 1. );
175  dN.at(8, 1) = -2. * y * ( z - 1. );
176  dN.at(9, 1) = 2. * y * ( z - 1. );
177  dN.at(10, 1) = -2. * ( z + 1. ) * ( x + y - 1. ) - 2. * x * ( z + 1. );
178  dN.at(11, 1) = 2. * y * ( z + 1. );
179  dN.at(12, 1) = -2. * y * ( z + 1. );
180  dN.at(13, 1) = z * z - 1.;
181  dN.at(14, 1) = 1. - z * z;
182  dN.at(15, 1) = 0.;
183 
184 
185  dN.at(1, 2) = 1. / 2. - ( z - 1. ) * ( x + y - 1. ) - z * z / 2. - ( ( z - 1. ) * ( 2. * x + 2. * y - 1. ) ) / 2.;
186  dN.at(2, 2) = 0.;
187  dN.at(3, 2) = z * z / 2. - y * ( z - 1. ) - ( ( 2. * y - 1. ) * ( z - 1. ) ) / 2. - 1. / 2.;
188  dN.at(4, 2) = ( ( z + 1. ) * ( 2. * x + 2. * y - 1. ) ) / 2. + ( z + 1. ) * ( x + y - 1. ) - z * z / 2. + 1. / 2.;
189  dN.at(5, 2) = 0.;
190  dN.at(6, 2) = ( ( 2. * y - 1. ) * ( z + 1. ) ) / 2. + y * ( z + 1. ) + z * z / 2. - 1. / 2.;
191  dN.at(7, 2) = 2. * x * ( z - 1. );
192  dN.at(8, 2) = -2. * x * ( z - 1. );
193  dN.at(9, 2) = 2. * ( z - 1. ) * ( x + y - 1. ) + 2. * y * ( z - 1. );
194  dN.at(10, 2) = -2. * x * ( z + 1. );
195  dN.at(11, 2) = 2. * x * ( z + 1. );
196  dN.at(12, 2) = -2. * ( z + 1. ) * ( x + y - 1. ) - 2. * y * ( z + 1. );
197  dN.at(13, 2) = z * z - 1.;
198  dN.at(14, 2) = 0.;
199  dN.at(15, 2) = 1. - z * z;
200 
201 
202  dN.at(1, 3) = -z * ( x + y - 1. ) - ( ( 2. * x + 2. * y - 1. ) * ( x + y - 1. ) ) / 2.;
203  dN.at(2, 3) = x * z - ( x * ( 2. * x - 1. ) ) / 2.;
204  dN.at(3, 3) = y * z - ( y * ( 2 * y - 1. ) ) / 2.;
205  dN.at(4, 3) = ( ( 2. * x + 2. * y - 1. ) * ( x + y - 1. ) ) / 2. - z * ( x + y - 1. );
206  dN.at(5, 3) = ( x * ( 2. * x - 1. ) ) / 2. + x * z;
207  dN.at(6, 3) = ( y * ( 2. * y - 1. ) ) / 2. + y * z;
208  dN.at(7, 3) = x * ( 2. * x + 2. * y - 2. );
209  dN.at(8, 3) = -2. * x * y;
210  dN.at(9, 3) = 2. * y * ( x + y - 1. );
211  dN.at(10, 3) = -2. * x * ( x + y - 1. );
212  dN.at(11, 3) = 2. * x * y;
213  dN.at(12, 3) = -2. * y * ( x + y - 1. );
214  dN.at(13, 3) = 2. * z * ( x + y - 1. );
215  dN.at(14, 3) = -2. * x * z;
216  dN.at(15, 3) = -2. * y * z;
217 }
218 
219 
220 void FEI3dWedgeQuad :: edgeEvalN(FloatArray &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
221 {
222  double ksi = lcoords.at(1);
223  answer.resize(3);
224  answer.at(1) = ksi * ( ksi - 1. ) * 0.5;
225  answer.at(2) = ksi * ( 1. + ksi ) * 0.5;
226  answer.at(3) = ( 1. - ksi * ksi );
227 }
228 
229 
230 void FEI3dWedgeQuad :: edgeEvaldNdx(FloatMatrix &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
231 {
232  OOFEM_ERROR("not implemented");
233 }
234 
235 
236 void FEI3dWedgeQuad :: edgeLocal2global(FloatArray &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
237 {
238  IntArray nodes;
239  FloatArray n;
240 
241  this->computeLocalEdgeMapping(nodes, iedge);
242  this->edgeEvalN(n, iedge, lcoords, cellgeo);
243 
244  answer.clear();
245  for ( int i = 1; i <= n.giveSize(); ++i ) {
246  answer.add( n.at(i), * cellgeo.giveVertexCoordinates( nodes.at(i) ) );
247  }
248 }
249 
250 
251 void
252 FEI3dWedgeQuad :: computeLocalEdgeMapping(IntArray &edgeNodes, int iedge)
253 {
254  if ( iedge == 1 ) {
255  edgeNodes = {1, 2, 7};
256  } else if ( iedge == 2 ) {
257  edgeNodes = {2, 3, 8};
258  } else if ( iedge == 3 ) {
259  edgeNodes = {3, 1, 9};
260  } else if ( iedge == 4 ) {
261  edgeNodes = {4, 5, 10};
262  } else if ( iedge == 5 ) {
263  edgeNodes = {5, 6, 11};
264  } else if ( iedge == 6 ) {
265  edgeNodes = {6, 4, 12};
266  } else if ( iedge == 7 ) {
267  edgeNodes = {1, 4, 13};
268  } else if ( iedge == 8 ) {
269  edgeNodes = {2, 5, 14};
270  } else if ( iedge == 9 ) {
271  edgeNodes = {3, 6, 15};
272  } else {
273  OOFEM_ERROR("Edge %d doesn't exist.\n", iedge);
274  }
275 }
276 
277 
278 double FEI3dWedgeQuad :: edgeGiveTransformationJacobian(int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
279 {
280  OOFEM_ERROR("not implemented");
281  return 0.0;
282 }
283 
284 
285 void
286 FEI3dWedgeQuad :: surfaceEvalN(FloatArray &answer, int isurf, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
287 {
288  if ( isurf <= 2 ) {
289  double l1, l2, l3;
290  l1 = lcoords.at(1);
291  l2 = lcoords.at(2);
292  l3 = 1.0 - l1 - l2;
293 
294  answer.resize(6);
295  answer.at(1) = ( 2. * l1 - 1. ) * l1;
296  answer.at(2) = ( 2. * l2 - 1. ) * l2;
297  answer.at(3) = ( 2. * l3 - 1. ) * l3;
298  answer.at(4) = 4. * l1 * l2;
299  answer.at(5) = 4. * l2 * l3;
300  answer.at(6) = 4. * l3 * l1;
301  } else {
302  double ksi = lcoords.at(1);
303  double eta = lcoords.at(2);
304 
305  answer.resize(8);
306  answer.at(1) = ( 1. + ksi ) * ( 1. + eta ) * 0.25 * ( ksi + eta - 1. );
307  answer.at(2) = ( 1. - ksi ) * ( 1. + eta ) * 0.25 * ( -ksi + eta - 1. );
308  answer.at(3) = ( 1. - ksi ) * ( 1. - eta ) * 0.25 * ( -ksi - eta - 1. );
309  answer.at(4) = ( 1. + ksi ) * ( 1. - eta ) * 0.25 * ( ksi - eta - 1. );
310  answer.at(5) = 0.5 * ( 1. - ksi * ksi ) * ( 1. + eta );
311  answer.at(6) = 0.5 * ( 1. - ksi ) * ( 1. - eta * eta );
312  answer.at(7) = 0.5 * ( 1. - ksi * ksi ) * ( 1. - eta );
313  answer.at(8) = 0.5 * ( 1. + ksi ) * ( 1. - eta * eta );
314  }
315 }
316 
317 
318 void
319 FEI3dWedgeQuad :: surfaceLocal2global(FloatArray &answer, int isurf,
320  const FloatArray &lcoords, const FEICellGeometry &cellgeo)
321 {
322  IntArray nodes;
323  FloatArray n;
324 
325  this->computeLocalSurfaceMapping(nodes, isurf);
326  this->surfaceEvalN(n, isurf, lcoords, cellgeo);
327 
328  answer.clear();
329  for ( int i = 1; i <= n.giveSize(); ++i ) {
330  answer.add( n.at(i), * cellgeo.giveVertexCoordinates( nodes.at(i) ) );
331  }
332 }
333 
334 
335 void
336 FEI3dWedgeQuad :: computeLocalSurfaceMapping(IntArray &nodes, int isurf)
337 {
338  if ( isurf == 1 ) {
339  nodes = {1, 2, 3, 7, 8, 9};
340  } else if ( isurf == 2 ) {
341  nodes = {4, 5, 6, 10, 11, 12};
342  } else if ( isurf == 3 ) {
343  nodes = {1, 2, 5, 4, 7, 14, 10, 13};
344  } else if ( isurf == 4 ) {
345  nodes = {2, 3, 6, 5, 8, 15, 11, 14};
346  } else if ( isurf == 5 ) {
347  nodes = {3, 1, 4, 6, 9, 13, 12, 15};
348  } else {
349  OOFEM_ERROR("Surface %d doesn't exist.\n", isurf);
350  }
351 }
352 
353 
354 double
355 FEI3dWedgeQuad :: surfaceEvalNormal(FloatArray &answer, int isurf, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
356 {
357  FloatArray a, b, dNdksi, dNdeta;
358  IntArray snodes;
359 
360  this->computeLocalSurfaceMapping(snodes, isurf);
361 
362  if ( snodes.giveSize() == 6 ) {
363  double l1, l2, l3;
364  l1 = lcoords.at(1);
365  l2 = lcoords.at(2);
366  l3 = 1.0 - l1 - l2;
367 
368  dNdksi.resize(6);
369  dNdksi(0) = 4.0 * l1 - 1.0;
370  dNdksi(1) = 0.0;
371  dNdksi(2) = -1.0 * ( 4.0 * l3 - 1.0 );
372  dNdksi(3) = 4.0 * l2;
373  dNdksi(4) = -4.0 * l2;
374  dNdksi(5) = 4.0 * l3 - 4.0 * l1;
375 
376  dNdeta.resize(6);
377  dNdeta(0) = 0.0;
378  dNdeta(1) = 4.0 * l2 - 1.0;
379  dNdeta(2) = -1.0 * ( 4.0 * l3 - 1.0 );
380  dNdeta(3) = 4.0 * l1;
381  dNdeta(4) = 4.0 * l3 - 4.0 * l2;
382  dNdeta(5) = -4.0 * l1;
383  } else {
384  double ksi, eta;
385  ksi = lcoords.at(1);
386  eta = lcoords.at(2);
387 
388  dNdksi.resize(8);
389  dNdksi.at(1) = 0.25 * ( 1. + eta ) * ( 2.0 * ksi + eta );
390  dNdksi.at(2) = -0.25 * ( 1. + eta ) * ( -2.0 * ksi + eta );
391  dNdksi.at(3) = -0.25 * ( 1. - eta ) * ( -2.0 * ksi - eta );
392  dNdksi.at(4) = 0.25 * ( 1. - eta ) * ( 2.0 * ksi - eta );
393  dNdksi.at(5) = -ksi * ( 1. + eta );
394  dNdksi.at(6) = -0.5 * ( 1. - eta * eta );
395  dNdksi.at(7) = -ksi * ( 1. - eta );
396  dNdksi.at(8) = 0.5 * ( 1. - eta * eta );
397 
398  dNdeta.resize(8);
399  dNdeta.at(1) = 0.25 * ( 1. + ksi ) * ( 2.0 * eta + ksi );
400  dNdeta.at(2) = 0.25 * ( 1. - ksi ) * ( 2.0 * eta - ksi );
401  dNdeta.at(3) = -0.25 * ( 1. - ksi ) * ( -2.0 * eta - ksi );
402  dNdeta.at(4) = -0.25 * ( 1. + ksi ) * ( -2.0 * eta + ksi );
403  dNdeta.at(5) = 0.5 * ( 1. - ksi * ksi );
404  dNdeta.at(6) = -eta * ( 1. - ksi );
405  dNdeta.at(7) = -0.5 * ( 1. - ksi * ksi );
406  dNdeta.at(8) = -eta * ( 1. + ksi );
407  }
408 
409  for ( int i = 1; i <= snodes.giveSize(); ++i ) {
410  a.add( dNdksi.at(i), * cellgeo.giveVertexCoordinates( snodes.at(i) ) );
411  b.add( dNdeta.at(i), * cellgeo.giveVertexCoordinates( snodes.at(i) ) );
412  }
413 
414  answer.beVectorProductOf(a, b);
415  return answer.normalize();
416 }
417 
418 
419 double
420 FEI3dWedgeQuad :: surfaceGiveTransformationJacobian(int isurf, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
421 {
422  FloatArray normal;
423  return this->surfaceEvalNormal(normal, isurf, lcoords, cellgeo);
424 }
425 
426 
427 IntegrationRule *
428 FEI3dWedgeQuad :: giveIntegrationRule(int order)
429 {
430  IntegrationRule *iRule = new GaussIntegrationRule(1, NULL);
432  //int points = iRule->getRequiredNumberOfIntegrationPoints(_Wedge, order);
433  OOFEM_WARNING("Warning.. ignoring 'order' argument: FIXME");
434  int pointsZeta = 1;
435  int pointsTriangle = 1;
436  iRule->SetUpPointsOnWedge(pointsTriangle, pointsZeta, _Unknown);
437  return iRule;
438 }
439 
440 IntegrationRule *
441 FEI3dWedgeQuad :: giveBoundaryIntegrationRule(int order, int boundary)
442 {
443  IntegrationRule *iRule = new GaussIntegrationRule(1, NULL);
444  if ( boundary <= 2 ) {
445  int points = iRule->getRequiredNumberOfIntegrationPoints(_Triangle, order + 2);
446  iRule->SetUpPointsOnTriangle(points, _Unknown);
447  } else {
449  int points = iRule->getRequiredNumberOfIntegrationPoints(_Square, order + 2);
450  iRule->SetUpPointsOnSquare(points, _Unknown);
451  }
452  return iRule;
453 }
454 } // end namespace oofem
oofem::FloatMatrix::giveDeterminant
double giveDeterminant() const
Returns the trace (sum of diagonal components) of the receiver.
Definition: floatmatrix.C:1408
oofem::FEI3dWedgeQuad::giveJacobianMatrixAt
virtual void giveJacobianMatrixAt(FloatMatrix &jacobianMatrix, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Gives the jacobian matrix at the local coordinates.
Definition: fei3dwedgequad.C:145
oofem::FEI3dWedgeQuad::edgeLocal2global
virtual void edgeLocal2global(FloatArray &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates edge global coordinates from given local ones.
Definition: fei3dwedgequad.C:236
oofem::FloatArray::beVectorProductOf
void beVectorProductOf(const FloatArray &v1, const FloatArray &v2)
Computes vector product (or cross product) of vectors given as parameters, , and stores the result in...
Definition: floatarray.C:415
oofem::FEI3dWedgeQuad::surfaceEvalNormal
virtual double surfaceEvalNormal(FloatArray &answer, int isurf, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the normal out of the surface at given point.
Definition: fei3dwedgequad.C:355
oofem::FloatArray::at
double & at(int i)
Coefficient access function.
Definition: floatarray.h:131
oofem::FEI3dWedgeQuad::evaldNdx
virtual double evaldNdx(FloatMatrix &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the matrix of derivatives of interpolation functions (shape functions) at given point...
Definition: fei3dwedgequad.C:70
oofem::FEICellGeometry::giveVertexCoordinates
virtual const FloatArray * giveVertexCoordinates(int i) const =0
oofem::IntegrationRule::SetUpPointsOnWedge
virtual int SetUpPointsOnWedge(int nPointsTri, int nPointsDepth, MaterialMode mode)
Sets up receiver&#39;s integration points on a wedge integration domain.
Definition: integrationrule.h:338
oofem::FEICellGeometry
Class representing a general abstraction for cell geometry.
Definition: feinterpol.h:62
oofem::FloatArray::clear
void clear()
Clears receiver (zero size).
Definition: floatarray.h:206
oofem::FEI3dWedgeQuad::giveLocalNodeCoords
virtual void giveLocalNodeCoords(FloatMatrix &answer)
Returns a matrix containing the local coordinates for each node corresponding to the interpolation...
Definition: fei3dwedgequad.C:87
oofem::FEI3dWedgeQuad::edgeGiveTransformationJacobian
virtual double edgeGiveTransformationJacobian(int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the edge jacobian of transformation between local and global coordinates.
Definition: fei3dwedgequad.C:278
oofem::IntegrationRule::SetUpPointsOnSquare
virtual int SetUpPointsOnSquare(int, MaterialMode mode)
Sets up receiver&#39;s integration points on unit square integration domain.
Definition: integrationrule.h:277
oofem::IntArray
Class implementing an array of integers.
Definition: intarray.h:61
oofem::IntArray::at
int & at(int i)
Coefficient access function.
Definition: intarray.h:103
oofem::FEI3dWedgeQuad::giveBoundaryIntegrationRule
virtual IntegrationRule * giveBoundaryIntegrationRule(int order, int boundary)
Sets up a suitable integration rule for integrating over the requested boundary.
Definition: fei3dwedgequad.C:441
oofem::IntegrationRule
Abstract base class representing integration rule.
Definition: integrationrule.h:94
oofem::FEI3dWedgeQuad::giveIntegrationRule
virtual IntegrationRule * giveIntegrationRule(int order)
Sets up a suitable integration rule for numerical integrating over volume.
Definition: fei3dwedgequad.C:428
OOFEM_ERROR
#define OOFEM_ERROR(...)
Definition: error.h:61
oofem::FEI3dWedgeQuad::surfaceEvalN
virtual void surfaceEvalN(FloatArray &answer, int isurf, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the array of edge interpolation functions (shape functions) at given point.
Definition: fei3dwedgequad.C:286
oofem::FEI3dWedgeQuad::computeLocalEdgeMapping
virtual void computeLocalEdgeMapping(IntArray &edgeNodes, int iedge)
Definition: fei3dwedgequad.C:252
oofem::FEI3dWedgeQuad::surfaceGiveTransformationJacobian
virtual double surfaceGiveTransformationJacobian(int isurf, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the edge jacobian of transformation between local and global coordinates.
Definition: fei3dwedgequad.C:420
oofem::FloatMatrix::at
double at(int i, int j) const
Coefficient access function.
Definition: floatmatrix.h:176
oofem::FEI3dWedgeQuad::edgeEvaldNdx
virtual void edgeEvaldNdx(FloatMatrix &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the matrix of derivatives of edge interpolation functions (shape functions) at given point...
Definition: fei3dwedgequad.C:230
oofem::FEI3dWedgeQuad::evalN
virtual void evalN(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the array of interpolation functions (shape functions) at given point.
Definition: fei3dwedgequad.C:43
oofem::FloatArray
Class representing vector of real numbers.
Definition: floatarray.h:82
oofem::FloatMatrix
Implementation of matrix containing floating point numbers.
Definition: floatmatrix.h:94
oofem::FloatMatrix::resize
void resize(int rows, int cols)
Checks size of receiver towards requested bounds.
Definition: floatmatrix.C:1358
oofem::IntegrationRule::getRequiredNumberOfIntegrationPoints
virtual int getRequiredNumberOfIntegrationPoints(integrationDomain dType, int approxOrder)
Abstract service.
Definition: integrationrule.h:215
oofem::FloatArray::zero
void zero()
Zeroes all coefficients of receiver.
Definition: floatarray.C:658
oofem::FEI3dWedgeQuad::surfaceLocal2global
virtual void surfaceLocal2global(FloatArray &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates edge global coordinates from given local ones.
Definition: fei3dwedgequad.C:319
oofem::FloatMatrix::setColumn
void setColumn(const FloatArray &src, int c)
Sets the values of the matrix in specified column.
Definition: floatmatrix.C:648
oofem::FEI3dWedgeQuad::computeLocalSurfaceMapping
virtual void computeLocalSurfaceMapping(IntArray &nodes, int iSurf)
Definition: fei3dwedgequad.C:336
oofem::FEI3dWedgeQuad::giveTransformationJacobian
virtual double giveTransformationJacobian(const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the determinant of the transformation.
Definition: fei3dwedgequad.C:135
oofem::IntegrationRule::SetUpPointsOnTriangle
virtual int SetUpPointsOnTriangle(int, MaterialMode mode)
Sets up receiver&#39;s integration points on triangular (area coords) integration domain.
Definition: integrationrule.h:270
oofem::FEI3dWedgeQuad::giveLocalDerivative
void giveLocalDerivative(FloatMatrix &dN, const FloatArray &lcoords)
Definition: fei3dwedgequad.C:159
oofem::FloatMatrix::beProductOf
void beProductOf(const FloatMatrix &a, const FloatMatrix &b)
Assigns to the receiver product of .
Definition: floatmatrix.C:337
oofem::IntArray::giveSize
int giveSize() const
Definition: intarray.h:203
oofem::FloatArray::giveSize
int giveSize() const
Returns the size of receiver.
Definition: floatarray.h:218
oofem
the oofem namespace is to define a context or scope in which all oofem names are defined.
oofem::FloatMatrix::beInverseOf
void beInverseOf(const FloatMatrix &src)
Modifies receiver to become inverse of given parameter.
Definition: floatmatrix.C:835
oofem::FEI3dWedgeQuad::global2local
virtual int global2local(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates local coordinates from given global ones.
Definition: fei3dwedgequad.C:127
oofem::FloatArray::normalize
double normalize()
Normalizes receiver.
Definition: floatarray.C:828
OOFEM_WARNING
#define OOFEM_WARNING(...)
Definition: error.h:62
oofem::FEI3dWedgeQuad::local2global
virtual void local2global(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates global coordinates from given local ones.
Definition: fei3dwedgequad.C:111
oofem::FloatArray::add
void add(const FloatArray &src)
Adds array src to receiver.
Definition: floatarray.C:156
oofem::FEI3dWedgeQuad::edgeEvalN
virtual void edgeEvalN(FloatArray &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
Evaluates the array of edge interpolation functions (shape functions) at given point.
Definition: fei3dwedgequad.C:220
oofem::GaussIntegrationRule
Class representing Gaussian-quadrature integration rule.
Definition: gaussintegrationrule.h:59
oofem::FloatArray::resize
void resize(int s)
Resizes receiver towards requested size.
Definition: floatarray.C:631
This page is part of the OOFEM documentation. Copyright (c) 2011 Borek Patzak
Project e-mail: info@oofem.org
Generated at Tue Jan 2 2018 20:07:28 for OOFEM by doxygen 1.8.11 written by Dimitri van Heesch, © 1997-2011