SCT_CalibHvTool Class Reference

#include <SCT_CalibHvTool.h>

Inheritance diagram for SCT_CalibHvTool:

Collaboration diagram for SCT_CalibHvTool:

Public Member Functions
	SCT_CalibHvTool (const std::string &, const std::string &, const IInterface *)
virtual	~SCT_CalibHvTool ()=default
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
virtual bool	book ()
virtual bool	fill (const bool fromData=false)
virtual bool	fillFromData ()

Private Types
enum	{   n_chipPerSide = 6, n_chipPerModule = 12, n_stripPerChip = 128, n_etaInBarrel = 12,   n_phiBinsB0 = 32, n_phiBinsB1 = 40, n_phiBinsB2 = 48, n_phiBinsB3 = 56,   n_phiBinsECShort = 40, n_phiBinsECMiddle = 40, n_phiBinsECOuter = 52, n_elements =8176,   n_BSErrorType = 15, firstBSErrorType = 0, lastBSErrorType = 14 }
typedef std::vector< int >	VecInt

Private Member Functions
template<class T >
bool	retrievedTool (T &tool, const std::string &toolName) const
	retrieve a tool and report if it failed More...

Private Attributes
ToolHandle< ISCT_DCSConditionsTool >	m_DCSConditionsTool {this, "SCT_DCSConditionsTool", "SCT_DCSConditionsTool", "Tool to retrieve SCT DCS information"}
const SCT_ID *	m_pSCTHelper {nullptr}
SCT_ID::const_id_iterator	m_waferItrBegin
SCT_ID::const_id_iterator	m_waferItrEnd
VecInt *	m_sct_waferHash {nullptr}
VecInt *	m_sct_numHitsInWafer {nullptr}
int	m_maxq {100}
std::vector< std::queue< int > >	m_phvtripQueue
std::queue< int >	m_prevLBN
VecInt	m_phvtripRunningTotalInt
VecInt	m_phvtripProcessedEventsInt
VecInt	m_phvtripHasItTripped
VecInt	m_phvtripHasItTripped_prev
int	m_phvtripPrevTime {0}
int	m_phvtripFirstTime {0}
double	m_absolutetriplimit {0}
double	m_relativetriplimit {0}
int	m_tq [100] {0}
std::vector< std::vector< std::pair< int, int > > >	m_summarytrips
std::vector< std::vector< std::pair< int, int > > >	m_summarytripslb
bool	m_outputLowHits {false}
int	m_lowHitCut {100}

Detailed Description

Definition at line 38 of file SCT_CalibHvTool.h.

Member Typedef Documentation

VecInt

typedef std::vector<int> SCT_CalibHvTool::VecInt

private

Definition at line 68 of file SCT_CalibHvTool.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
n_chipPerSide
n_chipPerModule
n_stripPerChip
n_etaInBarrel
n_phiBinsB0
n_phiBinsB1
n_phiBinsB2
n_phiBinsB3
n_phiBinsECShort
n_phiBinsECMiddle
n_phiBinsECOuter
n_elements
n_BSErrorType
firstBSErrorType
lastBSErrorType

Definition at line 57 of file SCT_CalibHvTool.h.

           {n_chipPerSide = 6, n_chipPerModule = 12, n_stripPerChip = 128, n_etaInBarrel = 12,
            n_phiBinsB0 = 32, n_phiBinsB1 = 40, n_phiBinsB2 = 48, n_phiBinsB3 = 56,
            n_phiBinsECShort = 40, n_phiBinsECMiddle = 40, n_phiBinsECOuter = 52, n_elements=8176,
            n_BSErrorType = 15, firstBSErrorType = 0, lastBSErrorType = 14
           };

Constructor & Destructor Documentation

SCT_CalibHvTool()

SCT_CalibHvTool::SCT_CalibHvTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 24 of file SCT_CalibHvTool.cxx.

                                                                                                       :
   base_class(type, name, parent)
{
}

~SCT_CalibHvTool()

virtual SCT_CalibHvTool::~SCT_CalibHvTool ( )

virtualdefault

Member Function Documentation

book()

bool SCT_CalibHvTool::book ( )

virtual

