Container class for species binary diffusion models. More...

#include <mixture_diffusion.h>

Inheritance diagram for Antioch::MixtureDiffusion< Diffusion, CoeffType >:

Public Member Functions
	MixtureDiffusion (const TransportMixture< CoeffType > &transport_mixture)

virtual	~MixtureDiffusion ()

template<typename StateType , typename MatrixStateType >
void	compute_binary_diffusion_matrix (const StateType &T, const StateType &molar_density, MatrixStateType &D) const
	Computes the binary diffusion matrix. More...

template<typename StateType >
void	compute_species_diffusivity (unsigned int s, const StateType &rho, const StateType &cp, const StateType &k, StateType &D) const
	Computes species diffusivity for species s. More...

void	add_species_diffusion (unsigned int s, const std::vector< CoeffType > &coeffs)
	Add species diffusion model for species s. More...

template<typename StateType >
void	extrapolate_max_temp (const StateType &Tmax)
	Extrapolate to input maximum temperature, given in [K]. More...

const ChemicalMixture < CoeffType > &	chemical_mixture () const

const TransportMixture < CoeffType > &	transport_mixture () const

const TransportMixture < CoeffType > &	mixture () const

Protected Attributes
std::vector < SpeciesDiffusionBase < Diffusion, CoeffType > * >	_species_diffusivities
	Stores species diffusivity models. More...

std::vector< std::vector < BinaryDiffusionBase < Diffusion, CoeffType > * > >	_binary_diffusivities
	Stores binary diffusion model for all species pairs. More...

const TransportMixture < CoeffType > &	_transport_mixture

Private Member Functions
void	private_init_impl (AntiochPrivate::diffusion_tag< SpeciesDiffusionBase< Diffusion, CoeffType > > &)
	Initialize species diffusion models. More...

void	private_init_impl (AntiochPrivate::diffusion_tag< BinaryDiffusionBase< Diffusion, CoeffType > > &)
	Initialize binary diffusion models. More...

template<typename StateType , typename MatrixStateType >
void	private_diff_matrix_impl (const StateType &T, const StateType &molar_density, MatrixStateType &D, AntiochPrivate::diffusion_tag< BinaryDiffusionBase< Diffusion, CoeffType > > &) const
	Compute binary diffusion matrix. More...

template<typename StateType , typename MatrixStateType >
void	private_diff_matrix_impl (const StateType &, const StateType &, MatrixStateType &, AntiochPrivate::diffusion_tag< SpeciesDiffusionBase< Diffusion, CoeffType > > &) const
	Invalid to call binary diffusion matrix with SpeciesDiffusionBase model. More...

template<typename StateType >
void	private_species_diff_impl (unsigned int s, const StateType &rho, const StateType &cp, const StateType &k, StateType &D, AntiochPrivate::diffusion_tag< SpeciesDiffusionBase< Diffusion, CoeffType > > &) const
	Compute species diffusivities. More...

template<typename StateType >
void	private_species_diff_impl (unsigned int, const StateType &, const StateType &, const StateType &, StateType &, AntiochPrivate::diffusion_tag< BinaryDiffusionBase< Diffusion, CoeffType > > &) const
	Invalid to call species diffusivity calculation with BinaryDiffusionBase model. More...

	MixtureDiffusion ()

Detailed Description

template<typename Diffusion, class CoeffType>
class Antioch::MixtureDiffusion< Diffusion, CoeffType >

Container class for species binary diffusion models.

For the given set of chemical species in the input TransportMixture, this contains the diffusion models for each of those species and provides an interface for computing the species diffusion coefficients/binary diffusion matrix, depending on the Diffusion model template parameter. Total/mixture diffusion coefficients are computed by a mixing model, e.g. MixtureAveragedTransportEvaluator. This class is templated on the diffusion model, so an inherent assumption is that all species diffusions have the same model.

This is intended to only be used through a mixing model, e.g. MixtureAveragedTransportEvaluator.

This class supports interfaces to multiple types of species diffusion models. As such, we use "tagging" mechanisms to defer to the correct, private, implemenation for various functions.

Definition at line 55 of file mixture_diffusion.h.

Constructor & Destructor Documentation

template<typename Diffusion , class CoeffType>

Antioch::MixtureDiffusion< Diffusion, CoeffType >::MixtureDiffusion ( const TransportMixture< CoeffType > & transport_mixture )

Definition at line 210 of file mixture_diffusion.h.

