TriggerMappingV2.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef ALICEO2_EMCAL_TRIGGERMAPPINGV2_H_
#define ALICEO2_EMCAL_TRIGGERMAPPINGV2_H_
 
#include <array>
#include <bitset>
#include <tuple>
#include "EMCALBase/GeometryBase.h"
 
namespace o2
{
namespace emcal
{
 
class Geometry;
 
class TriggerMappingV2
{
 public:
  //********************************************
  // static constant
  //********************************************
  static constexpr unsigned int SUPERMODULES = 20;                                                    
  static constexpr unsigned int ALLTRUS = 52;                                                         
  static constexpr unsigned int FASTORSETATRU = 8;                                                    
  static constexpr unsigned int FASTORSPHITRU = 12;                                                   
  static constexpr unsigned int FASTORSTRU = FASTORSETATRU * FASTORSPHITRU;                           
  static constexpr unsigned int TRUSETASM = 3;                                                        
  static constexpr unsigned int TRUSPHISM = 1;                                                        
  static constexpr unsigned int TRUSSUPERMODULE = TRUSETASM * TRUSPHISM;                              
  static constexpr unsigned int FASTORSETASM = FASTORSETATRU * TRUSETASM;                             
  static constexpr unsigned int FASTORSPHISM = FASTORSPHITRU * TRUSPHISM;                             
  static constexpr unsigned int FASTORSETA = 2 /*Aside,Cside*/ * FASTORSETASM;                        
  static constexpr unsigned int FASTORSPHI = (5 * FASTORSPHISM) + (1 * FASTORSPHISM / 3)              /*EMCAL*/
                                             + (3 * FASTORSPHISM) + (1 * FASTORSPHISM / 3) /*DCAL */; 
  static constexpr unsigned int ALLFASTORS = FASTORSETA * FASTORSPHI;                                 
  static constexpr unsigned int PATCHESINTRU = 77;
 
  //********************************************
  // Index types
  //********************************************
  using IndexTRU = unsigned int;
  using IndexSTU = unsigned int;
  using IndexSupermodule = unsigned int;
  using IndexFastOR = unsigned int;
  using IndexCell = unsigned int;
  using IndexColumnEta = unsigned int;
  using IndexRowPhi = unsigned int;
  using IndexOnline = unsigned int;
 
  enum class DetType_t {
    DET_EMCAL,
    DET_DCAL
  };
 
  TriggerMappingV2();
 
  TriggerMappingV2(Geometry* geo);
 
  ~TriggerMappingV2() = default;
 
  //********************************************
  // Get FastOR index from TRU/SM/EMCAL Geometry
  //********************************************
 
  IndexFastOR getAbsFastORIndexFromIndexInTRU(IndexTRU truIndex, IndexFastOR fastorIndexTRU) const;
 
  IndexFastOR getAbsFastORIndexFromPositionInTRU(IndexTRU truIndex, IndexColumnEta etaColumn, IndexRowPhi phiRow) const;
 
  IndexFastOR getAbsFastORIndexFromPositionInSupermodule(IndexSupermodule supermoduleID, IndexColumnEta etaColumn, IndexRowPhi phiRow) const;
 
  IndexFastOR getAbsFastORIndexFromPositionInEMCAL(IndexColumnEta etaColumn, IndexRowPhi phiRow) const;
 
  IndexFastOR getAbsFastORIndexFromPHOSSubregion(unsigned int phosRegionID) const;
 
  //********************************************
  // Get TRU/SM/EMCAL Geometry from FastOR index
  //********************************************
  std::tuple<IndexTRU, IndexFastOR> getTRUFromAbsFastORIndex(IndexFastOR fastOrAbsID) const;
 
  std::tuple<IndexTRU, IndexColumnEta, IndexRowPhi> getPositionInTRUFromAbsFastORIndex(IndexFastOR fastORAbsID) const;
 
  std::tuple<IndexSupermodule, IndexColumnEta, IndexRowPhi> getPositionInSupermoduleFromAbsFastORIndex(IndexFastOR fastORAbsID) const;
 
  std::tuple<IndexColumnEta, IndexRowPhi> getPositionInEMCALFromAbsFastORIndex(IndexFastOR fastORAbsID) const;
 
  //********************************************
  // TRU vs. STU
  //********************************************
 
  std::tuple<IndexTRU, IndexFastOR> convertFastORIndexSTUtoTRU(IndexTRU truIndexSTU, IndexFastOR fastOrIndexSTU, DetType_t detector) const;
 
  std::tuple<IndexTRU, IndexFastOR> convertFastORIndexTRUtoSTU(IndexTRU truIndexTRU, IndexFastOR fastorIndexTRU) const;
 
  std::tuple<IndexTRU, IndexColumnEta, IndexRowPhi> convertFastORPositionSTUtoTRU(IndexTRU truIndexSTU, IndexColumnEta truEtaSTU, IndexRowPhi truPhiSTU, DetType_t detector) const;
 
  std::tuple<IndexTRU, IndexColumnEta, IndexRowPhi> convertFastORPositionTRUtoSTU(IndexTRU truIndexTRU, IndexColumnEta etaTRU, IndexRowPhi phiTRU) const;
 
  //********************************************
  // Cell Index
  //********************************************
 
  IndexFastOR getAbsFastORIndexFromCellIndex(IndexCell cellIndex) const;
 
