CorrelationMatrixHelpers.CorrMat4D Class Reference

Collaboration diagram for CorrelationMatrixHelpers.CorrMat4D:

Public Member Functions
def	__init__ (self, relMet=False)
def	setInfo (self, jetDef, varType, plotType)
def	setInfoCopy (self, toCopy, plotType="")
def	cloneHist4D (self, toClone)
def	applyAbsValue (self)
def	fillHist4DFromFile (self, inFile, fixedString, fixedX, fixedY, filterStartString="", granularityFactor=1)
	4D histogram building from 2D histograms # More...
def	fillHist4DFromDifference (self, hist1, hist2)
	4D histograms from differences of 4D hist sets # More...
def	fillHist4DFromMinOfSet (self, hists)
	4D histogram from minimum value of a 4D set # More...
def	fillHist4DFromMaxOfSet (self, hists)
	4D histogram from maximum value of a 4D set # More...
def	fillHist4DFromEnvelopeOfSet (self, hists)
	4D histogram from envelope of a 4D set # More...
def	fillHist4DFromCoverageOfSet (self, minDiffFromNominal, maxDiffBetweenScenarios, plotStyle, nominalHist=None)
	4D histogram from coverage of a 4D set # More...

Public Attributes
	hist4D
	jetDef
	varType
	plotType
	OOB
	OOBT
	relativeMetric
	ATLASLabelName
	DrawATLASLabel
	iEPS
	histName

Detailed Description

                                           #

4D histogram class # #

Definition at line 22 of file CorrelationMatrixHelpers.py.

Constructor & Destructor Documentation

__init__()

def CorrelationMatrixHelpers.CorrMat4D.__init__	(		self,
			relMet = False
	)

Definition at line 24 of file CorrelationMatrixHelpers.py.

    def __init__(self,relMet=False):
        self.hist4D   = None
        self.jetDef   = None
        self.varType  = None
        self.plotType = None
        self.OOB  = -1234 # out of bounds value
        self.OOBT = -1000 # out of bounds threshold
        # Whether to use (nominal-reduced) or (1-nominal)/(1-reduced)
        self.relativeMetric = relMet
    
        # For the plotting functions
        self.ATLASLabelName = "Internal"
        self.DrawATLASLabel = True
        self.iEPS = 0
 
 

Member Function Documentation

applyAbsValue()

def CorrelationMatrixHelpers.CorrMat4D.applyAbsValue

(

self

)

Definition at line 57 of file CorrelationMatrixHelpers.py.

    def applyAbsValue(self):
        if not self.hist4D:
          print "Cannot apply absolute value when the histogram hasn't been created"
          return False
 
        for binX in range(1,self.hist4D.GetNbinsX()+1):
          for binY in range(1,self.hist4D.GetNbinsY()+1):
            if self.hist4D.GetBinContent(binX,binY) > self.OOBT:
                self.hist4D.SetBinContent(binX,binY,fabs(self.hist4D.GetBinContent(binX,binY)))
        return True
 

cloneHist4D()

def CorrelationMatrixHelpers.CorrMat4D.cloneHist4D	(		self,
			toClone
	)

Definition at line 50 of file CorrelationMatrixHelpers.py.

    def cloneHist4D(self,toClone):
        try:
            self.hist4D = toClone.Clone()
        except AttributeError:
            self.hist4D = toClone.hist4D.Clone()
        self.hist4D.SetName("4D_var%s_%s_%s"%(self.varType,self.jetDef,self.plotType))
 

fillHist4DFromCoverageOfSet()

def CorrelationMatrixHelpers.CorrMat4D.fillHist4DFromCoverageOfSet	(		self,
			minDiffFromNominal,
			maxDiffBetweenScenarios,
			plotStyle,
			nominalHist = None
	)

4D histogram from coverage of a 4D set #

