예제 #1
0
gauss_model = ResolutionModel(Name = "gauss_model", Type = GaussModel, Parameters = [t_diff, res_mean, st, mean_sf, gauss_sigma_sf], ConditionalObservables = [st])

gexp_frac = RealVar(Name = "gexp_frac", Value = 0.1, MinMax = (0.0001, 0.9999))
add_model = AddModel("add_model", Models = [gexp_model, gauss_model], Fractions = [gexp_frac], ConditionalObservables = [st])

from ROOT import RooDecay as Decay
peak_tau = RealVar(Name = "peak_tau", Value = 0, Constant = True)
peak = Pdf(Name = "peak", Type = Decay, Parameters = [t_diff, peak_tau, add_model, 'SingleSided'], ConditionalObservables = [st])

## peak2 = Pdf(Name = "peak2", Type = Decay, Parameters = [t_diff, peak_tau, gexp_model, 'SingleSided'], ConditionalObservables = [st])

## peak3 = Pdf(Name = "peak3", Type = Decay, Parameters = [t_diff, peak_tau, gauss_model, 'SingleSided'], ConditionalObservables = [st])

# signal component
from P2VV.Parameterizations.MassPDFs import LP2011_Signal_Mass as Signal_Mass
sig_m = Signal_Mass(Name = 'sig_m', mass = m) 
signal = Component('signal', (sig_m.pdf(), st_pdf, peak), Yield = (150000, 10000, 1000000))

sig_mass_pdf = buildPdf(Components = (signal, background), Observables = (m,), Name = 'sig_mass_pdf')
signal_name = signal.GetName()
mass_pdf = sig_mass_pdf

fitOpts = dict(NumCPU = 4, Timer = 1, Save = True, Minimizer = 'Minuit2', Optimize = 2, Offset = True,
               Verbose = False)

gen_pdf = buildPdf(Components = (signal,), Observables = (t_diff, st), Name = 'gen_pdf')
fit_pdf = buildPdf(Components = (signal,), Observables = (t_diff,), Name = 'fit_pdf')

toy.set_fit_opts(**dict(Verbose = False))
toy.run(Observables = [t_diff, st], Pdf = fit_pdf, GenPdf = gen_pdf)
예제 #2
0
hlt2_unbiased = Category('hlt2_unbiased', States = {'unbiased' : 1, 'not_unbiased' : 0}, Observable = True)
selected = Category('sel', States = {'Selected' : 1, 'NotSelected' : 0})

observables = [t, m, mpsi, mphi, st, hlt1_excl_biased, selected, zerr,
               hlt1_biased, hlt1_unbiased, hlt2_biased, hlt2_unbiased] + angles
               
project_vars = [st, hlt1_excl_biased]

# now build the actual signal PDF...
from ROOT import RooGaussian as Gaussian
from ROOT import RooExponential as Exponential
from ROOT import RooDecay as Decay

# B mass pdf
from P2VV.Parameterizations.MassPDFs import LP2011_Signal_Mass as Signal_BMass, LP2011_Background_Mass as Background_BMass
sig_m = Signal_BMass(Name = 'sig_m', mass = m, m_sig_mean = dict(Value = 5365, MinMax = (5363,5372)))

# J/psi mass pdf
mpsi_mean  = RealVar('mpsi_mean',   Unit = 'MeV', Value = 3097, MinMax = (3070, 3110))
mpsi_sigma = RealVar('mpsi_sigma',  Unit = 'MeV', Value = 10, MinMax = (5, 20))
mpsi_alpha = RealVar('mpsi_alpha',  Unit = '', Value = 1.36, MinMax = (0.5, 3))
mpsi_n = RealVar('mpsi_n',  Unit = '', Value = 2, MinMax = (0.1, 4), Constant = True)
psi_m  = Pdf(Name = 'psi_m', Type = CrystalBall, Parameters = [mpsi, mpsi_mean, mpsi_sigma, mpsi_alpha, mpsi_n])
# J/psi background
psi_c = RealVar( 'psi_c',  Unit = '1/MeV', Value = -0.0004, MinMax = (-0.1, -0.0000001))
bkg_mpsi = Pdf(Name = 'bkg_mpsi',  Type = Exponential, Parameters = [mpsi, psi_c])

