SCTCalib.cxx File Reference

#include "SCT_CalibAlgs/SCTCalib.h"
#include "SCT_CalibAlgs/SCT_LorentzAngleFunc.h"
#include "SCT_CalibUtilities.h"
#include "XmlHeader.h"
#include "XmlStreamer.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
#include "GaudiKernel/IEventProcessor.h"
#include "TFile.h"
#include "TH1I.h"
#include "TH2D.h"
#include "TF1.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "Math/ProbFuncMathCore.h"
#include <array>
#include <cmath>

Go to the source code of this file.

Functions
StatusCode SCTCalib::stop	ATLAS_NOT_THREAD_SAFE ()
	stop - process results accumulated in execute() More...
StatusCode SCTCalib::writeModuleListToCool	ATLAS_NOT_THREAD_SAFE (const std::map< Identifier, std::set< Identifier >> &moduleListAll, const std::map< Identifier, std::set< Identifier >> &moduleListNew, const std::map< Identifier, std::set< Identifier >> &moduleListRef)

Detailed Description

Find noisy strips, HV trips and dead strips/chips Upload NoiseOccupancy and BSErrors from monitoring histograms

Author

Jose E. Garcia, jose..nosp@m.enri.nosp@m.que.g.nosp@m.arci.nosp@m.a@cer.nosp@m.n.ch

Peter Vankov, peter.nosp@m..van.nosp@m.kov@c.nosp@m.ern..nosp@m.ch

Kazu Hanagaki, kazun.nosp@m.ori..nosp@m.hanag.nosp@m.aki@.nosp@m.cern..nosp@m.ch

Minoru Hirose, minor.nosp@m.u.hi.nosp@m.rose@.nosp@m.cern.nosp@m..ch

Tim Andeen, timot.nosp@m.hy.r.nosp@m.obert.nosp@m..and.nosp@m.een@c.nosp@m.ern..nosp@m.ch

Junji Tojo, junji.nosp@m..toj.nosp@m.o@cer.nosp@m.n.ch

Peter Rosendahl, peter.nosp@m..lun.nosp@m.dgaar.nosp@m.d.ro.nosp@m.senda.nosp@m.hl@c.nosp@m.ern.c.nosp@m.h

Christian Sander, chris.nosp@m.tian.nosp@m..sand.nosp@m.er@c.nosp@m.ern.c.nosp@m.h

Mateusz Dyndal, mateu.nosp@m.sz.d.nosp@m.yndal.nosp@m.@cer.nosp@m.n.ch

Timothee Theveneaux-Pelzer, tpelz.nosp@m.er@c.nosp@m.ern.c.nosp@m.h

Definition in file SCTCalib.cxx.

Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/2]

StatusCode SCTCalib::stop ATLAS_NOT_THREAD_SAFE ( )

inline

stop - process results accumulated in execute()

Install fatal handler with default options.

getLorentzAngle() Read LorentzAngle from HIST and write out into local DB

getBSErrors() Read BSErrors from Monitoring HIST and write out into local DB

getEfficiency() Read Efficiency from Monitoring HIST and write out into local DB

getRawOccupancy() Read RawOccupancy from Monitoring HIST and write out into local DB

getNoiseOccupancy() Read NoiseOccupancy from HIST and write out into local DB

getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats

