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)