# Create combinatorical background component
bkg_m = Background_BMass( Name = 'bkg_m', mass = m, m_bkg_exp  = dict( Name = 'm_bkg_exp' ) )
background = Component('background', (bkg_m.pdf(), bkg_mpsi), Yield = (100000,100,500000) )
예제 #3
0
# J/psi signal component
psi_ll = Component('psi_ll', (psi_m, bkg_m, psi_t), Yield= (8.5575e+03,100,500000) )

# Background component
from P2VV.Parameterizations.TimePDFs import Prompt_Peak
background = Component('background', (bkg_mpsi.pdf(), bkg_m), Yield = (19620,100,500000) )
if options.add_background:
    bkg_t = Prompt_Peak(time_obs, bkg_tres.model(), Name = 'bkg_prompt_pdf')
    background[t] = bkg_t.pdf()

# B signal component
sig_t = Prompt_Peak(time_obs, resolutionModel = sig_tres.model(), Name = 'sig_t')

from P2VV.Parameterizations.MassPDFs import LP2011_Signal_Mass as Signal_Mass
sig_m = Signal_Mass(Name = 'sig_m', mass = m)
signal = Component('signal', (sig_m.pdf(), sig_t.pdf()), Yield = (3e5, 10000, 1e7))

# Prompt component
prompt_pdf = Prompt_Peak(time_obs, sig_tres.model(), Name = 'prompt_pdf')
prompt = Component('prompt', (prompt_pdf.pdf(), psi_m), Yield = (160160, 100, 500000))

# Read data
fit_mass = (options.fit_mass or not options.cache) or options.reduce

## from profiler import heap_profiler_start, heap_profiler_stop
## heap_profiler_start("profile.log")

# Tree and cut
tree_name = 'DecayTree'
if signal_MC and options.excl_biased:
예제 #4
0
sigFrac     = eventFracs[0]['N_sigMass'] if eventFracs[0]['N_sigMass'] else 1. - sum(val for val in eventFracs[0].itervalues() if val)
nEvents     = dataSets['pre'][0].sumEntries()
nSignal     = nEvents * sigFrac
nBackground = nEvents * ( 1. - sigFrac )

from P2VV.RooFitWrappers import Component
sigMassComps  = Component( 'sigMass',  [ ], Yield = ( nSignal,     0., nEvents ) )  # signal
cbkgMassComps = Component( 'cbkgMass', [ ], Yield = ( nBackground, 0., nEvents ) )  # combinatorial background

massComps  = [ sigMassComps, cbkgMassComps ]
yieldNames = [ comp.getYield().GetName() for comp in massComps ]

# build the signal mass PDF
sigMassArgs = dict( Name = 'sig_m', mass = observables['mass'] )
from P2VV.Parameterizations.MassPDFs import LP2011_Signal_Mass as SignalBMass
signalBMass = SignalBMass( **sigMassArgs )

# build the combinatorial background mass PDF
cbkgMassArgs = dict( Name = 'cbkg_m', mass = observables['mass'] )
from P2VV.Parameterizations.MassPDFs import LP2011_Background_Mass as BackgroundBMass
backgroundBMass = BackgroundBMass( **cbkgMassArgs )

# build mass PDF
from P2VV.RooFitWrappers import buildPdf
sigMassComps  += signalBMass.pdf()
cbkgMassComps += backgroundBMass.pdf()
massPdf = buildPdf( massComps, Observables = [ observables['mass'] ], Name = 'JpsiKKMass' )


###########################################################################################################################################
## fit J/psiKK mass distributions ##
예제 #5
0
    observables=[mass, t, st, excl_biased],
    Rename="JpsiphiData",
    ntupleCuts=cut,
)

sigFrac = 0.504
nEvents = data.sumEntries()
nSignal = nEvents * sigFrac
nBackground = nEvents * (1.0 - sigFrac)

## from P2VV.Parameterizations.MassPDFs import Ipatia2_Signal_Mass as SignalBMass
## sig_m = SignalBMass(Name = 'sig_m', mass = mass, m_sig_lambda = -2.5, m_sig_zeta = 0.01,
##                     m_sig_alpha_1 = 3.0, m_sig_alpha_2 = 2.5, m_sig_n_1 = 1.5, m_sig_n_2 = 2.0)
from P2VV.Parameterizations.MassPDFs import LP2011_Signal_Mass as SignalBMass

