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
// - $Id: fcst_variables.h 2605 2014-08-15 03:36:44Z secanell $
//
// ------------------------------------------------------------------------------------------------

#ifndef _FCST_FUELCELLSHOP_SOLUTION_VARIABLE_H_
#define _FCST_FUELCELLSHOP_SOLUTION_VARIABLE_H_

#include <cmath>
#include <iostream>

#include <base/parameter_handler.h>
#include <base/point.h>
#include <base/function.h>
#include <lac/vector.h>
#include <fe/fe_values.h>

#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