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
// - $Id: base_layer.h 1373 2013-08-21 00:34:53Z madhur $
//
// ----------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__BASE__LAYER_H
#define _FUELCELLSHOP__BASE__LAYER_H

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

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

// Include OpenFCST routines:
#include "utils/fcst_variables.h"
#include "utils/system_management.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(std::vector<Point<dim> > &p)
            {
                point = p;
            }
            
                        
            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);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }
            

                
            bool belongs_to_material(const char material_id);
            
            inline const std::string& name_material();

            virtual const std::type_info& get_base_type() const
            {
                const std::type_info& info = typeid(*this);
                deallog << "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);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
                
                return false;
            }
            
            unsigned int get_material_id()
            {
             return 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::Integer(0),
                        "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;
            unsigned int material_id;
            std::vector<Point<dim> > point;
            std::vector<VariableNames> derivative_flags;
            std::map< VariableNames, double > constant_solutions;
        };
        
    } // Layer
    
}  // FuelCellShop
    
    #endif // _FUELCELLSHOP__GENERIC__LAYER_H