response_water_sorption.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 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: response_water_sorption.h
// - Description: This file defines response class computing amount of water sorbed in the catalyst layers.
// - Developers: Marc Secanell Gallart and Madhur Bhaiya
// - $Id:
//
// ----------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__RESPONSE_WATER_SORPTION_H
#define _FUELCELLSHOP__RESPONSE_WATER_SORPTION_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 <exception>      // std::exception

// Include OpenFCST routines:
#include "application_core/fcst_variables.h"
#include "application_core/system_management.h"

#include "equations/equation_base.h"
#include "equations/sorption_source_terms.h"

#include "layers/base_layer.h"
#include "layers/catalyst_layer.h"

#include "postprocessing/base_response.h"

using namespace dealii;

namespace FuelCellShop
{

    namespace PostProcessing
    {

        template <int dim>
        class WaterSorptionResponse : public BaseResponse<dim>
        {
        public:            

            WaterSorptionResponse(const FuelCell::SystemManagement& sm,
                                  const FuelCellShop::Equation::SorptionSourceTerms<dim>* sst)
            :
            BaseResponse<dim>(sm),
            sorption_source(sst)
            {}
            
            ~WaterSorptionResponse() {}
            
            void initialize(ParameterHandler& param) 
            {                
                if ( this->system_management->solution_in_userlist("membrane_water_content") )
                {
                    lambda.solution_index = this->system_management->solution_name_to_index("membrane_water_content"); 
                    lambda.fetype_index = this->system_management->block_info->base_element[lambda.solution_index];
                    lambda.indices_exist = true;
                }
                else
                    throw std::runtime_error("membrane_water_content variable required for WaterSorptionResponse");
                
                if ( this->system_management->solution_in_userlist("water_molar_fraction") )
                {
                    x_w.solution_index = this->system_management->solution_name_to_index("water_molar_fraction"); 
                    x_w.fetype_index = this->system_management->block_info->base_element[x_w.solution_index];
                    x_w.indices_exist = true;
                }
                else
                    throw std::runtime_error("water_molar_fraction variable required for WaterSorptionResponse");
                    
                if ( this->system_management->solution_in_userlist("temperature_of_REV") )
                {
                    tRev.solution_index = this->system_management->solution_name_to_index("temperature_of_REV"); 
                    tRev.fetype_index = this->system_management->block_info->base_element[tRev.solution_index];
                    tRev.indices_exist = true;
                }
                
                time_k = sorption_source->get_time_constant();
            }
            


            void compute_responses(const typename DoFApplication<dim>::CellInfo& info,
                                   FuelCellShop::Layer::BaseLayer<dim>* const layer, 
                                   std::map<FuelCellShop::PostProcessing::ResponsesNames, double>& respMap) const
            {
                respMap.clear();
                
                // Make sure you are in a CL
                const std::type_info& base_layer = layer->get_base_type();
                const std::type_info& CatalystLayer = typeid(FuelCellShop::Layer::CatalystLayer<dim>);
                AssertThrow(base_layer == CatalystLayer,
                            ExcMessage("WaterSorptionResponse can only be used with a CatalystLayer object"));
                                
                // Get number of quadrature points in the cell:
                unsigned int n_q_points_cell = (info.fe(lambda.fetype_index)).n_quadrature_points;
                
                // Find where the solution is stored in info:
                unsigned int solIndex = info.global_data->find_vector("Solution");
                
                // Create CL:
                FuelCellShop::Layer::CatalystLayer<dim>* catalyst_layer = dynamic_cast< FuelCellShop::Layer::CatalystLayer<dim>* >(layer);
                
                double rhoDry = catalyst_layer->get_electrolyte()->get_density();
                double EW = catalyst_layer->get_electrolyte()->get_EW();
                catalyst_layer->get_electrolyte()->set_water_molar_fraction( FuelCellShop::SolutionVariable(&info.values[solIndex][x_w.solution_index], water_molar_fraction) );
                if (tRev.indices_exist)
                    catalyst_layer->get_electrolyte()->set_temperature( FuelCellShop::SolutionVariable(&info.values[solIndex][tRev.solution_index], temperature_of_REV) );
                
                std::vector<double> lambdaValue( info.values[solIndex][lambda.solution_index] );
                
                std::vector<double> lambdaEq(n_q_points_cell, 0.0);
                catalyst_layer->get_electrolyte()->sorption_isotherm(lambdaEq);
                
                for (unsigned int q = 0; q < n_q_points_cell; ++q){
                    double JxW = info.fe(lambda.fetype_index).JxW(q);
                    respMap[FuelCellShop::PostProcessing::ResponsesNames::sorbed_water] += ( ( ((time_k*rhoDry)/EW)*(lambdaEq[q] - lambdaValue[q]) ) * JxW );       
                }
            }
            void compute_responses(std::vector< FuelCellShop::SolutionVariable > solution_variables,
                                   const typename DoFApplication<dim>::CellInfo& info,
                                   FuelCellShop::Layer::BaseLayer<dim>* const layer, 
                                   std::map<FuelCellShop::PostProcessing::ResponsesNames, double>& resp) const
            {
                throw std::runtime_error("WaterSorptionResponse::compute_responses(solution_variables, info, layer, resp) not implemented");
            }
            //
        private:
            const FuelCellShop::Equation::SorptionSourceTerms<dim>* sorption_source;
            
            double time_k;
            
            FuelCellShop::Equation::VariableInfo lambda;
            
            FuelCellShop::Equation::VariableInfo x_w;
            
            FuelCellShop::Equation::VariableInfo tRev;
        };
        
    }   
}

#endif