Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType > Class Template Reference

Compute transport properties using ``mixture averaged" model. More...

#include <mixture_averaged_transport_evaluator.h>

Public Types
enum	DiffusivityType { MOLE_FLUX_MOLE_FRACTION, MASS_FLUX_MASS_FRACTION, MASS_FLUX_MOLE_FRACTION }
	For the mixture averaged diffusion models, there are three typical ways of computing an average diffusivity, depending on the "units" of the flux and which variable with which the gradient is taken: molar flux with gradients of mole fraction (MOLE_FLUX_MOLE_FRACTION) mass flux with gradients of mass fraction (MASS_FLUX_MASS_FRACTION) mass flux with gradients of mole fraction (MASS_FLUX_MOLE_FRACTION) See, for example: Kee, Coltrin, Glarborg, ``Chemically Reacting Flow", Wiley, 2003, Chapter 12.7. More...

Public Member Functions
	MixtureAveragedTransportEvaluator (const MixtureAveragedTransportMixture< CoeffType > &mixture, const MixtureDiffusion< Diffusion, CoeffType > &diffusion, const MixtureViscosity< Viscosity, CoeffType > &viscosity, const MixtureConductivity< ThermalConductivity, CoeffType > &conductivity)
	~MixtureAveragedTransportEvaluator ()
template<typename StateType , typename VectorStateType >
void	D (const StateType &rho, const StateType &T, const VectorStateType &mass_fractions, VectorStateType &D_vec, DiffusivityType diff_type=DiffusivityType::MASS_FLUX_MOLE_FRACTION) const
	Mixture diffusivities for each species, in [m^2/s]. More...
template<typename StateType , typename VectorStateType >
value_type< VectorStateType >::type	mu (const StateType &T, const VectorStateType &mass_fractions) const
	Mixture viscosity, in [Pa-s]. More...
template<typename StateType , typename VectorStateType >
value_type< VectorStateType >::type	k (const StateType &T, const VectorStateType &mass_fractions) const
	Mixture conducivity, in [W/m-K]. More...
template<typename StateType , typename VectorStateType >
void	mu_and_k (const StateType &T, const VectorStateType &mass_fractions, StateType &mu, StateType &k) const
	Mixture viscosity and thermal conductivity, in [Pa-s], [W/m-K] respectively. More...
template<typename StateType , typename VectorStateType >
void	mu_and_k_and_D (const StateType &T, const StateType &rho, const StateType &cp, const VectorStateType &mass_fractions, StateType &mu, StateType &k, VectorStateType &D_vec, DiffusivityType diff_type=DiffusivityType::MASS_FLUX_MOLE_FRACTION) const
	Mixture viscosity, thermal conductivity, and diffusivities in [Pa-s], [W/m-K], [m^2/s] respectively. More...
template<typename StateType , typename VectorStateType >
void	compute_mu_chi (const StateType &T, const VectorStateType &mass_fractions, VectorStateType &mu, VectorStateType &chi) const
	Helper function to reduce code duplication. More...
template<typename VectorStateType >
value_type< VectorStateType >::type	compute_phi (typename rebind< VectorStateType, VectorStateType >::type &mu_mu_sqrt, const VectorStateType &chi, const unsigned int s) const
	Helper function to reduce code duplication. More...
template<typename VectorStateType >
void	compute_mu_mu_sqrt (const VectorStateType &mu, typename rebind< VectorStateType, VectorStateType >::type &mu_mu_sqrt) const
	Helper function to reduce code duplication. More...
template<typename StateType , typename VectorStateType >
value_type< VectorStateType >::type	mu (const StateType &T, const VectorStateType &mass_fractions) const
template<typename StateType , typename VectorStateType >
value_type< VectorStateType >::type	k (const StateType &T, const VectorStateType &mass_fractions) const
template<typename VectorStateType >
value_type< VectorStateType >::type	compute_phi (typename Antioch::rebind< VectorStateType, VectorStateType >::type &mu_mu_sqrt, const VectorStateType &chi, const unsigned int s) const

