#include <TRT_LocalOccupancy.h>

Inheritance diagram for InDet::TRT_LocalOccupancy:

Collaboration diagram for InDet::TRT_LocalOccupancy:

Classes
struct	OccupancyData

Public Member Functions
	TRT_LocalOccupancy (const std::string &, const std::string &, const IInterface *)

virtual StatusCode	initialize () override
	standard Athena-Algorithm method More...

virtual float	LocalOccupancy (const EventContext &ctx, const Trk::Track &track) const override
	Return the local occupancy for the sectors crossed by a given track. More...

virtual float	LocalOccupancy (const EventContext &ctx, const double eta, const double phi) const override

virtual std::map< int, double >	getDetectorOccupancy (const EventContext &ctx, const TRT_RDO_Container *p_trtRDOContainer) const override
	Return a map of the occupancy in the barrel (-1,+1) and endcaps (-2,+2) More...

virtual std::vector< float >	GlobalOccupancy (const EventContext &ctx) const override
	Return the global occupancy of the event. More...

Static Public Attributes
static const int	NTOTAL = 7

static const int	NLOCAL = 6

static const int	NWHEEL = 34

static const int	NLOCALPHI = 32

Private Member Functions
const OccupancyData *	getData (const EventContext &ctx) const

std::unique_ptr< OccupancyData >	makeData (const EventContext &ctx) const

std::unique_ptr< OccupancyData >	makeDataTrigger (const EventContext &ctx) const

bool	passValidityGate (unsigned int word, float t0) const

void	countHitsNearTrack (const EventContext &ctx, OccupancyData &data, int track_local[NLOCAL][NLOCALPHI]) const

int	findArrayTotalIndex (const int det, const int lay) const
	To convert from array index to det id and viceversa. More...

int	mapEtaToPartition (const double eta) const

Static Private Member Functions
static bool	isMiddleBXOn (unsigned int word)

static int	mapPhiToPhisector (const double phi)

Private Attributes
const TRT_ID *	m_TRTHelper {}
	External tools: More...

ToolHandle< ITRT_CalDbTool >	m_CalDbTool {this, "TRTCalDbTool", "TRT_CalDbTool", ""}

SG::ReadHandleKey< TRT_DriftCircleContainer >	m_trt_driftcircles { this, "TRT_DriftCircleCollection", "TRT_DriftCircles", "m_trt_driftcircles" }

SG::ReadCondHandleKey< TRTCond::AliveStraws >	m_strawReadKey {this,"AliveStraws","AliveStraws","AliveStraws in-key"}

SG::ReadCondHandleKey< TRTCond::StrawStatusData >	m_strawStatusKey {this,"StrawStatus","StrawStatusData","StrawStatus key"}

SG::ReadHandleKey< OccupancyData >	m_occupancyCacheRead {"OccupancyData"}

SG::WriteHandleKey< OccupancyData >	m_occupancyCacheWrite {"OccupancyData"}

Gaudi::Property< bool >	m_isTrigger {this, "isTrigger", false, ""}

Gaudi::Property< bool >	m_T0Shift {this, "includeT0Shift", true, "choice to use T0shift or not"}

Gaudi::Property< float >	m_lowGate {this, "LowGate", 14.0625*Gaudi::Units::ns, ""}

Gaudi::Property< float >	m_highGate {this, "HighGate", 42.1875*Gaudi::Units::ns, ""}

Gaudi::Property< float >	m_lowWideGate {this, "LowWideGate", 20.3125*Gaudi::Units::ns, ""}

Gaudi::Property< float >	m_highWideGate {this, "HighWideGate", 54.6875*Gaudi::Units::ns, ""}

Detailed Description

TRT_LocalOccupancy is a tool to compute the TRT occupancy for the elements crossed by a track.

This tool has to be called with: StartEvent() before checking occupancy for a given track, so the different volumes are computed.

Then, for each track call LocalOccupancy( Track ) and a will be returned.

Author: Alejandro Alonso: Aleja.nosp@m.ndro.nosp@m..Alon.nosp@m.so@c.nosp@m.ern.c.nosp@m.h

Definition at line 52 of file TRT_LocalOccupancy.h.

