fcst_variables.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: fcst_variables.h
// - Description: This structure keeps a name of an FCST solution variable
//                and
//                values of this variable in the quadrature points of a mesh entity
// - Developers: Phil Wardlaw,       University of Alberta
//               Madhur Bhaiya,      University of Alberta
//               Valentin N. Zingan, University of Alberta
//
// ------------------------------------------------------------------------------------------------

#ifndef _FCST_FUELCELLSHOP_SOLUTION_VARIABLE_H_
#define _FCST_FUELCELLSHOP_SOLUTION_VARIABLE_H_
//-- C++ Standard libraries
#include <cmath>
#include <iostream>

//-- dealII
#include <deal.II/base/point.h>
#include <deal.II/base/function.h>
#include <deal.II/lac/vector.h>
#include <deal.II/fe/fe_values.h>

//--OpenFCST
#include <application_core/system_management.h>

using namespace dealii;

namespace FuelCellShop
{
    struct SolutionVariable
    {
        

        
        SolutionVariable()
        {
            data = NULL;
            initialized = false;
            initialized_default_data = false;
            initialized_data = false;
        }
        
        SolutionVariable(const std::vector<double>* data_in, const VariableNames& name_in)
        {
            data = data_in;
            name = name_in;
            initialized = true;
            initialized_default_data = false;
            initialized_data = true;
        }
        
        SolutionVariable(const double& value, const unsigned int& length, const VariableNames& name_in)
        {
            data = NULL;
            default_data = std::vector<double>(length, value);
            name = name_in;
            initialized = true;
            initialized_default_data = true;
            initialized_data = false;
        }
        
        SolutionVariable(const std::vector<double>& data_in, const VariableNames& name_in)
        {
            data = NULL;
            default_data = data_in;
            name = name_in;
            initialized = true;
            initialized_default_data = true;
            initialized_data = false;
        }
        
        


        const std::vector<double>& get_default_data() const
        {
            Assert( initialized_default_data, ExcMessage("default_data is not initialized") );
            return default_data;
        }
        
        const std::vector<double>* get_data() const
        {
            Assert( initialized_data, ExcMessage("data is not initialized") );
            return data;
        }
        
        VariableNames get_variablename() const
        {
            Assert( initialized, ExcMessage("SolutionVariable not initialized !!!") );
            return name;
        }
        
        const bool is_initialized() const
        {
            return initialized;
        }
        
        const bool is_default_data_initialized() const
        {
            return initialized_default_data;
        }
        
        const bool is_data_initialized() const
        {
            return initialized_data;
        }
        
        unsigned int size() const
        {
            unsigned int answer = 0;
            //If initialized and pointer is not NULL
            if (initialized && (data != NULL))
                answer = data->size();
            else if (initialized && (data == NULL))
                answer = default_data.size();
            
            return answer;
        }
        
        

        
        const double& operator[](const unsigned int& i) const
        {
            Assert( initialized, ExcMessage("SolutionVariables struct is not initialized !!!") );
            
            if (data != NULL)
            {
                Assert( i < data->size(), ExcMessage("Index is out of range in operator[] for SolutionVariables struct.") );
                return data->at(i);
            }
            else if (data == NULL)
            {
                Assert( i < default_data.size(), ExcMessage("Index is out of range in operator[] for SolutionVariables struct.") );
                return default_data.at(i);
            }
        }
        
        friend SolutionVariable operator* (const SolutionVariable& left,
                                           const double&           right)
        {
            Assert( left.is_default_data_initialized(), ExcMessage("SolutionVariable left operand default_data is not initialized") );
            
            std::vector<double> tmp(left.size());
            
            const VariableNames name = left.get_variablename();
            
            if( left.is_default_data_initialized() && !left.is_data_initialized() )
            {
                for(unsigned int q = 0; q < tmp.size(); ++q)
                    tmp[q] = left.get_default_data().at(q);
                
                for(unsigned int q = 0; q < tmp.size(); ++q)
                    tmp[q] *= right;
                
                return SolutionVariable(tmp,
                                        name);
            }
            else if( !left.is_default_data_initialized() && left.is_data_initialized() )
            {
                AssertThrow( false, ExcNotImplemented() );
            }
            else
            {
                AssertThrow( false, ExcInternalError() );
            }
        }
        
