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 <grid/geometry.h>

// STD:
#include <numeric>

namespace FuelCellShop
{
    namespace Geometry
    {
        
        template <int dim>
        class GridExternal
        : public GridBase<dim>
        {
        public:
            GridExternal(const std::string &name)
            : GridBase<dim>()
            {}
            
            GridExternal()
            {
                    this->get_mapFactory()->insert(std::pair<std::string, GridExternal<dim>* > (this->concrete_name, this) );           
            }
            
            virtual void generate_grid(Triangulation<dim> &triangulation);
            
            static const std::string concrete_name;
            
        protected:
            


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::GridExternal<dim> (name));
            }   
            


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


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::HyperCube<dim> (name));
            }   
            


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


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::CathodeMPL<dim> (name));
            }   
            


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


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::PemfcMPL<dim> (name));
            }   
            


            static PemfcMPL<dim> const* PROTOTYPE;
            
        };
        
        
        template <int dim>
        class Agglomerate
        : public GridBase<dim>
        {
        public:
            Agglomerate(const std::string &name)
            : GridBase<dim> ()
            {}
            
            Agglomerate()
            : GridBase<dim> ()
            {
                this->get_mapFactory()->insert(std::pair<std::string, Agglomerate<dim>* > (this->concrete_name, this) );           
            }
            
            virtual void generate_grid(Triangulation<dim> &triangulation);
            
            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 (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::Agglomerate<dim> (name));
            }   
            


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


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > (new FuelCellShop::Geometry::GridTest<dim> (name));
            }   
            


            static GridTest<dim> const* PROTOTYPE;
            
        };
    }
}
#endif