Constructor & Destructor Documentation

◆ TRT_LocalOccupancy()

InDet::TRT_LocalOccupancy::TRT_LocalOccupancy	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 42 of file TRT_LocalOccupancy.cxx.

   :
   base_class(t,n,p)
 {
 }

Member Function Documentation

◆ countHitsNearTrack()

void InDet::TRT_LocalOccupancy::countHitsNearTrack	(	const EventContext &	ctx,
		OccupancyData &	data,
		int	track_local[NLOCAL][NLOCALPHI]
	)		const

private

Definition at line 262 of file TRT_LocalOccupancy.cxx.

 {
  
     SG::ReadHandle<TRT_DriftCircleContainer> driftCircleContainer( m_trt_driftcircles,ctx );
     if (!driftCircleContainer.isValid()){
       ATH_MSG_FATAL("driftCircleContainer " << m_trt_driftcircles << " not available");
       return;
     }
  
     bool allOfEndcapAFound[2][NLOCALPHI] = {{false}};
  
     for (int i=0; i<NLOCAL; ++i){
       for (int j=0; j<NLOCALPHI; ++j){
  
     // we are only interested in filling regions through which track passed
     if (track_local[i][j] < 1) continue;
  
     // if we already filled this region, skip it
     if (data.m_hit_local[i][j] > 0) continue;
  
     for (const InDet::TRT_DriftCircleCollection *colNext : *driftCircleContainer) {
       if (!colNext) continue;
       DataVector<TRT_DriftCircle>::const_iterator p_rdo           =    colNext->begin();
       DataVector<TRT_DriftCircle>::const_iterator p_rdo_end       =    colNext->end();
       for(; p_rdo!=p_rdo_end; ++p_rdo){
         const TRT_DriftCircle* rdo = (*p_rdo);
         if(!rdo)        continue;
  
           Identifier id = rdo->identify();
  
           int det      = m_TRTHelper->barrel_ec(         id)     ;
           int lay      = m_TRTHelper->layer_or_wheel(    id)     ;
           int phi      = m_TRTHelper->phi_module(        id)     ;
           int i_total       = findArrayTotalIndex(det, lay)-1;
  
           if (i_total != i || phi != j) continue; // only fill the one region [i][j]
  
           if (i%3==1 && lay>4)  allOfEndcapAFound[(i<3?0:1)][phi]=true;  //why the rescaling below?
  
           data.m_hit_local[i_total][phi]           +=1;
       }
     }
  
     int hits = data.m_hit_local[i][j];
     int stws = data.m_stw_local[i][j];
     data.m_occ_local[i][j] = int(hits*100) / stws;
  
       }
     }
  
     bool region_rescaled[NLOCAL][NLOCALPHI] = {{false}};
  
     // rescale endcap A regions if not all wheels were counted
     for (int i=0; i<NLOCAL; ++i){
       for (int j=0; j<NLOCALPHI; ++j){
     if (i%3!=1) continue; // only looking in endcapA
     // we are only interested in regions through which track passed
     if (track_local[i][j] < 1) continue;
     if (!allOfEndcapAFound[(i<3?0:1)][j] && !region_rescaled[i][j]){
       // if there are no hits in last wheel of endcapA
       // && we haven't already rescaled this region:
       // scale it down so the denominator is realistic
       data.m_occ_local[i][j]/=(data.m_stws_ratio[(i<3?0:1)][j]);
       region_rescaled[i][j]=true;
     }
     else if (allOfEndcapAFound[(i<3?0:1)][j] && region_rescaled[i][j]){
       // if there are hits in last wheel of endcapA
       // && we already rescaled this region:
       // scale it back up to count all of endcapA
       data.m_occ_local[i][j]*=(data.m_stws_ratio[(i<3?0:1)][j]);
       region_rescaled[i][j]=false;
     }
       }
     }
  
     }

◆ findArrayTotalIndex()

int InDet::TRT_LocalOccupancy::findArrayTotalIndex	(	const int	det,
		const int	lay
	)		const

private

To convert from array index to det id and viceversa.

