Gems3k  3.1
GEMS3K standalone solver for geochemical equilibria
 All Classes Files Functions Variables Enumerations Enumerator
/Users/kulik/DevGEMS/trunk/standalone/GEMS3K/s_solmod.h
Go to the documentation of this file.
00001 //-------------------------------------------------------------------
00002 // $Id: s_fgl.h 725 2012-10-02 15:43:37Z kulik $
00003 //
00007 
00008 // Copyright (C) 2003-2012  T.Wagner, D.Kulik, S.Dmitrieva, F.Hingerl, S.Churakov
00009 // <GEMS Development Team, mailto:gems2.support@psi.ch>
00010 //
00011 // This file is part of the GEMS3K code for thermodynamic modelling
00012 // by Gibbs energy minimization <http://gems.web.psi.ch/GEMS3K/>
00013 //
00014 // GEMS3K is free software: you can redistribute it and/or modify
00015 // it under the terms of the GNU Lesser General Public License as
00016 // published by the Free Software Foundation, either version 3 of
00017 // the License, or (at your option) any later version.
00018 
00019 // GEMS3K is distributed in the hope that it will be useful,
00020 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00021 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00022 // GNU Lesser General Public License for more details.
00023 
00024 // You should have received a copy of the GNU General Public License
00025 // along with GEMS3K code. If not, see <http://www.gnu.org/licenses/>.
00026 //------------------------------------------------------------------
00027 //
00028 
00029 #ifndef _s_solmod_h_
00030 #define _s_solmod_h_
00031 #include <cstring>
00032 #include <vector>
00033 #include <iostream>
00034 
00035 // re-declaration of enums below required for GEMS3K
00036 // dc_class_codes for fluids will be replaced by tp_codes
00037 enum fluid_mix_rules {  
00038     MR_UNDEF_ = 'N',
00039     MR_WAAL_ = 'W',
00040     MR_CONST_ = 'C',
00041     MR_TEMP_ = 'T',
00042     MR_LJ_ = 'J',
00043     MR_KW1_ = 'K',
00044     MR_PITZ5_ = '5',
00045     MR_PITZ6_ = '6',
00046     MR_PITZ8_ = '8'
00047 };
00048 
00049 enum dc_class_codes {  
00050     DC_GAS_H2O_ = 'V',
00051     DC_GAS_CO2_ = 'C',
00052     DC_GAS_H2_ = 'H',
00053     DC_GAS_N2_ = 'N',
00054     DC_GAS_COMP_ = 'G'
00055 };
00056 
00057 enum tp_codes {  
00058     CEM_OFF_ = 'N',
00059     CEM_GAS_ = 'G',
00060     CEM_H2O_ = 'V',
00061     CEM_CO2_ = 'C',
00062     CEM_CH4_ = 'M',
00063     CEM_N2_ = 'T',
00064     CEM_H2_ = 'H',
00065     CEM_O2_ = 'O',
00066     CEM_AR_ = 'A',
00067     CEM_PO_ = 'P',
00068     CEM_NP_ = 'Q'
00069 };
00070 
00071 // ------------------------------------------------------------------
00072 
00073 #define MAXPHASENAME 16
00074 
00077 struct SolutionData {
00078     long int NSpecies;  
00079     long int NParams;   
00080     long int NPcoefs;   
00081     long int MaxOrder;  
00082     long int NPperDC;   
00083     long int NSublat;   
00084     long int NMoiet;    
00085     char Mod_Code;      
00086     char Mix_Code;      
00087     char *DC_Codes;     
00088     char (*TP_Code)[6]; 
00089     long int *arIPx;    
00090     double *arIPc;      
00091     double *arDCc;      
00092     double *arMoiSN;    
00093     double *arSitFr;    
00094  // TBD   double *arSitFj; ///< Table of end member sublattice activity coefficients -> NSpecies x NSublat
00095     double *arGEX;      
00096     double *arPparc;    
00097     double *arWx;       
00098     double *arlnGam;    
00099     double *arVol;      
00100     double *aphVOL;     
00101     double T_k;         
00102     double P_bar;       
00103 };
00104 
00105 
00106 class TSolMod
00107 {
00108         protected:
00109         char ModCode;   
00110         char MixCode;   
00111                 char *DC_Codes; 
00112 
00113         char PhaseName[MAXPHASENAME+1];    
00114 
00115         long int NComp;   
00116         long int NPar;     
00117         long int NPcoef;   
00118         long int MaxOrd;   
00119         long int NP_DC;    
00120         long int NSub;     
00121         long int NMoi;     
00122 //        long int NPTP_DC;  ///< Number of properties per one DC at T,P of interest (columns in aDC)  !!!! Move to CG EOS subclass
00123         long int *aIPx;    
00124 
00125         double R_CONST; 
00126         double Tk;      
00127         double Pbar;    
00128 
00129         double *aIPc;   
00130         double *aIP;    
00131         double *aDCc;   
00132         double *aGEX;   
00133         double *aPparc;  
00134         double **aDC;   
00135         double *aMoiSN; 
00136         double *aSitFR; 
00137 // TBD        double *aSitFj; ///< Table of site activity coefficients [NComp][NSub]
00138         double *x;      
00139         double *aVol;   
00140         double *phVOL;  
00141 
00142         // Results
00143         // double Gam;          ///< work cell for activity coefficient of end member
00144         // double lnGamRT;
00145         // double lnGam;
00146         double Gex, Hex, Sex, CPex, Vex, Aex, Uex;   
00147         double Gid, Hid, Sid, CPid, Vid, Aid, Uid;   
00148         double Gdq, Hdq, Sdq, CPdq, Vdq, Adq, Udq;   
00149         double Grs, Hrs, Srs, CPrs, Vrs, Ars, Urs;   
00150         double *lnGamConf, *lnGamRecip, *lnGamEx;    
00151         double *lnGamma;   
00152 
00153         double **y;       
00154         double ***mn;     
00155         double *mns;      
00156    double **fjs;     
00157 
00158         // functions for calculation of configurational term for multisite ideal mixing
00159         void alloc_multisite();
00160         long int init_multisite();
00161         void free_multisite();
00162 
00164         long int IdealMixing();
00165         double ideal_conf_entropy();
00166         void return_sitefr();
00167         void retrieve_sitefr();
00168 
00169 
00170         public:
00171 
00173                 TSolMod( SolutionData *sd );
00174                     // TSolMod( long int NSpecies, long int NParams, long int NPcoefs, long int MaxOrder,
00175                         // long int NPperDC, long int NPTPperDC, char Mod_Code, char Mix_Code,
00176                         // long int* arIPx, double* arIPc, double* arDCc, double *arWx,
00177                         // double *arlnGam, double *aphVOL, double T_k, double P_bar );
00178 
00180                 TSolMod( long int NSpecies,  char Mod_Code,  double T_k, double P_bar );
00181 
00183                 virtual ~TSolMod();
00184 
00185                 virtual long int PureSpecies()
00186                 {
00187                         return 0;
00188                 };
00189 
00190                 virtual long int PTparam()
00191                 {
00192                         return 0;
00193                 };
00194 
00195                 virtual long int MixMod()
00196                 {
00197                         return 0;
00198                 };
00199 
00200                 virtual long int ExcessProp( double *Zex )
00201                 {
00202                         return 0;
00203                 };
00204 
00205                 virtual long int IdealProp( double *Zid )
00206                 {
00207                         return 0;
00208                 };
00209 
00211                 long int UpdatePT ( double T_k, double P_bar );
00212 
00213                 // bool testSizes( long int NSpecies, long int NParams, long int NPcoefs,
00214                     // long int MaxOrder, long int NPperDC, char Mod_Code, char Mix_Code );
00215 
00216                 bool testSizes( SolutionData *sd );
00217 
00219                 void GetPhaseName( const char *PhName );
00220 
00221                 
00222                 // return pointer to activity coefficients
00223                 inline void Get_lnGamma( double* lngamma )              
00224                 { 
00225                         for( int i=0; i<NComp; i++ )
00226                                 lngamma[i] = lnGamma[i]; 
00227                 }
00228 
00229 
00230 };
00231 
00232 
00233 
00235 class TIdeal: public TSolMod
00236 {
00237             private:
00238 
00239             public:
00240 
00242                     TIdeal( SolutionData *sd );
00243 
00245                     ~TIdeal();
00246 
00248                     long int PTparam();
00249 
00251                     long int MixMod();
00252 
00254                     long int ExcessProp( double *Zex );
00255 
00257                     long int IdealProp( double *Zid );
00258 
00259 };
00260 
00261 
00262 
00265 class EOSPARAM
00266 {
00267         private:
00268                 //static double Told;
00269                 // unsigned long int isize;  // int isize = NComp;
00270                 long int NComp;
00271                 double emix, s3mix;
00272                 double *epspar,*sig3par;
00273                 double *XX;
00274                 double *eps;
00275                 double *eps05;
00276                 double *sigpar;
00277                 double *mpar;
00278                 double *apar;
00279                 double *aredpar;
00280                 double *m2par;
00281                 double **mixpar;
00282 
00283                 void allocate();
00284                 void free();
00285 
00286         public:
00287 
00288                 double *XX0;
00289 
00290                 //EOSPARAM():isize(0),emix(0),s3mix(0),NComp(0){};
00291                 //EOSPARAM(double*data, unsigned nn):isize(0){allocate(nn);init(data,nn);};
00292 
00293                 EOSPARAM( double *Xtmp, double *data, long int nn )
00294                         :NComp(nn), emix(0),s3mix(0)
00295                         { allocate(); init(Xtmp,data,nn); }
00296 
00297                 ~EOSPARAM()
00298                         { free(); }
00299 
00300                 void init( double*,double *, long int );
00301                 long int NCmp()   {return NComp; }
00302 
00303                 double EPS05( long int i)
00304                         { return eps05[i]; }
00305                 double X( long int i)
00306                         { return XX[i]; }
00307                 double EPS( long int i)
00308                         { return eps[i]; }
00309                 double EMIX(void)
00310                         { return emix; }
00311                 double S3MIX(void)
00312                         { return s3mix; }
00313 
00314                 double MIXS3( long int i, long int j)
00315                 {
00316                         if (i==j) return sig3par[i];
00317                         if (i<j) return mixpar[i][j];
00318                             else return mixpar[j][i];
00319                 }
00320 
00321                 double MIXES3( long int i, long int j)
00322                 {
00323                         if ( i==j ) return epspar[i];
00324                         if (i<j) return mixpar[j][i];
00325                             else return mixpar[i][j];
00326                 };
00327 
00328                 double SIG3( long int i){ return sig3par[i]; }
00329                 double M2R( long int i) { return m2par[i]; }
00330                 double A( long int i)   { return apar[i]; }
00331 
00332                 long int ParamMix( double *Xin);
00333 };
00334 
00335 
00336 
00337 // -------------------------------------------------------------------------------------
00343 class TCGFcalc: public TSolMod
00344 {
00345         private:
00346 
00347                 double
00348                 PI_1,    
00349                 TWOPI,    
00350                 PISIX,    
00351                 TWOPOW1SIX,   
00352                 DELTA,
00353                 DELTAMOLLIM,
00354                 R,  NA,  P1,
00355                 PP2, P3, P4,
00356                 P5,  P6, P7,
00357                 P8,  P9, P10,
00358                 AA1, AA2, AA3,
00359                 A4, A5, A6,
00360                 BB1, BB2, BB3,
00361                 B4,  B5,  B6,
00362                 A00, A01, A10,
00363                 A11, A12, A21,
00364                 A22, A23, A31,
00365                 A32, A33, A34;
00366 
00367                 //  double PhVol;  // phase volume in cm3
00368                 double *Pparc;     
00369                 double *phWGT;
00370                 double *aX;        
00371                     // double *aGEX;      // Increments to molar G0 values of DCs from pure fugacities
00372                     // double *aVol;      // DC molar volumes, cm3/mol [L]
00373 
00374                 // main work arrays
00375                 EOSPARAM *paar;
00376                 EOSPARAM *paar1;
00377                 double *FugCoefs;
00378                 double *EoSparam;
00379                 double *EoSparam1;
00380                 double (*Cf)[8];   
00381 
00382                 // internal functions
00383                 void alloc_internal();
00384                 void free_internal();
00385                 void set_internal();
00386 
00387                 void choose( double *pres, double P,unsigned long int &x1,unsigned long int &x2 );
00388                 double Melt2( double T );
00389                 double Melt( double T );
00390                 void copy( double* sours,double *dest,unsigned long int num );
00391                 void norm( double *X,unsigned long int mNum );
00392                 double RPA( double beta,double nuw );
00393                 double dHS( double beta,double ro );
00394 
00395                 inline double fI1_6( double nuw )
00396                 {
00397                     return (1.+(A4+(A5+A6*nuw)*nuw)*nuw)/
00398                         ((1.+(AA1+(AA2+AA3*nuw)*nuw)*nuw)*3.);
00399                 }
00400 
00401                 inline double fI1_12( double nuw )
00402                 {
00403                     return (1.+(B4+(B5+B6*nuw)*nuw)*nuw)/
00404                         ((1.+(BB1+(BB2+BB3*nuw)*nuw)*nuw)*9.);
00405                 }
00406 
00407                 inline double fa0( double nuw ,double nu1w2 )
00408                 {
00409                     return (A00 + A01*nuw)/nu1w2;
00410                 }
00411 
00412                 inline double fa1( double nuw ,double nu1w3 )
00413                 {
00414                     return (A10+(A11+A12*nuw)*nuw)/nu1w3;
00415                 }
00416 
00417                 inline double fa2( double nuw ,double nu1w4 )
00418                 {
00419                     return ((A21+(A22+A23*nuw)*nuw)*nuw)/nu1w4;
00420                 }
00421 
00422                 inline double fa3( double nuw ,double nu1w5 )
00423                 {
00424                     return ((A31+(A32+(A33+A34*nuw)*nuw)*nuw)*nuw)/nu1w5;
00425                 }
00426 
00427                 double DIntegral( double T, double ro, unsigned long int IType ); // not used
00428                 double LIntegral( double T, double ro, unsigned long int IType ); // not used
00429                 double KIntegral( double T, double ro, unsigned long int IType ); // not used
00430                 double K23_13( double T, double ro );
00431                 double J6LJ( double T,double ro );
00432                 double FDipPair( double T,double ro,double m2 ); // not used
00433                 double UWCANum( double T,double ro );
00434                 double ZWCANum( double T,double ro );
00435 
00436                 double FWCA( double T,double ro );
00437                 double FTOTALMIX( double T_Real,double ro_Real,EOSPARAM* param );
00438                 double UTOTALMIX( double T_Real,double ro_Real,EOSPARAM* param ); // not used
00439                 double ZTOTALMIX( double T_Real,double ro_Real,EOSPARAM* param );
00440                 double PTOTALMIX( double T_Real,double ro_Real,EOSPARAM* param );
00441                 double ROTOTALMIX( double P,double TT,EOSPARAM* param );
00442 
00443                 double PRESSURE( double *X, double *param, unsigned long int NN, double ro, double T ); // not used
00444                 double DENSITY( double *X,double *param, unsigned long int NN ,double Pbar, double T );
00445                 long int CGActivCoefRhoT( double *X,double *param, double *act, unsigned long int NN,
00446                                 double ro, double T ); // not used
00447 
00448                 long int CGActivCoefPT(double *X,double *param,double *act, unsigned long int NN,
00449                                 double Pbar, double T, double &roro );
00450 
00451         public:
00452 
00454                 TCGFcalc( long int NCmp, double Pp, double Tkp );
00455                 TCGFcalc( SolutionData *sd, double *aphWGT, double *arX );
00456 
00458                 ~TCGFcalc();
00459 
00461                 long int PureSpecies( );
00462 
00464                 long int PTparam();
00465 
00467                 long int MixMod();
00468 
00470                 long int ExcessProp( double *Zex );
00471 
00473                 long int IdealProp( double *Zid );
00474 
00476                 long int CGcalcFugPure( double Tmin, float *Cemp, double *FugProps );  // called from DCthermo
00477                 long int CGFugacityPT( double *EoSparam, double *EoSparPT, double &Fugacity,
00478                                 double &Volume, double P, double T, double &roro );
00479 
00481                 long int CGResidualFunct( double *X, double *param, double *param1, unsigned long int NN,
00482                                 double ro, double T );
00483 
00484                 double GetDELTA( void )
00485                 {
00486                         return DELTA;
00487                 };
00488 };
00489 
00490 
00491 
00492 // -------------------------------------------------------------------------------------
00496 class TPRSVcalc: public TSolMod
00497 
00498 {
00499         private:
00500 
00501         double PhVol;   
00502                 double *Pparc;  
00503                     // double *aGEX;   // Increments to molar G0 values of DCs from pure fugacities
00504                     // double *aVol;   // DC molar volumes, cm3/mol [L]
00505 
00506                 // main work arrays
00507         double (*Eosparm)[6];   
00508         double (*Pureparm)[4];  
00509         double (*Fugpure)[6];   
00510         double (*Fugci)[4];     
00511 
00512         double **a;             
00513                 double **b;
00514         double **KK;     
00515         double **dKK;    
00516         double **d2KK;   
00517         double **AA;     
00518 
00519 
00520 
00521                 // internal functions
00522                 void alloc_internal();
00523                 void free_internal();
00524                 long int AB( double Tcrit, double Pcrit, double omg, double k1, double k2, double k3,
00525                                 double &apure, double &bpure, double &da, double &d2a );
00526                 long int FugacityPT( long int i, double *EoSparam );
00527                 long int FugacityPure( long int j ); // Calculates the fugacity of pure species
00528                 long int Cardano( double a2, double a1, double a0, double &z1, double &z2, double &z3 );
00529                 long int MixParam( double &amix, double &bmix );
00530                 long int FugacityMix( double amix, double bmix, double &fugmix, double &zmix, double &vmix );
00531                 long int FugacitySpec( double *fugpure );
00532                 long int ResidualFunct( double *fugpure );
00533                 long int MixingWaals();
00534                 long int MixingConst();
00535                 long int MixingTemp();
00536 
00537         public:
00538 
00540                 TPRSVcalc( long int NCmp, double Pp, double Tkp );
00541                 TPRSVcalc( SolutionData *sd );
00542 
00544                 ~TPRSVcalc();
00545 
00547                 long int PureSpecies();
00548 
00550                 long int PTparam();
00551 
00553                 long int MixMod();
00554 
00556                 long int ExcessProp( double *Zex );
00557 
00559                 long int IdealProp( double *Zid );
00560 
00562                 long int PRSVCalcFugPure( double Tmin, float *Cpg, double *FugProps );
00563 
00564 };
00565 
00566 
00567 
00568 // -------------------------------------------------------------------------------------
00572 class TSRKcalc: public TSolMod
00573 
00574 {
00575         private:
00576 
00577         double PhVol;   
00578                 double *Pparc;  
00579                     // double *aGEX;   // Increments to molar G0 values of DCs from pure fugacities
00580                     // double *aVol;   // DC molar volumes, cm3/mol [L]
00581 
00582                 // main work arrays
00583         double (*Eosparm)[4];   
00584         double (*Pureparm)[4];  
00585         double (*Fugpure)[6];   
00586         double (*Fugci)[4];     
00587 
00588         double **a;             
00589                 double **b;
00590         double **KK;    
00591         double **dKK;   
00592         double **d2KK;  
00593         double **AA;    
00594 
00595                 // internal functions
00596                 void alloc_internal();
00597                 void free_internal();
00598                 long int AB( double Tcrit, double Pcrit, double omg, double N,
00599                                 double &apure, double &bpure, double &da, double &d2a );
00600                 long int FugacityPT( long int i, double *EoSparam );
00601                 long int FugacityPure( long int j ); // Calculates the fugacity of pure species
00602                 long int Cardano( double a2, double a1, double a0, double &z1, double &z2, double &z3 );
00603                 long int MixParam( double &amix, double &bmix );
00604                 long int FugacityMix( double amix, double bmix, double &fugmix, double &zmix, double &vmix );
00605                 long int FugacitySpec( double *fugpure );
00606                 long int ResidualFunct( double *fugpure );
00607                 long int MixingWaals();
00608                 long int MixingConst();
00609                 long int MixingTemp();
00610 
00611         public:
00612 
00614                 TSRKcalc( long int NCmp, double Pp, double Tkp );
00615                 TSRKcalc( SolutionData *sd );
00616 
00618                 ~TSRKcalc();
00619 
00621                 long int PureSpecies();
00622 
00624                 long int PTparam();
00625 
00627                 long int MixMod();
00628 
00630                 long int ExcessProp( double *Zex );
00631 
00633                 long int IdealProp( double *Zid );
00634 
00636                 long int SRKCalcFugPure( double Tmin, float *Cpg, double *FugProps );
00637 
00638 };
00639 
00640 
00641 
00642 // -------------------------------------------------------------------------------------
00646 class TPR78calc: public TSolMod
00647 
00648 {
00649         private:
00650 
00651         double PhVol;   
00652                 double *Pparc;  
00653                     // double *aGEX;   // Increments to molar G0 values of DCs from pure fugacities
00654                     // double *aVol;   // DC molar volumes, cm3/mol [L]
00655 
00656                 // main work arrays
00657         double (*Eosparm)[4];   
00658         double (*Pureparm)[4];  
00659         double (*Fugpure)[6];   
00660         double (*Fugci)[4];     
00661 
00662         double **a;             
00663                 double **b;
00664         double **KK;    
00665         double **dKK;   
00666         double **d2KK;  
00667         double **AA;    
00668 
00669                 // internal functions
00670                 void alloc_internal();
00671                 void free_internal();
00672                 long int AB( double Tcrit, double Pcrit, double omg, double N,
00673                                 double &apure, double &bpure, double &da, double &d2a );
00674                 long int FugacityPT( long int i, double *EoSparam );
00675                 long int FugacityPure( long int j ); // Calculates the fugacity of pure species
00676                 long int Cardano( double a2, double a1, double a0, double &z1, double &z2, double &z3 );
00677                 long int MixParam( double &amix, double &bmix );
00678                 long int FugacityMix( double amix, double bmix, double &fugmix, double &zmix, double &vmix );
00679                 long int FugacitySpec( double *fugpure );
00680                 long int ResidualFunct( double *fugpure );
00681                 long int MixingWaals();
00682                 long int MixingConst();
00683                 long int MixingTemp();
00684 
00685         public:
00686 
00688                 TPR78calc( long int NCmp, double Pp, double Tkp );
00689                 TPR78calc( SolutionData *sd );
00690 
00692                 ~TPR78calc();
00693 
00695                 long int PureSpecies();
00696 
00698                 long int PTparam();
00699 
00701                 long int MixMod();
00702 
00704                 long int ExcessProp( double *Zex );
00705 
00707                 long int IdealProp( double *Zid );
00708 
00710                 long int PR78CalcFugPure( double Tmin, float *Cpg, double *FugProps );
00711 
00712 };
00713 
00714 
00715 
00716 // -------------------------------------------------------------------------------------
00720 class TCORKcalc: public TSolMod
00721 
00722 {
00723         private:
00724 
00725                 // constants and external parameters
00726                 double RR;    
00727                 double Pkb;   
00728                 double PhVol;   
00729                 double *Pparc;  
00730                     // double *aGEX;   // Increments to molar G0 values of DCs from pure fugacities
00731                     // double *aVol;   // DC molar volumes, cm3/mol [L]
00732 
00733                 // internal work data
00734                 double (*Eosparm)[2];   
00735                 double (*Fugpure)[6];   
00736                 double (*Fugci)[4];     
00737                 double (*Rho)[11];      
00738                 char *EosCode;    
00739                 double *phi;
00740                 double *dphi;
00741                 double *d2phi;
00742                 double *dphip;
00743                 double **A;         
00744                 double **W;         
00745                 double **B;
00746                 double **dB;
00747                 double **d2B;
00748                 double **dBp;
00749 
00750                 // internal functions
00751                 void alloc_internal();
00752                 void free_internal();
00753                 long int FugacityPT( long int j, double *EoSparam );
00754                 long int FugacityH2O( long int j );
00755                 long int FugacityCO2( long int j );
00756                 long int FugacityCorresponding( long int j );
00757                 long int VolumeFugacity( long int phState, double pp, double p0, double a, double b, double c,
00758                         double d, double e, double &vol, double &fc );
00759                 long int Cardano( double cb, double cc, double cd, double &v1, double &v2, double &v3 );
00760                 long int FugacityMix();
00761                 long int ResidualFunct();
00762 
00763         public:
00764 
00766                 TCORKcalc( long int NCmp, double Pp, double Tkp, char Eos_Code );
00767                 TCORKcalc( SolutionData *sd );
00768 
00770                 ~TCORKcalc();
00771 
00773                 long int PureSpecies();
00774 
00776                 long int PTparam();
00777 
00779                 long int MixMod();
00780 
00782                 long int ExcessProp( double *Zex );
00783 
00785                 long int IdealProp( double *Zid );
00786 
00788                 long int CORKCalcFugPure( double Tmin, float *Cpg, double *FugProps );
00789 
00790 };
00791 
00792 
00793 
00794 // -------------------------------------------------------------------------------------
00798 class TSTPcalc: public TSolMod
00799 
00800 {
00801         private:
00802 
00803                 // constants and external parameters
00804                 double RC, RR, TMIN, TMAX, PMIN, PMAX;
00805                 double Pkbar, Pkb, Pmpa;
00806                 double PhVol;   
00807                 double *Pparc;  
00808 
00809                 // internal work data
00810                 char *EosCode;
00811                 double *Tc;
00812                 double *Pc;
00813                 double *Psat;
00814                 double *Rhol;
00815                 double *Rhov;
00816                 double *Mw;
00817                 double *Phi;
00818                 double *dPhiD;
00819                 double *dPhiDD;
00820                 double *dPhiT;
00821                 double *dPhiTT;
00822                 double *dPhiDT;
00823                 double *dPhiDDD;
00824                 double *dPhiDDT;
00825                 double *dPhiDTT;
00826                 double (*Fugpure)[7];
00827                 double (*Rho)[11];
00828                 double *phi;
00829                 double *dphi;
00830                 double *d2phi;
00831                 double *dphip;
00832                 double *lng;
00833                 double **cfh;
00834                 double **cfc;
00835                 double **A;
00836                 double **W;
00837                 double **B;
00838                 double **dB;
00839                 double **d2B;
00840                 double **dBp;
00841 
00842                 // internal functions
00843                 void alloc_internal();
00844                 void free_internal();
00845                 void set_internal();
00846                 long int UpdateTauP();
00847                 long int FugacityPT( long int j, double *EoSparam );
00848                 long int FugacityH2O( long int j );
00849                 long int FugacityCO2( long int j );
00850                 long int FugacityCorresponding( long int j );
00851                 long int DensityGuess( long int j, double &Delguess );
00852                 long int PsatH2O( long int j );
00853                 long int PsatCO2( long int j );
00854                 long int Pressure( double rho, double &p, double &dpdrho, double **cf );
00855                 long int Helmholtz( long int j, double rho, double **cf );
00856                 long int ResidualFunct();
00857 
00858         public:
00859 
00861                 TSTPcalc ( long int NCmp, double Pp, double Tkp, char Eos_Code );
00862                 TSTPcalc ( SolutionData *sd );
00863 
00865                 ~TSTPcalc();
00866 
00868                 long int PureSpecies();
00869 
00871                 long int PTparam();
00872 
00874                 long int MixMod();
00875 
00877                 long int ExcessProp( double *Zex );
00878 
00880                 long int IdealProp( double *Zid );
00881 
00883                 long int STPCalcFugPure( double Tmin, float *Cpg, double *FugProps );
00884 
00885 };
00886 
00887 
00888 
00889 // -------------------------------------------------------------------------------------
00893 
00894 class TVanLaar: public TSolMod
00895 {
00896         private:
00897                 double *Wu;
00898                 double *Ws;
00899                 double *Wv;
00900         double *Wpt;   
00901         double *Phi;   
00902         double *PsVol; 
00903 
00904                 void alloc_internal();
00905                 void free_internal();
00906 
00907         public:
00908 
00910                 TVanLaar( SolutionData *sd );
00911 
00913                 ~TVanLaar();
00914 
00916                 long int PTparam();
00917 
00919                 long int MixMod();
00920 
00922                 long int ExcessProp( double *Zex );
00923 
00925                 long int IdealProp( double *Zid );
00926 
00927 };
00928 
00929 
00930 
00931 // -------------------------------------------------------------------------------------
00935 class TRegular: public TSolMod
00936 {
00937         private:
00938                 double *Wu;
00939                 double *Ws;
00940                 double *Wv;
00941         double *Wpt;   
00942 
00943                 void alloc_internal();
00944                 void free_internal();
00945 
00946         public:
00947 
00949                 TRegular( SolutionData *sd );
00950 
00952                 ~TRegular();
00953 
00955         long int PTparam( );
00956 
00958                 long int MixMod();
00959 
00961                 long int ExcessProp( double *Zex );
00962 
00964                 long int IdealProp( double *Zid );
00965 
00966 };
00967 
00968 
00969 
00970 // -------------------------------------------------------------------------------------
00974 class TRedlichKister: public TSolMod
00975 {
00976         private:
00977                 double (*Lu)[4];
00978                 double (*Ls)[4];
00979                 double (*Lcp)[4];
00980                 double (*Lv)[4];
00981                 double (*Lpt)[4];
00982 
00983                 void alloc_internal();
00984                 void free_internal();
00985 
00986         public:
00987 
00989                 TRedlichKister( SolutionData *sd );
00990 
00992                 ~TRedlichKister();
00993 
00995                 long int PTparam();
00996 
00998                 long int MixMod();
00999 
01001                 long int ExcessProp( double *Zex );
01002 
01004                 long int IdealProp( double *Zid );
01005 
01006 };
01007 
01008 
01009 
01010 // -------------------------------------------------------------------------------------
01014 class TNRTL: public TSolMod
01015 {
01016         private:
01017                 double **Tau;
01018                 double **dTau;
01019                 double **d2Tau;
01020                 double **Alp;
01021                 double **dAlp;
01022                 double **d2Alp;
01023                 double **G;
01024                 double **dG;
01025                 double **d2G;
01026 
01027                 void alloc_internal();
01028                 void free_internal();
01029 
01030         public:
01031 
01033                 TNRTL( SolutionData *sd );
01034 
01036                 ~TNRTL();
01037 
01039                 long int PTparam();
01040 
01042                 long int MixMod();
01043 
01045                 long int ExcessProp( double *Zex );
01046 
01048                 long int IdealProp( double *Zid );
01049 
01050 };
01051 
01052 
01053 
01054 // -------------------------------------------------------------------------------------
01058 class TWilson: public TSolMod
01059 {
01060         private:
01061                 double **Lam;
01062                 double **dLam;
01063                 double **d2Lam;
01064 
01065                 void alloc_internal();
01066                 void free_internal();
01067 
01068         public:
01069 
01071                 TWilson( SolutionData *sd );
01072 
01074                 ~TWilson();
01075 
01077                 long int PTparam();
01078 
01080                 long int MixMod();
01081 
01083                 long int ExcessProp( double *Zex );
01084 
01086                 long int IdealProp( double *Zid );
01087 
01088 };
01089 
01090 
01091 
01092 // -------------------------------------------------------------------------------------
01097 class TBerman: public TSolMod
01098 {
01099         private:
01100 
01101                 double *Wu;
01102                 double *Ws;
01103                 double *Wv;
01104                 double *Wpt;   
01105             double **fjs;      
01106 
01107                 double *Grec;  
01108                 double *oGf;   
01109                 double *G0f;   
01110 
01111                 void alloc_internal();
01112                 void free_internal();
01113             long int ExcessPart();     
01114 
01115                 long int ReciprocalPart();   
01116 
01117         public:
01118 
01120                 TBerman( SolutionData *sd, double *G0 );
01121 
01123                 ~TBerman();
01124 
01126                 long int PTparam();
01127 
01129                 long int MixMod();
01130 
01132                 long int ExcessProp( double *Zex );
01133 
01135                 long int IdealProp( double *Zid );
01136 
01137 };
01138 
01139 
01140 // -------------------------------------------------------------------------------------
01143 class TSIT: public TSolMod
01144 {
01145         private:
01146 
01147         // data objects copied from MULTI
01148         double *z;    
01149         double *m;    
01150         double *RhoW;  
01151         double *EpsW;  
01152 
01153         // internal work objects
01154         double I;       
01155         double A, dAdT, d2AdT2, dAdP;  
01156         double *LnG;  
01157         double *dLnGdT;  
01158                 double *d2LnGdT2;
01159                 double *dLnGdP;
01160         double **E0;  
01161                 double **E1;
01162                 double **dE0;
01163                 double **dE1;
01164                 double **d2E0;
01165                 double **d2E1;
01166 
01167         // internal functions
01168                 double IonicStrength();
01169                 void alloc_internal();
01170                 void free_internal();
01171 
01172         public:
01173 
01175                 TSIT( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01176 
01178                 ~TSIT();
01179 
01181                 long int MixMod();
01182 
01184                 long int ExcessProp( double *Zex );
01185 
01187                 long int IdealProp( double *Zid );
01188 
01190                 long int PTparam();
01191 
01192 };
01193 
01194 
01195 
01196 // -------------------------------------------------------------------------------------
01200 class TPitzer: public TSolMod
01201 {
01202 
01203 private:
01204     long int Nc;         
01205     long int Na;     
01206     long int Nn;     
01207     long int Ns;     
01208 
01209     long int *xcx;   
01210     long int *xax;   
01211     long int *xnx;   
01212     double *aZ;    
01213         double *zc;
01214         double *za;
01215     double *aM;    
01216         double *mc;
01217         double *ma;
01218         double *mn;
01219     double *RhoW;  
01220     double *EpsW;  
01221 
01222         double Aphi, dAphidT, d2AphidT2, dAphidP;  
01223     double I;  
01224     double Is;  
01225     double Ffac; 
01226     double Zfac; 
01227 
01228     // Input parameter arrays
01229             //for Gex and activity coefficient calculation
01230     double **Bet0;     
01231     double **Bet1;         
01232     double **Bet2;         
01233     double **Cphi;     
01234     double **Lam;      
01235     double **Lam1;     
01236     double **Theta;    
01237     double **Theta1;   
01238     double ***Psi;     
01239     double ***Psi1;    
01240     double ***Zeta;    
01241 
01242 
01243             // Work parameter arrays
01244             // double *B1;      /// B' table for cation-anion interactions corrected for IS [Nc][Na]
01245             // double *B2;      /// B table for cation-anion interactions corrected for IS [Nc][Na]
01246             // double *B3;      /// B_phi table for cation-anion interactions corrected for IS [Nc][Na]
01247             // double *Phi1;    /// Phi' table for anion-anion interactions corrected for IS [Na][Na]
01248             // double *Phi2;    /// Phi table for cation-cation interactions corrected for IS [Nc][Nc]
01249             // double *Phi3;    /// PhiPhi table for anion-anion interactions corrected for IS [Na][Na]
01250             // double *C;       /// C table for cation-anion interactions corrected for charge [Nc][Na]
01251             // double *Etheta;  /// Etheta table for cation-cation interactions [Nc][Nc]
01252             // double *Ethetap; /// Etheta' table for anion-anion interactions [Na][Na]
01253             // double bk[21];   /// work space
01254             // double dk[21];   /// work space
01255 
01257         double *McI_PT_array;
01258         double *GammaMcI;
01259 
01260         enum eTableType
01261         {
01262                 bet0_ = -10, bet1_ = -11, bet2_ = -12, Cphi_ = -20, Lam_ = -30, Lam1_ = -31,
01263                 Theta_ = -40,  Theta1_ = -41, Psi_ = -50, Psi1_ = -51, Zeta_ = -60
01264         };
01265 
01266     // internal setup
01267         void calcSizes();
01268         void alloc_internal();
01269         void free_internal();
01270 
01272         void setIndexes();
01273         double setvalue(long int ii, int Gex_or_Sex);
01274 
01275     // internal calculations
01277         void Ecalc( double z, double z1, double I, double DH_term,
01278                                         double& Etheta, double& Ethetap );
01279         inline long int getN() const
01280         {
01281                 return Nc+Na+Nn;
01282         }
01283 
01284         double Z_Term( );
01285         double IonicStr( double& I );
01286         void getAlp( long int c, long int a, double& alp, double& alp1 );
01287         double get_g( double x_alp );
01288         double get_gp( double x_alp );
01289         double G_ex_par5( long int ii );
01290         double G_ex_par8( long int ii );
01291         double S_ex_par5( long int ii );
01292         double S_ex_par8( long int ii );
01293         double CP_ex_par5( long int ii );
01294         double CP_ex_par8( long int ii );
01295         double F_Factor( double DH_term );
01296         double lnGammaN( long int N );
01297         double lnGammaM( long int M, double DH_term );
01298         double lnGammaX( long int X, double DH_term );
01299         double lnGammaH2O( double DH_term );
01300 
01302         void PTcalc( int Gex_or_Sex );
01303 
01305         double McInnes_KCl();
01306 
01307         inline long int getIc( long int jj )
01308     {
01309                 for( long int ic=0; ic<Nc; ic++ )
01310                         if( xcx[ic] == jj )
01311                                 return ic;
01312                 return -1;
01313     }
01314 
01315         inline long int getIa( long int jj )
01316     {
01317                 for( long int ia=0; ia<Na; ia++ )
01318                         if( xax[ia] == jj )
01319                                 return ia;
01320                 return -1;
01321     }
01322 
01323         inline long int getIn( long int jj )
01324     {
01325                 for( long int in=0; in<Nn; in++ )
01326                         if( xnx[in] == jj )
01327                                 return in;
01328                 return -1;
01329     }
01330 
01331     inline double p_sum( double* arr, long int *xx, long int Narr )
01332     {
01333                 double sum_ =0.;
01334                 for( long int i=0; i<Narr; i++ )
01335           sum_ += arr[xx[i]];
01336                 return sum_;
01337     }
01338 
01339 public:
01340 
01342         TPitzer( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01343 
01345         ~TPitzer();
01346 
01348         long int PTparam();
01349 
01350 
01351     long int MixMod();
01352 
01354         long int Pitzer_calc_Gamma();
01355         long int Pitzer_McInnes_KCl();
01356 
01358     long int ExcessProp( double *Zex );
01359 
01361         long int IdealProp( double *Zid );
01362 
01363         void Pitzer_test_out( const char *path, double Y );
01364 
01365 };
01366 
01367 
01368 
01369 // -------------------------------------------------------------------------------------
01373 class TEUNIQUAC: public TSolMod
01374 {
01375         private:
01376 
01377         // data objects copied from MULTI
01378         double *z;   
01379         double *m;   
01380         double *RhoW;  
01381         double *EpsW;  
01382 
01383         // internal work objects
01384         double *R;   
01385         double *Q;   
01386                 double *Phi;
01387                 double *Theta;
01388         double **U;   
01389         double **dU;   
01390         double **d2U;   
01391                 double **Psi;
01392                 double **dPsi;
01393                 double **d2Psi;
01394         double IS;  
01395         double A, dAdT, d2AdT2, dAdP;  
01396 
01398                 double gammaDH[200];
01399                 double gammaC[200];
01400                 double gammaR[200];
01401 
01402         // internal functions
01403                 void alloc_internal();
01404                 void free_internal();
01405                 long int IonicStrength();
01406 
01407         public:
01408 
01410                 TEUNIQUAC( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01411 
01413                 ~TEUNIQUAC();
01414 
01416                 long int PTparam();
01417 
01419                 long int MixMod();
01420 
01422                 long int ExcessProp( double *Zex );
01423 
01425                 long int IdealProp( double *Zid );
01426 
01427                 void Euniquac_test_out( const char *path );
01428 
01429 };
01430 
01431 
01432 // -------------------------------------------------------------------------------------
01436 class THelgeson: public TSolMod
01437 {
01438         private:
01439 
01440         // status flags copied from MULTI
01441         long int flagH2O;  
01442         long int flagNeut;  
01443         long int flagElect;  
01444 
01445         // data objects copied from MULTI
01446         double *z;   
01447         double *m;   
01448         double *RhoW;  
01449         double *EpsW;  
01450         double *an;  
01451         double *bg;  
01452         double ac;  
01453         double bc;  
01454 
01455         // internal work objects
01456         double ao, daodT, d2aodT2, daodP;  
01457         double bgam, dbgdT, d2bgdT2, dbgdP;  
01458         double *LnG;  
01459         double *dLnGdT;  
01460                 double *d2LnGdT2;
01461                 double *dLnGdP;
01462         double IS;  
01463         double molT;  
01464         double molZ;  
01465         double A, dAdT, d2AdT2, dAdP;  
01466         double B, dBdT, d2BdT2, dBdP;  
01467         double Gf, dGfdT, d2GfdT2, dGfdP;  
01468 
01469         // internal functions
01470                 void alloc_internal();
01471                 void free_internal();
01472                 long int IonicStrength();
01473                 long int BgammaTP();
01474                 long int IonsizeTP();
01475                 long int Gfunction();
01476                 long int GShok2( double T, double P, double D, double beta,
01477                                 double alpha, double daldT, double &g, double &dgdP,
01478                                 double &dgdT, double &d2gdT2 );
01479 
01480         public:
01481 
01483                 THelgeson( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01484 
01486                 ~THelgeson();
01487 
01489                 long int PTparam();
01490 
01492                 long int MixMod();
01493 
01495                 long int ExcessProp( double *Zex );
01496 
01498                 long int IdealProp( double *Zid );
01499 
01500 };
01501 
01502 
01503 
01504 // -------------------------------------------------------------------------------------
01508 class TDavies: public TSolMod
01509 {
01510         private:
01511 
01512         // status flags copied from MULTI
01513         long int flagH2O;  
01514         long int flagNeut;  
01515         long int flagMol;  
01516 
01517         // data objects copied from MULTI
01518         double *z;   
01519         double *m;   
01520         double *RhoW;  
01521         double *EpsW;  
01522 
01523         // internal work objects
01524         double *LnG;  
01525         double *dLnGdT;  
01526                 double *d2LnGdT2;
01527                 double *dLnGdP;
01528         double IS;  
01529         double molT;  
01530         double A, dAdT, d2AdT2, dAdP;  
01531 
01532         // internal functions
01533                 void alloc_internal();
01534                 void free_internal();
01535                 long int IonicStrength();
01536 
01537         public:
01538 
01540                 TDavies( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01541 
01543                 ~TDavies();
01544 
01546                 long int PTparam();
01547 
01549                 long int MixMod();
01550 
01552                 long int ExcessProp( double *Zex );
01553 
01555                 long int IdealProp( double *Zid );
01556 
01557 };
01558 
01559 
01560 
01561 // -------------------------------------------------------------------------------------
01565 class TLimitingLaw: public TSolMod
01566 {
01567         private:
01568 
01569         // status flags copied from MULTI
01570         long int flagH2O;  
01571         long int flagNeut;  
01572 
01573         // data objects copied from MULTI
01574         double *z;   
01575         double *m;   
01576         double *RhoW;  
01577         double *EpsW;  
01578 
01579         // internal work objects
01580         double *LnG;  
01581         double *dLnGdT;  
01582                 double *d2LnGdT2;
01583                 double *dLnGdP;
01584         double IS;  
01585         double molT;  
01586         double A, dAdT, d2AdT2, dAdP;  
01587 
01588         // internal functions
01589                 void alloc_internal();
01590                 void free_internal();
01591                 long int IonicStrength();
01592 
01593         public:
01594 
01596                 TLimitingLaw( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01597 
01599                 ~TLimitingLaw();
01600 
01602                 long int PTparam();
01603 
01605                 long int MixMod();
01606 
01608                 long int ExcessProp( double *Zex );
01609 
01611                 long int IdealProp( double *Zid );
01612 
01613 };
01614 
01615 
01616 
01617 // -------------------------------------------------------------------------------------
01622 class TDebyeHueckel: public TSolMod
01623 {
01624         private:
01625 
01626         // status flags copied from MULTI
01627         long int flagH2O;  
01628         long int flagNeut;  
01629 
01630         // data objects copied from MULTI
01631         double *z;   
01632         double *m;   
01633         double *RhoW;  
01634         double *EpsW;  
01635         double *an;  
01636         double *bg;  
01637         double ac;  
01638         double bc;  
01639 
01640         // internal work objects
01641         double ao;  
01642         double *LnG;  
01643         double *dLnGdT;  
01644                 double *d2LnGdT2;
01645                 double *dLnGdP;
01646         double IS;  
01647         double molT;  
01648         double A, dAdT, d2AdT2, dAdP;  
01649         double B, dBdT, d2BdT2, dBdP;  
01650 
01651         // internal functions
01652                 void alloc_internal();
01653                 void free_internal();
01654                 long int IonicStrength();
01655 
01656         public:
01657 
01659                 TDebyeHueckel( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01660 
01662                 ~TDebyeHueckel();
01663 
01665                 long int PTparam();
01666 
01668                 long int MixMod();
01669 
01671                 long int ExcessProp( double *Zex );
01672 
01674                 long int IdealProp( double *Zid );
01675 
01676 };
01677 
01678 
01679 
01680 // -------------------------------------------------------------------------------------
01685 class TKarpov: public TSolMod
01686 {
01687         private:
01688 
01689         // status flags copied from MULTI
01690         long int flagH2O;  
01691         long int flagNeut;  
01692         long int flagElect;  
01693 
01694         // data objects copied from MULTI
01695         double *z;   
01696         double *m;   
01697         double *RhoW;  
01698         double *EpsW;  
01699         double *an;  
01700         double *bg;  
01701         double ac;  
01702         double bc;  
01703 
01704         // internal work objects
01705         double ao;  
01706         double bgam, dbgdT, d2bgdT2, dbgdP;  
01707         double *LnG;  
01708         double *dLnGdT;  
01709                 double *d2LnGdT2;
01710                 double *dLnGdP;
01711         double IS;  
01712         double molT;  
01713         double molZ;  
01714         double A, dAdT, d2AdT2, dAdP;  
01715         double B, dBdT, d2BdT2, dBdP;  
01716         double Gf, dGfdT, d2GfdT2, dGfdP;  
01717 
01718         // internal functions
01719                 void alloc_internal();
01720                 void free_internal();
01721                 long int IonicStrength();
01722                 long int BgammaTP();
01723                 long int IonsizeTP();
01724                 long int Gfunction();
01725                 long int GShok2( double T, double P, double D, double beta,
01726                                 double alpha, double daldT, double &g, double &dgdP,
01727                                 double &dgdT, double &d2gdT2 );
01728 
01729         public:
01730 
01732                 TKarpov( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01733 
01735                 ~TKarpov();
01736 
01738                 long int PTparam();
01739 
01741                 long int MixMod();
01742 
01744                 long int ExcessProp( double *Zex );
01745 
01747                 long int IdealProp( double *Zid );
01748 
01749 };
01750 
01751 
01752 
01753 // -------------------------------------------------------------------------------------
01758 class TShvarov: public TSolMod
01759 {
01760         private:
01761 
01762         // status flags copied from MULTI
01763         long int flagH2O;  
01764         long int flagNeut;  
01765         long int flagElect;  
01766 
01767         // data objects copied from MULTI
01768         double *z;   
01769         double *m;   
01770         double *RhoW;  
01771         double *EpsW;  
01772         double *bj;  
01773         double ac;  
01774         double bc;  
01775 
01776         // internal work objects
01777         double ao, daodT, d2aodT2, daodP;  
01778         double bgam, dbgdT, d2bgdT2, dbgdP;  
01779         double *LnG;  
01780         double *dLnGdT;  
01781                 double *d2LnGdT2;
01782                 double *dLnGdP;
01783         double IS;  
01784         double molT;  
01785         double A, dAdT, d2AdT2, dAdP;  
01786         double B, dBdT, d2BdT2, dBdP;  
01787         double Gf, dGfdT, d2GfdT2, dGfdP;  
01788 
01789         // internal functions
01790                 void alloc_internal();
01791                 void free_internal();
01792                 long int IonicStrength();
01793                 long int BgammaTP();
01794                 long int IonsizeTP();
01795                 long int Gfunction();
01796                 long int GShok2( double T, double P, double D, double beta,
01797                                 double alpha, double daldT, double &g, double &dgdP,
01798                                 double &dgdT, double &d2gdT2 );
01799 
01800         public:
01801 
01803                 TShvarov( SolutionData *sd, double *arM, double *arZ, double *dW, double *eW );
01804 
01806                 ~TShvarov();
01807 
01809                 long int PTparam();
01810 
01812                 long int MixMod();
01813 
01815                 long int ExcessProp( double *Zex );
01816 
01818                 long int IdealProp( double *Zid );
01819 
01820 };
01821 
01822 
01823 
01824 // -------------------------------------------------------------------------------------
01827 class TModOther: public TSolMod
01828 {
01829         private:
01830         double PhVol;   
01831                     // double *Pparc;  /// DC partial pressures/ pure fugacities, bar (Pc by default) [0:L-1]
01832                     // double *aGEX;   /// Increments to molar G0 values of DCs from pure fugacities or DQF terms, normalized [L]
01833                     // double *aVol;   /// DC molar volumes, cm3/mol [L]
01834         double *Gdqf;   
01835                 double *Hdqf;
01836                 double *Sdqf;
01837                 double *CPdqf;
01838                 double *Vdqf;
01839 
01840                 void alloc_internal();
01841                 void free_internal();
01842 
01843         public:
01844 
01846                 TModOther( SolutionData *sd, double *dW, double *eW );
01847 
01849                 ~TModOther();
01850 
01852                 long int PureSpecies();
01853 
01855                 long int PTparam();
01856 
01858                 long int MixMod();
01859 
01861                 long int ExcessProp( double *Zex );
01862 
01864                 long int IdealProp( double *Zid );
01865 
01866                 // functions for individual models (under construction)
01867                 long int Amphibole1();
01868                 long int Biotite1();
01869                 long int Chlorite1();
01870                 long int Clinopyroxene1();
01871                 long int Feldspar1();
01872                 long int Feldspar2();
01873                 long int Garnet1();
01874                 long int Muscovite1();
01875                 long int Orthopyroxene1();
01876                 long int Staurolite1();
01877                 long int Talc();
01878 
01879 };
01880 
01881 
01882 
01883 // -------------------------------------------------------------------------------------
01887 class TMargules: public TSolMod
01888 {
01889         private:
01890 
01891                 double WU12, WS12, WV12, WG12;
01892                 double WU13, WS13, WV13, WG13;
01893                 double WU23, WS23, WV23, WG23;
01894                 double WU123, WS123, WV123, WG123;
01895 
01896         public:
01897 
01899                 TMargules( SolutionData *sd );
01900 
01902                 ~TMargules();
01903 
01905                 long int PTparam( );
01906 
01908                 long int MixMod();
01909 
01911                 long int ExcessProp( double *Zex );
01912 
01914                 long int IdealProp( double *Zid );
01915 
01916 };
01917 
01918 
01919 
01920 // -------------------------------------------------------------------------------------
01924 class TSubregular: public TSolMod
01925 {
01926         private:
01927 
01928                 double WU12, WS12, WV12, WG12;
01929                 double WU21, WS21, WV21, WG21;
01930 
01931         public:
01932 
01934                 TSubregular( SolutionData *sd );
01935 
01937                 ~TSubregular();
01938 
01940                 long int PTparam( );
01941 
01943                 long int MixMod();
01944 
01946                 long int ExcessProp( double *Zex );
01947 
01949                 long int IdealProp( double *Zid );
01950 
01951 };
01952 
01953 
01954 
01955 // -------------------------------------------------------------------------------------
01960 class TGuggenheim: public TSolMod
01961 {
01962         private:
01963 
01964                 double a0, a1, a2;
01965 
01966         public:
01967 
01969                 TGuggenheim( SolutionData *sd );
01970 
01972                 ~TGuggenheim();
01973 
01975                 long int PTparam( );
01976 
01978                 long int MixMod();
01979 
01981                 long int ExcessProp( double *Zex );
01982 
01984                 long int IdealProp( double *Zid );
01985 
01986 };
01987 
01988 
01989 
01990 #endif
01991