geometry.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2006-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: geometry.h
//    - Description: Used to store and output information for general fuel cell geometries
//    - Developers: M. Secanell and Peter Dobson
//                  Salome parser dealii::GridIn<dim, spacedim>::read_unv(): Valentin N. Zingan, University of Alberta, (C) 2012.
//    - $Id: geometry.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__GEOMETRY_H
#define _FUELCELLSHOP__GEOMETRY_H

//------------------------------
// STANDARD LIBRARY DECLARATIONS
//------------------------------
#include <fstream>
#include <iostream>

//------------------------------
// DEAL.II DECLARATIONS
//------------------------------
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/grid/tria_boundary_lib.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/grid_in.h>
#include <deal.II/grid/grid_out.h>
#include <deal.II/base/parameter_handler.h>
#include <deal.II/base/exceptions.h>

#include <utils/fcst_utilities.h>

using namespace dealii;

namespace FuelCellShop
{
    namespace Geometry
    {

        template <int dim>
        class GridBase
        {
        public:

            static void declare_GridGenerator_parameters (ParameterHandler &param);

            static boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > create_GridGenerator (ParameterHandler &param)
            {
                boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > pointer;
                std::string concrete_name;
                
                param.enter_subsection("Grid generation");
                {
                    concrete_name = param.get("Type of mesh");
                    FcstUtilities::log <<" "<<std::endl;
                    FcstUtilities::log << "name: "<<concrete_name.c_str()<<std::endl;
                }
                param.leave_subsection();
                //FcstUtilities::log <<FuelCellShop::Geometry::GridBase<dim>::get_mapFactory()->empty()<<std::endl;

                typename FuelCellShop::Geometry::GridBase<dim>::_mapFactory::iterator iterator = FuelCellShop::Geometry::GridBase<dim>::get_mapFactory()->find(concrete_name);
                if (iterator != FuelCellShop::Geometry::GridBase<dim>::get_mapFactory()->end())
                {
                    if (iterator->second)
                    {
                        pointer = iterator->second->create_replica(concrete_name);
                    }
                    else
                    {
                        FcstUtilities::log<<"Pointer not initialized"<<std::endl;
                        abort();
                    }
                }
                else
                {
                    FcstUtilities::log<<"Concrete name does not exist"<<std::endl;
                    abort();
                }
                
                pointer->initialize(param);
                
                return pointer;
            }
            
            virtual void generate_grid (Triangulation<dim>& ) 
            {
                const std::type_info& info = typeid ( *this );
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }

            void generate_grid_with_curved_boundaries(Triangulation<dim>&                triangulation,
                                                      const types::boundary_id&          bdry_id,
                                                      boost::shared_ptr< Boundary<dim> > boundary) const
            {
                   FcstUtilities::log << "Read mesh from file: " << std::endl;
                   FcstUtilities::log << "\t mesh name: " << this->mesh_name << std::endl;
                   FcstUtilities::log << "\t mesh type: " << this->mesh_type << std::endl;

                   GridIn<dim> grid_in;
                   grid_in.attach_triangulation(triangulation);
                   std::ifstream input_file( this->mesh_name.c_str() );
                   grid_in.read( input_file , grid_in.parse_format( this->mesh_type ) );
                   input_file.close();

                   triangulation.set_boundary(bdry_id,
                                             *boundary);

                   triangulation.refine_global(this->num_refine);
            }

            std::vector<unsigned int> get_material_id ( const std::string ) const;

            unsigned int get_boundary_id ( ParameterHandler& param,
                                           const std::string boundary ) const;

            unsigned int get_boundary_id ( const std::string ) const;

            void output_grid ( const Triangulation<dim> &triangulation, const std::string filename ) const;

            void refine_area ( Triangulation<dim> &triangulation, const unsigned int material_id );

            std::string get_mesh_type()
            {
                return mesh_type_name;
            }