Definition at line 403 of file TRT_LocalOccupancy.cxx.

                                                                                 {
     int arrayindex = 0; // to be reset below
     // NOTE: Below, arrayindex starts at 1
     // because index 0 is filled with TOTAL value.
     if      (det == -1) arrayindex = 1; // barrel side C
     else if (det == -2) {               // endcap side C
       if (lay < 6)      arrayindex = 2; //   wheel A
       else              arrayindex = 3; //   wheel B
     }
     else if (det ==  1) arrayindex = 4; // barrel side A
     else if (det ==  2) {               // endcap side A
       if (lay < 6)      arrayindex = 5; //   wheel A
       else              arrayindex = 6; //   wheel B
     }
     else        ATH_MSG_WARNING(" detector value is: " << det << ", out of range -2, -1, 1, 2, so THIS IS NOT TRT!!!");
     return arrayindex;
   }

◆ getData()

const TRT_LocalOccupancy::OccupancyData * InDet::TRT_LocalOccupancy::getData ( const EventContext & ctx ) const

private

Definition at line 452 of file TRT_LocalOccupancy.cxx.

 {
   SG::ReadHandle<OccupancyData> rh (m_occupancyCacheRead,ctx);
   if (rh.isValid()){
     return rh.cptr();
   }
  
   SG::WriteHandle<OccupancyData> wh (m_occupancyCacheWrite,ctx);
   return wh.put (makeData(ctx), true);
 }

◆ getDetectorOccupancy()

std::map< int, double > InDet::TRT_LocalOccupancy::getDetectorOccupancy	(	const EventContext &	ctx,
		const TRT_RDO_Container *	p_trtRDOContainer
	)		const

overridevirtual

Return a map of the occupancy in the barrel (-1,+1) and endcaps (-2,+2)

Definition at line 191 of file TRT_LocalOccupancy.cxx.

 {
   SG::ReadCondHandle<TRTCond::StrawStatusData> strawStatusHandle{m_strawStatusKey, ctx};
   const TRTCond::StrawStatusData *strawStatus{*strawStatusHandle};
  
   std::map<int,int> hitCounter;
   std::map<int,double> occResults;
  
   TRT_RDO_Container::const_iterator RDO_collection_iter = p_trtRDOContainer->begin();
   TRT_RDO_Container::const_iterator RDO_collection_end  = p_trtRDOContainer->end();
   for ( ; RDO_collection_iter!= RDO_collection_end; ++RDO_collection_iter) {
     const InDetRawDataCollection<TRT_RDORawData>* RDO_Collection(*RDO_collection_iter);
     if (!RDO_Collection) continue;
     if (!RDO_Collection->empty()){
       DataVector<TRT_RDORawData>::const_iterator r,rb=RDO_Collection->begin(),re=RDO_Collection->end();
  
       for(r=rb; r!=re; ++r) {
         if (!*r)
           continue;
  
         Identifier rdo_id = (*r)->identify();
         IdentifierHash straw_hash = m_TRTHelper->straw_hash(rdo_id);
  
         //Check if straw is OK
         if (strawStatus->findStatus(straw_hash) != TRTCond::StrawStatus::Good) {
           continue;
         }
  
         int det      = m_TRTHelper->barrel_ec(rdo_id)     ;
  
         unsigned int word = (*r)->getWord();
  
         double t0 = 0.;
         if (m_T0Shift) {
            unsigned  mask = 0x02000000;
           bool SawZero = false;
           int tdcvalue;
           for(tdcvalue=0;tdcvalue<24;++tdcvalue)
           {
             if      (  (word & mask) && SawZero) break;
             if ( !(word & mask) ) SawZero = true;
             mask>>=1;
             if(tdcvalue==7 || tdcvalue==15) mask>>=1;
           }
           if(tdcvalue!=0 && tdcvalue!=24) {
             t0 =  m_CalDbTool->getT0(rdo_id);
           }
         }
  
         if (!passValidityGate(word, t0)) continue;
  
         hitCounter[det] +=1;
       }
     }
   }
  
   SG::ReadCondHandle<TRTCond::AliveStraws> strawHandle{m_strawReadKey, ctx};
   const TRTCond::AliveStraws* strawCounts{*strawHandle};
  
   const std::array<int,TRTCond::AliveStraws::NTOTAL> &straws = strawCounts->getStwTotal();
  
   occResults[-1] = (double)hitCounter[-1]/(double)straws[1];
   occResults[-2] = (double)hitCounter[-2]/(double)(straws[2] + straws[3]);
   occResults[1]  = (double)hitCounter[1] /(double)straws[4];
   occResults[2]  = (double)hitCounter[2] /(double)(straws[5] + straws[6]);
  
   return occResults;
 }