Protected Member Functions
template<typename VectorStateType , typename MatrixStateType >
void	diffusion_mixing_rule (const ChemicalMixture< CoeffType > &mixture, const VectorStateType &mass_fractions, const MatrixStateType &D_mat, DiffusivityType diff_type, VectorStateType &D_vec) const
	Compute species diffusion coefficients. More...

Protected Attributes
const MixtureAveragedTransportMixture < CoeffType > &	_mixture
const MixtureDiffusion < Diffusion, CoeffType > &	_diffusion
const MixtureViscosity < Viscosity, CoeffType > &	_viscosity
const MixtureConductivity < ThermalConductivity, CoeffType > &	_conductivity

Private Member Functions
	MixtureAveragedTransportEvaluator ()

Detailed Description

template<class Diffusion, class Viscosity, class ThermalConductivity, class CoeffType = double>
class Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >

Compute transport properties using ``mixture averaged" model.

Use the species transport models (template parameters) to evaluate species values, then use Wilke's mixing rule to compute the mixture viscosity and thermal conductivity and the appropriate DiffusivityType for the mixture diffusivity. This is the expected interface for the user. Underlying compile time decisions are made based on the species transport models that should be invisible to the user. The preferred, most efficient, and most general method is mu_and_k_and_D for evaluating the transport quantities. The other methods are less efficient and may only be available for a subset of species model; they are present for backwards compatibility and pedagogical reasons.

In a multi-threaded computing environment, this object should be created after threads have been forked. In other words, this object is meant to live only temporarily for computing quantities.

Definition at line 66 of file mixture_averaged_transport_evaluator.h.

Member Enumeration Documentation

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

enum Antioch::MixtureAveragedTransportEvaluator::DiffusivityType

For the mixture averaged diffusion models, there are three typical ways of computing an average diffusivity, depending on the "units" of the flux and which variable with which the gradient is taken:

1. molar flux with gradients of mole fraction (MOLE_FLUX_MOLE_FRACTION)
2. mass flux with gradients of mass fraction (MASS_FLUX_MASS_FRACTION)
3. mass flux with gradients of mole fraction (MASS_FLUX_MOLE_FRACTION) See, for example: Kee, Coltrin, Glarborg, ``Chemically Reacting Flow", Wiley, 2003, Chapter 12.7.

Enumerator
MOLE_FLUX_MOLE_FRACTION
MASS_FLUX_MASS_FRACTION
MASS_FLUX_MOLE_FRACTION

Definition at line 86 of file mixture_averaged_transport_evaluator.h.

                         { MOLE_FLUX_MOLE_FRACTION,
                           MASS_FLUX_MASS_FRACTION,
                           MASS_FLUX_MOLE_FRACTION };

Constructor & Destructor Documentation

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::MixtureAveragedTransportEvaluator	(	const MixtureAveragedTransportMixture< CoeffType > &	mixture,
		const MixtureDiffusion< Diffusion, CoeffType > &	diffusion,
		const MixtureViscosity< Viscosity, CoeffType > &	viscosity,
		const MixtureConductivity< ThermalConductivity, CoeffType > &	conductivity
	)

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::~MixtureAveragedTransportEvaluator ( )

inline

Definition at line 75 of file mixture_averaged_transport_evaluator.h.

{};

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::MixtureAveragedTransportEvaluator ( )

private

Member Function Documentation

template<class Diff , class Visc , class TherCond , class CoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::MixtureAveragedTransportEvaluator< Diff, Visc, TherCond, CoeffType >::compute_mu_chi	(	const StateType &	T,
		const VectorStateType &	mass_fractions,
		VectorStateType &	mu,
		VectorStateType &	chi
	)		const

Helper function to reduce code duplication.

Populates species viscosities and the intermediate variable needed for Wilke's mixing rule. This is not intended for the user; only public to facilitate testing.

Definition at line 425 of file mixture_averaged_transport_evaluator.h.