Definition at line 41 of file SCT_CalibHvTool.cxx.

                      {
   bool result{true};
   ATH_MSG_DEBUG("Book HVTrips");
   //now initialize the queues (fill 100 spots with 0):
   std::queue<int> qtemp;
   initQueue(qtemp, m_maxq,0);
   // need to keep previous bins lbn 4 deep.
   initQueue(m_prevLBN, 4, 0);
   std::vector<std::pair <int,int>> dummy;
   //first set num events processed to 0
   m_phvtripProcessedEventsInt.insert(m_phvtripProcessedEventsInt.end(), n_elements, 1);
   m_phvtripRunningTotalInt.insert(m_phvtripRunningTotalInt.end(), n_elements, 0);
   m_phvtripHasItTripped.insert(m_phvtripHasItTripped.end(),n_elements, 0);
   m_phvtripQueue.insert(m_phvtripQueue.end(), n_elements, qtemp);
   m_summarytrips.insert(m_summarytrips.end(),n_elements, dummy);
   m_summarytripslb.insert(m_summarytripslb.end(), n_elements, dummy);
   m_phvtripHasItTripped_prev = m_phvtripHasItTripped;
   return result;
}

fill()

bool SCT_CalibHvTool::fill ( const bool  fromData = false )

virtual

calculate the limit for an individual module, limit is m_relativetriplimit (default = 4) times the running average in that module. limits are given in hits/second. need to convert numhits in bin to average (within bin) hits/sec.

