Public Member Functions
def	__init__ (self, inputDQMName, outputFileName, noiseOutputFileName, dirs)

def	ReadHistograms (self)

Public Attributes
	barrelInefficientDColTh

	barrelNoisyColumnTh

	barrelNoisyColumnTh2

	detDict
	More...

	dicOfModuleHistograms

	dirs

	endcapInefficientDColTh

	endcapNoisyColumnTh

	inputFile

	inputFileName

	lookForStr

	noiseOutputFileName

	outputFileName

	pixelNoisynessTh
	THRESHOLDS SECTION. More...

	rocMaxCol

	rocMaxRow

	rocOccupancyTh

	rocsInCol

	rocsInRow

Private Member Functions
def	__convertCoordinatesFromHistToROCSpace (self, histName, histXpos, histRow)

def	__customMedianFilter (self, array, radius=2)

def	__determineBarrelDColInefficiencyAndNoise (self, medFiltRes, histName, pixelArr, pixelArrWithoutDrops, startPixel, rocCol, rocRow, outputFile, columnsWithSuspiciouslyNoisyPixels, noiseFile)

def	__determineBarrelNoise (self, noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, maxMed, val, pos, rocCol, rocRow)

def	__determineBarrelNoise2 (self, noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, normMeanOfPixels, normVal, pos, rocCol, rocRow)

def	__determineEndcapDColInefficiencyAndNoise (self, medFiltRes, histName, pixelArr, startPixel, rocCol, rocRow, outputFile, columnsWithSuspiciouslyNoisyPixels, noiseFile)

def	__determineEndcapNoise (self, noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, linVal, val, pos, rocCol, rocRow)

def	__getPixelArrWithRemovedDrops (self, pixelArr, medFiltRes)

def	__getROCData (self, hist, startPixel, endPixel, row, repeatFilter=3, filterKernelSize=5)

def	__lmsExp (self, data, xMin, xMax)

def	__lmsLin (self, data, xMin, xMax)

def	__normalizeArray (self, pixelArr)

def	__setNormalizedArrayZeroInThePoint (self, pixelArr, pt)

def	__TraverseDirTree (self, dir)

Detailed Description

Definition at line 12 of file InefficientDoubleROC.py.

Constructor & Destructor Documentation

def InefficientDoubleROC.InefficientDeadROCs.__init__	(	self,
		inputDQMName,
		outputFileName,
		noiseOutputFileName,
		dirs
	)

Definition at line 45 of file InefficientDoubleROC.py.

   def __init__(self, inputDQMName, outputFileName, noiseOutputFileName, dirs):
   
     self.inputFileName = inputDQMName
     self.outputFileName = outputFileName
     self.noiseOutputFileName = noiseOutputFileName
     self.dirs = dirs
     
     self.lookForStr = "digi_occupancy_per_col_per_row_"
     
     self.rocMaxCol = 52
     self.rocMaxRow = 80
     self.rocsInRow = 8
     self.rocsInCol = 2
     
     self.inputFile = TFile(self.inputFileName)
     self.dicOfModuleHistograms = {}
     
     ### THRESHOLDS SECTION
     self.pixelNoisynessTh = 6
     self.rocOccupancyTh = 200
     
     self.barrelNoisyColumnTh = 1.35
     self.barrelNoisyColumnTh2 = 4.5
     self.endcapNoisyColumnTh = 1.5
     
     self.barrelInefficientDColTh = 8#2.5
     self.endcapInefficientDColTh = 30#8
     
     ### ###################
     
     if self.inputFile.IsOpen():
       print("%s opened successfully!" % (self.inputFileName))
       #Get all neeeded histograms
       for dir in self.dirs:
         self.__TraverseDirTree(self.inputFile.Get(dir))
       print("Histograms to read: %d" % (len(self.dicOfModuleHistograms)))
       
       self.detDict = {}
       
     else:
       print("Unable to open file %s" % (self.inputFileName))
       

Member Function Documentation

def InefficientDoubleROC.InefficientDeadROCs.__convertCoordinatesFromHistToROCSpace	(	self,
		histName,
		histXpos,
		histRow
	)

private

