TIDARoiDescriptor.h

Go to the documentation of this file.

/* emacs: this is -*- c++ -*- */

 
 
#ifndef TIDA_ROIDESCRIPTOR_H
#define TIDA_ROIDESCRIPTOR_H
 
#include <ostream>
#include <cmath>
#include <vector>
 
#include "TObject.h"
 
#include "TrigInDetAnalysis/TIDARoiParameters.h"
 
 
class TIDARoiDescriptor : public TObject { //, public IRoiDescriptor {
 
public:

  TIDARoiDescriptor(bool fullscan=false);
 

 
  TIDARoiDescriptor( double eta,  double etaMinus,   double etaPlus,
             double phi,  double phiMinus,   double phiPlus,
             double zed,  double zedMinus,   double zedPlus );
 

  TIDARoiDescriptor(unsigned l1id, int id, 
            double eta,  double etaMinus,   double etaPlus,
            double phi,  double phiMinus,   double phiPlus,
            double zed,  double zedMinus,   double zedPlus );
  
  TIDARoiDescriptor(unsigned roiWord, unsigned l1id, int id, 
            double eta,  double etaMinus,   double etaPlus,
            double phi,  double phiMinus,   double phiPlus,
            double zed,  double zedMinus,   double zedPlus );
  
  TIDARoiDescriptor( const TIDARoiDescriptor& r);
 

  TIDARoiDescriptor& operator=( const TIDARoiDescriptor& r);
 
 
  // Destructor
  virtual ~TIDARoiDescriptor();
  
  // Methods to set data members
  //  void phi(const double phi) { m_phi = phi; } //!< set phi of RoI
  //  void eta(const double eta) { m_eta = eta; } //!< set eta of RoI
  //  void zed(const double zed) { m_zed = zed; } //!< set eta of RoI
 
  void set_roiId(const unsigned int id) { m_roiId=id; }     
  void set_l1Id(const unsigned int l1id) { m_l1Id=l1id; }             
  void set_roiWord(const unsigned int roiWord) { m_roiWord=roiWord; } 
 
  //  void phiHalfWidth(double x) { m_phiHalfWidth=x; }       //!< sets phi half-width
  //  void etaHalfWidth(double x) { m_etaHalfWidth=x; }       //!< sets eta half-width
  //  void zedHalfWidth(double x) { m_zedHalfWidth=x; }       //!< sets zed half-width
 
  //  void  etaPlus(double x)  { m_etaPlus  = x; }       //!< sets eta at z+zwidth
  //  void  etaMinus(double x) { m_etaMinus = x; }     //!< sets eta at z-zwidth
 
  // Methods to retrieve data members
 
  //  double phi0() const { return m_params.phi(); }
  //  double eta0() const { return m_params.eta(); }
  //  double zed0() const { return m_params.zed(); }
 
  double phi()  const { return m_params.phi(); }
  double eta()  const { return m_params.eta(); }
  double zed()  const { return m_params.zed(); }
 
  double etaMinus() const { return m_params.etaMinus(); }
  double etaPlus()  const { return m_params.etaPlus(); }
 
  double phiMinus() const { return m_params.phiMinus(); }
  double phiPlus()  const { return m_params.phiPlus(); }
 
  double zedMinus() const { return m_params.zedMinus(); }
  double zedPlus()  const { return m_params.zedPlus(); }
 

 
  double zedPlusR()  const { return m_zedPlusR; }
  double zedMinusR() const { return m_zedMinusR; }
 
  double rPlusZed()  const { return m_rPlusZed; }
  double rMinusZed() const { return m_rMinusZed; }
 
  double maxR()   const { return maxRadius; }
  double maxZ()   const { return maxZed; }
 
  static double  exitpoint( double tz0, double teta, double& zexit, double& rexit );

 
  unsigned roiId()   const { return m_roiId; }
  unsigned l1Id()    const { return m_l1Id; }
  unsigned roiWord() const { return m_roiWord; }
 
  int      version() const { return 4; }  
 
  operator std::string() const;
 
  bool isFullscan() const { return m_fullscan; } 

 
  bool composite() const { return !m_rois.empty(); }
 
  size_t size() const { return m_rois.size(); }
 
  const TIDARoiDescriptor* operator[](int i) const { return &m_rois.at(i); }
  const TIDARoiDescriptor* at(int i)         const { return &m_rois.at(i); }