Referenced by Antioch::WilkeEvaluator< MixtureViscosity, ThermalConductivity, CoeffType >::compute_mu_chi().

  {
    const typename value_type<VectorStateType>::type M = _mixture.chem_mixture().M(mass_fractions);

    // Precompute needed quantities
    // chi_s = w_s*M/M_s
    for( unsigned int s = 0; s < _mixture.chem_mixture().n_species(); s++ )
      {
        mu[s] = _viscosity(s,T);
        chi[s] = mass_fractions[s]*M/_mixture.chem_mixture().M(s);
      }

    return;
  }

template<class Diff , class Visc , class TherCond , class CoeffType >

template<typename VectorStateType >

void Antioch::MixtureAveragedTransportEvaluator< Diff, Visc, TherCond, CoeffType >::compute_mu_mu_sqrt ( const VectorStateType &  mu, typename rebind< VectorStateType, VectorStateType >::type &  mu_mu_sqrt  ) const

inline

Helper function to reduce code duplication.

Computes the intermediate , matrix needed for Wilke's mixing rule. Not intended for the user; only public to facilitate testing.

first the diagonal

then the square roots and the inversion (first row, first column)

now the remaining n-2 matrix, using the fact that mu[i]/mu[j] = mu[i]/mu[0] * mu[0]/mu[j]

Definition at line 474 of file mixture_averaged_transport_evaluator.h.

References antioch_assert_equal_to, antioch_assert_greater, and Antioch::constant_clone().

Referenced by tester().

  {
    antioch_assert_equal_to(mu.size(),mu_mu_sqrt.size()); // indeed square matrix
    antioch_assert_greater(mu.size(),0); // not empty
#ifndef NDEBUG
    for(unsigned int i = 0; i < mu.size(); i++)
      {
        antioch_assert_equal_to(mu.size(),mu_mu_sqrt[i].size());
      }
#endif

    for(unsigned int s = 0; s < mu.size(); s++)
      {
        mu_mu_sqrt[s][s] = Antioch::constant_clone(mu[s],1);
      }
    for(unsigned int s = 1; s < mu.size(); s++)
      {
        mu_mu_sqrt[0][s] = ant_sqrt(mu[0]/mu[s]);
        mu_mu_sqrt[s][0] = Antioch::constant_clone(mu[0],1)/mu_mu_sqrt[0][s];
      }
    for(unsigned int s = 1; s < mu.size(); s++)
      {
        for(unsigned int l = 1; l < mu.size(); l++)
          {
            if(l == s)continue;
            mu_mu_sqrt[s][l] = mu_mu_sqrt[s][0] * mu_mu_sqrt[0][l];
          }
      }
  }

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

template<typename VectorStateType >

value_type<VectorStateType>::type Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::compute_phi	(	typename rebind< VectorStateType, VectorStateType >::type &	mu_mu_sqrt,
		const VectorStateType &	chi,
		const unsigned int	s
	)		const

Helper function to reduce code duplication.

Computes the intermediate variable needed for Wilke's mixing rule. Not intended for the user; only public to facilitate testing.

Referenced by tester().

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

template<typename VectorStateType >

value_type<VectorStateType>::type Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::compute_phi	(	typename Antioch::rebind< VectorStateType, VectorStateType >::type &	mu_mu_sqrt,
		const VectorStateType &	chi,
		const unsigned int	s
	)		const

Definition at line 447 of file mixture_averaged_transport_evaluator.h.

  {
    using std::sqrt;

    typedef typename value_type<VectorStateType>::type StateType;

    /* We initialize to the first iterate and loop starting from 1
       since some StateTypes have a hard time initializing from
       a constant. */
    // phi_s = sum_r (chi_r*(1+sqrt(mu_s/mu_r)*(Mr/Ms)^(1/4))^2)/sqrt(8*(1+Ms/Mr))
    const StateType dummy = 1 + mu_mu_sqrt[s][0]*_mixture.Mr_Ms_to_the_one_fourth(0,s);
    StateType phi_s = chi[0]*dummy*dummy/_mixture.denominator(0,s);

    for(unsigned int r = 1; r < _mixture.chem_mixture().n_species(); r++ )
      {
        const StateType numerator = 1 + mu_mu_sqrt[s][r]*_mixture.Mr_Ms_to_the_one_fourth(r,s);
        phi_s += chi[r]*numerator*numerator/_mixture.denominator(r,s);
      }

    return phi_s;
  }