◆ GlobalOccupancy()

std::vector< float > InDet::TRT_LocalOccupancy::GlobalOccupancy ( const EventContext & ctx ) const

overridevirtual

Return the global occupancy of the event.

7 Floats: TRT, Barrel A / C, endcapA/B A/C

Definition at line 80 of file TRT_LocalOccupancy.cxx.

                                                                                   {
   std::vector<float>    output              ;
   if (m_isTrigger) {
     ATH_MSG_INFO("Cannot compute Global Occupancies in trigger environment! Returning empty vector");
     return output;
   }
  
   const OccupancyData* data = getData(ctx);
   if (!data) {
     ATH_MSG_INFO("Cannot get occupancy data.  Returning empty vector.");
     return output;
   }
  
   output.push_back( data->m_occ_total[0]*1.e-2    ) ;   //  Whole TRT
   output.push_back( data->m_occ_total[1]*1.e-2  )   ;   //  Barrel  C
   output.push_back( data->m_occ_total[2]*1.e-2  )   ;   //  EndcapA C
   output.push_back( data->m_occ_total[3]*1.e-2  )   ;   //  EndcapB C
   output.push_back( data->m_occ_total[4]*1.e-2  )   ;   //  Barrel  A
   output.push_back( data->m_occ_total[5]*1.e-2  )   ;   //  EndcapA A
   output.push_back( data->m_occ_total[6]*1.e-2  )   ;   //  EndcapB A
  
   ATH_MSG_DEBUG("Compute Global Occupancy: whole TRT: "
                 << output.at(0) << "\t Barrel C: " << output.at(1)
                 << "\t EndcapA C: " << output.at(2) << "\t EndcapB C: "
                 << output.at(3) << "\t Barrel A: " << output.at(4)
                 << "\t EndcapA A: " << output.at(5)
                 << "\t EndcapB A: " << output.at(6));
   return output;
 }

◆ initialize()

StatusCode InDet::TRT_LocalOccupancy::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 51 of file TRT_LocalOccupancy.cxx.

 {
   // The TRT helper:
   CHECK( detStore()->retrieve(m_TRTHelper, "TRT_ID") );
  
   // access to t0 and straw status
   if (m_T0Shift) {
     CHECK( m_CalDbTool.retrieve());
   }
   else { //use wider validity gate if no T0 shift
     m_lowGate  = m_lowWideGate ;
     m_highGate = m_highWideGate ;
   }
  
   //Initialize ReadHandleKeys -  AllowEmpty has to be kept for overlay client passing RDOs as input arg
   ATH_CHECK( m_trt_driftcircles.initialize(SG::AllowEmpty));
  
   ATH_CHECK( m_strawStatusKey.initialize() );
   ATH_CHECK( m_strawReadKey.initialize() );
  
   std::string OccupancyCacheName = "GlobalTRTOccupancyData";
   m_occupancyCacheRead = OccupancyCacheName;
   m_occupancyCacheWrite = OccupancyCacheName;
   ATH_CHECK(m_occupancyCacheRead.initialize());
   ATH_CHECK(m_occupancyCacheWrite.initialize());
  
   return StatusCode::SUCCESS;
 }

◆ isMiddleBXOn()

bool InDet::TRT_LocalOccupancy::isMiddleBXOn ( unsigned int word )

staticprivate

Definition at line 373 of file TRT_LocalOccupancy.cxx.

                                                        {
   // check that there is at least one hit in middle 25 ns
   unsigned mask = 0x00010000;
   int i=0;
   for (i=0; i<8; ++i) {
     if (word & mask) return true;
     mask >>= 1;
   }
 return false;
 }

◆ LocalOccupancy() [1/2]

