RawChannelId.h

Go to the documentation of this file.

// $Id: RawChannelId.h,v 1.31 2005/08/26 19:04:53 rhatcher Exp $
// 
// RawChannelId 
// 
// RawChannelId is the base class for a channel # of a raw digit
// ElecType::Elec_t either kQIE or kVA (Viking data)
//
// Author:  R. Hatcher 2000.04.19
//

#ifndef RAWCHANNELID_H
#define RAWCHANNELID_H

#include "Conventions/Detector.h"
#include "Conventions/ElecType.h"

// make the RawChannelId cout'able
#include <iosfwd>

class RawChannelId;
std::ostream& operator<<(std::ostream& os, const RawChannelId& rcid);

class RawChannelId {

 public:

   RawChannelId();

#define RAWCHANNELID_NEW_CTOR 1 // new ctors drop pedmode,commonmode flags

   // ctor from ChAdd
   RawChannelId(Detector::Detector_t detector, ElecType::Elec_t etype,
                         UInt_t crate, UInt_t chadd);

   // ctor from QIE components
   // note GeoAddr==Master  MasterCh=Minder  MinderCh=Menu
   RawChannelId(Detector::Detector_t detector, ElecType::Elec_t etype,
                         UInt_t crate, UInt_t geoaddr,
                         UInt_t masterChan, UInt_t minderChan);

   // ctor from VA components
   RawChannelId(Detector::Detector_t detector, ElecType::Elec_t etype,
                         UInt_t crate,  UInt_t varc, UInt_t vmm, 
                         UInt_t adcsel, UInt_t vachip, UInt_t vachan);

   // ctor from CrateId (w/ mode bits) & ChAdd
   RawChannelId(Detector::Detector_t detector, 
                         UInt_t crateinfo,UInt_t chadd);

   // non-virtual dtor would be okay, but ClassDef brings in virtualness
   virtual ~RawChannelId() { ; } // no owned data members

   // use these two with caution as they work on the rawest level
   RawChannelId(const UInt_t encoded);
   inline UInt_t          GetEncoded() const { return fEncoded; }

   const char            *AsString(Option_t *option="") const;

   Detector::Detector_t     GetDetector() const;
   ElecType::Elec_t         GetElecType() const;
   Bool_t                   GetPedMode() const;
   Bool_t                   GetSparsMode() const;
   Bool_t                   GetCommonMode() const;
   UShort_t                 GetCrate() const;
   UShort_t                 GetChAdd() const;

   // if ElecType == kQIE
   UShort_t                 GetGeographicAddress() const;
   UShort_t                 GetMasterChannel() const;
   UShort_t                 GetMinderChannel() const;
   // alternatives
   UShort_t                 GetMaster() const {return GetGeographicAddress();}
   UShort_t                 GetMinder() const {return GetMasterChannel();}
   UShort_t                 GetMenu() const   {return GetMinderChannel();}

   // if ElecType == kVA
   UShort_t               GetVarcId() const;
   UShort_t               GetVfb() const;
   UShort_t               GetVmm() const;
   UShort_t               GetVaAdcSel() const;
   UShort_t               GetVaChip() const;
   UShort_t               GetVaChannel() const;

   virtual void             Print(Option_t *option="") const;
   virtual std::ostream&    FormatToOStream(std::ostream& os,
                                            Option_t *option="") const;

   /* these tests do NOT include ped/sparse/common mode components */
   Bool_t IsSameChannel(const RawChannelId &other) const;
   Bool_t IsSameCrate(const RawChannelId &other) const;

   Bool_t IsSameVAChip(const RawChannelId &other) const;
   Bool_t IsSameVfb(const RawChannelId &other) const;

   Bool_t IsSameMinder(const RawChannelId &other) const;

   /* these comparisons include ped/common mode components */
   friend Bool_t operator< (const RawChannelId &lhs, const RawChannelId &rhs);
   friend Bool_t operator==(const RawChannelId &lhs, const RawChannelId &rhs);
   friend Bool_t operator!=(const RawChannelId &lhs, const RawChannelId &rhs);

   Bool_t                 IsNull() const;

   void SetDetector(Detector::Detector_t detector);
   void SetElecType(ElecType::Elec_t etype);
   void SetPedMode(Bool_t pedmode);
   void SetSparsMode(Bool_t sparsmode);
   void SetCommonMode(Bool_t commonmode); 
   void SetModeBits(Bool_t commonmode, Bool_t sparsmode, Bool_t pedmode);
   void ClearModeBits();
   void SetCrate(UInt_t crate);
   void SetChAdd(UInt_t chadd);

   // if ElecType == kQIE
   void SetGeographicAddress(UInt_t geoaddr);
   void SetMasterChannel(UInt_t master);
   void SetMinderChannel(UInt_t minder);

   // if ElecType == kVA
   void SetVarcId(UInt_t varc);
   void SetVmm(UInt_t vmm);
   void SetVaAdcSel(UInt_t adcsel);
   void SetVaChip(UInt_t vachip);
   void SetVaChannel(UInt_t vachan);

   // static methods for (de)constructing ChAdd (to/)from components 
   // for both QIE and VA electronics
   static Int_t CalcChAdd(UInt_t geo, UInt_t master, UInt_t minder);
   static Int_t CalcChAdd(UInt_t varcid, UInt_t vmm, UInt_t adcsel,
                          UInt_t vachip, UInt_t vachan);
   static void  DecompChAdd(UInt_t chadd, UInt_t& geo, 
                            UInt_t& master, UInt_t& minder);
   static void  DecompChAdd(UInt_t chadd, UInt_t& varcid, UInt_t& vmm, 
                            UInt_t& adcsel, UInt_t& vachip, UInt_t& vachan);

 protected:

   void Init(Detector::Detector_t detector, ElecType::Elec_t etype,
             UInt_t crate, UInt_t chadd);

   Bool_t CheckElecType(ElecType::Elec_t etype, const char* from = "");

   static UInt_t ConvertEncodedToVersion2(UInt_t encoded);
   void ConvertToVersion2(Bool_t inStreamerRead=false) const; // logical const

   UInt_t    fEncoded;  // encoded value

 private:

   ClassDef(RawChannelId,2)  // detector,electronics,crate,chanAddr
};

//_____________________________________________________________________________

inline Bool_t operator< (const RawChannelId &lhs, const RawChannelId &rhs)
{ 
  lhs.ConvertToVersion2(); rhs.ConvertToVersion2();
  return lhs.fEncoded < rhs.fEncoded; 
}

inline Bool_t operator==(const RawChannelId &lhs, const RawChannelId &rhs)
{ 
  lhs.ConvertToVersion2(); rhs.ConvertToVersion2();
  return lhs.fEncoded == rhs.fEncoded; 
}

inline Bool_t operator!=(const RawChannelId &lhs, const RawChannelId &rhs)
{ 
  lhs.ConvertToVersion2(); rhs.ConvertToVersion2();
  return lhs.fEncoded != rhs.fEncoded; 
}

const UInt_t  defaultRawChannelId = 0;

inline RawChannelId::RawChannelId() : fEncoded(defaultRawChannelId) { ; }
inline RawChannelId::RawChannelId(UInt_t encoded) : fEncoded(encoded) { ; }

#endif // RAWCHANNELID_H

---