template<class Diff , class Visc , class TherCond , class CoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::MixtureAveragedTransportEvaluator< Diff, Visc, TherCond, CoeffType >::D	(	const StateType &	rho,
		const StateType &	T,
		const VectorStateType &	mass_fractions,
		VectorStateType &	D_vec,
		DiffusivityType	diff_type = DiffusivityType::MASS_FLUX_MOLE_FRACTION
	)		const

Mixture diffusivities for each species, in [m^2/s].

Only valid for BinaryDiffusionBase species diffusion models. Compile time error if otherwise.

Definition at line 198 of file mixture_averaged_transport_evaluator.h.

References antioch_static_assert_runtime_fallback, and Antioch::init_constant().

Referenced by tester().

  {
    antioch_static_assert_runtime_fallback( DiffusionTraits<Diff>::is_binary_diffusion,
                                            "ERROR: This function requires a binary diffusion model to compute D!");

    typename rebind<VectorStateType,VectorStateType>::type D_mat(D_vec.size());
    init_constant(D_mat,D_vec);

    const StateType molar_density = rho / _mixture.chem_mixture().M(mass_fractions); // total molar density

    _diffusion.compute_binary_diffusion_matrix( T, molar_density, D_mat );

    this->diffusion_mixing_rule( _mixture.chem_mixture(),
                                 mass_fractions,
                                 D_mat,
                                 diff_type,
                                 D_vec );
  }

template<class Diff , class Visc , class TherCond , class CoeffType >

template<typename VectorStateType , typename MatrixStateType >

void Antioch::MixtureAveragedTransportEvaluator< Diff, Visc, TherCond, CoeffType >::diffusion_mixing_rule ( const ChemicalMixture< CoeffType > &  mixture, const VectorStateType &  mass_fractions, const MatrixStateType &  D_mat, DiffusivityType  diff_type, VectorStateType &  D_vec  ) const

protected

Compute species diffusion coefficients.

Uses Wilke mixing rule to compute species diffusion coefficients, D_vec, based on the given binary diffusion matrix, D_mat.

Definition at line 511 of file mixture_averaged_transport_evaluator.h.