float InDet::TRT_LocalOccupancy::LocalOccupancy	(	const EventContext &	ctx,
		const double	eta,
		const double	phi
	)		const

overridevirtual

Definition at line 341 of file TRT_LocalOccupancy.cxx.

                                                                      {
     // take eta, phi of track, RoI, ... what have you
     // return local occupancy in an appropriate region of the detector
     // size of region is:
     //   - 1 of 6 partitions (barrel, endcapA, endcapB, sides A & C)
     //   - 1 of 32 phi modules (in triangular shape of chips, not 'pie slices')
     ATH_MSG_DEBUG("LocalOccupancy(eta,phi)");
  
     const OccupancyData* data = getData(ctx);
     if (!data) {
       ATH_MSG_ERROR ("Cannot get occupancy data.");
       return 0;
     }
  
     int partition=mapEtaToPartition(t_eta);
     int phisector=mapPhiToPhisector(t_phi);
  
     if (partition > 5 || phisector > 31) {
       ATH_MSG_DEBUG("mapping failed ; returning global occ");
       return data->m_occ_total[0]*1.e-2 ;
     }
  
     float mapped_occ = data->m_occ_local[partition][phisector]*1.e-2;
     ATH_MSG_DEBUG("returning mapped occupancy");
     return mapped_occ;
  
   }

◆ LocalOccupancy() [2/2]

float InDet::TRT_LocalOccupancy::LocalOccupancy	(	const EventContext &	ctx,
		const Trk::Track &	track
	)		const

overridevirtual

Return the local occupancy for the sectors crossed by a given track.

Definition at line 111 of file TRT_LocalOccupancy.cxx.

                                                                                              {
   ATH_MSG_DEBUG("Compute LocalOccupancy(const Trk::Track& track ) for tool: " << name());
  
   int track_local[NLOCAL][NLOCALPHI]= {{0}};
  
   const Trk::TrackStates* trackStates = track.trackStateOnSurfaces();
   Trk::TrackStates::const_iterator  tsos        =trackStates->begin();
   Trk::TrackStates::const_iterator  tsosEnd     =trackStates->end();
   for (;tsos!=tsosEnd;++tsos) {
     const Trk::MeasurementBase* mesb = (*tsos)->measurementOnTrack();
     if (!mesb) {
       continue;
     }
     const InDet::TRT_DriftCircleOnTrack* driftcircle = nullptr;
     if (mesb->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
       const Trk::RIO_OnTrack* tmpRio = static_cast<const Trk::RIO_OnTrack*>(mesb);
       if (tmpRio->rioType(Trk::RIO_OnTrackType::TRT_DriftCircle)) {
         driftcircle = static_cast<const InDet::TRT_DriftCircleOnTrack*>(tmpRio);
       }
     }
  
     if(!driftcircle) {
       continue;
     }
  
     Identifier id=driftcircle->identify();
     int det = m_TRTHelper->barrel_ec(         id)     ;
     int lay = m_TRTHelper->layer_or_wheel(    id)     ;
     int phi = m_TRTHelper->phi_module(        id)     ;
  
     int i_total = findArrayTotalIndex(det, lay);
     track_local[i_total-1][phi]     +=1;
  
   }
  
   std::unique_ptr<OccupancyData> data_ptr;
   const OccupancyData* data = nullptr;
   if (m_isTrigger) {
     data_ptr = makeDataTrigger(ctx);
     countHitsNearTrack(ctx, *data_ptr, track_local);
     data = data_ptr.get();
   }
   else
     data = getData(ctx);
  
   if (!data) {
     ATH_MSG_INFO("Cannot get occupancy data.  Returning 0.");
     return 0;
   }
  
   float  averageocc   = 0;
   int    nhits        = 0;
   const std::array<std::array<int,NLOCALPHI>,NLOCAL> &stw_local = data->m_stw_local;
  
   for (int i=0; i<6; ++i){
      for (int j = 0; j < 32; j++){
  
         float hits_array  = track_local[i][j] ;
         if (hits_array<1) continue;
     float occ=0;
     occ =  (data->m_occ_local [i][j])*1.e-2 ;
     if (stw_local[i][j] != 0){
       if(occ == 0 && float(hits_array)/stw_local[i][j] > 0.01){
         ATH_MSG_DEBUG("Occupancy is 0 for : " << i << " " << j << " BUT THERE ARE HITS!!!: " << hits_array);
         continue;
       }
     }
         averageocc  += (occ*hits_array);
         nhits       += hits_array;
  
     ATH_MSG_DEBUG("new track: " << i << " " << j << "\t" << hits_array << "\t" << occ );
      }
   }
   if (nhits>0)  averageocc  = averageocc / nhits;
   ATH_MSG_DEBUG("Compute LocalOccupancy(const Trk::Track& track ) for tool: " << averageocc << " is over" );
  
   return averageocc;
 }

