agglomerate_base.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
// C++ Interface: agglomerate_base.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_BASE_H
#define _FUELCELLSHOP__LAYER__AGGLOMERATE_BASE_H

#include "fcst_constants.h"
#include "catalyst_base.h"
#include "catalyst_support_base.h"
#include "polymer_electrolyte_material_base.h"
#include "base_kinetics.h"
#include "tafel_kinetics.h"

#include "platinum.h"
#include "nafion.h"

#include <vector>
#include <string.h>

//Liquid water
#include "PureLiquid.h"

class AnalyticalAgglomerateTest;

namespace FuelCellShop
{
namespace MicroScale
{
        class AgglomerateBase
        {

        friend class ::AnalyticalAgglomerateTest;

        public:
                AgglomerateBase()
                {
                        //Constants
                        R = Constants::R();
                        F = Constants::F();
                        permittivity_0 = Constants::E0() *1e-2; // cm
                        pi = Constants::Pi();
                        maxRadialDimension = 1.0;
                        IC_loaded = false;
                }

                virtual ~AgglomerateBase() {};

                virtual void set_structure ( FuelCellShop::Material::CatalystSupportBase*,
                                                                FuelCellShop::Material::CatalystBase*,
                                                                FuelCellShop::Material::PolymerElectrolyteBase*,
                                                                double A, double r, double delta, double epsilon ) = 0;

                void set_kinetics ( FuelCellShop::Kinetics::BaseKinetics* kin )
                {
                        kinetics = kin;
                };

                virtual double compute_current (double &E_r) = 0;

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

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

                inline void set_P ( double P_Tot )
                {
                        P = P_Tot;
                }

                inline void set_T ( double Temp )
                {
                        T = Temp;
                }

                inline void setLoadingWeigths(std::vector<double> weigths)
                {
                        loadingWeigths = weigths;
                }
                
                inline void set_conductivity_factor ( double temp )
                {
                        cond_factor = temp;
                }
                
                inline bool analytical_derivatives() 
                {
                        return analyticalDerivatives;
                }
                
                inline void load_initial_guess(std::vector<std::vector<double>> IC){
                    initial_data = IC;
                    IC_loaded = true;
                }

                inline bool guess_not_loaded(){
                    return !IC_loaded;
                }

                void deep_copy_pointers();



                std::vector<std::vector<double>> results;
                std::vector<std::string> column_titles;

    protected:



                inline void setAV(double newAV){
                AV = newAV;
        }

        double getAV(double location);

        void setUpLoadings();

        void interpolate_initial_data(double z[], double &x, double left_pos, double right_pos, std::vector<double> left_data, std::vector<double> right_data);

        bool use_initial_data(double z[], double &x);

                // Constants & V.ariables
                double permittivity_0;
                double pi;
                double F;
                double R;

                // Operating Conditions
                double P;
                double T;

                // Kinetic parameters
                std::vector<double> loadingWeigths;
                std::vector<double> actualLoadings;
                std::vector<double> loadingRadii;
                double AV;

                double maxRadialDimension;



                bool IC_loaded;

                bool analyticalDerivatives;

                FuelCellShop::Material::CatalystSupportBase *catalyst_support;

                FuelCellShop::Material::CatalystBase *catalyst;

                FuelCellShop::Material::PolymerElectrolyteBase *electrolyte;

                FuelCellShop::Kinetics::BaseKinetics *kinetics;
                
                std::vector<double> co2_final;
                std::vector<double> mesh_final;
                
                double cond_factor;

        double r_agg;

        double delta_agg;

        double epsilon_agg;

        double c_R;

        double phi_M;

        double phi_S;

        double interface;

        double D_R_N;

        double H_R_N;

        double R_tol;

        std::vector<VariableNames> sol_names;

        std::map<VariableNames, SolutionVariable> solutions;
        VariableNames reactant;
        int sol_index;

        std::vector< std::vector<double>> initial_data;
        };
}
}

#endif