base_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: base_layer.h
// - Description: This is a base class for all available FCST layers
// - Developers: Marc Secanell Gallart,    University of Alberta
//               Madhur Bhaiya, University of Alberta
//               Valentin N. Zingan, U of A
// - $Id: base_layer.h 2605 2014-08-15 03:36:44Z secanell $
//
// ----------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__BASE__LAYER_H
#define _FUELCELLSHOP__BASE__LAYER_H

// Include deal.II classes
#include <deal.II/base/parameter_handler.h>
#include <deal.II/base/point.h>
#include <deal.II/base/function.h>
#include <deal.II/lac/vector.h>
#include <deal.II/fe/fe_values.h>

//Include STL
#include <cmath>
#include <iostream>

// Include OpenFCST routines:
#include <application_core/fcst_variables.h>
#include <application_core/system_management.h>
#include <utils/fcst_utilities.h>

using namespace dealii;

namespace FuelCellShop
{
    

    namespace Layer
    {
        template <int dim>
        class BaseLayer : public Subscriptor
        {
        public:

            
            virtual void set_derivative_flags(const std::vector<VariableNames>& flags)
            {
                this->derivative_flags = flags;
            }
            
            void set_position(const std::vector<Point<dim> > &p)
            {
                point = p;
            }
            

            virtual void  set_local_material_id(const unsigned int& id){

                AssertThrow(std::find(std::begin(material_ids), std::end(material_ids), id) != std::end(material_ids), ExcMessage("Material id not found in layer."));
                local_material_id_ = id;
            }

            inline void unset_local_material_id(){
                                //Ideally a material id will be 0 to 255, so we assume the max integer value will be an invalid key
                local_material_id_ = std::numeric_limits<int>::max(); 
            }
                        
            virtual void set_constant_solution(const double& value, const VariableNames& name)
            {
                constant_solutions[name] = value;
            }
            
            virtual void set_solution(const std::vector< SolutionVariable >&)
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }
            
            

                
            bool belongs_to_material(const unsigned int material_id);
            
            
            inline const std::string& name_layer() const
            {
              return name;
            }

            virtual const std::type_info& get_base_type() const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }    
            virtual void print_layer_properties() const;
            
            virtual bool test_layer()
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
                
                return false;
            }
            
            std::vector<unsigned int> get_material_ids()
            {
             return material_ids;
            }

            inline unsigned int local_material_id() const
            {
                AssertThrow(std::find(std::begin(material_ids), std::end(material_ids), local_material_id_) != std::end(material_ids),
                        ExcMessage("The material id for layer " + name + " has not been set."));

                return local_material_id_;
            }
        
        protected:
            


            BaseLayer()
            {};
    
            BaseLayer(const std::string& name);
            
            virtual ~BaseLayer();
            
            virtual void declare_parameters (const std::string &object_name, ParameterHandler &param) const
            {
                param.enter_subsection("Fuel cell data");
                {
                    param.enter_subsection(object_name);
                    {
                        param.declare_entry("Material id",
                                            "1",
                                            Patterns::List(Patterns::Integer(0, 255)),
                                            "Id number used to identify this layer");
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
            }
            
            virtual void declare_parameters (ParameterHandler &param) const
            {
                this->declare_parameters(this->name,param);
            }
                         
            virtual void set_parameters(const std::string &object_name, 
                                       const std::vector<std::string>& name_dvar,
                                       const std::vector<double>& value_dvar,
                                       ParameterHandler &param)
            {
                param.enter_subsection("Fuel cell data");
                {
                    param.enter_subsection(object_name);
                    {
                        // ADD VARIABLES IF NEEDED
                        //param.set(name_var, value_param);
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
            };
            virtual void set_parameters(const std::vector<std::string>& name_dvar,
                                        const std::vector<double>& value_dvar,
                                        ParameterHandler &param)
            {
                param.enter_subsection("Fuel cell data");
                {
                    param.enter_subsection(this->name);
                    {
                        // ADD VARIABLES IF NEEDED
                        //param.set(name_var, value_param);
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
            };
            
            virtual void initialize (ParameterHandler &param);
            
            


            const std::string name;
            std::vector<unsigned int> material_ids; 
            std::vector<Point<dim> > point;
            std::vector<VariableNames> derivative_flags;
            std::map< VariableNames, double > constant_solutions;

            

        private:
            unsigned int local_material_id_;

        };
        
    } // Layer
    
}  // FuelCellShop
    
    #endif // _FUELCELLSHOP__GENERIC__LAYER_H