  std::array<IndexCell, 4> getCellIndexFromAbsFastORIndex(IndexFastOR fastORAbsID) const;
 
  //********************************************
  // TRU index
  //********************************************
 
  IndexTRU convertTRUIndexSTUtoTRU(IndexTRU truIndexSTU, DetType_t detector) const;
 
  IndexTRU convertTRUIndexTRUtoSTU(IndexTRU truIndexTRU) const;
 
  IndexTRU getTRUIndexFromOnlineIndex(IndexOnline onlineIndex) const noexcept { return onlineIndex; };
 
  IndexOnline getOnlineIndexFromTRUIndex(IndexTRU truIndex) const { return truIndex; };
 
  IndexTRU getTRUIndexFromOnlineHardareAddree(int hardwareAddress, unsigned int ddlID, unsigned int supermoduleID) const;
 
  //********************************************
  // L0 Index
  //********************************************
 
  std::array<unsigned int, 4> getFastORIndexFromL0Index(IndexTRU iTRU, IndexFastOR l0index, int size) const;
 
  struct FastORInformation {
    unsigned int mTRUID;                
    unsigned int mFastORIDTRU;          
    unsigned int mColumnEtaTRU;         
    unsigned int mRowPhiTRU;            
    unsigned int mSupermoduleID;        
    unsigned int mColumnEtaSupermodule; 
    unsigned int mRowPhiSupermodule;    
  };
 
  FastORInformation getInfoFromAbsFastORIndex(IndexFastOR absFastORID) const;
 
  //********************************************
  // getters arrays (for debugging)
  //********************************************
  const std::array<unsigned int, ALLTRUS>& getArrayTRUFastOROffsetX() const { return mTRUFastOROffsetX; }
  const std::array<unsigned int, ALLTRUS>& getTRUFastOROffsetY() const { return mTRUFastOROffsetY; }
  const std::array<unsigned int, ALLTRUS>& getNFastORInTRUPhi() const { return mNFastORInTRUPhi; }
  const std::array<unsigned int, ALLTRUS>& getNFastORInTRUEta() const { return mNFastORInTRUEta; }
  const std::array<unsigned int, SUPERMODULES>& getArraySMFastOROffsetX() const { return mSMFastOROffsetX; }
  const std::array<unsigned int, SUPERMODULES>& getArraySMFastOROffsetY() const { return mSMFastOROffsetY; }
  const std::array<unsigned int, SUPERMODULES>& getArrayNFastORInSMPhi() const { return mNFastORInSMPhi; }
  const std::array<unsigned int, SUPERMODULES>& getArrayNFastORInSMEta() const { return mNFastORInSMEta; }
  const std::array<unsigned int, 5>& getArrayNModuleInEMCALPhi() const { return mNModuleInEMCALPhi; }
 
 private:
  //********************************************
  // fastOR offset parameters
  //********************************************
  o2::emcal::Geometry* mGeometry;
  std::array<unsigned int, ALLTRUS> mTRUFastOROffsetX; 
  std::array<unsigned int, ALLTRUS> mTRUFastOROffsetY; 
  std::array<unsigned int, ALLTRUS> mNFastORInTRUPhi;  
  std::array<unsigned int, ALLTRUS> mNFastORInTRUEta;  
  std::bitset<ALLTRUS> mTRUIsCside;                    
 
  std::array<unsigned int, SUPERMODULES> mSMFastOROffsetX; // FastOR offset[#of SM ]
  std::array<unsigned int, SUPERMODULES> mSMFastOROffsetY; //
  std::array<unsigned int, SUPERMODULES> mNFastORInSMPhi;  // SM size
  std::array<unsigned int, SUPERMODULES> mNFastORInSMEta;  //
 
  std::array<unsigned int, 5> mNModuleInEMCALPhi; //#FastOR/EMCAL in Phi
 
  //********************************************
  // Initialization of FastOR index offset of each SM/TRU
  //********************************************
 
  void init_TRU_offset();
  void init_SM_offset();
 
  void reset_arrays();
 
  //********************************************
  // Rotation methods from between eta and phi orientation
  //********************************************
 
  IndexFastOR rotateAbsFastOrIndexEtaToPhi(IndexFastOR fastorIndexInEta) const;
 
  IndexFastOR rotateAbsFastOrIndexPhiToEta(IndexFastOR fastorIndexInPhi) const;
 
  EMCALSMType getSupermoduleType(IndexSupermodule supermoduleID) const
  {
    if (supermoduleID >= SUPERMODULES) {
      throw SupermoduleIndexException(supermoduleID, SUPERMODULES);
    }
    if (supermoduleID < 10) {
      return EMCAL_STANDARD;
    }
    if (supermoduleID < 12) {
      return EMCAL_THIRD;
    }
    if (supermoduleID < 18) {
      return DCAL_STANDARD;
    }
    if (supermoduleID < 20) {
      return DCAL_EXT;
    }
    // silence compiler warning (check already done before in order to avoid unnecessary filter)
    throw SupermoduleIndexException(supermoduleID, SUPERMODULES);
  }
 
  bool isSupermoduleOnCSide(IndexSupermodule supermoduleID) const
  {
    return (supermoduleID % 2 == 1) ? true : false;
  }
 
  ClassDefNV(TriggerMappingV2, 1);
};
 
} // namespace emcal
} // namespace o2
 
#endif // ALIEMCALTRIGGERMAPPINGV2_H