Example #1
0
logger.info('Dataset: %s' % dataset)

## various fit components
signal_x1 = Models.Gauss_pdf('G1x',
                             xvar=m_x,
                             mean=m1.value(),
                             sigma=m1.error())
signal_y1 = signal_x1.clone(name='G1y', xvar=m_y)

signal_x2 = Models.Gauss_pdf(name='G2x',
                             xvar=m_x,
                             mean=m2.value(),
                             sigma=m2.error())
signal_y2 = signal_x2.clone(name='G2y', xvar=m_y)

bkg_x = make_bkg(-1, 'Bx', m_x)
bkg_y = bkg_x.clone(name='By', xvar=m_y)

# S(x)*S(y) component
ss_cmp = signal_x2 * signal_y2

# S(x)*B(y) component
sb = signal_x2 * bkg_y

# B(x)*S(y) component
bs = bkg_x * signal_y2

# B(x)*S(y)+ S(x)*B(y) component
sb_cmp = sb + bs

# B(x)*B(y) component
def test_fitting_components_3D():

    logger = getLogger('test_fitting_components_3D')
    ## make simple test mass
    m_x = ROOT.RooRealVar('mass_x', 'Some test mass(X)', 0, 10)
    m_y = ROOT.RooRealVar('mass_y', 'Some test mass(Y)', 0, 10)
    m_z = ROOT.RooRealVar('mass_z', 'Some test mass(z)', 0, 10)

    ## book very simple data set
    varset = ROOT.RooArgSet(m_x, m_y, m_z)
    dataset = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset)

    m1 = VE(3, 0.10**2)
    m2 = VE(7, 0.20**2)

    ## fill it

    N_sss = 5000
    N_ssb = 500
    N_sbs = 500
    N_bss = 1000

    N_bbs = 500
    N_bsb = 100
    N_sbb = 100

    N_bbb = 250

    random.seed(0)

    ## fill it : 5000 events  Gauss * Gauss *Gauss
    for m in (m1, m2):

        ##  S x S x S
        for i in range(N_sss):

            m_x.value = m.gauss()
            m_y.value = m.gauss()
            m_z.value = m.gauss()

            dataset.add(varset)

        ## S x S x B
        for i in range(0, N_bss):

            m_x.value = m.gauss()
            m_y.value = m.gauss()
            m_z.value = random.uniform(*m_z.minmax())

            dataset.add(varset)

        ## S x B x S
        for i in range(N_ssb):

            m_x.value = m.gauss()
            m_y.value = random.uniform(*m_y.minmax())
            m_z.value = m.gauss()

            dataset.add(varset)

        ## B x S x S
        for i in range(N_sbs):
            m_x.value = random.uniform(*m_x.minmax())
            m_y.value = m.gauss()
            m_z.value = m.gauss()
            dataset.add(varset)

        ## B x B X S
        for i in range(N_sbb):

            m_x.value = random.uniform(*m_x.minmax())
            m_y.value = random.uniform(*m_y.minmax())
            m_z.value = m.gauss()
            dataset.add(varset)

        ## B  x S x B
        for i in range(N_bsb):

            m_x.value = random.uniform(*m_x.minmax())
            m_y.value = m.gauss()
            m_z.value = random.uniform(*m_y.minmax())
            dataset.add(varset)

        ## S x B x B
        for i in range(N_sbb):

            m_x.value = m.gauss()
            m_y.value = random.uniform(*m_y.minmax())
            m_z.value = random.uniform(*m_y.minmax())

            dataset.add(varset)

        ## B x B x B
        for i in range(N_bbb):

            m_x.value = random.uniform(*m_x.minmax())
            m_y.value = random.uniform(*m_y.minmax())
            m_z.value = random.uniform(*m_y.minmax())

            dataset.add(varset)

    logger.info('Dataset:\n%s' % dataset.table(prefix='# '))

    ## various fit components for main fit model :

    signal_x1 = Models.Gauss_pdf('G1x',
                                 xvar=m_x,
                                 mean=m1.value(),
                                 sigma=m1.error())
    signal_y1 = signal_x1.clone(name='G1y', xvar=m_y)
    signal_z1 = signal_x1.clone(name='G1z', xvar=m_z)

    bkg_x = make_bkg(-1, 'Bx', m_x)
    bkg_y = bkg_x.clone(name='By', xvar=m_y)
    bkg_z = bkg_x.clone(name='Bz', xvar=m_z)

    ## construct other components

    signal_x2 = Models.Gauss_pdf(name='G2x',
                                 xvar=m_x,
                                 mean=m2.value(),
                                 sigma=m2.error())
    signal_y2 = signal_x2.clone(name='G2y', xvar=m_y)
    signal_z2 = signal_x2.clone(name='G2z', xvar=m_z)

    ## S(x) * S(y) components
    ss_cmp = signal_x2 * signal_y2

    ## S(x) * B(y) component
    sb_cmp = signal_x2 * bkg_y

    ## B(x) * S(y) component
    bs_cmp = bkg_x * signal_y2

    ## B(x) * B(y) component
    bb_cmp = bkg_x * bkg_y

    ## S(x) * S(y) * S(z) component
    sss_cmp = ss_cmp * signal_z2

    ## S(x) * S(y) * B(z) component
    ssb_cmp = ss_cmp * bkg_z

    ## S(x) * B(y) * S(z) component
    sbs_cmp = sb_cmp * signal_z2

    ## S(x) * B(y) * S(z) component
    bss_cmp = bs_cmp * signal_z2

    ## S(x) * B(y) * B(z) component
    sbb_cmp = sb_cmp * bkg_z

    ## B(x) * S(y) * B(z) component
    bsb_cmp = bs_cmp * bkg_z

    ## B(x) * B(y) * S(z) component
    bbs_cmp = bs_cmp * signal_z2

    model = Models.Fit3D(
        name='fit_comp',
        signal_x=signal_x1,
        signal_y=signal_y1,
        signal_z=signal_z1,
        bkg_1x=bkg_x,
        bkg_1y=bkg_y,
        bkg_1z=bkg_z,
        suffix="_1",
        ##
        components=[
            sss_cmp, ssb_cmp, sbs_cmp, bss_cmp, sbb_cmp, bsb_cmp, bbs_cmp
        ])

    model.SSS = N_sss

    model.SSB = N_ssb
    model.SBS = N_sbs
    model.BSS = N_bss

    model.BBS = N_bbs
    model.BSB = N_bsb
    model.SBB = N_sbb

    model.BBB = N_bbb

    model.C = N_sss, N_ssb, N_sbs, N_sbb, N_bss, N_sbs, N_bbs

    r = model.fitTo(dataset, silent=True)
    r = model.fitTo(dataset, silent=True)

    with use_canvas('test_fitting_components_3D'):
        with wait(2):
            model.draw1(dataset)
        with wait(2):
            model.draw2(dataset)
        with wait(2):
            model.draw3(dataset)

    logger.info('Model %s Fit result\n%s ' %
                (model.name, r.table(prefix='# ')))