◆ makeData()

std::unique_ptr< TRT_LocalOccupancy::OccupancyData > InDet::TRT_LocalOccupancy::makeData ( const EventContext & ctx ) const

private

Definition at line 465 of file TRT_LocalOccupancy.cxx.

 {
   // count live straws
   SG::ReadCondHandle<TRTCond::AliveStraws> strawHandle{m_strawReadKey, ctx};
   const TRTCond::AliveStraws* strawCounts{*strawHandle};
  
   auto data = std::make_unique<OccupancyData>(strawCounts->getStwLocal());
  
   // put # hits in vectors
   if ( m_trt_driftcircles.empty() ) {
     ATH_MSG_WARNING("No TRT Drift Circles key is empty");
   } else {
     SG::ReadHandle<TRT_DriftCircleContainer> driftCircleContainer( m_trt_driftcircles,ctx );
     if ( driftCircleContainer.isValid() ) {
       ATH_MSG_DEBUG("Found Drift Circles in StoreGate");
       for (const InDet::TRT_DriftCircleCollection *colNext : *driftCircleContainer) {
         if(!colNext) continue;
         // loop over DCs
         DataVector<TRT_DriftCircle>::const_iterator p_rdo           =    colNext->begin();
         DataVector<TRT_DriftCircle>::const_iterator p_rdo_end       =    colNext->end();
         for(; p_rdo!=p_rdo_end; ++p_rdo){
           const TRT_DriftCircle* rdo = (*p_rdo);
           if(!rdo)        continue;
           Identifier id = rdo->identify();
  
           int det      = m_TRTHelper->barrel_ec(         id)     ;
           int lay      = m_TRTHelper->layer_or_wheel(    id)     ;
           int phi      = m_TRTHelper->phi_module(        id)     ;
           int i_total  = findArrayTotalIndex(det, lay);
  
           data->m_hit_total[0]                        +=1;
           data->m_hit_total[i_total]                  +=1;
           data->m_hit_local[i_total-1][phi]           +=1;
         }
       }
     } else {
       ATH_MSG_WARNING("No TRT Drift Circles in StoreGate");
     }
   }
  
   const std::array<int,NTOTAL> &stw_total = strawCounts->getStwTotal();
   const std::array<std::array<int,NLOCALPHI>,NLOCAL> &stw_local = strawCounts->getStwLocal();
  
   // Calculate Occs:
   for (int i=0; i<NTOTAL; ++i) {
     float occ = 0;
     int hits  = data->m_hit_total[i];
     int stws  = stw_total[i];
     if (stws>0) occ = float(hits*100)/stws;
     data->m_occ_total[i] = int(occ);
   }
   for (int i=0; i<NLOCAL; ++i) {
     for (int j=0; j<NLOCALPHI; ++j) {
       float occ = 0;
       int hits  = data->m_hit_local[i][j];
       int stws  = stw_local[i][j];
       if (stws>0) occ = float(hits*100)/stws;
       data->m_occ_local[i][j] = int(occ);
     }
   }
  
   ATH_MSG_DEBUG("Active straws: " << stw_total[0] << "\t total number of hits: "
                                   << data->m_hit_total[0]
                                   << "\t occ: " << data->m_occ_total[0]);
   return data;
 }

◆ makeDataTrigger()

std::unique_ptr< TRT_LocalOccupancy::OccupancyData > InDet::TRT_LocalOccupancy::makeDataTrigger ( const EventContext & ctx ) const

