Add functionality to store auxiliary information in TFCSSimulationState

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSSimulationState.h

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef ISF_FASTCALOSIMEVENT_TFCSSimulationState_h
@@ -8,7 +8,9 @@
 #include <TObject.h>
 #include "ISF_FastCaloSimEvent/FastCaloSim_CaloCell_ID.h"
 #include <map>
+#include <unordered_map>
 #include <vector>
+#include <stdint.h>
 
 class CaloDetDescrElement;
 
@@ -17,6 +19,8 @@ namespace CLHEP
  class HepRandomEngine;
 }
 
+constexpr std::uint32_t operator"" _FCShash(char const* s, std::size_t count);
+
 class TFCSSimulationState:public TObject
 {
   public:
@@ -44,8 +48,11 @@ class TFCSSimulationState:public TObject
     void deposit(const CaloDetDescrElement* cellele, float E);
     
     void Print(Option_t *option="") const;
-    void set_SF(double mysf) {m_SF = mysf;}
-    double get_SF() {return m_SF;}
+    
+    //TODO: Remove explicit functions for SF here and use getAuxInfo<double>("SF"_FCShash) and setAuxInfo<double>("SF"_FCShash,mysf)
+    //directly in the energy parametrization
+    void set_SF(double mysf) {setAuxInfo<double>("SF"_FCShash,mysf);};
+    double get_SF() {return getAuxInfo<double>("SF"_FCShash);}
 
     void clear();
   private:
@@ -54,15 +61,83 @@ class TFCSSimulationState:public TObject
     int    m_Ebin;
     double m_Etot;
     // TO BE CLEANED UP! SHOULD ONLY STORE EITHER E OR EFRAC!!!
-    double m_SF;
     double m_E[CaloCell_ID_FCS::MaxSample];
     double m_Efrac[CaloCell_ID_FCS::MaxSample];
     
     Cellmap_t m_cells;
     
-  ClassDef(TFCSSimulationState,1)  //TFCSSimulationState
+  public:
+    // Allow to store arbitrary type objects as auxilliary information
+    // Use compile time hashes of strings as index to an unordered map of union AuxInfo_t
+    // Example:
+    // TFCSSimulationState s;
+    // s.setAuxInfo<double>("SF"_FCShash,2);
+    // 
+    // If pointers are stored, a dedicated cleanup is needed
+    // If a new data type is needed, a cast operator and an explicit template implementation of the set method has to be added
+    union AuxInfo_t {
+      bool b;
+      char c;
+      int i;
+      float f;
+      double d;
+      void* p;
+      
+      //cast operators
+      operator bool()   const {return b;};
+      operator char()   const {return c;};
+      operator int()    const {return i;};
+      operator float()  const {return f;};
+      operator double() const {return d;};
+      operator void*()  const {return p;};
+      
+      //template set method. No general implementation exist, only explict implementations are added after the class definition
+      template<class T> void set(T val);
+    };
+    
+    // FNV-1a 32bit hashing algorithm that is evaluated during compile time
+    // function taken from https://gist.github.com/Lee-R/3839813
+    static constexpr std::uint32_t fnv1a_32(char const* s, std::size_t count)
+    {
+        return ((count ? fnv1a_32(s, count - 1) : 2166136261u) ^ s[count]) * 16777619u;
+    }
+    // Run time call for hash function
+    static std::uint32_t getAuxIndex(std::string s);
+    static std::uint32_t getAuxIndex(const char* s);
+    
+    //Check if some auxiliary information is stored
+    bool hasAuxInfo(std::uint32_t index) const {return m_AuxInfo.find(index)!=m_AuxInfo.end();};
+    
+    //Get auxiliary info
+    //Use as TFCSSimulationState::getAuxInfo<int>(index)
+    template<class T> inline const T getAuxInfo(std::uint32_t index) const  {return static_cast<T>(m_AuxInfo.at(index));}
+    
+    //Set auxiliary info
+    //Use as TFCSSimulationState::setAuxInfo<double>(7,2.0f)
+    //    or TFCSSimulationState::setAuxInfo(7,2.0)
+    template<class T> inline void setAuxInfo(std::uint32_t index, const T& val) {m_AuxInfo[index].set<T>(val);}
+    
+  private:
+    std::unordered_map< std::uint32_t , AuxInfo_t > m_AuxInfo;//! Do not persistify
+    
+  ClassDef(TFCSSimulationState,3)  //TFCSSimulationState
 };
 
