35 #include "GaudiKernel/IEventProcessor.h"
43 #include "TProfile2D.h"
44 #include "Math/ProbFuncMathCore.h"
54 const std::string shortNames[] = {
"EndCapC",
"Barrel",
"EndCapA"};
56 bool areConsecutiveIntervals(
const std::pair<int, int>& i1,
const std::pair<int, int>& i2,
const int withinLimits) {
57 return i1.second <= (i2.first + withinLimits);
59 const std::string
xmlHeader{
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"};
60 const std::string linefeed{
"\n"};
62 associateStylesheet(
const std::string& stylesheetName) {
63 return std::string(
"<?xml-stylesheet type=\"text/xsl\" href=\"")+stylesheetName+
"\"?>";
68 xmlPartData(
const Bec bec,
const int layer,
const int eta,
const std::string& dataName,
const T
data) {
69 std::ostringstream
os;
71 os <<
" <parts>" << std::endl
72 <<
" " <<
xmlValue(
"part", thisPart) << std::endl
75 std::string barrelEtaXml{
xmlValue(
"eta",
"all")};
76 std::string endcapEtaXml{
xmlValue(
"eta", eta)};
78 else os << endcapEtaXml;
81 <<
" </parts>" << std::endl;
87 xmlModuleData(
const Bec bec,
const int layer,
const int side,
const int phi,
const int eta,
const std::string& dataName,
const T
data,
const std::string& serial,
const std::string& listOfErrors) {
88 std::ostringstream
os;
89 os <<
" <module>" << std::endl
90 <<
" " <<
xmlValue(
"SN", serial) << std::endl;
97 <<
" " <<
xmlValue(
"eta", eta) << std::endl
98 <<
" " <<
xmlValue(
"phi", phi) << std::endl
101 os <<
" </module>" << std::endl;
127 return StatusCode::FAILURE;
136 ATH_MSG_DEBUG(
"ReadCalibDataTool was removed in initialization");
143 ATH_MSG_DEBUG(
"MajorityConditionsTool was removed in initialization");
155 ATH_MSG_DEBUG(
"ByteStreamErrorsSvc was removed in initialization");
182 ATH_MSG_ERROR(
"Both BS and HIST are set to be read. Choose either of BS or HIST.");
183 return StatusCode::FAILURE;
188 ATH_MSG_INFO(
"------------> Reading from ByteStream <-------------");
194 ATH_MSG_INFO(
"------------> Reading from HIST <-------------");
197 std::string
hist{
""};
204 ATH_MSG_ERROR(
"The input histogram collection property is empty");
205 return StatusCode::FAILURE;
218 if (not
m_inputHist->GetDirectory(
"/run_"+TString{os})) {
220 return StatusCode::FAILURE ;
232 ATH_MSG_INFO(
"Initialization of TimeStamp/LB, taken from runInfo.txt");
247 ATH_MSG_INFO(
"Set CalibEventInfo for m_readHitMaps == true");
277 return StatusCode::SUCCESS;
284 ATH_MSG_ERROR(
"Number of events in " << histogramName <<
": " << obtained <<
" is less than the required minimum number of events " <<
required);
301 const EventContext& ctx = Gaudi::Hive::currentContext();
302 const int timeStamp{
static_cast<int>(ctx.eventID().time_stamp())};
303 const int lumiBlock{
static_cast<int>(ctx.eventID().lumi_block())};
304 int timeStampBeginOld;
335 return StatusCode::SUCCESS;
345 m_numberOfEvents = (m_readHIST or (!m_doHitMaps and m_readHitMaps)) ? m_numberOfEventsHist : m_calibEvtInfoTool->counter();
346 m_calibEvtInfoTool->getTimeStamps(m_utcBegin, m_utcEnd);
349 unsigned int beginRun{
static_cast<unsigned int>(m_runNumber.value())};
350 unsigned int endRun{
static_cast<unsigned int>(m_runNumber.value())};
353 m_iovStart.setRunEvent(
static_cast<unsigned long>(beginRun),
static_cast<unsigned long>(beginLB));
354 m_iovStop.setRunEvent(
static_cast<unsigned long>(endRun),
static_cast<unsigned long>(endLB));
357 const bool doNoisyStripAnalysis{((!m_doHitMaps and m_readHitMaps) or !m_readHitMaps) and m_doNoisyStrip};
358 if (doNoisyStripAnalysis) {
359 if (getNoisyStrip().isFailure()) {
361 return StatusCode::FAILURE;
367 m_gofile.open(m_badModulesFile.value().c_str(),
std::ios::out);
368 if (not m_gofile)
ATH_MSG_ERROR(
"Problem opening " << m_badModulesFile);
374 const unsigned int onlyDummy{1};
375 std::pair<int, int> timeInterval{0, 0};
376 std::pair<int, int>
lbRange{0, 0};
377 const int withinLimits{m_maxtbins};
379 for (; waferItr not_eq waferItrE; ++waferItr) {
381 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
382 const std::vector<std::pair<int, int>>& tvec{m_summarytrips.at(waferHash.value())};
383 const std::vector<std::pair<int, int>>& tlbn{m_summarytripslb.at(waferHash.value())};
385 const unsigned int numberOfElements{
static_cast<unsigned int>(tvec.size())};
386 if (numberOfElements > onlyDummy) {
388 timeInterval=tvec.at(1);
390 for (
unsigned int itrip{2}; itrip != numberOfElements; ++itrip) {
391 if (areConsecutiveIntervals(tvec[itrip], timeInterval, withinLimits)) {
392 timeInterval.second = tvec.at(itrip).second;
393 lbRange.second = tlbn.at(itrip).second;
396 doHVPrintXML(timeInterval,
lbRange, waferId);
397 timeInterval = tvec.at(itrip);
401 doHVPrintXML(timeInterval,
lbRange, waferId);
407 if ((m_doDeadStrip or m_doDeadChip) and getDeadStrip().isFailure()) {
409 return StatusCode::FAILURE;
413 if (m_doNoiseOccupancy and getNoiseOccupancy().isFailure()) {
415 return StatusCode::FAILURE;
419 if (m_doRawOccupancy and getRawOccupancy().isFailure()) {
421 return StatusCode::FAILURE;
425 if (m_doEfficiency and getEfficiency().isFailure()) {
427 return StatusCode::FAILURE;
431 if (m_doBSErrorDB and getBSErrors().isFailure()) {
433 return StatusCode::FAILURE;
437 if (m_doLorentzAngle and getLorentzAngle().isFailure()) {
439 return StatusCode::FAILURE;
443 if (m_readHIST) m_inputHist->Close();
445 return StatusCode::SUCCESS;
458 return StatusCode::FAILURE;
462 return StatusCode::SUCCESS;
507 enum Categories {
ALL, NEW, REF, N_CATEGORIES};
513 m_numOfLBsProcessed = 0;
514 for (
int iLB{0}; iLB != m_LBRange; ++iLB) {
515 if (m_calibLbTool and m_calibLbTool->getNumberOfEventsInBin(iLB + 1) > 0) ++m_numOfLBsProcessed;
520 using ModuleList_t = std::map<Identifier, std::set<Identifier>>;
521 ModuleList_t moduleLists[N_CATEGORIES];
525 if (m_calibModuleListTool->readModuleList(moduleLists[REF]).isFailure()) {
527 return StatusCode::FAILURE;
531 using StripList_t = std::set<Identifier>;
532 StripList_t stripIdLists[2];
537 for (; waferItr not_eq waferItrE; ++waferItr) {
540 Identifier moduleId{m_pSCTHelper->module_id(waferId)};
542 if (m_pSCTHelper->side(waferId) == 0) {
543 stripIdLists[
ALL].clear();
544 stripIdLists[NEW].clear();
546 std::pair<int, bool> noisy{getNumNoisyStrips(waferId)};
547 const int numNoisyStripsInWafer{noisy.first};
548 const bool isNoisyWafer{noisy.second};
549 if (numNoisyStripsInWafer!=0 || m_noisyWriteAllModules) {
550 if (m_noisyWaferFinder and isNoisyWafer) {
552 if (not m_noisyWaferWrite)
break;
553 if (m_noisyWaferAllStrips) {
554 if (addStripsToList(waferId, stripIdLists[
ALL],
false,
false).isFailure() or addStripsToList(waferId, stripIdLists[NEW],
false,
true).isFailure()) {
556 return StatusCode::FAILURE;
561 if (addStripsToList(waferId, stripIdLists[
ALL],
true,
false).isFailure() or addStripsToList(waferId, stripIdLists[NEW],
true,
true).isFailure()) {
563 return StatusCode::FAILURE;
567 if (addStripsToList(waferId, stripIdLists[
ALL],
true,
false).isFailure() or addStripsToList(waferId, stripIdLists[NEW],
true,
true).isFailure()) {
569 return StatusCode::FAILURE;
574 if (m_pSCTHelper->side(waferId) == 1) {
576 if (!stripIdLists[NEW].
empty()) moduleLists[NEW].insert(std::map<
Identifier, std::set<Identifier> >::
value_type(moduleId, stripIdLists[NEW]));
583 if (writeModuleListToCool(moduleLists[
ALL], moduleLists[NEW], moduleLists[REF]).isFailure()) {
585 return StatusCode::FAILURE;
589 if (noisyStripsToXml(moduleLists[
ALL], m_badStripsAllFile).isFailure()) {
591 return StatusCode::FAILURE;
593 if (noisyStripsToXml(moduleLists[NEW], m_badStripsNewFile).isFailure()) {
595 return StatusCode::FAILURE;
598 if (noisyStripsToSummaryXml(moduleLists[
ALL], moduleLists[REF], m_badStripsSummaryFile).isFailure()) {
600 return StatusCode::FAILURE;
603 return StatusCode::SUCCESS;
615 const std::set<Identifier>* badMods{m_ConfigurationConditionsTool->badModules()};
616 std::set<Identifier>::const_iterator ModItr{badMods->begin()};
617 std::set<Identifier>::const_iterator ModEnd{badMods->end()};
619 const std::map<IdentifierHash, std::pair<bool, bool> >* badLinks{m_ConfigurationConditionsTool->badLinks()};
620 std::map<IdentifierHash, std::pair<bool, bool> >::const_iterator linkItr{badLinks->begin()};
621 std::map<IdentifierHash, std::pair<bool, bool> >::const_iterator linkEnd{badLinks->end()};
623 const std::map<Identifier, unsigned int>* badChips{m_ConfigurationConditionsTool->badChips()};
624 std::map<Identifier, unsigned int>::const_iterator chipItr{badChips->begin()};
625 std::map<Identifier, unsigned int>::const_iterator chipEnd{badChips->end()};
627 std::set<Identifier> badStripsExclusive;
628 m_ConfigurationConditionsTool->badStrips(badStripsExclusive,
true,
true);
629 std::set<Identifier>::const_iterator stripEnd(badStripsExclusive.end());
631 int numEnabledModules_B[
n_barrels] = {n_phiBinsB0*n_etaInBarrel, n_phiBinsB1*n_etaInBarrel, n_phiBinsB2*n_etaInBarrel, n_phiBinsB3*n_etaInBarrel};
635 if (!((
i==0 and j==2) or (
i==6 and j==2) or (
i==7 and j==2) or (
i==8 and j==1) or (
i==8 and j==2))) {
636 numEnabledModules_EC[
i][j] = j==0 ? n_phiBinsECOuter*2 : n_phiBinsECMiddle*2;
640 for (; ModItr!=ModEnd; ++ModItr) {
642 if (m_pSCTHelper->barrel_ec(moduleId)==
BARREL) numEnabledModules_B[m_pSCTHelper->layer_disk(moduleId)]--;
643 else numEnabledModules_EC[m_pSCTHelper->layer_disk(moduleId)][m_pSCTHelper->eta_module(moduleId)]--;
646 double meanOccupancy_Barrel[
n_barrels] = {0};
650 for (; waferItr != waferItrE; ++waferItr) {
652 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
653 for (
int j{0}; j<n_stripPerChip*n_chipPerSide; j++) {
654 double n_hits{m_calibHitmapTool->getBinForHistogramIndex(j+1, waferHash.value())};
655 if (n_hits/m_numberOfEvents<m_noisyThr4DeadFinding) {
656 if (m_pSCTHelper->barrel_ec(waferId)==
BARREL) {
657 meanOccupancy_Barrel[m_pSCTHelper->layer_disk(waferId)]+=m_calibHitmapTool->getBinForHistogramIndex(j+1, waferHash.value());
659 meanOccupancy_EC[m_pSCTHelper->layer_disk(waferId)][m_pSCTHelper->eta_module(waferId)]+=m_calibHitmapTool->getBinForHistogramIndex(j+1, waferHash.value());
666 meanOccupancy_Barrel[
i]/=
static_cast<double>(m_numberOfEvents*
nbins*2*numEnabledModules_B[
i]);
667 ATH_MSG_INFO(
"Barrel : layer=" <<
i <<
", meanOccupancy=" << meanOccupancy_Barrel[
i] <<
", nbins:" <<
nbins <<
", #enabledModule=" << numEnabledModules_B[
i]);
672 if (numEnabledModules_EC[
i][j]!=0) {
673 meanOccupancy_EC[
i][j]/=
static_cast<double>(m_numberOfEvents*
nbins*2*numEnabledModules_EC[
i][j]);
674 ATH_MSG_INFO(
"EndCap : disk=" <<
i <<
", eta=" << j <<
", meanOccupancy=" << meanOccupancy_EC[
i][j] <<
", #enabledModule=" << numEnabledModules_EC[
i][j]);
678 bool busyStream{meanOccupancy_Barrel[3]>m_busyThr4DeadFinding ? true :
false};
679 unsigned int minStat{busyStream ?
static_cast<unsigned int>(m_deadStripMinStatBusy) :
static_cast<unsigned int>(m_deadStripMinStat)};
680 if (m_doDeadStrip and m_numberOfEvents<minStat) {
681 ATH_MSG_WARNING(
"required minimum statistics is " << minStat/1E3 <<
"k events for DeadStrip search with this stream");
682 m_doDeadStrip =
true;
684 if (m_doDeadChip and m_numberOfEvents<m_deadChipMinStat) {
685 ATH_MSG_WARNING(
"required minimum statistics is " <<
static_cast<unsigned int>(m_deadChipMinStat) <<
" events for DeadChip search");
688 if (m_doDeadStrip==
false and m_doDeadChip==
false) {
689 ATH_MSG_ERROR(
"Number of events " << m_numberOfEvents <<
" is less than the required minimum number of events... exit getDeadStrip()");
690 return StatusCode::FAILURE;
694 if (openXML4DB(m_outDeadStrips,
"DeadStrip", m_tagID4DeadStrips.value().c_str(), m_iovStart, m_iovStop).isFailure()) {
696 return StatusCode::FAILURE;
700 if (openXML4DB(m_outDeadChips,
"DeadChip", m_tagID4DeadChips.value().c_str(), m_iovStart, m_iovStop).isFailure()) {
702 return StatusCode::FAILURE;
709 if (elements==
nullptr) {
710 ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() <<
" could not be retrieved");
711 return StatusCode::FAILURE;
715 bool hasDeadStrip{
false};
716 bool hasDeadChip{
false};
717 bool isNoHitLink{
false};
719 bool beforeIsDead{
false};
724 int n_checkedChip{0};
727 std::string defectStrip;
728 std::string defectChip;
729 std::ostringstream summaryList;
732 const double deadStripDefinition{ROOT::Math::gaussian_cdf_c(m_deadStripSignificance)};
733 const double deadChipDefinition{ROOT::Math::gaussian_cdf_c(m_deadChipSignificance)};
736 waferItr = m_pSCTHelper->wafer_begin();
737 for (; waferItr != waferItrE; ++waferItr) {
739 Identifier moduleId{m_pSCTHelper->module_id(waferId)};
740 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
742 bool disabledChip[n_chipPerModule] = {
false};
743 unsigned int disabledChipFlag=0;
744 double numHitsInStrip[n_stripPerChip*n_chipPerSide] = {0};
745 double numHitsInChip[n_chipPerSide] = {0};
746 double totalHitsInWafer{0};
748 int n_noHitsStrip{0};
749 int n_disabledStrip{0};
750 int n_disabledInChip[n_chipPerSide] = {0};
753 int side{m_pSCTHelper->side(waferId)};
765 if (badMods->find(moduleId)!=badMods->end())
disabled=
true;
766 linkItr=badLinks->find(waferHash);
767 if (linkItr!=linkEnd) {
768 std::pair<bool, bool>
status{(*linkItr).second};
773 bool hasBSError{
false};
774 if (m_calibBsErrTool->size(waferHash.value())>0) hasBSError=
true;
778 if (defectChip==
" 0-5 6-11 ") {
780 }
else if (defectChip==
" 0-5 " or defectChip==
" 6-11 ") {
784 if (!(defectStrip.empty()) or !(defectChip.empty())) {
785 if (addToSummaryStr(summaryList, waferId,
"DEAD", defectStrip.c_str(), defectChip.c_str()).isFailure()) {
787 return StatusCode::FAILURE;
791 if (!(defectStrip.empty())) {
793 double threshold = m_deadStripSignificance;
794 if (!m_deadNotQuiet)
threshold = m_quietThresholdStrip;
796 if (m_pCalibWriteTool->createListStrip(moduleId, m_pSCTHelper, 10000,
"DEAD",
threshold, defectStrip).isFailure()) {
798 return StatusCode::FAILURE;
801 if (addToXML4DB(m_outDeadStrips, waferId,
"DEAD",
threshold, defectStrip.c_str()).isFailure()) {
803 return StatusCode::FAILURE;
809 if (!(defectChip.empty())) {
811 double threshold = m_deadChipSignificance;
812 if (!m_deadNotQuiet)
threshold = m_quietThresholdChip;
814 if (m_pCalibWriteTool->createListChip(moduleId, m_pSCTHelper, 10000,
"DEAD",
threshold, defectChip).isFailure()) {
816 return StatusCode::FAILURE;
820 if (addToXML4DB(m_outDeadChips, waferId,
"DEAD",
threshold, defectChip.c_str()).isFailure()) {
822 return StatusCode::FAILURE;
832 chipItr=badChips->find(moduleId);
833 if (chipItr!=chipEnd) disabledChipFlag = (*chipItr).second;
834 for (
unsigned int i{0};
i<n_chipPerModule;
i++) {
835 disabledChip[
i] = ((disabledChipFlag & (1 <<
i)) != 0);
839 for (
int j=0; j<n_stripPerChip*n_chipPerSide; j++) {
841 bool swap{(pElement->swapPhiReadoutDirection()) ?
true :
false};
843 if (
side==0) chipNum =
swap ? 5-j/n_stripPerChip : j/n_stripPerChip;
844 else chipNum =
swap ? 11-j/n_stripPerChip : 6+j/n_stripPerChip;
845 int stripNum{
swap ? 767-j : j};
846 Identifier stripId{m_pSCTHelper->strip_id(waferId, j)};
848 numHitsInStrip[stripNum] = m_calibHitmapTool->getBinForHistogramIndex(j+1, waferHash.value());
849 bool misMatch{
false};
850 double n_hitsInDisable{numHitsInStrip[stripNum]};
851 if (((disabledChipFlag & (1 << chipNum))!=0) or badStripsExclusive.find(stripId)!=stripEnd) {
852 if (numHitsInStrip[stripNum]!=0) misMatch =
true;
853 numHitsInStrip[stripNum] = -99;
857 <<
"n_hits=" << n_hitsInDisable <<
", "
858 <<
"bec=" << m_pSCTHelper->barrel_ec(stripId) <<
", "
859 <<
"layer=" << m_pSCTHelper->layer_disk(stripId) <<
", "
860 <<
"phi=" << m_pSCTHelper->phi_module(stripId) <<
", "
861 <<
"eta=" << m_pSCTHelper->eta_module(stripId) <<
", "
862 <<
"side=" << m_pSCTHelper->side(stripId) <<
", "
863 <<
"strip=" << m_pSCTHelper->strip(stripId));
866 if (numHitsInStrip[stripNum]==0) {
868 ATH_MSG_DEBUG(
"nohit strip : barrel_ec=" << m_pSCTHelper->barrel_ec(stripId)
869 <<
", layer=" << m_pSCTHelper->layer_disk(stripId) <<
", phi=" << m_pSCTHelper->phi_module(stripId)
870 <<
", eta=" << m_pSCTHelper->eta_module(stripId) <<
", side=" << m_pSCTHelper->side(stripId)
871 <<
", strip=offline" << m_pSCTHelper->strip(stripId));
872 }
else if (numHitsInStrip[stripNum]==-99) {
874 n_disabledInChip[stripNum/n_stripPerChip]++;
875 ATH_MSG_DEBUG(
"disabled strip : barrel_ec=" << m_pSCTHelper->barrel_ec(stripId)
876 <<
", layer=" << m_pSCTHelper->layer_disk(stripId) <<
", phi=" << m_pSCTHelper->phi_module(stripId)
877 <<
", eta=" << m_pSCTHelper->eta_module(stripId) <<
", side=" << m_pSCTHelper->side(stripId)
878 <<
", strip=offline" << m_pSCTHelper->strip(stripId));
879 }
else if (numHitsInStrip[stripNum]/m_numberOfEvents>m_noisyThr4DeadFinding) {
882 totalHitsInWafer+=numHitsInStrip[stripNum];
887 if (n_disabledStrip==768) {
889 if (defectChip==
" 0-5 6-11 ") {
891 }
else if (defectChip==
" 0-5 " or defectChip==
" 6-11 ") {
894 if (!(defectStrip.empty()) or !(defectChip.empty())) {
895 if (addToSummaryStr(summaryList, waferId,
"DEAD", defectStrip.c_str(), defectChip.c_str()).isFailure()) {
897 return StatusCode::FAILURE;
901 if (!(defectStrip.empty())) {
903 if (m_pCalibWriteTool->createListStrip(moduleId, m_pSCTHelper, 10000,
"DEAD", m_deadStripSignificance, defectStrip).isFailure()) {
905 return StatusCode::FAILURE;
909 if (addToXML4DB(m_outDeadStrips, waferId,
"DEAD", m_deadStripSignificance, defectStrip.c_str()).isFailure()) {
911 return StatusCode::FAILURE;
916 if (!(defectChip.empty())) {
918 if (m_pCalibWriteTool->createListChip(moduleId, m_pSCTHelper, 10000,
"DEAD", m_deadChipSignificance, defectChip).isFailure()) {
920 return StatusCode::FAILURE;
924 if (addToXML4DB(m_outDeadChips, waferId,
"DEAD", m_deadChipSignificance, defectChip.c_str()).isFailure()) {
926 return StatusCode::FAILURE;
938 if (n_noHitsStrip+n_disabledStrip==768) {
939 n_checkedChip+=n_chipPerSide;
943 if (m_pSCTHelper->barrel_ec(waferId)==
BARREL) meanOccu=meanOccupancy_Barrel[m_pSCTHelper->layer_disk(waferId)];
944 else meanOccu=meanOccupancy_EC[m_pSCTHelper->layer_disk(waferId)][m_pSCTHelper->eta_module(waferId)];
945 double sum_binomial{ROOT::Math::binomial_cdf(0, meanOccu, m_numberOfEvents*n_stripPerChip*n_chipPerSide)};
947 if (sum_binomial<deadChipDefinition) {
949 n_deadChip+=n_chipPerSide;
953 if (
side==0) beginDead=0, endDead=767;
954 else beginDead=768, endDead=1535;
955 defectStrip = m_pCalibWriteTool->addDefect(defectStrip, beginDead, endDead);
960 if (
side==0) beginDead=0, endDead=5;
961 else beginDead=6, endDead=11;
962 defectChip = m_pCalibWriteTool->addDefect(defectChip, beginDead, endDead);
966 if (defectChip==
" 0-5 6-11 ") {
968 }
else if (defectChip==
" 0-5 " or defectChip==
" 6-11 ") {
972 if (!(defectStrip.empty()) or !(defectChip.empty())) {
973 if (addToSummaryStr(summaryList, waferId,
"DEAD", defectStrip.c_str(), defectChip.c_str()).isFailure()) {
975 return StatusCode::FAILURE;
978 if (!(defectStrip.empty())) {
980 if (m_pCalibWriteTool->createListStrip(moduleId, m_pSCTHelper, 10000,
"DEAD", m_deadStripSignificance, defectStrip).isFailure()) {
982 return StatusCode::FAILURE;
986 if (addToXML4DB(m_outDeadStrips, waferId,
"DEAD", m_deadStripSignificance, defectStrip.c_str()).isFailure()) {
988 return StatusCode::FAILURE;
995 if (!(defectChip.empty())) {
997 if (m_pCalibWriteTool->createListChip(moduleId, m_pSCTHelper, 10000,
"DEAD", m_deadChipSignificance, defectChip).isFailure()) {
999 return StatusCode::FAILURE;
1003 if (addToXML4DB(m_outDeadChips, waferId,
"DEAD", m_deadChipSignificance, defectChip.c_str()).isFailure()) {
1005 return StatusCode::FAILURE;
1016 if (n_noHitsStrip>0 || !m_deadNotQuiet) {
1017 int n_deadChipInWafer{0};
1019 double n_effectiveEvents{0.};
1020 if (busyStream) n_effectiveEvents = m_numberOfEvents*(n_stripPerChip*n_chipPerSide-n_disabledStrip-n_noisyStrip-n_noHitsStrip);
1021 else n_effectiveEvents = m_numberOfEvents*(n_stripPerChip*n_chipPerSide-n_disabledStrip-n_noisyStrip);
1024 double meanOccupancy{totalHitsInWafer/n_effectiveEvents};
1025 for (
int j{0}; j<n_stripPerChip*n_chipPerSide; j++) {
1026 if (numHitsInStrip[j]>0) numHitsInChip[j/n_stripPerChip] += numHitsInStrip[j];
1029 for (
int j{0}; j<n_chipPerSide; j++) {
1031 int chipNum{
side==0 ? j : j+6};
1032 if ( !disabledChip[chipNum] && (numHitsInChip[j]==0 || !m_deadNotQuiet) ) {
1033 if (!isNoHitLink) n_checkedChip++;
1034 double sum_binomial{ROOT::Math::binomial_cdf(0, meanOccupancy, m_numberOfEvents*(n_stripPerChip-n_disabledInChip[j]))};
1036 if ((m_deadNotQuiet && sum_binomial<deadChipDefinition) ||
1037 (!m_deadNotQuiet && numHitsInChip[j]/(m_numberOfEvents*(n_stripPerChip-n_disabledInChip[j])) < meanOccupancy*m_quietThresholdChip)) {
1038 ATH_MSG_INFO(
"DEADCHIP : " << moduleId <<
", side=" <<
side <<
", chip(online)=" << (
side==0 ? j : j+n_chipPerSide));
1041 n_deadChipInWafer++;
1042 endDead =
side==0 ? j : j+n_chipPerSide;
1043 if (!beforeIsDead) beginDead =
side==0 ? j : j+n_chipPerSide;
1048 if ((beforeIsDead and !isDead) or (j==5 and isDead)) defectChip = m_pCalibWriteTool->addDefect(defectChip, beginDead, endDead);
1050 beforeIsDead = isDead;
1054 if (m_doDeadStrip) {
1055 double meanOccExceptDeadChip{totalHitsInWafer/(n_effectiveEvents-n_stripPerChip*n_deadChipInWafer)};
1056 double numHitsInStripOnlineOrder[n_stripPerChip*n_chipPerSide] = {0};
1057 for (
int j{0}; j<n_stripPerChip*n_chipPerSide; j++) {
1058 numHitsInStripOnlineOrder[j] =
side==0 ? numHitsInStrip[j] : numHitsInStrip[n_stripPerChip*n_chipPerSide-1-j];
1060 if (numHitsInStripOnlineOrder[j]==0 || !m_deadNotQuiet) {
1061 double sum_binomial{ROOT::Math::binomial_cdf(0, meanOccExceptDeadChip, m_numberOfEvents)};
1063 if ((m_deadNotQuiet && sum_binomial<deadStripDefinition) ||
1064 (!m_deadNotQuiet && numHitsInStripOnlineOrder[j]/m_numberOfEvents < meanOccExceptDeadChip*m_quietThresholdStrip)) {
1065 ATH_MSG_INFO(
"DEADSTRIP : " << moduleId <<
", side=" <<
side <<
", strip(offline)=" << j);
1068 endDead =
side==0 ? j : j+n_stripPerChip*n_chipPerSide;
1069 if (!beforeIsDead) beginDead =
side==0 ? j : j+n_stripPerChip*n_chipPerSide;
1073 if (m_doDeadStrip) {
1074 if ((beforeIsDead and !isDead) or (j==5 and isDead)) defectStrip = m_pCalibWriteTool->addDefect(defectStrip, beginDead, endDead);
1076 beforeIsDead = isDead;
1084 if (m_doDeadStrip) {
1086 if (closeXML4DB(m_outDeadStrips).isFailure()) {
1088 return StatusCode::FAILURE;
1092 ATH_MSG_INFO(
"total #DeadChip : " << n_deadChip <<
", #noHitChip : " << n_checkedChip);
1093 if (closeXML4DB(m_outDeadChips).isFailure()) {
1095 return StatusCode::FAILURE;
1100 if (openXML4DeadSummary(m_outDeadSummary,
"DEAD", n_deadModule, n_deadLink, n_deadChip, n_deadStrip).isFailure()) {
1102 return StatusCode::FAILURE;
1104 if (wrapUpXML4Summary(m_outDeadSummary,
"DEAD", summaryList).isFailure()) {
1106 return StatusCode::FAILURE;
1109 if (m_writeToCool) {
1110 if (m_doDeadStrip and hasDeadStrip) {
1111 if (m_pCalibWriteTool->wrapUpDeadStrips().isFailure()) {
1113 return StatusCode::FAILURE;
1116 if (m_doDeadChip and hasDeadChip) {
1117 if (m_pCalibWriteTool->wrapUpDeadChips().isFailure()) {
1119 return StatusCode::FAILURE;
1125 return StatusCode::SUCCESS;
1138 int n_phiBinsBarrel[
n_barrels] = {n_phiBinsB0, n_phiBinsB1, n_phiBinsB2, n_phiBinsB3};
1139 int n_phiBinsEndcap[
n_disks][
n_etaBinsEC] = {{n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1140 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1141 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1142 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1143 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1144 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1145 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1146 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1147 {n_phiBinsECOuter, 0, 0}
1158 stem =
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEC/Noise/";
1159 m_pnoiseoccupancymapHistoVectorECm.clear();
1160 for (
int iDisk{0}; iDisk <
n_disks ; ++iDisk) {
1161 for (
int iSide{0}; iSide < 2; ++iSide) {
1162 std::ostringstream streamHist;
1163 streamHist <<
"hitoccupancymap";
1164 if (m_noiseOccupancyTriggerAware) streamHist <<
"trigger";
1165 streamHist <<
"ECm_" << iDisk <<
"_" << iSide;
1166 std::string
histName{stem + streamHist.str()};
1167 TProfile2D* hist_tmp{
dynamic_cast<TProfile2D*
>(m_inputHist->Get(
histName.c_str()))};
1168 m_pnoiseoccupancymapHistoVectorECm.push_back(hist_tmp);
1172 stem =
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTB/Noise/";
1173 m_pnoiseoccupancymapHistoVector.clear();
1174 for (
int iLayer{0}; iLayer <
n_barrels ; ++iLayer) {
1175 for (
int iSide{0}; iSide < 2; ++iSide) {
1176 std::ostringstream streamHist;
1177 streamHist <<
"hitoccupancymap";
1178 if (m_noiseOccupancyTriggerAware) streamHist <<
"trigger";
1179 streamHist <<
"_" << iLayer <<
"_" << iSide;
1180 std::string
histName{stem + streamHist.str()};
1181 TProfile2D* hist_tmp{
dynamic_cast<TProfile2D*
>(m_inputHist->Get(
histName.c_str()))};
1182 m_pnoiseoccupancymapHistoVector.push_back(hist_tmp);
1186 stem =
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEA/Noise/";
1187 m_pnoiseoccupancymapHistoVectorECp.clear();
1188 for (
int iDisk{0}; iDisk <
n_disks ; ++iDisk) {
1189 for (
int iSide{0}; iSide < 2; ++iSide) {
1190 std::ostringstream streamHist;
1191 streamHist <<
"hitoccupancymap";
1192 if (m_noiseOccupancyTriggerAware) streamHist <<
"trigger";
1193 streamHist <<
"ECp_" << iDisk <<
"_" << iSide;
1194 std::string
histName{stem + streamHist.str()};
1195 TProfile2D* hist_tmp{
dynamic_cast<TProfile2D*
>(m_inputHist->Get(
histName.c_str()))};
1196 m_pnoiseoccupancymapHistoVectorECp.push_back(hist_tmp);
1201 const char* outputNoiseOccupancyFileName{m_noiseOccupancyFile.value().c_str()};
1204 ATH_MSG_ERROR(
"Unable to open NoiseOccupancyFile : " << outputNoiseOccupancyFileName);
1205 return StatusCode::FAILURE;
1209 std::ostringstream osHeader;
1210 osHeader <<
"<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/NoiseOccupancy\" "
1211 <<
"since=\"" << m_iovStart.re_time() <<
"\" "
1212 <<
"until=\"" << m_iovStop.re_time() <<
"\" "
1213 <<
"tag=\"" << m_tagID4NoiseOccupancy <<
"\" "
1214 <<
"version=\"" <<
"multi\">" << std::endl;
1218 for (
int iDisk{0}; iDisk <
n_disks ; ++iDisk) {
1219 for (
int iSide{0}; iSide < 2; ++iSide) {
1223 float occupancy{
static_cast<float>(m_pnoiseoccupancymapHistoVectorECm[2*iDisk + iSide]->GetBinContent(
iEta+1,
iPhi+1))};
1224 occupancy /=
static_cast<float>(
ntimeBins);
1227 meanNO_ECC[iDisk][
iEta]+=occupancy;
1228 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
1230 outFile << xmlChannelNoiseOccDataString(waferId, occupancy, sn) << std::endl;
1232 if (m_writeToCool) {
1233 if (m_pCalibWriteTool->createListNO(waferId, m_pSCTHelper, 10000, occupancy).isFailure()) {
1235 return StatusCode::FAILURE;
1243 for (
int iLayer{0}; iLayer <
n_barrels; ++iLayer) {
1244 for (
int iSide{0}; iSide < 2; ++iSide) {
1246 if (
iEta-6 == 0)
continue;
1247 for (
int iPhi{0};
iPhi < n_phiBinsBarrel[iLayer]; ++
iPhi) {
1249 float occupancy{
static_cast<float>(m_pnoiseoccupancymapHistoVector[2*iLayer + iSide]->GetBinContent(
iEta+1,
iPhi+1))};
1250 occupancy /=
static_cast<float>(
ntimeBins);
1253 meanNO_Barrel[iLayer]+=occupancy;
1254 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
1256 outFile << xmlChannelNoiseOccDataString(waferId, occupancy, sn) << std::endl;
1258 if (m_writeToCool) {
1259 if (m_pCalibWriteTool->createListNO(waferId, m_pSCTHelper, 10000, occupancy).isFailure()) {
1261 return StatusCode::FAILURE;
1269 for (
int iDisk{0}; iDisk <
n_disks ; ++iDisk) {
1270 for (
int iSide{0}; iSide < 2; ++iSide) {
1274 float occupancy{
static_cast<float>(m_pnoiseoccupancymapHistoVectorECp[2*iDisk + iSide]->GetBinContent(
iEta+1,
iPhi+1))};
1275 occupancy /=
static_cast<float>(
ntimeBins);
1278 meanNO_ECA[iDisk][
iEta]+=occupancy;
1279 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
1281 outFile << xmlChannelNoiseOccDataString(waferId, occupancy, sn) << std::endl;
1283 if (m_writeToCool) {
1284 if (m_pCalibWriteTool->createListNO(waferId, m_pSCTHelper, 10000, occupancy).isFailure()) {
1286 return StatusCode::FAILURE;
1295 outFile <<
"</channels>" << std::endl;
1298 std::ostringstream summaryList;
1301 if (n_phiBinsEndcap[
i][j] != 0) {
1302 meanNO_ECC[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1303 summaryList << xmlPartData(
ENDCAP_C,
i, j,
"meanNO", meanNO_ECC[
i][j]);
1308 meanNO_Barrel[
i] /= (n_phiBinsBarrel[
i]*n_etaInBarrel*2);
1309 summaryList << xmlPartData(
BARREL,
i, 0,
"meanNO", meanNO_Barrel[
i]);
1313 if (n_phiBinsEndcap[
i][j] != 0) {
1314 meanNO_ECA[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1315 summaryList << xmlPartData(
ENDCAP_A,
i, j,
"meanNO", meanNO_ECA[
i][j]);
1320 if (openXML4MonSummary(m_outNOSummary,
"NoiseOccupancy").isFailure()) {
1322 return StatusCode::FAILURE;
1324 if (wrapUpXML4Summary(m_outNOSummary,
"NoiseOccupancy", summaryList).isFailure()) {
1326 return StatusCode::FAILURE;
1330 if (m_writeToCool) {
1331 if (m_pCalibWriteTool->wrapUpNoiseOccupancy().isFailure()) {
1333 return StatusCode::FAILURE;
1337 return StatusCode::SUCCESS;
1350 int n_phiBinsBarrel[
n_barrels] = {n_phiBinsB0, n_phiBinsB1, n_phiBinsB2, n_phiBinsB3};
1351 int n_phiBinsEndcap[
n_disks][
n_etaBinsEC] = {{n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1352 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1353 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1354 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1355 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1356 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1357 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1358 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1359 {n_phiBinsECOuter, 0, 0}
1368 std::vector<std::pair<std::string, int>> EC_stems;
1370 std::pair<std::string, int> stem_C(
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEC/hits/",
ENDCAP_C);
1371 std::pair<std::string, int> stem_A(
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEA/hits/",
ENDCAP_A);
1372 EC_stems.push_back(stem_C);
1373 EC_stems.push_back(stem_A);
1374 std::vector< std::pair<std::string, int> >
::iterator stemItr{EC_stems.begin()};
1377 for (stemItr=EC_stems.begin(); stemItr!=EC_stems.end(); ++stemItr) {
1378 for (
int iDisk{0}; iDisk<
n_disks; ++iDisk) {
1379 for (
int iSide{0}; iSide<2; ++iSide) {
1382 Identifier waferId{m_pSCTHelper->wafer_id((*stemItr).second, iDisk,
iPhi,
iEta, iSide)};
1383 std::string detector_part;
1384 detector_part.erase();
1385 if (m_histBefore2010) {
1386 if ((*stemItr).second==
ENDCAP_C) detector_part =
"ECm_hitsmap";
1387 else detector_part =
"ECp_hitsmap";
1389 if ((*stemItr).second==
ENDCAP_C) detector_part =
"hitsmapECm";
1390 else detector_part =
"hitsmapECp";
1392 std::ostringstream streamHist;
1393 streamHist << detector_part <<
"_" << iDisk <<
"_" << iSide;
1394 std::string hitsmapname{stemItr->first + streamHist.str()};
1395 TH2F* hist_tmp{
dynamic_cast<TH2F*
>(m_inputHist->Get(hitsmapname.c_str()))};
1396 unsigned long long n_hits{
static_cast<unsigned long long>(hist_tmp->GetBinContent(
iEta+1,
iPhi+1))};
1398 if (m_numberOfEvents!=0) {
1399 raw_occu =
static_cast<float>(n_hits)/(m_numberOfEvents*n_chipPerSide*n_stripPerChip);
1401 if (stemItr->second==
ENDCAP_C) meanRO_ECC[iDisk][
iEta] +=
static_cast<double>(raw_occu);
1402 else if (stemItr->second==
ENDCAP_A) meanRO_ECA[iDisk][
iEta] +=
static_cast<double>(raw_occu);
1405 if (m_writeToCool) {
1406 if (m_pCalibWriteTool->createListRawOccu(waferId, m_pSCTHelper, m_numberOfEvents, raw_occu).isFailure()) {
1408 return StatusCode::FAILURE;
1417 for (
int iLayer{0}; iLayer<
n_barrels; ++iLayer) {
1418 for (
int iSide{0}; iSide<2; ++iSide) {
1420 if (
iEta-6==0)
continue;
1421 for (
int iPhi{0};
iPhi<n_phiBinsBarrel[iLayer]; ++
iPhi) {
1423 std::ostringstream streamHist;
1424 streamHist << iLayer <<
"_" << iSide;
1425 std::string hitsmapname{
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTB/hits/hitsmap_" + streamHist.str()};
1426 TH2F* hist_tmp{
dynamic_cast<TH2F*
>(m_inputHist->Get(hitsmapname.c_str()))};
1427 unsigned long long n_hits{
static_cast<unsigned long long>(hist_tmp->GetBinContent(
iEta+1,
iPhi+1))};
1429 if (m_numberOfEvents!=0) {
1430 raw_occu =
static_cast<float>(n_hits)/(m_numberOfEvents*n_chipPerSide*n_stripPerChip);
1432 meanRO_Barrel[iLayer] +=
static_cast<double>(raw_occu);
1435 if (m_writeToCool) {
1436 if (m_pCalibWriteTool->createListRawOccu(waferId, m_pSCTHelper, m_numberOfEvents, raw_occu).isFailure()) {
1438 return StatusCode::FAILURE;
1446 std::ostringstream summaryList;
1449 if (n_phiBinsEndcap[
i][j] != 0) {
1450 meanRO_ECC[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1451 summaryList << xmlPartData(
ENDCAP_C,
i, j,
"meanRO", meanRO_ECC[
i][j]);
1456 meanRO_Barrel[
i] /= (n_phiBinsBarrel[
i]*n_etaInBarrel*2);
1457 summaryList << xmlPartData(
BARREL,
i, 0,
"meanRO", meanRO_Barrel[
i]);
1461 if (n_phiBinsEndcap[
i][j] != 0) {
1462 meanRO_ECA[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1463 summaryList << xmlPartData(
ENDCAP_A,
i, j,
"meanRO", meanRO_ECA[
i][j]);
1468 if (openXML4MonSummary(m_outROSummary,
"RawOccupancy").isFailure()) {
1470 return StatusCode::FAILURE;
1472 if (wrapUpXML4Summary(m_outROSummary,
"RawOccupancy", summaryList).isFailure()) {
1474 return StatusCode::FAILURE;
1478 if (m_writeToCool) {
1479 if (m_pCalibWriteTool->wrapUpRawOccupancy().isFailure()) {
1481 return StatusCode::FAILURE;
1485 return StatusCode::SUCCESS;
1497 int n_phiBinsBarrel[
n_barrels] = {n_phiBinsB0, n_phiBinsB1, n_phiBinsB2, n_phiBinsB3};
1498 int n_phiBinsEndcap[
n_disks][
n_etaBinsEC] = {{n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1499 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1500 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1501 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1502 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1503 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1504 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1505 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1506 {n_phiBinsECOuter, 0, 0}
1513 double meanEff_Barrel_bcid1[
n_barrels ] = { 0 };
1518 std::vector<std::pair<std::string, int>> EC_stems;
1520 std::pair<std::string, int> stem_C{
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEC/eff/",
ENDCAP_C};
1521 std::pair<std::string, int> stem_A{
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEA/eff/",
ENDCAP_A};
1522 EC_stems.push_back(stem_C);
1523 EC_stems.push_back(stem_A);
1524 std::vector<std::pair<std::string, int>>
::iterator stemItr{EC_stems.begin()};
1526 const char* outputEfficiencyFileName{m_efficiencyModuleFile.value().c_str()};
1529 ATH_MSG_ERROR(
"Unable to open EfficiencyFile : " << outputEfficiencyFileName);
1530 return StatusCode::FAILURE;
1533 std::string xslName{
"EfficiencyInfo.xsl"};
1534 outFile <<
xmlHeader << linefeed << associateStylesheet(xslName) << linefeed <<
"<run>" << std::endl;
1536 <<
xmlValue(
"StartTime", m_utcBegin) << linefeed
1537 <<
xmlValue(
"EndTime", m_utcEnd) << linefeed
1538 <<
xmlValue(
"Duration", m_calibEvtInfoTool->duration()) << linefeed
1539 <<
xmlValue(
"LB", m_LBRange) << linefeed
1540 <<
xmlValue(
"Events", m_numberOfEvents) << linefeed
1541 <<
" <modules>" << std::endl;
1543 const char* outputEfficiencyFileNameChip{m_efficiencyChipFile.value().c_str()};
1544 std::ofstream outFileChip{outputEfficiencyFileNameChip,
std::ios::out};
1545 if (!outFileChip.good()) {
1546 ATH_MSG_ERROR(
"Unable to open EfficiencyFile for chips : " << outputEfficiencyFileNameChip);
1547 return StatusCode::FAILURE;
1550 if (m_efficiencyDoChips) {
1551 std::string xslNameChip{
"EfficiencyChipInfo.xsl"};
1552 outFileChip <<
xmlHeader << linefeed << associateStylesheet(xslNameChip) << linefeed <<
"<run>" << std::endl;
1553 outFileChip <<
xmlValue(
"RunNumber", m_runNumber.value()) << linefeed
1554 <<
xmlValue(
"StartTime", m_utcBegin) << linefeed
1555 <<
xmlValue(
"EndTime", m_utcEnd) << linefeed
1556 <<
xmlValue(
"Duration", m_calibEvtInfoTool->duration()) << linefeed
1557 <<
xmlValue(
"LB", m_LBRange) << linefeed
1558 <<
xmlValue(
"Events", m_numberOfEvents) << linefeed
1559 <<
" <chips>" << std::endl;
1563 for (stemItr=EC_stems.begin(); stemItr!=EC_stems.end(); ++stemItr) {
1564 for (
int iDisk{0}; iDisk<
n_disks; ++iDisk) {
1565 for (
int iSide{0}; iSide<2; ++iSide) {
1568 Identifier waferId = m_pSCTHelper->wafer_id((*stemItr).second, iDisk,
iPhi,
iEta, iSide);
1569 std::string detector_part;
1570 detector_part.erase();
1571 std::ostringstream streamProf;
1573 detector_part =
"m_eff";
1574 streamProf << detector_part <<
"_" << iDisk <<
"_" << iSide;
1576 detector_part =
"p_eff";
1577 streamProf << detector_part <<
"_" << iDisk <<
"_" << iSide;
1579 std::string effmapname{stemItr->first + streamProf.str()};
1580 TProfile2D* prof_tmp{
dynamic_cast<TProfile2D*
>(m_inputHist->Get(effmapname.c_str()))};
1581 int global_bin{prof_tmp->GetBin(
iEta+1,
iPhi+1)};
1582 float eff{
static_cast<float>(prof_tmp->GetBinContent(global_bin))};
1583 unsigned long long eff_entry{
static_cast<unsigned long long>(prof_tmp->GetBinEntries(global_bin))};
1586 if (stemItr->second==
ENDCAP_C) meanEff_ECC[iDisk][
iEta] +=
static_cast<double>(
eff);
1587 else if (stemItr->second==
ENDCAP_A) meanEff_ECA[iDisk][
iEta] +=
static_cast<double>(
eff);
1589 std::string effmapname_bcid1 = effmapname+
"_bcid";
1590 TProfile2D* prof_tmp_bcid1 = (TProfile2D*) m_inputHist->Get( effmapname_bcid1.c_str() );
1591 int global_bin_bcid1 = prof_tmp_bcid1->GetBin(
iEta+1,
iPhi+1 );
1592 float eff_bcid1 = (
float)prof_tmp_bcid1->GetBinContent( global_bin_bcid1 );
1596 else if( stemItr->second==
ENDCAP_A ) meanEff_ECA_bcid1[iDisk][
iEta]+=(
double)eff_bcid1;
1599 float effToXML = (eff_entry == 0 ? -1. :
eff);
1602 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
1604 outFile << xmlChannelEfficiencyDataString(waferId, effToXML, sn, iSide) << std::endl;
1607 if (m_efficiencyDoChips) {
1608 for (
int iChip{0}; iChip<n_chipPerSide; ++iChip) {
1609 std::string detector_part_chip;
1610 detector_part_chip.erase();
1611 std::ostringstream streamProfChip;
1613 detector_part_chip =
"m_eff";
1614 streamProfChip << detector_part_chip <<
"_" <<
"chip" << iChip<<
"_" << iDisk <<
"_" << iSide;
1616 detector_part_chip =
"p_eff";
1617 streamProfChip << detector_part_chip <<
"_" <<
"chip" << iChip<<
"_" << iDisk <<
"_" << iSide;
1619 std::string effchipmapname{stemItr->first +
"chip" +
std::to_string(iChip) +
"/" + streamProfChip.str()};
1620 TProfile2D* profChip_tmp{
dynamic_cast<TProfile2D*
>(m_inputHist->Get(effchipmapname.c_str()))};
1621 global_bin = profChip_tmp->GetBin(
iEta+1,
iPhi+1);
1622 float effChip{
static_cast<float>(profChip_tmp->GetBinContent(global_bin))};
1623 unsigned long long effChip_entry{
static_cast<unsigned long long>(profChip_tmp->GetBinEntries(global_bin))};
1626 effToXML = (effChip_entry == 0 ? -1. : effChip);
1628 std::string effchipmapname_bcid1 = effchipmapname+
"_bcid";
1629 TProfile2D* profChip_tmp_bcid1 = (TProfile2D*) m_inputHist->Get( effchipmapname_bcid1.c_str() );
1630 global_bin_bcid1 = profChip_tmp_bcid1->GetBin(
iEta+1,
iPhi+1 );
1631 eff_bcid1 = (
float)profChip_tmp_bcid1->GetBinContent( global_bin_bcid1 );
1632 outFileChip << xmlChannelEfficiencyDataStringChip(waferId, effToXML, eff_bcid1, sn, iSide, iChip) << std::endl;
1637 if (m_writeToCool) {
1638 if (m_pCalibWriteTool->createListEff(waferId, m_pSCTHelper, eff_entry,
eff).isFailure()) {
1640 return StatusCode::FAILURE;
1649 for (
int iLayer{0}; iLayer<
n_barrels; ++iLayer) {
1650 for (
int iSide{0}; iSide<2; ++iSide) {
1652 if (
iEta-6==0)
continue;
1653 for (
int iPhi{0};
iPhi<n_phiBinsBarrel[iLayer]; ++
iPhi) {
1655 std::ostringstream streamProf;
1656 streamProf << iLayer <<
"_" << iSide;
1658 std::string effmapname{
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTB/eff/eff_" + streamProf.str()};
1659 TProfile2D* prof_tmp{
dynamic_cast<TProfile2D*
>(m_inputHist->Get(effmapname.c_str()))};
1660 int global_bin{prof_tmp->GetBin(
iEta+1,
iPhi+1)};
1661 float eff{
static_cast<float>(prof_tmp->GetBinContent(global_bin))};
1662 unsigned long long eff_entry{
static_cast<unsigned long long>(prof_tmp->GetBinEntries(global_bin))};
1665 meanEff_Barrel[iLayer] +=
static_cast<double>(
eff);
1667 std::string effmapname_bcid1 = effmapname+
"_bcid";
1668 TProfile2D* prof_tmp_bcid1 = (TProfile2D*) m_inputHist->Get( effmapname_bcid1.c_str() );
1669 int global_bin_bcid1 = prof_tmp_bcid1->GetBin(
iEta+1,
iPhi+1 );
1670 float eff_bcid1 = (
float)prof_tmp_bcid1->GetBinContent( global_bin_bcid1 );
1673 meanEff_Barrel_bcid1[iLayer]+=(
double)eff_bcid1;
1676 float effToXML = (eff_entry == 0 ? -1. :
eff);
1679 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
1681 outFile << xmlChannelEfficiencyDataString(waferId, effToXML, sn, iSide) << std::endl;
1684 if (m_efficiencyDoChips) {
1685 for (
int iChip{0}; iChip<n_chipPerSide; ++iChip) {
1686 std::ostringstream streamProfChip;
1687 streamProfChip <<
"chip" << iChip <<
"_" << iLayer <<
"_" << iSide;
1689 std::string effchipmapname{
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTB/eff/chip" +
std::to_string(iChip) +
"/eff_" + streamProfChip.str()};
1690 TProfile2D* profChip_tmp{
dynamic_cast<TProfile2D*
>(m_inputHist->Get(effchipmapname.c_str()))};
1691 global_bin = profChip_tmp->GetBin(
iEta+1,
iPhi+1);
1692 float effChip{
static_cast<float>(profChip_tmp->GetBinContent(global_bin))};
1693 unsigned long long effChip_entry{
static_cast<unsigned long long>(profChip_tmp->GetBinEntries(global_bin))};
1696 effToXML = (effChip_entry == 0 ? -1. : effChip);
1698 std::string effchipmapname_bcid1 = effchipmapname+
"_bcid";
1699 TProfile2D* profChip_tmp_bcid1 = (TProfile2D*) m_inputHist->Get( effchipmapname_bcid1.c_str() );
1700 int global_bin_bcid1 = profChip_tmp_bcid1->GetBin(
iEta+1,
iPhi+1 );
1701 float eff_bcid1 = (
float)profChip_tmp_bcid1->GetBinContent( global_bin_bcid1 );
1703 outFileChip << xmlChannelEfficiencyDataStringChip(waferId, effToXML, eff_bcid1, sn, iSide, iChip) << std::endl;
1708 if (m_writeToCool) {
1709 if (m_pCalibWriteTool->createListEff(waferId, m_pSCTHelper, eff_entry,
eff).isFailure()) {
1711 return StatusCode::FAILURE;
1719 outFile <<
" </modules>" << std::endl;
1720 outFile <<
"</run>" << std::endl;
1722 if (m_efficiencyDoChips) {
1723 outFileChip <<
" </chips>" << std::endl;
1724 outFileChip <<
"</run>" << std::endl;
1728 std::ostringstream summaryList;
1731 if (n_phiBinsEndcap[
i][j] != 0) {
1732 meanEff_ECC[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1733 summaryList << xmlPartData(
ENDCAP_C,
i, j,
"meanEff", meanEff_ECC[
i][j]);
1734 meanEff_ECC_bcid1[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1735 summaryList<<xmlPartData(
ENDCAP_C,
i, j,
"meanEff_bcid1",meanEff_ECC_bcid1[
i][j]);
1740 meanEff_Barrel[
i] /= (n_phiBinsBarrel[
i]*n_etaInBarrel*2);
1741 summaryList << xmlPartData(
BARREL,
i, 0,
"meanEff", meanEff_Barrel[
i]);
1742 meanEff_Barrel_bcid1[
i] /= (n_phiBinsBarrel[
i]*n_etaInBarrel*2);
1743 summaryList<<xmlPartData(
BARREL,
i, 0,
"meanEff_bcid1",meanEff_Barrel_bcid1[
i]);
1747 if (n_phiBinsEndcap[
i][j] != 0) {
1748 meanEff_ECA[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1749 summaryList << xmlPartData(
ENDCAP_A,
i, j,
"meanEff", meanEff_ECA[
i][j]);
1750 meanEff_ECA_bcid1[
i][j] /= (n_phiBinsEndcap[
i][j]*2);
1751 summaryList<<xmlPartData(
ENDCAP_A,
i, j,
"meanEff_bcid1",meanEff_ECA_bcid1[
i][j]);
1756 if (openXML4MonSummary(m_outEffSummary,
"Efficiency").isFailure()) {
1758 return StatusCode::FAILURE;
1761 if (wrapUpXML4Summary(m_outEffSummary,
"Efficiency", summaryList).isFailure()) {
1763 return StatusCode::FAILURE;
1767 if (m_writeToCool) {
1768 if (m_pCalibWriteTool->wrapUpEfficiency().isFailure()) {
1770 return StatusCode::FAILURE;
1774 return StatusCode::SUCCESS;
1786 int n_phiBinsBarrel[
n_barrels] = {n_phiBinsB0, n_phiBinsB1, n_phiBinsB2, n_phiBinsB3};
1787 int n_phiBinsEndcap[
n_disks][
n_etaBinsEC] = {{n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1788 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1789 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1790 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1791 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1792 {n_phiBinsECOuter, n_phiBinsECMiddle, n_phiBinsECShort},
1793 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1794 {n_phiBinsECOuter, n_phiBinsECMiddle, 0},
1795 {n_phiBinsECOuter, 0, 0}
1798 unsigned long long nErrLink_Barrel[
n_barrels] = {0};
1802 unsigned long long nErrLink_Barrel_module[
n_barrels][2][
n_etaBins][n_phiBinsB3] = {{{{0}}}};
1803 unsigned long long nErrLink_ECA_module[
n_disks][2][
n_etaBinsEC][n_phiBinsECOuter] = {{{{0}}}};
1804 unsigned long long nErrLink_ECC_module[
n_disks][2][
n_etaBinsEC][n_phiBinsECOuter] = {{{{0}}}};
1815 using IntStringMap = std::map<int, std::string>;
1816 IntStringMap ErrMap_C, ErrMap;
1817 const int numberOfErrorTypes{12};
1818 std::array<std::string, numberOfErrorTypes> errorNames = {{
1819 "ByteStreamParseError",
"TimeOutError",
"BCIDError",
"LVL1IDError",
"PreambleError",
"FormatterError",
1820 "ABCDError",
"RawError",
"MaskedLink",
"RODClockError",
1821 "TruncatedROD",
"ROBFragmentError"
1825 std::array<std::string, numberOfErrorTypes> errorNames_C = {{
1826 "ByteStreamParseError",
"TimeOutError",
"BCIDError",
"LVL1IDError",
"PreambleError",
"FormatterError",
1827 "ABCDError",
"RawError",
"MaskedLink",
"RODClockError",
1828 "TruncatedROD",
"ROBFragmentError"
1831 std::array<int, numberOfErrorTypes> errorValues = {{0, 1, 2, 3, 4, 5, 9, 10, 11, 12, 13, 14}};
1834 for (
int indx{0}; indx!=numberOfErrorTypes; ++indx) {
1835 ErrMap_C.insert(std::make_pair(errorValues[indx], errorNames_C[indx]));
1838 for (
int indx{0}; indx!=numberOfErrorTypes; ++indx) {
1839 ErrMap.insert(std::make_pair(errorValues[indx], errorNames[indx]));
1844 std::array<std::string, N_ENDCAPS> detectorStems = {{
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEC/errors/",
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTEA/errors/"}};
1845 std::array<IntStringMap::iterator, N_ENDCAPS> detectorIterators = {{ErrMap_C.begin(), ErrMap.begin()}};
1846 std::array<IntStringMap::iterator, N_ENDCAPS> detectorIteratorsE = {{ErrMap_C.end(), ErrMap.end()}};
1847 std::array<std::string, N_ENDCAPS> detectorParts = {{
"EC",
"EA"}};
1848 std::string defecttype{
""};
1849 std::string n_defect{
""};
1852 for (
int stemIndex{0}; stemIndex!=
N_ENDCAPS; ++stemIndex) {
1853 const int thisBec{(4 * stemIndex) - 2};
1854 const std::string detector_part{detectorParts[stemIndex]};
1855 for (
int iDisk{0}; iDisk<
n_disks; ++iDisk) {
1856 for (
int iSide{0}; iSide<2; ++iSide) {
1861 std::ostringstream osErrorList;
1862 std::ostringstream osProbList;
1864 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
1868 nErrLink_ECC_module_serial[iDisk][iSide][
iEta][
iPhi]=sn.
str();
1870 nErrLink_ECA_module_serial[iDisk][iSide][
iEta][
iPhi]=sn.str();
1875 for (
int iType{0}; iType < n_BSErrorType; ++iType) {
1876 float errorProb{0.};
1877 unsigned long long n_errors{0};
1878 if (errItr!=errItrE and iType == errItr->first) {
1879 std::ostringstream streamHist;
1880 std::ostringstream streamHistAlt;
1881 streamHist <<
"SCT_NumberOf" << errItr->second << detector_part <<
"_" << iDisk <<
"_" << iSide;
1882 streamHistAlt <<
"SCT_" << errItr->second << detector_part <<
"_" << iDisk <<
"_" << iSide;
1883 std::string
folder = errItr->second+std::string(
"/");
1885 std::string profname = detectorStems[stemIndex] +
folder +streamHist.str();
1886 std::string profnameShort = detectorStems[stemIndex] + streamHist.str();
1887 std::string profnameAlt = detectorStems[stemIndex] +
folder +streamHistAlt.str();
1888 std::string profnameAltShort = detectorStems[stemIndex] + streamHistAlt.str();
1890 TProfile2D* prof_tmp = (TProfile2D*) m_inputHist->Get( profname.c_str() );
1891 if(prof_tmp ==
nullptr) {
1892 prof_tmp = (TProfile2D*) m_inputHist->Get( profnameShort.c_str() );
1894 if(prof_tmp ==
nullptr) {
1895 prof_tmp = (TProfile2D*) m_inputHist->Get( profnameAlt.c_str() );
1897 if(prof_tmp ==
nullptr) {
1898 prof_tmp = (TProfile2D*) m_inputHist->Get( profnameAltShort.c_str() );
1900 if(prof_tmp ==
nullptr) {
1901 msg( MSG::ERROR ) <<
"Unable to get profile for BSErrorsDB : " << profname <<
endmsg;
1902 return StatusCode::FAILURE;
1905 float n_errors_float = prof_tmp->GetBinContent(
iEta+1,
iPhi+1);
1906 if (n_errors_float != 0){
1908 nErrs_ECC_module[iDisk][iSide][
iEta][
iPhi][errItr->first] = n_errors_float;
1910 nErrs_ECA_module[iDisk][iSide][
iEta][
iPhi][errItr->first] = n_errors_float;
1914 n_errors =
static_cast<unsigned long long>(n_errors_float);
1916 defecttype = m_pCalibWriteTool->addNumber(defecttype, errItr->first);
1917 n_defect = m_pCalibWriteTool->addNumber(n_defect, n_errors);
1918 errorProb =
static_cast<float>(n_errors) /
static_cast<float>(m_numberOfEvents);
1920 nErrLink_ECC_module[iDisk][iSide][
iEta][
iPhi]+=n_errors;
1922 nErrLink_ECA_module[iDisk][iSide][
iEta][
iPhi]+=n_errors;
1928 osErrorList << n_errors;
1929 osProbList << errorProb;
1930 if (iType != n_BSErrorType-1) {
1936 if (!(defecttype.empty()) || n_errorLink == 0) {
1939 nErrLink_ECC[iDisk][
iEta]++;
1941 nErrLink_ECA[iDisk][
iEta]++;
1943 if (m_writeToCool) {
1944 if (m_pCalibWriteTool->createListBSErr(waferId, m_pSCTHelper, m_numberOfEvents, osErrorList.str(), osProbList.str()).isFailure()) {
1946 return StatusCode::FAILURE;
1956 for (
int iLayer{0}; iLayer<
n_barrels; ++iLayer) {
1957 for (
int iSide{0}; iSide<2; ++iSide) {
1959 if (
iEta-6==0)
continue;
1960 for (
int iPhi{0};
iPhi<n_phiBinsBarrel[iLayer]; ++
iPhi) {
1963 std::ostringstream osErrorList;
1964 std::ostringstream osProbList;
1966 IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
1968 nErrLink_Barrel_module_serial[iLayer][iSide][
iEta][
iPhi] = sn.
str();
1971 for (
int iType{0}; iType < n_BSErrorType; ++iType) {
1972 float errorProb{0.};
1973 unsigned long long n_errors{0};
1974 if (errItr!=errItrE and iType == errItr->first) {
1975 std::ostringstream streamHist;
1976 streamHist <<
"SCT_NumberOf" << errItr->second <<
"B" <<
"_" << iLayer <<
"_" << iSide;
1978 std::string
folder = errItr->second+std::string(
"/");
1979 std::string profname =
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTB/errors/" +
folder + streamHist.str();
1980 std::string profnameShort =
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/SCTB/errors/" + streamHist.str();
1982 TProfile2D* prof_tmp = (TProfile2D*) m_inputHist->Get( profname.c_str() );
1983 if(prof_tmp ==
nullptr) {
1984 prof_tmp = (TProfile2D*) m_inputHist->Get( profnameShort.c_str() );
1986 if(prof_tmp ==
nullptr) {
1987 msg( MSG::ERROR ) <<
"Unable to get profile for BSErrorsDB : " << profname <<
endmsg;
1988 return StatusCode::FAILURE;
1991 float n_errors_float = prof_tmp->GetBinContent(
iEta+1,
iPhi+1);
1992 if (n_errors_float != 0){
1993 nErrs_Barrel_module[iLayer][iSide][
iEta][
iPhi][errItr->first] = n_errors_float;
1996 n_errors =
static_cast<unsigned long long>(n_errors_float);
1998 defecttype = m_pCalibWriteTool->addNumber(defecttype, errItr->first);
1999 n_defect = m_pCalibWriteTool->addNumber(n_defect, n_errors);
2000 errorProb =
static_cast<float>(n_errors) /
static_cast<float>(m_numberOfEvents);
2001 nErrLink_Barrel_module[iLayer][iSide][
iEta][
iPhi]+=n_errors;
2006 osErrorList << n_errors;
2007 osProbList << errorProb;
2008 if (iType != n_BSErrorType-1) {
2014 if (!(defecttype.empty())) {
2016 nErrLink_Barrel[iLayer]++;
2017 if (m_writeToCool) {
2018 if (m_pCalibWriteTool->createListBSErr(waferId, m_pSCTHelper, m_numberOfEvents, osErrorList.str(), osProbList.str()).isFailure()) {
2020 return StatusCode::FAILURE;
2029 ATH_MSG_INFO(
"#Links which send BSError : " << n_errorLink);
2032 std::ostringstream summaryList;
2035 if (n_phiBinsEndcap[
i][j] != 0) {
2036 summaryList << xmlPartData(
ENDCAP_C,
i, j,
"nErrLink", nErrLink_ECC[
i][j]);
2041 summaryList << xmlPartData(
BARREL,
i, 0,
"nErrLink", nErrLink_Barrel[
i]);
2046 if (n_phiBinsEndcap[
i][j] != 0) {
2047 summaryList << xmlPartData(
ENDCAP_A,
i, j,
"nErrLink", nErrLink_ECA[
i][j]);
2052 if (openXML4MonSummary(m_outBSErrSummary,
"BSErrors").isFailure()) {
2054 return StatusCode::FAILURE;
2056 if (wrapUpXML4Summary(m_outBSErrSummary,
"BSErrors", summaryList).isFailure()) {
2058 return StatusCode::FAILURE;
2066 if (n_phiBinsEndcap[
i][j] != 0) {
2067 for (
int k{0};
k < 2;
k++) {
2068 for (
int l{0};
l < n_phiBinsEndcap[
i][j];
l++) {
2069 serial = nErrLink_ECC_module_serial[
i][
k][j][
l];
2072 std::ostringstream errList;
2073 for (
int errCount{0}; errCount < numberOfErrorTypes; errCount++) {
2074 int type{errorValues[errCount]};
2075 errList <<
" " <<
xmlValue(ErrMap[
type], nErrs_ECC_module[
i][
k][j][
l][
type]) << std::endl;
2078 moduleList << xmlModuleData(
ENDCAP_C,
i,
k, j,
l,
"nErrors", nErrLink_ECC_module[
i][
k][j][
l], serial, errList.str());
2088 for (
int j{0}; j < 2; j++) {
2090 for (
int l{0};
l < n_phiBinsBarrel[
i] ;
l++) {
2091 serial = nErrLink_Barrel_module_serial[
i][j][
k][
l];
2093 std::ostringstream errList;
2094 for (
int errCount{0}; errCount < numberOfErrorTypes; errCount++) {
2095 int type{errorValues[errCount]};
2096 errList <<
" " <<
xmlValue(ErrMap[
type], nErrs_Barrel_module[
i][j][
k][
l][
type]) << std::endl;
2099 moduleList << xmlModuleData(
BARREL,
i, j,
k,
l,
"nErrors", nErrLink_Barrel_module[
i][j][
k][
l], serial, errList.str());
2107 if (n_phiBinsEndcap[
i][j] != 0) {
2108 for (
int k{0};
k < 2;
k++) {
2109 for (
int l{0};
l < n_phiBinsEndcap[
i][j];
l++) {
2110 serial = nErrLink_ECA_module_serial[
i][
k][j][
l];
2112 std::ostringstream errList;
2113 for (
int errCount{0}; errCount < numberOfErrorTypes; errCount++) {
2114 int type{errorValues[errCount]};
2115 errList <<
" " <<
xmlValue(ErrMap[
type], nErrs_ECA_module[
i][
k][j][
l][
type]) << std::endl;
2118 moduleList << xmlModuleData(
ENDCAP_A,
i,
k, j,
l,
"nErrors", nErrLink_ECA_module[
i][
k][j][
l], serial, errList.str());
2125 if (openXML4MonSummary(m_outBSErrModule,
"BSErrorsModule").isFailure()) {
2127 return StatusCode::FAILURE;
2129 if (wrapUpXML4Summary(m_outBSErrModule,
"BSErrors",
moduleList).isFailure()) {
2131 return StatusCode::FAILURE;
2135 if (m_writeToCool) {
2136 if (m_pCalibWriteTool->wrapUpBSErrors().isFailure()) {
2138 return StatusCode::FAILURE;
2142 return StatusCode::SUCCESS;
2155 float A_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2156 float LA_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2157 float B_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2158 float Sigma_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2160 float Err_A_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2161 float Err_LA_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2162 float Err_B_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2163 float Err_Sigma_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2165 float MCW_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2166 float Err_MCW_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2167 float Chisq_BarrelSide[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2169 std::string DBUploadFlag{
"G"};
2170 std::string
module[2] = {
"100",
"111"};
2171 int moduleint[2] = {100, 111};
2173 int FitFlag[
n_barrels][2][2] = {{{0}, {0}}, {{0}, {0}}};
2182 stem =
"/run_" +
std::to_string(m_runNumber.value()) +
"/SCT/GENERAL/lorentz/";
2183 m_h_phiVsNstripsSideHistoVector.clear();
2184 for (
int iLayer{0}; iLayer <
n_barrels ; ++iLayer) {
2185 for (
int iSide{0}; iSide < 2; ++iSide) {
2186 for (
int iModule{0}; iModule < 2; ++iModule) {
2187 std::ostringstream streamHist;
2188 streamHist <<
"h_phiVsNstrips_" <<
module[iModule] <<
"_" << iLayer <<
"Side" << iSide;
2189 std::string
histName{stem + streamHist.str()};
2191 if (hist_tmp ==
nullptr) {
2193 return StatusCode::FAILURE;
2195 m_h_phiVsNstripsSideHistoVector.push_back(hist_tmp);
2201 const char* outputLorentzAngleFileName{m_LorentzAngleFile.value().c_str()};
2204 ATH_MSG_ERROR(
"Unable to open LorentzAngleFile : " << outputLorentzAngleFileName);
2205 return StatusCode::FAILURE;
2209 std::ostringstream osHeader;
2210 osHeader <<
"<folder>" << std::endl;
2213 fitFile =
new TFile(
"FittingDebugFile.root",
"RECREATE");
2216 for (
int iLayer{0}; iLayer <
n_barrels; ++iLayer) {
2217 for (
int iSide{0}; iSide < 2; ++iSide) {
2218 for (
int iModule{0}; iModule < 2; ++iModule) {
2219 if (iLayer==1 and iModule==0)
continue;
2220 ATH_MSG_INFO(
"LorentzAngle fit start : " << 4*iLayer + iSide +1 + iModule <<
" / 16");
2222 Double_t
par[4], err_par[4];
2223 TF1* LAfit{
new TF1{
"LAfit",
LA_func, -9., 2., 4}};
2224 std::ostringstream streamFile;
2225 streamFile <<
"h_phiVsNstrips_" <<
module[iModule] <<
"_" << iLayer <<
"Side" << iSide;
2227 LAfit->SetParLimits(3, 0.1, 50.);
2228 LAfit->SetParNames(
"a",
"LA",
"b",
"sigma");
2229 LAfit->SetParameters(1., -5., 1.13, 2.);
2230 fitResult = m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Fit(
"LAfit",
"E",
"", -9., 2.);
2231 LAfit->GetParameters(
par);
2232 err_par[0] = LAfit->GetParError(0);
2233 err_par[1] = LAfit->GetParError(1);
2234 err_par[2] = LAfit->GetParError(2);
2235 err_par[3] = LAfit->GetParError(3);
2238 if (m_LorentzAngleDebugMode) {
2239 std::ostringstream streamFileTmp;
2240 streamFileTmp <<
"h_phiVsNstrips_" <<
module[iModule] <<
"_" << iLayer <<
"Side" << iSide <<
"_First_Fit";
2241 std::string
dn{streamFile.str()};
2242 std::string tmp_hn{streamFileTmp.str()};
2243 const char* dir_name{
dn.c_str()};
2244 const char* histo_name{tmp_hn.c_str()};
2246 fitFile->mkdir(dir_name);
2247 fitFile->cd(dir_name);
2248 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->SetName(histo_name);
2249 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Write();
2250 ATH_MSG_INFO(
"-------:Directory Name: " << dir_name <<
"--------");
2253 if (fitResult != 0) {
2254 ATH_MSG_INFO(
"Try to use parabola Fit to determine initial value!");
2255 TF1* parafit{
new TF1{
"parafit",
"[0]*(x-[1])*(x-[1])+[2]", -9., 2.}};
2256 ATH_MSG_INFO(
"LorentzAngle 2nd para fit start : " << 4*iLayer + iSide +1 + iModule <<
" / 16");
2257 parafit->SetParameters(
par[0],
par[1], LAfit->Eval(
par[1], 0, 0, 0));
2258 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Fit(
"parafit",
"R",
"", -9., 2.);
2259 ATH_MSG_INFO(
"LorentzAngle 2nd pre fit start : " << 4*iLayer + iSide +1 + iModule <<
" / 16");
2260 par[1] = parafit->GetParameter(1);
2262 LAfit->SetParLimits(1,
par[1],
par[1]);
2263 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Fit(
"LAfit",
"R",
"", -9., 2.);
2264 LAfit->GetParameters(
par);
2265 LAfit->SetParLimits(1, -90., 90.);
2267 ATH_MSG_INFO(
"LorentzAngle 2nd main fit start : " << 4*iLayer + iSide +1 + iModule <<
" / 16");
2268 fitResult = m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Fit(
"LAfit",
"E",
"", -9., 2.);
2269 LAfit->GetParameters(
par);
2270 if (m_LorentzAngleDebugMode) {
2271 std::ostringstream streamFileTmp;
2272 streamFileTmp <<
"h_phiVsNstrips_" <<
module[iModule] <<
"_" << iLayer <<
"Side" << iSide <<
"Second_Fit";
2273 std::string tmp_hn{streamFileTmp.str()};
2274 const char* histo_name{tmp_hn.c_str()};
2275 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->SetName(histo_name);
2276 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Write();
2280 if (fitResult != 0) {
2281 ATH_MSG_INFO(
"Try to fix one parameter sigma=2.0 to determine other initial value!");
2282 ATH_MSG_INFO(
"LorentzAngle 3rd pre fit start : " << 4*iLayer + iSide +1+ iModule <<
" / 16");
2283 LAfit->SetParameters(
par[0],
par[1],
par[2], 2.);
2284 LAfit->SetParLimits(3, 2., 2.);
2285 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Fit(
"LAfit",
"R",
"", -9., 2.);
2286 LAfit->GetParameters(
par);
2287 LAfit->SetParLimits(3, 0., 50.);
2289 ATH_MSG_INFO(
"LorentzAngle 3rd main fit start : " << 4*iLayer + iSide +1 +iModule <<
" / 16");
2290 fitResult = m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Fit(
"LAfit",
"E",
"", -9., 2.);
2291 LAfit->GetParameters(
par);
2292 if (m_LorentzAngleDebugMode) {
2293 std::ostringstream streamFileTmp;
2294 streamFileTmp <<
"h_phiVsNstrips_" <<
module[iModule] <<
"_" << iLayer <<
"Side" << iSide <<
"Third_Fit";
2295 std::string tmp_hn{streamFileTmp.str()};
2296 const char* histo_name{tmp_hn.c_str()};
2297 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->SetName(histo_name);
2298 m_h_phiVsNstripsSideHistoVector[4*iLayer + 2*iSide +iModule]->Write();
2302 if (fitResult == 0) {
2303 FitFlag[iLayer][iSide][iModule] = 1;
2306 FitFlag[iLayer][iSide][iModule] = 0;
2313 double err_A{err_par[0]};
2314 double err_LA{err_par[1]};
2315 double err_B{err_par[2]};
2316 double err_sigma{err_par[3]};
2317 float MCW{
static_cast<float>(LAfit->Eval(LA, 0, 0, 0))};
2318 float err_MCW{
static_cast<float>(LAfit->Eval(std::abs(err_par[1]), 0, 0, 0))};
2320 A_BarrelSide[iLayer][iSide][iModule] =
A;
2321 LA_BarrelSide[iLayer][iSide][iModule] = LA;
2322 B_BarrelSide[iLayer][iSide][iModule] =
B;
2323 Sigma_BarrelSide[iLayer][iSide][iModule] =
sigma;
2324 Err_A_BarrelSide[iLayer][iSide][iModule] = err_A;
2325 Err_LA_BarrelSide[iLayer][iSide][iModule] = err_LA;
2326 Err_B_BarrelSide[iLayer][iSide][iModule] = err_B;
2327 Err_Sigma_BarrelSide[iLayer][iSide][iModule] = err_sigma;
2328 MCW_BarrelSide[iLayer][iSide][iModule] = MCW;
2329 Err_MCW_BarrelSide[iLayer][iSide][iModule] = err_MCW;
2330 Chisq_BarrelSide[iLayer][iSide][iModule] = LAfit->GetChisquare();
2335 if (m_LorentzAngleDebugMode) {
2339 for (
int iLayer{0}; iLayer <
n_barrels; ++iLayer) {
2340 for (
int iSide{0}; iSide < 2; ++iSide) {
2341 for (
int iModule{0}; iModule < 2; ++iModule) {
2344 outFile <<
"<folderDefinition folder=\"SCT/Derived/LorentzAngleRun2_v2\" version=\"multi\">" << linefeed
2345 <<
" <folderDescription>" << linefeed
2346 <<
" <timeStamp>run-lumi</timeStamp>" << linefeed
2347 <<
" <addrHeader>" << linefeed
2348 <<
" <address_header service_type=\"71\" clid=\"1238547719\">" << linefeed
2349 <<
" </addrHeader>" << linefeed
2350 <<
" <typeName>CondAttrListCollection</typeName>" << linefeed
2351 <<
" </folderDescription>" << linefeed
2352 <<
" <payloadDescription>" << linefeed
2353 <<
" <payloadType name=\"moduleType\">" << moduleint[iModule] <<
"</payloadType>" << linefeed
2354 <<
" <payloadType name=\"lorentzAngle\">" << LA_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2355 <<
" <payloadType name=\"err_lorentzAngle\">" << Err_LA_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2356 <<
" <payloadType name=\"chisq\">" << Chisq_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2357 <<
" <payloadType name=\"fitParam_a\">" << A_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2358 <<
" <payloadType name=\"err_a\">" << Err_A_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2359 <<
" <payloadType name=\"fitParam_b\">" << B_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2360 <<
" <payloadType name=\"err_b\">" << Err_B_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2361 <<
" <payloadType name=\"fitParam_sigma\">" << Sigma_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2362 <<
" <payloadType name=\"err_sigma\">" << Err_Sigma_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2363 <<
" <payloadType name=\"minClusterWidth\">" << MCW_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2364 <<
" <payloadType name=\"err_minClusterWidth\">" << Err_MCW_BarrelSide[iLayer][iSide][iModule] <<
"</payloadType>" << linefeed
2365 <<
" </payloadDescription>" << linefeed
2366 <<
" <channel id=\"" <<
ch <<
"\" name=\"" << iLayer <<
"_" << iSide <<
" \" />" << linefeed
2367 <<
"</folderDefinition>" << std::endl;
2372 if (m_writeToCool) {
2373 if (m_pCalibWriteTool->createListLA(waferId, m_pSCTHelper, 10000, moduleint[iModule], LA_BarrelSide[iLayer][iSide][iModule], Err_LA_BarrelSide[iLayer][iSide][iModule], Chisq_BarrelSide[iLayer][iSide][iModule], A_BarrelSide[iLayer][iSide][iModule], Err_A_BarrelSide[iLayer][iSide][iModule], B_BarrelSide[iLayer][iSide][iModule], Err_B_BarrelSide[iLayer][iSide][iModule], Sigma_BarrelSide[iLayer][iSide][iModule], Err_Sigma_BarrelSide[iLayer][iSide][iModule], MCW_BarrelSide[iLayer][iSide][iModule], Err_MCW_BarrelSide[iLayer][iSide][iModule]).isFailure()) {
2375 return StatusCode::FAILURE;
2384 outFile <<
"</folder>" << std::endl;
2387 std::ostringstream summaryList;
2389 for (
int iSide{0}; iSide < 2; ++iSide) {
2390 for (
int iModule{0}; iModule < 2; ++iModule) {
2392 summaryList <<
" <parts>" << linefeed
2393 <<
xmlValue(
"part", thisPart) << linefeed
2395 <<
xmlValue(
"Side", iSide) << linefeed
2397 <<
xmlValue(
"lorentzAngle", LA_BarrelSide[
i][iSide][iModule]) << linefeed
2398 <<
xmlValue(
"minClusterWidth", MCW_BarrelSide[
i][iSide][iModule]) << linefeed
2399 <<
xmlValue(
"Fit", FitFlag[
i][iSide][iModule]) << linefeed
2400 <<
" </parts>" << linefeed;
2405 std::ofstream&
file{m_outLASummary};
2406 using TwoStrings = std::pair<std::string, std::string>;
2407 using Names = std::map<std::string, TwoStrings>;
2408 Names nameAssociation;
2409 nameAssociation[
"LorentzAngle"]=TwoStrings(m_LorentzAngleSummaryFile,
"LorentzAngleInfo.xsl");
2411 if (
found!=nameAssociation.end()) {
2413 std::string xslName{
found->second.second};
2415 if (!
file.good())
return StatusCode::FAILURE;
2416 file <<
xmlHeader << linefeed << associateStylesheet(xslName) << linefeed <<
"<run>" << std::endl;
2418 ATH_MSG_ERROR(
" argument \"type\" needs to be LorentzAngle.");
2419 return StatusCode::FAILURE;
2422 file <<
xmlValue(
"RunNumber", m_runNumber.value()) << linefeed
2423 <<
xmlValue(
"StartTime", m_utcBegin) << linefeed
2424 <<
xmlValue(
"EndTime", m_utcEnd) << linefeed
2425 <<
xmlValue(
"Duration", m_calibEvtInfoTool->duration()) << linefeed
2426 <<
xmlValue(
"LB", m_LBRange) << linefeed
2427 <<
xmlValue(
"Events", m_numberOfEvents) << linefeed
2428 <<
xmlValue(
"Flag", DBUploadFlag) << linefeed
2429 <<
" <data>" << std::endl;
2431 if (wrapUpXML4Summary(m_outLASummary,
"LorentzAngle", summaryList).isFailure()) {
2433 return StatusCode::FAILURE;
2437 if (m_writeToCool) {
2438 if (m_pCalibWriteTool->wrapUpLorentzAngle().isFailure()) {
2440 return StatusCode::FAILURE;
2443 return StatusCode::SUCCESS;
2451 if (!strcmp(
type,
"DeadStrip")) {
2453 if (!
file.good())
return StatusCode::FAILURE;
2454 file <<
"<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadStrips\" ";
2455 }
else if (!strcmp(
type,
"DeadChip")) {
2457 if (!
file.good())
return StatusCode::FAILURE;
2458 file <<
"<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadChips\" ";
2460 ATH_MSG_ERROR(
"in openXML4DB : argument \"type\" needs to be (DeadStrip, DeadChip).");
2461 return StatusCode::FAILURE;
2463 file <<
"since=\"" <<
start.re_time() <<
"\" "
2464 <<
"until=\"" <<
end.re_time() <<
"\" "
2465 <<
"tag=\"" <<
tag <<
"\" "
2466 <<
"version=\"" <<
"multi\">" << linefeed;
2467 return StatusCode::SUCCESS;
2472 file <<
"</channels>" << std::endl;
2473 if (
file.is_open()) {
2475 return StatusCode::SUCCESS;
2477 return StatusCode::FAILURE;
2483 std::string
tmp{DefectList};
2484 int length{
static_cast<int>(
tmp.length())};
2485 std::string Defect4DB{
tmp.substr(1,
length-2)};
2488 <<
xmlValue(
"SampleSize",
"10000") << linefeed
2493 <<
xmlValue(
"DefectType", DefectType) << linefeed
2495 <<
xmlValue(
"DefectList", Defect4DB) << linefeed
2498 return StatusCode::SUCCESS;
2506 if (!strcmp(
type,
"DEAD")) {
2508 if (!
file.good())
return StatusCode::FAILURE;
2509 file <<
xmlHeader << linefeed << associateStylesheet(
"DeadInfo.xsl") << linefeed
2510 <<
"<run>" << linefeed;
2512 ATH_MSG_ERROR(
"in openXML4DeadSummary : argument \"type\" needs to be \"DEAD\".");
2513 return StatusCode::FAILURE;
2517 std::string strUploadFlag{
"U"};
2518 bool isNonZero{
false};
2523 strUploadFlag =
"G";
2525 strUploadFlag =
"R";
2530 std::ostringstream osNonZero;
2531 osNonZero <<
"#chips or #strips is non-zero";
2532 std::ostringstream osFlagReason;
2533 if (!isNonZero) osFlagReason <<
"FAILED in " << osNonZero.str();
2535 std::ostringstream osCheckList;
2536 osCheckList << osNonZero.str();
2544 <<
xmlValue(
"Modules", n_Module) << linefeed
2545 <<
xmlValue(
"Links", n_Link) << linefeed
2546 <<
xmlValue(
"Chips", n_Chip) << linefeed
2547 <<
xmlValue(
"Strips", n_Strip) << linefeed
2548 <<
xmlValue(
"Flag", strUploadFlag) << linefeed
2549 <<
xmlValue(
"FlagReason", osFlagReason.str()) << linefeed
2550 <<
xmlValue(
"FlagEnable", strFlagEnable) << linefeed
2551 <<
xmlValue(
"CheckList", osCheckList.str()) << linefeed
2552 <<
" <modules>" << std::endl;
2554 return StatusCode::SUCCESS;
2559 using TwoStrings = std::pair<std::string, std::string>;
2560 using Names = std::map<std::string, TwoStrings>;
2561 Names nameAssociation;
2568 if (
found!=nameAssociation.end()) {
2570 std::string xslName{
found->second.second};
2573 if (!
file.good())
return StatusCode::FAILURE;
2574 file <<
xmlHeader << linefeed << associateStylesheet(xslName) << linefeed <<
"<run>" << std::endl;
2576 ATH_MSG_ERROR(
"in openXML4MonSummary : argument \"type\" needs to be (NoiseOccupancy, RawOccupancy, Efficiency, BSErrors).");
2577 return StatusCode::FAILURE;
2585 <<
" <data>" << std::endl;
2586 return StatusCode::SUCCESS;
2592 if (!strcmp(
type,
"DEAD")) {
2593 file <<
" </modules>" << std::endl;
2594 }
else if (!strcmp(
type,
"NoiseOccupancy") or !strcmp(
type,
"RawOccupancy") or !strcmp(
type,
"Efficiency") or !strcmp(
type,
"BSErrors") or !strcmp(
type,
"LorentzAngle")) {
2595 file <<
" </data>" << std::endl;
2597 file <<
"</run>" << std::endl;
2599 if (
file.is_open()) {
2601 return StatusCode::SUCCESS;
2603 return StatusCode::FAILURE;
2610 const std::string tmpstrip{stripId};
2611 const std::string tmpchip{chipId};
2612 int len_strip{
static_cast<int>(tmpstrip.length())};
2613 int len_chip{
static_cast<int>(tmpchip.length())};
2614 std::string stripList{
""};
2615 std::string chipList{
""};
2616 if (len_strip > 0) {
2617 int stringLength = (len_strip-2 >0) ? len_strip-2 : len_strip;
2618 stripList = tmpstrip.substr(1, stringLength);
2621 int stringLength = (len_chip-2 >0) ? len_chip-2 : len_chip;
2622 chipList = tmpchip.substr(1, stringLength);
2647 if (!strcmp(
type,
"DEAD")) {
2651 ATH_MSG_ERROR(
"in addToSummaryStr : argument \"type\" needs to be \"DEAD\".");
2652 return StatusCode::FAILURE;
2655 return StatusCode::SUCCESS;
2661 std::ostringstream
os;
2663 <<
" " <<
xmlValue(
"SN", serial.
str()) << std::endl
2664 <<
" " <<
xmlValue(
"SampleSize",
"10000") << std::endl
2669 <<
" " <<
xmlValue(
"NoiseOccupancy", occupancy) << std::endl
2677 std::ostringstream
os;
2678 os <<
" <module>" << std::endl
2679 <<
" " <<
xmlValue(
"SN", serial.
str()) << std::endl
2680 <<
" " <<
xmlValue(
"SampleSize",
"10000") << std::endl
2694 std::ostringstream
os;
2695 os <<
" <chip>" << std::endl
2696 <<
" " <<
xmlValue(
"SN", serial.
str()) << std::endl
2697 <<
" " <<
xmlValue(
"SampleSize",
"10000") << std::endl
2703 <<
" " <<
xmlValue(
"Chip", chip )<<std::endl
2705 <<
" " <<
xmlValue(
"Efficiency_bcid", efficiency_bcid) << std::endl
2710 std::pair<int, bool>
2714 int numNoisyStripsInTheWafer{0};
2715 bool isNoisyWafer{
false};
2717 for (
int iStrip{0}; iStrip !=
nbins; ++iStrip) {
2731 << averageOccupancy);
2733 return std::make_pair(numNoisyStripsInTheWafer, isNoisyWafer);
2741 for (
int iStrip{0}; iStrip !=
nbins; ++iStrip) {
2744 stripIdList.insert(stripId);
2747 if (stripOccupancy > noisyStripThr) {
2749 stripIdList.insert(stripId);
2754 if (isGoodInConfiguration and isGoodInCalibration) {
2755 stripIdList.insert(stripId);
2762 return StatusCode::SUCCESS;
2768 (
const std::map<Identifier, std::set<Identifier>>& moduleListAll,
2769 const std::map<Identifier, std::set<Identifier>>& moduleListNew,
2770 const std::map<Identifier, std::set<Identifier>>& moduleListRef) {
2772 float noisyStripThr{m_noisyStripThrDef?(m_noisyStripThrOffline):(m_noisyStripThrOnline)};
2776 for (; idItr != idItrE; ++idItr) {
2777 if (m_pSCTHelper->side(*idItr) == 0) {
2778 Identifier moduleId{m_pSCTHelper->module_id(*idItr)};
2779 std::map<Identifier, std::set<Identifier>>::const_iterator moduleAllItr{moduleListAll.find(moduleId)};
2780 std::map<Identifier, std::set<Identifier>>::const_iterator moduleNewItr{moduleListNew.find(moduleId)};
2781 std::map<Identifier, std::set<Identifier>>::const_iterator moduleRefItr{moduleListRef.find(moduleId)};
2782 std::string defectStripsAll{moduleAllItr != moduleListAll.end() ? getStripList((*moduleAllItr).second) :
""};
2783 std::string defectStripsNew{moduleNewItr != moduleListNew.end() ? getStripList((*moduleNewItr).second) :
""};
2784 std::string defectStripsRef{moduleRefItr != moduleListRef.end() ? getStripList((*moduleRefItr).second) :
""};
2785 if (m_noisyUpdate) {
2786 if (defectStripsAll != defectStripsRef) {
2787 if (m_pCalibWriteTool->createCondObjects(moduleId, m_pSCTHelper, 10000,
"NOISY", noisyStripThr, defectStripsAll).isFailure()) {
2788 ATH_MSG_ERROR(
"Could not create defect strip entry in the CalibWriteTool.");
2793 if (m_noisyStripAll) {
2794 if (!defectStripsAll.empty() || m_noisyWriteAllModules) {
2795 if (m_pCalibWriteTool->createCondObjects(moduleId, m_pSCTHelper, 10000,
"NOISY", noisyStripThr, defectStripsAll).isFailure()) {
2796 ATH_MSG_ERROR(
"Could not create defect strip entry in the CalibWriteTool.");
2800 if (!defectStripsNew.empty()) {
2801 if (m_pCalibWriteTool->createCondObjects(moduleId, m_pSCTHelper, 10000,
"NOISY", noisyStripThr, defectStripsNew).isFailure()) {
2802 ATH_MSG_ERROR(
"Could not create defect strip entry in the CalibWriteTool.");
2809 ATH_MSG_DEBUG(
"Number of modules for which conditions were created: " << nDefects <<
" !!!!");
2810 if (moduleListAll.empty() or ( nDefects==0 && m_noisyUpdate )) {
2811 ATH_MSG_INFO(
"Number of noisy strips was zero or the same list of noisy strips. No local DB was created.");
2813 ATH_MSG_DEBUG(
"directly before call of wrapUpNoisyChannel");
2814 if (m_pCalibWriteTool->wrapUpNoisyChannel().isFailure()) {
2816 return StatusCode::FAILURE;
2820 return StatusCode::SUCCESS;
2824 std::set<Identifier>
2826 std::set<Identifier> stripList;
2827 std::set<Identifier>::const_iterator stripAllItrLast = stripAllIdList.end();
2828 std::set<Identifier>::const_iterator stripRefItrLast = stripRefIdList.end();
2830 std::set<Identifier>::const_iterator stripAllItr = stripAllIdList.begin();
2831 for ( ; stripAllItr != stripAllItrLast; ++stripAllItr ) {
2832 std::set<Identifier>::const_iterator stripRefItr = stripRefIdList.begin();
2834 for ( ; stripRefItr != stripRefItrLast; ++stripRefItr ) {
2835 if (*stripAllItr == *stripRefItr)
old =
true;
2838 stripList.insert(*stripAllItr);
2847 std::string strList;
2848 if (!stripIdList.empty()) {
2852 std::set<Identifier>::const_iterator stripItrFirst{stripIdList.begin()};
2853 std::set<Identifier>::const_iterator stripItrLast{--stripIdList.end()};
2855 std::set<Identifier>::const_iterator stripItr{stripIdList.begin()};
2856 std::set<Identifier>::const_iterator stripItrE{stripIdList.end()};
2857 for (; stripItr != stripItrE; ++stripItr) {
2860 if (stripItr == stripItrFirst) {
2874 if (stripItr == stripItrLast) {
2876 int stripEnd{stripNum};
2892 return(StatusCode::FAILURE);
2896 std::ostringstream osModuleList;
2900 for (; waferItr != waferItrE; ++waferItr) {
2904 std::map< Identifier, std::set<Identifier> >::const_iterator moduleItr{
moduleList.find(moduleId)};
2906 std::string defectStrips{
getStripList((*moduleItr).second)};
2908 <<
"since=\"" <<
m_iovStart.re_time() <<
"\" "
2909 <<
"until=\"" <<
m_iovStop.re_time() <<
"\">" << linefeed
2910 <<
" <value name=\"SampleSize\">" <<
"10000" <<
"</value>" << linefeed
2915 <<
" <value name=\"DefectType\">" <<
"NOISY" <<
"</value>" << linefeed
2916 <<
" <value name=\"Threshold\">" << noisyStripThr <<
"</value>" << linefeed
2917 <<
" <value name=\"DefectList\">" <<
normalizeList(defectStrips) <<
"</value>" << linefeed
2918 <<
" </channel>" << std::endl;
2922 outFile <<
"<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"CONDBR2\" folder=\"SCT/Derived/Monitoring\" "
2923 <<
"since=\"" <<
m_iovStart.re_time() <<
"\" "
2924 <<
"until=\"" <<
m_iovStop.re_time() <<
"\" "
2926 <<
"version=\"" <<
"multi\">" << std::endl
2927 << osModuleList.str()
2928 <<
"</channels>" << std::endl;
2930 return StatusCode::SUCCESS;
2935 const std::map<
Identifier, std::set<Identifier>>& moduleListRef,
2936 const std::string& badStripsFile)
const {
2945 return(StatusCode::FAILURE);
2949 int numLinksAll{0}, numChipsAll{0};
2950 int numModulesAll{0}, numModulesRef{0};
2951 int numStripsAll{0}, numStripsNew{0}, numStripsRef{0};
2952 int numModulesDiff{0};
2954 std::string defectLinks, defectChips;
2955 std::string defectStripsAll, defectStripsNew, defectStripsRef;
2956 std::ostringstream osModuleList, osChipList;
2961 ATH_MSG_DEBUG(
"noisyStripsToSummaryXml: before wafer loop");
2962 for (; waferItr != waferItrE; ++waferItr) {
2971 defectLinks.erase();
2972 defectChips.erase();
2973 defectStripsAll.erase();
2974 defectStripsNew.erase();
2975 defectStripsRef.erase();
2990 std::map< Identifier, std::set<Identifier> >::const_iterator moduleAllItr{moduleListAll.find(moduleId)};
2991 if (moduleAllItr != moduleListAll.end()) {
2992 defectStripsAll =
getStripList((*moduleAllItr).second);
2994 numStripsAll += (*moduleAllItr).second.size();
2999 std::map< Identifier, std::set<Identifier> >::const_iterator moduleRefItr{moduleListRef.find(moduleId)};
3000 if (moduleRefItr != moduleListRef.end()) {
3003 numStripsRef += moduleRefItr->second.size();
3008 if ( moduleAllItr != moduleListAll.end() ) {
3009 if ( moduleRefItr != moduleListRef.end() ) {
3010 std::set<Identifier> listNEW =
getOverlapStripList( (*moduleAllItr).second, (*moduleRefItr).second );
3012 numStripsNew += listNEW.size();
3015 defectStripsNew =
getStripList( (*moduleAllItr).second );
3019 ATH_MSG_DEBUG(
"noisyStripsToSummaryXml: stripIdList -> chipIdList");
3021 if (moduleAllItr != moduleListAll.end()) {
3022 std::set<int> chipIdList{
getNoisyChips(moduleAllItr->second)};
3023 if (!chipIdList.empty()) {
3027 for (; chipItr != chipItrE; ++chipItr) {
3028 int chipId{*chipItr};
3032 std::pair< std::string, float > defectLB{
getNoisyLB(moduleId, chipId)};
3034 osChipList <<
" <chip>" << linefeed
3035 <<
" <value name=\"SN\">" << sn.str() <<
"</value>" << linefeed
3040 <<
" <value name=\"ChipID\">" << chipId <<
"</value>" << linefeed
3041 <<
" <value name=\"LB\">" <<
normalizeList(defectLB.first) <<
"</value>" << linefeed
3042 <<
" <value name=\"LBFraction\">" << defectLB.second <<
"</value>" << linefeed
3043 <<
" </chip>" << std::endl;
3047 ATH_MSG_DEBUG(
"noisyStripsToSummaryXml: Difference between All & Ref");
3049 if (defectStripsAll != defectStripsRef) ++numModulesDiff;
3051 if (!defectStripsAll.empty() or (
m_noisyUpdate and defectStripsAll != defectStripsRef)) {
3052 osModuleList <<
" <module>" << linefeed
3053 <<
" <value name=\"SN\">" << sn.str() <<
"</value>" << linefeed
3058 <<
" <value name=\"LinkID\">" <<
normalizeList(defectLinks) <<
"</value>" << linefeed
3059 <<
" <value name=\"ChipID\">" <<
normalizeList(defectChips) <<
"</value>" << linefeed
3060 <<
" <value name=\"StripOfflineAll\">" <<
normalizeList(defectStripsAll) <<
"</value>" << linefeed
3061 <<
" <value name=\"StripOfflineNew\">" <<
normalizeList(defectStripsNew) <<
"</value>" << linefeed
3062 <<
" <value name=\"StripOfflineRef\">" <<
normalizeList(defectStripsRef) <<
"</value>" << linefeed
3063 <<
" </module>" << std::endl;
3065 ATH_MSG_DEBUG(
"noisyStripsToSummaryXml: After Difference between All & Ref");
3072 std::string strUploadFlag{
"U"};
3074 bool isRunsInCool{
false};
3075 bool isNoisyMinStat{
false}, isNoisyModuleList{
false}, isNoisyModuleDiff{
false}, isNoisyStripDiff{
false};
3083 if (!isNoisyMinStat or !isNoisyModuleList) {
3084 strUploadFlag =
"R";
3086 if (!isNoisyModuleDiff or !isNoisyStripDiff) {
3087 strUploadFlag =
"Y";
3089 strUploadFlag =
"G";
3095 ATH_MSG_DEBUG(
"noisyStripsToSummaryXml: after FlagChecking");
3098 std::ostringstream osNoisyMinStat, osNoisyModuleList, osNoisyModuleDiff, osNoisyStripDiff;
3099 osNoisyMinStat <<
"#events more than " <<
m_noisyMinStat.value();
3100 osNoisyModuleList <<
"#(modules w/ at least 1 noisy strip) less than " <<
m_noisyModuleList.value();
3101 osNoisyModuleDiff <<
"Increase of #(modules w/ at least 1 noisy strip) from average of recent runs less than " <<
m_noisyModuleDiff*100 <<
"%";
3102 osNoisyStripDiff <<
"Increase of #(noisy strips) from average of recent runs less than " <<
m_noisyStripDiff*100 <<
"%";
3104 std::ostringstream osFlagReason;
3105 if (!isNoisyMinStat) osFlagReason <<
"FAILED in " << osNoisyMinStat.str() <<
"; ";
3106 if (!isNoisyModuleList) osFlagReason <<
"FAILED in " << osNoisyModuleList.str() <<
"; ";
3107 if (!isNoisyModuleDiff) osFlagReason <<
"FAILED in " << osNoisyModuleDiff.str() <<
"; ";
3108 if (!isNoisyStripDiff) osFlagReason <<
"FAILED in " << osNoisyStripDiff.str();
3111 std::string strRunsInCool = isRunsInCool ?
"AVAILABLE" :
"UNAVAILABLE";
3113 std::ostringstream osCheckList;
3114 osCheckList << osNoisyMinStat.str() <<
"; "
3115 << osNoisyModuleList.str() <<
"; "
3116 << osNoisyModuleDiff.str() <<
"; "
3117 << osNoisyStripDiff.str();
3121 << associateStylesheet(
"BadStrips.xsl") << linefeed
3122 <<
"<run>" << linefeed
3123 <<
" <value name=\"RunNumber\">" <<
m_runNumber.value() <<
"</value>" << linefeed
3124 <<
" <value name=\"StartTime\">" <<
m_utcBegin <<
"</value>" << linefeed
3125 <<
" <value name=\"EndTime\">" <<
m_utcEnd <<
"</value>" << linefeed
3126 <<
" <value name=\"Duration\">" <<
m_calibEvtInfoTool->duration() <<
"</value>" << linefeed
3128 <<
" <value name=\"Events\">" <<
m_numberOfEvents <<
"</value>" << linefeed
3129 <<
" <value name=\"Modules\">" << numModulesAll <<
"</value>" << linefeed
3130 <<
" <value name=\"Links\">" << numLinksAll <<
"</value>" << linefeed
3131 <<
" <value name=\"Chips\">" << numChipsAll <<
"</value>" << linefeed
3132 <<
" <value name=\"StripsOfflineAll\">" << numStripsAll <<
"</value>" << linefeed
3133 <<
" <value name=\"StripsOfflineNew\">" << numStripsNew <<
"</value>" << linefeed
3134 <<
" <value name=\"ModulesRef\">" << numModulesRef <<
"</value>" << linefeed
3135 <<
" <value name=\"StripsOfflineRef\">" << numStripsRef <<
"</value>" << linefeed
3136 <<
" <value name=\"ModulesDiff\">" << numModulesDiff <<
"</value>" << linefeed
3137 <<
" <value name=\"Flag\">" << strUploadFlag <<
"</value>" << linefeed
3138 <<
" <value name=\"FlagReason\">" << osFlagReason.str() <<
"</value>" << linefeed
3139 <<
" <value name=\"FlagEnable\">" << strFlagEnable <<
"</value>" << linefeed
3140 <<
" <value name=\"ReadCool\">" << strRunsInCool <<
"</value>" << linefeed
3141 <<
" <value name=\"CheckList\">" << osCheckList.str() <<
"</value>" << linefeed
3142 <<
" <chips>" << linefeed
3144 <<
" </chips>" << linefeed
3145 <<
" <modules>" << linefeed
3146 << osModuleList.str()
3147 <<
" </modules>" << linefeed
3148 <<
"</run>" << std::endl;
3152 return StatusCode::SUCCESS;
3158 std::set<int> chipIdList;
3164 if (elements==
nullptr) {
3171 if (stripIdList.size() > noisyChipThr) {
3174 std::set<Identifier>::const_iterator stripItr{stripIdList.begin()};
3175 std::set<Identifier>::const_iterator stripItrE{stripIdList.end()};
3176 for (; stripItr != stripItrE; ++stripItr) {
3186 int stripOnline{(pElement->swapPhiReadoutDirection()) ?
lastStrip - stripOffline : stripOffline};
3189 ++numStripsPerChip[chipId];
3194 if (numStripsPerChip[iChip] > noisyChipThr) chipIdList.insert(iChip);
3201 std::pair< std::string, float >
3203 std::string defectLB{
""};
3204 float defectLBFrac{0.0};
3216 int histIndex{
static_cast<int>((waferHash.value())*
n_chipPerSide + chipPositionInSide)};
3220 std::set<int> LBList;
3224 return std::make_pair(defectLB, defectLBFrac);
3227 for (
int iLB{0}; iLB !=
m_LBRange; ++iLB) {
3228 double numEventsInLB{
static_cast<double>(
m_calibLbTool->getNumberOfEventsInBin(iLB + 1))};
3229 if (numEventsInLB == 0)
continue;
3230 double chipOccupancy{(
float)
m_calibLbTool->getBinForHistogramIndex(iLB + 1, histIndex) / numEventsInLB};
3231 if (chipOccupancy > chipOccupancyThr) LBList.insert(iLB);
3234 if (LBList.size() != 0) {
3239 return std::make_pair(defectLB, defectLBFrac);
3244 std::string strList;
3246 if (!LBList.empty()) {
3250 std::set<int>::const_iterator LBItrFirst{LBList.begin()};
3251 std::set<int>::const_iterator LBItrLast{--LBList.end()};
3253 std::set<int>::const_iterator LBItr{LBList.begin()};
3254 std::set<int>::const_iterator LBItrE{LBList.end()};
3255 for (; LBItr != LBItrE; ++LBItr) {
3257 if (LBItr == LBItrFirst) {
3261 if (iLB == firstLB + LBSize) {
3264 int LBBegin{firstLB};
3265 int LBEnd{firstLB + LBSize -1};
3271 if (LBItr == LBItrLast) {
3272 int LBBegin{firstLB};