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
00028
00029 #include "kunzel.h"
00030 #include "globalt.h"
00031
00032
00033 kunmat::kunmat()
00034 {
00035 long i;
00036
00037
00038 kunzeltype = 0;
00039
00040
00041 rho_m = 0.0;
00042
00043 rho_w = 1000.0;
00044
00045 M = 0.01801528;
00046
00047 R = 8.314472;
00048
00049 for (i=0;i<20;i++){
00050 MatChar[i]=0;
00051 }
00052 }
00053
00054 kunmat::~kunmat()
00055 {
00056
00057 }
00058
00059
00060
00061
00062
00063
00064
00065
00066 void kunmat::read(XFILE *in)
00067 {
00068 long i,nr,nc;
00069
00070 for (i = 2; i<20; i++){
00071 xfscanf(in, "%d",&MatChar[i]);
00072 }
00073
00074 for (i = 2;i < 19; i++){
00075
00076 switch (MatChar[i]){
00077 case 0:{
00078
00079 break;
00080 }
00081 case 1:{
00082
00083
00084 data[i]=new gfunct ();
00085
00086
00087 data[i]->tfunc=stat;
00088
00089 xfscanf(in, "%lf",&data[i]->f);
00090
00091 break;
00092 }
00093 case 2:{
00094
00095
00096
00097
00098 xfscanf(in, "%ld %ld",&nr,&nc);
00099
00100
00101 data[i]=new gfunct (tab,nr);
00102
00103 data[i]->tabf[0].itype = piecewiselin;
00104
00105 data[i]->tabf[0].readval (in);
00106
00107
00108 xfscanf(in, "%d",&nr);
00109
00110 break;
00111 }
00112 case 3:{
00113
00114 break;
00115 }
00116 case 30:{
00117 if( MatChar[i-1] ==1)
00118 {
00119 xfscanf(in, "%lf %lf",&MatFunce[i][0],&MatFunce[i][1]);
00120 }
00121 else
00122 {
00123 xfscanf(in, "%lf %lf",&MatFunce[i][0],&MatFunce[i][1]);
00124 }
00125 break;
00126 }
00127 case 31:{
00128 if( MatChar[i-1] ==1)
00129 {
00130 if (i == 6)
00131 {
00132 xfscanf(in, "%lf %lf %lf",&MatFunce[i][0],&MatFunce[i][1], &MatFunce[i][2]);
00133 }
00134 else
00135 {
00136 xfscanf(in, "%lf %lf",&MatFunce[i][0],&MatFunce[i][1]);
00137 }
00138 }
00139 else
00140 {
00141 if (i == 6)
00142 {
00143 xfscanf(in, "%lf %lf %lf",&MatFunce[i][0],&MatFunce[i][1], &MatFunce[i][2]);
00144 }
00145 else
00146 {
00147 xfscanf(in, "%lf %lf",&MatFunce[i][0],&MatFunce[i][1]);
00148 }
00149 }
00150
00151 break;
00152 }
00153 case 32:{
00154 if( MatChar[i-1] ==1)
00155 {
00156 xfscanf(in, "%lf %lf",&MatFunce[i][0],&MatFunce[i][1]);
00157 }
00158 else
00159 {
00160 xfscanf(in, "%lf %lf",&MatFunce[i][0],&MatFunce[i][1]);
00161 }
00162 break;
00163 }
00164 default:{
00165 print_err("unknown definition of Material KUNZEL is required",__FILE__,__LINE__,__func__);
00166 }
00167 }
00168 }
00169
00170
00171 kunzeltype = MatChar[19];
00172
00173 CorD(2,kd,0,rho_m,a2,a3);
00174 }
00175
00176
00177
00178
00179
00180
00181
00182
00183 void kunmat::print(FILE *out)
00184 {
00185 long i,j;
00186
00187 fprintf (out,"\n");
00188 for (i = 2; i<20; i++)
00189 {
00190 fprintf(out, " %ld ",MatChar[i]);
00191 }
00192 fprintf(out, " %ld ",MatChar[19]);
00193 for (i = 2;i < 19; i++)
00194 {
00195
00196 switch (MatChar[i]){
00197 case 0:{
00198
00199 break;
00200 }
00201 case 1:{
00202
00203 fprintf(out, "\n %e ",data[i]->f);
00204 break;
00205 }
00206 case 2:{
00207
00208
00209 fprintf(out, "\n %ld %d ",data[i]->tabf[0].asize,2);
00210
00211 for (j=0;j<data[i]->tabf[0].asize;j++){
00212 fprintf(out, "\n %e %e ",data[i]->tabf[0].x[j],data[i]->tabf[0].y[j]);
00213 }
00214
00215 fprintf(out, "\n %ld ",data[i]->tabf[0].asize);
00216 break;
00217 }
00218 case 3:{
00219
00220 break;
00221 }
00222 case 30:{
00223 if( MatChar[i-1] ==1)
00224 {
00225 fprintf(out, "\n %e %e ",MatFunce[i][0],MatFunce[i][1]);
00226 }
00227 else
00228 {
00229 fprintf(out, "\n %e %e ",MatFunce[i][0],MatFunce[i][1]);
00230 }
00231 break;
00232 }
00233 case 31:{
00234 if( MatChar[i-1] ==1)
00235 {
00236 if (i == 6)
00237 {
00238 fprintf(out, "\n %e %e %e ",MatFunce[i][0],MatFunce[i][1], MatFunce[i][2]);
00239 }
00240 else
00241 {
00242 fprintf(out, "\n %e %e ",MatFunce[i][0],MatFunce[i][1]);
00243 }
00244 }
00245 else
00246 {
00247 if (i == 6)
00248 {
00249 fprintf(out, "\n %e %e %e",MatFunce[i][0],MatFunce[i][1], MatFunce[i][2]);
00250 }
00251 else
00252 {
00253 fprintf(out, "\n %e %e ",MatFunce[i][0],MatFunce[i][1]);
00254 }
00255 }
00256
00257 break;
00258 }
00259 case 32:{
00260 if( MatChar[i-1] ==1)
00261 {
00262 fprintf(out, "\n %e %e ",MatFunce[i][0],MatFunce[i][1]);
00263 }
00264 else
00265 {
00266 fprintf(out, "\n %e %e ",MatFunce[i][0],MatFunce[i][1]);
00267 }
00268 break;
00269 }
00270 default:{
00271 print_err("unknown definition of Material KUNZEL is required",__FILE__,__LINE__,__func__);
00272 fprintf (out,"\n");
00273 }
00274 }
00275 }
00276 fprintf (out,"\n");
00277 }
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291 void kunmat::matcond (matrix &d,long ri,long ci,long ipp)
00292 {
00293 long n;
00294 n = d.n;
00295
00296 switch (n){
00297 case 1:{
00298 matcond1d (d,ri,ci,ipp);
00299 break;
00300 }
00301 case 2:{
00302 matcond2d (d,ri,ci,ipp);
00303 break;
00304 }
00305 case 3:{
00306 matcond3d (d,ri,ci,ipp);
00307 break;
00308 }
00309 default:{
00310 print_err("unknown number of components of conductivity tensor is required",__FILE__,__LINE__,__func__);
00311 }
00312 }
00313 }
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326 void kunmat::matcond1d (matrix &d,long ri,long ci,long ipp)
00327 {
00328 double k;
00329 k = 0.0;
00330
00331 if((ri == 0) && (ci == 0))
00332 k = kmm(ipp);
00333 if((ri == 0) && (ci == 1))
00334 k = kmt(ipp);
00335 if((ri == 1) && (ci == 0))
00336 k = khm(ipp);
00337 if((ri == 1) && (ci == 1))
00338 k = kht(ipp);
00339
00340 d[0][0] = k;
00341 }
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353 void kunmat::matcond2d (matrix &d,long ri,long ci,long ipp)
00354 {
00355 double k;
00356 k = 0.0;
00357
00358
00359 if((ri == 0) && (ci == 0))
00360 k = kmm(ipp);
00361 if((ri == 0) && (ci == 1))
00362 k = kmt(ipp);
00363 if((ri == 1) && (ci == 0))
00364 k = khm(ipp);
00365 if((ri == 1) && (ci == 1))
00366 k = kht(ipp);
00367
00368 fillm(0.0,d);
00369
00370
00371
00372 d[0][0] = k; d[0][1] = 0.0;
00373 d[1][0] = 0.0; d[1][1] = k;
00374 }
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386 void kunmat::matcond3d (matrix &d,long ri,long ci,long ipp)
00387 {
00388 double k;
00389 k = 0.0;
00390
00391
00392 if((ri == 0) && (ci == 0))
00393 k = kmm(ipp);
00394 if((ri == 0) && (ci == 1))
00395 k = kmt(ipp);
00396 if((ri == 1) && (ci == 0))
00397 k = khm(ipp);
00398 if((ri == 1) && (ci == 1))
00399 k = kht(ipp);
00400
00401 fillm(0.0,d);
00402
00403 d[0][0]=k; d[0][1]=0.0; d[0][2]=0.0;
00404 d[1][0]=0.0; d[1][1]=k; d[1][2]=0.0;
00405 d[2][0]=0.0; d[2][1]=0.0; d[2][2]=k;
00406 }
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418 void kunmat::matcap (double &c,long ri,long ci,long ipp)
00419 {
00420 c=0.0;
00421
00422 if((ri == 0) && (ci == 0))
00423 c = cmm(ipp);
00424 if((ri == 0) && (ci == 1))
00425 c = cmt(ipp);
00426 if((ri == 1) && (ci == 0))
00427 c = chm(ipp);
00428 if((ri == 1) && (ci == 1)){
00429 c = cht(ipp);
00430 }
00431 }
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441 void kunmat::values_correction (vector &nv)
00442 {
00443
00444 switch (kunzeltype) {
00445 case 1:{
00446 double rh, tk;
00447
00448 rh=nv[0];
00449
00450 tk=nv[1];
00451
00452 if (rh >= 1.0)
00453 rh = 1.0;
00454 if (rh <= 0.0)
00455 rh = 0.0;
00456
00457 if (tk >= 350.0)
00458 tk = 350.0;
00459 if (tk <= 240.0)
00460 tk = 240.0;
00461
00462 nv[0]=rh;
00463 nv[1]=tk;
00464 break;
00465 }
00466 case 2:
00467 case 3:
00468 case 4:
00469 {
00470 double pv, tk, pvs, rh;
00471
00472 pv=nv[0];
00473
00474 tk=nv[1];
00475
00476 pvs = saturated_water_vapor_pressure(tk);
00477
00478 rh = pv/pvs;
00479
00480 if(rh >= 1.0)
00481 pv = pvs;
00482 if(rh <= 0.0)
00483
00484
00485 if (tk >= 350.0)
00486 tk = 350.0;
00487 if (tk <= 240.0)
00488 tk = 240.0;
00489
00490 nv[0]=pv;
00491 nv[1]=tk;
00492 break;
00493 }
00494 case 5:
00495 case 6:
00496 case 7:{
00497 double pv, tk, pvs, rh;
00498
00499 pv=nv[0];
00500
00501 tk=nv[1];
00502
00503
00504 nv[0]=pv;
00505 nv[1]=tk;
00506 }
00507 break;
00508 default:{
00509 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
00510
00511 }
00512 }
00513
00514
00515 }
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525 double kunmat::kmm(long ipp)
00526 {
00527 double kk, tk;
00528
00529
00530 switch (kunzeltype) {
00531 case 1:{
00532
00533 double dw, mi, dp, dmretc, ps, dphi, moist, smc;
00534
00535
00536
00537
00538
00539 tk = Tm->ip[ipp].av[1];
00540
00541
00542
00543
00544
00545 moist = Tm->ip[ipp].eqother[0];
00546
00547
00548 CorD(4,kd,moist,mi,a2,a3);
00549
00550
00551 dw = Tm->ip[ipp].eqother[3];
00552
00553 dp = water_vapour_permeability(tk,ipp);
00554 ps = saturated_water_vapor_pressure( tk);
00555
00556
00557 dmretc = Tm->ip[ipp].eqother[1];
00558
00559 dphi = dw * dmretc;
00560 kk = dphi + dp * ps;
00561
00562 break;
00563 }
00564 case 2:{
00565 double dw, dp;
00566
00567
00568
00569
00570
00571 tk = Tm->ip[ipp].av[1];
00572
00573
00574 dw = Tm->ip[ipp].eqother[3];
00575
00576 dp = water_vapour_permeability(tk,ipp);
00577
00578 kk = dp+dw*M/(R*tk);
00579 break;
00580 }
00581 case 3:{
00582 double D, moist;
00583
00584
00585
00586
00587
00588
00589
00590
00591 moist = Tm->ip[ipp].eqother[0];
00592
00593
00594 CorD(18,kd,moist,D,a2,a3);
00595 kk = D;
00596 break;
00597 }
00598 case 4:{
00599 double D, moist;
00600
00601
00602
00603
00604
00605 tk = Tm->ip[ipp].av[1];
00606
00607
00608 moist = Tm->ip[ipp].eqother[0];
00609
00610
00611 CorD(18,kd,moist,D,a2,a3);
00612 kk = D*M/(R*tk);;
00613 break;
00614 }
00615 case 5:
00616 case 6:{
00617 double dp;
00618
00619
00620
00621
00622
00623 tk = Tm->ip[ipp].av[1];
00624
00625 dp = water_vapour_permeability(tk,ipp);
00626
00627 kk = dp;
00628 break;
00629 }
00630 case 7:{
00631 double moist, D, dp;
00632
00633
00634
00635 moist= 0.05;
00636 CorD(18,kd,moist,D,a2,a3);
00637
00638
00639 dp = 2.217e-11;
00640 D = dp*R*293.15/M;
00641
00642 kk = D;
00643 break;
00644 }
00645 default:{
00646 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
00647
00648 }
00649 }
00650
00651
00652
00653
00654 return (kk);
00655 }
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667 double kunmat::kmt(long ipp)
00668 {
00669 double kk, tk;
00670
00671 switch (kunzeltype) {
00672 case 1:{
00673 double rh,tk;
00674 double dp, dpvs;
00675
00676
00677 rh = Tm->ip[ipp].av[0];
00678
00679
00680 tk = Tm->ip[ipp].av[1];
00681
00682 if (rh>1.0) rh = 1.0;
00683 if (rh<0.0) rh = 0.0;
00684
00685 dpvs = derivative_of_saturated_water_vapor_pressure(tk);
00686 dp = water_vapour_permeability(tk,ipp);
00687
00688
00689 kk = dp * rh * dpvs;
00690 break;
00691 }
00692 case 2:{
00693 double pv,tk, dw;
00694
00695 pv = Tm->ip[ipp].av[0];
00696
00697 tk = Tm->ip[ipp].av[1];
00698
00699
00700 dw = Tm->ip[ipp].eqother[3];
00701
00702 kk = -dw*M*pv/(R*tk*tk);
00703
00704 break;
00705 }
00706
00707 case 3:
00708 case 4:
00709 case 5:
00710 case 6:
00711 case 7:{
00712 kk = 0.0;
00713
00714 break;
00715 }
00716 default:{
00717 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
00718
00719 }
00720
00721 }
00722
00723
00724
00725
00726 return (kk);
00727 }
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738 double kunmat::kht(long ipp)
00739 {
00740 double kk,tk;
00741
00742 switch (kunzeltype) {
00743 case 1:{
00744 double rh;
00745 double lv1, lambda, dpvs, dp, moist;
00746
00747
00748 rh = Tm->ip[ipp].av[0];
00749
00750
00751 tk = Tm->ip[ipp].av[1];
00752
00753 if (rh>1.0) rh = 1.0;
00754 if (rh<0.0) rh = 0.0;
00755
00756
00757 moist = Tm->ip[ipp].eqother[0];
00758
00759 CorD(10,kd,moist,lambda,a2,a3);
00760
00761 dpvs = derivative_of_saturated_water_vapor_pressure(tk);
00762 dp = water_vapour_permeability(tk,ipp);
00763
00764 lv1 = latent_heat_of_evaporation_of_water (tk);
00765
00766
00767 kk = lambda + lv1 * dp * rh * dpvs;
00768 break;
00769 }
00770 case 2:
00771 case 3:
00772 case 4:
00773 case 5:
00774 case 6:{
00775 double moist, lambda;
00776
00777 moist = Tm->ip[ipp].eqother[0];
00778
00779
00780 CorD(10,kd,moist,lambda,a2,a3);
00781
00782 kk = lambda;
00783 break;
00784 }
00785 case 7:{
00786 double rov;
00787 double lv1, lambda, pvs, dp, moist;
00788
00789
00790 rov = Tm->ip[ipp].av[0];
00791
00792
00793 tk = Tm->ip[ipp].av[1];
00794
00795
00796 moist = 0.01;
00797
00798 CorD(10,kd,moist,lambda,a2,a3);
00799 dp = water_vapour_permeability(tk,ipp);
00800
00801 lv1 = latent_heat_of_evaporation_of_water (tk);
00802
00803
00804 kk = lambda + lv1 * dp * R * rov/M;
00805
00806 break;
00807 }
00808 default:{
00809 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
00810
00811 }
00812 }
00813
00814
00815
00816
00817 return (kk);
00818 }
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830 double kunmat::khm(long ipp)
00831 {
00832 double kk,tk;
00833
00834 switch (kunzeltype) {
00835 case 1:{
00836 double tk;
00837
00838 double lv, dp, ps;
00839
00840
00841
00842
00843 tk = Tm->ip[ipp].av[1];
00844
00845
00846
00847
00848 dp = water_vapour_permeability(tk,ipp);
00849 ps = saturated_water_vapor_pressure (tk);
00850 lv = latent_heat_of_evaporation_of_water (tk);
00851
00852
00853 kk = lv * dp * ps;
00854
00855 break;
00856 }
00857 case 2:
00858 case 3:
00859 case 4:
00860 case 5:{
00861 double tk;
00862 double lv, dp, ps;
00863
00864
00865 tk = Tm->ip[ipp].av[1];
00866
00867 dp = water_vapour_permeability(tk,ipp);
00868 lv = latent_heat_of_evaporation_of_water (tk);
00869
00870 kk = lv*dp;
00871
00872 break;
00873 }
00874 case 6:{
00875
00876 double lv, dp, ps;
00877
00878
00879
00880
00881
00882 tk = Tm->ip[ipp].av[1];
00883
00884 dp = water_vapour_permeability(tk,ipp);
00885 lv = latent_heat_of_evaporation_of_water (tk);
00886
00887 kk = lv*dp;
00888
00889 break;
00890 }
00891 case 7:{
00892 double tk, moist,dp;
00893
00894 double lv,D;
00895
00896
00897
00898
00899 tk = Tm->ip[ipp].av[1];
00900
00901
00902
00903
00904 moist= 0.05;
00905 CorD(18,kd,moist,D,a2,a3);
00906 lv = latent_heat_of_evaporation_of_water (tk);
00907 dp = water_vapour_permeability(tk,ipp);
00908
00909 kk = lv * dp*R*tk/M;
00910
00911 break;
00912 }
00913 default:{
00914 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
00915
00916 }
00917 }
00918
00919
00920
00921
00922
00923 return (kk);
00924 }
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935 double kunmat::cmm(long ipp)
00936 {
00937 double cc,tk;
00938
00939 switch (kunzeltype) {
00940 case 1:{
00941
00942 cc = Tm->ip[ipp].eqother[1];
00943 break;
00944 }
00945 case 2:{
00946 double tk;
00947
00948
00949
00950 tk = Tm->ip[ipp].av[1];
00951
00952 cc = M/(R*tk);
00953
00954 break;
00955 }
00956 case 3:{
00957 double moist, pi;
00958
00959
00960 moist = Tm->ip[ipp].eqother[0];
00961
00962
00963 CorD(3,kd,moist,pi,a2,a3);
00964
00965 cc = (pi-moist);
00966
00967 break;
00968 }
00969 case 4:{
00970 double moist, pi;
00971
00972
00973
00974 tk = Tm->ip[ipp].av[1];
00975
00976
00977 moist = Tm->ip[ipp].eqother[0];
00978
00979
00980 CorD(3,kd,moist,pi,a2,a3);
00981
00982 cc = (pi-moist)*M/(R*tk);;
00983
00984 break;
00985 }
00986 case 5:{
00987 double moist, pi;
00988
00989
00990
00991 tk = Tm->ip[ipp].av[1];
00992
00993
00994 CorD(3,kd,1,pi,a2,a3);
00995
00996 cc = (pi)*M/(R*tk);;
00997
00998 break;
00999 }
01000 case 6:{
01001 double moist, pi;
01002
01003
01004
01005 tk = Tm->ip[ipp].av[1];
01006
01007
01008 CorD(3,kd,1,pi,a2,a3);
01009
01010 cc = (pi)*M/(R*tk);
01011
01012 break;
01013 }
01014 case 7:{
01015 double moist, pi;
01016
01017
01018
01019
01020
01021
01022 CorD(3,kd,1,pi,a2,a3);
01023
01024 cc = pi;
01025
01026 cc = 1.0;
01027
01028 break;
01029 }
01030 default:{
01031 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
01032
01033 }
01034
01035
01036 }
01037
01038
01039
01040
01041
01042 return (cc);
01043 }
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054 double kunmat::cmt(long ipp)
01055 {
01056 double cc,tk ;
01057
01058 switch (kunzeltype) {
01059 case 1:{
01060
01061
01062
01063
01064
01065
01066
01067
01068 cc = 0.0;
01069
01070 break;
01071 }
01072 case 2:{
01073 double pv,tk, dw;
01074
01075 pv = Tm->ip[ipp].av[0];
01076
01077 tk = Tm->ip[ipp].av[1];
01078
01079 cc = -M*pv/(R*tk*tk);
01080 break;
01081 }
01082 case 3:
01083 case 4:
01084 case 5:
01085 case 6:
01086 case 7:{
01087
01088
01089
01090
01091
01092
01093 cc = 0.0;
01094 break;
01095 }
01096
01097 default:{
01098 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
01099 }
01100
01101 }
01102
01103
01104
01105
01106
01107 return (cc);
01108 }
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119 double kunmat::chm(long ipp)
01120 {
01121 double cc,tk;
01122
01123 switch (kunzeltype) {
01124 case 1:{
01125
01126
01127
01128
01129
01130
01131
01132
01133 cc = 0.0;
01134
01135 break;
01136 }
01137 case 2:
01138 case 3:
01139 case 4:
01140 case 5:
01141 case 6:
01142 case 7:{
01143
01144
01145
01146
01147
01148
01149 cc = 0.0;
01150
01151 break;
01152 }
01153
01154 default:{
01155 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
01156
01157 }
01158
01159 }
01160
01161
01162
01163
01164
01165 return (cc);
01166 }
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177 double kunmat::cht(long ipp)
01178 {
01179 double cc,tk;
01180
01181 switch (kunzeltype) {
01182 case 1:{
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194 cc = derivative_of_the_enthalpy_density(ipp);
01195
01196 break;
01197 }
01198 case 2:
01199 case 3:
01200 case 4:
01201 case 5:
01202 case 6:
01203 case 7:{
01204
01205
01206
01207
01208
01209
01210 cc = derivative_of_the_enthalpy_density(ipp);
01211
01212 break;
01213 }
01214
01215 default:{
01216 print_err("unknown type of Kunzel is required",__FILE__,__LINE__,__func__);
01217 }
01218
01219 }
01220
01221
01222
01223
01224
01225
01226 return (cc);
01227 }
01228
01229
01230
01231
01232
01233
01234
01235
01236 double kunmat::derivative_of_saturated_water_vapor_pressure(double tk)
01237 {
01238
01239 return ((4042.9 * exp(23.5771-4042.9/(tk - 37.58)))/((tk-37.58)*(tk-37.58)));
01240 }
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254
01255 double kunmat::water_vapour_permeability( double tk,long ipp)
01256 {
01257 double P, Rv, Pa;
01258 double da, dp, mi;
01259
01260
01261 moist = Tm->ip[ipp].eqother[0];
01262
01263
01264 CorD(4,kd,moist,mi,a2,a3);
01265
01266 Rv = R/M;
01267
01268
01269 Pa = 101325;
01270 P = 101325;
01271
01272 da = (2.306e-5 * Pa)/(Rv * tk * P)*pow((tk/273.15),1.81);
01273
01274 if (mi==0.0)
01275 dp=0.0;
01276 else
01277 dp = da/mi;
01278
01279 return (dp);
01280 }
01281
01282
01283
01284
01285
01286
01287 double kunmat::latent_heat_of_evaporation_of_water(double tk)
01288 {
01289 return (2.5008e6)*pow((273.15/tk),(0.167+tk*3.67e-4));
01290 }
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
01304 double kunmat::saturated_water_vapor_pressure(double tk)
01305 {
01306 return (exp(23.5771 - 4042.9/(tk - 37.58)));
01307 }
01308
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319 double kunmat::derivative_of_the_enthalpy_density(long ipp)
01320 {
01321 double rom, c, moist;
01322
01323
01324 moist = Tm->ip[ipp].eqother[0];
01325
01326
01327 CorD(2,kd,0,rom,a2,a3);
01328
01329
01330 CorD(9,kd,moist,c,a2,a3);
01331
01332 rho_m = rom;
01333
01334 return (rom * c);
01335 }
01336
01337
01338
01339
01340
01341
01342
01343 double kunmat::hygroscopic_moisture(double rh, double tk)
01344 {
01345
01346 double mhmc, mhrh,a3;
01347 CorD(6,kd,rh,mhmc,mhrh,a3);
01348
01349 return (mhmc/(1-sqrt(1-mhrh)));
01350
01351 }
01352
01353
01354
01355
01356
01357
01358
01359
01360 double kunmat::derivative_of_the_sorption_isotherm_root(double rh, double tk)
01361 {
01362
01363 double mhv;
01364 if (rh >1) rh = 1;
01365 if (rh < 0) rh = 0;
01366
01367 mhv = hygroscopic_moisture (rh,tk);
01368
01369 return (1000 * mhv/(2*sqrt(1-rh)));
01370
01371 }
01372
01373
01374
01375
01376
01377
01378
01379 double kunmat::derivative_of_retention_curve_root(double rh, double tk, long ipp)
01380 {
01381
01382 double smc, mhmc, mhrh;
01383
01384 smc = Tm->ip[ipp].eqother[2];
01385 CorD(6,kd,rh,mhmc,mhrh,a3);
01386
01387
01388 return (1000 * (smc - mhmc)/(1 - mhrh));
01389 }
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400 double kunmat::sorption_izotherm_derivative_kk_hansen(double rh, double tk)
01401 {
01402 double a, b, n;
01403
01404 CorD(6,kd,rh,a,b,n);
01405
01406
01407 if (rh >1) rh = 1;
01408 if (rh < 0) rh = 0;
01409
01410
01411 return (1000 * (a/(b*rh*n))*pow((1-(log(rh))/b),(-1-(1/n))));
01412
01413 }
01414
01415
01416
01417
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429 double kunmat::transmission_transcoeff(double trc,long ri,long ci,long nn,long bc,long ipp)
01430 {
01431 long k;
01432 double new_trc,h,t;
01433 new_trc = 0.0;
01434
01435 k=Gtt->give_dof(nn,0);
01436 if (k>0) {h = Lsrst->lhs[k-1]+Lsrst->lhsi[k-1];}
01437 if (k==0) {h = 0.0;}
01438 if (k<0) {h = Tb->lc[0].pv[0-k-1].getval();}
01439 k=Gtt->give_dof(nn,1);
01440 if (k>0) {t = Lsrst->lhs[k-1]+Lsrst->lhsi[k-1];}
01441 if (k==0) {t = 0.0;}
01442 if (k<0) {t = Tb->lc[0].pv[0-k-1].getval();}
01443
01444 if((ri == 0) && (ci == 0))
01445 new_trc = get_transmission_transcoeff_hh(h,t,bc,ipp);
01446 if((ri == 0) && (ci == 1))
01447 new_trc = 0.0;
01448
01449 if((ri == 1) && (ci == 0))
01450 new_trc = 0.0;
01451 if((ri == 1) && (ci == 1))
01452 new_trc = get_transmission_transcoeff_tt(h,t,bc,ipp);
01453
01454 new_trc = new_trc*trc;
01455
01456 return (new_trc);
01457 }
01458
01459
01460
01461
01462
01463
01464
01465
01466
01467
01468
01469
01470
01471
01472 double kunmat::transmission_nodval(double nodval,double trc2,long ri,long ci,long nn,long bc,long ipp)
01473 {
01474 long k;
01475 double new_nodval,h,t;
01476 new_nodval = 0.0;
01477
01478 k=Gtt->give_dof(nn,0);
01479 if (k>0) {h = Lsrst->lhs[k-1]+Lsrst->lhsi[k-1];}
01480 if (k==0) {h = 0.0;}
01481 if (k<0) {h = Tb->lc[0].pv[0-k-1].getval();}
01482 k=Gtt->give_dof(nn,1);
01483 if (k>0) {t = Lsrst->lhs[k-1]+Lsrst->lhsi[k-1];}
01484 if (k==0) {t = 0.0;}
01485 if (k<0) {t = Tb->lc[0].pv[0-k-1].getval();}
01486
01487 if((ri == 0) && (ci == 0))
01488 new_nodval = get_transmission_nodval_hh(nodval,h,t,bc,ipp);
01489 if((ri == 0) && (ci == 1))
01490 new_nodval = 0.0;
01491
01492 if((ri == 1) && (ci == 0))
01493 new_nodval = 0.0;
01494 if((ri == 1) && (ci == 1))
01495 new_nodval = get_transmission_nodval_tt(nodval,h,t,bc,ipp);
01496
01497 return (new_nodval);
01498 }
01499
01500
01501
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514 double kunmat::transmission_flux(double nodval,double trc2,long ri,long ci,long nn,long bc,long ipp)
01515 {
01516 long k;
01517 double flux,h,t;
01518 flux = 0.0;
01519
01520 k=Gtt->give_dof(nn,0);
01521 if (k>0) {h = Lsrst->lhs[k-1]+Lsrst->lhsi[k-1];}
01522 if (k==0) {h = 0.0;}
01523 if (k<0) {h = Tb->lc[0].pv[0-k-1].getval();}
01524 k=Gtt->give_dof(nn,1);
01525 if (k>0) {t = Lsrst->lhs[k-1]+Lsrst->lhsi[k-1];}
01526 if (k==0) {t = 0.0;}
01527 if (k<0) {t = Tb->lc[0].pv[0-k-1].getval();}
01528
01529 if((ri == 0) && (ci == 0))
01530 flux = get_transmission_flux_hh(nodval,h,t,bc,ipp);
01531 if((ri == 0) && (ci == 1))
01532 flux = 0.0;
01533
01534 if((ri == 1) && (ci == 0))
01535 flux = 0.0;
01536 if((ri == 1) && (ci == 1))
01537 flux = get_transmission_flux_tt(nodval,h,t,bc,ipp);
01538
01539 return (flux);
01540 }
01541
01542
01543
01544
01545
01546
01547
01548
01549
01550 double kunmat::get_transmission_transcoeff_hh(double rh,double t,long bc,long ipp)
01551 {
01552 double trc,pgws;
01553
01554 switch (bc){
01555 case 30:{
01556 pgws = saturated_water_vapor_pressure(t);
01557 trc = pgws;
01558 break;
01559 }
01560 case 31:{
01561 pgws = saturated_water_vapor_pressure(t);
01562 trc = pgws;
01563 break;
01564 }
01565 case 32:{
01566 trc = 0.0;
01567 break;
01568 }
01569 default:{
01570 print_err("no real boundary condition is prescribed",__FILE__,__LINE__,__func__);
01571 exit(0);
01572 }
01573 }
01574 return(trc);
01575 }
01576
01577
01578
01579
01580
01581
01582
01583
01584
01585 double kunmat::get_transmission_nodval_hh(double bv,double rh,double t,long bc,long ipp)
01586 {
01587 double nodval,pgws, pgwspred;
01588
01589 switch (bc){
01590 case 30:{
01591
01592 pgws = saturated_water_vapor_pressure(t);
01593 pgwspred = saturated_water_vapor_pressure(t);
01594
01595 nodval = bv*pgwspred;
01596
01597 break;
01598 }
01599 case 31:{
01600 nodval = bv;
01601 break;
01602 }
01603 case 32:{
01604 pgws = saturated_water_vapor_pressure(t);
01605
01606 nodval = pgws*rh;
01607 bv = pgws*bv;
01608 nodval = bv - nodval;
01609
01610 break;
01611 }
01612 default:{
01613 print_err("no real boundary condition is prescribed",__FILE__,__LINE__,__func__);
01614 exit(0);
01615 }
01616 }
01617 return(nodval);
01618 }
01619
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629 double kunmat::get_transmission_flux_hh(double bv,double rh,double t,long bc,long ipp)
01630 {
01631 double flux,pgws;
01632
01633 switch (bc){
01634 case 30:{
01635 pgws = saturated_water_vapor_pressure( t);
01636
01637 flux = pgws*rh;
01638 bv = pgws*bv;
01639 flux = bv - flux;
01640
01641 break;
01642 }
01643 case 31:{
01644 pgws = saturated_water_vapor_pressure(t);
01645 flux = pgws*rh;
01646
01647 flux = bv - flux;
01648 break;
01649 }
01650 case 32:{
01651 pgws = saturated_water_vapor_pressure(t);
01652
01653 flux = pgws*rh;
01654 bv = pgws*bv;
01655 flux = bv - flux;
01656
01657 break;
01658 }
01659 default:{
01660 print_err("no real boundary condition is prescribed",__FILE__,__LINE__,__func__);
01661 exit(0);
01662 }
01663 }
01664 return(flux);
01665 }
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675 double kunmat::get_transmission_transcoeff_tt(double h,double t,long bc,long ipp)
01676 {
01677 double trc;
01678
01679 switch (bc){
01680 case 30:{
01681 trc = 1.0;
01682 break;
01683 }
01684 default:{
01685 print_err("no real boundary condition is prescribed",__FILE__,__LINE__,__func__);
01686 exit(0);
01687 }
01688 }
01689
01690 return(trc);
01691 }
01692
01693
01694
01695
01696
01697
01698
01699
01700
01701 double kunmat::get_transmission_nodval_tt(double bv,double h,double t,long bc,long ipp)
01702 {
01703 double nodval;
01704
01705 switch (bc){
01706 case 30:{
01707 nodval = bv;
01708 break;
01709 }
01710 default:{
01711 print_err("no real boundary condition is prescribed",__FILE__,__LINE__,__func__);
01712 exit(0);
01713 }
01714 }
01715 return(nodval);
01716 }
01717
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727 double kunmat::get_transmission_flux_tt(double bv,double h,double t,long bc,long ipp)
01728 {
01729 double flux;
01730
01731 switch (bc){
01732 case 30:{
01733 flux = (bv - t);
01734 break;
01735 }
01736 default:{
01737 print_err("no real boundary condition is prescribed",__FILE__,__LINE__,__func__);
01738 exit(0);
01739 }
01740 }
01741 return(flux);
01742 }
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754 double kunmat::get_othervalue(long compother,double rh,double t, long ipp)
01755 {
01756 double other;
01757
01758 switch (compother){
01759 case 0:{
01760 other = rh;
01761 break;
01762 }
01763 case 1:{
01764 other = t;
01765 break;
01766 }
01767 case 2:{
01768 double w, a3;
01769
01770 other = w;
01771 break;
01772 }
01773 case 3:{
01774 other = rh * saturated_water_vapor_pressure (t);
01775 break;
01776 }
01777 case 4:{
01778 double w, a3;
01779
01780 other = w*rho_w/rho_m;
01781 break;
01782 }
01783 case 5:{
01784 other = rh/saturated_water_vapor_pressure (t);
01785 break;
01786 }
01787 case 6:{
01788 other = rh*saturated_water_vapor_pressure (t)*M/(R*t);
01789 break;
01790 }
01791 case 7:{
01792 other = rh*R*t/(saturated_water_vapor_pressure (t)*M);
01793 break;
01794 }
01795 case 8:{
01796 other = 0.0;
01797 break;
01798 }
01799 case 9:{
01800 other = 0.0;
01801 break;
01802 }
01803 case 10:{
01804 other = 0.0;
01805 break;
01806 }
01807 default:{
01808 print_err("unknown type of component is required",__FILE__,__LINE__,__func__);
01809 }
01810 }
01811 return (other);
01812
01813 }
01814
01815
01816
01817
01818
01819
01820 void kunmat::print_othervalue_name(FILE *out,long compother)
01821 {
01822 switch (compother){
01823 case 0:{
01824 fprintf (out,"Relative humidity () ");
01825 break;
01826 }
01827 case 1:{
01828 fprintf (out,"Temperature (K) ");
01829 break;
01830 }
01831 case 2:{
01832 fprintf (out,"Moisture content w (m3/m3) ");
01833 break;
01834 }
01835 case 3:{
01836 fprintf (out,"Water vapour pressure (Pa) ");
01837 break;
01838 }
01839 case 4:{
01840 fprintf (out,"Moisture content u (kg/kg) ");
01841 break;
01842 }
01843 default:{
01844 print_err("unknown type of component is required",__FILE__,__LINE__,__func__);
01845 }
01846 }
01847 }
01848
01849
01850 void kunmat::give_data(double rh,double Mhmc, double Smc, double Mhrh, double & moistakt)
01851 {
01852 double hvezdicka;
01853 hvezdicka = Mhmc/(1-sqrt(1-Mhrh));
01854
01855 if (rh < Mhrh)
01856 {
01857 moistakt = (1-sqrt(1-rh)) * hvezdicka ;
01858 }
01859 else {
01860 if (rh > 1)
01861 {
01862 moistakt = Smc;
01863 }
01864 else
01865 {
01866 moistakt = Mhmc + (rh - Mhrh )/(1-Mhrh )* (Smc - Mhmc );
01867 }
01868 }
01869
01870 }
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880
01881 double kunmat::kapa_exp(double a, double b, double rh)
01882 {
01883 return (a * exp(b * rh));
01884 }
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911
01912
01913
01914
01915
01916
01917
01918 void kunmat::CorD(long charid,long &kvyhl, double x, double &y, double &z, double &z2)
01919 {
01920
01921 switch (MatChar[charid]){
01922 case 0:{
01923 kvyhl = 0;
01924 break;
01925 }
01926 case 1:{
01927
01928
01929 y = data[charid]->getval(0.0);
01930 kvyhl = 1;
01931 break;
01932 }
01933 case 2:{
01934
01935
01936 y = data[charid]->getval(x);
01937 kvyhl = 2;
01938
01939
01940 long nr=data[charid]->tabf[0].asize;
01941
01942
01943 z2 = data[charid]->tabf[0].y[nr-1];
01944
01945 break;
01946 }
01947 case 30:{
01948 y = MatFunce[charid][0];
01949 z = MatFunce[charid][1];
01950 kvyhl = 30;
01951 break;
01952 }
01953 case 31:{
01954 y = MatFunce[charid][0];
01955 z = MatFunce[charid][1];
01956 if (charid == 6)
01957 {
01958 z2 = MatFunce[charid][2];
01959 }
01960 kvyhl = 31;
01961 break;
01962 }
01963 case 32:{
01964 y = MatFunce[charid][0];
01965 z = MatFunce[charid][1];
01966 kvyhl = 32;
01967 break;
01968 }
01969 case 33:{
01970 kvyhl = 33;
01971
01972 break;
01973 }
01974 default:{
01975 print_err("unknown definition of material parameter is required",__FILE__,__LINE__,__func__);
01976 }
01977 }
01978 }
01979
01980 void kunmat::sorption_izoterms_giva_data(long kod,double rh, double tk, double & moist, double & dmoistdrh, long ipp)
01981 {
01982
01983
01984
01985 long s;
01986 double hmrh, mhmc, smc, u, a, n;
01987
01988 if (rh < 0) rh = 0;
01989
01990 CorD(6,s,0,a1,a2,a3);
01991
01992 switch (s){
01993 case 2:{
01994 if(rh>0.976)
01995 {
01996
01997 CorD(7,kd,rh,smc,a2,a3);
01998 CorD(6,kd,0.976,mhmc,a2,mhmc);
01999 give_data(rh,mhmc, smc, 0.976,moist);
02000 dmoistdrh =1000 * (smc - mhmc)/(1 - 0.976);
02001 }
02002 else
02003 {
02004 CorD(6,s,rh,moist,dmoistdrh,a3);
02005 dmoistdrh =1000* derivative_sorption_izoterm_data(rh);
02006 }
02007 break;
02008 }
02009 case 30:{
02010 CorD(6,s,rh,a1,hmrh,a3);
02011 CorD(7,s,rh,smc,a2,a3);
02012 CorD(6,s,rh,mhmc,hmrh,a3);
02013 give_data(rh,mhmc, smc, hmrh,moist);
02014 if (rh < hmrh)
02015 {
02016 dmoistdrh = derivative_of_the_sorption_isotherm_root (rh, tk);
02017 }
02018 else {
02019 dmoistdrh = derivative_of_retention_curve_root(rh, tk, ipp);
02020 }
02021
02022 break;
02023 }
02024 case 31:{
02025 switch (kod){
02026 case 0:{
02027 CorD(6,kod,0,u,a,n);
02028 moist = si_kk_hansen(rh, 0,u,a,n);
02029 dmoistdrh = sorption_izotherm_derivative_kk_hansen(rh, tk);
02030 break;
02031 }
02032 case 1:{
02033 dmoistdrh = sorption_izotherm_derivative_kk_hansen(rh, tk);
02034 break;
02035 }
02036 default:{
02037 print_err("unknown definition of Sorption isotherm HANSEN is required",__FILE__,__LINE__,__func__);
02038 }
02039 }
02040 break ;
02041 }
02042 default:{
02043 print_err("unknown definition of Sorption isotherm is required",__FILE__,__LINE__,__func__);
02044 }
02045 }
02046
02047
02048 }
02049
02050 double kunmat::si_kk_hansen(double rh, double tk,double u, double a, double n)
02051 {
02052 return (u*pow((1-(log(rh))/a),(-1/n)));
02053 }
02054
02055
02056
02057
02058
02059
02060
02061
02062 double kunmat::derivative_sorption_izoterm_data(double x1)
02063 {
02064 long charid;
02065 double derbi;
02066
02067
02068 charid=6;
02069 derbi = data[charid]->getderiv (x1);
02070
02071 return derbi;
02072 }
02073
02074
02075
02076
02077
02078
02079
02080
02081
02082 void kunmat::aux_values (long ipp,double *in,double *inp, double *ineq,double *out)
02083 {
02084
02085
02086 switch (kunzeltype) {
02087 case 1:{
02088 double rh,tk;
02089 double w,dwdf, kapaA, smc;
02090
02091
02092 rh = in[0];
02093
02094 tk = in[1];
02095
02096 smc = data[7]->getval(0.0);
02097
02098 sorption_izoterms_giva_data(0,rh,tk,w,dwdf, ipp);
02099 if (w>smc) w = smc;
02100 if(w<0) w = 0.0;
02101
02102 kapa_values(MatChar[5],ipp,w, kapaA);
02103
02104
02105 out[3] = kapaA;
02106
02107 out[0] = w;
02108
02109 out[1] = dwdf;
02110
02111 out[2] = smc;
02112
02113 out[4] = kunzeltype;
02114
02115 break;
02116 }
02117 case 2:
02118 case 3:
02119 case 4:{
02120 double pv,tk, pvs;
02121 double w,dwdf, kapaA, smc, rh;
02122
02123 pv = Tm->ip[ipp].av[0];
02124
02125 tk = Tm->ip[ipp].av[1];
02126
02127 pvs = saturated_water_vapor_pressure(tk);
02128
02129 rh = pv/pvs;
02130 if (rh>1) {
02131 rh = 1;
02132 }
02133 if (rh<0) {
02134 rh = 0.0;
02135 }
02136
02137 smc = data[7]->getval(0.0);
02138
02139 sorption_izoterms_giva_data(0,rh,tk,w,dwdf, ipp);
02140 if (w>smc) w = smc;
02141 if(w<0) w = 0.0;
02142
02143 kapa_values(MatChar[5],ipp,w, kapaA);
02144
02145
02146 out[3] = kapaA;
02147
02148 out[0] = w;
02149
02150
02151 out[1] = rh;
02152
02153 out[2] = smc;
02154
02155 out[4] = kunzeltype;
02156 break;
02157 }
02158 case 5:
02159 case 6:
02160 case 7:{
02161 double pv,tk, pvs;
02162 double w,dwdf, kapaA, smc, rh;
02163
02164 pv = Tm->ip[ipp].av[0];
02165
02166 tk = Tm->ip[ipp].av[1];
02167
02168
02169 smc = data[7]->getval(0.0);
02170
02171
02172
02173 out[3] = -10000.0;
02174
02175 out[0] =smc;
02176
02177
02178 out[1] = 0.1;
02179
02180 out[2] = smc;
02181
02182 out[4] = kunzeltype;
02183 break;
02184 }
02185 default:
02186 ;
02187 }
02188 }
02189
02190
02191
02192
02193
02194
02195
02196
02197
02198 void kunmat::save_values (long ipp,double *out)
02199 {
02200 Tm->ip[ipp].eqother[0]=out[0];
02201 Tm->ip[ipp].eqother[1]=out[1];
02202 Tm->ip[ipp].eqother[2]=out[2];
02203 Tm->ip[ipp].eqother[3]=out[3];
02204 Tm->ip[ipp].eqother[4]=out[4];
02205 }
02206
02207
02208
02209
02210
02211
02212
02213
02214
02215
02216 void kunmat::give_values (long ipp,double *av,double *eq)
02217 {
02218 av[0] = Tm->ip[ipp].av[0];
02219 av[1] = Tm->ip[ipp].av[1];
02220
02221 eq[0] = Tm->ip[ipp].eqother[0];
02222 eq[1] = Tm->ip[ipp].eqother[1];
02223 eq[2] = Tm->ip[ipp].eqother[2];
02224 eq[3] = Tm->ip[ipp].eqother[3];
02225 eq[4] = Tm->ip[ipp].eqother[4];
02226 }
02227
02228
02229
02230
02231
02232
02233 void kunmat::kapa_values (long kod, long ipp,double x1, double &kapa)
02234 {
02235 double kapa1, kapa2, kapa3;
02236 long kd1;
02237
02238 switch (kod){
02239 case 0: kapa = 0.0;
02240 break;
02241 case 1: CorD(5,kod,x1,kapa,kapa1,kapa2);
02242 break;
02243 case 2: CorD(5,kod,x1,kapa,kapa1,kapa2);
02244 break;
02245 case 30:{
02246 CorD(5,kod,x1,kapa1,kapa2,kapa3);
02247 kapa = kapa_exp(kapa1,kapa2,x1);
02248 break;
02249 }
02250 default:{
02251 print_err("unknown kod is required",__FILE__,__LINE__,__func__);
02252 }
02253 }
02254 }
02255
02256 void kunmat::initvalues (long ipp,long ido)
02257 {
02258 double x1,x2;
02259
02260 x1 = Tm->ip[ipp].av[0];
02261 x2 = Tm->ip[ipp].av[1];
02262
02263 }
02264
02265