MuonRoI_v1.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// xAOD include(s):
#include "xAODCore/AuxStoreAccessorMacros.h"
 
// Local include(s):
#include "xAODTrigger/versions/MuonRoI_v1.h"
 
// get bitsmasks from common definition source:
#include "TrigT1MuctpiBits/MuCTPI_Bits.h"
using namespace LVL1::MuCTPIBits;
 
namespace xAOD{
 
   MuonRoI_v1::MuonRoI_v1()
      : SG::AuxElement() {
 
   }

   void MuonRoI_v1::initialize( uint32_t roiword, float eta, float phi,
                                const std::string& thrname, float thrvalue,
                                uint32_t extraword ) {
 
      setRoIWord( roiword );
      setEta( eta );
      setPhi( phi );
      setThrValue( thrvalue );
      setThrName( thrname );
      setRoIExtraWord( extraword );
      return;
   }

   //
   //                    Raw/simple data accessor functions
   //
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( MuonRoI_v1, float, eta, setEta )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( MuonRoI_v1, float, phi, setPhi )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( MuonRoI_v1, uint32_t, roiWord,
                                         setRoIWord )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( MuonRoI_v1, float, thrValue,
                                         setThrValue )
 
   AUXSTORE_OBJECT_SETTER_AND_GETTER( MuonRoI_v1, std::string, thrName,
                                      setThrName )
   // for Run-4+ only
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( MuonRoI_v1, uint32_t, roiExtraWord,
                                         setRoIExtraWord )
   //

   //
   //          Implementation of the RoI word decoder functions
   //                     available only in Run-1/2/3
   //

   int MuonRoI_v1::getThrNumber() const {
     if (isRun4()) return static_cast<int>((roiExtraWord() >> THR_SHIFT) & THR_MASK);
     else if (isRun3()) return ( ( roiWord() >> RUN3_CAND_PT_SHIFT ) & RUN3_CAND_PT_MASK );
     else return ( ( roiWord() >> CAND_PT_SHIFT ) & CAND_PT_MASK );
   }

   int MuonRoI_v1::getRoI() const {
     if (isRun4()) {
       return 0;   // TBI
     } else if (isRun3()) {
       if( this->getSource() == Forward ) {
     return ( ( roiWord() >> RUN3_ROI_SHIFT ) & FORWARD_ROI_MASK );
       } else if( this->getSource() == Endcap ) {
     return ( ( roiWord() >> RUN3_ROI_SHIFT ) & ENDCAP_ROI_MASK );
       } else if( this->getSource() == Barrel ) {
     return ( ( roiWord() >> RUN3_ROI_SHIFT ) & BARREL_ROI_MASK );
       }
     } else {
       if( this->getSource() == Forward ) {
     return ( ( roiWord() >> ROI_SHIFT ) & FORWARD_ROI_MASK );
       } else if( this->getSource() == Endcap ) {
     return ( ( roiWord() >> ROI_SHIFT ) & ENDCAP_ROI_MASK );
       } else if( this->getSource() == Barrel ) {
     return ( ( roiWord() >> ROI_SHIFT ) & BARREL_ROI_MASK );
       }
     }
     return 0;
   }

   int MuonRoI_v1::getSectorAddress() const {
     if (isRun4()) return 0;  // TBI
     else if (isRun3()) return ( ( roiWord() >> RUN3_CAND_SECTOR_ADDRESS_SHIFT ) & CAND_SECTOR_ADDRESS_MASK );
     else return ( ( roiWord() >> CAND_SECTOR_ADDRESS_SHIFT ) & CAND_SECTOR_ADDRESS_MASK );
   }

   int MuonRoI_v1::getSectorID() const {
     if (isRun4()) {
       return 0;   // TBI
     } else if (isRun3()) {
       if( this->getSource() == Forward ) {
     return ( ( roiWord() >> RUN3_CAND_SECTORID_SHIFT ) & FORWARD_SECTORID_MASK );
       } else if( this->getSource() == Endcap ) {
     return ( ( roiWord() >> RUN3_CAND_SECTORID_SHIFT ) & ENDCAP_SECTORID_MASK );
       } else if( this->getSource() == Barrel ) {
     return ( ( roiWord() >> RUN3_CAND_SECTORID_SHIFT ) & BARREL_SECTORID_MASK );
       }
     } else {
       if( this->getSource() == Forward ) {
     return ( ( roiWord() >> CAND_SECTORID_SHIFT ) & FORWARD_SECTORID_MASK );
       } else if( this->getSource() == Endcap ) {
     return ( ( roiWord() >> CAND_SECTORID_SHIFT ) & ENDCAP_SECTORID_MASK );
       } else if( this->getSource() == Barrel ) {
     return ( ( roiWord() >> CAND_SECTORID_SHIFT ) & BARREL_SECTORID_MASK );
       }
     }
     return 0;
   }

   bool MuonRoI_v1::isFirstCandidate() const {
     if (isRun4()) return true;  // TBI
     else if (isRun3()) return true;  // undefined in run3, return default true
     else return ( ( roiWord() >> CAND_HIGHEST_PT_SHIFT ) & CAND_HIGHEST_PT_MASK );
   }

