OOFEM  2.4 OOFEM.org - Object Oriented Finite Element Solver
hemotkmat.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
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 "hemotkmat.h"
36 #include "floatmatrix.h"
37 #include "gausspoint.h"
38 #include "mathfem.h"
39 #include "classfactory.h"
40
41 namespace oofem {
42 REGISTER_Material(HeMoTKMaterial);
43
44 int
46 {
47  if ( ( mode == _2dHeMo ) || ( mode == _3dHeMo ) ) {
48  return 1;
49  }
50
51  return 0;
52 }
53
54
57 {
58  IRResultType result; // Required by IR_GIVE_FIELD macro
59
64
68
73
76
77  return Material :: initializeFrom(ir);
78 }
79
80
81 double
83 //
84 // Returns the value of the property aProperty (e.g. the Young's modulus
85 // 'E') of the receiver.
86 //
87 {
88  return Material :: give(aProperty, gp);
89 }
90
91
92 void
93 HeMoTKMaterial :: giveFluxVector(FloatArray &answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep)
94 {
95  TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
96
97  double w = field.at(2);
98  double t = field.at(1);
99
100  FloatArray ans_w, ans_t;
102  int size = grad.giveSize() / 2;
103  for ( int i = 1; i <= size; ++i ) {
105  }
106  for ( int i = size + 1; i <= size * 2; ++i ) {
108  }
111  ans_t.beScaled(perm_ww(w, t) * get_latent(w, t), grad_w);
112  ans_t.beScaled(get_chi(w, t) + get_latent(w, t) * perm_wt(w, t), grad_t);
113
118
119  ms->setTempField(field);
122 }
123
124
125 void
127  MatResponseMode mode,
128  GaussPoint *gp,
129  TimeStep *tStep)
130 {
131  /*
132  * returns constitutive matrix of receiver
133  */
134  if ( ( mode == Conductivity_ww ) || ( mode == Conductivity_hh ) || ( mode == Conductivity_hw ) || ( mode == Conductivity_wh ) ) {
136  } else {
137  OOFEM_ERROR("unknown mode (%s)", __MatResponseModeToString(mode) );
138  }
139 }
140
141
142 double
144  GaussPoint *gp,
145  TimeStep *tStep)
146 {
147  return this->computeCapacityCoeff(mode, gp, tStep);
148 }
149
150
152 {
153  MaterialMode mmode = gp->giveMaterialMode();
154  switch ( mmode ) {
155  case _2dHeMo:
157  return;
158
159  case _3dHeMo:
161  return;
162
163  default:
164  OOFEM_ERROR("Unsupported MaterialMode");
165  }
166 }
167
168
169 void
171 // function creates conductivity matrix of the
172 // isotropic heat material for 1D problems
173 //
174 // d - conductivity matrix of the material
175 // 25.9.2001
176 {
177  double k = 0.0, w = 0.0, t = 0.0;
178  TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
179  FloatArray s;
180
181
182  // w = Tm->ip[ipp].av[0];
183  // t = Tm->ip[ipp].av[1];
184  s = status->giveTempField();
185  if ( s.isEmpty() ) {
186  OOFEM_ERROR("undefined state vector");
187  }
188
189  w = s.at(2);
190  t = s.at(1);
191
192  if ( mode == Conductivity_ww ) {
193  k = perm_ww(w, t);
194  } else if ( mode == Conductivity_wh ) {
195  k = perm_wt(w, t);
196  } else if ( mode == Conductivity_hw ) {
197  k = perm_ww(w, t) * get_latent(w, t);
198  } else if ( mode == Conductivity_hh ) {
199  k = get_chi(w, t) + get_latent(w, t) * perm_wt(w, t);
200  } else {
201  OOFEM_ERROR("Unknown MatResponseMode");
202  }
203
204  d.resize(1, 1);
205  d.at(1, 1) = k;
206 }
207
208 void
210 // function creates conductivity matrix of the
211 // isotropic heat material for 2D problems
212 //
213 // d - conductivity matrix of the material
214 // 25.9.2001
215 {
216  double k = 0.0, w = 0.0, t = 0.0;
217  TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
218  FloatArray s;
219
220
221  // w = Tm->ip[ipp].av[0];
222  // t = Tm->ip[ipp].av[1];
223  s = status->giveTempField();
224  if ( s.isEmpty() ) {
225  OOFEM_ERROR("undefined state vector");
226  }
227
228  w = s.at(2);
229  t = s.at(1);
230
231  if ( mode == Conductivity_ww ) {
232  k = perm_ww(w, t);
233  } else if ( mode == Conductivity_wh ) {
234  k = perm_wt(w, t);
235  } else if ( mode == Conductivity_hw ) {
236  k = perm_ww(w, t) * get_latent(w, t);
237  } else if ( mode == Conductivity_hh ) {
238  k = get_chi(w, t) + get_latent(w, t) * perm_wt(w, t);
239  } else {
240  OOFEM_ERROR("Unknown MatResponseMode");
241  }
242
243  d.resize(2, 2);
244  d.at(1, 1) = k;
245  d.at(1, 2) = 0.0;
246  d.at(2, 1) = 0.0;
247  d.at(2, 2) = k;
248 }
249
250 void
252 // function creates conductivity matrix of the
253 // isotropic heat material for 3D problems
254 //
255 // d - conductivity matrix of the material
256 // 25.9.2001
257 {
258  double k = 0.0, w = 0.0, t = 0.0;
259  TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
260  FloatArray s;
261
262
263  // w = Tm->ip[ipp].av[0];
264  // t = Tm->ip[ipp].av[1];
265  s = status->giveTempField();
266  if ( s.isEmpty() ) {
267  OOFEM_ERROR("undefined state vector");
268  }
269
270  w = s.at(2);
271  t = s.at(1);
272
273  if ( mode == Conductivity_ww ) {
274  k = perm_ww(w, t);
275  } else if ( mode == Conductivity_wh ) {
276  k = perm_wt(w, t);
277  } else if ( mode == Conductivity_hw ) {
278  k = perm_ww(w, t) * get_latent(w, t);
279  } else if ( mode == Conductivity_hh ) {
280  k = get_chi(w, t) + get_latent(w, t) * perm_wt(w, t);
281  } else {
282  OOFEM_ERROR("Unknown MatResponseMode");
283  }
284
285  d.resize(3, 3);
286  d.at(1, 1) = k;
287  d.at(1, 2) = 0.0;
288  d.at(1, 3) = 0.0;
289  d.at(2, 1) = 0.0;
290  d.at(2, 2) = k;
291  d.at(2, 3) = 0.0;
292  d.at(3, 1) = 0.0;
293  d.at(3, 2) = 0.0;
294  d.at(3, 3) = k;
295 }
296
297
299 {
300  if ( mode == Capacity_ww ) {
301  return 1.0 * rho;
302  } else if ( mode == Capacity_wh ) {
303  return 0.0;
304  } else if ( mode == Capacity_hw ) {
305  TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
306  FloatArray s;
307  double w, t;
308
309  s = status->giveTempField();
310  if ( s.isEmpty() ) {
311  OOFEM_ERROR("undefined state vector");
312  }
313
314  w = s.at(2);
315  t = s.at(1);
316  return get_b(w, t) * get_latent(w, t);
317  } else if ( mode == Capacity_hh ) {
318  TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
319  FloatArray s;
320  double w, t;
321
322  s = status->giveTempField();
323  if ( s.isEmpty() ) {
324  OOFEM_ERROR("undefined state vector");
325  }
326
327  w = s.at(2);
328  t = s.at(1);
329  return get_ceff(w, t);
330  } else {
331  OOFEM_ERROR("Unknown MatResponseMode");
332  }
333
334  return 0.0; // to make compiler happy
335 }
336
337
338 double
340 {
341  TransportMaterialStatus *ms = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
342  const FloatArray &tempState = ms->giveTempField();
343  if ( tempState.giveSize() < 2 ) {
344  OOFEM_ERROR("undefined moisture status!");
345  }
346
347  const FloatArray &state = ms->giveField();
348
349  if ( mode == VM_Total ) {
350  return inverse_sorption_isotherm( tempState.at(2) );
351  } else if ( mode == VM_Incremental ) {
352  return inverse_sorption_isotherm( tempState.at(2) ) - inverse_sorption_isotherm( state.at(2) );
353  } else if ( mode == VM_Velocity ) { // VM_Previous
354  return inverse_sorption_isotherm( state.at(2) );
355  }
356
357  return 1.;
358 }
359
360
361
362
363 double
364 HeMoTKMaterial :: perm_ww(double w, double t)
365 {
366  // Function calculates permability water content-water content (k_ww)
367  // phi ... relative humidity
368  // delta_gw ... water vapor permeability
369  // dphi_dw ... differentiation of relative with respect to water content
370  // p_gws ... saturation water vapor pressure
371  double k_ww, phi, delta_gw, dphi_dw, p_gws;
372
373  phi = inverse_sorption_isotherm(w);
374  delta_gw = give_delta_gw(phi);
375  dphi_dw = give_dphi_dw(w);
376  p_gws = give_p_gws(t);
377
378  k_ww = delta_gw * p_gws * dphi_dw;
379
380  return ( k_ww );
381 }
382
383 double
384 HeMoTKMaterial :: perm_wt(double w, double t)
385 {
386  // Function calculates permability water content-temperature (k_wt)
387  // delta_gw ... water vapor permeability
388  // d_pgw_d_t ... differentiation of water vapor presssure with respect to temperature
389  double k_wt, phi, delta_gw, dpgw_dt;
390
391  phi = inverse_sorption_isotherm(w);
392  delta_gw = give_delta_gw(phi);
393  dpgw_dt = give_dpgw_dt(t, phi);
394
395  k_wt = delta_gw * dpgw_dt;
396
397  return ( k_wt );
398 }
399
400
401 double
403 // Function calculates the water vapor permeability delta_gw. Relative humidity (phi) is from range 0.2 - 0.98 !!!
404 // delta_gw ... by Z. P. Bazant and L. J. Najjar (1972), Nonlinear water diffusion in nonsaturated concrete,
405 // MATERIAUX ET CONSTRUCTIONS, Vol. 5, No. 25, pp. 3 -20.
406 // phi ... relative humidity
407 // a_0, nn, phi_c, delta_wet ... constants obtained from experiments
408 {
409  double delta_gw;
410
411  if ( ( phi < 0.2 ) || ( phi > 0.98 ) ) {
412  OOFEM_ERROR("Relative humidity is out of range");
413  }
414
415  // water vapor permeability
416  delta_gw = delta_wet * ( a_0 + ( 1.0 - a_0 ) / ( 1.0 + pow( ( 1.0 - phi ) / ( 1.0 - phi_c ), nn ) ) );
417
418  return ( delta_gw );
419 }
420
421
422
423 double
425 // Function calculates water content in medium from relative humidity. Relative humidity (phi) is from range 0.2 - 0.98 !!!
426 // sorption isotherm by C. R. Pedersen (1990), Combined heat and moisture transfer in building constructions,
427 // PhD-thesis, Technical University of Denmark, Lingby.
428 // w (kg/kg) ... water content
429 // phi ... relative humidity
430 // w_h, n, a ... constants obtained from experiments
431 {
432  double w;
433
434  if ( ( phi < 0.2 ) || ( phi > 0.98 ) ) {
435  OOFEM_ERROR("Relative humidity %.3f is out of range", phi);
436  }
437
438  // water content
439  w = w_h * pow( ( 1.0 - log(phi) / a ), ( -1.0 / n ) );
440
441  return ( w );
442 }
443
444
445
446 double
448 // Function calculates relative humidity from water content (inverse relation form sorption isotherm).
449 // Relative humidity (phi) is from range 0.2 - 0.98 !!!
450 // sorption isotherm by C. R. Pedersen (1990), Combined heat and moisture transfer in building constructions,
451 // PhD-thesis, Technical University of Denmark, Lingby.
452 // w (kg/kg) ... water content
453 // phi ... relative humidity
454 // w_h, n, a ... constants obtained from experiments
455 {
456  double phi;
457
458  // relative humidity
459  phi = exp( a * ( 1.0 - pow( ( w_h / w ), ( n ) ) ) );
460
461  if ( ( phi < 0.2 ) || ( phi > 0.98 ) ) {
462  OOFEM_ERROR("Relative humidity %.3f is out of range", phi);
463  }
464
465  return ( phi );
466 }
467
468
469
470 double
472 // Function calculates differentiation of relative humidity with respect to water content (inverse relation form sorption isotherm).
473 // Relative humidity (phi) is from range 0.2 - 0.98 !!!
474 // sorption isotherm by C. R. Pedersen (1990), Combined heat and moisture transfer in building constructions,
475 // PhD-thesis, Technical University of Denmark, Lingby.
476 // w (kg/kg) ... water content
477 // phi ... relative humidity
478 // w_h, n, a ... constants obtained from experiments
479 {
480  double dphi_dw;
481
482  // diferentiation of realative humidity with respect to water content
483  dphi_dw = exp( a * ( 1.0 - pow( ( w_h / w ), n ) ) ) * a * n * pow(w_h, n) * pow( w, ( -1.0 - n ) );
484
485  return ( dphi_dw );
486 }
487
488 double
489 HeMoTKMaterial :: give_dpgw_dt(double t, double phi)
490 // Function calculates differentiation of water vapor pressure with respect to temperature
491 // saturation water vapor pressure by C. R. Pedersen (1990), Combined heat and moisture transfer in building constructions,
492 // PhD-thesis, Technical University of Denmark, Lingby.
493 // t ... temperature [K]
494 // phi ... relative humidity
495 {
496  double dp_gw_dt, dp_gws_dt;
497
498  //differentiation of saturation water vapor pressure (analytical expression) with respect to temperature
499  dp_gws_dt = exp( 23.5771 - 4042.9 / ( t - 37.58 ) ) * 4042.9 / ( t - 37.58 ) / ( t - 37.58 );
500
501  dp_gw_dt = phi * dp_gws_dt;
502
503  return ( dp_gw_dt );
504 }
505
506
507 double
509 // Function calculates saturation water vapor pressure
510 // saturation water vapor pressure by C. R. Pedersen (1990), Combined heat and moisture transfer in building constructions,
511 // PhD-thesis, Technical University of Denmark, Lingby.
512 // t ... temperature [K]
513 // phi ... relative humidity
514 {
515  double p_gws;
516
517  //saturation water vapor pressure ... analytical expression
518  p_gws = exp( 23.5771 - 4042.9 / ( t - 37.58 ) );
519
520  return ( p_gws );
521 }
522
523 double
524 HeMoTKMaterial :: get_latent(double w, double t)
525 {
526  // Function calculates latent heat of evaporation
527
528  double l;
529
530  l = latent; //zatim!!!!
531
532  return ( l );
533 }
534
535 double
536 HeMoTKMaterial :: get_b(double w, double t)
537 {
538  // Function calculates coefficient b
539  // sat ... degree of saturation
540
541  double b, sat, phi, dphi_dw;
542
543  phi = inverse_sorption_isotherm(w);
544  dphi_dw = give_dphi_dw(w);
545  sat = get_sat(w, t);
546
547  b = por * rho_gws * ( phi + ( 1 - sat ) * dphi_dw );
548
549  return ( b );
550 }
551
552
553 double
554 HeMoTKMaterial :: get_sat(double w, double t)
555 {
556  // Function calculates degree of saturation
557  // sat ... degree of saturation
558
559  double sat;
560
561  sat = 1.0; //zatim!!!!
562
563  return ( sat );
564 }
565
566 double
567 HeMoTKMaterial :: get_ceff(double w, double t)
568 {
569  // Function calculates effective thermal capacity
570
571  double ceff;
572
573  ceff = c * rho; //zatim!!!!
574
575  return ( ceff );
576 }
577
578
579 double
580 HeMoTKMaterial :: get_chi(double w, double t)
581 {
582  // Function calculates effective thermal conductivity
583
584  double chi;
585
586  chi = chi_eff; //zatim!!!!
587
588  return ( chi );
589 }
590
591 bool
593 {
594  if ( ( mode == Conductivity_ww ) || ( mode == Conductivity_hh ) || ( mode == Conductivity_hw ) || ( mode == Conductivity_wh ) ) {
595  return false;
596  } else {
597  OOFEM_ERROR("unknown mode (%s)", __MatResponseModeToString(mode) );
598  }
599
600  return false; // to make compiler happy
601 }
602
603 int
605 // IST_Humidity overriden to use inverse_sorption_isotherm
606 {
607  if ( type == IST_Humidity ) {
609  answer.at(1) = giveHumidity(gp, VM_Velocity); // VM_Previous = equilibrated value of humidity
610  return 1;
611  } else {
612  return TransportMaterial :: giveIPValue(answer, gp, type, tStep);
613  }
614 }
615 } // end namespace oofem
double sorption_isotherm(double phi)
Definition: hemotkmat.C:424
InternalStateType
Type representing the physical meaning of element or constitutive model internal variable.
MaterialMode giveMaterialMode()
Returns corresponding material mode of receiver.
Definition: gausspoint.h:191
const FloatArray & giveTempField()
Return last field.
double nn
Constant-exponent (obtained from experiments) [Bazant and Najjar, 1972].
Definition: hemotkmat.h:70
virtual MaterialStatus * giveStatus(GaussPoint *gp) const
Returns material status of receiver in given integration point.
Definition: material.C:244
#define _IFT_HeMoTKMaterial_n
Definition: hemotkmat.h:48
double give_dphi_dw(double w)
Definition: hemotkmat.C:471
void matcond3d(FloatMatrix &d, GaussPoint *gp, MatResponseMode mode, TimeStep *tStep)
Definition: hemotkmat.C:251
double & at(int i)
Coefficient access function.
Definition: floatarray.h:131
ValueModeType
Type representing the mode of UnknownType or CharType, or similar types.
Definition: valuemodetype.h:78
#define _IFT_HeMoTKMaterial_nn
Definition: hemotkmat.h:44
void matcond2d(FloatMatrix &d, GaussPoint *gp, MatResponseMode mode, TimeStep *tStep)
Definition: hemotkmat.C:209
double give_p_gws(double t)
Definition: hemotkmat.C:508
double get_sat(double w, double t)
Definition: hemotkmat.C:554
const char * __MatResponseModeToString(MatResponseMode _value)
Definition: cltypes.C:326
virtual int giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep)
Returns the integration point corresponding value in Reduced form.
This class implements a transport material status information.
MaterialMode
Type representing material mode of integration point.
Definition: materialmode.h:89
MatResponseMode
Describes the character of characteristic material matrix.
virtual void giveCharacteristicMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
Computes characteristic matrix of receiver in given integration point.
Definition: hemotkmat.C:126
void matcond1d(FloatMatrix &d, GaussPoint *gp, MatResponseMode mode, TimeStep *tStep)
Definition: hemotkmat.C:170
void beScaled(double s, const FloatArray &b)
Definition: floatarray.C:146
virtual double give(int aProperty, GaussPoint *gp)
Returns the value of material property &#39;aProperty&#39;.
Definition: material.C:52
virtual int hasMaterialModeCapability(MaterialMode mode)
Tests if material supports material mode.
Definition: hemotkmat.C:45
#define _IFT_HeMoTKMaterial_phi_c
Definition: hemotkmat.h:45
virtual int giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep)
Returns the integration point corresponding value in Reduced form.
Definition: hemotkmat.C:604
const FloatArray & giveField()
Return last field.
double w_h
Constant water content (obtained from experiments) [Pedersen, 1990].
Definition: hemotkmat.h:74
virtual double give(int aProperty, GaussPoint *gp)
Returns the value of material property &#39;aProperty&#39;.
Definition: hemotkmat.C:82
#define OOFEM_ERROR(...)
Definition: error.h:61
#define _IFT_HeMoTKMaterial_delta_wet
Definition: hemotkmat.h:46
double giveHumidity(GaussPoint *gp, ValueModeType mode)
Returns positive value of humidity, use VM_Velocity for previous (equilibrated) value.
Definition: hemotkmat.C:339
void addSubVector(const FloatArray &src, int si)
Definition: floatarray.C:399
double a
Constant (obtained from experiments) [Pedersen, 1990].
Definition: hemotkmat.h:76
void setTempField(FloatArray newField)
Set field.
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
double give_delta_gw(double phi)
Definition: hemotkmat.C:402
#define _IFT_HeMoTKMaterial_rho
Definition: hemotkmat.h:52
double get_b(double w, double t)
Definition: hemotkmat.C:536
double get_ceff(double w, double t)
Definition: hemotkmat.C:567
Class representing vector of real numbers.
Definition: floatarray.h:82
Implementation of matrix containing floating point numbers.
Definition: floatmatrix.h:94
double computeCapacityCoeff(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
Definition: hemotkmat.C:298
double c
Thermal capacity.
Definition: hemotkmat.h:79
IRResultType
Type defining the return values of InputRecord reading operations.
Definition: irresulttype.h:47
#define _IFT_HeMoTKMaterial_chi_eff
Definition: hemotkmat.h:53
virtual double giveCharacteristicValue(MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
Computes the characteristic value of receiver in given integration point, respecting its history...
Definition: hemotkmat.C:143
#define _IFT_HeMoTKMaterial_a
Definition: hemotkmat.h:49
double por
Porosity.
Definition: hemotkmat.h:83
virtual IRResultType initializeFrom(InputRecord *ir)
Initializes receiver according to object description stored in input record.
Definition: hemotkmat.C:56
double phi_c
Constant-relative humidity (obtained from experiments) [Bazant and Najjar, 1972]. ...
Definition: hemotkmat.h:71
#define _IFT_HeMoTKMaterial_w_h
Definition: hemotkmat.h:47
#define _IFT_HeMoTKMaterial_c
Definition: hemotkmat.h:51
double n
Constant-exponent (obtained from experiments) [Pedersen, 1990].
Definition: hemotkmat.h:75
void setTempFlux(FloatArray w)
Set flux.
double get_latent(double w, double t)
Definition: hemotkmat.C:524
double chi_eff
Effective thermal conductivity.
Definition: hemotkmat.h:81
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
double get_chi(double w, double t)
Definition: hemotkmat.C:580
#define _IFT_HeMoTKMaterial_a_0
Definition: hemotkmat.h:43
double perm_wt(double w, double t)
Definition: hemotkmat.C:384
void zero()
Definition: floatarray.C:658
double give_dpgw_dt(double t, double phi)
Definition: hemotkmat.C:489
double latent
Latent heat of evaporation.
Definition: hemotkmat.h:78
virtual void giveFluxVector(FloatArray &answer, GaussPoint *gp, const FloatArray &grad, const FloatArray &field, TimeStep *tStep)
Returns the flux for the field and its gradient.
Definition: hemotkmat.C:93
double a_0
Constant (obtained from experiments) [Bazant and Najjar, 1972].
Definition: hemotkmat.h:69
double delta_wet
Constant-water vapor permeability (obtained from experiments) [Bazant and Najjar, 1972]...
Definition: hemotkmat.h:72
REGISTER_Material(DummyMaterial)
int giveSize() const
Definition: floatarray.h:218
the oofem namespace is to define a context or scope in which all oofem names are defined.
#define _IFT_HeMoTKMaterial_por
Definition: hemotkmat.h:54
#define IR_GIVE_FIELD(__ir, __value, __id)
Macro facilitating the use of input record reading methods.
Definition: inputrecord.h:69
double perm_ww(double w, double t)
Definition: hemotkmat.C:364
double rho_gws
Saturation volume density.
Definition: hemotkmat.h:84
#define _IFT_HeMoTKMaterial_rho_gws
Definition: hemotkmat.h:55
virtual IRResultType initializeFrom(InputRecord *ir)
Initializes receiver according to object description stored in input record.
Definition: material.C:89
Class representing integration point in finite element program.
Definition: gausspoint.h:93
double rho
Volume density.
Definition: hemotkmat.h:80
Class representing solution step.
Definition: timestep.h:80
virtual bool isCharacteristicMtrxSymmetric(MatResponseMode rMode)
Returns true if stiffness matrix of receiver is symmetric Default implementation returns true...
Definition: hemotkmat.C:592
#define _IFT_HeMoTKMaterial_latent
Definition: hemotkmat.h:50
double inverse_sorption_isotherm(double w)
Definition: hemotkmat.C:447
void resize(int s)
Definition: floatarray.C:631
void computeConductivityMtrx(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
Definition: hemotkmat.C:151