Example #3
0
def test_fitting_in_range_2d():

    logger = getLogger('test_fitting_in_range_2d')
    ## make simple test mass
    m_x = ROOT.RooRealVar('m_x', 'Some test mass(X)', 0, 5)
    m_y = ROOT.RooRealVar('m_y', 'Some test mass(Y)', 6, 10)

    ## book very simple data set
    varset = ROOT.RooArgSet(m_x, m_y)
    dataset = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset)

    m1 = VE(3, 0.10**2)
    m2 = VE(7, 0.10**2)

    ## fill it with three gausissians, 5k events each
    N_ss = 5000
    N_sb = 1000
    N_bs = 500
    N_bb = 100

    random.seed(0)

    ## S x S
    for i in range(N_ss):
        m_x.value = m1.gauss()
        m_y.value = m2.gauss()
        dataset.add(varset)

    ## S x B
    for i in range(N_sb):
        m_x.value = m1.gauss()
        m_y.value = random.uniform(*m_y.minmax())
        dataset.add(varset)

    ## B x S
    for i in range(N_bs):
        m_x.value = random.uniform(*m_x.minmax())
        m_y.value = m2.gauss()
        dataset.add(varset)

    ## B x B
    for i in range(N_bb):
        m_x.value = random.uniform(*m_x.minmax())
        m_y.value = random.uniform(*m_y.minmax())
        dataset.add(varset)

    logger.info('Dataset:\n%s' % dataset.table(prefix='# '))

    ## various fit components
    signal_x1 = Models.Gauss_pdf('G1x',
                                 xvar=m_x,
                                 mean=m1.value(),
                                 sigma=m1.error())
    signal_y1 = Models.Gauss_pdf(name='G1y',
                                 xvar=m_y,
                                 mean=m2.value(),
                                 sigma=m2.error())

    bkg_x = make_bkg(-1, 'Bx', m_x)
    bkg_y = make_bkg(-1, name='By', xvar=m_y)

    ## build fit model
    model = Models.Fit2D(name='fit_comp',
                         signal_x=signal_x1,
                         signal_y=signal_y1,
                         bkg_1x=bkg_x,
                         bkg_1y=bkg_y)
    model.SS = N_ss
    model.SB = N_sb
    model.BS = N_bs
    model.BB = N_bb

    r = model.fitTo(dataset, silent=True)
    r = model.fitTo(dataset, silent=True)

    dataset.m_y.setRange('fit', 8, 10.)
    model.yvar.setRange('fit', 8, 10.)

    with use_canvas('test_fitting_in_range_2d'):
        with wait(2):
            model.draw1(dataset, nbins=200, in_range=(6, 8))
        with wait(2):
            model.draw1(dataset, nbins=200, in_range='fit')

    dataset.m_x.setRange('fit2', 0, 2.5)
    model.xvar.setRange('fit2', 0, 2.5)

    with use_canvas('test_fitting_in_range_2d'):
        with wait(2):
            model.draw2(dataset, nbins=200, in_range=(2.5, 5))
        with wait(2):
            model.draw2(dataset, nbins=200, in_range='fit2')
