HardwareComponent.h

Go to the documentation of this file.

#ifndef HARDWARECOMPONENT_H
#define HARDWARECOMPONENT_H
#include "Plex/PlexHandle.h"
#include "HardwareType.h"

class HardwareComponent 
{
 private:
  HardwareType::Hardware_t     fType;
  Int_t                        fId;

 public:
  HardwareComponent(HardwareType::Hardware_t type=HardwareType::kUnknown, 
                    Int_t id=0) 
    : fType(type), fId(id) {};  
  ~HardwareComponent() {};

  // Copy operator.
  void operator=(const HardwareComponent& other) { fType = other.fType; fId = other.fId; };

  // Ctors for various types
  HardwareComponent(HardwareType::Hardware_t type, RawChannelId rcid);
  HardwareComponent(HardwareType::Hardware_t type, PlexPixelSpotId psid);
  HardwareComponent(HardwareType::Hardware_t type, PlexStripEndId seid);
  HardwareComponent(HardwareType::Hardware_t type, PlexPinDiodeId pdid);
  HardwareComponent(HardwareType::Hardware_t type, PlexPlaneId    plane);

  //HardwareComponent(const char* s); // from string  

  // Set functions:
  Bool_t      FromString(const char* string);
  void        SetType(HardwareType::Hardware_t type) { fType = type; };
  void        SetId(Int_t id)                        { fId = id; };

  // Get functions:
  HardwareType::Hardware_t   GetType() const { return fType; };
  Int_t                      GetId() const { return fId; };
  RawChannelId               GetRawChannelId() const { return RawChannelId(fId); };
  PlexPixelSpotId            GetPixelSpotId() const { return PlexPixelSpotId(fId); };
  PlexStripEndId             GetStripEndId() const { return PlexStripEndId(fId); };
  PlexPinDiodeId             GetPinDiodeId() const { return PlexPinDiodeId(fId); };
  PlexPlaneId                GetPlaneId() const { return PlexPlaneId(fId); };
  
  const std::vector<PlexStripEndId>& GetStripEnds(PlexHandle plex);

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

  // Comparisons
  friend Bool_t operator< (const HardwareComponent &lhs, const HardwareComponent &rhs);
  friend Bool_t operator<=(const HardwareComponent &lhs, const HardwareComponent &rhs);
  friend Bool_t operator==(const HardwareComponent &lhs, const HardwareComponent &rhs);
  friend Bool_t operator!=(const HardwareComponent &lhs, const HardwareComponent &rhs);
  friend Bool_t operator> (const HardwareComponent &lhs, const HardwareComponent &rhs);
  friend Bool_t operator>=(const HardwareComponent &lhs, const HardwareComponent &rhs);


 private:
  static std::vector<PlexStripEndId> fEndList; // ! Temporary storage for GetStripEnds calls.

  void GetStripEndsForPixelSpot(PlexPixelSpotId psid, PlexHandle plex);
  void GetStripEndsForPixel(PlexPixelSpotId psid, PlexHandle plex);
  void GetStripEndsForPmt(PlexPixelSpotId psid, PlexHandle plex);

  void GetStripEndsForChannel(RawChannelId rcid, PlexHandle plex);
  void GetStripEndsForMinder(RawChannelId rcid, PlexHandle plex);
  void GetStripEndsForMaster(RawChannelId rcid, PlexHandle plex);
  void GetStripEndsForVaChip(RawChannelId rcid, PlexHandle plex);
  void GetStripEndsForVfb(RawChannelId rcid, PlexHandle plex);
  void GetStripEndsForVmm(RawChannelId rcid, PlexHandle plex);
  void GetStripEndsForVarc(RawChannelId rcid, PlexHandle plex);
  void GetStripEndsForCrate(RawChannelId rcid, PlexHandle plex);

  void GetStripEndsForPlane(PlexPlaneId plane, PlexHandle plex);
  void GetStripEndsForVetoShield(PlexHandle plex);
  void GetStripEndsForSupermodule(Int_t sm, PlexHandle plex);
  void GetStripEndsForSpectrometer(PlexHandle plex);
  void GetStripEndsForCalorimeter(PlexHandle plex);
  void GetStripEndsForDetector(PlexHandle plex);

};


// Comparison operators:

inline Bool_t operator< (const HardwareComponent &lhs, const HardwareComponent &rhs)
{ 
  if( lhs.fType==rhs.fType ) return (lhs.fId  < rhs.fId);
  else                       return (lhs.fType< rhs.fType);
}
inline Bool_t operator<=(const HardwareComponent &lhs, const HardwareComponent &rhs)
{ 
  if( lhs.fType==rhs.fType ) return (lhs.fId  <= rhs.fId);
  else                       return (lhs.fType<= rhs.fType);
}
inline Bool_t operator==(const HardwareComponent &lhs, const HardwareComponent &rhs)
{ 
  if( lhs.fType==rhs.fType ) return (lhs.fId  == rhs.fId);
  return false;
}
inline Bool_t operator!=(const HardwareComponent &lhs, const HardwareComponent &rhs)
{ 
  if(lhs.fId   != rhs.fId) return true;
  if( lhs.fType!=rhs.fType ) return true;
  return false;
}
inline Bool_t operator> (const HardwareComponent &lhs, const HardwareComponent &rhs)
{ 
  if( lhs.fType==rhs.fType ) return (lhs.fId  > rhs.fId);
  else                       return (lhs.fType> rhs.fType);
}
inline Bool_t operator>=(const HardwareComponent &lhs, const HardwareComponent &rhs)
{ 
  if( lhs.fType==rhs.fType ) return (lhs.fId  >= rhs.fId);
  else                       return (lhs.fType>= rhs.fType);
}


#endif

---