rootana/src/framework/IdChannel.h

Go to the documentation of this file.

#ifndef IDCHANNEL_H_
#define IDCHANNEL_H_

#include "TObject.h"
#include <map>
#include <string>

namespace IDs{
  class channel;

  enum Detector_t { 
    kErrorDetector=-1,
    kAnyDetector=0,
                kGe       , kLiquidSc , kNDet     , kNDet2  , kScGe   , // 1-5
                kScL      , kScR      , kScVe     , kSiL1_1 , kSiL1_2 , // 6-10
                kSiL1_3   , kSiL1_4   , kSiL2     , kSiR1_1 , kSiR1_2 , // 11-15
                kSiR1_3   , kSiR1_4   , kSiR1_sum , kSiR2   , kMuSc   , // 16-20
                kMuScA };                                               // 21
        const short num_detector_enums=21;

  enum SlowFast_t{
    kErrorSlowFast=-1,
    kAnySlowFast=0,
    kFast=1,
    kSlow=2,
    kNotApplicable=3 };
}

class IDs::channel:public TObject{
public:
  channel(Detector_t det=kAnyDetector, SlowFast_t type=kAnySlowFast);

  channel(const std::string& detector , const std::string& type);

  channel(const std::string& channel );
  virtual ~channel(){};

  void Reset(){fDetector=kAnyDetector; fSlowFast=kAnySlowFast;};
public:
  Detector_t Detector()const{return fDetector;};
  void Detector(const Detector_t& d){ fDetector=d;};

  SlowFast_t SlowFast()const{return fSlowFast;};
  void SlowFast(const SlowFast_t& d){ fSlowFast=d;};

  channel& operator=(const std::string& rhs);

  channel& operator=(const char* rhs){ return (*this=std::string(rhs));};

  bool operator==(const channel& rhs)const;

  bool operator!=(const channel& rhs)const{return !(this->operator==(rhs));};
  bool matches(const channel& rhs)const;
        
  bool operator<(const channel& rhs)const;
  bool operator>(const channel& rhs)const;

  std::string str()const;

  bool isValid(){return (fDetector!=kErrorDetector) && (fSlowFast != kErrorSlowFast);};

  bool isWildCardDetector() const {return fDetector == kAnyDetector;}

  bool isWildCardSlowFast() const {return fSlowFast == kAnySlowFast;}

  bool isWildCard() const {return isWildCardDetector() || isWildCardSlowFast();}

  bool isFast() const {return fSlowFast==kFast;};
  bool isSlow() const {return fSlowFast==kSlow;};

  channel GetCorrespondingFastSlow()const;

  static std::string GetDetectorString(Detector_t det);

  static Detector_t GetDetectorEnum(const std::string& det);

  static std::string GetSlowFastString(SlowFast_t sf);

  static SlowFast_t GetSlowFastEnum(const std::string& sf);

  void Debug()const;

private:
  Detector_t fDetector;
  SlowFast_t fSlowFast;

  ClassDef(IDs::channel,1);
};

inline bool IDs::channel::operator==(const IDs::channel& rhs)const{
  return (fDetector == rhs.fDetector) && (fSlowFast== rhs.fSlowFast);
}

inline bool IDs::channel::matches(const channel& rhs)const{
  return (isWildCardDetector() || rhs.isWildCardDetector() || fDetector==rhs.fDetector) 
    && (isWildCardSlowFast() || rhs.isWildCardSlowFast() || fSlowFast==rhs.fSlowFast) ;
}

inline bool IDs::channel::operator>(const IDs::channel& rhs)const{
  return fDetector>rhs.fDetector || (fDetector == rhs.fDetector && fSlowFast>rhs.fSlowFast);
}

inline bool IDs::channel::operator<(const IDs::channel& rhs)const{
  return fDetector<rhs.fDetector || ( fDetector == rhs.fDetector && fSlowFast<rhs.fSlowFast );
}

inline IDs::channel::channel(Detector_t det, SlowFast_t type):fDetector(det),fSlowFast(type){
}

inline IDs::channel::channel(const std::string& detector , const std::string& type):fDetector(),fSlowFast(kAnySlowFast){
  fDetector=GetDetectorEnum(detector);
  fSlowFast=GetSlowFastEnum(type);
}

inline IDs::channel::channel(const std::string& channel ):fDetector(),fSlowFast(kAnySlowFast){
  *this=channel;
}

std::ostream& operator<< (ostream& os ,const IDs::channel& id);

#endif //IDCHANNEL_H_

---