spec_head.hpp

Go to the documentation of this file.

//   GAMBIT: Global and Modular BSM Inference Tool
//   *********************************************

#ifndef __spec_hpp__
#define __spec_hpp__

#include "gambit/Elements/subspectrum.hpp"
#include "gambit/Models/SpectrumContents/subspectrum_contents.hpp"

// Particle database access
#define PDB Models::ParticleDB()        

namespace Gambit
{

   template <class>
   class Spec;

   class DummyModel {};
   class DummyInput {};
 
   template< typename T >
   struct always_false { 
       enum { value = false };  
   };

   template <class T>
   struct SpecTraits
   {
      static_assert(always_false<T>::value, "Failed to find appropriate specialisation of SpecTraits! Did you define one along with your SubSpectrum wrapper? If so, please be sure that the template parameter matches the name of your wrapper class.");
   };

   struct DefaultTraits
   {
      typedef DummyModel Model;
      typedef DummyInput Input;
   };

   template<class,class> class SetMaps;
   template<class,class> class FptrFinder;  
   template<class,class> class CallFcn; 

   template<class Contents>
   class VerifyContents
   {
      public:
        VerifyContents(const SubSpectrum& spec)
        {
          Contents contents;
          contents.verify_contents(spec); 
        }
   };

   // CRTP used to allow access to some special data members of the derived class.
   // Various inherited classes are just used to factor out code, some of which
   // doesn't need to be templated.
   template <class DerivedSpec>
   class Spec : public SubSpectrum
   { 
     template <class,class>
     friend class FptrFinder;
 
     public:
         typedef DerivedSpec D;
         typedef Spec<D> Self;

         typedef typename SpecTraits<D>::Contents Contents;
         typedef typename SpecTraits<D>::Model    Model;
         typedef typename SpecTraits<D>::Input    Input;

         typedef MapTypes<D,MapTag::Get> MTget; 
         typedef MapTypes<D,MapTag::Set> MTset; 

         std::string getName() const { return SpecTraits<D>::name(); };

         /* Getters and checker declarations for parameter retrieval with zero, one, and two indices */
         bool   has(const Par::Tags, const str&, const SpecOverrideOptions=use_overrides, const SafeBool=SafeBool(true)) const;
         double get(const Par::Tags, const str&, const SpecOverrideOptions=use_overrides, const SafeBool=SafeBool(true)) const;
         bool   has(const Par::Tags, const str&, const int, const SpecOverrideOptions=use_overrides, const SafeBool=SafeBool(true)) const;
         double get(const Par::Tags, const str&, const int, const SpecOverrideOptions=use_overrides, const SafeBool=SafeBool(true)) const;
         bool   has(const Par::Tags, const str&, const int, const int, const SpecOverrideOptions=use_overrides) const;
         double get(const Par::Tags, const str&, const int, const int, const SpecOverrideOptions=use_overrides) const;

         /* Setter declarations, for setting parameters in a derived model object,
            and for overriding model object values with values stored outside
            the model object (for when values cannot be inserted back into the
            model object)
            Note; these are NON-CONST */
         void set(const Par::Tags, const double, const str&, const SafeBool=SafeBool(true));
         void set(const Par::Tags, const double, const str&, const int, const SafeBool=SafeBool(true));
         void set(const Par::Tags, const double, const str&, const int, const int);

         static const std::map<Par::Tags,MapCollection<MTget>> fill_getter_maps()
         {     
            std::map<Par::Tags,MapCollection<MTget>> tmp;
            return tmp;
         }
         static const std::map<Par::Tags,MapCollection<MTset>> fill_setter_maps()
         {     
            std::map<Par::Tags,MapCollection<MTset>> tmp;
            return tmp;
         }

         static int index_offset() { return 0; } 


      private:
         static int get_index_offset() { return D::index_offset(); }

       
         static void getter_maps_fill_tags(std::map<Par::Tags,MapCollection<MTget>>& in)
         {     
            std::vector<Par::Tags> all = Par::get_all();
            for(std::vector<Par::Tags>::iterator it = all.begin(); it!=all.end(); ++it)
            {
              in[*it]; // insert tag key if missing
            }
         }
         static void setter_maps_fill_tags(std::map<Par::Tags,MapCollection<MTset>>& in)
         {     
            std::vector<Par::Tags> all = Par::get_all();
            for(std::vector<Par::Tags>::iterator it = all.begin(); it!=all.end(); ++it)
            {
              in[*it]; // insert tag key if missing
            }
         }


         static const std::map<Par::Tags,MapCollection<MTget>> final_fill_getter_maps()
         {  
            // Fill from (possibly overriden) derived class filler function
            std::map<Par::Tags,MapCollection<MTget>> tmp = D::fill_getter_maps();
            // Add in any missing tags
            getter_maps_fill_tags(tmp);    
            return tmp;
         }
         static const std::map<Par::Tags,MapCollection<MTset>> final_fill_setter_maps()
         {     
            // Fill from (possibly overriden) derived class filler function
            std::map<Par::Tags,MapCollection<MTset>> tmp = D::fill_setter_maps();
            // Add in any missing tags
            setter_maps_fill_tags(tmp);    
            return tmp;
         }

         
      public: 

         Spec() { static VerifyContents<Contents> runonce(*this); };
       
         virtual ~Spec() {};
    
         virtual std::unique_ptr<SubSpectrum> clone() const       
         {
           return std::unique_ptr<SubSpectrum>(
              new DerivedSpec(static_cast<DerivedSpec const &>(*this))
              );
         }
 

         DummyModel dummymodel;
         DummyInput dummyinput;
         Model& get_Model() { return dummymodel; }
         Input& get_Input() { return dummyinput; }
         const Model& get_Model() const { return dummymodel; }
         const Input& get_Input() const { return dummyinput; }

         Model& model() { return static_cast<DerivedSpec*>(this)->get_Model(); }
         const Model& model() const { return static_cast<const DerivedSpec*>(this)->get_Model(); }

         Input& input() { return static_cast<DerivedSpec*>(this)->get_Input(); }
         const Input& input() const { return static_cast<const DerivedSpec*>(this)->get_Input(); }


         
         typedef std::map<Par::Tags,MapCollection<MTget>> GetterMaps; 
         typedef std::map<Par::Tags,MapCollection<MTset>> SetterMaps; 
         static const GetterMaps getter_maps;
         static const SetterMaps setter_maps;

   };

   template <class D>
   const typename Spec<D>::GetterMaps Spec<D>::getter_maps(Spec<D>::final_fill_getter_maps());

   template <class D>
   const typename Spec<D>::SetterMaps Spec<D>::setter_maps(Spec<D>::final_fill_setter_maps());
 
} // end namespace Gambit

// Undef the various helper macros to avoid contaminating other files
#undef PDB

#endif