  double phiHalfWidth() const { 
    double dphi = 0.5*(params().phiPlus()-params().phiMinus());
    if ( params().phiMinus()>params().phiPlus() ) dphi += M_PI;
    return dphi;
  }
 
  double etaHalfWidth() const { return 0.5*(params().etaPlus()-params().etaMinus()); } 
  double zedHalfWidth() const { return 0.5*(params().zedPlus()-params().zedMinus()); } 
 
  //  double zedPlus()  const { return m_zed+m_zedHalfWidth; } //!< gets phi half-width
  //  double zedMinus() const { return m_zed-m_zedHalfWidth; } //!< gets phi half-width
 
  //  double etaPlus()  const { return m_etaPlus; }    //!< gets eta at z+zwidth
  //  double etaMinus() const { return m_etaMinus; }   //!< gets eta at z-zwidth

 
 
  bool operator==( const TIDARoiDescriptor& b ) const {
    if ( roiWord() != b.roiWord() ) return false;
    double epsilon=0.001; // arbitrary , but seems to be reasonable
    if ( std::fabs( phi() - b.phi()) > epsilon ) return false;
    if ( std::fabs( eta() - b.eta()) > epsilon ) return false;
    if ( std::fabs( zed() - b.zed()) > epsilon ) return false;
    return true;
  }
  
  bool operator!=( const TIDARoiDescriptor& b ) const { return !((*this)==b); }
 
  void push_back( const TIDARoiDescriptor& roi ) { m_rois.push_back( roi ); }
  void push_back( const TIDARoiDescriptor* roi ) { m_rois.push_back( *roi ); }
 
 
 
#if 0

 
  virtual double zedMin(double r) const { return 0; } 
  virtual double zedMax(double r) const { return 0; } 
 
  virtual double rhoMin(double z) const { return 0; } 
  virtual double rhoMax(double z) const { return 0; } 

  virtual double dzdrMinus() const { return 0; } 
  virtual double dzdrPlus()  const { return 0; } 
 
  virtual double drdzMinus() const { return 0; } 
  virtual double drdzPlus()  const { return 0; } 
 
  virtual bool contains( double z0, double dzdr )            const { return false; }  
  virtual bool contains_internal( double z0, double zouter ) const { return false; }  
  
  virtual bool contains( double _z, double _r, double _phi ) const { return false; } 
  virtual bool containsPhi( double _phi )                    const { return false; } 
  virtual bool containsZed( double _z, double _r )           const { return false; } 
 
#endif
 
protected:

  const TIDARoiParameters&  params() const { return m_params; };  

  void reset() {
    m_params = TIDARoiParameters();
    //    m_phi=0.0;          m_eta=0.0;          m_zed=0.0;
    //    m_phiHalfWidth=0.1; m_etaHalfWidth=0.1; m_zedHalfWidth=168;
    //    m_etaPlus=m_eta;    m_etaMinus=m_eta;
    m_l1Id=0; 
    m_roiId=0;  
    m_roiWord=0;
    m_rois.clear();
  }
 
  double phicheck(double phi);  
  double etacheck(double eta);  
  double zedcheck(double zed);  
 
protected: 
 
  static const double maxRadius; 
  static const double maxZed;    
 
protected:
 
  TIDARoiParameters m_params;   //  actual roi values
 
  bool         m_fullscan;
 
  unsigned int m_l1Id;          //< lvl1 event number
  unsigned int m_roiId;         //< RoI number
  unsigned int m_roiWord;       //< lvl1 RoI word from which this RoI was initially constructed
 
  std::vector<TIDARoiDescriptor>  m_rois;   //<  actual roi descriptors - mot pointers as online
 
  bool    m_cached;  
  double  m_dphi;    
 
  double m_zedPlusR;  
  double m_zedMinusR; 
 
  double m_rPlusZed;  
  double m_rMinusZed; 
 
  double m_tanthetaPlus;   
  double m_tanthetaMinus; 
  
 
  ClassDef( TIDARoiDescriptor, 2 ) 
 
}; 
 
 
inline std::ostream& operator<<( std::ostream& s, const TIDARoiDescriptor& d ) { 
  return s << (std::string)d; 
}
 
#endif // TIDA_ROIDESCRIPTOR_H