sig_m = SignalBMass(Name="sig_m", mass=mass)

signal = Component("signal", [sig_m.pdf()], Yield=(nSignal, 0.0, nEvents))

from P2VV.Parameterizations.MassPDFs import LP2011_Background_Mass as BackgroundBMass

bkg_m = BackgroundBMass(Name="bkg_m", mass=mass)
background = Component("background", [bkg_m.pdf()], Yield=(nBackground, 0.0, nEvents))

mass_pdf = buildPdf([signal, background], Observables=[mass], Name="mass_pdf")

fitOpts = dict(NumCPU=4, Optimize=2, Save=True, Timer=True, Minimizer="Minuit2", Offset=True)

mass_result = mass_pdf.fitTo(data, **fitOpts)

# categories for splitting the PDF
예제 #6
0
cut += ' && sel_cleantail == 1'

for o in [mass, t, st]:
    cut += ' && {0} > {1} && {0} < {2}'.format(o.GetName(), o.getMin(), o.getMax())

from P2VV.Utilities.DataHandling import readData
data = readData(filePath = input_file, dataSetName = 'DecayTree', NTuple = True,
                observables = [mass, t, st, excl_biased], Rename = 'JpsiphiData', ntupleCuts = cut)

sigFrac = 0.504
nEvents     = data.sumEntries()
nSignal     = nEvents * sigFrac
nBackground = nEvents * ( 1. - sigFrac )

from P2VV.Parameterizations.MassPDFs import LP2011_Signal_Mass as SignalBMass
sig_m = SignalBMass(Name = 'sig_m', mass = mass)

signal = Component( 'signal', [sig_m.pdf()], Yield = ( nSignal,     0., nEvents ) )

from P2VV.Parameterizations.MassPDFs import LP2011_Background_Mass as BackgroundBMass
bkg_m = BackgroundBMass(Name = 'bkg_m', mass = mass)
background = Component( 'background', [bkg_m.pdf()], Yield = ( nBackground, 0., nEvents ) )

mass_pdf = buildPdf( [ signal, background ], Observables = [ mass ], Name = 'mass_pdf')

fitOpts = dict(NumCPU = 4, Optimize = 2, Save = True, Timer = True, Minimizer = 'Minuit2',
               Offset = True)

mass_result = mass_pdf.fitTo(data, **fitOpts)

# categories for splitting the PDF
예제 #7
0
observables = [t, m, mpsi, st, hlt1_biased, hlt1_unbiased, hlt1_excl_biased_dec,
               hlt2_biased, hlt2_unbiased, hlt2_excl_biased, selected, nPV, run_period]

# now build the actual signal PDF...
from ROOT import RooGaussian as Gaussian
from ROOT import RooExponential as Exponential
from ROOT import RooDecay as Decay

from P2VV.Parameterizations.TimeResolution import Gaussian_TimeResolution as TimeResolution
tres = TimeResolution(Name = 'resolution', time = t, BiasScaleFactor = False,
                      timeResSigma = dict(Value = 0.045, Constant = True),
                      timeResMu = dict(Value = 0, Constant = True), Cache = False)

# B mass pdf
from P2VV.Parameterizations.MassPDFs import LP2011_Signal_Mass as Signal_BMass, LP2011_Background_Mass as Background_BMass
sig_m = Signal_BMass(Name = 'sig_m', mass = m, m_sig_mean = dict( Value = 5365, MinMax = (5363,5372)))

# Create combinatorical background component
bkg_m = Background_BMass( Name = 'bkg_m', mass = m, m_bkg_exp = dict( Name = 'm_bkg_exp' ) )

# Create components
signal_mass = Component('signal', (sig_m.pdf(),), Yield = (30000,100,100000))
background_mass = Component('background', (bkg_m.pdf(),), Yield = (100000,100,300000) )

## Build mass PDF
mass_pdf = buildPdf(Components = (signal_mass, background_mass), Observables = (m, ), Name='mass_pdf')
mass_pdf.Print("t")

## base_location = '/home/raaij'
base_location = '/stuff/PhD/p2vv'