KVIdentificationResult.h

#ifndef KVIDENTIFICATIONRESULT_H
#define KVIDENTIFICATIONRESULT_H
 
#include "KVBase.h"
#include "TString.h"
#include <unordered_map>
 
class KVIdentificationResult : public KVBase {
public:
    Bool_t IDattempted;
    Bool_t IDOK;
    Int_t IDcode;
    Bool_t Zident;
    Bool_t Aident;
    Int_t IDquality;
    Int_t Z;
    Int_t A;
    Double_t PID;
    Int_t deltaEpedestal;
    TString Rejecting_Cut;
 
   using grid_infos = std::unordered_map<std::string, std::vector<TString>>; //infos from each grid used to identify particle
   grid_infos flags;
 
   enum {
      deltaEpedestal_UNKNOWN, // status unknown, case not treated
      deltaEpedestal_YES,     // the particle to identify has a delta-E consistent with pedestal
      deltaEpedestal_NO       // the particle to identify has a delta-E > pedestal
   };
 
   KVIdentificationResult() :
      IDattempted(0), IDOK(0), IDcode(-1),
      Zident(0), Aident(0), IDquality(-1), Z(-1), A(-1), PID(-1.0), deltaEpedestal(deltaEpedestal_UNKNOWN)
   {};
 
   KVIdentificationResult(const KVIdentificationResult& id) : KVBase()
   {
      id.Copy(*this);
   }
   void Clear(Option_t* opt = "");
   void Copy(TObject&) const;
   void Print(Option_t* opt = "") const;
   KVIdentificationResult& operator=(const KVIdentificationResult& i)
   {
      i.Copy(*this);
      return *this;
   }
 
   void SetIDType(const Char_t* t)
   {
      SetType(t);
   }
   const Char_t* GetIDType() const
   {
      return GetType();
   }
   void SetComment(const Char_t* c)
   {
      SetLabel(c);
   }
   const Char_t* GetComment() const
   {
      return GetLabel();
   }
   void SetGridName(const Char_t* n)
   {
      SetName(n);
   }
   const Char_t* GetGridName() const
   {
      return GetName();
   }
 
   void AddFlag(std::string grid_name, TString flag)
   {
      flags[grid_name].push_back(flag);
   }
 
   Bool_t HasFlag(std::string grid_name, TString flag)
   {
      auto fv = flags.find(grid_name);
      if (fv != flags.end()) return (std::find(fv->second.begin(), fv->second.end(), flag) != fv->second.end());
      return kFALSE;
   }
 
   Bool_t HasFlagWhichBegins(std::string grid_name, TString flag_beginning)
   {
      auto fv = flags.find(grid_name);
      if (fv != flags.end()) {
         for (auto& f : fv->second) {
            if (f.BeginsWith(flag_beginning)) return kTRUE;
         }
      }
      return kFALSE;
   }
 
   TString GetFlagWhichBegins(std::string grid_name, TString flag_beginning)
   {
      auto fv = flags.find(grid_name);
      if (fv != flags.end()) {
         for (auto& f : fv->second) {
            if (f.BeginsWith(flag_beginning)) return f;
         }
      }
      return "";
   }
 
   Bool_t IdentifyingGridHasFlag(TString flag)
   {
      return HasFlag(GetGridName(), flag);
   }
 
   Bool_t IdentifyingGridHasFlagWhichBegins(TString flag_beginning)
   {
      return HasFlagWhichBegins(GetGridName(), flag_beginning);
   }
 
   TString IdentifyingGridGetFlagWhichBegins(TString flag_beginning)
   {
      return GetFlagWhichBegins(GetGridName(), flag_beginning);
   }
 
   Bool_t HasFlag_AnyGrid(TString flag, std::string& grid_name)
   {
 
      for (auto& fv : flags) {
         grid_name = fv.first;
         if (HasFlag(grid_name, flag)) return kTRUE;
      }
      return kFALSE;
   }
 
   Bool_t HasFlagWhichBegins_AnyGrid(TString flag_beginning, std::string& grid_name)
   {
      for (auto& fv : flags) {
         grid_name = fv.first;
         if (HasFlagWhichBegins(grid_name, flag_beginning)) return kTRUE;
      }
      return kFALSE;
   }
 
   TString GetFlagWhichBegins_AnyGrid(TString flag_beginning, std::string& grid_name)
   {
      for (auto& fv : flags) {
         grid_name = fv.first;
         auto f = GetFlagWhichBegins(grid_name, flag_beginning);
         if (f.Length()) return f;
      }
      return "";
   }
 
   ClassDef(KVIdentificationResult, 5) //Full result of one attempted particle identification
};
 
#endif