            inline double L_channel_c(){return 2.0*l_channel_c;}
            inline double L_channelLength_c(){return l_channelLength_c;}
            inline double L_channelHeight_c(){return l_channelHeight_c;}
            inline double L_channelEntrance_c(){return l_channelEntrance_c;}
            inline double L_channelExit_c(){return l_channelExit_c;}
            inline double L_land_c(){return 2.0*l_land_c;}
            inline double L_gdl_c(){return l_gdl_c;}
            inline  std::vector<double> L_cat_c(){return l_cat_c;}

            inline double L_mpl_c(){return l_mpl_c;}


            inline double L_mem(){return l_mem;}

            inline double L_cat_a(){return l_cat_a;}
            inline double L_mpl_a(){return l_mpl_a;}
            inline double L_gdl_a(){return l_gdl_a;}
            inline double L_channel_a(){return 2.0*l_channel_a;}
            inline double L_land_a(){return 2.0*l_land_a;}

            bool read_from_file;
            
            boost::shared_ptr<GridIn<dim>> grid_in;
            

        protected:


            GridBase();

            virtual ~GridBase();

            void initialize(ParameterHandler& param);





            typedef std::map< std::string, GridBase<dim>* > _mapFactory;



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


            virtual boost::shared_ptr<FuelCellShop::Geometry::GridBase<dim> > 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;
            }


            void print_material_id_and_boundary_id ( const Triangulation<dim> &triangulation ) const;



            std::string mesh_type_name;
            std::string mesh_name;
            std::string mesh_type;
            unsigned int num_refine;



            double l_channel_c;
            double l_channelLength_c;
            double l_channelHeight_c;
            double l_channelEntrance_c;
            double l_channelExit_c;
            double l_land_c;
            double l_gdl_c;
            double l_mpl_c;
            //double l_cat_c;                                                           //##
            std::vector<double> l_cat_c;
            double l_mem;
            double l_cat_a;
            double l_mpl_a;
            double l_gdl_a;
            double l_channel_a;
            double l_land_a;
            
            double l_cube;



            unsigned int num_vert;

            unsigned int num_c_Channel;
            unsigned int num_c_GDL;
            unsigned int num_c_MPL;
            unsigned int num_c_CL;

            unsigned int num_membrane;
            unsigned int num_a_CL;
            unsigned int num_a_MPL;
            unsigned int num_a_GDL;





            unsigned int test_mid;
            unsigned int c_CC_mid;
            unsigned int c_GC_mid;
            unsigned int c_GDL_mid;
            unsigned int c_MPL_mid;
            std::vector<unsigned int> c_CL_mid;
            unsigned int membrane_mid;
            unsigned int a_CL_mid;
            unsigned int a_MPL_mid;
            unsigned int a_GDL_mid;
            unsigned int a_CC_mid;
            unsigned int a_GC_mid;





            unsigned int c_Ch_Inlet_bid;    
            unsigned int c_Ch_Outlet_bid;
            unsigned int c_Ch_base_bid;
            unsigned int c_Ch_roof_bid;
            unsigned int c_Ch_GDL_bid;
            unsigned int c_BPP_GDL_bid;
            unsigned int c_GDL_CL_bid;
            unsigned int c_CL_Membrane_bid;

            unsigned int c_GDL_MPL_bid;
            unsigned int c_MPL_CL_bid;

            unsigned int a_Membrane_CL_bid;
            unsigned int a_CL_GDL_bid;
            unsigned int a_GDL_BPP_bid;
            unsigned int a_GDL_Ch_bid;

            unsigned int a_MPL_GDL_bid;
            unsigned int a_CL_MPL_bid;
            unsigned int a_Ch_Inlet_bid;    
            unsigned int a_Ch_Outlet_bid;
            unsigned int a_Ch_base_bid;
            unsigned int a_Ch_roof_bid;



            double r_agg;

            double delta_agg;

            unsigned int r_agg_mid;

            unsigned int delta_agg_mid;

            unsigned int r_delta_bid;

            unsigned int delta_bid;

            Point<dim> center;
        };

    }//namespace Geometry

}//namespace FuelCell

#endif