Ice Sheet System Model  4.18
Code documentation
Public Member Functions | Private Attributes
Matice Class Reference

#include <Matice.h>

Inheritance diagram for Matice:
Material Object

Public Member Functions

 Matice ()
 
 Matice (int mid, int i, IoModel *iomodel)
 
 Matice (int mid, int i, int materialtype)
 
 ~Matice ()
 
void Init (int mid, int i, int materialtype)
 
Object * copy ()
 
void DeepEcho ()
 
void Echo ()
 
int Id ()
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
int ObjectEnum ()
 
void Configure (Elements *elements)
 
Material * copy2 (Element *element)
 
void GetViscosity (IssmDouble *pviscosity, IssmDouble eps_eff, Gauss *gauss)
 
void GetViscosityBar (IssmDouble *pviscosity, IssmDouble eps_eff, Gauss *gauss)
 
void GetViscosityComplement (IssmDouble *pviscosity_complement, IssmDouble *pepsilon, Gauss *gauss)
 
void GetViscosityDComplement (IssmDouble *, IssmDouble *, Gauss *gauss)
 
void GetViscosityDerivativeEpsSquare (IssmDouble *pmu_prime, IssmDouble *pepsilon, Gauss *gauss)
 
void GetViscosity_B (IssmDouble *pviscosity, IssmDouble eps_eff, Gauss *gauss)
 
void GetViscosity_D (IssmDouble *pviscosity, IssmDouble eps_eff, Gauss *gauss)
 
void GetViscosity2dDerivativeEpsSquare (IssmDouble *pmu_prime, IssmDouble *pepsilon, Gauss *gauss)
 
IssmDouble GetA (Gauss *gauss)
 
IssmDouble GetAbar (Gauss *gauss)
 
IssmDouble GetB (Gauss *gauss)
 
IssmDouble GetBbar (Gauss *gauss)
 
IssmDouble GetD (Gauss *gauss)
 
IssmDouble GetDbar (Gauss *gauss)
 
IssmDouble GetE (Gauss *gauss)
 
IssmDouble GetEbar (Gauss *gauss)
 
IssmDouble GetN ()
 
bool IsDamage ()
 
bool IsEnhanced ()
 
void ResetHooks ()
 
void SetCurrentConfiguration (Elements *elements, Loads *loads, Nodes *nodes, Vertices *vertices, Materials *materials, Parameters *parameters)
 
void ViscosityFSDerivativeEpsSquare (IssmDouble *pmu_prime, IssmDouble *epsilon, Gauss *gauss)
 
void ViscosityHODerivativeEpsSquare (IssmDouble *pmu_prime, IssmDouble *epsilon, Gauss *gauss)
 
void ViscositySSADerivativeEpsSquare (IssmDouble *pmu_prime, IssmDouble *epsilon, Gauss *gauss)
 
void ViscosityFS (IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, Input2 *vz_input)
 
