00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include <stdio.h>
00028 #include <stdlib.h>
00029 #include <math.h>
00030 #include "aliast.h"
00031 #include "constrel.h"
00032 #include "consol_awf1.h"
00033 #include "globalt.h"
00034
00035 con_awf1mat::con_awf1mat()
00036 {
00037 alpha = 1.0;
00038
00039 ks = 2.167e6;
00040
00041 kw = 2.0e9;
00042
00043 phi0 = 0.297;
00044
00045 kintr = 4.5e-13;
00046
00047 rhow = 1000.0;
00048
00049 muw0 = 1.0e-3;
00050
00051
00052 ssat = 1.0;
00053
00054 sirr = 0.33;
00055
00056 alfa = 0.1;
00057
00058 ksat = 0.1;
00059
00060 gamaw = 10000.0;
00061
00062 hp_min = 0.0;
00063 htz = 0.14;
00064 r = 100.0;
00065
00066 delta = 20.0;
00067 expn = 2.0;
00068
00069 k0 = 32e-11;
00070 e0 = 0.52;
00071 lam0 = 0.001;
00072 lam = 0.03;
00073 m = 9;
00074 sigma_m_bar = 100000.0;
00075
00076 kappa = 0.012;
00077 sigma_m_eff_bar = 0.0;
00078 sigma_m_tot_bar = 0.0;
00079 sigma_m_eff_init = 1.0e-3;
00080
00081 }
00082
00083 con_awf1mat::~con_awf1mat()
00084 {}
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097 void con_awf1mat::matcond (matrix &d,long ri,long ci,long ipp)
00098 {
00099 long n;
00100 n = d.n;
00101
00102 switch (n){
00103 case 1:{
00104 matcond1d (d,ri,ci,ipp);
00105 break;
00106 }
00107 case 2:{
00108 matcond2d (d,ri,ci,ipp);
00109 break;
00110 }
00111 case 3:{
00112 matcond3d (d,ri,ci,ipp);
00113 break;
00114 }
00115 default:{
00116 print_err("unknown number of components of conductivity tensor is required",__FILE__,__LINE__,__func__);
00117 }
00118 }
00119 }
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130 void con_awf1mat::matcond1d (matrix &d,long ri,long ci,long ipp)
00131 {
00132 double kk;
00133 double pw;
00134
00135 pw = Tm->ip[ipp].av[0];
00136 kk = get_kww(pw,ipp);
00137
00138 fillm(0.0,d);
00139
00140 d[0][0] = kk;
00141 }
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151 void con_awf1mat::matcond2d (matrix &d,long ri,long ci,long ipp)
00152 {
00153 double kk;
00154 double pw;
00155
00156 pw = Tm->ip[ipp].av[0];
00157 kk = get_kww(pw,ipp);
00158
00159 fillm(0.0,d);
00160
00161 d[0][0] = kk; d[0][1] = 0.0;
00162 d[1][0] = 0.0; d[1][1] = kk;
00163 }
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174 void con_awf1mat::matcond3d (matrix &d,long ri,long ci,long ipp)
00175 {
00176 double kk;
00177 double pw;
00178
00179 pw = Tm->ip[ipp].av[0];
00180 kk = get_kww(pw,ipp);
00181
00182 fillm(0.0,d);
00183
00184 d[0][0]=kk; d[0][1]=0.0; d[0][2]=0.0;
00185 d[1][0]=0.0; d[1][1]=kk; d[1][2]=0.0;
00186 d[2][0]=0.0; d[2][1]=0.0; d[2][2]=kk;
00187 }
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198 void con_awf1mat::matcap (double &cc,long ri,long ci,long ipp)
00199 {
00200 double pw;
00201
00202 pw = Tm->ip[ipp].av[0];
00203 cc = get_capww(pw);
00204 }
00205
00206
00207
00208
00209
00210
00211
00212
00213 void con_awf1mat::read(XFILE *in)
00214 {
00215
00216 xfscanf (in,"%k%m","waterflowtype",&waterflowtype_kwdset, &model_type);
00217
00218 switch (model_type){
00219 case lewis_and_schrefler:{
00220 xfscanf (in,"%lf %lf %lf %lf %lf %lf %lf", &alpha, &ks, &phi0, &kw, &rhow, &muw0, &kintr);
00221 break;
00222 }
00223 case gardner_exponential:{
00224 xfscanf (in,"%lf %lf %lf %lf %lf %lf", &ssat, &sirr, &phi0, &alfa, &ksat, &gamaw);
00225 break;
00226 }
00227 case potts_log_linear:{
00228 xfscanf (in,"%lf %lf %lf %lf %lf %lf %lf %lf", &ssat, &sirr, &phi0, &hp_min, &htz, &r, &ksat, &gamaw);
00229 break;
00230 }
00231 case van_genuchten:{
00232 xfscanf (in,"%lf %lf %lf %lf %lf %lf %lf", &ssat, &sirr, &phi0, &expn, &ksat, &delta, &gamaw);
00233 break;
00234 }
00235 case kuklik_camclay:{
00236 xfscanf (in,"%lf %lf %lf %lf %lf %lf %lf %lf", &k0, &e0, &kappa, &lam, &m, &gamaw, &sigma_m_eff_bar, &sigma_m_tot_bar);
00237 break;
00238 }
00239 case kuklik_camclay_mech:{
00240 xfscanf (in,"%lf %lf %lf %lf %lf %lf %lf", &k0, &e0, &kappa, &lam, &m, &gamaw, &sigma_m_eff_init);
00241 break;
00242 }
00243 default:{
00244 fprintf (stderr,"\n unknown model type is required");
00245 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00246 }
00247 }
00248 }
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262 void con_awf1mat::rhs_volume (matrix &d,long ri,long ci,long ipp)
00263 {
00264 long m;
00265 m = d.m;
00266
00267 switch (m){
00268 case 1:{
00269 rhs1d1 (d,ri,ci,ipp);
00270 break;
00271 }
00272 case 2:{
00273 rhs2d1 (d,ri,ci,ipp);
00274 break;
00275 }
00276 case 3:{
00277 rhs3d1 (d,ri,ci,ipp);
00278 break;
00279 }
00280 default:{
00281 fprintf (stderr,"\n unknown number of components of stress tensor is required");
00282 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00283 }
00284 }
00285 }
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296 void con_awf1mat::rhs1d1 (matrix &d,long ri,long ci,long ipp)
00297 {
00298 double f,pw;
00299 double g;
00300
00301 pw = Tm->ip[ipp].av[0];
00302 f = get_fw1(pw,ipp);
00303 g = Tp->gr1;
00304 fillm(0.0,d);
00305 d[0][0] = f*g;
00306 }
00307
00308
00309
00310
00311
00312
00313
00314
00315 void con_awf1mat::rhs2d1 (matrix &d,long ri,long ci,long ipp)
00316 {
00317 double f,pw;
00318 double *g;
00319
00320 pw = Tm->ip[ipp].av[0];
00321
00322 g = new double [2];
00323 f = get_fw1(pw,ipp);
00324
00325 g[0] = Tp->gr1;
00326 g[1] = Tp->gr2;
00327
00328 fillm(0.0,d);
00329 d[0][0] = f*g[0];
00330 d[1][0] = f*g[1];
00331 }
00332
00333
00334
00335
00336
00337
00338
00339
00340 void con_awf1mat::rhs3d1 (matrix &d,long ri,long ci,long ipp)
00341 {
00342 double f,pw;
00343 double *g;
00344
00345 pw = Tm->ip[ipp].av[0];
00346
00347 g = new double [3];
00348 f = get_fw1(pw,ipp);
00349
00350 g[0] = Tp->gr1;
00351 g[1] = Tp->gr2;
00352 g[2] = Tp->gr3;
00353
00354 fillm(0.0,d);
00355 d[0][0] = f*g[0];
00356 d[1][0] = f*g[1];
00357 d[2][0] = f*g[2];
00358 }
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371 double con_awf1mat::get_sw(double pw)
00372 {
00373 double sw,kr;
00374 double hp,theta,expm;
00375
00376 switch (model_type){
00377 case lewis_and_schrefler:{
00378 sw = 1.0 - (1.9722e-11)*pow(-pw,2.4279);
00379 break;
00380 }
00381 case gardner_exponential:{
00382 kr = get_krw(pw);
00383 sw = sirr + (ssat - sirr)*kr;
00384
00385 break;
00386 }
00387 case potts_log_linear:{
00388 kr = get_krw(pw);
00389 sw = sirr + (ssat - sirr)*kr;
00390
00391 break;
00392 }
00393 case van_genuchten:{
00394 hp = pw/gamaw;
00395 expm = 1.0 - 1.0/expn;
00396 theta = pow(1+(pow(delta*fabs(hp),expn)),-expm);
00397 sw = sirr + (ssat - sirr)*theta;
00398 break;
00399 }
00400 case kuklik_camclay:{
00401 sw = 1.0;
00402 break;
00403 }
00404 case kuklik_camclay_mech:{
00405 sw = 1.0;
00406 break;
00407 }
00408 default:{
00409 fprintf (stderr,"\n unknown model type is required");
00410 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00411 }
00412 }
00413 return(sw);
00414 }
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425 double con_awf1mat::get_dsw_dpw(double pw)
00426 {
00427 double dsw_dpw;
00428 double dkr_dpw;
00429 double hp,expm;
00430
00431 dsw_dpw = 0.0;
00432
00433 switch (model_type){
00434 case lewis_and_schrefler:{
00435 dsw_dpw = 2.4279*(1.9722e-11)*pow(-pw,(2.4279-1.0));
00436 break;
00437 }
00438 case gardner_exponential:{
00439 dkr_dpw = exp(alfa*pw/gamaw)*alfa/gamaw;
00440 dsw_dpw = (ssat - sirr)*dkr_dpw;
00441
00442 break;
00443 }
00444 case potts_log_linear:{
00445 hp = pw/gamaw;
00446 dkr_dpw = pow(10,(hp - hp_min)*log10(r)/htz)*log(10)*log10(r)/gamaw/htz;
00447 dsw_dpw = (ssat - sirr)*dkr_dpw;
00448
00449 break;
00450 }
00451 case van_genuchten:{
00452 hp = pw/gamaw;
00453 expm = 1.0 - 1.0/expn;
00454 dsw_dpw = (expm*expn*delta*(ssat - sirr)*pow(delta*fabs(hp),(expn-1)))/
00455 (pow(1+(pow(delta*fabs(hp),expn)),(expm+1)))/gamaw;
00456 break;
00457 }
00458 default:{
00459 fprintf (stderr,"\n unknown model type is required");
00460 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00461 }
00462 }
00463
00464 return(dsw_dpw);
00465 }
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476 double con_awf1mat::get_krw(double pw)
00477 {
00478 double krw,s;
00479 double hp,expm;
00480
00481 krw=1.0;
00482
00483 switch (model_type){
00484 case lewis_and_schrefler:{
00485 s = get_sw(pw);
00486 krw = 1.0+2207*pow((1.0-s),1.0121);
00487 break;
00488 }
00489 case gardner_exponential:{
00490 krw = exp(0.1*pw/gamaw);
00491 break;
00492 }
00493 case potts_log_linear:{
00494 hp = pw/gamaw;
00495 krw = pow(10,(hp - hp_min)*log10(r)/htz);
00496 break;
00497 }
00498 case van_genuchten:{
00499 expm = 1.0 - 1.0/expn;
00500 hp = pw/gamaw;
00501 krw = pow(1.0-pow(delta*fabs(hp),expn)*pow(1.0+pow(delta*fabs(hp),expn),-expm),2.0)/
00502 pow(1.0+pow(delta*fabs(hp),expn),(expm/2.0));
00503
00504
00505 break;
00506 }
00507 default:{
00508 fprintf (stderr,"\n unknown model type is required");
00509 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00510 }
00511 }
00512
00513 return(krw);
00514 }
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524 double con_awf1mat::get_phi()
00525 {
00526 double phi;
00527
00528 phi = phi0;
00529
00530 return(phi);
00531 }
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541 double con_awf1mat::get_kintr()
00542 {
00543 return(kintr);
00544 }
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554 double con_awf1mat::get_alpha()
00555 {
00556 return(alpha);
00557 }
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567 double con_awf1mat::get_kw()
00568 {
00569 return(kw);
00570 }
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580 double con_awf1mat::get_muw()
00581 {
00582 return(muw0);
00583 }
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594 double con_awf1mat::get_kww(double pw, long ipp)
00595 {
00596 double krw,kww;
00597 double ks;
00598 double e,eps_v,sigma_m_eff,e0_bar;
00599 double a,b,c,e0_hat,lam_hat;
00600
00601
00602 switch (model_type){
00603 case lewis_and_schrefler:{
00604 krw = get_krw(pw);
00605 kww = krw*kintr/muw0;
00606 break;
00607 }
00608 case gardner_exponential:{
00609 ks = ksat/86400.0;
00610 krw = get_krw(pw);
00611 kww = krw*ks/gamaw;
00612 break;
00613 }
00614 case potts_log_linear:{
00615 ks = ksat/86400.0;
00616 krw = get_krw(pw);
00617 kww = krw*ks/gamaw;
00618 break;
00619 }
00620 case van_genuchten:{
00621 ks = ksat/86400.0;
00622 krw = get_krw(pw);
00623 kww = krw*ks/gamaw;
00624 break;
00625 }
00626 case kuklik_camclay:{
00627
00628 sigma_m_eff = sigma_m_tot_bar + pw;
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650 e0_bar = (kappa - lam)*log(-sigma_m_eff_bar) + e0;
00651 c = e0_bar;
00652 b = -kappa;
00653 a = -b*(lam/e0) - c*(lam/e0)*(lam/e0);
00654 e0_hat = -2*a*(log(-sigma_m_eff))+a*(log(-sigma_m_eff))*(log(-sigma_m_eff)) + b*(log(-sigma_m_eff)) + c;
00655 lam_hat = -2*a*(log(-sigma_m_eff));
00656
00657 eps_v = -lam_hat/(1+e0_hat)*log(-sigma_m_eff);
00658 e = e0*(1 + eps_v) + eps_v;
00659 kww = -k0*(1+e0_hat)/lam_hat/gamaw*sigma_m_eff*pow((e/e0),m);
00660
00661 break;
00662 }
00663 case kuklik_camclay_mech:{
00664
00665
00666 if(Tm->nontransq != NULL){
00667 sigma_m_eff_bar = Tm->givenontransq(precons_press, ipp);
00668 sigma_m_eff = Tm->givenontransq(mean_stress_eff, ipp);
00669 if(sigma_m_eff >= sigma_m_eff_init)
00670 sigma_m_eff = sigma_m_eff_init;
00671 }
00672
00673
00674 e0_bar = (lam + kappa)*log(-sigma_m_eff_bar);
00675 if(sigma_m_eff >= sigma_m_eff_bar){
00676 eps_v = -kappa/(1+e0_bar)*log(-sigma_m_eff);
00677 e = -kappa*log(-sigma_m_eff) + e0_bar;
00678 kww = -k0*(1+e0_bar)/kappa/gamaw*sigma_m_eff*pow((e/e0),m);
00679 }
00680 else{
00681 eps_v = -lam/(1+e0)*log(-sigma_m_eff);
00682 e = -lam*log(-sigma_m_eff) + e0;
00683 kww = -k0*(1+e0)/lam/gamaw*sigma_m_eff*pow((e/e0),m);
00684 }
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699 break;
00700 }
00701 default:{
00702 fprintf (stderr,"\n unknown model type is required");
00703 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00704 }
00705 }
00706 return(kww);
00707 }
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719 double con_awf1mat::get_capww(double pw)
00720 {
00721 double sw,dsw_dpw,n,capww;
00722
00723 switch (model_type){
00724 case lewis_and_schrefler:{
00725 sw = get_sw(pw);
00726 dsw_dpw = get_dsw_dpw(pw);
00727 n = phi0;
00728 capww = (alpha-n)/ks*sw*(sw + dsw_dpw*pw)+n*sw/kw + n*dsw_dpw;
00729
00730 break;
00731 }
00732 case gardner_exponential:{
00733 dsw_dpw = get_dsw_dpw(pw);
00734 capww = phi0*dsw_dpw;
00735 break;
00736 }
00737 case potts_log_linear:{
00738 dsw_dpw = get_dsw_dpw(pw);
00739 capww = phi0*dsw_dpw;
00740 break;
00741 }
00742 case van_genuchten:{
00743 dsw_dpw = get_dsw_dpw(pw);
00744 capww = phi0*dsw_dpw;
00745 break;
00746 }
00747 case kuklik_camclay:{
00748
00749 capww = 1.0;
00750 break;
00751 }
00752 case kuklik_camclay_mech:{
00753
00754 capww = 1.0;
00755 break;
00756 }
00757 default:{
00758 fprintf (stderr,"\n unknown model type is required");
00759 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00760 }
00761 }
00762 return(capww);
00763
00764 }
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775 double con_awf1mat::get_fw1(double pw, long ipp)
00776 {
00777 double krw,fw1;
00778
00779 fw1 = 0.0;
00780
00781 switch (model_type){
00782 case lewis_and_schrefler:{
00783 krw = get_krw(pw);
00784 fw1 = krw*kintr/muw0*rhow;
00785 }
00786 case gardner_exponential:{
00787 break;
00788 }
00789 case potts_log_linear:{
00790 break;
00791 }
00792 case van_genuchten:{
00793 break;
00794 }
00795 case kuklik_camclay:{
00796
00797 break;
00798 }
00799 case kuklik_camclay_mech:{
00800
00801 krw = get_kww(pw,ipp);
00802 fw1 = krw*rhow;
00803 break;
00804 }
00805 default:{
00806 fprintf (stderr,"\n unknown model type is required");
00807 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
00808 }
00809 }
00810
00811 return(fw1);
00812
00813 }
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829 double con_awf1mat::get_othervalue(long compother,double pw, long ipp)
00830 {
00831 double other;
00832 state_eq tt;
00833
00834 switch (compother){
00835 case 0:{
00836 other = -pw;
00837 break;
00838 }
00839 case 1:{
00840 other = get_sw(pw);
00841 break;
00842 }
00843 case 2:{
00844 other = pw;
00845 break;
00846 }
00847 default:{
00848 fprintf (stderr,"\n\n unknown type of component is required in function (%s, line %d).\n",__FILE__,__LINE__);
00849 }
00850 }
00851 return (other);
00852
00853 }
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864 void con_awf1mat::print_othervalue_name(FILE *out,long compother)
00865 {
00866 switch (compother){
00867 case 0:{
00868 fprintf (out,"Capillary pressure (Pa)");
00869 break;
00870 }
00871 case 1:{
00872 fprintf (out,"Degree of saturation () ");
00873 break;
00874 }
00875 case 2:{
00876 fprintf (out,"Pore water pressure (Pa) ");
00877 break;
00878 }
00879 default:{
00880 fprintf (stderr,"\n\n unknown type of component is required in function (%s, line %d).\n",__FILE__,__LINE__);
00881 }
00882 }
00883 }
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895 void con_awf1mat::values_correction (vector &nv, long ipp)
00896 {
00897
00898 water_pressure_check(nv[0],ipp);
00899 }
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910 void con_awf1mat::water_pressure_check(double &pw,long ipp)
00911 {
00912
00913
00914
00915
00916
00917
00918 }
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928 void con_awf1mat::updateval (long ipp)
00929 {
00930 }
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941 void con_awf1mat::initval(long ipp)
00942 {
00943 }
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957 void con_awf1mat::give_dof_names(namevart *dofname, long ntm)
00958 {
00959 if (ntm < 1)
00960 {
00961 print_err("the model defines %ld unknowns but number of transported media is %ld",
00962 __FILE__, __LINE__, __func__, 1, ntm);
00963 abort();
00964 }
00965 dofname[0] = trf_water_press;
00966 }
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978 double con_awf1mat::give_water_pressure(long ipp)
00979 {
00980 double pw;
00981
00982 pw = Tm->ip[ipp].av[0];
00983
00984 return(pw);
00985 }
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996 double con_awf1mat::give_suction(long ipp)
00997 {
00998 double pw,suction;
00999
01000 pw = Tm->ip[ipp].av[0];
01001
01002 switch (model_type){
01003 case lewis_and_schrefler:{
01004 suction = -pw;
01005 break;
01006 }
01007 case gardner_exponential:{
01008 suction = -pw;
01009 break;
01010 }
01011 case potts_log_linear:{
01012 suction = -pw;
01013 break;
01014 }
01015 case van_genuchten:{
01016 suction = -pw;
01017 break;
01018 }
01019 case kuklik_camclay:{
01020 suction = -pw;
01021 break;
01022 }
01023 case kuklik_camclay_mech:{
01024 suction = -pw;
01025 break;
01026 }
01027 default:{
01028 fprintf (stderr,"\n unknown model type is required");
01029 fprintf (stderr,"\n in function (%s, line %d).\n",__FILE__,__LINE__);
01030 }
01031 }
01032 return(suction);
01033 }
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044 double con_awf1mat::give_saturation_degree(long ipp)
01045 {
01046 double pw,s;
01047
01048 pw = Tm->ip[ipp].av[0];
01049 s = get_sw(pw);
01050
01051 return(s);
01052 }
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063 void con_awf1mat::give_reqntq(long *antq)
01064 {
01065 switch (model_type){
01066 case lewis_and_schrefler:{
01067 break;
01068 }
01069 case gardner_exponential:{
01070 break;
01071 }
01072 case potts_log_linear:{
01073 break;
01074 }
01075 case van_genuchten:{
01076 break;
01077 }
01078 case kuklik_camclay:{
01079 break;
01080 }
01081 case kuklik_camclay_mech:{
01082 antq[precons_press-1] = 1;
01083 antq[mean_stress_eff-1] = 1;
01084 break;
01085 }
01086 default:{
01087 print_err("unknown model type is required", __FILE__, __LINE__, __func__);
01088 }
01089 }
01090 }