Definition at line 238 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.rocMaxCol.

Referenced by InefficientDoubleROC.InefficientDeadROCs.__determineBarrelDColInefficiencyAndNoise(), InefficientDoubleROC.InefficientDeadROCs.__determineBarrelNoise(), InefficientDoubleROC.InefficientDeadROCs.__determineBarrelNoise2(), InefficientDoubleROC.InefficientDeadROCs.__determineEndcapDColInefficiencyAndNoise(), and InefficientDoubleROC.InefficientDeadROCs.__determineEndcapNoise().

   def __convertCoordinatesFromHistToROCSpace(self, histName, histXpos, histRow):
     tempXROC = (histXpos / self.rocMaxCol) # 0,...,7
     tempYROC = histRow
     
     tempXCoordInROC = histXpos % self.rocMaxCol
     
     realXROC, realYROC = tempXROC, tempYROC
     xCoordInROC = tempXCoordInROC
     
     rocNum = 0
     
     if histName.find("BPix_Bp") != -1: #zero ROC is in top left corner
       realYROC = 1 - tempYROC
       if realYROC == 1:
         rocNum = 15 - realXROC
         xCoordInROC = self.rocMaxCol - 1 - xCoordInROC
       else:
         rocNum = realXROC
     else: # zero ROC is in bottom right corner
       realXROC = 7 - tempXROC
       if realYROC == 1:
         rocNum = 15 - realXROC
       else:
         rocNum = realXROC
         xCoordInROC = self.rocMaxCol - 1 - xCoordInROC
         
     return rocNum, xCoordInROC
     
     

def InefficientDoubleROC.InefficientDeadROCs.__customMedianFilter	(	self,
		array,
		radius = `2`
	)

private

Definition at line 122 of file InefficientDoubleROC.py.

