InDet::TRT_LocalOccupancy Class Reference

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

#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
virtual float	LocalOccupancy (const EventContext &ctx, const Trk::Track &track) const override
	Return the local occupancy for the sectors crossed by a given track.
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)
virtual std::vector< float >	GlobalOccupancy (const EventContext &ctx) const override
	Return the global occupancy of the event.

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.
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:
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.

{this, "TRTCalDbTool", "TRT_CalDbTool", ""};

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.

{this, "HighGate", 42.1875*Gaudi::Units::ns, ""};

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.

{this, "HighWideGate", 54.6875*Gaudi::Units::ns, ""};

m_isTrigger

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

private

Definition at line 121 of file TRT_LocalOccupancy.h.

{this, "isTrigger", false, ""};

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.

{this, "LowGate", 14.0625*Gaudi::Units::ns, ""};

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.

{this, "LowWideGate", 20.3125*Gaudi::Units::ns, ""};

m_occupancyCacheRead

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

private

Definition at line 118 of file TRT_LocalOccupancy.h.

{"OccupancyData"};

m_occupancyCacheWrite

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

private

Definition at line 119 of file TRT_LocalOccupancy.h.

{"OccupancyData"};

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.

{this,"AliveStraws","AliveStraws","AliveStraws in-key"};

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.

{this,"StrawStatus","StrawStatusData","StrawStatus key"};

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.

{this, "includeT0Shift", true, "choice to use T0shift or not"};

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.

{ this, "TRT_DriftCircleCollection", "TRT_DriftCircles", "m_trt_driftcircles" };

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:

• TRT_LocalOccupancy.h
• TRT_LocalOccupancy.cxx