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