Definition at line 62 of file SCT_CalibHvTool.cxx.

                                         {
   const EventContext& ctx = Gaudi::Hive::currentContext();
 
   if (fromData) {
      return fillFromData();
   }
   bool result{true};
   int lumi_block{0}; //fix me!
   const int wafersize{static_cast<int>(m_sct_waferHash->size())};
   int time_stamp{static_cast<int>(ctx.eventID().time_stamp())};
   int curr_time{time_stamp};
   int dtime{curr_time - m_phvtripPrevTime};
   int totalHits{0};
   if (curr_time<m_phvtripPrevTime) {
      ATH_MSG_ERROR("Events not sorted properly (time is going backwards!) ");
      return false;
   }
   // for first event
   if (m_phvtripFirstTime > curr_time) {
      m_phvtripFirstTime = curr_time;
   }
   bool newbin{false};
   // check if we have a new time bin, if we do pop off the back (oldest) part
   // of the queue and enqueue 0 for every wafer
   int maxtbins{5};
   if (dtime > maxtbins) {
      newbin = true;
      ATH_MSG_DEBUG(" new t bin " << dtime <<" since start "<< (curr_time-(m_phvtripFirstTime-1.01)));
      m_phvtripHasItTripped_prev = m_phvtripHasItTripped;
      for (int iwaf{0}; iwaf!=n_elements; ++iwaf) {
         m_phvtripQueue[iwaf].pop();
         m_phvtripQueue[iwaf].push(0);
         m_phvtripHasItTripped[iwaf]=0;
      }
   }
   // Loop over all hits in the event
   bool isgoodnow;
   for( int itrk{0}; itrk!=wafersize; ++itrk) {
      int waferhash{(*m_sct_waferHash)[itrk]};
      Identifier waferId{m_pSCTHelper->wafer_id(waferhash)};
      Identifier moduleId{m_pSCTHelper->module_id(waferId)};
      //step one is to make sure this one isn't already know to be messed up:
      isgoodnow = m_DCSConditionsTool->isGood(moduleId,InDetConditions::SCT_MODULE);
      ATH_MSG_DEBUG("checked is good "<< isgoodnow);
      if (isgoodnow) {
         int numhits{(*m_sct_numHitsInWafer)[itrk]};
         totalHits += numhits;
         double limit{m_relativetriplimit * static_cast<double>(m_phvtripRunningTotalInt[waferhash]) / (static_cast<double>(curr_time)-(static_cast<double>(m_phvtripFirstTime-0.01)))};
 
         ATH_MSG_DEBUG("waferhash "<<waferhash<<" itrk "<<itrk <<" run tot "<< m_phvtripRunningTotalInt[waferhash]
                       <<" num hits "<<numhits<<" evnts processed "<<  m_phvtripProcessedEventsInt[waferhash] <<" limit "<<limit
                       <<" abs limit, rel limit "<<m_absolutetriplimit<<","<< m_relativetriplimit<<" max bins "<<maxtbins);
 
         if ( ((numhits + m_phvtripQueue[waferhash].back() )/ static_cast<double>(maxtbins) ) > m_absolutetriplimit
               and ((numhits + m_phvtripQueue[waferhash].back() )/ static_cast<double>(maxtbins) ) > limit) {
            //read back queue and see if the high hit rate is persistant for 3 previous bins (a bin is 5 seconds by default)
            for (int iq{0}; iq<m_maxq; ++iq) {
               m_tq[iq]=m_phvtripQueue[waferhash].front();
               m_phvtripQueue[waferhash].pop();
            }
            if (m_tq[m_maxq-2]/static_cast<double>(maxtbins) > limit && m_tq[m_maxq-3]/static_cast<double>(maxtbins) > limit && m_tq[m_maxq-4]/static_cast<double>(maxtbins) > limit) {
               // found a persistent trip/thing
               ATH_MSG_DEBUG("Found a potential trip in SCT wafer " << waferhash);
               ATH_MSG_DEBUG("TRIP more info: limit = " << limit << " abslimit = " << m_absolutetriplimit
                             << " hits/secs now = " << ((numhits + m_tq[m_maxq-1])/ maxtbins )
                             << " running total = " << m_phvtripRunningTotalInt[waferhash]
                             << " running average =  " <<  m_phvtripRunningTotalInt[waferhash] / (curr_time-(m_phvtripFirstTime-1.01)));
               m_phvtripHasItTripped[waferhash] = (numhits + m_tq[m_maxq-1] );
            } // end trip found
 
            //put queue back the way we found it:
            for (int iq{0}; iq < m_maxq; ++iq) {
               m_phvtripQueue[waferhash].push(m_tq[iq]);
            }
         } // end potential trip id
         //incriment event counter
         m_phvtripProcessedEventsInt[waferhash] += 1;
         //recalcuate running total:
         m_phvtripRunningTotalInt[waferhash] += numhits;
         m_phvtripQueue[waferhash].back() += numhits;
      } //end is good check
      else {
         ATH_MSG_DEBUG("Was a bad module already: " << waferhash);
      }
   } //end loop over tracks
 
   // text output, summarizing the event
   //if new bin summarzie the previous event.
   if (newbin) {
      SCT_ID::const_id_iterator waferItr{m_waferItrBegin};
      SCT_ID::const_id_iterator waferItrE{m_waferItrEnd};
      for (; waferItr not_eq waferItrE; ++waferItr) {
         Identifier waferId{*waferItr};
         IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
         if (m_phvtripHasItTripped_prev[waferHash]>0) {
            std::pair<int, int> wp;
            wp.first = (m_phvtripPrevTime - 3*maxtbins);
            wp.second = (m_phvtripPrevTime + maxtbins);
            m_summarytrips[waferHash].push_back(wp);
            std::pair<int,int> lbn;
            lbn.first = m_prevLBN.front();
            lbn.second = m_prevLBN.back();
            m_summarytripslb[waferHash].push_back(lbn);
         }
      }
      m_phvtripPrevTime = curr_time; //reset prev and current time
      m_prevLBN.pop();
      m_prevLBN.push(lumi_block);
   }
 
   for (int iwaf{0}; iwaf!=n_elements; ++iwaf) {
      ATH_MSG_DEBUG("mod "<< iwaf <<" events with that waf " <<m_phvtripProcessedEventsInt[iwaf] << " numhits "<<m_phvtripRunningTotalInt[iwaf]);
      ATH_MSG_DEBUG("did it trip "<<m_phvtripHasItTripped[iwaf]);
      if (m_phvtripHasItTripped[iwaf]) {
         ATH_MSG_DEBUG("TRIP more info: abslimit = "<<  m_absolutetriplimit
                       <<" hits/secs now = "<< ( m_phvtripQueue[iwaf].back() / maxtbins )
                       <<" running total = "<< m_phvtripRunningTotalInt[iwaf]
                       <<" running average =  "<<  m_phvtripRunningTotalInt[iwaf] / (curr_time-(m_phvtripFirstTime-1.01)));
      }
   }
   if (m_outputLowHits && (totalHits < m_lowHitCut) ) {
   }
   return result;
}

fillFromData()

bool SCT_CalibHvTool::fillFromData ( )

virtual

Definition at line 192 of file SCT_CalibHvTool.cxx.

                              {
   bool result{true};
   return result;
}

finalize()

StatusCode SCT_CalibHvTool::finalize ( )

virtual

Definition at line 36 of file SCT_CalibHvTool.cxx.

                          {
   return StatusCode::SUCCESS;
}

initialize()

StatusCode SCT_CalibHvTool::initialize ( )

virtual

Definition at line 30 of file SCT_CalibHvTool.cxx.

                            {
   ATH_CHECK(m_DCSConditionsTool.retrieve());
   return StatusCode::SUCCESS;
}

retrievedTool()

template<class T >