Definition at line 340 of file CorrelationMatrixHelpers.py.

    def fillHist4DFromCoverageOfSet(self,minDiffFromNominal,maxDiffBetweenScenarios,plotStyle,nominalHist=None):
      # Ensure the histogram wasn't already filled
      if self.hist4D:
        print "Blocking re-filling of existing CorrMat4D histogram of name ",self.hist4D.GetName()
        return False
 
      # Ensure the histogram(s) exist
      if not minDiffFromNominal or not maxDiffBetweenScenarios:
        print "Argument is None or empty list: ",minDiffFromNominal,maxDiffBetweenScenarios
        return False
      if plotStyle==2 and not nominalHist:
        print "NominalHist is None for style which requires it"
        return False
 
      # Copy the minDiff histogram for formatting purposes
      self.cloneHist4D(minDiffFromNominal)
 
      # Now fill with the value controlled by plotStyle
      #   0: 0 if max(scenarioDiff) > min(nominalDiff) else min(nominalDiff)
      #   1: 0 if max(scenarioDiff) > min(nominalDiff) else min(nominalDiff) - max(scenarioDiff)
      #   2: 0 if max(scenarioDiff) > min(nominalDiff) else nominalValue
 
      for binX in range(1,self.hist4D.GetNbinsX()+1):
        for binY in range(1,self.hist4D.GetNbinsY()+1):
            if self.hist4D.GetBinContent(binX,binY) > self.OOBT:
                minDiff = fabs(minDiffFromNominal.hist4D.GetBinContent(binX,binY))
                maxDiff = fabs(maxDiffBetweenScenarios.hist4D.GetBinContent(binX,binY))
                
                if not self.relativeMetric:
                    if minDiff <= maxDiff:
                        self.hist4D.SetBinContent(binX,binY,0)
                    elif plotStyle == 0:
                        self.hist4D.SetBinContent(binX,binY,minDiffFromNominal.hist4D.GetBinContent(binX,binY))
                    elif plotStyle == 1:
                        self.hist4D.SetBinContent(binX,binY,maxDiff-minDiff)
                    elif plotStyle == 2:
                        self.hist4D.SetBinContent(binX,binY,nominalHist.hist4D.GetBinContent(binX,binY))
                    else:
                        print "Unrecognized plotStyle of ",plotStyle
                        return False
                else:
                    # The min difference from 1 (nominal vs reduced) should be smaller 
                    # than the max difference from 1 (reduced vs reduced) as a relative comparison
                    if (minDiff <= 1 and maxDiff <= 1) and (minDiff >= maxDiff):
                        self.hist4D.SetBinContent(binX,binY,1)
                    elif (minDiff >= 1 and maxDiff >= 1) and (minDiff <= maxDiff):
                        self.hist4D.SetBinContent(binX,binY,1)
                    elif (minDiff >= 1 and maxDiff <= 1) and (minDiff <= 1/maxDiff):
                        self.hist4D.SetBinContent(binX,binY,1)
                    elif (minDiff <= 1 and maxDiff >= 1) and (minDiff >= 1/maxDiff):
                        self.hist4D.SetBinContent(binX,binY,1)
                    else:
                        if plotStyle == 0:
                            self.hist4D.SetBinContent(binX,binY,minDiffFromNominal.hist4D.GetBinContent(binX,binY))
                        elif plotStyle == 1:
                            if (minDiff <= 1 and maxDiff <= 1) or (minDiff >= 1 and maxDiff >= 1):
                                self.hist4D.SetBinContent(binX,binY,minDiff/maxDiff)
                            else:
                                self.hist4D.SetBinContent(binX,binY,minDiff*maxDiff)
                        elif plotStyle == 2:
                            self.hist4D.SetBinContent(binX,binY,nominalHist.hist4D.GetBinContent(binX,binY))
                        else:
                            print "Unrecognized plotStyle of ",plotStyle
                            return False
 
      return True
 
 

fillHist4DFromDifference()

def CorrelationMatrixHelpers.CorrMat4D.fillHist4DFromDifference	(		self,
			hist1,
			hist2
	)

4D histograms from differences of 4D hist sets #