Definition at line 342 of file SCTCalib.cxx.

                                                 { // Thread unsafe getNoisyStrip, getDeadStrip, getNoiseOccupancy, getRawOccupancy, getEfficiency, getBSErrors, getLorentzAngle methods are used.
   ATH_MSG_INFO("----- in stop() ----- ");
   //--- Number of events processed
   m_numberOfEvents = (m_readHIST or (!m_doHitMaps and m_readHitMaps)) ? m_numberOfEventsHist : m_calibEvtInfoTool->counter();
   m_calibEvtInfoTool->getTimeStamps(m_utcBegin, m_utcEnd);
 
   //--- IOV range defined by RunNumber and LB
   unsigned int beginRun{static_cast<unsigned int>(m_runNumber.value())};
   unsigned int endRun{static_cast<unsigned int>(m_runNumber.value())};
   unsigned int beginLB{IOVTime::MINEVENT};
   unsigned int endLB{IOVTime::MAXEVENT};
   m_iovStart.setRunEvent(static_cast<unsigned long>(beginRun), static_cast<unsigned long>(beginLB));
   m_iovStop.setRunEvent(static_cast<unsigned long>(endRun), static_cast<unsigned long>(endLB));
 
   //--- Find noisy strips from hitmaps
   const bool doNoisyStripAnalysis{((!m_doHitMaps and m_readHitMaps) or !m_readHitMaps) and m_doNoisyStrip};
   if (doNoisyStripAnalysis) {
      if (getNoisyStrip().isFailure()) {
         ATH_MSG_ERROR("Failed to run getNoisyStrip()");
         return StatusCode::FAILURE;
      }
   }
 
   //--- Upload hv
   if (m_doHV) {
      m_gofile.open(m_badModulesFile.value().c_str(), std::ios::out);
      if (not m_gofile) ATH_MSG_ERROR("Problem opening " << m_badModulesFile);
      //
      XmlHeader myXml{m_gofile};
      XmlStreamer root{"modules", m_gofile};
      SCT_ID::const_id_iterator waferItr{m_pSCTHelper->wafer_begin()};
      SCT_ID::const_id_iterator waferItrE{m_pSCTHelper->wafer_end()};
      const unsigned int onlyDummy{1};
      std::pair<int, int> timeInterval{0, 0};
      std::pair<int, int> lbRange{0, 0};
      const int withinLimits{m_maxtbins};
      //
      for (; waferItr not_eq waferItrE; ++waferItr) {
         const Identifier waferId{*waferItr};
         IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
         const std::vector<std::pair<int, int>>& tvec{m_summarytrips.at(waferHash.value())};
         const std::vector<std::pair<int, int>>& tlbn{m_summarytripslb.at(waferHash.value())};
         //tvec is a pair of times in general, although the very first one is a dummy
         const unsigned int numberOfElements{static_cast<unsigned int>(tvec.size())};
         if (numberOfElements > onlyDummy) {
            //only care if something happened in this module
            timeInterval=tvec.at(1);
            lbRange=tlbn.at(1);
            for (unsigned int itrip{2}; itrip != numberOfElements; ++itrip) { //skip 0 since that is just the dummy pair.
               if (areConsecutiveIntervals(tvec[itrip], timeInterval, withinLimits)) {
                  timeInterval.second = tvec.at(itrip).second;
                  lbRange.second = tlbn.at(itrip).second;
               } else {
                  //not consecutive, so first print out the old one
                  doHVPrintXML(timeInterval, lbRange, waferId);
                  timeInterval = tvec.at(itrip);
                  lbRange = tlbn.at(itrip);
               }
            } // end loop over times
            doHVPrintXML(timeInterval, lbRange, waferId);
         }
      } // end loop over wafers
   }
 
   //--- Find dead strips/chips from hitmaps
   if ((m_doDeadStrip or m_doDeadChip) and getDeadStrip().isFailure()) {
      ATH_MSG_ERROR("Failed to run getDeadStrip()");
      return StatusCode::FAILURE;
   }
 
   //--- Upload noise occupancy
   if (m_doNoiseOccupancy and getNoiseOccupancy().isFailure()) {
      ATH_MSG_ERROR("Failed to run getNoiseOccupancy()");
      return StatusCode::FAILURE;
   }
 
   //--- Upload raw occupancy
   if (m_doRawOccupancy and getRawOccupancy().isFailure()) {
      ATH_MSG_ERROR("Failed to run getRawOccupancy()");
      return StatusCode::FAILURE;
   }
 
   //--- Upload efficiency
   if (m_doEfficiency and getEfficiency().isFailure()) {
      ATH_MSG_ERROR("Failed to run getEfficiency()");
      return StatusCode::FAILURE;
   }
 
   //--- Upload ByteStream Errors
   if (m_doBSErrorDB and getBSErrors().isFailure()) {
      ATH_MSG_ERROR("Failed to run getBSErrors()");
      return StatusCode::FAILURE;
   }
 
   //--- Upload Lorentz Angle
   if (m_doLorentzAngle and getLorentzAngle().isFailure()) {
      ATH_MSG_ERROR("Failed to run getLorentzAngle()");
      return StatusCode::FAILURE;
   }
 
   //--- Close HIST
   if (m_readHIST) m_inputHist->Close();
 
   return StatusCode::SUCCESS;
}

