RoiDescriptor.h

Go to the documentation of this file.

// emacs: this is -*- c++ -*-
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
//
//   @file    RoiDescriptor.h        
//
//             RoiDescriptor class - includes constructors in preparation
//             for enforcement of correct roi sizes       
//  
//   @author sutt@cern.ch
//
 
 
#ifndef ROIDESCRIPTOR_ROIDESCRIPTOR_H
#define ROIDESCRIPTOR_ROIDESCRIPTOR_H
 
#include <iostream>
#include <atomic>
 
#include "IRegionSelector/IRoiDescriptor.h"
#include "IRegionSelector/RoiUtil.h"
 
 
class RoiDescriptor : public IRoiDescriptor {
 
public:
 
  static constexpr bool FULLSCAN = true;
  static constexpr bool ROI = false;
 
public:
 
  RoiDescriptor(bool fullscan=ROI);
 
  RoiDescriptor(double eta_,   double etaMinus_,   double etaPlus_, 
        double phi_,   double phiMinus_,   double phiPlus_, 
        double zed_=0, double zedMinus_=-s_zedWidthDefault, double zedPlus_=s_zedWidthDefault   );
  RoiDescriptor(double etaMinus_, double etaPlus_, 
        double phiMinus_, double phiPlus_ ); 
 
  RoiDescriptor( const IRoiDescriptor& roi );
  RoiDescriptor& operator=( const IRoiDescriptor& r );  
 
  /*
   *  need an explicit class copy constructor
   */
  RoiDescriptor( const RoiDescriptor& roi );
  RoiDescriptor& operator=( const RoiDescriptor& r );  
 
  
  // Destructor
  virtual ~RoiDescriptor();
 
 
  // Methods to retrieve data members
 
  virtual double phi() const override final { return m_phi; }
  virtual double eta() const override final { return m_eta; }
  virtual double zed() const override final { return m_zed; }
 
 
  virtual unsigned int roiId()   const override { return 0; }
  virtual unsigned int l1Id()    const override { return 0; }
  virtual unsigned int roiWord() const override { return 0; }
 
  virtual double zedPlus()  const override final { return m_zedPlus; } 
  virtual double zedMinus() const override final { return m_zedMinus; } 
 
  virtual double etaPlus()  const override final { return m_etaPlus; }   
  virtual double etaMinus() const override final { return m_etaMinus; }   
 
  virtual double phiPlus()  const override final { return m_phiPlus; }    
  virtual double phiMinus() const override final { return m_phiMinus; }   
 
 
  virtual int version() const override final { return m_version; }
  void version(int v)                  { m_version = v; }
 
 
  virtual operator std::string() const override;
 
 
  virtual bool  isFullscan() const override final { return m_fullscan; }
 
 
  virtual bool composite() const override final { return m_composite; }
  void setComposite(bool b=true)          { m_composite=b; }
 
  bool manageConstituents() const { return m_manageConstituents; }
  void manageConstituents(bool b) { m_manageConstituents=b; }
 
  virtual unsigned size() const override final { return m_roiDescriptors.size(); }
 
  virtual const IRoiDescriptor* at(int i) const override final { return m_roiDescriptors.at(i); }
 
  void clear()  { m_roiDescriptors.clear(); }  // setComposite(false); }
 
  void reserve(size_t s) { m_roiDescriptors.reserve(s); }
 
  void push_back(const IRoiDescriptor* roi) { m_roiDescriptors.push_back(roi); setComposite(true); }
 
  virtual roi_iterator  begin() const override final { return m_roiDescriptors.begin(); }
  virtual roi_iterator  end()   const override final { return m_roiDescriptors.end(); }
 
  virtual double dzdrMinus() const override final { return m_dzdrMinus; }       
  virtual double dzdrPlus()  const override final { return m_dzdrPlus; }        
 
  virtual double drdzMinus() const override final { return m_drdzMinus; }       
  virtual double drdzPlus()  const override final { return m_drdzPlus; }        
 
  virtual double zedMin(double r) const override final;
  virtual double zedMax(double r) const override final;
 
  virtual double zedOuterPlus()  const override final { return m_zedOuterPlus; } 
  virtual double zedOuterMinus() const override final { return m_zedOuterMinus; } 
 
  virtual double rhoMin(double z) const override final;
  virtual double rhoMax(double z) const override final;
 
public:
 
  static double zedWidthDefault() { return s_zedWidthDefault; }
 
  static void zedWidthDefault( double d );
 
protected:
 
  friend class TrigRoiDescriptorCnv_p2;
  friend class TrigRoiDescriptorCnv_p3;
 
  void construct(double eta, double etaMinus, double etaPlus, 
         double phi, double phiMinus, double phiPlus, 
         double zed, double zedMinus, double zedPlus); 
 
  void construct( const IRoiDescriptor& _roi );
 
protected:
 
  static std::atomic<double> s_zedWidthDefault;
  static std::atomic<bool> s_firstInstanceCreated;
 
protected:
 
  float m_phi;                 
  float m_eta;                 
  float m_zed;                 
 
  float m_phiMinus;            
  float m_phiPlus;             
  float m_etaMinus;             
  float m_etaPlus;              
  float m_zedMinus;             
  float m_zedPlus;              
 
  float m_dzdrMinus;       
  float m_dzdrPlus;        
 
  float m_drdzMinus;    
  float m_drdzPlus;     
 
  float m_zedOuterMinus;  
  float m_zedOuterPlus;   
 
  bool m_fullscan;             
  bool m_composite;            
  bool m_manageConstituents;   
 
  int  m_version;              
 
  std::vector<const IRoiDescriptor*>  m_roiDescriptors;  
  
};
 
 
std::string str( const RoiDescriptor& d );                           //<! printing helper
std::ostream& operator<<( std::ostream& m, const RoiDescriptor& d ); //<! printing helper (wraps above)
 
#endif // ROIDESCRIPTOR_H