Definition at line 175 of file CorrelationMatrixHelpers.py.

    def fillHist4DFromDifference(self,hist1,hist2):
      # Ensure the histogram wasn't already filled
      if self.hist4D:
        print "Blocking re-filling of existing CorrMat4D histogram of name ",self.hist4D.GetName()
        return False
 
      # Ensure the histograms exist
      if not hist1 or not hist2:
        print "Argument(s) are None: ",hist1,hist2
        return False
 
      # Copy the first histogram and subtract the second
      self.cloneHist4D(hist1)
 
      # Manually do the difference so that we can watch for out-of-bounds
      for binX in range(1,hist1.hist4D.GetNbinsX()+1):
        for binY in range(1,hist2.hist4D.GetNbinsX()+1):
            if hist1.hist4D.GetBinContent(binX,binY) > self.OOBT and hist2.hist4D.GetBinContent(binX,binY) > self.OOBT:
                if not hist1.relativeMetric:
                    self.hist4D.SetBinContent(binX,binY,hist1.hist4D.GetBinContent(binX,binY) - hist2.hist4D.GetBinContent(binX,binY))
                else:
                    self.hist4D.SetBinContent(binX,binY,relativeMetric(hist1.hist4D.GetBinContent(binX,binY),hist2.hist4D.GetBinContent(binX,binY)))
 
      return True
 

fillHist4DFromEnvelopeOfSet()

def CorrelationMatrixHelpers.CorrMat4D.fillHist4DFromEnvelopeOfSet	(		self,
			hists
	)

4D histogram from envelope of a 4D set #

Definition at line 298 of file CorrelationMatrixHelpers.py.

    def fillHist4DFromEnvelopeOfSet(self,hists):
      # Ensure the histogram wasn't already filled
      if self.hist4D:
        print "Blocking re-filling of existing CorrMat4D histogram of name ",self.hist4D.GetName()
        return False
 
      # Ensure the histogram(s) exist
      if not hists or len(hists) < 2:
        print "Argument is None or contains less than two histograms: ",hists
        return False
 
      # Copy the first histogram for formatting purposes
      self.cloneHist4D(hists[0])
 
      # The values of the first histogram were copied from cloning
      # We need to set these back to 0 (excluding out-of-bounds values)
      for binX in range(1,self.hist4D.GetNbinsX()+1):
        for binY in range(1,self.hist4D.GetNbinsY()+1):
            if self.hist4D.GetBinContent(binX,binY) > self.OOBT:
                self.hist4D.SetBinContent(binX,binY,0)
 
      # Now construct the envelope
      # Fill with the maximum |difference| from zero when subtracting config X from config Y for all combinations of X,Y
      for iHist1 in range(0,len(hists)):
        hist1 = hists[iHist1]
        for iHist2 in range(iHist1+1,len(hists)):
            hist2 = hists[iHist2]
            for binX in range(self.hist4D.GetNbinsX()+1):
                for binY in range(self.hist4D.GetNbinsY()+1):
                    if self.hist4D.GetBinContent(binX,binY) > self.OOBT:
                        if aHist.relativeMetric:
                            diff = relativeMetric(1-hist1.hist4D.GetBinContent(binX,binY),1-hist2.hist4D.GetBinContent(binX,binY))
                        else:
                            diff = fabs(hist2.hist4D.GetBinContent(binX,binY) - hist1.hist4D.GetBinContent(binX,binY))
                        if diff > self.hist4D.GetBinContent(binX,binY):
                            self.hist4D.SetBinContent(binX,binY,diff)
 
      return True
 

fillHist4DFromFile()

def CorrelationMatrixHelpers.CorrMat4D.fillHist4DFromFile	(		self,
			inFile,
			fixedString,
			fixedX,
			fixedY,
			filterStartString = "",
			granularityFactor = 1
	)

4D histogram building from 2D histograms #

