OOFEM  2.4
OOFEM.org - Object Oriented Finite Element Solver
lattice2d_mt.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 "lattice2d_mt.h"
36 #include "transportmaterial.h"
37 #include "latticetransmat.h"
38 #include "node.h"
39 #include "material.h"
40 #include "crosssection.h"
41 #include "gausspoint.h"
42 #include "gaussintegrationrule.h"
43 #include "floatmatrix.h"
44 #include "floatarray.h"
45 #include "intarray.h"
46 #include "domain.h"
47 #include "mathfem.h"
48 #include "engngm.h"
49 #include "load.h"
50 #include "classfactory.h"
51 
52 #ifdef __OOFEG
53  #include "oofeggraphiccontext.h"
54  #include "connectivitytable.h"
55 #endif
56 
57 namespace oofem {
58 REGISTER_Element(Lattice2d_mt);
59 
61  LatticeTransportElement(n, aDomain, em)
62  // Constructor.
63 {
64  numberOfDofMans = 2;
65  area = -1.0;
66  length = 0.0;
67  couplingFlag = 0;
69  crackWidths.zero();
71 }
72 
74 // Destructor
75 { }
76 
78 // Returns the length of the receiver.
79 {
80  double dx, dy;
81  Node *nodeA, *nodeB;
82 
83  if ( length == 0. ) {
84  nodeA = this->giveNode(1);
85  nodeB = this->giveNode(2);
86  dx = nodeB->giveCoordinate(1) - nodeA->giveCoordinate(1);
87  dy = nodeB->giveCoordinate(2) - nodeA->giveCoordinate(2);
88  length = sqrt(dx * dx + dy * dy);
89  }
90 
91  return length;
92 }
93 
94 double
96 {
99  GaussPoint *gp = iRule->getIntegrationPoint(0);
100 
101  status = static_cast< LatticeTransportMaterialStatus * >( gp->giveMaterialStatus() );
102 
103  return status->givePressure();
104 }
105 
106 double
108 {
111  GaussPoint *gp = iRule->getIntegrationPoint(0);
112 
113  status = static_cast< LatticeTransportMaterialStatus * >( gp->giveMaterialStatus() );
114 
115  return status->giveOldPressure();
116 }
117 
118 
119 double
121 {
123 
125  GaussPoint *gp = iRule->getIntegrationPoint(0);
126 
127  status = static_cast< LatticeTransportMaterialStatus * >( gp->giveMaterialStatus() );
128  double mass = 0;
129  mass = status->giveMass();
130  //multiply with volume
131  mass *= this->length * this->width / 2.;
132 
133  return mass;
134 }
135 
136 
137 void
139 {
140  double ksi, n1, n2;
141  //FloatMatrix* answer ;
142 
143  ksi = coords.at(1);
144  n1 = ( 1. - ksi ) * 0.5;
145  n2 = ( 1. + ksi ) * 0.5;
146 
147  answer.resize(1, 2);
148  answer.zero();
149 
150  answer.at(1, 1) = n1;
151  answer.at(1, 2) = n2;
152 }
153 
154 void
156 {
157  this->computeNSubMatrixAt(answer, coords);
158 }
159 
160 
161 void
163 {
164  double l = this->giveLength();
165 
166  // Assemble Gradient Matrix used to compute temperature gradient
167  answer.resize(1, 2);
168  answer.zero();
169  answer.at(1, 1) = -1.;
170  answer.at(1, 2) = 1.;
171 
172  answer.times(1. / l);
173 }
174 
175 void
177 // Updates the receiver at end of step.
178 {
179  FloatArray f, r;
180  FloatMatrix n;
181  TransportMaterial *mat = static_cast< TransportMaterial * >( this->giveMaterial() );
182 
183  // force updating ip values
184  for ( auto &iRule: integrationRulesArray ) {
185  for ( GaussPoint *gp: *iRule ) {
186  this->computeNmatrixAt( n, gp->giveNaturalCoordinates() );
187  this->computeVectorOf({P_f}, VM_Total, tStep, r);
188  f.beProductOf(n, r);
189  mat->updateInternalState(f, gp, tStep);
190  }
191  }
192 }
193 
194 
195 void
197 // Sets up the array containing the four Gauss points of the receiver.
198 {
199  integrationRulesArray.resize( 1 );
200  integrationRulesArray [ 0 ].reset( new GaussIntegrationRule(1, this, 1, 2) );
201  integrationRulesArray [ 0 ]->SetUpPointsOnLine(1, _2dMTLattice);
202 }
203 
204 void
206 {
207  answer = {P_f};
208 }
209 
212 {
213  IRResultType result; // Required by IR_GIVE_FIELD macro
214 
215  // first call parent
217  if ( result != IRRT_OK ) return result;
218 
219  dimension = 2.;
221 
223 
225  crackLengths.resize(1);
226  crackLengths.at(1) = width;
227 
228 
230 
231  crackWidths.resize(1);
232  crackWidths.zero();
234 
235  couplingFlag = 0;
237 
240  if ( couplingFlag == 1 ) {
242  }
243 
245 
246  return IRRT_OK;
247 }
248 
249 double
251 // Returns the portion of the receiver which is attached to gp.
252 {
253  return this->width *this->thickness *this->giveLength();
254 }
255 
256 void
258 {
259  double dV;
260  FloatMatrix b, d, db;
261  GaussPoint *gp;
262  std :: unique_ptr< IntegrationRule >&iRule = integrationRulesArray [ 0 ];
263  gp = iRule->getIntegrationPoint(0);
264 
265  double length = giveLength();
266  double k;
267 
268  answer.resize(2, 2);
269  answer.zero();
270  answer.at(1, 1) = 1.;
271  answer.at(1, 2) = -1.;
272  answer.at(2, 1) = -1;
273  answer.at(2, 2) = 1.;
274 
275  k = static_cast< TransportMaterial * >( this->giveMaterial() )->giveCharacteristicValue(Conductivity, gp, tStep);
276  dV = this->computeVolumeAround(gp);
277  double temp = k * dV / pow(length, 2.);
278  answer.times(temp);
279 }
280 
281 
282 void
284 {
285  double dV, c;
286  FloatMatrix n;
287  GaussPoint *gp = integrationRulesArray [ 0 ]->getIntegrationPoint(0);
288  answer.resize(2, 2);
289  answer.zero();
290  answer.at(1, 1) = 2.;
291  answer.at(1, 2) = 1.;
292  answer.at(2, 1) = 1.;
293  answer.at(2, 2) = 2.;
294  c = static_cast< TransportMaterial * >( this->giveMaterial() )->giveCharacteristicValue(Capacity, gp, tStep);
295  dV = this->computeVolumeAround(gp) / ( 6.0 * this->dimension );
296  answer.times(c * dV);
297 }
298 
299 
300 
301 void
303 {
304  int n, nLoads;
305  double dV;
306  bcGeomType ltype;
307  Load *load;
308  std :: unique_ptr< IntegrationRule > &iRule = integrationRulesArray [ 0 ];
309  Node *nodeA, *nodeB;
310 
311 
312  FloatArray deltaX(3);
313  FloatArray val, helpLoadVector, globalIPcoords;
314  FloatMatrix nm;
315  double k;
316  answer.clear();
317 
318  FloatArray gravityHelp(2);
319 
320  nLoads = this->giveBodyLoadArray()->giveSize();
321  for ( int i = 1; i <= nLoads; i++ ) {
322  n = bodyLoadArray.at(i);
323  load = domain->giveLoad(n);
324  ltype = load->giveBCGeoType();
325 
326  if ( ltype == GravityPressureBGT ) {
327  //Compute change of coordinates
328  nodeA = this->giveNode(1);
329  nodeB = this->giveNode(2);
330  deltaX.at(1) = nodeB->giveCoordinate(1) - nodeA->giveCoordinate(1);
331  deltaX.at(2) = nodeB->giveCoordinate(2) - nodeA->giveCoordinate(2);
332  deltaX.at(3) = nodeB->giveCoordinate(2) - nodeA->giveCoordinate(2);
333 
334  //Compute the local coordinate system
335  GaussPoint *gp = iRule->getIntegrationPoint(0);
336 
337  gravityHelp.at(1) = 1.;
338  gravityHelp.at(2) = -1.;
339 
340  dV = this->computeVolumeAround(gp);
341  load->computeValueAt(val, tStep, deltaX, mode);
342 
343  k = static_cast< TransportMaterial * >( this->giveMaterial() )->giveCharacteristicValue(Conductivity, gp, tStep);
344 
345  double helpFactor = val.at(1) * k * dV;
346 
347  helpFactor /= pow(this->giveLength(), 2.);
348  gravityHelp.times(helpFactor);
349 
350  if ( helpLoadVector.isEmpty() ) {
351  helpLoadVector.resize( gravityHelp.giveSize() );
352  }
353 
354  for ( int j = 1; j <= gravityHelp.giveSize(); j++ ) {
355  helpLoadVector.at(j) += gravityHelp.at(j);
356  }
357  }
358 
359  answer.add(helpLoadVector);
360  }
361 }
362 
363 
364 void
366 {
367  answer.resize(3);
368  answer.at(1) = this->gpCoords.at(1);
369  answer.at(2) = this->gpCoords.at(2);
370 }
371 
372 int
374 {
375  answer.resize(3);
376  answer.at(1) = this->gpCoords.at(1);
377  answer.at(2) = this->gpCoords.at(2);
378 
379  return 1;
380 }
381 
382 #define POINT_TOL 1.e-3
383 
384 bool
386 {
387  answer.resize(1);
388  answer.at(1) = 0.;
389 
390  return true;
391 }
392 
393 
394 #ifdef __OOFEG
395 
396 
397 void
399 {
401 
402  if ( mode == OGC_rawGeometry ) {
403  this->drawRawGeometry(gc, tStep);
404  this->drawRawCrossSections(gc, tStep);
405  } else {
406  OOFEM_ERROR("unsupported mode");
407  }
408 }
409 
410 
411 
412 
414 {
415  GraphicObj *go;
416  // if (!go) { // create new one
417  WCRec p [ 2 ]; /* poin */
418  if ( !gc.testElementGraphicActivity(this) ) {
419  return;
420  }
421 
422  EASValsSetLineWidth(OOFEG_RAW_GEOMETRY_WIDTH);
423  EASValsSetColor( gc.getElementColor() );
424  EASValsSetLayer(OOFEG_RAW_GEOMETRY_LAYER);
425  p [ 0 ].x = ( FPNum ) this->giveNode(1)->giveCoordinate(1);
426  p [ 0 ].y = ( FPNum ) this->giveNode(1)->giveCoordinate(2);
427  p [ 0 ].z = 0.;
428  p [ 1 ].x = ( FPNum ) this->giveNode(2)->giveCoordinate(1);
429  p [ 1 ].y = ( FPNum ) this->giveNode(2)->giveCoordinate(2);
430  p [ 1 ].z = 0.;
431 
432  go = CreateLine3D(p);
433  EGWithMaskChangeAttributes(WIDTH_MASK | COLOR_MASK | LAYER_MASK, go);
434  EGAttachObject(go, ( EObjectP ) this);
435  EMAddGraphicsToModel(ESIModel(), go);
436 }
437 
439 {
440  GraphicObj *go;
441 
442  // if (!go) { // create new one
443  WCRec p [ 2 ]; /* poin */
444  if ( !gc.testElementGraphicActivity(this) ) {
445  return;
446  }
447 
448  EASValsSetLineWidth(OOFEG_RAW_GEOMETRY_WIDTH);
449  EASValsSetColor( gc.getCrossSectionColor() );
450  EASValsSetLayer(OOFEG_RAW_CROSSSECTION_LAYER);
451 
452  FloatArray coords;
453  this->giveCrossSectionCoordinates(coords);
454 
455  p [ 0 ].x = ( FPNum ) coords.at(1);
456  p [ 0 ].y = ( FPNum ) coords.at(2);
457  p [ 0 ].z = ( FPNum ) coords.at(3);
458  p [ 1 ].x = ( FPNum ) coords.at(4);
459  p [ 1 ].y = ( FPNum ) coords.at(5);
460  p [ 1 ].z = ( FPNum ) coords.at(6);
461 
462  go = CreateLine3D(p);
463  EGWithMaskChangeAttributes(WIDTH_MASK | COLOR_MASK | LAYER_MASK, go);
464  EGAttachObject(go, ( EObjectP ) this);
465  EMAddGraphicsToModel(ESIModel(), go);
466 }
467 
468 void
470 {
471  double x1, y1, x2, y2;
472  x1 = this->giveNode(1)->giveCoordinate(1);
473  y1 = this->giveNode(1)->giveCoordinate(2);
474  x2 = this->giveNode(2)->giveCoordinate(1);
475  y2 = this->giveNode(2)->giveCoordinate(2);
476 
477  //Compute normal and shear direction
478  FloatArray normalDirection;
479  FloatArray shearDirection;
480  normalDirection.resize(2);
481  normalDirection.zero();
482  shearDirection.resize(2);
483  shearDirection.zero();
484  normalDirection.at(1) = x2 - x1;
485  normalDirection.at(2) = y2 - y1;
486  normalDirection.normalize();
487  if ( normalDirection.at(2) == 0. ) {
488  shearDirection.at(1) = 0.;
489  shearDirection.at(2) = 1.;
490  } else {
491  shearDirection.at(1) = 1.0;
492  shearDirection.at(2) =
493  -normalDirection.at(1) / normalDirection.at(2);
494  }
495 
496  shearDirection.normalize();
497 
498  coords.resize(6);
499  coords.at(1) = this->gpCoords.at(1) - shearDirection.at(1) * this->width / 2.;
500  coords.at(2) = this->gpCoords.at(2) - shearDirection.at(2) * this->width / 2.;
501  coords.at(3) = 0.;
502  coords.at(4) = this->gpCoords.at(1) + shearDirection.at(1) * this->width / 2.;
503  coords.at(5) = this->gpCoords.at(2) + shearDirection.at(2) * this->width / 2.;
504  coords.at(6) = 0.;
505 }
506 
507 
508 
509 
510 
511 #endif
512 } // end namespace oofem
FloatArray crackWidths
Definition: lattice2d_mt.h:67
int testElementGraphicActivity(Element *)
Test if particular element passed fulfills various filtering criteria for its graphics output...
virtual IRResultType initializeFrom(InputRecord *ir)
Initializes receiver according to object description stored in input record.
Definition: lattice2d_mt.C:211
#define _IFT_Lattice2DMT_couplingflag
Definition: lattice2d_mt.h:49
virtual int computeGlobalCoordinates(FloatArray &answer, const FloatArray &lcoords)
Computes the global coordinates from given element&#39;s local coordinates.
Definition: lattice2d_mt.C:373
Class and object Domain.
Definition: domain.h:115
void computeVectorOf(ValueModeType u, TimeStep *tStep, FloatArray &answer)
Returns local vector of unknowns.
Definition: element.C:86
virtual IntegrationRule * giveDefaultIntegrationRulePtr()
Access method for default integration rule.
Definition: element.h:822
Domain * domain
Link to domain object, useful for communicating with other FEM components.
Definition: femcmpnn.h:82
This class implements associated Material Status to LatticeTransportMaterial.
bcGeomType
Type representing the geometric character of loading.
Definition: bcgeomtype.h:40
void zero()
Sets all component to zero.
Definition: intarray.C:52
double & at(int i)
Coefficient access function.
Definition: floatarray.h:131
#define OOFEG_RAW_CROSSSECTION_LAYER
#define _IFT_Lattice2DMT_dim
Definition: lattice2d_mt.h:44
ValueModeType
Type representing the mode of UnknownType or CharType, or similar types.
Definition: valuemodetype.h:78
virtual void computeInternalSourceRhsVectorAt(FloatArray &answer, TimeStep *, ValueModeType mode)
Computes the contribution to balance equation(s) due to internal sources.
Definition: lattice2d_mt.C:302
#define OOFEG_RAW_GEOMETRY_LAYER
virtual void drawRawGeometry(oofegGraphicContext &gc, TimeStep *tStep)
Definition: lattice2d_mt.C:413
void clear()
Clears receiver (zero size).
Definition: floatarray.h:206
oofem::oofegGraphicContext gc[OOFEG_LAST_LAYER]
virtual void computeValueAt(FloatArray &answer, TimeStep *tStep, const FloatArray &coords, ValueModeType mode)=0
Computes components values of load at given point - global coordinates (coordinates given)...
virtual void computeGaussPoints()
Initializes the array of integration rules member variable.
Definition: lattice2d_mt.C:196
virtual void computeConductivityMatrix(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
Computes the conductivity matrix of the receiver.
Definition: lattice2d_mt.C:257
virtual double giveCoordinate(int i)
Definition: node.C:82
virtual double giveLength()
Returns the element length.
Definition: lattice2d_mt.C:77
Class implementing an array of integers.
Definition: intarray.h:61
int & at(int i)
Coefficient access function.
Definition: intarray.h:103
MatResponseMode
Describes the character of characteristic material matrix.
Pressure due to distributed body load.
Definition: bcgeomtype.h:47
virtual void updateInternalState(TimeStep *tStep)
Updates element state after equilibrium in time step has been reached.
Definition: lattice2d_mt.C:176
Abstract base class representing integration rule.
virtual double giveMass()
Returns the mass.
Definition: lattice2d_mt.C:120
Lattice2d_mt(int, Domain *, ElementMode em=HeatTransferEM)
Definition: lattice2d_mt.C:60
virtual void drawRawCrossSections(oofegGraphicContext &gc, TimeStep *tStep)
Definition: lattice2d_mt.C:438
virtual double givePressure()
Returns the pressure.
Definition: lattice2d_mt.C:95
FloatArray crackLengths
Definition: lattice2d_mt.h:68
virtual void drawYourself(oofegGraphicContext &gc, TimeStep *tStep)
Definition: lattice2d_mt.C:398
#define OOFEM_ERROR(...)
Definition: error.h:61
REGISTER_Element(LSpace)
virtual void computeNmatrixAt(FloatMatrix &n, const FloatArray &)
Computes the interpolation matrix corresponding to all unknowns.
Definition: lattice2d_mt.C:155
#define OOFEG_RAW_GEOMETRY_WIDTH
#define _IFT_Lattice2DMT_thick
Definition: lattice2d_mt.h:45
void times(double f)
Multiplies receiver by factor f.
Definition: floatmatrix.C:1594
virtual void computeNSubMatrixAt(FloatMatrix &n, const FloatArray &)
Definition: lattice2d_mt.C:138
IRResultType initializeFrom(InputRecord *ir)
Initializes receiver according to object description stored in input record.
IntArray * giveBodyLoadArray()
Returns array containing load numbers of loads acting on element.
Definition: element.C:372
void beProductOf(const FloatMatrix &aMatrix, const FloatArray &anArray)
Receiver becomes the result of the product of aMatrix and anArray.
Definition: floatarray.C:676
IntArray bodyLoadArray
Array containing indexes of loads (body loads and boundary loads are kept separately), that apply on receiver.
Definition: element.h:160
virtual double giveCharacteristicValue(CharType type, TimeStep *tStep)
Computes characteristic value of receiver of requested type in given time step.
Definition: element.C:627
bool isEmpty() const
Returns true if receiver is empty.
Definition: floatarray.h:222
double at(int i, int j) const
Coefficient access function.
Definition: floatmatrix.h:176
void resize(int n)
Checks size of receiver towards requested bounds.
Definition: intarray.C:124
virtual ~Lattice2d_mt()
Definition: lattice2d_mt.C:73
#define _IFT_Lattice2DMT_gpcoords
Definition: lattice2d_mt.h:47
virtual void updateInternalState(const FloatArray &state, GaussPoint *gp, TimeStep *tStep)
Updates internal state of material according to new state vector.
int numberOfGaussPoints
Number of integration points as specified by nip.
Definition: element.h:188
double givePressure()
Returns pressure.
virtual double computeVolumeAround(GaussPoint *)
Returns volume related to given integration point.
Definition: lattice2d_mt.C:250
Class representing vector of real numbers.
Definition: floatarray.h:82
IntArray couplingNumbers
Definition: lattice2d_mt.h:66
Implementation of matrix containing floating point numbers.
Definition: floatmatrix.h:94
#define _IFT_Lattice2DMT_couplingnumber
Definition: lattice2d_mt.h:50
IRResultType
Type defining the return values of InputRecord reading operations.
Definition: irresulttype.h:47
GaussPoint * getIntegrationPoint(int n)
Access particular integration point of receiver.
FloatArray gpCoords
Definition: lattice2d_mt.h:71
IntegrationPointStatus * giveMaterialStatus()
Returns reference to associated material status (NULL if not defined).
Definition: gausspoint.h:205
#define _IFT_Lattice2DMT_crackwidth
Definition: lattice2d_mt.h:48
void resize(int rows, int cols)
Checks size of receiver towards requested bounds.
Definition: floatmatrix.C:1358
Class representing the general Input Record.
Definition: inputrecord.h:101
#define _IFT_Lattice2DMT_width
Definition: lattice2d_mt.h:46
void zero()
Zeroes all coefficients of receiver.
Definition: floatarray.C:658
virtual bcGeomType giveBCGeoType() const
Returns geometry character of boundary condition.
Abstract base class for all constitutive models for transport problems.
virtual void computeGradientMatrixAt(FloatMatrix &answer, const FloatArray &lcoords)
Computes the gradient matrix corresponding to one unknown.
Definition: lattice2d_mt.C:162
void times(double s)
Multiplies receiver with scalar.
Definition: floatarray.C:818
std::vector< std::unique_ptr< IntegrationRule > > integrationRulesArray
List of integration rules of receiver (each integration rule contains associated integration points a...
Definition: element.h:170
void zero()
Zeroes all coefficient of receiver.
Definition: floatmatrix.C:1326
virtual void giveDofManDofIDMask(int inode, IntArray &) const
Returns dofmanager dof mask for node.
Definition: lattice2d_mt.C:205
Load is base abstract class for all loads.
Definition: load.h:61
#define IR_GIVE_OPTIONAL_FIELD(__ir, __value, __id)
Macro facilitating the use of input record reading methods.
Definition: inputrecord.h:78
int giveSize() const
Definition: intarray.h:203
int giveSize() const
Returns the size of receiver.
Definition: floatarray.h:218
the oofem namespace is to define a context or scope in which all oofem names are defined.
virtual void giveCrossSectionCoordinates(FloatArray &coords)
Definition: lattice2d_mt.C:469
virtual double giveOldPressure()
Returns the old pressure.
Definition: lattice2d_mt.C:107
Class implementing node in finite element mesh.
Definition: node.h:87
#define IR_GIVE_FIELD(__ir, __value, __id)
Macro facilitating the use of input record reading methods.
Definition: inputrecord.h:69
double normalize()
Normalizes receiver.
Definition: floatarray.C:828
virtual void computeCapacityMatrix(FloatMatrix &answer, TimeStep *tStep)
Computes the capacity matrix of the receiver.
Definition: lattice2d_mt.C:283
Node * giveNode(int i) const
Returns reference to the i-th node of element.
Definition: element.h:610
virtual Material * giveMaterial()
Load * giveLoad(int n)
Service for accessing particular domain load.
Definition: domain.C:222
virtual bool computeLocalCoordinates(FloatArray &answer, const FloatArray &gcoords)
Computes the element local coordinates from given global coordinates.
Definition: lattice2d_mt.C:385
Class representing integration point in finite element program.
Definition: gausspoint.h:93
virtual void giveGpCoordinates(FloatArray &coords)
Gives the GP coordinates.
Definition: lattice2d_mt.C:365
Class representing solution step.
Definition: timestep.h:80
int numberOfDofMans
Number of dofmanagers.
Definition: element.h:149
void add(const FloatArray &src)
Adds array src to receiver.
Definition: floatarray.C:156
Class representing Gaussian-quadrature integration rule.
void resize(int s)
Resizes receiver towards requested size.
Definition: floatarray.C:631
OGC_PlotModeType giveIntVarPlotMode()

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:29 for OOFEM by doxygen 1.8.11 written by Dimitri van Heesch, © 1997-2011