   bool MuonRoI_v1::isMoreCandInRoI() const {
     if (isRun4()) {
       return false;   // TBI
     } else if (isRun3()) {
       if (getSource() == Barrel) return ( ( roiWord() >> RUN3_ROI_OVERFLOW_SHIFT ) & ROI_OVERFLOW_MASK );
       else return false; // Endcap + Fwd have no flag for this
     } else {
       return ( ( roiWord() >> ROI_OVERFLOW_SHIFT ) & ROI_OVERFLOW_MASK );
     }
   }

   bool MuonRoI_v1::isMoreCandInSector() const {
     if (isRun4()) return false;  // TBI
     else if (isRun3()) return ( ( roiWord() >> RUN3_CAND_OVERFLOW_SHIFT ) & CAND_OVERFLOW_MASK );
     else return ( ( roiWord() >> CAND_OVERFLOW_SHIFT ) & CAND_OVERFLOW_MASK );
   }

   MuonRoI_v1::RoISource MuonRoI_v1::getSource() const {
     if (isRun4()) return Barrel;  // TBI - not correct
     //same mask for run2 and run3
     if( this->getSectorAddress() & ENDCAP_ADDRESS_MASK ) {
         return Endcap;
     } else if( this->getSectorAddress() & FORWARD_ADDRESS_MASK ) {
         return Forward;
      } else {
         return Barrel;
      }
   }

   MuonRoI_v1::Hemisphere MuonRoI_v1::getHemisphere() const {
     if (isRun4()) return Positive;  // TBI - not correct
     //same mask for run2 and run3
     if( this->getSectorAddress() & SECTOR_HEMISPHERE_MASK ) {
         return Positive;
      } else {
         return Negative;
      }
   }

   bool MuonRoI_v1::getPhiOverlap() const {
     if (isRun4()) return false;  // TBI
     if (isRun3()) {
       if (getSource() == Barrel) return (roiWord() >> RUN3_CAND_WORD_CANDFLAGS_BA_PHIOVERLAP_SHIFT) & RUN3_CAND_WORD_CANDFLAGS_BA_PHIOVERLAP_MASK;
       else return false;
     } else {
       if (getSource() == Barrel) return (roiWord() >> BARREL_OL_SHIFT) & BARREL_PHI_OL_MASK;
       else return false;
     }
   }

   bool MuonRoI_v1::getEtaOverlap() const {
     if (isRun4()) return false;  // TBI
     if (isRun3()) return false;
     else {
       if (getSource() == Barrel) return (roiWord() >> BARREL_OL_SHIFT) & BARREL_ETA_OL_MASK;
       else return (roiWord() >> ENDCAP_OL_SHIFT) & ENDCAP_OL_MASK;
     }
   }

   MuonRoI_v1::Charge MuonRoI_v1::getCharge() const {
     if (isRun4()) {
       return ((roiWord() >> CHARGE_SHIFT) & 0x1) ? Pos : Neg;
     }
 
     if( getSource() == Barrel ) return Undef;
 
      if (isRun3()) {
    if( ( roiWord() >> RUN3_CAND_TGC_CHARGE_SIGN_SHIFT) & 0x1 ) {
      return Pos;
    } else {
      return Neg;
    }
      } else {
    if( ( roiWord() >> CAND_TGC_CHARGE_SIGN_SHIFT) & 0x1 ) {
      return Pos;
    } else {
      return Neg;
    }
      }
   }

   bool MuonRoI_v1::getBW3Coincidence() const {
     if (isRun4()) return false;  // TBI
     if (isRun3() && getSource() != Barrel) return (roiWord() >> RUN3_CAND_TGC_BW2OR3_SHIFT) & 0x1;
     else return false;
   }
 

   bool MuonRoI_v1::getInnerCoincidence() const {
     if (isRun4()) return false;  // TBI
     if (isRun3() && getSource() != Barrel) return (roiWord() >> RUN3_CAND_TGC_INNERCOIN_SHIFT) & 0x1;
     else return false;
   }
 

   bool MuonRoI_v1::getGoodMF() const {
     if (isRun4()) return false;  // TBI
     if (isRun3() && getSource() != Barrel) return (roiWord() >> RUN3_CAND_TGC_GOODMF_SHIFT) & 0x1;
     else return false;
   }

   bool MuonRoI_v1::isVetoed() const {
     if (isRun4()) return false;  // TBI
     if (isRun3()) return ( ( roiWord() >> RUN3_CAND_VETO_SHIFT) & 0x1 );
     else return ( ( roiWord() >> CAND_VETO_SHIFT) & 0x1 );
   }

   bool MuonRoI_v1::isRun3() const {
     return isRun4() ? false : (roiWord() >> 31 & 0x1);
   }
 
   //

   //
   //   Implementation for Run-4+ only RoI interfaces
   //

   float MuonRoI_v1::pt() const {
     if (isRun4()) return static_cast<float>((roiWord() >> PT_SHIFT) & PT_MASK) * PT_WIDTH;
     else return 0.;
   }

   bool MuonRoI_v1::isRun4() const {
     static const Accessor<uint32_t> acc{"roiExtraWord"};
     if (!acc.isAvailable(*this)) {
       return false;
     } else {
       return (roiExtraWord() > 0);
     }
   }
 
} // namespace xAOD