micro_scale_base.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2014 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: MicroScaleBase
// - Description: Base class for micro scale objects
// - Developers: Philip Wardlaw, University of Alberta
// - $Id: micro_scale_base.h 2605 2014-08-15 03:36:44Z secanell $
//
// ----------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__LAYER__MICROSCALE_BASE_H
#define _FUELCELLSHOP__LAYER__MICROSCALE_BASE_H


// The following definitions are necessary for compilation
// MultiScaleCL must be included in this header
// MultiScaleCL makes references to this class
// This class must be declared before we read MultiScaleCL file
namespace FuelCellShop
{
    namespace MicroScale
    {
        class MicroScaleBase;
    }
    namespace Layer
    {
        template <int dim>
        class MultiScaleCL;
    }
}




//FCST classes and utils
#include <utils/fcst_constants.h>
#include <utils/fcst_utilities.h>
#include <layers/multi_scale_CL.h>
#include <utils/logging.h>

//deal.ii classes and utils
#include  <deal.II/base/utilities.h>
#include  <deal.II/base/parameter_handler.h>

//STL containers, functions, streams
#include <vector>
#include <map>
#include <string.h>
#include <cmath>
#include <iostream>

//Boost shared pointer
#include <boost/shared_ptr.hpp>



namespace FuelCellShop
{
    namespace MicroScale
    {
        class MicroScaleBase
        {

            public:

            virtual ~MicroScaleBase() {};





            static void declare_MicroScale_parameters (ParameterHandler &param)
            {
                param.enter_subsection("MicroScale");
                std::string micro_type_list;

                for (typename FuelCellShop::MicroScale::MicroScaleBase::_mapFactory::iterator iterator = FuelCellShop::MicroScale::MicroScaleBase::get_mapFactory()->begin();
                        iterator != FuelCellShop::MicroScale::MicroScaleBase::get_mapFactory()->end(); iterator++)
                {
                    iterator->second->declare_parameters(param);
                    micro_type_list += iterator->first +"|";
                }

                micro_type_list =  micro_type_list.substr(0,  micro_type_list.size()-1);//Trim string 1 '|' char
                param.declare_entry("Microscale type", "IonomerAgglomerateAnalytical", Patterns::Selection(micro_type_list));
                param.leave_subsection();

            }

            static boost::shared_ptr<FuelCellShop::MicroScale::MicroScaleBase > create_MicroStructure (ParameterHandler &param,
                    FuelCellShop::Layer::MultiScaleCL<deal_II_dimension>* layer)
            {
                boost::shared_ptr<FuelCellShop::MicroScale::MicroScaleBase > pointer;

                param.enter_subsection("MicroScale");
                std::string concrete_name = param.get("Microscale type");


                typename FuelCellShop::MicroScale::MicroScaleBase::_mapFactory::iterator iterator = FuelCellShop::MicroScale::MicroScaleBase::get_mapFactory()->find(concrete_name);

                if (iterator != FuelCellShop::MicroScale::MicroScaleBase::get_mapFactory()->end())
                {
                    if (iterator->second)
                    {
                        pointer = iterator->second->create_replica();
                    }
                    else
                    {
                        FcstUtilities::log<<"Pointer not initialized"<<std::endl;
                        abort();
                    }
                }
                else
                {
                    FcstUtilities::log<<"Concrete name in FuelCellShop::MicroScale::MicroScaleBase::create_MicroStructure does not exist"<<std::endl;
                    abort();
                }

                pointer->set_layer(layer);
                pointer->initialize(param);
                pointer->set_structure();
                param.leave_subsection();
                return pointer;
            }



            virtual void set_solution(const std::map<VariableNames,SolutionVariable>&,const VariableNames&, const int&) = 0;

            virtual SolutionMap compute_current () = 0;

            virtual std::vector<double> compute_derivative_current ()
            {
                Assert(false, ExcPureFunctionCalled());
                return std::vector<double>(3, 0.0);
            }

            virtual bool has_derivatives() = 0;

            virtual std::string get_name() = 0;

            virtual void print_properties() = 0;


            virtual double aux_volume_fraction() = 0;


            /*
            * MicroScale will deep create new instances of pointers (kinetics, materials), to prevent race condition during parallel execution.
            */
            virtual void make_thread_safe(ParameterHandler &param, unsigned int thread_index) = 0;


        protected:

            /*
            * Protected member function, for storing address to catalyst layer which
            * constructed this MicroScale object.
            */
            void set_layer(FuelCellShop::Layer::MultiScaleCL<deal_II_dimension>* _layer){

                if(_layer!= NULL){
                    layer = _layer;
                }
                else
                {
                    std::string msg = "MultiScaleCl pointer passed to MicroScaleBase is NULL!";
                    throw std::runtime_error(msg);
                }
            }

            /*
            * Protected member pointer, for storing address to catalyst layer which
            * constructed this MicroScale object.
            */
            FuelCellShop::Layer::MultiScaleCL<deal_II_dimension>* layer;

            /*
            * Protected pure virtual member function for declaring parameters, must be implemented
            * by all children. Parameter structure is hierarchical, therefore children
            * should call their parent's declare parameter function from their own declare
            * parameter function.
            */
            virtual void declare_parameters (ParameterHandler &param) const =0;

            /*
            * Protected pure virtual member function for initializing parameters, must be implemented
            * by all children. Parameter structure is hierarchical, therefore children
            * should call their parent's initialize function from their own initialize function.
            */
            virtual void initialize (ParameterHandler &param) =0;


            /*
            *  Constructor
            */
            MicroScaleBase(){}


            /*
            * Protected member function for setting up MicroScale structure after object
            * initialization.
            *
            * Responsible for pulling structural properties from catalyst layer.
            *
            * Responsible for setting up pointer to materials and kinetics.
            *
            */
            virtual void set_structure () = 0;



            typedef std::map< std::string, MicroScaleBase* > _mapFactory;




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



            virtual boost::shared_ptr<MicroScaleBase> create_replica () = 0;

        };
    }
}

#endif