experimental_porous_layer.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2013 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: experimental_porous_layer.h
// - Description: This class describes a porous layer
// - Developers: Valentin N. Zingan, University of Alberta
// - Id: $Id: experimental_porous_layer.h 2605 2014-08-15 03:36:44Z secanell $
//
// ----------------------------------------------------------------------------

#ifndef _FCST_FUELCELLSHOP_LAYER_EXPERIMENTAL_POROUS_LAYER_H_
#define _FCST_FUELCELLSHOP_LAYER_EXPERIMENTAL_POROUS_LAYER_H_

#include <layers/base_layer.h>
#include <materials/experimental_fluid.h>
#include <materials/GasMixture.h>
#include <materials/experimental_solid.h>

namespace FuelCellShop
{
    namespace Layer
    {

        template<int dim>
        class ExperimentalPorousLayer : public BaseLayer<dim>
        {
            public:



                ExperimentalPorousLayer(const std::string& name);

                ExperimentalPorousLayer(const std::string&                         name,
                                        FuelCellShop::Material::ExperimentalFluid& fluid,
                                        FuelCellShop::Material::ExperimentalSolid& solid);

                ExperimentalPorousLayer(const std::string&                         name,
                                        FuelCellShop::Material::GasMixture&        gas_mixture,
                                        FuelCellShop::Material::ExperimentalSolid& solid);

                virtual ~ExperimentalPorousLayer();

                void initialize(FuelCellShop::Material::ExperimentalFluid& rfluid,
                                FuelCellShop::Material::ExperimentalSolid& rsolid)
                {
                    fluid       = &rfluid;
                    gas_mixture = nullptr;
                    solid       = &rsolid;
                }

                void initialize(FuelCellShop::Material::GasMixture&        rgas_mixture,
                                FuelCellShop::Material::ExperimentalSolid& rsolid)
                {
                    fluid       = nullptr;
                    gas_mixture = &rgas_mixture;
                    solid       = &rsolid;
                }

                void initialize(const bool& rporosity_is_constant,
                                const bool& rpermeability_is_constant,
                                const bool& rtortuosity_is_constant)
                {
                    porosity_is_constant     = rporosity_is_constant;
                    permeability_is_constant = rpermeability_is_constant;
                    tortuosity_is_constant   = rtortuosity_is_constant;
                }

                virtual void declare_parameters(ParameterHandler& param) const;

                virtual void initialize(ParameterHandler& param);




                const FuelCellShop::Material::ExperimentalFluid* const get_fluid() const
                {
                    return fluid;
                }

                const FuelCellShop::Material::GasMixture* const get_gas_mixture() const
                {
                    return gas_mixture;
                }

                const FuelCellShop::Material::ExperimentalSolid* const get_solid() const
                {
                    return solid;
                }

                const bool& get_porosity_is_constant() const
                {
                    return porosity_is_constant;
                }

                const bool& get_permeability_is_constant() const
                {
                    return permeability_is_constant;
                }

                const bool& get_tortuosity_is_constant() const
                {
                    return tortuosity_is_constant;
                }

                void get_porosity(std::vector<double>& dst) const;

                void get_porosity(std::vector<double>&             dst,
                                    const std::vector< Point<dim> >& points) const;

                void get_permeability(std::vector< SymmetricTensor<2,dim> >& dst) const;

                void get_permeability(std::vector< SymmetricTensor<2,dim> >& dst,
                                        const std::vector< Point<dim> >&       points) const;

                void get_SQRT_permeability(std::vector< SymmetricTensor<2,dim> >& dst) const;

                void get_SQRT_permeability(std::vector< SymmetricTensor<2,dim> >& dst,
                                            const std::vector< Point<dim> >&       points) const;

                void get_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst) const;

                void get_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst,
                                            const std::vector< Point<dim> >&       points) const;

                void get_SQRT_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst) const;

                void get_SQRT_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst,
                                                const std::vector< Point<dim> >&       points) const;

                void get_Forchheimer_permeability(std::vector< SymmetricTensor<2,dim> >& dst) const;

                void get_Forchheimer_permeability(std::vector< SymmetricTensor<2,dim> >& dst,
                                                    const std::vector< Point<dim> >&       points) const;

                void get_tortuosity(std::vector< SymmetricTensor<2,dim> >& dst) const;

                void get_tortuosity(std::vector< SymmetricTensor<2,dim> >& dst,
                                    const std::vector< Point<dim> >&       points) const;

                const std::type_info& get_base_type() const
                {
                    return typeid(ExperimentalPorousLayer<dim>);
                }

                virtual void print_layer_properties() const;


            protected:



                void print_caller_name(const std::string& caller_name) const;


                // DATA //



                FuelCellShop::Material::ExperimentalFluid* fluid;

                FuelCellShop::Material::GasMixture* gas_mixture;

                FuelCellShop::Material::ExperimentalSolid* solid;

                bool porosity_is_constant;

                bool permeability_is_constant;

                bool tortuosity_is_constant;

                double porosity;

                SymmetricTensor<2,dim> permeability;

                SymmetricTensor<2,dim> SQRT_permeability;

                SymmetricTensor<2,dim> permeability_INV;

                SymmetricTensor<2,dim> SQRT_permeability_INV;

                SymmetricTensor<2,dim> Forchheimer_permeability;

                SymmetricTensor<2,dim> tortuosity;


        };

    } // Layer

} // FuelCellShop

#endif