PureSolid.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 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: PureSolid.h
//    - Description: Material class for pure liquids.
//    - Developers: Marc Secanell, Jie Zhou
//    - $Id: PureSolid.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__PURESOLID__H
#define _FUELCELLSHOP__PURESOLID__H

//Include STL
#include <cmath>
#include <iostream>
#include <cstdlib>
#include <vector>
#include <fstream>
#include <string>
#include <map>

#include <deal.II/base/parameter_handler.h>
#include "base_material.h"
#include "system_management.h"

enum SolidMaterialTypes
{
    nosolidmaterial = 0,
    Graphite,
    DummySolid
};

namespace FuelCellShop

{
    namespace Material
    {
        
        class PureSolid : public BaseMaterial
        {
        public:
            

            
            PureSolid()
            :
            BaseMaterial()
            {};
            
            virtual ~PureSolid();
            
            static void declare_PureSolid_parameters (ParameterHandler &param)
            {
                
                for (typename FuelCellShop::Material::PureSolid::_mapFactory::iterator iterator = FuelCellShop::Material::PureSolid::get_mapFactory()->begin(); 
                     iterator != FuelCellShop::Material::PureSolid::get_mapFactory()->end(); 
                     iterator++)
                     {
                         param.enter_subsection("Material Database");
                         {
                             param.enter_subsection("PureSolid");
                             {
                                 iterator->second->declare_parameters(param);
                             }
                             param.leave_subsection();                             
                         }
                         param.leave_subsection();
                     }    
                  
            }
            
            static boost::shared_ptr<FuelCellShop::Material::PureSolid > create_PureSolid (std::string concrete_name,
                                                                                           ParameterHandler &param)
             {       
                 
                 boost::shared_ptr<FuelCellShop::Material::PureSolid> pointer;
                 
                 typename FuelCellShop::Material::PureSolid::_mapFactory::iterator iterator = FuelCellShop::Material::PureSolid::get_mapFactory()->find(concrete_name);
                 
                 if (iterator != FuelCellShop::Material::PureSolid::get_mapFactory()->end())
                 {
                     if (iterator->second)
                     {
                         pointer = iterator->second->create_replica(concrete_name);
                     }
                     else 
                     {
                         FcstUtilities::log<<"Pointer not initialized"<<std::endl;
                         abort();
                     }
                 }
                 else
                 {
                     AssertThrow(false, ExcMessage("Concrete name in FuelCellShop::Material::PureSolid::create_PureSolid does not exist"));
                 }
                 
                 param.enter_subsection("Material Database");
                 {
                     param.enter_subsection("PureSolid");
                     {
                         pointer->initialize(param);
                     }
                     param.leave_subsection();                             
                 }
                 param.leave_subsection();                
                 
                 return pointer;
                 
             }
            

            
            virtual  double get_density() const = 0;
            
            virtual  double get_electrical_conductivity(double temperature) const = 0 ;
            
            virtual  void get_electrical_conductivity(std::vector<double> temperature,std::vector<double>& dst) const = 0;
            
            virtual  double get_Delectrical_conductivity_Dtemperature(double temperature) const = 0;
            
            virtual  void get_Delectrical_conductivity_Dtemperature(std::vector<double> temperature,std::vector<double> &dst) const = 0;
            
            virtual   double get_thermal_conductivity(double temperature) const = 0;
            
            virtual  void get_thermal_conductivity(std::vector<double> temperature,std::vector<double>&dst) const = 0;
            
            virtual  double get_Dthermal_conductivity_Dtemperature(double temperature) const = 0;
            
            virtual  void get_Dthermal_conductivity_Dtemperature(std::vector<double> temperature,std::vector<double> &dst) const = 0;
            
            virtual   double get_coefficient_thermal_expansion(double temperature) const = 0;
            
            virtual   double get_compressive_strength(double temperature) const = 0;
            
            virtual   double get_H2_permeability(double temperature) const = 0;
            
            virtual   double get_Poissons_ratio(double temperature) const = 0;

            


            typedef std::map< std::string, PureSolid* > _mapFactory;      
            


            static _mapFactory * get_mapFactory()
            {
                static _mapFactory mapFactory;
                return &mapFactory;
            }
            


        protected:



            static const std::string concrete_name;
            


            static PureSolid const* PROTOTYPE;
            