Definition at line 70 of file CorrelationMatrixHelpers.py.

    def fillHist4DFromFile(self,inFile,fixedString,fixedX,fixedY,filterStartString="",granularityFactor=1):
      # Ensure the histogram wasn't already filled
      if self.hist4D:
          print "Blocking re-filling of existing CorrMat4D histogram of name ",self.hist4D.GetName()
          return False
    
      # Begin by checking the size of the 2D matrices
      numBins = -1
      for histName in inFile.GetKeyNames():
        if filterStartString != "" and not histName.startswith(filterStartString):
            continue
        if self.jetDef not in histName:
            continue
        if "_%s"%(fixedString) in histName:
            hist = inFile.Get(histName)
            numBins = hist.GetNbinsX()
            break
      if numBins < 0:
        print "Failed to find histogram matching criteria:"
        print "jetDef = \"%s\""%(self.jetDef)
        print "filterStartString = \"%s\""%(filterStartString)
        return False
 
      # Granularity scaling if requested
      localNumBins = int(numBins / granularityFactor) if granularityFactor > 1 else numBins
      if granularityFactor > 1:
        # Ensure the granularity fits
        if numBins % granularityFactor != 0:
            print "Cannot apply granularity factor: %d bins can't be divided by %d"%(numBins,granularityFactor)
            return False
 
      # Now build the empty 4D matrix
      histName4D = "4D_var%s_%s_%s"%(self.varType,self.jetDef,inFile.GetNameNoDir())
      self.hist4D = TH2D(histName4D,"",len(fixedX)*localNumBins,0.,len(fixedX)*localNumBins,len(fixedY)*localNumBins,0.,len(fixedY)*localNumBins)
 
      # Fill with the out-of-bounds value
      for binX in range(1,self.hist4D.GetNbinsX()+1):
        for binY in range(1,self.hist4D.GetNbinsY()+1):
            self.hist4D.SetBinContent(binX,binY,self.OOB)
 
      # Fill the histogram
      for histName in inFile.GetKeyNames():
        if filterStartString != "" and not histName.startswith(filterStartString):
            continue
        if self.jetDef not in histName:
            continue
 
        # Get the fixed values for this 2D histogram
        # Sanity checks were already done before, so we just need to retrieve them
        fixed1,fixed2 = getFixedValuesFromName(histName)
        if not fixed1.startswith(fixedString): continue
        fixed1 = float(fixed1.replace(fixedString,"",1))
        fixed2 = float(fixed2.replace(fixedString,"",1))
 
        # We have the fixed values, now determine the respective indices
        index1 = -1
        index2 = -1
        for aIndex in range(0,len(fixedX)):
            aValue = fixedX[aIndex]
            if fabs(aValue - fixed1) < 1.e-4:
                index1 = aIndex
                break
        for aIndex in range(0,len(fixedY)):
            aValue = fixedY[aIndex]
            if fabs(aValue - fixed2) < 1.e-4:
                index2 = aIndex
                break
        if index1 < 0 or index2 < 0:
            print "Failed to find index1 (%d) or index2 (%d) for histogram (%s)"%(index1,index2,histName)
            self.histName = None
            return False
 
        # We now have the indices
        # Get the 2D histogram and use it to fill the relevant portion of the 4D histogram
        # Watch for granularity factors
        hist2D = inFile.Get(histName)
        offsetX = int((self.hist4D.GetNbinsX()/len(fixedX))*index1)
        offsetY = int((self.hist4D.GetNbinsY()/len(fixedY))*index2)
        if localNumBins == numBins:
            for binX in range(1,hist2D.GetNbinsX()+1):
                for binY in range(1,hist2D.GetNbinsY()+1):
                    self.hist4D.SetBinContent(binX+offsetX,binY+offsetY,hist2D.GetBinContent(binX,binY))
        else:
            # Split into pieces by the granularity factor
            # Watch for the root indexing from 1, which has to be in the sub-bin indices
            # Also have to be careful about bins which are on the edge of the kinematic limit
            for binX in range(0,hist2D.GetNbinsX()/granularityFactor):
                for binY in range(0,hist2D.GetNbinsY()/granularityFactor):
                    subVal = 0
                    numVal = 0
                    for subBinX in range(1,granularityFactor+1):
                        for subBinY in range(1,granularityFactor+1):
                            binContent = hist2D.GetBinContent(binX*granularityFactor+subBinX,binY*granularityFactor+subBinY)
                            if binContent > self.OOBT:
                                subVal += binContent
                                numVal += 1
                    self.hist4D.SetBinContent(binX+1+offsetX,binY+1+offsetY,subVal/numVal if numVal > 0 else self.OOB)
 
        # Done with this 2D histogram
      # Done with this 4D histogram
      return True
 