Example #4
0
## various fit components
signal_x1 = Models.Gauss_pdf('G1x',
                             xvar=m_x,
                             mean=m1.value(),
                             sigma=m1.error())
signal_y1 = Models.Gauss_pdf(name='G1y',
                             xvar=m_y,
                             mean=m2.value(),
                             sigma=m2.error())
signal_z1 = Models.Gauss_pdf(name='G1z',
                             xvar=m_z,
                             mean=m3.value(),
                             sigma=m3.error())

bkg_x = make_bkg(-1, 'Bx', m_x)
bkg_y = make_bkg(-1, name='By', xvar=m_y)
bkg_z = make_bkg(-1, name='Bz', xvar=m_z)

model = Models.Fit3D(
    name='fit_comp',
    signal_x=signal_x1,
    signal_y=signal_y1,
    signal_z=signal_z1,
    bkg_1x=bkg_x,
    bkg_1y=bkg_y,
    bkg_1z=bkg_z,
)
with rooSilent():
    ## components
    model.SSS.setVal(5000)
def test_fitting_in_range_3d():

    logger = getLogger('test_fitting_in_range_3d')

    ## make simple test mass
    m_x = ROOT.RooRealVar('m_x', 'Some test mass(X)', 0, 5)
    m_y = ROOT.RooRealVar('m_y', 'Some test mass(Y)', 6, 10)
    m_z = ROOT.RooRealVar('m_z', 'Some test mass(z)', 10, 15)

    ## book very simple data set
    varset = ROOT.RooArgSet(m_x, m_y, m_z)
    dataset = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset)

    m1 = VE(3, 0.10**2)
    m2 = VE(7, 0.10**2)
    m3 = VE(12, 0.10**2)

    N_sss = 5000
    N_ssb = 5000
    N_sbs = 5000
    N_sbb = 1000

    N_bss = 500
    N_bsb = 100
    N_bbs = 100
    N_bbb = 250

    random.seed(0)

    ## S x S x S
    for i in range(N_sss):
        m_x.value = m1.gauss()
        m_y.value = m2.gauss()
        m_z.value = m3.gauss()
        dataset.add(varset)

    ## S x S x B
    for i in range(N_ssb):
        m_x.value = m1.gauss()
        m_y.value = m2.gauss()
        m_z.value = random.uniform(*m_z.minmax())
        dataset.add(varset)

    ## S x B x S
    for i in range(N_sbs):
        m_x.value = m1.gauss()
        m_y.value = random.uniform(*m_y.minmax())
        m_z.value = m3.gauss()
        dataset.add(varset)

    ## B x S x S
    for i in range(N_bss):
        m_x.value = random.uniform(*m_x.minmax())
        m_y.value = m2.gauss()
        m_z.value = m3.gauss()
        dataset.add(varset)

    ## S x B x B
    for i in range(N_sbb):
        m_x.value = m1.gauss()
        m_y.value = random.uniform(*m_y.minmax())
        m_z.value = random.uniform(*m_z.minmax())
        dataset.add(varset)

    ## B x S x B
    for i in range(N_bsb):
        m_x.value = random.uniform(*m_x.minmax())
        m_y.value = m2.gauss()
        m_z.value = random.uniform(*m_z.minmax())
        dataset.add(varset)

    ## B x B x S
    for i in range(N_bbs):
        m_x.value = random.uniform(*m_x.minmax())
        m_y.value = random.uniform(*m_y.minmax())
        m_z.value = m3.gauss()
        dataset.add(varset)

    ## B x B x B
    for i in range(N_bbb):
        m_x.value = random.uniform(*m_x.minmax())
        m_y.value = random.uniform(*m_y.minmax())
        m_z.value = random.uniform(*m_z.minmax())
        dataset.add(varset)

    logger.info('Dataset:\n%s' % dataset.table(prefix='# '))

    signal_x1 = Models.Gauss_pdf('G1x',
                                 xvar=m_x,
                                 mean=m1.value(),
                                 sigma=m1.error())
    signal_y1 = Models.Gauss_pdf(name='G1y',
                                 xvar=m_y,
                                 mean=m2.value(),
                                 sigma=m2.error())
    signal_z1 = Models.Gauss_pdf(name='G1z',
                                 xvar=m_z,
                                 mean=m3.value(),
                                 sigma=m3.error())

    bkg_x = make_bkg(-1, 'Bx', m_x)
    bkg_y = make_bkg(-1, name='By', xvar=m_y)
    bkg_z = make_bkg(-1, name='Bz', xvar=m_z)

    model = Models.Fit3D(
        name='fit_comp',
        signal_x=signal_x1,
        signal_y=signal_y1,
        signal_z=signal_z1,
        bkg_1x=bkg_x,
        bkg_1y=bkg_y,
        bkg_1z=bkg_z,
    )

    model.SSS = N_sss
    model.SSB = N_ssb
    model.SBS = N_sbs
    model.BSS = N_bss
    model.SBB = N_sbb
    model.BSB = N_bsb
    model.BBS = N_bbs
    model.BBB = N_bbb

    r = model.fitTo(dataset, silent=True)
    r = model.fitTo(dataset, silent=True)

    dataset.m_y.setRange('fit', 6, 8.)
    model.yvar.setRange('fit', 6, 8.)

    t = 1.0

    with use_canvas('test_fitting_in_range_3d'):
        with wait(t):
            model.draw1(dataset,
                        nbins=200,
                        in_range3=(11, 12),
                        in_range2=(8, 10))
        with wait(t):
            model.draw1(dataset,
                        nbins=200,
                        in_range3=(11, 12),
                        in_range2='fit')
        with wait(t):
            model.draw1(dataset, nbins=200, in_range3=(11, 12))
        with wait(t):
            model.draw1(dataset, nbins=200, in_range2='fit')

    dataset.m_x.setRange('fit2', 2.5, 3.)
    model.xvar.setRange('fit2', 2.5, 3.)

    with use_canvas('test_fitting_in_range_3d'):
        with wait(t):
            model.draw2(dataset,
                        nbins=200,
                        in_range3=(11, 12),
                        in_range1=(0, 3))
        with wait(t):
            model.draw2(dataset,
                        nbins=200,
                        in_range3=(11, 12),
                        in_range1='fit2')
        with wait(t):
            model.draw2(dataset, nbins=200, in_range3=(11, 12))
        with wait(t):
            model.draw2(dataset, nbins=200, in_range1='fit2')

    dataset.m_x.setRange('fit3', 2.5, 3.)
    model.xvar.setRange('fit3', 2.5, 3.)

    with use_canvas('test_fitting_in_range_3d'):
        with wait(t):
            model.draw3(dataset, nbins=200, in_range2=(6, 8), in_range1=(0, 3))
        with wait(t):
            model.draw3(dataset, nbins=200, in_range2=(6, 8), in_range1='fit3')
        with wait(t):
            model.draw3(dataset, nbins=200, in_range2=(6, 8))
        with wait(t):
            model.draw3(dataset, nbins=200, in_range1='fit3')