Referenced by InefficientDoubleROC.InefficientDeadROCs.__getROCData().

   def __customMedianFilter(self, array, radius = 2):
     # contrary to scipy implementation it provides adaptive kernel size instead of copying data on boundaries
     filtered = [0 for i in range(len(array))]
     currArray = []
     for i in range(len(array)):
       if i - radius < 0:
         currArray = array[0 : i + radius + 1]
       elif i + radius + 1 >= len(array):
         currArray = array[i - radius : ]
       
       currArray.sort()
       filtered[i] = currArray[len(currArray) // 2]
       
     return filtered
     

def InefficientDoubleROC.InefficientDeadROCs.__determineBarrelDColInefficiencyAndNoise	(	self,
		medFiltRes,
		histName,
		pixelArr,
		pixelArrWithoutDrops,
		startPixel,
		rocCol,
		rocRow,
		outputFile,
		columnsWithSuspiciouslyNoisyPixels,
		noiseFile
	)

private

Definition at line 267 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.__convertCoordinatesFromHistToROCSpace(), InefficientDoubleROC.InefficientDeadROCs.__determineBarrelNoise2(), InefficientDoubleROC.InefficientDeadROCs.barrelInefficientDColTh, SiStripPI.max, min(), and InefficientDoubleROC.InefficientDeadROCs.rocMaxCol.

Referenced by InefficientDoubleROC.InefficientDeadROCs.ReadHistograms().

   def __determineBarrelDColInefficiencyAndNoise(self, medFiltRes, histName, pixelArr, pixelArrWithoutDrops, startPixel, rocCol, rocRow, outputFile, columnsWithSuspiciouslyNoisyPixels, noiseFile):
     meanOfPixels = sum(medFiltRes) / len(medFiltRes)
     maxMed = max(medFiltRes)
     minMed = min(medFiltRes) 
 
     normMeanOfPixels = sum(pixelArrWithoutDrops) / len(pixelArrWithoutDrops)
     # print( meanOfPixels, maxMed, minMed )
     
     doubleDeadCols = 0
     noisyColsNum = 0
     noisyROC = 0
     
     # for x in range(startPixel, endPixel, 1):
     for i in range(1, len(pixelArr) - 2):
       # print(i , i + 1)
       bin1valDiff = minMed - pixelArr[i + 0]#hist.GetBinContent(x+0)
       bin2valDiff = minMed - pixelArr[i + 1]
       # WE ONLY WANT A SET OF TWO COLUMNS SO ADJACENT COLUMNS HAVE TO BE NORMAL
       bin0valDiff = minMed - pixelArr[i - 1]
       bin3valDiff = minMed - pixelArr[i + 2]
       
       # currentDoubleBinThreshold = minMed / math.sqrt(meanOfPixels) * self.barrelInefficientDColTh # error in bin entry grows as sqrt(N)
       currentDoubleBinThreshold = math.sqrt(meanOfPixels) * self.barrelInefficientDColTh # error in bin entry grows as sqrt(N)
                         
       if bin1valDiff > currentDoubleBinThreshold and bin2valDiff > currentDoubleBinThreshold and not bin3valDiff > currentDoubleBinThreshold and not bin0valDiff > currentDoubleBinThreshold:
 
         doubleColInRoc = ((i + startPixel) % (self.rocMaxCol)) // 2 + 1
         doubleDeadCols = doubleDeadCols + 1
         
         # outputFile.write("%s,\tX: %d-%d\tROC COLUMN: %d\tROC ROW: %d\tDOUBLE COL IN ROC: %d\tTH: %f\tMIN IN ROC: %f\tBINVAL: %f\n" % (histName, startPixel + (i + 0), startPixel + (i + 1), rocCol, rocRow, doubleColInRoc, currentDoubleBinThreshold, minMed, pixelArr[i]))
         rocNum, xCoordInROC = self.__convertCoordinatesFromHistToROCSpace(histName, startPixel + i, rocRow)
         outputFile.write("%s\t(x, row)->[rocNum, doubleXPixelColInROC]\t(%d, %d)->[%d, %d];\t{MIN - VAL, TH}\t{%f, %f}\n" % (histName, startPixel + i, rocRow + 1, rocNum, xCoordInROC / 2, bin1valDiff, currentDoubleBinThreshold))
 
       # HANDLE NOISY PIXELS
       if noisyROC == True:  #don't go inside if noisyness was determined already
         continue
       
       # res = self.__determineBarrelNoise(noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, maxMed, pixelArr[i], startPixel + i, rocCol, rocRow)
       # noisyColsNum, noisyROC = noisyColsNum + res[0], res[1]
       # if i == len(pixelArr) - 3: #  CHECK NOISYNESS IN THE RIGHTMOST INNER COL
         # res = self.__determineBarrelNoise(noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, maxMed, pixelArr[i + 1], startPixel + i + 1, rocCol, rocRow)
         # noisyColsNum, noisyROC = noisyColsNum + res[0], res[1]      
       
       # NORMALIZED MEAN NOISE DETERMINATION METHOD
       res = self.__determineBarrelNoise2(noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, normMeanOfPixels, pixelArrWithoutDrops[i], startPixel + i, rocCol, rocRow)
       noisyColsNum, noisyROC = noisyColsNum + res[0], res[1]
       if i == len(pixelArr) - 3: #  CHECK NOISYNESS IN THE RIGHTMOST INNER COL
         res = self.__determineBarrelNoise2(noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, normMeanOfPixels, pixelArrWithoutDrops[i + 1], startPixel + i + 1, rocCol, rocRow)
         noisyColsNum, noisyROC = noisyColsNum + res[0], res[1]
         
         
         
     return doubleDeadCols, noisyColsNum
   

def InefficientDoubleROC.InefficientDeadROCs.__determineBarrelNoise	(	self,
		noiseFile,
		columnsWithSuspiciouslyNoisyPixels,
		histName,
		meanOfPixels,
		maxMed,
		val,
		pos,
		rocCol,
		rocRow
	)

private

Definition at line 183 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.__convertCoordinatesFromHistToROCSpace(), InefficientDoubleROC.InefficientDeadROCs.barrelNoisyColumnTh, and InefficientDoubleROC.InefficientDeadROCs.rocOccupancyTh.

   def __determineBarrelNoise(self, noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, maxMed, val, pos, rocCol, rocRow):
     noisyROC = False;
     if meanOfPixels < self.rocOccupancyTh:
       #print("Very low mean occupancy: %f in %s in (col, row) (%d, %d)...\tSkipping noisy ROC calculation" % (meanOfPixels, histName, rocCol, rocRow) )
       noisyROC = True
     else:
       th = self.barrelNoisyColumnTh * maxMed
       if val > th:
         if pos not in columnsWithSuspiciouslyNoisyPixels:
           rocNum, xCoordInROC = self.__convertCoordinatesFromHistToROCSpace(histName, pos, rocRow)
           noiseFile.write("%s\t(x, row)->[rocNum, xRoc]\t(%d, %d)->[%d, %d];\t{VAL, TH}\t{%f, %f}\n" % (histName, pos, rocRow+1, rocNum, xCoordInROC, val, th))
           
           return 1, noisyROC
         # else:
           # print("WARNING: rejecting %s (x, row) (%d, %d) as being affected by a few noisy pixel(s)" % (histName, pos, rocRow+1))
           
     return 0, noisyROC
     

def InefficientDoubleROC.InefficientDeadROCs.__determineBarrelNoise2	(	self,
		noiseFile,
		columnsWithSuspiciouslyNoisyPixels,
		histName,
		meanOfPixels,
		normMeanOfPixels,
		normVal,
		pos,
		rocCol,
		rocRow
	)

private

Definition at line 201 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.__convertCoordinatesFromHistToROCSpace(), InefficientDoubleROC.InefficientDeadROCs.barrelNoisyColumnTh2, and InefficientDoubleROC.InefficientDeadROCs.rocOccupancyTh.

Referenced by InefficientDoubleROC.InefficientDeadROCs.__determineBarrelDColInefficiencyAndNoise().

   def __determineBarrelNoise2(self, noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, normMeanOfPixels, normVal, pos, rocCol, rocRow):
     noisyROC = False;
     if meanOfPixels < self.rocOccupancyTh:
       #print("Very low mean occupancy: %f in %s in (col, row) (%d, %d)...\tSkipping noisy ROC calculation" % (meanOfPixels, histName, rocCol, rocRow) )
       noisyROC = True
     else:
       th = self.barrelNoisyColumnTh2 * normMeanOfPixels
       if normVal > th:
         if pos not in columnsWithSuspiciouslyNoisyPixels:
           rocNum, xCoordInROC = self.__convertCoordinatesFromHistToROCSpace(histName, pos, rocRow)
           noiseFile.write("%s\t(x, row)->[rocNum, xRoc]\t(%d, %d)->[%d, %d];\t{NORMVAL, TH}\t{%f, %f}\n" % (histName, pos, rocRow+1, rocNum, xCoordInROC, normVal, th))
           
           return 1, noisyROC
         # else:
           # print("WARNING: rejecting %s (x, row) (%d, %d) as being affected by a few noisy pixel(s)" % (histName, pos, rocRow+1))
           
     return 0, noisyROC
         

def InefficientDoubleROC.InefficientDeadROCs.__determineEndcapDColInefficiencyAndNoise	(	self,
		medFiltRes,
		histName,
		pixelArr,
		startPixel,
		rocCol,
		rocRow,
		outputFile,
		columnsWithSuspiciouslyNoisyPixels,
		noiseFile
	)

private

Definition at line 321 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.__convertCoordinatesFromHistToROCSpace(), InefficientDoubleROC.InefficientDeadROCs.__determineEndcapNoise(), InefficientDoubleROC.InefficientDeadROCs.__lmsLin(), InefficientDoubleROC.InefficientDeadROCs.endcapInefficientDColTh, and InefficientDoubleROC.InefficientDeadROCs.rocMaxCol.

Referenced by InefficientDoubleROC.InefficientDeadROCs.ReadHistograms().

   def __determineEndcapDColInefficiencyAndNoise(self, medFiltRes, histName, pixelArr, startPixel, rocCol, rocRow, outputFile, columnsWithSuspiciouslyNoisyPixels, noiseFile):
     doubleDeadCols = 0
     noisyColsNum = 0
     noisyROC = 0
     
     useLin = True
     # <D> might be used for high noise ROC recognition
     a, b, D = self.__lmsLin(medFiltRes, startPixel, len(medFiltRes) + startPixel)
                   
     meanOfPixels = sum(medFiltRes) / len(medFiltRes)
     
     # for x in range(startPixel, endPixel, 1):
     for i in range(1, len(pixelArr) - 2):
       
       if useLin == True:
         linVal1 = a * (i + startPixel + 0) + b
         linVal2 = a * (i + startPixel + 1) + b
         
         linVal0 = a * (i + startPixel - 1) + b
         linVal3 = a * (i + startPixel + 2) + b
       else:
         linVal1 = b * math.exp(a * (i + startPixel + 0))
         linVal2 = b * math.exp(a * (i + startPixel + 1))
                                
         linVal0 = b * math.exp(a * (i + startPixel - 1))
         linVal3 = b * math.exp(a * (i + startPixel + 2))
       
       bin1valDiff = linVal1 - pixelArr[i + 0]
       bin2valDiff = linVal2 - pixelArr[i + 1]
       # WE ONLY WANT A SET OF TWO COLUMNS SO ADJACENT COLUMNS HAVE TO BE NORMAL
       bin0valDiff = linVal0 - pixelArr[i - 1]
       bin3valDiff = linVal3 - pixelArr[i + 2] 
          
       try:
         currentDoubleBinThreshold = math.sqrt((linVal1 + linVal2) * 0.5) * self.endcapInefficientDColTh
       except:
         # print(a, b, startPixel, i, linVal1, linVal2)
         continue
       
       if bin1valDiff > currentDoubleBinThreshold and bin2valDiff > currentDoubleBinThreshold and not bin3valDiff > currentDoubleBinThreshold and not bin0valDiff > currentDoubleBinThreshold:
 
         doubleColInRoc = ((i + startPixel) % (self.rocMaxCol)) // 2 + 1
         doubleDeadCols = doubleDeadCols + 1
         
         # outputFile.write("%s,\tX: %d-%d\tROC COLUMN: %d\tROC ROW: %d\tDOUBLE COL IN ROC: %d\tTH: %f\tLINVAL: %f\tBINVAL: %f\n" % (histName, startPixel + (i + 0), startPixel + (i + 1), rocCol, rocRow, doubleColInRoc, currentDoubleBinThreshold, linVal1, pixelArr[i]))
         rocNum, xCoordInROC = self.__convertCoordinatesFromHistToROCSpace(histName, startPixel + i, rocRow)
         outputFile.write("%s\t(x, row)->[rocNum, doubleXPixelColInROC]\t(%d, %d)->[%d, %d];\t{LIN(x) - VAL, TH}\t{%f, %f}\n" % (histName, startPixel + i, rocRow + 1, rocNum, xCoordInROC / 2, bin1valDiff, currentDoubleBinThreshold))
 
 
       # HANDLE NOISY PIXELS
       if noisyROC == True:  #don't go inside if noisyness was determined already
         continue
       
       res = self.__determineEndcapNoise(noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, linVal1, pixelArr[i], i + startPixel, rocCol, rocRow)
       noisyColsNum, noisyROC = noisyColsNum + res[0], res[1]
       if i == len(pixelArr) - 3: #  CHECK NOISYNESS IN THE RIGHTMOST INNER COL
         res = self.__determineEndcapNoise(noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, linVal2, pixelArr[i + 1], i + 1 + startPixel, rocCol, rocRow)
         noisyColsNum, noisyROC = noisyColsNum + res[0], res[1]
     
     return doubleDeadCols, noisyColsNum
       

def InefficientDoubleROC.InefficientDeadROCs.__determineEndcapNoise	(	self,
		noiseFile,
		columnsWithSuspiciouslyNoisyPixels,
		histName,
		meanOfPixels,
		linVal,
		val,
		pos,
		rocCol,
		rocRow
	)

private

Definition at line 219 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.__convertCoordinatesFromHistToROCSpace(), InefficientDoubleROC.InefficientDeadROCs.endcapNoisyColumnTh, and InefficientDoubleROC.InefficientDeadROCs.rocOccupancyTh.

Referenced by InefficientDoubleROC.InefficientDeadROCs.__determineEndcapDColInefficiencyAndNoise().

   def __determineEndcapNoise(self, noiseFile, columnsWithSuspiciouslyNoisyPixels, histName, meanOfPixels, linVal, val, pos, rocCol, rocRow):
     noisyROC = False;
     if meanOfPixels < self.rocOccupancyTh:
       # print("Very low mean occupancy: %f in %s in (col, row) (%d, %d)...\tSkipping noisy ROC calculation" % (meanOfPixels, histName, rocCol, rocRow) )
       noisyROC = True
     
     else:
       th = self.endcapNoisyColumnTh * linVal
       if val > th:
         if pos not in columnsWithSuspiciouslyNoisyPixels:
           rocNum, xCoordInROC = self.__convertCoordinatesFromHistToROCSpace(histName, pos, rocRow)
           noiseFile.write("%s\t(x, row)->[rocNum, xRoc]\t(%d, %d)->[%d, %d];\t{VAL, TH}\t{%f, %f}\n" % (histName, pos, rocRow+1, rocNum, xCoordInROC, val, th))
           
           return 1, noisyROC
         # else:
           # print("WARNING: rejecting %s (x, row) (%d, %d) as being affected by a few noisy pixel(s)" % (histName, pos, rocRow+1))
           
     return 0, noisyROC
     

def InefficientDoubleROC.InefficientDeadROCs.__getPixelArrWithRemovedDrops	(	self,
		pixelArr,
		medFiltRes
	)

private

Definition at line 168 of file InefficientDoubleROC.py.

References min().

Referenced by InefficientDoubleROC.InefficientDeadROCs.ReadHistograms().

   def __getPixelArrWithRemovedDrops(self, pixelArr, medFiltRes):
     return [ (pixelArr[i] if pixelArr[i] > medFiltRes[i] else medFiltRes[i]) if 0 < i < len(pixelArr) - 1 else min(medFiltRes) for i in range(len(pixelArr))]
     

def InefficientDoubleROC.InefficientDeadROCs.__getROCData	(	self,
		hist,
		startPixel,
		endPixel,
		row,
		repeatFilter = `3`,
		filterKernelSize = `5`
	)

private

Definition at line 137 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.__customMedianFilter(), InefficientDoubleROC.InefficientDeadROCs.pixelNoisynessTh, and InefficientDoubleROC.InefficientDeadROCs.rocMaxRow.

Referenced by InefficientDoubleROC.InefficientDeadROCs.ReadHistograms().

   def __getROCData(self, hist, startPixel, endPixel, row, repeatFilter = 3, filterKernelSize = 5):
     pixelArr = []
     columnsWithSuspiciouslyNoisyPixels = []
     
     for x in range(startPixel, endPixel):
       
       columnPixels = [hist.GetBinContent(x, y + 1) for y in range(row * self.rocMaxRow, (row + 1) * self.rocMaxRow)]
       columnSum = sum(columnPixels)
       
       columnMean = columnSum / len(columnPixels)
       for i in range(len(columnPixels)):
         if columnPixels[i] > self.pixelNoisynessTh * columnMean:
           # col = (startPixel % self.rocMaxCol) + 1
           
           columnsWithSuspiciouslyNoisyPixels.append(x)
           
           # print("WARNING:\t %s : %dx%d:%d may contain NOISY PIXELS instead of NOISY COLUMNS" % (hist.GetName(), col, row + 1, startPixel + i))
           break
       
       pixelArr.append(columnSum)  
       
     if len(pixelArr) == 0:
       return None, None, None                                             # ROC down
     
     medFiltRes, sciPyMedFiltRes = deepcopy(pixelArr), deepcopy(pixelArr)
     for i in range(repeatFilter):
       sciPyMedFiltRes = signal.medfilt(sciPyMedFiltRes, filterKernelSize) # 5 is obligatory to filter doublets!!!
       medFiltRes = self.__customMedianFilter(medFiltRes, filterKernelSize // 2)
       
     return pixelArr, medFiltRes, columnsWithSuspiciouslyNoisyPixels, sciPyMedFiltRes
     

def InefficientDoubleROC.InefficientDeadROCs.__lmsExp	(	self,
		data,
		xMin,
		xMax
	)

private

Definition at line 87 of file InefficientDoubleROC.py.

   def __lmsExp(self, data, xMin, xMax):
     meanOfX = (xMax + xMin) * 0.5
     meanOfY = sum( [math.log(data[i]) for i in range(len(data))] ) / len(data)
     
     D = 0
     for i in range(xMin, xMax + 1):
       D = D + (i - meanOfX)**2
       # print(D)
 
     a = 0
     for i in range(len(data)):
       a = a + math.log(data[i]) * (xMin + i - meanOfX)
     a = a/D
     
     lnb = meanOfY - a * meanOfX
     
     return a, math.exp(lnb)
     

def InefficientDoubleROC.InefficientDeadROCs.__lmsLin	(	self,
		data,
		xMin,
		xMax
	)

private

Definition at line 105 of file InefficientDoubleROC.py.

Referenced by InefficientDoubleROC.InefficientDeadROCs.__determineEndcapDColInefficiencyAndNoise().

   def __lmsLin(self, data, xMin, xMax):
     meanOfX = (xMax + xMin) * 0.5
     meanOfY = sum(data) / len(data)
     
     D = 0
     for i in range(xMin, xMax + 1):
       D = D + (i - meanOfX)**2
 
     a = 0
     for i in range(len(data)):
       a = a + data[i] * (xMin + i - meanOfX)
     a = a/D
     
     b = meanOfY - a * meanOfX
     
     return a, b, D
     

def InefficientDoubleROC.InefficientDeadROCs.__normalizeArray	(	self,
		pixelArr
	)

private

Definition at line 171 of file InefficientDoubleROC.py.

References SiStripPI.max, and min().

Referenced by InefficientDoubleROC.InefficientDeadROCs.ReadHistograms().

   def __normalizeArray(self, pixelArr):
     c_min, c_max = min(pixelArr), max(pixelArr)
     if c_min != c_max:
       c_diff_inv = 1.0 / (c_max - c_min)
       return [ (pixelArr[i] - c_min) * c_diff_inv for i in range(len(pixelArr))]
     return [0 for i in range(len(pixelArr))]
     

def InefficientDoubleROC.InefficientDeadROCs.__setNormalizedArrayZeroInThePoint	(	self,
		pixelArr,
		pt
	)

private

Definition at line 178 of file InefficientDoubleROC.py.

   def __setNormalizedArrayZeroInThePoint(self, pixelArr, pt):
     c_diff_inv = 1.0 / (1.0 - pt)
     
     return [ (pixelArr[i] - pt) * c_diff_inv for i in range(len(pixelArr))]
     

def InefficientDoubleROC.InefficientDeadROCs.__TraverseDirTree	(	self,
		dir
	)

private

Definition at line 15 of file InefficientDoubleROC.py.

References InefficientDoubleROC.InefficientDeadROCs.__TraverseDirTree(), mps_setup.append, InefficientDoubleROC.InefficientDeadROCs.dicOfModuleHistograms, and InefficientDoubleROC.InefficientDeadROCs.lookForStr.

Referenced by InefficientDoubleROC.InefficientDeadROCs.__TraverseDirTree(), PhaseITreeProducer.ModuleLvlValuesReader.__TraverseDirTree(), and TH2PolyOfflineMaps.TH2PolyOfflineMaps.__TraverseDirTree().

   def __TraverseDirTree(self, dir):
   
     for obj in dir.GetListOfKeys():
       if not obj.IsFolder():
         if obj.ReadObjectAny(TClass.GetClass("TH2")):
           th1 = deepcopy(obj.ReadObj())
           name = th1.GetName()
           if name.startswith(self.lookForStr): #take only module lvl plots
             # print(''.join([dir.GetPath(), '/', name]))
             newName = name.split(self.lookForStr)[1]
             th1.SetName(newName)
             
             # used to sort outputs by disk/layer
             layer = 0
             # print(newName)
             if newName.startswith("B"):
               layer = "B" + ((newName.split("_LYR"))[1])[0]
             else:
               layer = ((newName.split("_D"))[1])[0]
               if newName.startswith("FPix_Bm"):
                 layer = "-" + layer
               layer = "F" + layer
             
             if layer in self.dicOfModuleHistograms:
               self.dicOfModuleHistograms[layer].append(th1)
             else:
               self.dicOfModuleHistograms.update({layer : [th1]})        
       else:
         self.__TraverseDirTree(obj.ReadObj())
         

def InefficientDoubleROC.InefficientDeadROCs.ReadHistograms ( self )

Definition at line 382 of file InefficientDoubleROC.py.

   def ReadHistograms(self):      
     doubleDeadCols, noisyColsNum = 0, 0
     
     with open(self.noiseOutputFileName, "w") as noiseFile:   
       with open(self.outputFileName, "w") as outputFile: 
         for layer in self.dicOfModuleHistograms:
           
           doubleDeadColsInLayer, noisyColsNumInLayer = 0, 0
              
           outputFile.write("-> " + layer + "\n\n")
           noiseFile.write("-> " + layer + "\n\n")
           
           for hist in self.dicOfModuleHistograms[layer]:          
             for row in range(2):          
               for rocNum in range(self.rocsInRow):
                 startPixel = rocNum * self.rocMaxCol + 1
                 endPixel = (rocNum + 1) * self.rocMaxCol + 1 # - 1 ???
                 
                 rocCol = rocNum + 1
                 
                 pixelArr, medFiltRes, columnsWithSuspiciouslyNoisyPixels, sciPyMedFiltRes = self.__getROCData(hist, startPixel, endPixel, row, 3, 5)
                 
                 if pixelArr == None:
                   continue
                   
                 # meanOfPixels = sum(pixelArr) / len(pixelArr)
                 # pixelArrSorted = deepcopy(pixelArr)
                 # pixelArrSorted.sort()
                 # outputFile.write("%s: <x> <med_min> VS. <med_max> | x_min:\t%f %f %f | %f, %f, %f, %f\n" % (hist.GetName(), meanOfPixels, min(medFiltRes), max(medFiltRes), pixelArrSorted[0], pixelArrSorted[1], pixelArrSorted[2], pixelArrSorted[3]))
                 
                 if "F" not in layer:
                   # pixelArrWithoutDrops = self.__getPixelArrWithRemovedDrops(pixelArr, medFiltRes)
                   pixelArrWithoutDrops = self.__getPixelArrWithRemovedDrops(pixelArr, sciPyMedFiltRes)
                   pixelArrWithoutDropsNormalized = self.__normalizeArray(pixelArrWithoutDrops)
                   # tmp_mean = sum(pixelArrWithoutDropsNormalized) / len(pixelArrWithoutDropsNormalized)
                   # pixelArrWithoutDropsNormalized = self.__setNormalizedArrayZeroInThePoint(pixelArrWithoutDropsNormalized, tmp_mean)
                   
                   # print(min(pixelArrWithoutDropsNormalized), max(pixelArrWithoutDropsNormalized))
                   result = self.__determineBarrelDColInefficiencyAndNoise(medFiltRes, hist.GetName(), pixelArr, pixelArrWithoutDropsNormalized, startPixel, rocCol, row, outputFile, columnsWithSuspiciouslyNoisyPixels, noiseFile)
                 else:
                   result = self.__determineEndcapDColInefficiencyAndNoise(medFiltRes, hist.GetName(), pixelArr, startPixel, rocCol, row, outputFile, columnsWithSuspiciouslyNoisyPixels, noiseFile)
                   
                 doubleDeadCols, doubleDeadColsInLayer = doubleDeadCols + result[0], doubleDeadColsInLayer + result[0]
                 noisyColsNum, noisyColsNumInLayer = noisyColsNum + result[1], noisyColsNumInLayer + result[1]               
                   
           outputFile.write("\n\tTOTAL IN LAYER/DISK: %d\n\n" % (doubleDeadColsInLayer))    
           noiseFile.write("\n\tTOTAL IN LAYER/DISK: %d\n\n" % (noisyColsNumInLayer))
           
     print("Number of inefficient double columns: %d"%(doubleDeadCols))
     print("Number of noisy cols: %d"%(noisyColsNum))
       
       
 #--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--