References antioch_error_msg, antioch_static_assert, and Antioch::MixtureDiffusion< Diffusion, CoeffType >::private_init_impl().

     :  MixtureTransportBase<CoeffType>(transport_mixture)
 
   {
     // This class currenltly only supports species or binary diffusion models
     if( !DiffusionTraits<Diffusion>::is_species_diffusion &&
         !DiffusionTraits<Diffusion>::is_binary_diffusion )
       {
         antioch_static_assert( DiffusionTraits<Diffusion>::is_species_diffusion ||
                                DiffusionTraits<Diffusion>::is_binary_diffusion,
                                "Can only instantiate MixtureDiffusion with a species or binary diffusion model!" );
 
         std::string error = "ERROR: You're trying to construct an object\n";
         error += "       with an unknown diffusion model!\n";
         error += "       Does your compiler not support static_assert?";
         antioch_error_msg(error);
       }
 
     // Build tag so we defer to the right initialization function
     AntiochPrivate::diffusion_tag<Diffusion> tag;
     this->private_init_impl( tag );
 
   }

template<typename Diffusion , class CoeffType >

Antioch::MixtureDiffusion< Diffusion, CoeffType >::~MixtureDiffusion ( )

virtual

Definition at line 235 of file mixture_diffusion.h.

   {
     // Clean up species diffusion models
     if( DiffusionTraits<Diffusion>::is_species_diffusion )
       {
         for( typename std::vector<SpeciesDiffusionBase<Diffusion,CoeffType>*>::iterator it = _species_diffusivities.begin();
          it != _species_diffusivities.end(); ++it )
           delete *it;
       }
 
     // Clean up binary diffusion models
     if( DiffusionTraits<Diffusion>::is_binary_diffusion )
       {
         for( typename std::vector<std::vector<BinaryDiffusionBase<Diffusion,CoeffType>*> >::iterator it_outer = _binary_diffusivities.begin();
              it_outer != _binary_diffusivities.end(); ++it_outer )
           for( typename std::vector<BinaryDiffusionBase<Diffusion,CoeffType>*>::iterator it_inner = it_outer->begin();
                it_inner != it_outer->end(); ++it_inner )
             delete *it_inner;
       }
   }

template<typename Diffusion, class CoeffType>

Antioch::MixtureDiffusion< Diffusion, CoeffType >::MixtureDiffusion ( )

private

Member Function Documentation

template<typename Diffusion , class CoeffType>

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::add_species_diffusion	(	unsigned int	s,
		const std::vector< CoeffType > &	coeffs
	)

Add species diffusion model for species s.

Definition at line 314 of file mixture_diffusion.h.

References antioch_assert_less, and antioch_static_assert_runtime_fallback.

   {
     antioch_static_assert_runtime_fallback( DiffusionTraits<Diffusion>::is_species_diffusion,
                                             "Invalid to add species diffusion model with Diffusion model is not a species diffusion model!" );
     antioch_assert_less( s, _species_diffusivities.size() );
 
     _species_diffusivities[s] = new Diffusion( coeffs );
   }

template<class CoeffType >

const ChemicalMixture< CoeffType > & Antioch::MixtureTransportBase< CoeffType >::chemical_mixture ( ) const

inlineinherited

Definition at line 68 of file mixture_transport_base.h.

   {
     return _transport_mixture.chemical_mixture();
   }

template<typename Diffusion , class CoeffType >

template<typename StateType , typename MatrixStateType >

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::compute_binary_diffusion_matrix	(	const StateType &	T,
		const StateType &	molar_density,
		MatrixStateType &	D
	)		const

inline

Computes the binary diffusion matrix.

Should only be called when using a binary diffusion model.

Definition at line 259 of file mixture_diffusion.h.

References antioch_assert_equal_to, and antioch_assert_greater.

   {
     const unsigned int n_cols = D.size();
     antioch_assert_greater(n_cols,0);
 
     // Make sure it's a square matrix
 #ifndef NDEBUG
     for( unsigned int r = 0; r < n_cols; r++ )
       antioch_assert_equal_to(D[r].size(),n_cols);
 #endif
 
     // Build tag so we defer to the right binary diffusion matrix function
     AntiochPrivate::diffusion_tag<Diffusion> tag;
     this->private_diff_matrix_impl(T,molar_density,D,tag);
   }

template<typename Diffusion , class CoeffType >