References antioch_assert_equal_to, antioch_error_msg, Antioch::constant_clone(), Antioch::ChemicalMixture< CoeffType >::M(), Antioch::ChemicalMixture< CoeffType >::n_species(), and Antioch::zero_clone().

  {
    antioch_assert_equal_to(D_vec.size(),mixture.n_species());
    antioch_assert_equal_to(D_vec.size(),mass_fractions.size());
    antioch_assert_equal_to(D_vec.size(),D_mat.size());

#ifndef NDEBUG
    // D_Mat should be square
    for(unsigned int s = 0; s < D_vec.size(); s++)
      antioch_assert_equal_to(D_vec.size(),D_mat[s].size());
#endif

    switch(diff_type)
      {
      case(MASS_FLUX_MOLE_FRACTION):
        {
          VectorStateType molar_fractions = zero_clone(mass_fractions);

          mixture.X(mixture.M(mass_fractions),mass_fractions,molar_fractions);

          // D_s = (1 - Y_s) / (sum_{j \neq s} x_j/D_{s,j})
          for(unsigned int s = 0; s < D_vec.size(); s++)
            {
              D_vec[s] = constant_clone(mass_fractions[s],1) - mass_fractions[s];

              typename value_type<VectorStateType>::type denom = zero_clone(mass_fractions[0]);

              for(unsigned int j = 0; j < D_vec.size(); j++)
                {
                  if(j == s)
                    continue;

                  denom += molar_fractions[j] / D_mat[s][j];
                }

              D_vec[s] /= denom;
            }
          break;
        }
      case(MOLE_FLUX_MOLE_FRACTION):
        {
          VectorStateType molar_fractions = zero_clone(mass_fractions);

          mixture.X(mixture.M(mass_fractions),mass_fractions,molar_fractions);

          // D_s = (1 - X_s) / (sum_{j \neq s} X_j/D_{s,j})
          for(unsigned int s = 0; s < D_vec.size(); s++)
            {
              // 1 - X_s
              D_vec[s] = constant_clone(mass_fractions[s],1) - molar_fractions[s];

              typename value_type<VectorStateType>::type denom = zero_clone(mass_fractions[0]);

              for(unsigned int j = 0; j < D_vec.size(); j++)
                {
                  if(j == s)
                    continue;

                  denom += molar_fractions[j] / D_mat[s][j];
                }

              D_vec[s] /= denom;
            }
          break;
        }
      case(MASS_FLUX_MASS_FRACTION):
        {
          VectorStateType molar_fractions = zero_clone(mass_fractions);

          mixture.X(mixture.M(mass_fractions),mass_fractions,molar_fractions);

          typename value_type<VectorStateType>::type one = constant_clone(mass_fractions[0],1);

          //               term1               term2
          // 1/D_s = (sum_{j\ne s} X_j/D_{s,j}) + X_s/(1-Y_s)\sum_{j\ne s} Y_j/D_{s,j}
          for(unsigned int s = 0; s < D_vec.size(); s++)
            {
              typename value_type<VectorStateType>::type term1 = zero_clone(mass_fractions[0]);
              typename value_type<VectorStateType>::type term2 = zero_clone(mass_fractions[0]);

              for(unsigned int j = 0; j < D_vec.size(); j++)
                {
                  if(j == s)
                    continue;

                  term1 += molar_fractions[j]/D_mat[s][j];

                  term2 += mass_fractions[j]/D_mat[s][j];
                }

              term2 *=  molar_fractions[s]/(one - mass_fractions[s]);

              D_vec[s] = one/(term1+term2);
            }
          break;
        }
      default:
        {
          antioch_error_msg("ERROR: Invalid DiffusivityType in MixtureAveragedTransportEvaluator::diffusion_mixing_rule");
        }
      } // switch(diff_type)
  }

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

template<typename StateType , typename VectorStateType >

value_type<VectorStateType>::type Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::k	(	const StateType &	T,
		const VectorStateType &	mass_fractions
	)		const

Mixture conducivity, in [W/m-K].

Only valid for "no diffusion" conductivity models. Compile time error if otherwise.

Referenced by Antioch::WilkeEvaluator< MixtureViscosity, ThermalConductivity, CoeffType >::k(), and tester().

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

template<typename StateType , typename VectorStateType >

value_type<VectorStateType>::type Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::k	(	const StateType &	T,
		const VectorStateType &	mass_fractions
	)		const

Definition at line 254 of file mixture_averaged_transport_evaluator.h.

References antioch_assert_equal_to, antioch_static_assert_runtime_fallback, Antioch::init_constant(), and Antioch::zero_clone().

  {
    antioch_static_assert_runtime_fallback( !ConductivityTraits<TherCond>::requires_diffusion,
                                            "This function requires a conductivity model independent of diffusion!");

    antioch_assert_equal_to(mass_fractions.size(), _mixture.chem_mixture().n_species());

    typename value_type<VectorStateType>::type k_mix = zero_clone(T);

    VectorStateType mu  = zero_clone(mass_fractions);
    VectorStateType chi = zero_clone(mass_fractions);

    typename Antioch::rebind<VectorStateType,VectorStateType>::type mu_mu_sqrt(mu.size());
    Antioch::init_constant(mu_mu_sqrt,mu);

    this->compute_mu_chi( T, mass_fractions, mu, chi );

    this->compute_mu_mu_sqrt( mu, mu_mu_sqrt);

    for( unsigned int s = 0; s < _mixture.chem_mixture().n_species(); s++ )
      {
        typename value_type<VectorStateType>::type  phi_s = this->compute_phi( mu_mu_sqrt, chi, s );

        typename value_type<VectorStateType>::type  k_s = zero_clone(T);

        k_s =  _conductivity.conductivity_without_diffusion( s,
                                                             T,
                                                             mu[s] );

        k_mix += k_s*chi[s]/phi_s;
      }

    return k_mix;
  }

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

template<typename StateType , typename VectorStateType >

