RoiDescriptor.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file RoiDescriptor.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2021 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

// TODO: update to C++17 style
#include <atomic>
#include <iostream>
#include <map>
#include <ostream>
#include <vector>

#include <stdint.h>

namespace Acts {

class RoiDescriptor {
 public:
  // iterator
  using roi_iterator = std::vector<const RoiDescriptor*>::const_iterator;
  static constexpr bool FULLSCAN = true;
  static constexpr bool ROI = false;

  RoiDescriptor(double eta, double etaMinus, double etaPlus, double phi,
                double phiMinus, double phiPlus, double zed = 0,
                double zedMinus = -s_zedWidthDefault,
                double zedPlus = s_zedWidthDefault);
  // zedminus - s_zedWidthDefault = 225 //from ROIDescriptor

  /*
   *  need an explicit class copy constructor
   */
  RoiDescriptor(const RoiDescriptor& roi);
  RoiDescriptor& operator=(const RoiDescriptor& r);

  // Destructor
  ~RoiDescriptor();

  // Methods to retrieve data members

  double phi() const { return m_phi; }
  double eta() const { return m_eta; }
  double zed() const { return m_zed; }


  double zedPlus() const {
    return m_zedPlus;
  }  
  double zedMinus() const {
    return m_zedMinus;
  }  

  double etaPlus() const { return m_etaPlus; }    
  double etaMinus() const { return m_etaMinus; }  

  double phiPlus() const { return m_phiPlus; }    
  double phiMinus() const { return m_phiMinus; }  

  int version() const { return m_version; }
  void version(int v) { m_version = v; }

  // virtual operator std::string() const ;

  bool isFullscan() const { return m_fullscan; }


  bool composite() const { return m_composite; }
  void setComposite(bool b = true) { m_composite = b; }

  bool manageConstituents() const { return m_manageConstituents; }
  void manageConstituents(bool b) { m_manageConstituents = b; }

  unsigned size() const { return m_roiDescriptors.size(); }

  const RoiDescriptor* at(int i) const { 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 RoiDescriptor* roi) {
    m_roiDescriptors.push_back(roi);
    setComposite(true);
  }

  roi_iterator begin() const { return m_roiDescriptors.begin(); }
  roi_iterator end() const { return m_roiDescriptors.end(); }

  double dzdrMinus() const {
    return m_dzdrMinus;
  }  
  double dzdrPlus() const {
    return m_dzdrPlus;
  }  

  double drdzMinus() const {
    return m_drdzMinus;
  }  
  double drdzPlus() const {
    return m_drdzPlus;
  }  

  double zedMin(double r) const;
  double zedMax(double r) const;

  double zedOuterPlus() const {
    return m_zedOuterPlus;
  }  
  double zedOuterMinus() const {
    return m_zedOuterMinus;
  }  

  double rhoMin(double z) const;
  double rhoMax(double z) const;

  static double zedWidthDefault() { return s_zedWidthDefault; }

  static void zedWidthDefault(double d);

  // fromn trig
  unsigned int roiId() const { return m_roiId; }
  unsigned int l1Id() const { return m_l1Id; }
  unsigned int roiWord() const { return m_roiWord; }

 private:
  static std::atomic<double> s_zedWidthDefault;
  static std::atomic<bool> s_firstInstanceCreated;

  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 RoiDescriptor*> m_roiDescriptors;  

  // from trig
  unsigned int m_l1Id{0};     
  unsigned int m_roiId{0};    
  unsigned int m_roiWord{0};  


  //   std::string str( const RoiDescriptor& d );                           //<!
  //   printing helper std::ostream& operator<<( std::ostream& m, const
  //   RoiDescriptor& d ); //<! printing helper (wraps above)
};

}  // namespace Acts