            virtual boost::shared_ptr<FuelCellShop::Material::PureSolid > create_replica (const std::string &name)
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            
            

            
            PureSolid(const std::string& name);
           
            virtual void declare_parameters (ParameterHandler &param) const {};
            
            virtual void initialize (ParameterHandler &param) {};
            
            
            // DATA //
            


            double density;
            
            double electrical_conductivity;
            
            double thermal_conductivity;
            
            double coefficient_thermal_expansion;
            
            double compressive_strength;        
            
            double H2_permeability; 
            
            double Poissons_ratio; 
            
//             /** Solutions at every quadrature point inside the cell. 
//             * for this mapping key is the Enumerator of VariableName_of_REV
//             * the mapped value is of type SolutionVariable
//             */
//             std::map <VariableNames, SolutionVariable> Solutions;
//             
//             SolutionVariable T_vector;
            
        };

        class Graphite : public PureSolid
        {
        public:
            


            Graphite();
            virtual ~Graphite();
            

                        
            virtual inline double get_density() const;
            
            virtual inline double get_electrical_conductivity(double temperature) const;
            
            virtual inline void get_electrical_conductivity(std::vector<double> temperature,std::vector<double>& dst) const;
            
            virtual inline double get_Delectrical_conductivity_Dtemperature(double temperature) const 
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
                return 0;
            }
            
            virtual inline void get_Delectrical_conductivity_Dtemperature(std::vector<double>,std::vector<double>&) const {}
            
            virtual  inline double get_thermal_conductivity(double temperature) const;
            
            virtual inline void get_thermal_conductivity(std::vector<double>,std::vector<double>&) const;
            
            virtual inline double get_Dthermal_conductivity_Dtemperature(double temperature) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
                return 0;
            }
            
            virtual inline void get_Dthermal_conductivity_Dtemperature(std::vector<double>,std::vector<double>&) const {}
            
            virtual  inline double get_coefficient_thermal_expansion(double temperature) const;
            
            virtual  inline double get_compressive_strength(double temperature) const;
            
            virtual  inline double get_H2_permeability(double temperature) const;
            
            virtual  inline double get_Poissons_ratio(double temperature) const;
            
        protected:
            


            virtual boost::shared_ptr<FuelCellShop::Material::PureSolid > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Material::PureSolid > (new FuelCellShop::Material::Graphite ());
            }
            


            static const std::string concrete_name;
            static Graphite const* PROTOTYPE;
            


            Graphite(const std::string& name);
            
            virtual void declare_parameters (ParameterHandler &param) const;
            
            virtual void initialize (ParameterHandler &param);
            
        };
        
        class DummySolid : public PureSolid
        {
        public: 


            DummySolid();
            virtual ~DummySolid();
            


            virtual inline double get_density() const;
            
            virtual inline double get_electrical_conductivity(double temperature) const ;
            
            virtual inline void get_electrical_conductivity(std::vector<double> temperature,std::vector<double>& dst) const;
            
            virtual inline double get_Delectrical_conductivity_Dtemperature(double temperature) const;
            
            virtual inline void get_Delectrical_conductivity_Dtemperature(std::vector<double> temperature ,std::vector<double>& dst) const;
            
            virtual  inline double get_thermal_conductivity(double temperature) const;
            
            virtual inline void get_thermal_conductivity(std::vector<double> temperature,std::vector<double>& dst) const;
            
            virtual inline double get_Dthermal_conductivity_Dtemperature(double temperature) const;
            
            virtual inline void get_Dthermal_conductivity_Dtemperature(std::vector<double> temperature,std::vector<double>& dst) const;
            
            virtual  inline double get_coefficient_thermal_expansion(double temperature) const;
            
            virtual  inline double get_compressive_strength(double temperature) const;
            
            virtual  inline double get_H2_permeability(double temperature) const;
            
            virtual  inline double get_Poissons_ratio(double temperature) const;
            
        protected:
            


            virtual boost::shared_ptr<FuelCellShop::Material::PureSolid > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Material::PureSolid > (new FuelCellShop::Material::DummySolid ());
            } 
            
            static const std::string concrete_name;
            static DummySolid const* PROTOTYPE;
            
            

            
            DummySolid(const std::string& name);
            virtual void declare_parameters (ParameterHandler &param) const;
            
            virtual void initialize (ParameterHandler &param);
        };
        
    }
}

#endif