value_type<VectorStateType>::type Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::mu	(	const StateType &	T,
		const VectorStateType &	mass_fractions
	)		const

Mixture viscosity, in [Pa-s].

Referenced by Antioch::WilkeEvaluator< MixtureViscosity, ThermalConductivity, CoeffType >::mu(), and tester().

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

template<typename StateType , typename VectorStateType >

value_type<VectorStateType>::type Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::mu ( const StateType &  T, const VectorStateType &  mass_fractions  ) const

inline

Definition at line 225 of file mixture_averaged_transport_evaluator.h.

References Antioch::init_constant(), and Antioch::zero_clone().

  {
    typename value_type<VectorStateType>::type mu_mix = zero_clone(T);

    VectorStateType mu  = zero_clone(mass_fractions);
    VectorStateType chi = zero_clone(mass_fractions);


    typename Antioch::rebind<VectorStateType,VectorStateType>::type mu_mu_sqrt(mu.size());
    Antioch::init_constant(mu_mu_sqrt,mu);

    this->compute_mu_chi( T, mass_fractions, mu, chi );

    this->compute_mu_mu_sqrt( mu, mu_mu_sqrt);

    for( unsigned int s = 0; s < _mixture.chem_mixture().n_species(); s++ )
      {
        typename value_type<VectorStateType>::type phi_s = this->compute_phi( mu_mu_sqrt, chi, s );

        mu_mix += mu[s]*chi[s]/phi_s;
      }

    return mu_mix;
  }

template<class Diff , class Visc , class TherCond , class CoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::MixtureAveragedTransportEvaluator< Diff, Visc, TherCond, CoeffType >::mu_and_k	(	const StateType &	T,
		const VectorStateType &	mass_fractions,
		StateType &	mu,
		StateType &	k
	)		const

Mixture viscosity and thermal conductivity, in [Pa-s], [W/m-K] respectively.

Only valid for "no diffusion" conductivity models. Compile time error if otherwise.

Definition at line 292 of file mixture_averaged_transport_evaluator.h.

References antioch_static_assert_runtime_fallback, Antioch::init_constant(), and Antioch::zero_clone().

Referenced by Antioch::WilkeEvaluator< MixtureViscosity, ThermalConductivity, CoeffType >::mu_and_k(), and tester().

  {
    antioch_static_assert_runtime_fallback( !ConductivityTraits<TherCond>::requires_diffusion,
                                            "This function requires a conductivity model independent of diffusion!");

    mu_mix = zero_clone(T);
    k_mix  = zero_clone(T);

    VectorStateType mu  = zero_clone(mass_fractions);
    VectorStateType chi = zero_clone(mass_fractions);

    typename Antioch::rebind<VectorStateType,VectorStateType>::type mu_mu_sqrt(mu.size());
    Antioch::init_constant(mu_mu_sqrt,mu);

    this->compute_mu_chi( T, mass_fractions, mu, chi );

    this->compute_mu_mu_sqrt( mu, mu_mu_sqrt);

    for( unsigned int s = 0; s < _mixture.transport_mixture().n_species(); s++ )
      {
        StateType phi_s = this->compute_phi( mu_mu_sqrt, chi, s );

        StateType k_s = zero_clone(T);

        k_s =  _conductivity.conductivity_without_diffusion( s, T, mu[s] );

        mu_mix += mu[s]*chi[s]/phi_s;
        k_mix += k_s*chi[s]/phi_s;
      }

    return;
  }

template<class Diff , class Visc , class TherCond , class CoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::MixtureAveragedTransportEvaluator< Diff, Visc, TherCond, CoeffType >::mu_and_k_and_D	(	const StateType &	T,
		const StateType &	rho,
		const StateType &	cp,
		const VectorStateType &	mass_fractions,
		StateType &	mu,
		StateType &	k,
		VectorStateType &	D_vec,
		DiffusivityType	diff_type = DiffusivityType::MASS_FLUX_MOLE_FRACTION
	)		const

Mixture viscosity, thermal conductivity, and diffusivities in [Pa-s], [W/m-K], [m^2/s] respectively.