Example #6
0
def test_fitting_components3_3D () :


    logger = getLogger( 'test_fitting_components3_3D' )
    
    ## make simple test mass 
    m_x     = ROOT.RooRealVar ( 'mass_x' , 'Some test mass(X)' , 0 , 10 )
    m_y     = ROOT.RooRealVar ( 'mass_y' , 'Some test mass(Y)' , 0 , 10 )
    m_z     = ROOT.RooRealVar ( 'mass_z' , 'Some test mass(z)' , 0 , 10 )

    ## book very simple data set
    varset  = ROOT.RooArgSet  ( m_x , m_y,m_z )
    dataset = ROOT.RooDataSet ( dsID() , 'Test Data set-1' , varset )  
    
    
    m1 = VE ( 3 , 0.10**2 )
    m2 = VE ( 7 , 0.20**2 )
    
    ## fill it with three gausissians, 5k events each
    N_sss = 5000
    N_ssb =  500
    N_sbs =  N_ssb
    N_bss =  N_ssb 
    
    N_bbs =  100
    N_bsb =  N_bbs
    N_sbb =  N_bbs 

    N_bbb =  500 
    
    random.seed(0)
    ## fill it : 5000 events  Gauss * Gauss *Gauss
    for m in (m1,m2) :

        ##  S x S x S 
        for i in range ( N_sss ) :
            
            m_x.value = m.gauss() 
            m_y.value = m.gauss() 
            m_z.value = m.gauss()
            
            dataset.add ( varset  )
            
        ## S x S x B 
        for i in range(0,N_bss) :
            
            m_x.value = m.gauss() 
            m_y.value = m.gauss() 
            m_z.value = random.uniform ( *m_z.minmax() )
            
            dataset.add ( varset  )
            
        ## S x B x S 
        for i in range ( N_ssb ) :
            
            m_x.value = m.gauss() 
            m_y.value = random.uniform ( *m_y.minmax() )  
            m_z.value = m.gauss() 
            
            dataset.add ( varset  )

        ## B x S x S 
        for i in range ( N_sbs ) : 
            m_x.value = random.uniform ( *m_x.minmax() ) 
            m_y.value = m.gauss() 
            m_z.value = m.gauss() 
            dataset.add ( varset  )

            
        ## B x B X S  
        for i in range ( N_sbb ) :
            
            m_x.value  = random.uniform ( *m_x.minmax() )
            m_y.value  = random.uniform ( *m_y.minmax() )
            m_z.value = m.gauss() 
            dataset.add ( varset  )

        ## B  x S x B 
        for i in range ( N_bsb ) : 

            m_x.value = random.uniform ( *m_x.minmax() ) 
            m_y.value = m.gauss() 
            m_z.value = random.uniform ( *m_y.minmax() )
            dataset.add ( varset  )

        ## S x B x B 
        for i in range ( N_sbb ) :
            
            m_x.value = m.gauss() 
            m_y.value = random.uniform ( *m_y.minmax() )  
            m_z.value = random.uniform ( *m_y.minmax() )
            
            dataset.add ( varset  )

        ## B x B x B 
        for i in range ( N_bbb ) :
            
            m_x.value  = random.uniform ( *m_x.minmax() )
            m_y.value  = random.uniform ( *m_y.minmax() )
            m_z.value = random.uniform ( *m_y.minmax() )
            
            dataset.add ( varset  )
            
    logger.info ('Dataset:\n%s' % dataset.table ( prefix = '# ') )   


    
    ## various fit components
    signal_x1 = Models.Gauss_pdf ( 'G1x'  , xvar = m_x  , mean = m1.value() , sigma = m1.error() )  
    signal_y1 = signal_x1.clone  ( name='G1y'  , xvar = m_y   ) 
    signal_z1 = signal_x1.clone  ( name='G1z'  , xvar = m_z   )
    
    bkg_x     = make_bkg ( -1      , 'Bx' , m_x )
    bkg_y     =  bkg_x.clone ( name= 'By' , xvar =m_y )
    bkg_z     = bkg_x.clone ( name='Bz' , xvar =m_z )
    
    signal_x2 = Models.Gauss_pdf ( name='G2x'  , xvar = m_x  , mean = m2.value() , sigma = m2.error() )  
    signal_y2 = signal_x2.clone ( name='G2y'  , xvar = m_y   ) 
    signal_z2 = signal_x2.clone ( name='G2z'  , xvar = m_z   )


    # S(x) * S(y) component 
    ss_cmp = signal_x2 * signal_y2
    
    # S(x) * B(y) component 
    sb_cmp = signal_x2 * bkg_y

    # B(x) * S(y) component 
    bs_cmp = bkg_x * signal_y2
    
    # B(x) * B(y) component 
    bb_cmp = bkg_x * bkg_y

    # S(x)*S(y)*S(z) component
    sss_cmp = ss_cmp * signal_z2

    # S(x) * B(y) * S(z) + B(x) * S(y) * S(z) + S(x) * S(y) * B(z) component
    ssb_    = ss_cmp * bkg_z
    sbs_    = sb_cmp * signal_z2
    bss_    = bs_cmp * signal_z2

    ssb_cmp = ssb_ + ( sbs_ , bss_ ) 

    # S(x)*B(y)*B(z) + B(x)*S(y)*B(z) + B(x)*B(y)*S(z) component
    sbb_ = sb_cmp * bkg_z
    bsb_ = bs_cmp * bkg_z
    bbs_ = bb_cmp * signal_z2 

    bbs_cmp = sbb_ + (  bsb_ ,  bbs_ ) 

    logger.info ('Test  multi-component  3d Sym fit')
    
    model = Models.Fit3DMix (
        name    = 'fitSym_comp', 
        signal_x    = signal_x1, 
        signal_y    = signal_y1,
        signal_z    = signal_z1,
        bkg_1x  = bkg_x ,
        bkg_1y= bkg_y,
        bkg_2x  = 'clone' ,
        bkg_2y= 'clone',
        components  = [ sss_cmp , ssb_cmp , bbs_cmp  ]
        )
    
    ## components        
    model.SSS = N_sss 
    model.SSB = N_ssb * 3 
    model.SBB = N_sbb * 3 
    model.BBB = N_bbb 
    
    model.C  = N_sss, N_ssb * 3 , N_sbb * 3
    
    r = model.fitTo ( dataset , silent = True  )
    r = model.fitTo ( dataset , silent = True  )
    r = model.fitTo ( dataset , silent = True  )

    
    with use_canvas ( 'test_fitting_components3_3D' ) : 
        
        with wait ( after = 2 ) : model.draw1 ( dataset )
        with wait ( after = 2 ) : model.draw2 ( dataset )
        with wait ( after = 2 ) : model.draw3 ( dataset )
        
    logger.info ( 'Model %s Fit result\n%s ' % ( model.name , r.table (prefix = '# ') ) )