private

Definition at line 534 of file TRT_LocalOccupancy.cxx.

 {
   SG::ReadCondHandle<TRTCond::AliveStraws> strawHandle{m_strawReadKey, ctx};
   const TRTCond::AliveStraws* strawCounts{*strawHandle};
  
   auto data = std::make_unique<OccupancyData>(strawCounts->getStwLocal());
   const std::array<std::array<int,NLOCALPHI>,NLOCAL> &stw_local = strawCounts->getStwLocal();;
   const std::array<std::array<int,NLOCALPHI>,NWHEEL> &stw_wheel = strawCounts->getStwWheel();
  
   for (int i=0; i<5; ++i){
     for (int j=0; j<NLOCALPHI; ++j){
       data->m_stws_ratio[0][j]+=float(stw_wheel[i+3 ][j])/stw_local[1][j];
       data->m_stws_ratio[1][j]+=float(stw_wheel[i+20][j])/stw_local[4][j];
     }
   }
  
   return data;
 }

◆ mapEtaToPartition()

int InDet::TRT_LocalOccupancy::mapEtaToPartition ( const double eta ) const

private

Definition at line 434 of file TRT_LocalOccupancy.cxx.

                                                                   {
  
   int partition=7;
  
   double abseta = fabs(t_eta);
  
   // do eta selection
   if      (                  abseta <= 0.90 ) partition = 0;
   else if ( abseta > 0.90 && abseta <= 1.55 ) partition = 1;
   else if ( abseta > 1.55 && abseta <= 2.00 ) partition = 2;
   else ATH_MSG_DEBUG("abs(eta) > 2.0 ; not in TRT!");
  
   if (t_eta>0.) partition += 3; // side A
  
   return partition;
 }

◆ mapPhiToPhisector()

int InDet::TRT_LocalOccupancy::mapPhiToPhisector ( const double phi )

staticprivate

Definition at line 421 of file TRT_LocalOccupancy.cxx.

                                                             {
  
   int phisector=33;
   // do phi selection
   // shift all phi to positive numbers
   float dphi = 0; // TBD
  
   double phi2pi = (t_phi > 0) ? t_phi : t_phi + 2*M_PI;
  
   phisector = int ( (phi2pi + dphi)*32./(2*M_PI) );
   return phisector;
 }

◆ passValidityGate()

bool InDet::TRT_LocalOccupancy::passValidityGate	(	unsigned int	word,
		float	t0
	)		const

private

Definition at line 384 of file TRT_LocalOccupancy.cxx.

                                                                            {
   bool foundInterval = false;
   unsigned  mask = 0x02000000;
   int i = 0;
   while ( !foundInterval && (i < 24) ) {
     if (word & mask) {
       float thisTime = ((0.5+i)*3.125)-t0;
       if (thisTime >= m_lowGate && thisTime <= m_highGate) foundInterval = true;
     }
     mask >>= 1;
     if (i == 7 || i == 15)
       mask >>= 1;
     i++;
   }
   return foundInterval;
 }

Member Data Documentation

◆ m_CalDbTool

ToolHandle< ITRT_CalDbTool > InDet::TRT_LocalOccupancy::m_CalDbTool {this, "TRTCalDbTool", "TRT_CalDbTool", ""}

private

Definition at line 112 of file TRT_LocalOccupancy.h.

◆ m_highGate

Gaudi::Property<float> InDet::TRT_LocalOccupancy::m_highGate {this, "HighGate", 42.1875*Gaudi::Units::ns, ""}

private

Definition at line 124 of file TRT_LocalOccupancy.h.

◆ m_highWideGate

Gaudi::Property<float> InDet::TRT_LocalOccupancy::m_highWideGate {this, "HighWideGate", 54.6875*Gaudi::Units::ns, ""}

private

Definition at line 127 of file TRT_LocalOccupancy.h.

◆ m_isTrigger

Gaudi::Property<bool> InDet::TRT_LocalOccupancy::m_isTrigger {this, "isTrigger", false, ""}

private

Definition at line 121 of file TRT_LocalOccupancy.h.

◆ m_lowGate