fillHist4DFromMaxOfSet()

def CorrelationMatrixHelpers.CorrMat4D.fillHist4DFromMaxOfSet	(		self,
			hists
	)

4D histogram from maximum value of a 4D set #

Definition at line 253 of file CorrelationMatrixHelpers.py.

    def fillHist4DFromMaxOfSet(self,hists):
      # Ensure the histogram wasn't already filled
      if self.hist4D:
        print "Blocking re-filling of existing CorrMat4D histogram of name ",self.hist4D.GetName()
        return False
 
      # Ensure the histogram(s) exist
      if not hists or len(hists) == 0:
        print "Argument is None or empty list: ",hists
        return False
 
      # Copy the first histogram for formatting purposes
      self.cloneHist4D(hists[0])
 
      # The values from the first histogram are already set from cloning
      # Now just check if any other hists have smaller values
      # Note that this may be values with respect to 1 if relative metric
      # Watch for out-of-bounds
      for aHist in hists[1:]:
        for binX in range(1,aHist.hist4D.GetNbinsX()+1):
            for binY in range(1,aHist.hist4D.GetNbinsY()+1):
                if aHist.hist4D.GetBinContent(binX,binY) > aHist.OOBT and aHist.hist4D.GetBinContent(binX,binY) < -aHist.OOBT:
                    if not aHist.relativeMetric:
                        if fabs(aHist.hist4D.GetBinContent(binX,binY)) > fabs(self.hist4D.GetBinContent(binX,binY)):
                            self.hist4D.SetBinContent(binX,binY,aHist.hist4D.GetBinContent(binX,binY))
                    else:
                        currVal = self.hist4D.GetBinContent(binX,binY)
                        newVal  = aHist.hist4D.GetBinContent(binX,binY)
                        if currVal < 1 and newVal < 1:
                            if newVal < currVal:
                                self.hist4D.SetBinContent(binX,binY,newVal)
                        elif currVal < 1 and newVal > 1:
                            if newVal > 1/currVal:
                                self.hist4D.SetBinContent(binX,binY,newVal)
                        elif currVal > 1 and newVal < 1:
                            if newVal < 1/currVal:
                                self.hist4D.SetBinContent(binX,binY,newVal)
                        elif currVal > 1 and newVal > 1:
                            if newVal > currVal:
                                self.hist4D.SetBinContent(binX,binY,newVal)
      return True
 

fillHist4DFromMinOfSet()

def CorrelationMatrixHelpers.CorrMat4D.fillHist4DFromMinOfSet	(		self,
			hists
	)

4D histogram from minimum value of a 4D set #