template<typename StateType >

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::compute_species_diffusivity	(	unsigned int	s,
		const StateType &	rho,
		const StateType &	cp,
		const StateType &	k,
		StateType &	D
	)		const

inline

Computes species diffusivity for species s.

Definition at line 280 of file mixture_diffusion.h.

References antioch_assert, and antioch_assert_less.

   {
     antioch_assert_less( s, _species_diffusivities.size());
     antioch_assert(_species_diffusivities[s]);
 
     // Build tag so we defer to the right species diffusivity function
     AntiochPrivate::diffusion_tag<Diffusion> tag;
     this->private_species_diff_impl(s,rho,cp,k,D,tag);
   }

template<typename Diffusion , class CoeffType >

template<typename StateType >

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::extrapolate_max_temp ( const StateType & Tmax )

inline

Extrapolate to input maximum temperature, given in [K].

For certain species diffusion models, interpolation of various quantities may be done based on the temperature. This method will use linear extrapolation to extend the range of temperature for all the species diffusion models.

This method is currently only valid for BinaryDiffusionBase subclasses. A static_assert will be throw if the user tries to instantiate a call to this method with a SpeciesDiffusionBase sublass (or runtime error if the compiler does not support static_assert).

Definition at line 297 of file mixture_diffusion.h.

References antioch_static_assert_runtime_fallback.

   {
     antioch_static_assert_runtime_fallback( DiffusionTraits<Diffusion>::is_binary_diffusion,
                                             "Invalid to extrapolate temperature with a non-binary diffusion model!" );
 
     for( typename std::vector<std::vector<BinaryDiffusionBase<Diffusion,CoeffType>*> >::iterator it_outer = _binary_diffusivities.begin();
          it_outer != _binary_diffusivities.end(); ++it_outer )
       {
         for( typename std::vector<BinaryDiffusionBase<Diffusion,CoeffType>*>::iterator it_inner = it_outer->begin();
              it_inner != it_outer->end(); ++it_inner )
           {
             (*it_inner)->extrapolate_max_temp(Tmax);
           }
       }
   }

template<class CoeffType >

const TransportMixture< CoeffType > & Antioch::MixtureTransportBase< CoeffType >::mixture ( ) const

inlineinherited

Definition at line 82 of file mixture_transport_base.h.

   {
     return _transport_mixture;
   }

template<typename Diffusion, class CoeffType>

template<typename StateType , typename MatrixStateType >

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::private_diff_matrix_impl	(	const StateType &	T,
		const StateType &	molar_density,
		MatrixStateType &	D,
		AntiochPrivate::diffusion_tag< BinaryDiffusionBase< Diffusion, CoeffType > > &
	)		const

inlineprivate

Compute binary diffusion matrix.

BinaryDiffusionBase models should've subclassed diffusion_tag so that they call this method.

Definition at line 154 of file mixture_diffusion.h.

     {
       for(unsigned int i = 0; i < D.size(); i++)
       {
         for(unsigned int j = 0; j < D.size(); j++)
           {
             antioch_assert(_binary_diffusivities[i][j]);
 
             D[i][j] = (*_binary_diffusivities[i][j])(T,molar_density);
           }
       }
     }

template<typename Diffusion, class CoeffType>

template<typename StateType , typename MatrixStateType >

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::private_diff_matrix_impl	(	const StateType &	,
		const StateType &	,
		MatrixStateType &	,
		AntiochPrivate::diffusion_tag< SpeciesDiffusionBase< Diffusion, CoeffType > > &
	)		const

inlineprivate

Invalid to call binary diffusion matrix with SpeciesDiffusionBase model.

Definition at line 172 of file mixture_diffusion.h.

     {
       antioch_error();
     }

template<typename Diffusion, class CoeffType>

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::private_init_impl ( AntiochPrivate::diffusion_tag< SpeciesDiffusionBase< Diffusion, CoeffType > > & )

inlineprivate

Initialize species diffusion models.

SpeciesDiffusionBase models should've subclassed diffusion_tag so that they call this method.

Definition at line 120 of file mixture_diffusion.h.

Referenced by Antioch::MixtureDiffusion< Diffusion, CoeffType >::MixtureDiffusion().

     {
       antioch_static_assert( DiffusionTraits<Diffusion>::is_species_diffusion,
                              "This shouldn't happen!" );
 
       _species_diffusivities.resize( this->_transport_mixture.n_species(), NULL );
     }

