def __init__(self, rawspectrum, yieldCalculator, limit):
self.__limit = limit
self.__points = DataCollection("ptreachdata%s" % (limit))
self.__parameterisation = TF1("powerlaw%d" % (self.__limit),
"[0] * TMath::Power(x, [1])", 0, 1e12)
self.__datamodel = yieldCalculator
self.__CreateCurve()
class PtReachData:
def __init__(self, name, data, isMinBias, doIntegral = True):
self.__calculator = PtReachCalculator(name, data, isMinBias, 50)
self.__data = DataCollection("data%s" %(name))
self.__isIntegral = doIntegral
self.__rootobject = None
self.__CreateData()
def __CreateData(self):
events = [500000, 1000000, 20000000, 50000000, 100000000, 200000000, 300000000, 400000000, 500000000, 750000000, 1000000000]
PtReachCalculation = lambda p : self.__calculator.GetPtReach(p)
if self.__isIntegral:
PtReachCalculation = lambda p : self.__calculator.GetPtReachForIntegral(p)
for nevents in events:
self.__data.AddDataPoint(Datapoint(nevents, PtReachCalculation(nevents), 0.))
def MakeGraphics(self):
if not self.__rootobject:
self.__MakeRootObject()
return self.__rootobject
def IsIntegral(self):
return self.__isIntegral
def __MakeRootObject(self):
self.__rootobject = self.__data.MakeLimitCurve(None, direction = "central")
def GetWeightingCurve(self):
"""
Build graph from the different weights
"""
result = DataCollection("weightlist")
for mybin in self.__pthatbins:
result.AddDataPoint(
Datapoint(mybin.GetBinID(), mybin.GetWeight(), 0.5))
return result.MakeLimitCurve(None, direction="central")
class EvDepPtReachData:
def __init__(self, rawspectrum, yieldCalculator, limit):
self.__limit = limit
self.__points = DataCollection("ptreachdata%s" % (limit))
self.__parameterisation = TF1("powerlaw%d" % (self.__limit),
"[0] * TMath::Power(x, [1])", 0, 1e12)
self.__datamodel = yieldCalculator
self.__CreateCurve()
def GetRawSpectrum(self):
return self.__datamodel.GetRawSpectrum()
def GetFit(self):
return self.__datamodel.GetFitCurve()
def GetReachForNumberOfEvents(self, nevents):
return self.__parameterisation.Eval(nevents)
def GetParameterisation(self, style):
return GraphicsObject(self.__parameterisation, style)
def __CreateCurve(self):
eventstocheck = [
1e6, 2e6, 5e6, 1e7, 5e7, 1e8, 5e8, 1e9, 5e9, 1e10, 5e10, 1e11, 5e11
]
for point in eventstocheck:
self.__points.AddDataPoint(
Datapoint(point,
self.__datamodel.FindMaxPt(point, self.__limit), 0))
self.__CreatePowerLawParameterisation()
def GetGraphics(self, style):
return GraphicsObject(
self.__points.MakeLimitCurve(None, direction="central"), style)
def __CreatePowerLawParameterisation(self):
points = self.__points.MakeLimitCurve(None, direction="central")
self.__parameterisation.SetParLimits(0, 1e-5, 500)
self.__parameterisation.SetParLimits(1, 1e-1, 1)
self.__parameterisation.SetParameter(0, 2)
self.__parameterisation.SetParameter(1, 0.2)
points.Fit(self.__parameterisation, "N", "", 1e8, 1e11)
def MakeOutputList(self):
result = TList()
result.SetName("Results%d" % (self.__limit))
rawspectrum = deepcopy(self.__datamodel.GetRawSpectrum())
rawspectrum.SetName("rawspectrum")
fitcurve = deepcopy(self.__datamodel.GetFitCurve())
fitcurve.SetName("parameterisation")
ptreach = self.__points.MakeLimitCurve(None, direction="central")
ptreach.SetName("ptreach")
result.Add(rawspectrum)
result.Add(fitcurve)
result.Add(ptreach)
return result
def __init__(self, rawspectrum, isMinBias = True):
"""
Constructor
"""
self.__rawspectrum = rawspectrum
self.__mbfitter = None
if isMinBias:
self.__mbfitter = MinBiasFitter("MinBiasFitter", self.__rawspectrum)
else:
self.__mbfitter = TriggeredSpectrumFitter("TriggeredFitter", self.__rawspectrum)
self.__datafitted = DataCollection("MinBiasFitted")
class HepDataReader(object):
'''
Class reading hepdata input
'''
def __init__(self, filename, dataname):
'''
Constructor
'''
self.__result = DataCollection(dataname)
self.ReadFile(filename)
def GetData(self):
return self.__result
def ReadFile(self, filename):
inputfile = open(filename)
for line in inputfile:
data = self.__ProcessDatapoint(line.replace("\n", ""))
if data:
self.__result.AddDataPoint(data)
inputfile.close()
print "Successfully read in %d points" % (len(
self.__result.GetPointList()))
def __ProcessDatapoint(self, line):
line = line.replace("E", "e")
tokens = line.split("\t")
values = self.__RemoveEmpty(tokens)
print values
if not self.TestDigit(values[0]):
print "%s is not a digit" % (values[0])
return None
result = Datapoint(float(values[0]), float(values[3]),
float(values[0]) - float(values[1]))
result.AddErrorSource("stat", float(values[5]), float(values[4]))
result.AddErrorSource("sys", float(values[7]), float(values[6]))
result.Print()
return result
def TestDigit(self, value):
try:
test = float(value)
except ValueError:
return False
return True
def __RemoveEmpty(self, inputlist):
output = []
for entry in inputlist:
if len(entry):
output.append(entry)
return output
def __Create(self, emcaldata):
result = DataCollection("turnonCurve%s" % (self.__name))
for mybin in range(1, emcaldata.GetXaxis().GetNbins() + 1):
minval = emcaldata.GetXaxis().GetBinLowEdge(mybin)
if minval < 15:
continue
maxval = emcaldata.GetXaxis().GetBinUpEdge(mybin)
binnedMb = self.__mbfitter.CalculateBinMean(minval, maxval)
statError = emcaldata.GetBinError(mybin) / binnedMb
datapoint = Datapoint(emcaldata.GetXaxis().GetBinCenter(mybin),
emcaldata.GetBinContent(mybin) / binnedMb,
emcaldata.GetXaxis().GetBinWidth(mybin) / 2.)
datapoint.AddErrorSource("stat", statError, statError)
result.AddDataPoint(datapoint)
return result
class IntegralRangeChecker:
def __init__(self, minbiasspectrum):
self.__spectrumfitter = SpectrumFitter("minbiasfitter",
minbiasspectrum)
self.__spectrumfitter.DoFit(15., 50.)
self.__upperrange = DataCollection("IntMax")
self.__intmin = 0.
def MakeIntMaxDependence(self, intmin=30):
for intmax in range(50, 1050, 50):
value = self.__spectrumfitter.CalculateIntegral(
float(intmin), float(intmax))
print "Max.: %f, value: %e" % (intmax, value)
self.__upperrange.AddDataPoint(Datapoint(float(intmax), value, 0.))
self.__intmin = intmin
def GetGraphics(self):
return GraphicsObject(
self.__upperrange.MakeLimitCurve(None, direction="central"),
Style(kRed, 24))
def GetLabelText(self):
return "Min. p_{t}: %1.f GeV/c" % (self.__intmin)
class RawData:
"""
Container class for the data to be plotted
"""
def __init__(self, rawspectrum, isMinBias = True):
"""
Constructor
"""
self.__rawspectrum = rawspectrum
self.__mbfitter = None
if isMinBias:
self.__mbfitter = MinBiasFitter("MinBiasFitter", self.__rawspectrum)
else:
self.__mbfitter = TriggeredSpectrumFitter("TriggeredFitter", self.__rawspectrum)
self.__datafitted = DataCollection("MinBiasFitted")
def MakeRawSpectrum(self):
"""
Access to the raw spectrum itself
"""
return GraphicsObject(self.__rawspectrum, Style(kRed, 24))
def MakeFitted(self):
for mybin in range(1, self.__rawspectrum.GetXaxis().GetNbins()+1):
xmin = self.__rawspectrum.GetXaxis().GetBinLowEdge(mybin)
xmax = self.__rawspectrum.GetXaxis().GetBinUpEdge(mybin)
self.__datafitted.AddDataPoint(Datapoint(self.__rawspectrum.GetXaxis().GetBinCenter(mybin), self.__mbfitter.CalculateBinMean(xmin, xmax),self.__rawspectrum.GetXaxis().GetBinWidth(mybin)/2.))
return GraphicsObject(self.__datafitted.MakeLimitCurve(None, direction="central"), Style(kGreen, 27))
def Write(self, filename):
result = TFile(filename, "RECREATE")
result.cd()
self.__rawspectrum.Write("rawspectrum")
self.__datafitted.MakeLimitCurve(None, "central").Write("fit")
result.Close()
def __init__(self, minbiasspectrum):
self.__spectrumfitter = SpectrumFitter("minbiasfitter",
minbiasspectrum)
self.__spectrumfitter.DoFit(15., 50.)
self.__upperrange = DataCollection("IntMax")
self.__intmin = 0.
def __init__(self, name, data, isMinBias, doIntegral = True):
self.__calculator = PtReachCalculator(name, data, isMinBias, 50)
self.__data = DataCollection("data%s" %(name))
self.__isIntegral = doIntegral
self.__rootobject = None
self.__CreateData()
def __init__(self, filename, dataname):
'''
Constructor
'''
self.__result = DataCollection(dataname)
self.ReadFile(filename)