+//Explicit template implementations for template<class T> void TFCSSimulationState::AuxInfo_t::set(T val);
+template<> inline void TFCSSimulationState::AuxInfo_t::set<const TFCSSimulationState::AuxInfo_t>(const TFCSSimulationState::AuxInfo_t val) {*this=val;}
+template<> inline void TFCSSimulationState::AuxInfo_t::set<bool>(bool val)     {b=val;}
+template<> inline void TFCSSimulationState::AuxInfo_t::set<char>(char val)     {c=val;}
+template<> inline void TFCSSimulationState::AuxInfo_t::set<int>(int val)       {i=val;}
+template<> inline void TFCSSimulationState::AuxInfo_t::set<float>(float val)   {f=val;}
+template<> inline void TFCSSimulationState::AuxInfo_t::set<double>(double val) {d=val;}
+template<> inline void TFCSSimulationState::AuxInfo_t::set<void*>(void* val)   {p=val;}
+
+//Implementation of the complile time text hash operator that can be used for human readable indices to the AuxInfo
+constexpr std::uint32_t operator"" _FCShash(char const* s, std::size_t count)
+{
+  return TFCSSimulationState::fnv1a_32(s, count);
+}
+
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
 #pragma link C++ class TFCSSimulationState+;
 #endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSSimulationState.cxx

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "CLHEP/Random/RandomEngine.h"
 
 #include "ISF_FastCaloSimEvent/TFCSSimulationState.h"
 #include <iostream>
+#include <cstring>
 
 //=============================================
 //======= TFCSSimulationState =========
@@ -19,7 +20,7 @@ TFCSSimulationState::TFCSSimulationState(CLHEP::HepRandomEngine* randomEngine)
 
 void TFCSSimulationState::clear()
 {
-  m_SF=1;
+  set_SF(1);
   m_Ebin=-1;
   m_Etot=0;
   for(int i=0;i<CaloCell_ID_FCS::MaxSample;++i)
@@ -31,16 +32,12 @@ void TFCSSimulationState::clear()
 
 void TFCSSimulationState::deposit(const CaloDetDescrElement* cellele, float E)
 {
-  //std::cout<<"TFCSSimulationState::deposit: cellele="<<cellele<<" E="<<E;
   auto mele=m_cells.find(cellele);
   if(mele==m_cells.end()) {
     m_cells.emplace(cellele,0);
     mele=m_cells.find(cellele);
   }  
-  //std::cout<<" Ebefore="<<mele->second;
   m_cells[cellele]+=E;
-  //std::cout<<" Eafter="<<mele->second;
-  //std::cout<<std::endl;
 }
 
 void TFCSSimulationState::Print(Option_t *) const
@@ -50,4 +47,21 @@ void TFCSSimulationState::Print(Option_t *) const
   {
     std::cout<<"  E"<<i<<"("<<CaloSampling::getSamplingName(i)<<")="<<E(i)<<" E"<<i<<"/E="<<Efrac(i)<<std::endl;
   }
+  if(m_AuxInfo.size()>0) {
+    std::cout<<"  AuxInfo has "<<m_AuxInfo.size()<<" elements"<<std::endl;
+    for(auto& a : m_AuxInfo) {
+      std::cout<<"    "<<a.first<<" : bool="<<a.second.b<<" char="<<a.second.c<<" int="<<a.second.i<<" float="<<a.second.f<<" double="<<a.second.d<<" void*="<<a.second.p<<std::endl;
+    }
+  }  
+}
+
+std::uint32_t TFCSSimulationState::getAuxIndex(std::string s) 
+{
+  return TFCSSimulationState::fnv1a_32(s.c_str(),s.size());
 }
+
+std::uint32_t TFCSSimulationState::getAuxIndex(const char* s) 
+{
+  return TFCSSimulationState::fnv1a_32(s,std::strlen(s));
+}
+