template<typename Diffusion, class CoeffType>

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::private_init_impl ( AntiochPrivate::diffusion_tag< BinaryDiffusionBase< Diffusion, CoeffType > > & )

inlineprivate

Initialize binary diffusion models.

BinaryDiffusionBase models should've subclassed diffusion_tag so that they call this method.

Definition at line 130 of file mixture_diffusion.h.

     {
       antioch_static_assert( DiffusionTraits<Diffusion>::is_binary_diffusion,
                              "This shouldn't happen!" );
 
       // Build up binary diffusion species models
       _binary_diffusivities.resize( this->_transport_mixture.n_species() );
       for( unsigned int i = 0; i < this->_transport_mixture.n_species(); i++ )
         {
           _binary_diffusivities[i].resize( this->_transport_mixture.n_species(), NULL );
 
           for (unsigned int j = 0; j < this->_transport_mixture.n_species(); j++)
             {
               const TransportSpecies<CoeffType>& s_i = this->_transport_mixture.transport_species(i);
               const TransportSpecies<CoeffType>& s_j = this->_transport_mixture.transport_species(j);
 
               _binary_diffusivities[i][j] = new Diffusion( s_i, s_j );
           }
         }
     }

template<typename Diffusion, class CoeffType>

template<typename StateType >

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::private_species_diff_impl	(	unsigned int	s,
		const StateType &	rho,
		const StateType &	cp,
		const StateType &	k,
		StateType &	D,
		AntiochPrivate::diffusion_tag< SpeciesDiffusionBase< Diffusion, CoeffType > > &
	)		const

inlineprivate

Compute species diffusivities.

SpeciesDiffusionBase models should've subclassed diffusion_tag so that they call this method.

Definition at line 183 of file mixture_diffusion.h.

     {
       D = (*_species_diffusivities[s]).D(rho,cp,k);
     }

template<typename Diffusion, class CoeffType>

template<typename StateType >

void Antioch::MixtureDiffusion< Diffusion, CoeffType >::private_species_diff_impl	(	unsigned	int,
		const StateType &	,
		const StateType &	,
		const StateType &	,
		StateType &	,
		AntiochPrivate::diffusion_tag< BinaryDiffusionBase< Diffusion, CoeffType > > &
	)		const

inlineprivate

Invalid to call species diffusivity calculation with BinaryDiffusionBase model.

Definition at line 195 of file mixture_diffusion.h.

     {
       antioch_error();
     }

template<class CoeffType >

const TransportMixture< CoeffType > & Antioch::MixtureTransportBase< CoeffType >::transport_mixture ( ) const

inlineinherited

Definition at line 75 of file mixture_transport_base.h.

   {
     return _transport_mixture;
   }

Member Data Documentation

template<typename Diffusion, class CoeffType>

std::vector<std::vector<BinaryDiffusionBase<Diffusion,CoeffType>*> > Antioch::MixtureDiffusion< Diffusion, CoeffType >::_binary_diffusivities

protected

Stores binary diffusion model for all species pairs.

This only gets built if Diffusion is a binary diffusion model.

Todo:: This will always be symmetric so we should make a smarter container that only stores the upper (lower) triangle of the species pairs and use accordingly.

Definition at line 114 of file mixture_diffusion.h.

template<typename Diffusion, class CoeffType>

std::vector<SpeciesDiffusionBase<Diffusion,CoeffType>*> Antioch::MixtureDiffusion< Diffusion, CoeffType >::_species_diffusivities

protected

Stores species diffusivity models.

This only gets built if Diffusion is a species diffusion model. Actually populating this is done in a separate function that calls the add_species_diffusivity method in this class since it depends on user-prescribed coefficients. However, if Diffusion is of species type, then the constructor will allocate space to add species diffusivities later.

Definition at line 106 of file mixture_diffusion.h.

template<class CoeffType = double>

const TransportMixture<CoeffType>& Antioch::MixtureTransportBase< CoeffType >::_transport_mixture

protectedinherited

Definition at line 53 of file mixture_transport_base.h.

Referenced by Antioch::MixtureDiffusion< Antioch::ConstantLewisDiffusivity< CoeffType >, CoeffType >::private_init_impl().

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

src/transport/include/antioch/mixture_diffusion.h

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

template<typename Diffusion, class CoeffType> class Antioch::MixtureDiffusion< Diffusion, CoeffType >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename Diffusion, class CoeffType>
class Antioch::MixtureDiffusion< Diffusion, CoeffType >