This is the preferred, most efficient, and most general method.

Definition at line 330 of file mixture_averaged_transport_evaluator.h.

References antioch_static_assert_runtime_fallback, Antioch::init_constant(), and Antioch::zero_clone().

Referenced by tester().

  {
    antioch_static_assert_runtime_fallback( (ConductivityTraits<TherCond>::requires_diffusion &&
                                             DiffusionTraits<Diff>::is_binary_diffusion) ||
                                            (!ConductivityTraits<TherCond>::requires_diffusion &&
                                             DiffusionTraits<Diff>::is_species_diffusion),
                                            "Incompatible thermal conductivity and diffusion models!" );

    mu_mix = zero_clone(T);
    k_mix  = zero_clone(T);
    D_vec = zero_clone(mass_fractions);

    VectorStateType mu  = zero_clone(mass_fractions);
    VectorStateType k  = zero_clone(mass_fractions);
    VectorStateType chi = zero_clone(mass_fractions);

    typedef typename Antioch::rebind<VectorStateType,VectorStateType>::type MatrixStateType;

    MatrixStateType mu_mu_sqrt(mu.size());
    Antioch::init_constant(mu_mu_sqrt,mu);

    MatrixStateType D_mat(mass_fractions.size());
    init_constant(D_mat,D_vec);


    this->compute_mu_chi( T, mass_fractions, mu, chi );

    this->compute_mu_mu_sqrt( mu, mu_mu_sqrt);

    const StateType molar_density = rho / _mixture.chem_mixture().M(mass_fractions); // total molar density

    // If we're using a binary diffusion model, compute D_mat, D_vec now
    if( DiffusionTraits<Diff>::is_binary_diffusion )
      {
        _diffusion.compute_binary_diffusion_matrix(T, molar_density, D_mat);

        this->diffusion_mixing_rule<VectorStateType,MatrixStateType>( _mixture.chem_mixture(),
                                                                      mass_fractions,
                                                                      D_mat,
                                                                      diff_type,
                                                                      D_vec );
      }

    for( unsigned int s = 0; s < _mixture.transport_mixture().n_species(); s++ )
      {
        StateType phi_s = this->compute_phi( mu_mu_sqrt, chi, s );

        if( ConductivityTraits<TherCond>::requires_diffusion )
          {
            k[s] = _conductivity.conductivity_with_diffusion( s,
                                                              T,
                                                              molar_density*_mixture.chem_mixture().M(s),
                                                              //rho*mass_fractions[s], see #146
                                                              mu[s],
                                                              D_mat[s][s] );

          }
        else
          {
            k[s] =  _conductivity.conductivity_without_diffusion( s,
                                                                  T,
                                                                  mu[s] );
          }

        k_mix += k[s]*chi[s]/phi_s;
        mu_mix += mu[s]*chi[s]/phi_s;

      }



    if( DiffusionTraits<Diff>::is_species_diffusion )
      {
        for( unsigned int s = 0; s < _mixture.transport_mixture().n_species(); s++ )
          {
            _diffusion.compute_species_diffusivity(s,
                                                   rho,
                                                   cp,
                                                   k_mix,
                                                   D_vec[s]);
          }
      }

    return;
  }

Member Data Documentation

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

const MixtureConductivity<ThermalConductivity,CoeffType>& Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::_conductivity

protected

Definition at line 175 of file mixture_averaged_transport_evaluator.h.

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

const MixtureDiffusion<Diffusion,CoeffType>& Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::_diffusion

protected

Definition at line 171 of file mixture_averaged_transport_evaluator.h.

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

const MixtureAveragedTransportMixture<CoeffType>& Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::_mixture

protected

Definition at line 169 of file mixture_averaged_transport_evaluator.h.

template<class Diffusion , class Viscosity , class ThermalConductivity , class CoeffType = double>

const MixtureViscosity<Viscosity,CoeffType>& Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::_viscosity

protected

Definition at line 173 of file mixture_averaged_transport_evaluator.h.

---

The documentation for this class was generated from the following file:

• src/transport/include/antioch/mixture_averaged_transport_evaluator.h