dopetypes.h

Go to the documentation of this file.

#ifndef DOPETYPES_H_
#define DOPETYPES_H_

#include <string>

#include "dopeexception.h"

namespace DOpE
{
  namespace DOpEtypes
  {
    //TODO typedef for dealii-boundary-type
    // (see changes after version 7.1 in deal.ii).

    enum RefinementType
    {
      global, fixed_fraction, fixed_number, optimized, finest_of_both
    };


    enum EETerms
    {
      primal_only, dual_only, mixed, mixed_control
    };

    enum WeightComputation
    {
      element_diameter, higher_order_interpolation, higher_order_computation, constant/*Not implemented!*/
    };

    enum ResidualEvaluation
    {
      strong_residual, smoothness_and_influence_factors
    };

    enum ControlType
    {
      stationary,
      initial,
      nonstationary
    };
    
    enum VectorStorageType
    {
      fullmem,
      store_on_disc,
      only_recent
    };

  }//End of namespace DOpEtypes


  template<typename C>
    inline std::string DOpEtypesToString(const C& /*t*/)
    {
      throw DOpEException("Not implemented!","DOpEtypesToString");
    }

    template <>
    inline std::string DOpEtypesToString(const DOpEtypes::VectorStorageType& t)
    {
      if( DOpEtypes::VectorStorageType::fullmem == t )
      {
        return "fullmem";
      }
      else if( DOpEtypes::VectorStorageType::store_on_disc == t )
      {
        return "store_on_disc";
      }
      else if( DOpEtypes::VectorStorageType::only_recent == t )
      {
        return "only_recent";
      }
      else
      {
        std::stringstream out;
        out<<"Unknown DOpEtypes::VectorStorageType"<< std::endl;
        out<<"Code given is "<< t<<std::endl;
        throw DOpEException(out.str(),"DOpEtypesToString<DOpEtypes::VectorStorageType");
      }
    }

    template <>
    inline std::string DOpEtypesToString(const DOpEtypes::ControlType& t)
    {
      if( DOpEtypes::ControlType::initial== t )
      {
        return "initial";
      }
      else if( DOpEtypes::ControlType::stationary == t )
      {
        return "stationary";
      }
      else if( DOpEtypes::ControlType::nonstationary == t )
      {
        return "nonstationary";
      }
      else
      {
        std::stringstream out;
        out<<"Unknown DOpEtypes::ControlType"<< std::endl;
        out<<"Code given is "<< t<<std::endl;
        throw DOpEException(out.str(),"DOpEtypesToString<DOpEtypes::ControlType");
      }
    }
    
    template <>
    inline std::string DOpEtypesToString(const DOpEtypes::RefinementType& t)
    {
      if( DOpEtypes::RefinementType::global== t )
      {
        return "global";
      }
      else if( DOpEtypes::RefinementType::fixed_fraction == t )
      {
        return "fixed_fraction";
      }
      else if( DOpEtypes::RefinementType::fixed_number == t )
      {
        return "fixed_number";
      }
      else if( DOpEtypes::RefinementType::optimized == t )
      {
        return "optimized";
      }
      else if( DOpEtypes::RefinementType::finest_of_both == t )
      {
        return "finest_of_both";
      }
      else
      {
        std::stringstream out;
        out<<"Unknown DOpEtypes::RefinementType"<< std::endl;
        out<<"Code given is "<< t<<std::endl;
        throw DOpEException(out.str(),"DOpEtypesToString<DOpEtypes::RefinementType>");
      }
    }

}//End of Namespace DOpE

#endif /* DOPETYPES_H_ */