Definition at line 203 of file CorrelationMatrixHelpers.py.

    def fillHist4DFromMinOfSet(self,hists):
      # Ensure the histogram wasn't already filled
      if self.hist4D:
        print "Blocking re-filling of existing CorrMat4D histogram of name ",self.hist4D.GetName()
        return False
 
      # Ensure the histogram(s) exist
      if not hists or len(hists) == 0:
        print "Argument is None or empty list: ",hists
        return False
 
      # Copy the first histogram for formatting purposes
      self.cloneHist4D(hists[0])
 
      # The values from the first histogram are already set from cloning
      # Now just check if any other hists have smaller values
      # Note that smaller may be relative to 1, not zero (for the relative metric)
      # Watch for out-of-bounds
      for aHist in hists[1:]:
        for binX in range(1,aHist.hist4D.GetNbinsX()+1):
            for binY in range(1,aHist.hist4D.GetNbinsY()+1):
                if aHist.hist4D.GetBinContent(binX,binY) > aHist.OOBT:
                    if not aHist.relativeMetric:
                        if fabs(aHist.hist4D.GetBinContent(binX,binY)) < fabs(self.hist4D.GetBinContent(binX,binY)):
                            self.hist4D.SetBinContent(binX,binY,aHist.hist4D.GetBinContent(binX,binY))
                    else:
                        currVal = self.hist4D.GetBinContent(binX,binY)
                        newVal  = aHist.hist4D.GetBinContent(binX,binY)
                        # If the values bracket one, we're safe
                        if currVal <= 1 and newVal >= 1:
                            self.hist4D.SetBinContent(binX,binY,1)
                        elif currVal >= 1 and newVal <= 1:
                            self.hist4D.SetBinContent(binX,binY,1)
                        elif currVal < 1 and newVal < 1:
                            if newVal > currVal:
                                self.hist4D.SetBinContent(binX,binY,newVal)
                        #elif currVal < 1 and newVal > 1:
                        #    if newVal < 1/currVal:
                        #        self.hist4D.SetBinContent(binX,binY,newVal)
                        #elif currVal > 1 and newVal < 1:
                        #    if newVal > 1/currVal:
                        #        self.hist4D.SetBinContent(binX,binY,newVal)
                        elif currVal > 1 and newVal > 1:
                            if newVal < currVal:
                                self.hist4D.SetBinContent(binX,binY,newVal)
      return True
 

setInfo()

def CorrelationMatrixHelpers.CorrMat4D.setInfo	(		self,
			jetDef,
			varType,
			plotType
	)

Definition at line 40 of file CorrelationMatrixHelpers.py.

    def setInfo(self,jetDef,varType,plotType):
        self.jetDef   = jetDef
        self.varType  = varType
        self.plotType = plotType
 

setInfoCopy()

def CorrelationMatrixHelpers.CorrMat4D.setInfoCopy	(		self,
			toCopy,
			plotType = ""
	)

Definition at line 45 of file CorrelationMatrixHelpers.py.

    def setInfoCopy(self,toCopy,plotType = ""):
        self.jetDef   = toCopy.jetDef
        self.varType  = toCopy.varType
        self.plotType = plotType if plotType != "" else toCopy.plotType
 

Member Data Documentation

ATLASLabelName

CorrelationMatrixHelpers.CorrMat4D.ATLASLabelName

Definition at line 35 of file CorrelationMatrixHelpers.py.

DrawATLASLabel

CorrelationMatrixHelpers.CorrMat4D.DrawATLASLabel

Definition at line 36 of file CorrelationMatrixHelpers.py.

hist4D

CorrelationMatrixHelpers.CorrMat4D.hist4D

Definition at line 25 of file CorrelationMatrixHelpers.py.

histName

CorrelationMatrixHelpers.CorrMat4D.histName

Definition at line 139 of file CorrelationMatrixHelpers.py.

iEPS

CorrelationMatrixHelpers.CorrMat4D.iEPS

Definition at line 37 of file CorrelationMatrixHelpers.py.

jetDef

CorrelationMatrixHelpers.CorrMat4D.jetDef

Definition at line 26 of file CorrelationMatrixHelpers.py.

OOB

CorrelationMatrixHelpers.CorrMat4D.OOB

Definition at line 29 of file CorrelationMatrixHelpers.py.

OOBT

CorrelationMatrixHelpers.CorrMat4D.OOBT

Definition at line 30 of file CorrelationMatrixHelpers.py.

plotType

CorrelationMatrixHelpers.CorrMat4D.plotType

Definition at line 28 of file CorrelationMatrixHelpers.py.

relativeMetric

CorrelationMatrixHelpers.CorrMat4D.relativeMetric

Definition at line 32 of file CorrelationMatrixHelpers.py.

varType

CorrelationMatrixHelpers.CorrMat4D.varType

Definition at line 27 of file CorrelationMatrixHelpers.py.

---

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

• CorrelationMatrixHelpers.py