app_compressible_flows.h

Go to the documentation of this file.

// ------------------------------------------------------------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2015 by Energy Systems Design Laboratory, University of Alberta
//
// This software is distributed under the MIT license
// For more information, see the README file in /doc/LICENSE
//
// - Class: app_compressible_flows.h
// - Description: This class deals with steady-state compressible and isothermal Kerkhof-Geboers
//                fluid transport equations for a single-phase multi-component case
//
//              - serpentine_comp      - serpentine flow                                   (channel + porous layer) - experiment
//              - DarcyCTest_comp      - Darcy equation convergence test                   (          porous layer) - test
//              - ThInPlane_comp       - through-plane & in-plane permeability experiments (channel + porous layer) - experiment
//              - pore_network_comp    - pore network flow                                 (channel)                - study
//              - StefanTube           - Stefan tube flow                                  (channel)                - test
//              - KerkhofGeboersTest_1 - one component  flow in narrow capillary           (channel)                - test
//              - KerkhofGeboersTest_2 - two components flow in narrow capillary           (channel)                - test
//
// - Developers: Valentin N. Zingan, Chad Balen and Marc Secanell, University of Alberta
//
// ------------------------------------------------------------------------------------------------------------------------------

#ifndef _FCST_APPLICATION_APP_COMPRESSIBLE_FLOWS_H_
#define _FCST_APPLICATION_APP_COMPRESSIBLE_FLOWS_H_
//-- deal II
#include <deal.II/base/function_parser.h>
//-- OpenFCST
#include <application_core/optimization_block_matrix_application.h>
#include <equations/compressible_multi_component_KG_equations_coupled.h>
#include <postprocessing/response_mass_flux.h> //For calculating the mass flux at a boundary
#include <utils/operating_conditions.h>
#include <utils/scaling.h> // For scaling equations and residuals to help with convergence with MUMPS

#include <postprocessing/data_out_mass_transport.h>

using namespace dealii;
using namespace FuelCell::ApplicationCore;

namespace FuelCell
{
    namespace Application
    {

        template<int dim>
        class AppCompressibleFlows : public OptimizationBlockMatrixApplication<dim>
        {
            public:



                AppCompressibleFlows( boost::shared_ptr<ApplicationData> data = boost::shared_ptr<ApplicationData>() );

                ~AppCompressibleFlows();

                virtual void declare_parameters(ParameterHandler& param);

                virtual void initialize(ParameterHandler& param);

                virtual void initialize_solution(FEVector&                        initial_guess,
                                                 std::shared_ptr< Function<dim> > function = std::shared_ptr< Function<dim> >());




                virtual void cell_matrix(MatrixVector&                                 cell_matrices,
                                         const typename DoFApplication<dim>::CellInfo& cell_info);

                virtual void cell_residual(FEVector&                                     cell_res,
                                           const typename DoFApplication<dim>::CellInfo& cell_info);

                virtual void bdry_matrix(MatrixVector&                                 bdry_matrices,
                                         const typename DoFApplication<dim>::FaceInfo& bdry_info);

                virtual void bdry_residual(FEVector&                                     bdry_res,
                                           const typename DoFApplication<dim>::FaceInfo& bdry_info);

                


                virtual void dirichlet_bc(std::map<unsigned int, double>& boundary_values) const;




                virtual void data_out(const std::string& filename,
                                        const FEVectors&   src);

                virtual void bdry_responses(std::vector<double>&                                                     dst,
                                            const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                            const FuelCell::ApplicationCore::FEVector&                               src);
                
            protected:



                void make_variable_initial_data(FEVector& initial_guess);

                void make_variable_boundary_data(FEVector& initial_guess);
                
                FuelCell::Scaling Scale;
                
                bool applyScaling = false;

                


                FuelCell::OperatingConditions OC;
                
                std::map<unsigned int, std::string> gasSpeciesMap;
                
                void set_gas_species(std::map<unsigned int, std::string> tmp, std::vector< FuelCellShop::Material::PureGas* >& gases);
                

                


                FuelCellShop::Equation::CompressibleMultiComponentKGEquationsCoupled<dim> fluid_transport_equations;
                



                FuelCellShop::Material::Oxygen oxygen;

                FuelCellShop::Material::WaterVapor water;

                FuelCellShop::Material::Nitrogen nitrogen;
                
                FuelCellShop::Material::Hydrogen hydrogen;
                
                FuelCellShop::Material::Air air;
                
                FuelCellShop::Material::Acetone acetone;
                
                FuelCellShop::Material::Methanol methanol;
                
                FuelCellShop::Material::DummyGas dummyGas;
                
                


                FuelCellShop::Material::GasMixture fluid;

                FuelCellShop::Layer::Channel<dim>  CChannel;

                boost::shared_ptr< FuelCellShop::Layer::GasDiffusionLayer<dim> > CGDL;

                std::string app_specification;

                


                FuelCellShop::PostProcessing::MassFluxResponse<dim>  mass_flux_response;
                
        };

    } // Application

} // FuelCell

#endif