ATLAS_NOT_THREAD_SAFE() [2/2]

StatusCode SCTCalib::writeModuleListToCool ATLAS_NOT_THREAD_SAFE	(	const std::map< Identifier, std::set< Identifier >> &	moduleListAll,
		const std::map< Identifier, std::set< Identifier >> &	moduleListNew,
		const std::map< Identifier, std::set< Identifier >> &	moduleListRef
	)

Definition at line 2767 of file SCTCalib.cxx.

                                                              {
   //--- Write out strips
   float noisyStripThr{m_noisyStripThrDef?(m_noisyStripThrOffline):(m_noisyStripThrOnline)};
   int nDefects{0};
   SCT_ID::const_id_iterator idItr{m_pSCTHelper->wafer_begin()};
   SCT_ID::const_id_iterator idItrE{m_pSCTHelper->wafer_end()};
   for (; idItr != idItrE; ++idItr) {
      if (m_pSCTHelper->side(*idItr) == 0) {
         Identifier moduleId{m_pSCTHelper->module_id(*idItr)};
         std::map<Identifier, std::set<Identifier>>::const_iterator moduleAllItr{moduleListAll.find(moduleId)};
         std::map<Identifier, std::set<Identifier>>::const_iterator moduleNewItr{moduleListNew.find(moduleId)};
         std::map<Identifier, std::set<Identifier>>::const_iterator moduleRefItr{moduleListRef.find(moduleId)};
         std::string defectStripsAll{moduleAllItr != moduleListAll.end() ? getStripList((*moduleAllItr).second) : ""};
         std::string defectStripsNew{moduleNewItr != moduleListNew.end() ? getStripList((*moduleNewItr).second) : ""};
         std::string defectStripsRef{moduleRefItr != moduleListRef.end() ? getStripList((*moduleRefItr).second) : ""};
         if (m_noisyUpdate) { //--- UPD1/UPD4
            if (defectStripsAll != defectStripsRef) {
               if (m_pCalibWriteTool->createCondObjects(moduleId, m_pSCTHelper, 10000, "NOISY", noisyStripThr, defectStripsAll).isFailure()) {
                  ATH_MSG_ERROR("Could not create defect strip entry in the CalibWriteTool.");
               }
               nDefects++;
            };
         } else {
            if (m_noisyStripAll) { //--- ALL noisy strips
               if (!defectStripsAll.empty() || m_noisyWriteAllModules) {
                  if (m_pCalibWriteTool->createCondObjects(moduleId, m_pSCTHelper, 10000, "NOISY", noisyStripThr, defectStripsAll).isFailure()) {
                     ATH_MSG_ERROR("Could not create defect strip entry in the CalibWriteTool.");
                  }
               }
            } else { //--- Only NEW noisy strips
               if (!defectStripsNew.empty()) {
                  if (m_pCalibWriteTool->createCondObjects(moduleId, m_pSCTHelper, 10000, "NOISY", noisyStripThr, defectStripsNew).isFailure()) {
                     ATH_MSG_ERROR("Could not create defect strip entry in the CalibWriteTool.");
                  }
               }
            }
         }
      }
   }
   ATH_MSG_DEBUG("Number of modules for which conditions were created: " << nDefects << "  !!!!");
   if (moduleListAll.empty() or ( nDefects==0 && m_noisyUpdate )) {
      ATH_MSG_INFO("Number of noisy strips was zero or the same list of noisy strips. No local DB was created.");
   } else {
      ATH_MSG_DEBUG("directly before call of wrapUpNoisyChannel");
      if (m_pCalibWriteTool->wrapUpNoisyChannel().isFailure()) {
         ATH_MSG_ERROR("Could not get NoisyStrips info");
         return StatusCode::FAILURE;
      }
   }
   ATH_MSG_DEBUG("before return");
   return StatusCode::SUCCESS;
}