antioch_transport_values.C File Reference

#include "grins_config.h"
#include <iomanip>
#include <vector>
#include <fstream>
#include "libmesh/getpot.h"
#include "grins/antioch_wilke_transport_evaluator.h"

Include dependency graph for antioch_transport_values.C:

Go to the source code of this file.

Functions
template<typename Thermo , typename Viscosity , typename Conductivity , typename Diffusivity >
int	do_transport_eval (const GetPot &input)
int	main (int argc, char *argv[])

Function Documentation

template<typename Thermo , typename Viscosity , typename Conductivity , typename Diffusivity >

int do_transport_eval

(

const GetPot &

input

)

Definition at line 43 of file antioch_transport_values.C.

References GRINS::AntiochEvaluator< Thermo >::cp(), GRINS::AntiochWilkeTransportEvaluator< Thermo, Viscosity, Conductivity, Diffusivity >::D(), GRINS::AntiochWilkeTransportEvaluator< Thermo, Viscosity, Conductivity, Diffusivity >::k(), GRINS::AntiochWilkeTransportEvaluator< Thermo, Viscosity, Conductivity, Diffusivity >::mu(), GRINS::AntiochChemistry::n_species(), and GRINS::AntiochChemistry::species_name().

{
  GRINS::AntiochWilkeTransportMixture<Thermo,Viscosity,Conductivity,Diffusivity> mixture(input);

  GRINS::AntiochWilkeTransportEvaluator<Thermo,Viscosity,Conductivity,Diffusivity> evaluator(mixture);

  libMesh::Real T0 = input( "Conditions/T0", 300.0 );
  libMesh::Real T1 = input( "Conditions/T1", 300.0 );
  libMesh::Real T_inc = input( "Conditions/T_increment", 100.0 );

  libMesh::Real rho = input( "Conditions/density", 1.0e-3 );

  const unsigned int n_species = mixture.n_species();

  std::vector<libMesh::Real> Y(n_species);
  if( input.vector_variable_size( "Conditions/mass_fractions" ) != n_species )
    {
      std::cerr << "Error: mass fractions size not consistent with n_species"
                << std::endl;
      libmesh_error();
    }
    
  for( unsigned int s = 0; s < n_species; s++ )
    {
      Y[s] = input( "Conditions/mass_fractions", 0.0, s );
    }

  libMesh::Real T = T0;

  std::ofstream output;
  output.open( "transport.dat", std::ios::trunc );
  
  output << "# Species names" << std::endl;
  for( unsigned int s = 0; s < n_species; s++ )
    {
      output << mixture.species_name( s ) << " ";
    }
  output << std::endl;
  output << "# T [K]    mu         k           D[s]" << std::endl;

  output.close();

  while( T < T1 )
    { 
      output.open( "transport.dat", std::ios::app );
      output << std::scientific << std::setprecision(16);
      output << T << " ";
     
      libMesh::Real mu = evaluator.mu(T,Y);
      libMesh::Real k = evaluator.k(T,Y);

      output <<  mu << " ";
      output << k << " ";
      
      std::vector<libMesh::Real> D(n_species);
      for( unsigned int s = 0; s< n_species; s++ )
        {
          evaluator.D(rho, evaluator.cp(T,Y), k, D);

          output << D[s] << " ";
        }
      output << std::endl;
      output.close();

      T += T_inc;
    }

  return 0;
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 113 of file antioch_transport_values.C.

{
  // Check command line count.
  if( argc < 2 )
    {
      // TODO: Need more consistent error handling.
      std::cerr << "Error: Must specify input file." << std::endl;
      exit(1);
    }

  GetPot input( argv[1] );

  std::string mixing_model = input( "Physics/Antioch/mixing_model", "wilke");
  std::string thermo_model = input( "Physics/Antioch/thermo_model", "stat_mech");
  std::string viscosity_model = input( "Physics/Antioch/viscosity_model", "sutherland");
  std::string conductivity_model = input( "Physics/Antioch/conductivity_model", "eucken");
  std::string diffusivity_model = input( "Physics/Antioch/diffusivity_model", "constant_lewis");

  int return_flag = 0;

  if( mixing_model == std::string("wilke") )
    {
      if( thermo_model == std::string("stat_mech") )
        {
          if( diffusivity_model == std::string("constant_lewis") )
            {
              if( conductivity_model == std::string("eucken") )
                {
                  if( viscosity_model == std::string("sutherland") )
                    {
                      return_flag = do_transport_eval<Antioch::StatMechThermodynamics<libMesh::Real>,
                                                      Antioch::MixtureViscosity<Antioch::SutherlandViscosity<libMesh::Real> >,
                                                      Antioch::EuckenThermalConductivity<Antioch::StatMechThermodynamics<libMesh::Real> >,
                                                      Antioch::ConstantLewisDiffusivity<libMesh::Real> >(input);
                    }
                  else if( viscosity_model == std::string("blottner") )
                    {
                      return_flag = do_transport_eval<Antioch::StatMechThermodynamics<libMesh::Real>,
                                                      Antioch::MixtureViscosity<Antioch::BlottnerViscosity<libMesh::Real> >,
                                                      Antioch::EuckenThermalConductivity<Antioch::StatMechThermodynamics<libMesh::Real> >,
                                                      Antioch::ConstantLewisDiffusivity<libMesh::Real> >(input);
                    }
                  else
                    {
                      std::cerr << "Error: Unknown viscosity_model "
                                << viscosity_model << "!"  << std::endl;
                      return_flag = 1;
                    }
                }
              else
                {
                  std::cerr << "Error: Unknown conductivity_model "
                            << conductivity_model << "!"  << std::endl;
                  return_flag = 1;
                }
            }
          else
            {
              std::cerr << "Error: Unknown diffusivity_model "
                        << diffusivity_model << "!"  << std::endl;
              return_flag = 1;
            }
        }
      else
        {
          std::cerr << "Error: Unknown thermo_model "
                    << thermo_model << "!"  << std::endl;
      return_flag = 1;
        }
    }
  else
    {
      std::cerr << "Error: Unknown mixing_model "
                << mixing_model << "!" << std::endl;
      return_flag = 1;
    }
  
  return return_flag;
}