bool SCT_CalibHvTool::retrievedTool ( T &  tool, const std::string &  toolName  ) const

inlineprivate

retrieve a tool and report if it failed

Definition at line 94 of file SCT_CalibHvTool.h.

                                                                   {
         if (tool.retrieve().isFailure()) {
            ATH_MSG_ERROR("Unable to retrieve " << toolName);
            return false;
         }
         return true;
      }

Member Data Documentation

m_absolutetriplimit

double SCT_CalibHvTool::m_absolutetriplimit {0}

private

Definition at line 84 of file SCT_CalibHvTool.h.

m_DCSConditionsTool

ToolHandle<ISCT_DCSConditionsTool> SCT_CalibHvTool::m_DCSConditionsTool {this, "SCT_DCSConditionsTool", "SCT_DCSConditionsTool", "Tool to retrieve SCT DCS information"}

private

Definition at line 63 of file SCT_CalibHvTool.h.

m_lowHitCut

int SCT_CalibHvTool::m_lowHitCut {100}

private

Definition at line 91 of file SCT_CalibHvTool.h.

m_maxq

int SCT_CalibHvTool::m_maxq {100}

private

Definition at line 73 of file SCT_CalibHvTool.h.

m_outputLowHits

bool SCT_CalibHvTool::m_outputLowHits {false}

private

Definition at line 90 of file SCT_CalibHvTool.h.

m_phvtripFirstTime

int SCT_CalibHvTool::m_phvtripFirstTime {0}

private

Definition at line 83 of file SCT_CalibHvTool.h.

m_phvtripHasItTripped

VecInt SCT_CalibHvTool::m_phvtripHasItTripped

private

Definition at line 79 of file SCT_CalibHvTool.h.

m_phvtripHasItTripped_prev

VecInt SCT_CalibHvTool::m_phvtripHasItTripped_prev

private

Definition at line 80 of file SCT_CalibHvTool.h.

m_phvtripPrevTime

int SCT_CalibHvTool::m_phvtripPrevTime {0}

private

Definition at line 82 of file SCT_CalibHvTool.h.

m_phvtripProcessedEventsInt

VecInt SCT_CalibHvTool::m_phvtripProcessedEventsInt

private

Definition at line 78 of file SCT_CalibHvTool.h.

m_phvtripQueue

std::vector<std::queue<int> > SCT_CalibHvTool::m_phvtripQueue

private

Definition at line 75 of file SCT_CalibHvTool.h.

m_phvtripRunningTotalInt

VecInt SCT_CalibHvTool::m_phvtripRunningTotalInt

private

Definition at line 77 of file SCT_CalibHvTool.h.

m_prevLBN

std::queue<int> SCT_CalibHvTool::m_prevLBN

private

Definition at line 76 of file SCT_CalibHvTool.h.

m_pSCTHelper

const SCT_ID* SCT_CalibHvTool::m_pSCTHelper {nullptr}

private

Definition at line 65 of file SCT_CalibHvTool.h.

m_relativetriplimit

double SCT_CalibHvTool::m_relativetriplimit {0}

private

Definition at line 85 of file SCT_CalibHvTool.h.

m_sct_numHitsInWafer

VecInt* SCT_CalibHvTool::m_sct_numHitsInWafer {nullptr}

private

Definition at line 70 of file SCT_CalibHvTool.h.

m_sct_waferHash

VecInt* SCT_CalibHvTool::m_sct_waferHash {nullptr}

private

Definition at line 69 of file SCT_CalibHvTool.h.

m_summarytrips

std::vector<std::vector<std::pair<int, int> > > SCT_CalibHvTool::m_summarytrips

private

Definition at line 88 of file SCT_CalibHvTool.h.

m_summarytripslb

std::vector<std::vector<std::pair<int, int> > > SCT_CalibHvTool::m_summarytripslb

private

Definition at line 89 of file SCT_CalibHvTool.h.

m_tq

int SCT_CalibHvTool::m_tq[100] {0}

private

Definition at line 86 of file SCT_CalibHvTool.h.

m_waferItrBegin

SCT_ID::const_id_iterator SCT_CalibHvTool::m_waferItrBegin

private

Definition at line 66 of file SCT_CalibHvTool.h.

m_waferItrEnd

SCT_ID::const_id_iterator SCT_CalibHvTool::m_waferItrEnd

private

Definition at line 67 of file SCT_CalibHvTool.h.

---

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

• SCT_CalibHvTool.h
• SCT_CalibHvTool.cxx