Gaudi::Property<float> InDet::TRT_LocalOccupancy::m_lowGate {this, "LowGate", 14.0625*Gaudi::Units::ns, ""}

private

Definition at line 123 of file TRT_LocalOccupancy.h.

◆ m_lowWideGate

Gaudi::Property<float> InDet::TRT_LocalOccupancy::m_lowWideGate {this, "LowWideGate", 20.3125*Gaudi::Units::ns, ""}

private

Definition at line 126 of file TRT_LocalOccupancy.h.

◆ m_occupancyCacheRead

SG::ReadHandleKey<OccupancyData> InDet::TRT_LocalOccupancy::m_occupancyCacheRead {"OccupancyData"}

private

Definition at line 118 of file TRT_LocalOccupancy.h.

◆ m_occupancyCacheWrite

SG::WriteHandleKey<OccupancyData> InDet::TRT_LocalOccupancy::m_occupancyCacheWrite {"OccupancyData"}

private

Definition at line 119 of file TRT_LocalOccupancy.h.

◆ m_strawReadKey

SG::ReadCondHandleKey<TRTCond::AliveStraws> InDet::TRT_LocalOccupancy::m_strawReadKey {this,"AliveStraws","AliveStraws","AliveStraws in-key"}

private

Definition at line 115 of file TRT_LocalOccupancy.h.

◆ m_strawStatusKey

SG::ReadCondHandleKey<TRTCond::StrawStatusData> InDet::TRT_LocalOccupancy::m_strawStatusKey {this,"StrawStatus","StrawStatusData","StrawStatus key"}

private

Definition at line 116 of file TRT_LocalOccupancy.h.

◆ m_T0Shift

Gaudi::Property<bool> InDet::TRT_LocalOccupancy::m_T0Shift {this, "includeT0Shift", true, "choice to use T0shift or not"}

private

Definition at line 122 of file TRT_LocalOccupancy.h.

◆ m_trt_driftcircles

SG::ReadHandleKey<TRT_DriftCircleContainer> InDet::TRT_LocalOccupancy::m_trt_driftcircles { this, "TRT_DriftCircleCollection", "TRT_DriftCircles", "m_trt_driftcircles" }

private

Definition at line 113 of file TRT_LocalOccupancy.h.

◆ m_TRTHelper

const TRT_ID* InDet::TRT_LocalOccupancy::m_TRTHelper {}

private

External tools:

Definition at line 111 of file TRT_LocalOccupancy.h.

◆ NLOCAL

const int InDet::TRT_LocalOccupancy::NLOCAL = 6

static

Definition at line 77 of file TRT_LocalOccupancy.h.

◆ NLOCALPHI

const int InDet::TRT_LocalOccupancy::NLOCALPHI = 32

static

Definition at line 79 of file TRT_LocalOccupancy.h.

◆ NTOTAL

const int InDet::TRT_LocalOccupancy::NTOTAL = 7

static

Definition at line 75 of file TRT_LocalOccupancy.h.

◆ NWHEEL

const int InDet::TRT_LocalOccupancy::NWHEEL = 34

static

Definition at line 78 of file TRT_LocalOccupancy.h.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TRT_LocalOccupancy()

Member Function Documentation

◆ countHitsNearTrack()

◆ findArrayTotalIndex()

◆ getData()

◆ getDetectorOccupancy()

◆ GlobalOccupancy()

◆ initialize()

◆ isMiddleBXOn()

◆ LocalOccupancy() [1/2]

◆ LocalOccupancy() [2/2]

◆ makeData()

◆ makeDataTrigger()

◆ mapEtaToPartition()

◆ mapPhiToPhisector()

◆ passValidityGate()

Member Data Documentation

◆ m_CalDbTool

◆ m_highGate

◆ m_highWideGate

◆ m_isTrigger

◆ m_lowGate

◆ m_lowWideGate

◆ m_occupancyCacheRead

◆ m_occupancyCacheWrite

◆ m_strawReadKey

◆ m_strawStatusKey

◆ m_T0Shift

◆ m_trt_driftcircles

◆ m_TRTHelper

◆ NLOCAL

◆ NLOCALPHI

◆ NTOTAL

◆ NWHEEL