void ViscosityHO (IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
 
void ViscosityL1L2 (IssmDouble *pviscosity, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, Input2 *surf)
 
void ViscositySSA (IssmDouble *pviscosity, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
 
void ViscosityBFS (IssmDouble *pmudB, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, Input2 *vz_input, IssmDouble eps_eff)
 
void ViscosityBHO (IssmDouble *pmudB, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, IssmDouble eps_eff)
 
void ViscosityBSSA (IssmDouble *pmudB, int dim, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, IssmDouble eps_eff)
 
- Public Member Functions inherited from Material
virtual ~Material ()
 
- Public Member Functions inherited from Object
virtual ~Object ()
 

Private Attributes

int mid
 
bool isdamaged
 
bool isenhanced
 
int rheology_law
 
Hook * helement
 
Element * element
 

Detailed Description

Definition at line 24 of file Matice.h.

Constructor & Destructor Documentation

◆ Matice() [1/3]

Matice::Matice ( )

Definition at line 24 of file Matice.cpp.

24  {/*{{{*/
25  this->helement=NULL;
26  this->element=NULL;
27  this->isdamaged=false;
28  this->isenhanced=false;
29  return;
30 }

◆ Matice() [2/3]

Matice::Matice ( int  mid,
int  i,
IoModel *  iomodel 
)

Definition at line 32 of file Matice.cpp.

32  {/*{{{*/
33 
34  /*Get material type and initialize object*/
35  int materialtype;
36  iomodel->FindConstant(&materialtype,"md.materials.type");
37  this->Init(matice_mid,index,materialtype);
38 
39 }

◆ Matice() [3/3]

Matice::Matice ( int  mid,
int  i,
int  materialtype 
)

Definition at line 41 of file Matice.cpp.

41  {/*{{{*/
42 
43  this->Init(matice_mid,index,materialtype);
44  return;
45 } /*}}}*/

◆ ~Matice()

Matice::~Matice ( )

Definition at line 46 of file Matice.cpp.

46  {/*{{{*/
47  delete helement;
48  return;
49 }

Member Function Documentation

◆ Init()

void Matice::Init ( int  mid,
int  i,
int  materialtype 
)

Definition at line 51 of file Matice.cpp.

51  {/*{{{*/
52 
53  /*Initialize id*/
54  this->mid=matice_mid;
55 
56  /*Hooks: */
57  int matice_eid=index+1;
58  this->helement=new Hook(&matice_eid,1);
59  this->element=NULL;
60 
61  /*Material specific properties*/
62  switch(materialtype){
63  case MatdamageiceEnum:
64  this->isdamaged = true;
65  this->isenhanced = false;
66  break;
67  case MaticeEnum:
68  this->isdamaged = false;
69  this->isenhanced = false;
70  break;
71  case MatenhancediceEnum:
72  this->isdamaged = false;
73  this->isenhanced = true;
74  break;
75  default:
76  _error_("Material type not recognized");
77  }
78 
79  return;
80 } /*}}}*/

◆ copy()

Object * Matice::copy ( void  )
virtual

Implements Object.

Definition at line 83 of file Matice.cpp.

83  {/*{{{*/
84 
85  /*Output*/
86  Matice* matice=NULL;
87 
88  /*Initialize output*/
89  matice=new Matice();
90 
91  /*copy fields: */
92  matice->mid=this->mid;
93  matice->helement=(Hook*)this->helement->copy();
94  matice->element =(Element*)this->helement->delivers();
95  matice->isdamaged = this->isdamaged;
96  matice->isenhanced = this->isenhanced;
97 
98  return matice;
99 }

◆ DeepEcho()

void Matice::DeepEcho ( void  )
virtual

Implements Object.

Definition at line 119 of file Matice.cpp.

119  {/*{{{*/
120 
121  _printf_("Matice:\n");
122  _printf_(" mid: " << mid << "\n");
123  _printf_(" isdamaged: " << isdamaged << "\n");
124  _printf_(" isenhanced: " << isenhanced << "\n");
125 
126  /*helement and element DeepEcho were commented to avoid recursion.*/
127  /*Example: element->DeepEcho calls matice->DeepEcho which calls element->DeepEcho etc*/
128  _printf_(" helement:\n");
129  _printf_(" note: helement not printed to avoid recursion.\n");
130  //if(helement) helement->DeepEcho();
131  //else _printf_(" helement = NULL\n");
132 
133  _printf_(" element:\n");
134  _printf_(" note: element not printed to avoid recursion.\n");
135  //if(element) element->DeepEcho();
136  //else _printf_(" element = NULL\n");
137 }

◆ Echo()

void Matice::Echo ( void  )
virtual

Implements Object.

Definition at line 139 of file Matice.cpp.

139  {/*{{{*/
140 
141  _printf_("Matice:\n");
142  _printf_(" mid: " << mid << "\n");
143  _printf_(" isdamaged: " << isdamaged << "\n");
144  _printf_(" isenhanced: " << isenhanced << "\n");
145 
146  /*helement and element Echo were commented to avoid recursion.*/
147  /*Example: element->Echo calls matice->Echo which calls element->Echo etc*/
148  _printf_(" helement:\n");
149  _printf_(" note: helement not printed to avoid recursion.\n");
150  //if(helement) helement->Echo();
151  //else _printf_(" helement = NULL\n");
152 
153  _printf_(" element:\n");
154  _printf_(" note: element not printed to avoid recursion.\n");
155  //if(element) element->Echo();
156  //else _printf_(" element = NULL\n");
157 }

◆ Id()

int Matice::Id ( void  )
virtual

Implements Object.

Definition at line 159 of file Matice.cpp.

159 { return mid; }/*{{{*/

◆ Marshall()

void Matice::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
virtual

Implements Object.

Definition at line 161 of file Matice.cpp.

161  { /*{{{*/
162 
163  if(marshall_direction==MARSHALLING_BACKWARD)helement=new Hook();
164 
165  MARSHALLING_ENUM(MaticeEnum);
166  MARSHALLING(mid);
167  MARSHALLING(isdamaged);
168  MARSHALLING(isenhanced);
169  this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
170  this->element=(Element*)this->helement->delivers();
171 
172 }

◆ ObjectEnum()

int Matice::ObjectEnum ( void  )
virtual

Implements Object.

Definition at line 174 of file Matice.cpp.

174  {/*{{{*/
175 
176  return MaticeEnum;
177 
178 }

◆ Configure()

void Matice::Configure ( Elements *  elements)
virtual

Implements Material.

Definition at line 182 of file Matice.cpp.

182  {/*{{{*/
183 
184  /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
185  * datasets, using internal ids and offsets hidden in hooks: */
186  helement->configure((DataSet*)elementsin);
187  this->element = (Element*)helement->delivers();
188 }

◆ copy2()

Material * Matice::copy2 ( Element *  element)
virtual

Implements Material.

Definition at line 101 of file Matice.cpp.

101  {/*{{{*/
102 
103  /*Output*/
104  Matice* matice=NULL;
105 
106  /*Initialize output*/
107  matice=new Matice();
108 
109  /*copy fields: */
110  matice->mid=this->mid;
111  matice->helement=(Hook*)this->helement->copy();
112  matice->element =element_in;
113  matice->isdamaged = this->isdamaged;
114  matice->isenhanced = this->isenhanced;
115 
116  return matice;
117 }

◆ GetViscosity()

void Matice::GetViscosity ( IssmDouble *  pviscosity,
IssmDouble  eps_eff,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 304 of file Matice.cpp.

304  {/*{{{*/
305  /*From a string tensor and a material object, return viscosity, using Glen's flow law.
306  (1-D) B
307  viscosity= -------------------------
308  2 E^[1/n] eps_eff ^[(n-1)/n]
309 
310  where viscosity is the viscosity, B the flow law parameter , eps_eff is the effective strain rate,
311  n the flow law exponent, and E is the enhancement factor.
312 
313  If eps_eff = 0 , it means this is the first time SystemMatrices is being run, and we
314  return 10^14, initial viscosity.
315  */
316 
317  /*output: */
318  IssmDouble viscosity;
319 
320  /*Intermediary: */
321  IssmDouble B,D=0.,E=1.,n;
322 
323  /*Get B and n*/
324  B=GetB(gauss); _assert_(B>0.);
325  n=GetN(); _assert_(n>0.);
326  if(this->isdamaged){
327  D=GetD(gauss);
328  _assert_(D>=0. && D<1.);
329  }
330  if(this->isenhanced){
331  E=GetE(gauss);
332  _assert_(E>0.);
333  }
334 
335  if (n==1.){
336  /*Linear Viscous behavior (Newtonian fluid) viscosity=B/2E: */
337  viscosity=(1.-D)*B/(2.*E);
338  }
339  else{
340 
341  /*if no strain rate, return maximum viscosity*/
342  if(eps_eff==0.){
343  viscosity = 1.e+14/2.;
344  //viscosity = B;
345  //viscosity=2.5*pow(10.,17);
346  }
347 
348  else{
349  viscosity=(1.-D)*B/(2.*pow(E,1./n)*pow(eps_eff,(n-1.)/n));
350  }
351  }
352 
353  /*Checks in debugging mode*/
354  if(viscosity<=0) _error_("Negative viscosity");
355 
356  /*Return: */
357  *pviscosity=viscosity;
358 }

◆ GetViscosityBar()

void Matice::GetViscosityBar ( IssmDouble *  pviscosity,
IssmDouble  eps_eff,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 360 of file Matice.cpp.

360  {/*{{{*/
361  /*From a string tensor and a material object, return viscosity, using Glen's flow law.
362  (1-D) B
363  viscosity= -------------------------
364  2 E^[1/n] eps_eff ^[(n-1)/n]
365 
366  where B the flow law parameter, eps_eff is the effective strain rate, n the flow law exponent,
367  and E is the enhancement factor.
368 
369  If eps_eff = 0 , it means this is the first time SystemMatrices is being run, and we
370  return 10^14, initial viscosity.
371  */
372 
373  /*output: */
374  IssmDouble viscosity;
375 
376  /*Intermediary: */
377  IssmDouble B,D=0.,E=1.,n;
378 
379  /*Get B and n*/
380  B=GetBbar(gauss); _assert_(B>0.);
381  n=GetN(); _assert_(n>0.);
382  if(this->isdamaged){
383  D=GetDbar(gauss);
384  _assert_(D>=0. && D<1.);
385  }
386  if(this->isenhanced){
387  E=GetEbar(gauss);
388  _assert_(E>0.);
389  }
390 
391  if (n==1.){
392  /*Linear Viscous behavior (Newtonian fluid) viscosity=B/2E: */
393  viscosity=(1.-D)*B/(2.*E);
394  }
395  else{
396 
397  /*if no strain rate, return maximum viscosity*/
398  if(eps_eff==0.){
399  viscosity = 1.e+14/2.;
400  //viscosity=2.5*pow(10.,17);
401  }
402 
403  else{
404  viscosity=(1.-D)*B/(2.*pow(E,1./n)*pow(eps_eff,(n-1.)/n));
405  }
406  }
407 
408  /*Checks in debugging mode*/
409  if(viscosity<=0) _error_("Negative viscosity");
410 
411  /*Return: */
412  *pviscosity=viscosity;
413 }

◆ GetViscosityComplement()

void Matice::GetViscosityComplement ( IssmDouble *  pviscosity_complement,
IssmDouble *  pepsilon,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 415 of file Matice.cpp.

415  {/*{{{*/
416  /*Return viscosity accounting for steady state power law creep [Thomas and SSA, 1982]:
417  *
418  * (1-D)
419  * viscosity= -------------------------------------------------------------------
420  * 2[ exx^2+eyy^2+exx*eyy+exy^2+exz^2+eyz^2 ]^[(n-1)/2n]
421  *
422  * If epsilon is NULL, it means this is the first time Gradjb is being run, and we
423  * return mu20, initial viscosity.
424  */
425 
426  /*output: */
427  IssmDouble viscosity_complement;
428 
429  /*input strain rate: */
430  IssmDouble exx,eyy,exy;
431 
432  /*Intermediary value A and exponent e: */
433  IssmDouble A,e;
434  IssmDouble D=0.,n;
435 
436  /*Get D and n*/
437  if(this->isdamaged){
438  D=GetDbar(gauss); /* GetD()? */
439  _assert_(D>=0. && D<1.);
440  }
441  n=GetN();
442 
443  if(epsilon){
444  exx=*(epsilon+0);
445  eyy=*(epsilon+1);
446  exy=*(epsilon+2);
447 
448  /*Build viscosity: mu2=(1-D)/(2*A^e) */
449  A=pow(exx,2)+pow(eyy,2)+pow(exy,2)+exx*eyy;
450  if(A==0){
451  /*Maximum viscosity_complement for 0 shear areas: */
452  viscosity_complement=2.25*pow(10.,17);
453  }
454  else{
455  e=(n-1)/(2*n);
456 
457  viscosity_complement=(1-D)/(2*pow(A,e));
458  }
459  }
460  else{
461  viscosity_complement=4.5*pow(10.,17);
462  }
463 
464  /*Checks in debugging mode*/
465  _assert_(D>=0 && D<1);
466  _assert_(n>0);
467  _assert_(viscosity_complement>0);
468 
469  /*Return: */
470  *pviscosity_complement=viscosity_complement;
471 }

◆ GetViscosityDComplement()

void Matice::GetViscosityDComplement ( IssmDouble *  pviscosity_complement,
IssmDouble *  epsilon,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 473 of file Matice.cpp.

473  {/*{{{*/
474  /*Return viscosity derivative for control method d(mu)/dD:
475  *
476  * B
477  * dviscosity= - -------------------------------------------------------------------
478  * 2[ exx^2+eyy^2+exx*eyy+exy^2+exz^2+eyz^2 ]^[(n-1)/2n]
479  *
480  * If epsilon is NULL, it means this is the first time Gradjb is being run, and we
481  * return mu20, initial viscosity.
482  */
483 
484  /*output: */
485  IssmDouble viscosity_complement;
486 
487  /*input strain rate: */
488  IssmDouble exx,eyy,exy;
489 
490  /*Intermediary value A and exponent e: */
491  IssmDouble A,e;
492  IssmDouble B,n;
493 
494  /*Get B and n*/
495  B=GetBbar(gauss);
496  n=GetN();
497 
498  if(epsilon){
499  exx=*(epsilon+0);
500  eyy=*(epsilon+1);
501  exy=*(epsilon+2);
502 
503  /*Build viscosity: mu2=B/(2*A^e) */
504  A=pow(exx,2)+pow(eyy,2)+pow(exy,2)+exx*eyy;
505  if(A==0){
506  /*Maximum viscosity_complement for 0 shear areas: */
507  viscosity_complement=- 2.25*pow(10.,17);
508  }
509  else{
510  e=(n-1)/(2*n);
511 
512  viscosity_complement=- B/(2*pow(A,e));
513  }
514  }
515  else{
516  viscosity_complement=- 4.5*pow(10.,17);
517  }
518 
519  /*Checks in debugging mode*/
520  _assert_(B>0);
521  _assert_(n>0);
522  _assert_(viscosity_complement<0);
523 
524  /*Return: */
525  *pviscosity_complement=viscosity_complement;
526 }

◆ GetViscosityDerivativeEpsSquare()

void Matice::GetViscosityDerivativeEpsSquare ( IssmDouble *  pmu_prime,
IssmDouble *  pepsilon,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 528 of file Matice.cpp.

528  {/*{{{*/
529 
530  /*output: */
531  IssmDouble mu_prime;
532  IssmDouble mu,n,eff2;
533 
534  /*input strain rate: */
535  IssmDouble exx,eyy,exy,exz,eyz;
536 
537  if((epsilon[0]==0) && (epsilon[1]==0) && (epsilon[2]==0) &&
538  (epsilon[3]==0) && (epsilon[4]==0)){
539  mu_prime=0.5*pow(10.,14);
540  }
541  else{
542 
543  /*Retrieve strain rate components: */
544  exx=epsilon[0];
545  eyy=epsilon[1];
546  exy=epsilon[2];
547  exz=epsilon[3];
548  eyz=epsilon[4];
549  eff2 = exx*exx + eyy*eyy + exx*eyy + exy*exy + exz*exz + eyz*eyz;
550 
551  GetViscosity(&mu,sqrt(eff2),gauss);
552  n=GetN();
553  mu_prime=(1.-n)/(2.*n) * mu/eff2;
554  }
555 
556  /*Assign output pointers:*/
557  *pmu_prime=mu_prime;
558 }

◆ GetViscosity_B()

void Matice::GetViscosity_B ( IssmDouble *  pviscosity,
IssmDouble  eps_eff,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 560 of file Matice.cpp.

560  {/*{{{*/
561 
562  /*output: */
563  IssmDouble dmudB;
564 
565  /*Intermediary: */
566  IssmDouble D=0.,E=1.,n;
567 
568  /*Get B and n*/
569  n=GetN(); _assert_(n>0.);
570  if(this->isdamaged){
571  D=GetD(gauss);
572  _assert_(D>=0. && D<1.);
573  }
574  if(this->isenhanced){
575  E=GetE(gauss);
576  _assert_(E>0.);
577  }
578 
579  if(n==1.){
580  /*Linear Viscous behavior (Newtonian fluid) dmudB=B/2E: */
581  dmudB=(1.-D)/(2.*E);
582  }
583  else{
584  if(eps_eff==0.) dmudB = 0.;
585  else dmudB = (1.-D)/(2.*pow(E,1./n)*pow(eps_eff,(n-1.)/n));
586  }
587 
588  /*Return: */
589  *pdmudB=dmudB;
590 }

◆ GetViscosity_D()

void Matice::GetViscosity_D ( IssmDouble *  pviscosity,
IssmDouble  eps_eff,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 592 of file Matice.cpp.

592  {/*{{{*/
593 
594  /*output: */
595  IssmDouble dmudD;
596 
597  /*Intermediary: */
598  IssmDouble n,B,E=1.;
599 
600  /*Get B and n*/
601  n=GetN(); _assert_(n>0.);
602  B=GetBbar(gauss);
603  _assert_(this->isdamaged);
604  if(this->isenhanced){
605  E=GetE(gauss);
606  _assert_(E>0.);
607  }
608 
609  if(n==1.){
610  /*Linear Viscous behavior (Newtonian fluid) dmudB=B/2E: */
611  dmudD=-B/(2.*E);
612  }
613  else{
614  if(eps_eff==0.) dmudD = 0.;
615  else dmudD = -B/(2.*pow(E,1./n)*pow(eps_eff,(n-1.)/n));
616  }
617 
618  /*Return: */
619  *pdmudD=dmudD;
620 }

◆ GetViscosity2dDerivativeEpsSquare()

void Matice::GetViscosity2dDerivativeEpsSquare ( IssmDouble *  pmu_prime,
IssmDouble *  pepsilon,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 622 of file Matice.cpp.

622  {/*{{{*/
623 
624  /*output: */
625  IssmDouble mu_prime;
626  IssmDouble mu,n,eff2;
627 
628  /*input strain rate: */
629  IssmDouble exx,eyy,exy;
630 
631  if((epsilon[0]==0) && (epsilon[1]==0) && (epsilon[2]==0)){
632  mu_prime=0.5*pow(10.,14);
633  }
634  else{
635  /*Retrive strain rate components: */
636  exx=epsilon[0];
637  eyy=epsilon[1];
638  exy=epsilon[2];
639  eff2 = exx*exx + eyy*eyy + exx*eyy + exy*exy ;
640 
641  GetViscosityBar(&mu,sqrt(eff2),gauss);
642  n=GetN();
643  mu_prime=(1.-n)/(2.*n)*mu/eff2;
644  }
645 
646  /*Assign output pointers:*/
647  *pmu_prime=mu_prime;
648 }

◆ GetA()

IssmDouble Matice::GetA ( Gauss *  gauss)
virtual

Implements Material.

Definition at line 190 of file Matice.cpp.

190  {/*{{{*/
191  /*
192  * A = 1/B^n
193  */
194 
195  IssmDouble B=this->GetB(gauss);
196  IssmDouble n=this->GetN();
197 
198  return pow(B,-n);
199 }

◆ GetAbar()

IssmDouble Matice::GetAbar ( Gauss *  gauss)
virtual

Implements Material.

Definition at line 201 of file Matice.cpp.

201  {/*{{{*/
202  /*
203  * A = 1/B^n
204  */
205 
206  IssmDouble B=this->GetBbar(gauss);
207  IssmDouble n=this->GetN();
208 
209  return pow(B,-n);
210 }

◆ GetB()

IssmDouble Matice::GetB ( Gauss *  gauss)
virtual

Implements Material.

Definition at line 212 of file Matice.cpp.

212  {/*{{{*/
213 
214  _assert_(gauss);
215 
216  /*Output*/
217  IssmDouble B;
218  Input2* B_input = element->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
219  B_input->GetInputValue(&B,gauss);
220  return B;
221 }

◆ GetBbar()

IssmDouble Matice::GetBbar ( Gauss *  gauss)
virtual

Implements Material.

Definition at line 223 of file Matice.cpp.

223  {/*{{{*/
224 
225  _assert_(gauss);
226 
227  /*Output*/
228  IssmDouble Bbar;
229 
230  Input2* B_input = element->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
231  B_input->GetInputValue(&Bbar,gauss);
232  return Bbar;
233 }

◆ GetD()

IssmDouble Matice::GetD ( Gauss *  gauss)
virtual

Implements Material.

Definition at line 235 of file Matice.cpp.

235  {/*{{{*/
236 
237  _assert_(this->isdamaged);
238  /*Output*/
239  IssmDouble D;
240  if(this->isdamaged){
241  Input2* D_input = element->GetInput2(DamageDEnum); _assert_(D_input);
242  D_input->GetInputValue(&D,gauss);
243  }
244  else{
245  _error_("Cannot get DamageD for non damaged ice");
246  }
247  return D;
248 }

◆ GetDbar()

IssmDouble Matice::GetDbar ( Gauss *  gauss)
virtual

Implements Material.

Definition at line 250 of file Matice.cpp.

250  {/*{{{*/
251 
252  _assert_(this->isdamaged);
253  /*Output*/
254  IssmDouble Dbar;
255  if(this->isdamaged){
256  Input2* D_input = element->GetInput2(DamageDbarEnum); _assert_(D_input);
257  D_input->GetInputValue(&Dbar,gauss);
258  }
259  else{
260  _error_("Cannot get DamageD for non damaged ice");
261  }
262  return Dbar;
263 }

◆ GetE()

IssmDouble Matice::GetE ( Gauss *  gauss)

Definition at line 265 of file Matice.cpp.

265  {/*{{{*/
266 
267  _assert_(this->isenhanced);
268  /*Output*/
269  IssmDouble E;
270  Input2* E_input = element->GetInput2(MaterialsRheologyEEnum); _assert_(E_input);
271  E_input->GetInputValue(&E,gauss);
272  return E;
273 }

◆ GetEbar()

IssmDouble Matice::GetEbar ( Gauss *  gauss)

Definition at line 275 of file Matice.cpp.

275  {/*{{{*/
276 
277  _assert_(this->isenhanced);
278  /*Output*/
279  IssmDouble Ebar;
280  Input2* E_input = element->GetInput2(MaterialsRheologyEbarEnum); _assert_(E_input);
281  E_input->GetInputValue(&Ebar,gauss);
282  return Ebar;
283 }

◆ GetN()

IssmDouble Matice::GetN ( )
virtual

Implements Material.

Definition at line 285 of file Matice.cpp.

285  {/*{{{*/
286 
287  /*Output*/
288  IssmDouble n;
289  Input2* n_input = element->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
290  n_input->GetInputAverage(&n);
291  return n;
292 }

◆ IsDamage()

bool Matice::IsDamage ( )
virtual

Implements Material.

Definition at line 294 of file Matice.cpp.

294  {/*{{{*/
295 
296  return this->isdamaged;
297 }

◆ IsEnhanced()

bool Matice::IsEnhanced ( )
virtual

Implements Material.

Definition at line 299 of file Matice.cpp.

299  {/*{{{*/
300 
301  return this->isenhanced;
302 }

◆ ResetHooks()

void Matice::ResetHooks ( )
virtual

Implements Material.

Definition at line 650 of file Matice.cpp.

650  {/*{{{*/
651 
652  this->element=NULL;
653 
654  /*Get Element type*/
655  this->helement->reset();
656 
657 }

◆ SetCurrentConfiguration()

void Matice::SetCurrentConfiguration ( Elements *  elements,
Loads *  loads,
Nodes *  nodes,
Vertices *  vertices,
Materials *  materials,
Parameters *  parameters 
)

Definition at line 659 of file Matice.cpp.

659  {/*{{{*/
660 
661 }

◆ ViscosityFSDerivativeEpsSquare()

void Matice::ViscosityFSDerivativeEpsSquare ( IssmDouble *  pmu_prime,
IssmDouble *  epsilon,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 663 of file Matice.cpp.

663  {/*{{{*/
664  this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
665 }/*}}}*/

◆ ViscosityHODerivativeEpsSquare()

void Matice::ViscosityHODerivativeEpsSquare ( IssmDouble *  pmu_prime,
IssmDouble *  epsilon,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 666 of file Matice.cpp.

666  {/*{{{*/
667  this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon,gauss);
668 }/*}}}*/

◆ ViscositySSADerivativeEpsSquare()

void Matice::ViscositySSADerivativeEpsSquare ( IssmDouble *  pmu_prime,
IssmDouble *  epsilon,
Gauss *  gauss 
)
virtual

Implements Material.

Definition at line 669 of file Matice.cpp.

669  {/*{{{*/
670  this->GetViscosity2dDerivativeEpsSquare(pmu_prime,epsilon,gauss);
671 }/*}}}*/

◆ ViscosityFS()

void Matice::ViscosityFS ( IssmDouble *  pviscosity,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss,
Input2 *  vx_input,
Input2 *  vy_input,
Input2 *  vz_input 
)
virtual

Implements Material.

Definition at line 673 of file Matice.cpp.

673  {/*{{{*/
674  /*The effective strain rate is defined in Paterson 3d Ed p 91 eq 9,
675  * and Cuffey p 303 eq 8.18:
676  *
677  * 2 eps_eff^2 = eps_xx^2 + eps_yy^2 + eps_zz^2 + 2(eps_xy^2 + eps_xz^2 + eps_yz^2)
678  *
679  * or
680  *
681  * eps_eff = 1/sqrt(2) sqrt( \sum_ij eps_ij^2 )
682  *
683  * = 1/sqrt(2) ||eps||_F
684  *
685  * where ||.||_F is the Frobenius norm */
686 
687  /*Intermediaries*/
688  IssmDouble viscosity;
689  IssmDouble epsilon3d[6]; /* epsilon=[exx,eyy,ezz,exy,exz,eyz];*/
690  IssmDouble epsilon2d[3]; /* epsilon=[exx,eyy,exy]; */
691  IssmDouble eps_eff;
692  IssmDouble eps0=1.e-27;
693 
694  if(dim==3){
695  /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
696  element->StrainRateFS(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input,vz_input);
697  eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[3]*epsilon3d[3] + epsilon3d[4]*epsilon3d[4] + epsilon3d[5]*epsilon3d[5] + epsilon3d[0]*epsilon3d[1]+eps0*eps0);
698  }
699  else{
700  /* eps_eff^2 = 1/2 ( exx^2 + eyy^2 + 2*exy^2 )*/
701  element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
702  eps_eff = 1./sqrt(2.)*sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + 2.*epsilon2d[2]*epsilon2d[2]);
703  }
704 
705  /*Get viscosity*/
706  this->GetViscosity(&viscosity,eps_eff,gauss);
707 
708  /*Assign output pointer*/
709  *pviscosity=viscosity;
710 }

◆ ViscosityHO()

void Matice::ViscosityHO ( IssmDouble *  pviscosity,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss,
Input2 *  vx_input,
Input2 *  vy_input 
)
virtual

Implements Material.

Definition at line 712 of file Matice.cpp.

712  {/*{{{*/
713 
714  /*Intermediaries*/
715  IssmDouble viscosity;
716  IssmDouble epsilon3d[5];/* epsilon=[exx,eyy,exy,exz,eyz];*/
717  IssmDouble epsilon2d[2];/* epsilon=[exx,exy]; */
718  IssmDouble eps_eff;
719 
720  if(dim==3){
721  /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
722  element->StrainRateHO(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input);
723  eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[2]*epsilon3d[2] + epsilon3d[3]*epsilon3d[3] + epsilon3d[4]*epsilon3d[4] + epsilon3d[0]*epsilon3d[1]);
724  }
725  else{
726  /* eps_eff^2 = 1/2 (2*exx^2 + 2*exy^2 ) (since eps_zz = - eps_xx)*/
727  element->StrainRateHO2dvertical(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
728  eps_eff = 1./sqrt(2.)*sqrt(2*epsilon2d[0]*epsilon2d[0] + 2*epsilon2d[1]*epsilon2d[1]);
729  }
730 
731  /*Get viscosity*/
732  this->GetViscosity(&viscosity,eps_eff,gauss);
733  _assert_(!xIsNan<IssmDouble>(viscosity));
734 
735  /*Assign output pointer*/
736  *pviscosity=viscosity;
737 }/*}}}*/

◆ ViscosityL1L2()

void Matice::ViscosityL1L2 ( IssmDouble *  pviscosity,
IssmDouble *  xyz_list,
Gauss *  gauss,
Input2 *  vx_input,
Input2 *  vy_input,
Input2 *  surf 
)
virtual

Implements Material.

Definition at line 738 of file Matice.cpp.

738  {/*{{{*/
739  /*Compute the L1L2 viscosity
740  *
741  * 1
742  * mu = - A^-1 (sigma'_e)^(1-n)
743  * 2
744  *
745  * sigma'_e^2 = |sigma'_//|^2 + |sigma'_perp|^2 (see Perego 2012 eq. 17,18)
746  *
747  * L1L2 assumptions:
748  *
749  * (1) |eps_b|_// = A (|sigma'_//|^2 + |sigma'_perp|^2)^((n-1)/2) |sigma'_//|
750  * (2) |sigma'_perp|^2 = |rho g (s-z) grad(s)|^2
751  *
752  * Assuming that n = 3, we have a polynom of degree 3 to solve (the only unkown is X=|sigma'_//|)
753  *
754  * A X^3 + A |rho g (s-z) grad(s)|^2 X - |eps_b|_// = 0 */
755 
756  IssmDouble z,s,viscosity,p,q,delta;
757  IssmDouble tau_perp,tau_par,eps_b,A;
758  IssmDouble epsilon[5]; /*exx eyy exy exz eyz*/
759  IssmDouble slope[3];
760 
761  /*Check that both inputs have been found*/
762  if (!vx_input || !vy_input || !surface_input) _error_("Input missing");
763 
764  /*Get tau_perp*/
765  surface_input->GetInputValue(&s,gauss);
766  surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
767  z=this->element->GetZcoord(xyz_list,gauss);
768  tau_perp = element->FindParam(MaterialsRhoIceEnum) * element->FindParam(ConstantsGEnum) * fabs(s-z)*sqrt(slope[0]*slope[0]+slope[1]*slope[1]);
769 
770  /* Get eps_b*/
771  element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
772  eps_b = sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[0]*epsilon[1] + epsilon[2]*epsilon[2]);
773  if(eps_b==0.){
774  *pviscosity = 2.5e+17;
775  return;
776  }
777 
778  /*Get A*/
779  _assert_(this->GetN()==3.0);
780  A=this->GetA(gauss);
781 
782  /*Solve for tau_perp (http://fr.wikipedia.org/wiki/Méthode_de_Cardan)*/
783  p = tau_perp *tau_perp;
784  q = - eps_b/A;
785  delta = q *q + p*p*p*4./27.;
786  _assert_(delta>0);
787  tau_par = pow(0.5*(-q+sqrt(delta)),1./3.) - pow(0.5*(q+sqrt(delta)),1./3.);
788 
789  /*Viscosity*/
790  viscosity = 1./(2.*A*(tau_par*tau_par + tau_perp*tau_perp));
791  _assert_(!xIsNan(viscosity));
792  _assert_(viscosity > 0.);
793 
794  /*Assign output pointer*/
795  *pviscosity = viscosity;
796 }/*}}}*/

◆ ViscositySSA()

void Matice::ViscositySSA ( IssmDouble *  pviscosity,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss,
Input2 *  vx_input,
Input2 *  vy_input 
)
virtual

Implements Material.

Definition at line 797 of file Matice.cpp.

797  {/*{{{*/
798 
799  /*Intermediaries*/
800  IssmDouble viscosity;
801  IssmDouble epsilon2d[3];/* epsilon=[exx,eyy,exy]; */
802  IssmDouble epsilon1d; /* epsilon=[exx]; */
803  IssmDouble eps_eff;
804 
805  if(dim==2){
806  /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exx*eyy*/
807  element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
808  eps_eff = sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + epsilon2d[2]*epsilon2d[2] + epsilon2d[0]*epsilon2d[1]);
809  }
810  else{
811  /* eps_eff^2 = exx^2*/
812  element->StrainRateSSA1d(&epsilon1d,xyz_list,gauss,vx_input);
813  eps_eff = fabs(epsilon1d);
814  }
815 
816  /*Get viscosity*/
817  this->GetViscosityBar(&viscosity,eps_eff,gauss);
818 
819  /*Assign output pointer*/
820  *pviscosity=viscosity;
821 }/*}}}*/

◆ ViscosityBFS()

void Matice::ViscosityBFS ( IssmDouble *  pmudB,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss,
Input2 *  vx_input,
Input2 *  vy_input,
Input2 *  vz_input,
IssmDouble  eps_eff 
)
inlinevirtual

Implements Material.

Definition at line 83 of file Matice.h.

83 {_error_("not supported");};

◆ ViscosityBHO()

void Matice::ViscosityBHO ( IssmDouble *  pmudB,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss,
Input2 *  vx_input,
Input2 *  vy_input,
IssmDouble  eps_eff 
)
inlinevirtual

Implements Material.

Definition at line 84 of file Matice.h.

84 {_error_("not supported");};

◆ ViscosityBSSA()

void Matice::ViscosityBSSA ( IssmDouble *  pmudB,
int  dim,
IssmDouble *  xyz_list,
Gauss *  gauss,
Input2 *  vx_input,
Input2 *  vy_input,
IssmDouble  eps_eff 
)
inlinevirtual

Implements Material.

Definition at line 85 of file Matice.h.

85 {_error_("not supported");};

Field Documentation

◆ mid

int Matice::mid
private

Definition at line 27 of file Matice.h.

◆ isdamaged

bool Matice::isdamaged
private

Definition at line 28 of file Matice.h.

◆ isenhanced

bool Matice::isenhanced
private

Definition at line 29 of file Matice.h.

◆ rheology_law

int Matice::rheology_law
private

Definition at line 30 of file Matice.h.

◆ helement

Hook* Matice::helement
private

Definition at line 31 of file Matice.h.

◆ element

Element* Matice::element
private

Definition at line 32 of file Matice.h.

The documentation for this class was generated from the following files:
Matice::Init
void Init(int mid, int i, int materialtype)
Definition: Matice.cpp:51
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
IssmDouble
double IssmDouble
Definition: types.h:37
xIsNan
int xIsNan(const T &X)
Definition: isnan.h:16
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
MARSHALLING_ENUM
#define MARSHALLING_ENUM(EN)
Definition: Marshalling.h:14
MaterialsRheologyEbarEnum
@ MaterialsRheologyEbarEnum
Definition: EnumDefinitions.h:646
Element::StrainRateFS
void StrainRateFS(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input, Input2 *vz_input)
Definition: Element.cpp:4055
Matice::GetViscosity2dDerivativeEpsSquare
void GetViscosity2dDerivativeEpsSquare(IssmDouble *pmu_prime, IssmDouble *pepsilon, Gauss *gauss)
Definition: Matice.cpp:622
MaterialsRhoIceEnum
@ MaterialsRhoIceEnum
Definition: EnumDefinitions.h:264
Matice::Matice
Matice()
Definition: Matice.cpp:24
Element::GetZcoord
IssmDouble GetZcoord(IssmDouble *xyz_list, Gauss *gauss)
Definition: Element.cpp:1494
Matice::GetViscosityDerivativeEpsSquare
void GetViscosityDerivativeEpsSquare(IssmDouble *pmu_prime, IssmDouble *pepsilon, Gauss *gauss)
Definition: Matice.cpp:528
MaterialsRheologyNEnum
@ MaterialsRheologyNEnum
Definition: EnumDefinitions.h:651
Matice::GetBbar
IssmDouble GetBbar(Gauss *gauss)
Definition: Matice.cpp:223
Matice::GetDbar
IssmDouble GetDbar(Gauss *gauss)
Definition: Matice.cpp:250
Matice::GetB
IssmDouble GetB(Gauss *gauss)
Definition: Matice.cpp:212
Hook::reset
void reset(void)
Definition: Hook.cpp:211
MaterialsRheologyBbarEnum
@ MaterialsRheologyBbarEnum
Definition: EnumDefinitions.h:644
Element::GetInput2
virtual Input2 * GetInput2(int inputenum)=0
Matice::GetN
IssmDouble GetN()
Definition: Matice.cpp:285
Element
Definition: Element.h:41
Matice::GetEbar
IssmDouble GetEbar(Gauss *gauss)
Definition: Matice.cpp:275
ConstantsGEnum
@ ConstantsGEnum
Definition: EnumDefinitions.h:102
Hook::delivers
Object * delivers(void)
Definition: Hook.cpp:191
Matice::GetViscosity
void GetViscosity(IssmDouble *pviscosity, IssmDouble eps_eff, Gauss *gauss)
Definition: Matice.cpp:304
Matice::mid
int mid
Definition: Matice.h:27
Hook
Definition: Hook.h:16
Hook::configure
void configure(DataSet *dataset)
Definition: Hook.cpp:145
MatdamageiceEnum
@ MatdamageiceEnum
Definition: EnumDefinitions.h:1165
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
DamageDEnum
@ DamageDEnum
Definition: EnumDefinitions.h:516
MARSHALLING
#define MARSHALLING(FIELD)
Definition: Marshalling.h:29
Element::StrainRateSSA1d
void StrainRateSSA1d(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input)
Definition: Element.cpp:4157
Matice::helement
Hook * helement
Definition: Matice.h:31
MaterialsRheologyEEnum
@ MaterialsRheologyEEnum
Definition: EnumDefinitions.h:645
Matice::GetE
IssmDouble GetE(Gauss *gauss)
Definition: Matice.cpp:265
Hook::copy
Object * copy(void)
Definition: Hook.cpp:61
DamageDbarEnum
@ DamageDbarEnum
Definition: EnumDefinitions.h:518
Input2
Definition: Input2.h:18
MARSHALLING_BACKWARD
@ MARSHALLING_BACKWARD
Definition: Marshalling.h:10
Matice
Definition: Matice.h:24
Matice::isdamaged
bool isdamaged
Definition: Matice.h:28
Element::StrainRateHO
void StrainRateHO(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
Definition: Element.cpp:4084
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
MaterialsRheologyBEnum
@ MaterialsRheologyBEnum
Definition: EnumDefinitions.h:643
Matice::GetD
IssmDouble GetD(Gauss *gauss)
Definition: Matice.cpp:235
MatenhancediceEnum
@ MatenhancediceEnum
Definition: EnumDefinitions.h:1166
Matice::element
Element * element
Definition: Matice.h:32
Element::StrainRateSSA
void StrainRateSSA(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
Definition: Element.cpp:4138
MaticeEnum
@ MaticeEnum
Definition: EnumDefinitions.h:1169
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
Matice::isenhanced
bool isenhanced
Definition: Matice.h:29
Element::StrainRateHO2dvertical
void StrainRateHO2dvertical(IssmDouble *epsilon, IssmDouble *xyz_list, Gauss *gauss, Input2 *vx_input, Input2 *vy_input)
Definition: Element.cpp:4114
Matice::GetA
IssmDouble GetA(Gauss *gauss)
Definition: Matice.cpp:190
DataSet
Declaration of DataSet class.
Definition: DataSet.h:14
Input2::GetInputAverage
virtual void GetInputAverage(IssmDouble *pvalue)
Definition: Input2.h:33
Matice::GetViscosityBar
void GetViscosityBar(IssmDouble *pviscosity, IssmDouble eps_eff, Gauss *gauss)
Definition: Matice.cpp:360
Hook::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: Hook.cpp:122
Generated on Thu Jul 2 2020 08:09:29 for Ice Sheet System Model by   doxygen 1.8.19