agglomerate_CL.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
// C++ Interface: agglomerate_CL.h
//
// Description: Class characterizing the catalyst layer and defining effective properties
//
// Authors: Marc Secanell <secanell@ualberta.ca,
//               Peter Dobson <pdobson@ualberta.ca>, (C) 2011
//              University of Alberta
//
// Copyright: See COPYING file that comes with this distribution
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__LAYER__AGGLOMERATE_CL__LAYER_H
#define _FUELCELLSHOP__LAYER__AGGLOMERATE_CL__LAYER_H

#include <boost/smart_ptr.hpp>

// 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 "base/timer.h"

// Include FCST classes
#include "utils/fcst_constants.h"
#include "utils/fcst_utilities.h"
#include "utils/fcst_db.h"

#include "layers/conventional_CL.h"
#include "layers/agglomerate_base.h"
#include "layers/agglomerate_ionomer_sun.h"


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

namespace FuelCellShop
{
    namespace Layer
    {
        template <int dim>
        class AgglomerateCL :
        public ConventionalCL<dim>
        {
        public:
            
            static const std::string concrete_name;
            


            AgglomerateCL ( );
            
            AgglomerateCL ( std::string name );
            
            ~AgglomerateCL();
            
            void declare_parameters ( ParameterHandler &param ) const
            {
               declare_parameters(this->name, param);                
            }
            
            void set_parameters ( const std::vector<std::string>& name_dvar, 
                                  const std::vector<double>& value_dvar, 
                                  ParameterHandler &param ) const
            {
               set_parameters(name_dvar, value_dvar, this->name, param);                
            }

            void initialize ( ParameterHandler &param );

            


            inline double get_n () const
            {
                return n_agg;
            }
            
            virtual void current_density ( std::vector<double>& current );
            
            virtual void current_density (std::vector<double>& current, std::vector<double>& effectiveness );           
            
            virtual void derivative_current_density ( std::map< VariableNames, std::vector<double> >& );
            
            virtual void print_layer_properties() const;
            
            inline void return_mesh_final(std::vector<double>& temp, std::vector<double>& temp1)
            { 
                temp = mesh_final;
                temp1 = co2_final;
                mesh_final.clear();
            }    
            
            inline void set_mesh(std::vector<double>& temp)
            { mesh_final = temp;}       
             

           
        protected:


            //AgglomerateCL(const std::string& cl_section_name);

            /*AgglomerateCL(const std::string& name, 
                          FuelCellShop::Material::PolymerElectrolyteBase*,
                          FuelCellShop::Material::CatalystSupportBase*,
                          FuelCellShop::Material::CatalystBase*);   
            */
            void declare_parameters (const std::string& cl_section_name, 
                                     ParameterHandler &param) const;
                                     
            void set_parameters ( const std::vector<std::string>& name_dvar, 
                                  const std::vector<double>& value_dvar, 
                                  const std::string& cl_section_name, 
                                  ParameterHandler &param ) const;
            


            virtual boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > create_replica (const std::string &cl_section_name)
            {
                return boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > (new FuelCellShop::Layer::AgglomerateCL<dim> (cl_section_name));
            }   



            static AgglomerateCL<dim> const* PROTOTYPE;
            


            void compute_void_fraction();
            
            void initialize_aggs();          
            
            boost::shared_ptr<FuelCellShop::MicroScale::AgglomerateBase>  get_agg();
            
            double compute_n() const;
            
            //double derivative_n_agg() const;
            
            double compute_thickness_agg ();
            
            double epsilon_N_agg ( const double delta_agg ) const;
            
            double depsilonN_dthickness_agg ( const double thickness_agg ) const;
            
            double micro_scale_current( boost::shared_ptr <FuelCellShop::MicroScale::AgglomerateBase> &_agg ,  std::map<VariableNames ,SolutionVariable>& solutionMap, const unsigned int& index, double& E_r);
            
            void choose_agglomerate(boost::shared_ptr <FuelCellShop::MicroScale::AgglomerateBase> &agg_);
            
            void solve_current_derivatives_average(std::map< VariableNames, std::vector<double> >& Dcurrent);
            
            void solve_current_derivatives_at_each_node(std::map< VariableNames, std::vector<double> >& Dcurrent);
            
            /*
             * Function for checking if our initial guess data is "up to date" within a certain tolerance.
             */
            bool check_micro_scale_initial_guess(const double &x_O2, const double &phi_m, const double &phi_s, 
                                                 const double lambda, const double radius, const double film_thickness, 
                                                 const double porosity);

            
            /*
             * Function for updating micro_scale_initial_guess, returns true if successful.
             */
            bool get_micro_scale_initial_guess(const double &x_O2, const double &phi_m, const double &phi_s, const double lambda, 
                                               boost::shared_ptr <FuelCellShop::MicroScale::AgglomerateBase> &_agg, const double radius,
                                               const double film_thickness, const double porosity);
            
            /*
             * Function for updating the database with new data.
             */
            void commit_data_to_db(std::vector<std::vector<double>> agg_data, std::vector<std::string> agg_column_titles, const double &x_R,
                                   const double &phi_m, const double &phi_s, const double lambda, const double radius, const double film_thickness, const double porosity);
            


            bool aggs_initialized;
                     
            std::string type_agg;
            
            std::string comp_agg;
            
            std::vector<double> agglomerateLoadingWeigths;
            
            bool water_agg;
            
            std::string solver_agg;
            
            bool average_cell_current;

            double r_agg;

            double thickness_agg;

            double epsilon_agg;
            
            double n_agg;

            double pi;

            std::vector<double> mesh_final;
            
            std::vector<double> co2_final;
            
            double cond_factor;
            
            std::vector<boost::shared_ptr<FuelCellShop::MicroScale::AgglomerateBase>> aggs; //Up to three aggs needed for parallel computation
            
            std::vector<std::vector<double>> micro_scale_initial_guess;
            
            FcstUtilities::FCSTdatabase db;          
            
            //** Data for monitoring the relevance our current initial guess */
            double IC_x_R;
            double IC_phi_m;
            double IC_phi_s;
            double IC_lambda;
            double IC_tolerance;
            double IC_radius;
            double IC_film_thickness;
            double IC_porosity;

        };
        
    } // Layer
    
}  // FuelCellShop

#endif // _FUELCELLSHOP__LAYER__AGGLOMERATE_CL__LAYER_H