diff --git a/Cantera/src/transport/LiquidTransportParams.cpp b/Cantera/src/transport/LiquidTransportParams.cpp index 43a8b510b..b811eefa4 100644 --- a/Cantera/src/transport/LiquidTransportParams.cpp +++ b/Cantera/src/transport/LiquidTransportParams.cpp @@ -26,22 +26,42 @@ namespace Cantera { + msg + "\n") {} }; + /** + * Exception thrown if an error is encountered while reading the + * transport database. + */ + class LTPmodelError : public CanteraError { + public: + LTPmodelError( std::string msg ) + : CanteraError("LTPspecies", + "error parsing transport data: " + + msg + "\n") {} + }; - - LiquidTranInteraction::LiquidTranInteraction( - const XML_Node &compModelNode, - TransportPropertyList tp_ind, - thermo_t* thermo ) : + //!Constructor + /** + * @param tp_ind Index indicating transport property type (i.e. viscosity) + */ + LiquidTranInteraction::LiquidTranInteraction( TransportPropertyList tp_ind ) : m_model(LTI_MODEL_NOTSET), - m_property(tp_ind), - m_thermo(thermo) + m_property(tp_ind) { + } + + + + + void LiquidTranInteraction::init( const XML_Node &compModelNode, + thermo_t* thermo ) + { + m_thermo = thermo; + int nsp = thermo->nSpecies(); - Aij.resize(nsp,nsp); - Dij.resize(nsp,nsp); - Eij.resize(nsp,nsp); - Sij.resize(nsp,nsp); + m_Aij.resize(nsp,nsp); + m_Dij.resize(nsp,nsp); + m_Eij.resize(nsp,nsp); + m_Sij.resize(nsp,nsp); std::string speciesA; std::string speciesB; @@ -63,19 +83,27 @@ namespace Cantera { if ( jSpecies < 0 ) throw CanteraError("TransportFactory::getLiquidInteractionsTransportData", "Unknown species " + speciesB ); - Aij(iSpecies,jSpecies) = getFloat( xmlChild, "Aij", "toSI" ); - Aij(jSpecies,iSpecies) = Aij(iSpecies,jSpecies) ; + if ( xmlChild.hasChild( "Aij" ) ) { + m_Aij(iSpecies,jSpecies) = getFloat( xmlChild, "Aij", "toSI" ); + m_Aij(jSpecies,iSpecies) = m_Aij(iSpecies,jSpecies) ; + } - Eij(iSpecies,jSpecies) = getFloat( xmlChild, "Eij", "actEnergy" ); - Eij(iSpecies,jSpecies) /= GasConstant; - Eij(jSpecies,iSpecies) = Eij(iSpecies,jSpecies) ; + if ( xmlChild.hasChild( "Eij" ) ) { + m_Eij(iSpecies,jSpecies) = getFloat( xmlChild, "Eij", "actEnergy" ); + m_Eij(iSpecies,jSpecies) /= GasConstant; + m_Eij(jSpecies,iSpecies) = m_Eij(iSpecies,jSpecies) ; + } - Sij(iSpecies,jSpecies) = getFloat( xmlChild, "Sij", "toSI" ); - Sij(iSpecies,jSpecies) /= GasConstant; - Sij(jSpecies,iSpecies) = Sij(iSpecies,jSpecies) ; + if ( xmlChild.hasChild( "Sij" ) ) { + m_Sij(iSpecies,jSpecies) = getFloat( xmlChild, "Sij", "toSI" ); + m_Sij(iSpecies,jSpecies) /= GasConstant; + m_Sij(jSpecies,iSpecies) = m_Sij(iSpecies,jSpecies) ; + } - Dij(iSpecies,jSpecies) = getFloat( xmlChild, "Dij", "toSI" ); - Dij(jSpecies,iSpecies) = Dij(iSpecies,jSpecies) ; + if ( xmlChild.hasChild( "Dij" ) ) { + m_Dij(iSpecies,jSpecies) = getFloat( xmlChild, "Dij", "toSI" ); + m_Dij(jSpecies,iSpecies) = m_Dij(iSpecies,jSpecies) ; + } } } @@ -88,9 +116,14 @@ namespace Cantera { LiquidTranInteraction& LiquidTranInteraction::operator=( const LiquidTranInteraction &right ) { if (&right != this) { - m_model = right.m_model; - m_property = right.m_property; + m_model = right.m_model; + m_property = right.m_property; m_thermo = right.m_thermo; + //m_trParam = right.m_trParam; + m_Aij = right.m_Aij; + m_Eij = right.m_Eij; + m_Sij = right.m_Sij; + m_Dij = right.m_Dij; } return *this; } @@ -98,15 +131,347 @@ namespace Cantera { - LTI_MoleFracs::LTI_MoleFracs( const XML_Node &compModelNode, - TransportPropertyList tp_ind, - thermo_t* thermo ) : - LiquidTranInteraction( compModelNode, tp_ind, thermo ) - { - m_model = LTI_MODEL_MOLEFRACS; + doublereal LTI_Solvent::getMixTransProp( doublereal *speciesValues, doublereal *speciesWeight ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + //if weightings are specified, use those + if ( speciesWeight ) { + for ( int k = 0; k < nsp; k++) { + //presume that the weighting is set to 1.0 for solvent and 0.0 for everything else. + value += speciesValues[k] * speciesWeight[k]; + } + } + else { + //This does not follow directly a solvent model + //although if the solvent mole fraction is dominant + //and the other species values are given or zero, + //it should work. + for ( int k = 0; k < nsp; k++) { + value += speciesValues[k] * molefracs[k]; + } + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += molefracs[i] * molefracs[j] * m_Aij(i,j) ; + + return value; + } + + + doublereal LTI_Solvent::getMixTransProp( std::vector LTPptrs ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + for ( int k = 0; k < nsp; k++) { + //presume that the weighting is set to 1.0 for solvent and 0.0 for everything else. + value += LTPptrs[k]->getSpeciesTransProp() * LTPptrs[k]->getMixWeight( ) ; + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += molefracs[i] * molefracs[j] * m_Aij(i,j) ; + + return value; + } + + + + + + doublereal LTI_MoleFracs::getMixTransProp( doublereal *speciesValues, doublereal *speciesWeight ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + //if weightings are specified, use those + if ( speciesWeight ) { + for ( int k = 0; k < nsp; k++) { + value += speciesValues[k] * speciesWeight[k] * molefracs[k]; + } + } + else { + for ( int k = 0; k < nsp; k++) { + value += speciesValues[k] * molefracs[k]; + } + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += molefracs[i] * molefracs[j] * m_Aij(i,j) ; + + return value; + } + + + doublereal LTI_MoleFracs::getMixTransProp( std::vector LTPptrs ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + for ( int k = 0; k < nsp; k++) { + value += LTPptrs[k]->getSpeciesTransProp() * LTPptrs[k]->getMixWeight( ) * molefracs[k]; + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += molefracs[i] * molefracs[j] * m_Aij(i,j) ; + + return value; + } + + + + + + doublereal LTI_MassFracs::getMixTransProp( doublereal *speciesValues, doublereal *speciesWeight ) { + + int nsp = m_thermo->nSpecies(); + doublereal massfracs[nsp]; + m_thermo->getMassFractions(massfracs); + + doublereal value = 0; + + //if weightings are specified, use those + if ( speciesWeight ) { + for ( int k = 0; k < nsp; k++) { + value += speciesValues[k] * speciesWeight[k] * massfracs[k]; + } + } + else { + for ( int k = 0; k < nsp; k++) { + value += speciesValues[k] * massfracs[k]; + } + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += massfracs[i] * massfracs[j] * m_Aij(i,j) ; + + return value; + } + + + doublereal LTI_MassFracs::getMixTransProp( std::vector LTPptrs ) { + + int nsp = m_thermo->nSpecies(); + doublereal massfracs[nsp]; + m_thermo->getMassFractions(massfracs); + + doublereal value = 0; + + for ( int k = 0; k < nsp; k++) { + value += LTPptrs[k]->getSpeciesTransProp() * LTPptrs[k]->getMixWeight( ) * massfracs[k]; + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += massfracs[i] * massfracs[j] * m_Aij(i,j) ; + + return value; + } + + + + + + doublereal LTI_Log_MoleFracs::getMixTransProp( doublereal *speciesValues, doublereal *speciesWeight ) { + + int nsp = m_thermo->nSpecies(); + doublereal temp = m_thermo->temperature(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + //if weightings are specified, use those + if ( speciesWeight ) { + for ( int k = 0; k < nsp; k++) { + value += log( speciesValues[k] ) * speciesWeight[k] * molefracs[k]; + } + } + else { + for ( int k = 0; k < nsp; k++) { + value += log( speciesValues[k] ) * molefracs[k]; + } + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += molefracs[i] * molefracs[j] + * ( m_Sij(i,j) + m_Eij(i,j) / temp ); + + value = exp( value ); + return value; + } + + + doublereal LTI_Log_MoleFracs::getMixTransProp( std::vector LTPptrs ) { + + int nsp = m_thermo->nSpecies(); + doublereal temp = m_thermo->temperature(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + for ( int k = 0; k < nsp; k++) { + value += log( LTPptrs[k]->getSpeciesTransProp() ) * LTPptrs[k]->getMixWeight( ) * molefracs[k]; + } + + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + value += molefracs[i] * molefracs[j] + * ( m_Sij(i,j) + m_Eij(i,j) / temp ); + + value = exp( value ); + + return value; + } + + + + + + void LTI_Pairwise_Interaction::setParameters( LiquidTransportParams& trParam ) { + int nsp = m_thermo->nSpecies(); + + for (int k = 0; k < nsp; k++) { + Cantera::LiquidTransportData <d = trParam.LTData[k]; + m_diagonals[k] = ltd.speciesDiffusivity; + } + } + + doublereal LTI_Pairwise_Interaction::getMixTransProp( doublereal *speciesValues, doublereal *speciesWeight ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + throw LTPmodelError( "Calling LTI_Pairwise_Interaction::getMixTransProp does not make sense." ); + + return value; + } + + + doublereal LTI_Pairwise_Interaction::getMixTransProp( std::vector LTPptrs ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + throw LTPmodelError( "Calling LTI_Pairwise_Interaction::getMixTransProp does not make sense." ); + + return value; + } + + DenseMatrix LTI_Pairwise_Interaction::getMatrixTransProp( doublereal *speciesValues ) { + + int nsp = m_thermo->nSpecies(); + doublereal temp = m_thermo->temperature(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + DenseMatrix tmp; + tmp.resize(nsp,nsp); + for ( int i = 0; i < nsp; i++ ) + for ( int j = 0; j < i; j++ ) + tmp(i,j) = tmp(j,i) = m_Dij(i,j) * exp( - m_Eij(i,j) / temp ); + + for ( int i = 0; i < nsp; i++ ) + if ( tmp(i,i) == 0.0 && !(m_diagonals[i]) ) + tmp(i,i) = m_diagonals[i]->getSpeciesTransProp() ; + + return tmp; } - + doublereal LTI_StokesEinstein::getMixTransProp( doublereal *speciesValues, doublereal *speciesWeight ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + throw LTPmodelError( "Calling LTI_StokesEinstein::getMixTransProp does not make sense." ); + + return value; + } + + + doublereal LTI_StokesEinstein::getMixTransProp( std::vector LTPptrs ) { + + int nsp = m_thermo->nSpecies(); + doublereal molefracs[nsp]; + m_thermo->getMoleFractions(molefracs); + + doublereal value = 0; + + throw LTPmodelError( "Calling LTI_StokesEinstein::getMixTransProp does not make sense." ); + + return value; + } + + + + void LTI_StokesEinstein::setParameters( LiquidTransportParams& trParam ) { + int nsp = m_thermo->nSpecies(); + m_viscosity.resize(nsp); + m_hydroRadius.resize(nsp); + for (int k = 0; k < nsp; k++) { + Cantera::LiquidTransportData <d = trParam.LTData[k]; + m_viscosity[k] = ltd.viscosity; + m_hydroRadius[k] = ltd.hydroRadius; + } + } + + DenseMatrix LTI_StokesEinstein::getMatrixTransProp( doublereal *speciesValues ) { + + int nsp = m_thermo->nSpecies(); + doublereal temp = m_thermo->temperature(); + + double *viscSpec = new double(nsp); + double *radiusSpec = new double(nsp); + + for (int k = 0; k < nsp; k++) { + viscSpec[k] = m_viscosity[k]->getSpeciesTransProp() ; + radiusSpec[k] = m_hydroRadius[k]->getSpeciesTransProp() ; + } + + DenseMatrix tmp; + tmp.resize(nsp,nsp); + for (int i = 0; i < nsp; i++) + for (int j = 0; j < nsp; j++) { + tmp(i,j) = GasConstant * temp + / ( 6.0 * Pi * radiusSpec[i] * viscSpec[j] ) ; + } + delete radiusSpec; + delete viscSpec; + + return tmp; + } + + + } //namespace Cantera diff --git a/Cantera/src/transport/LiquidTransportParams.h b/Cantera/src/transport/LiquidTransportParams.h index 3bb859a30..b4ab26a22 100644 --- a/Cantera/src/transport/LiquidTransportParams.h +++ b/Cantera/src/transport/LiquidTransportParams.h @@ -81,16 +81,19 @@ namespace Cantera { LTI_MODEL_MOLEFRACS, LTI_MODEL_MASSFRACS, LTI_MODEL_LOG_MOLEFRACS, - LTI_MODEL_PAIRWISE_INTERACTION + LTI_MODEL_PAIRWISE_INTERACTION, + LTI_MODEL_STOKES_EINSTEIN }; class LiquidTranInteraction { public: - LiquidTranInteraction( const XML_Node &compModelNode = 0, - TransportPropertyList tp_ind = TP_UNKNOWN, - thermo_t* thermo = 0 ); + //! Constructor + /** + * @param tp_ind Index indicating transport property type (i.e. viscosity) + */ + LiquidTranInteraction( TransportPropertyList tp_ind = TP_UNKNOWN ); //! Copy constructor LiquidTranInteraction( const LiquidTranInteraction &right ); @@ -99,12 +102,24 @@ namespace Cantera { LiquidTranInteraction& operator=( const LiquidTranInteraction &right ); //! destructor - virtual ~LiquidTranInteraction() { } + virtual ~LiquidTranInteraction() { ; } + //! initialize LiquidTranInteraction objects with thermo and XML node + /** + * @param compModelNode XML node + * @param thermo Pointer to thermo object + */ + virtual void init( const XML_Node &compModelNode = 0, + thermo_t* thermo = 0 ); + + virtual void setParameters( LiquidTransportParams& trParam ) { ; } + //! Return the mixture transport property value. //! (Must be implemented in subclasses.) - virtual doublereal getMixTransProp( ) { return 0.0; } - + virtual doublereal getMixTransProp( doublereal* speciesValues, doublereal *weightSpecies = 0 ) { return 0.0; } + virtual doublereal getMixTransProp( std::vector LTPptrs ) { return 0.0; } + virtual DenseMatrix getMatrixTransProp( doublereal* speciesValues = 0 ) { return m_Dij; } + protected: //! Model for species interaction effects //! Takes enum LiquidTranMixingModel @@ -116,17 +131,19 @@ namespace Cantera { //! pointer to thermo object to get current temperature thermo_t* m_thermo; + //LiquidTransportParams* m_trParam; + //! Matrix of interactions (no temperature dependence, dimensionless) - DenseMatrix Aij; + DenseMatrix m_Aij; //! Matrix of interactions (in energy units, 1/RT temperature dependence) - DenseMatrix Eij; + DenseMatrix m_Eij; //! Matrix of interactions (in entropy units, divided by R) - DenseMatrix Sij; + DenseMatrix m_Sij; //! Matrix of interactions - DenseMatrix Dij; + DenseMatrix m_Dij; }; @@ -145,12 +162,17 @@ namespace Cantera { //! Species transport parameters std::vector LTData; + + LiquidTranInteraction* viscosity; + LiquidTranInteraction* thermalCond; + LiquidTranInteraction* speciesDiffusivity; + LiquidTranInteraction* electCond; + LiquidTranInteraction* hydroRadius; //! Model for species interaction effects for viscosity //! Takes enum LiquidTranMixingModel LiquidTranMixingModel model_viscosity; - //! Energies of molecular interaction associated with viscosity. /** * These multiply the mixture viscosity by @@ -208,29 +230,221 @@ namespace Cantera { class LTI_Solvent; - - class LTI_MoleFracs : public LiquidTranInteraction { + class LTI_MoleFracs; + class LTI_MassFracs; + class LTI_Log_MoleFracs; + class LTI_Pairwise_Interaction; + + class LTI_Solvent : public LiquidTranInteraction { public: - LTI_MoleFracs( const XML_Node &compModelNode = 0, - TransportPropertyList tp_ind = TP_UNKNOWN, - thermo_t* thermo = 0 ) ; + LTI_Solvent( TransportPropertyList tp_ind = TP_UNKNOWN ) : + LiquidTranInteraction( tp_ind ) + { + m_model = LTI_MODEL_SOLVENT; + } //! Copy constructor - LTI_MoleFracs( const LTI_MoleFracs &right ); + // LTI_Solvent( const LTI_Solvent &right ); //! Assignment operator - LTI_MoleFracs& operator=( const LTI_MoleFracs &right ); + // LTI_Solvent& operator=( const LTI_Solvent &right ); - virtual ~LTI_MoleFracs( ) { } + virtual ~LTI_Solvent( ) { } //! Return the mixture transport property value. - doublereal getMixTransProp( ); + /** + * Takes the separate species transport properties + * as input (this method does not know what + * transport property it is at this point. + */ + doublereal getMixTransProp( doublereal *valueSpecies, doublereal *weightSpecies = 0 ); + doublereal getMixTransProp( std::vector LTPptrs ) ; + + DenseMatrix getMatrixTransProp( doublereal* speciesValues = 0 ) { return m_Aij; } + protected: }; + class LTI_MoleFracs : public LiquidTranInteraction { + + public: + LTI_MoleFracs( TransportPropertyList tp_ind = TP_UNKNOWN ) : + LiquidTranInteraction( tp_ind ) + { + m_model = LTI_MODEL_MOLEFRACS; + } + + + //! Copy constructor + // LTI_MoleFracs( const LTI_MoleFracs &right ); + + //! Assignment operator + // LTI_MoleFracs& operator=( const LTI_MoleFracs &right ); + + virtual ~LTI_MoleFracs( ) { } + + //! Return the mixture transport property value. + /** + * Takes the separate species transport properties + * as input (this method does not know what + * transport property it is at this point. + */ + doublereal getMixTransProp( doublereal *valueSpecies, doublereal *weightSpecies = 0 ); + doublereal getMixTransProp( std::vector LTPptrs ) ; + + DenseMatrix getMatrixTransProp( doublereal* speciesValues = 0 ) { return m_Aij; } + + protected: + + }; + + + class LTI_MassFracs : public LiquidTranInteraction { + + public: + LTI_MassFracs( TransportPropertyList tp_ind = TP_UNKNOWN ) : + LiquidTranInteraction( tp_ind ) + { + m_model = LTI_MODEL_MASSFRACS; + } + + + //! Copy constructor + // LTI_MassFracs( const LTI_MassFracs &right ); + + //! Assignment operator + // LTI_MassFracs& operator=( const LTI_MassFracs &right ); + + virtual ~LTI_MassFracs( ) { } + + //! Return the mixture transport property value. + /** + * Takes the separate species transport properties + * as input (this method does not know what + * transport property it is at this point. + */ + doublereal getMixTransProp( doublereal *valueSpecies, doublereal *weightSpecies = 0 ); + doublereal getMixTransProp( std::vector LTPptrs ) ; + + DenseMatrix getMatrixTransProp( doublereal* speciesValues = 0 ) { return m_Aij; } + + protected: + + }; + + + class LTI_Log_MoleFracs : public LiquidTranInteraction { + + public: + LTI_Log_MoleFracs( TransportPropertyList tp_ind = TP_UNKNOWN ) : + LiquidTranInteraction( tp_ind ) + { + m_model = LTI_MODEL_LOG_MOLEFRACS; + } + + + //! Copy constructor + // LTI_Log_MoleFracs( const LTI_Log_MoleFracs &right ); + + //! Assignment operator + // LTI_Log_MoleFracs& operator=( const LTI_Log_MoleFracs &right ); + + virtual ~LTI_Log_MoleFracs( ) { } + + //! Return the mixture transport property value. + /** + * Takes the separate species transport properties + * as input (this method does not know what + * transport property it is at this point. + */ + doublereal getMixTransProp( doublereal *valueSpecies, doublereal *weightSpecies = 0 ); + doublereal getMixTransProp( std::vector LTPptrs ) ; + + DenseMatrix getMatrixTransProp( doublereal* speciesValues = 0 ) { return m_Eij; } + + protected: + + }; + + + class LTI_Pairwise_Interaction : public LiquidTranInteraction { + + public: + LTI_Pairwise_Interaction( TransportPropertyList tp_ind = TP_UNKNOWN ) : + LiquidTranInteraction( tp_ind ) + { + m_model = LTI_MODEL_PAIRWISE_INTERACTION; + } + + + //! Copy constructor + // LTI_Pairwise_Interaction( const LTI_Pairwise_Interaction &right ); + + //! Assignment operator + // LTI_Pairwise_Interaction& operator=( const LTI_Pairwise_Interaction &right ); + + virtual ~LTI_Pairwise_Interaction( ) { } + + void setParameters( LiquidTransportParams& trParam ) ; + + //! Return the mixture transport property value. + /** + * Takes the separate species transport properties + * as input (this method does not know what + * transport property it is at this point. + */ + doublereal getMixTransProp( doublereal *valueSpecies, doublereal *weightSpecies = 0 ); + doublereal getMixTransProp( std::vector LTPptrs ) ; + + DenseMatrix getMatrixTransProp( doublereal* speciesValues = 0 ) ; + + protected: + + std::vector m_diagonals; + }; + + + class LTI_StokesEinstein : public LiquidTranInteraction { + + public: + LTI_StokesEinstein( TransportPropertyList tp_ind = TP_UNKNOWN ) : + LiquidTranInteraction( tp_ind ) + { + m_model = LTI_MODEL_STOKES_EINSTEIN; + } + + + //! Copy constructor + // LTI_StokesEinstein( const LTI_StokesEinstein &right ); + + //! Assignment operator + // LTI_StokesEinstein& operator=( const LTI_StokesEinstein &right ); + + virtual ~LTI_StokesEinstein( ) { } + + void setParameters( LiquidTransportParams& trParam ); + + //! Return the mixture transport property value. + /** + * Takes the separate species transport properties + * as input (this method does not know what + * transport property it is at this point. + */ + doublereal getMixTransProp( doublereal *valueSpecies, doublereal *weightSpecies = 0 ); + doublereal getMixTransProp( std::vector LTPptrs ) ; + + DenseMatrix getMatrixTransProp( doublereal* speciesValues = 0 ) ; + + protected: + + std::vector m_viscosity; + std::vector m_hydroRadius; + + }; + }