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 "base_layer.h"
#include "experimental_fluid.h"
#include "experimental_multi_fluid.h"
#include "GasMixture.h"
#include "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::ExperimentalMultiFluid& multi_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;
    multi_fluid = nullptr;
    gas_mixture = nullptr;
    solid       = &rsolid;
  }

  void initialize(FuelCellShop::Material::ExperimentalMultiFluid& rmulti_fluid,
                  FuelCellShop::Material::ExperimentalSolid&      rsolid)
  {
    fluid       = nullptr;
    multi_fluid = &rmulti_fluid;
    gas_mixture = nullptr;
    solid       = &rsolid;
  }

  void initialize(FuelCellShop::Material::GasMixture&        rgas_mixture,
                  FuelCellShop::Material::ExperimentalSolid& rsolid)
  {
    fluid       = nullptr;
    multi_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::ExperimentalMultiFluid* const get_multi_fluid() const
  {
    return multi_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::ExperimentalMultiFluid* multi_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