        friend SolutionVariable operator* (const double&           left,
                                           const SolutionVariable& right)
        {
            Assert( right.is_default_data_initialized(), ExcMessage("SolutionVariable right operand default_data is not initialized") );
            
            std::vector<double> tmp(right.size());
            
            const VariableNames name = right.get_variablename();
            
            if( right.is_default_data_initialized() && !right.is_data_initialized() )
            {
                for(unsigned int q = 0; q < tmp.size(); ++q)
                    tmp[q] = right.get_default_data().at(q);
                
                for(unsigned int q = 0; q < tmp.size(); ++q)
                    tmp[q] *= left;
                
                return SolutionVariable(tmp,
                                        name);
            }
            else if( !right.is_default_data_initialized() && right.is_data_initialized() )
            {
                AssertThrow( false, ExcNotImplemented() );
            }
            else
            {
                AssertThrow( false, ExcInternalError() );
            }
        }
        
        friend SolutionVariable operator/ (const SolutionVariable& left,
                                           const double&           right)
        {
            Assert( left.is_default_data_initialized(), ExcMessage("SolutionVariable left operand default_data is not initialized") );
            
            std::vector<double> tmp(left.size());
            
            const VariableNames name = left.get_variablename();
            
            if( left.is_default_data_initialized() && !left.is_data_initialized() )
            {
                for(unsigned int q = 0; q < tmp.size(); ++q)
                    tmp[q] = left.get_default_data().at(q);
                
                for(unsigned int q = 0; q < tmp.size(); ++q)
                    tmp[q] /= right;
                
                return SolutionVariable(tmp,
                                        name);
            }
            else if( !left.is_default_data_initialized() && left.is_data_initialized() )
            {
                AssertThrow( false, ExcNotImplemented() );
            }
            else
            {
                AssertThrow( false, ExcInternalError() );
            }
        }
        
        
        
    private:
        

        
        std::vector<double> default_data;
        
        const std::vector<double>* data;
        
        VariableNames name;
        
        bool initialized;
        
        bool initialized_default_data;
        
        bool initialized_data;
        
        
    };
    

    
    static bool is_phiM(const SolutionVariable& sol_var)
    {
        return (sol_var.get_variablename() == protonic_electrical_potential);
    }
    
    static bool is_phiS(const SolutionVariable& sol_var)
    {
        return (sol_var.get_variablename() == electronic_electrical_potential);
    }
    
    
    
    class SolutionMap : private std::map< VariableNames, SolutionVariable>
    {
    public:
        
        void push_back(const SolutionVariable& a){
            
            
            //Check that the key hasn't already been entered
            if (this->count(a.get_variablename()) > 0)
                throw std::runtime_error("You have already added a SolutionVariable of corresponding VariableNames type to SolutionMap");
            
            
            //add the variable
            this->operator [](a.get_variablename()) = a;
        }
        
        SolutionVariable& at(VariableNames key){
            return std::map<VariableNames, SolutionVariable>::at(key);
        }
        
        void clear(){
            std::map<VariableNames, SolutionVariable>::clear();
        }
        
        void erase(const VariableNames& v){
            std::map<VariableNames, SolutionVariable>::erase(v);
        }
        
        
        bool has(const VariableNames& v) const{
            bool answer = false;
            
            if(this->count(v) >0)
                answer = true;
            
            return answer;
        }
        
        SolutionVariable pop(const VariableNames& v){
            SolutionVariable temp = this->at(v);
            std::map<VariableNames, SolutionVariable>::erase(v);
            return temp;
        }
    };
}
#endif