geometries.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2009-13 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: geometries.h
//    - Description: Geometry definition for several fuel cell elements.
//    - Developers: L. Birkett, P. Dobson, M. Secanell and V. Zingan
//    - $Id: geometries.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------


#ifndef dimension
#if deal_II_dimension == 1
#define _1D_
#elif deal_II_dimension == 2
#define _2D_
#elif deal_II_dimension == 3
#define _3D_
#endif
#endif

#ifndef _FUELCELLSHOP__GEOMETRIES_H
#define _FUELCELLSHOP__GEOMETRIES_H

#include "geometry.h"

// STD:
#include <numeric>




namespace FuelCellShop
{
    namespace Geometry
    {
        
        template <int dim>
        class GridExternal
        : public GridBase<dim>
        {
        public:
            GridExternal()
            : GridBase<dim>()
            {}
            
            GridExternal(const bool create_replica)
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, GridExternal<dim>* > (this->concrete_name, this) );           

            }
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            static const std::string concrete_name;
            
        protected:
            


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::GridExternal<dim> ());
            }   
            


            static GridExternal<dim> const* PROTOTYPE;

        };
        
        template <int dim>
        class HyperCube
        : public GridBase<dim>
        {
        public:
            HyperCube()
            : GridBase<dim>()
            {}
            
            HyperCube(const bool create_replica)
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, HyperCube<dim>* > (this->concrete_name, this) );
            }
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            static const std::string concrete_name;
            
        protected:
            


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::HyperCube<dim> ());
            }   
            


            static HyperCube<dim> const* PROTOTYPE;
            
        };
        
        template <int dim>
        class Cathode
        : public GridBase<dim>
        {
        public:
            
            Cathode(const bool create_replica)
            : GridBase<dim>()
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, Cathode<dim>* > (this->concrete_name, this) );           
                
            }          
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
                        
            static const std::string concrete_name;
            
        protected:
            Cathode()
            : GridBase<dim>()
            {}              
            


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::Cathode<dim> ());
            }   
            


            static Cathode<dim> const* PROTOTYPE;
        };
        
        
        template <int dim>
        class CathodeMPL
        : public GridBase<dim>
        {
        public:
            CathodeMPL(const bool create_replica)
            : GridBase<dim>()
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, CathodeMPL<dim>* > (this->concrete_name, this) );           
                
            }  
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            

            
            static const std::string concrete_name;
            
        protected:
            CathodeMPL()
            : GridBase<dim>()
            {}


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::CathodeMPL<dim> ());
            }   
            


            static CathodeMPL<dim> const* PROTOTYPE;
        };
        
        
        template <int dim>
        class Anode
        : public GridBase<dim>
        {
        public:

            Anode(const bool create_replica)
            : GridBase<dim>()
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, Anode<dim>* > (this->concrete_name, this) );           
                
            } 
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            
            
            static const std::string concrete_name;
            
        protected:
            Anode()
            : GridBase<dim> ()
            {}


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::Anode<dim> ());
            }   
            


            static Anode<dim> const* PROTOTYPE;
            
            
            
            
            
            
        };
        
        
        template <int dim>
        class AnodeMPL
        : public GridBase<dim>
        {
        public:
                        
            AnodeMPL(const bool create_replica)
            : GridBase<dim> ()
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, AnodeMPL<dim>* > (this->concrete_name, this) );           
                
            } 
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            
            
            static const std::string concrete_name;
            
        protected:
            AnodeMPL()
            : GridBase<dim> ()
            {}


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::AnodeMPL<dim> ());
            }   
            


            static AnodeMPL<dim> const* PROTOTYPE;
        
        };
        
        
        template <int dim>
        class Pemfc
        : public GridBase<dim>
        {
        public:
            
            Pemfc(const bool create_replica)
            : GridBase<dim>()
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, Pemfc<dim>* > (this->concrete_name, this) );           
                
            } 
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            
           static const std::string concrete_name;
            
        protected:
            Pemfc()
            : GridBase<dim> ()
            {}


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::Pemfc<dim> ());
            }   
            


            static Pemfc<dim> const* PROTOTYPE;
            
           
        };
        
        
        template <int dim>
        class PemfcMPL
        : public GridBase<dim>
        {
        public:
            PemfcMPL(const bool create_replica)
            : GridBase<dim> ()
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, PemfcMPL<dim>* > (this->concrete_name, this) );           
                
            }            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            static const std::string concrete_name;
            
        protected:
            PemfcMPL()
            : GridBase<dim> ()
            {}


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::PemfcMPL<dim> ());
            }   
            


            static PemfcMPL<dim> const* PROTOTYPE;
   
        };
        
        
        template <int dim>
        class Agglomerate
        : public GridBase<dim>
        {
        public:
            Agglomerate()
            : GridBase<dim> ()
            {}
            
            Agglomerate(const bool create_replica)
            : GridBase<dim> ()
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, Agglomerate<dim>* > (this->concrete_name, this) );           
                
            }
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            void reset_material_ids(Triangulation<dim> &triangulation) const;
            
            static const std::string concrete_name;
            
        protected:



            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::Agglomerate<dim> ());
            }   
            


            static Agglomerate<dim> const* PROTOTYPE;

        };
        template <int dim>
        class GridTest
        : public GridBase<dim>
        {
        public:
            GridTest()
            : GridBase<dim>()
            {}
            
            GridTest(const bool create_replica)
            {
                if (create_replica)
                    this->get_mapFactory()->insert(std::pair<std::string, GridTest<dim>* > (this->concrete_name, this) );           

            }
            
            virtual void generate_grid(Triangulation<dim> &triangulation) const;
            
            static const std::string concrete_name;
            
        protected:
            


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica ()
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::GridTest<dim> ());
            }   
            


            static GridTest<dim> const* PROTOTYPE;

        };
    }
}
#endif