Difference: AnalysisTips (1 vs. 14)

Revision 142015-09-18 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

usage of git hub

Changed:
<
<
  • git cms-addpkg PhysicsTools?/PatAlgos
>
>
  • git cms-addpkg PhysicsTools/!PatAlgos
Added:
>
>
  • git clone "https://github.com/CMS-HIN-dilepton/Dimuons"
 

Way to copy the sample from different site

voms-proxy-init
xrdcp root://cmseos.fnal.gov//store/user/benwu/CMSDAS/DoubleMu/crab_CMSDAS_Data_analysis_test0/141126_235113/0000/slimMiniAOD_data_MuEle_1.root .

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

So, total uncertainty = sqrt( (2*eA_1/A_1)^2 + (2*eA_2/A_2)^2 + (2*eA_2/A_2)^2 ) // for the cases of three efficiencies.

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[<T_NN>(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0<cent<5| * (d^2_N)/(d_pt * d_eta)]/[<1/N_coll>|40<cent<60| * (d^2_N)/(d_pt * d_eta)]\

Python Tip

  • 255 arguments error
 readFiles = cms.untracked.vstring()
 readFiles.extend( [
     '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root'
 ] );
   
 process.source = cms.Source("PoolSource",
     fileNames = readFiles
 )

pPb collision energy calculation

sqrt(sNN) = 2*sqrt(E_p * E_pPb) = 2*sqrt(4 * 4 * 82 / 208) = 5.02 TeV

-- DongHoMoon - 03 Dec 2010

Revision 132015-09-15 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Added:
>
>

usage of git hub

  • git cms-addpkg PhysicsTools?/PatAlgos
 

Way to copy the sample from different site

voms-proxy-init
xrdcp root://cmseos.fnal.gov//store/user/benwu/CMSDAS/DoubleMu/crab_CMSDAS_Data_analysis_test0/141126_235113/0000/slimMiniAOD_data_MuEle_1.root .

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

So, total uncertainty = sqrt( (2*eA_1/A_1)^2 + (2*eA_2/A_2)^2 + (2*eA_2/A_2)^2 ) // for the cases of three efficiencies.

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[<T_NN>(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0<cent<5| * (d^2_N)/(d_pt * d_eta)]/[<1/N_coll>|40<cent<60| * (d^2_N)/(d_pt * d_eta)]\

Python Tip

  • 255 arguments error
 readFiles = cms.untracked.vstring()
 readFiles.extend( [
     '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root'
 ] );
   
 process.source = cms.Source("PoolSource",
     fileNames = readFiles
 )

pPb collision energy calculation

sqrt(sNN) = 2*sqrt(E_p * E_pPb) = 2*sqrt(4 * 4 * 82 / 208) = 5.02 TeV

-- DongHoMoon - 03 Dec 2010

Revision 122015-07-27 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Added:
>
>

Way to copy the sample from different site

voms-proxy-init
xrdcp root://cmseos.fnal.gov//store/user/benwu/CMSDAS/DoubleMu/crab_CMSDAS_Data_analysis_test0/141126_235113/0000/slimMiniAOD_data_MuEle_1.root .
 

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

So, total uncertainty = sqrt( (2*eA_1/A_1)^2 + (2*eA_2/A_2)^2 + (2*eA_2/A_2)^2 ) // for the cases of three efficiencies.

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[<T_NN>(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0<cent<5| * (d^2_N)/(d_pt * d_eta)]/[<1/N_coll>|40<cent<60| * (d^2_N)/(d_pt * d_eta)]\

Python Tip

  • 255 arguments error
 readFiles = cms.untracked.vstring()
 readFiles.extend( [
     '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root'
 ] );
   
 process.source = cms.Source("PoolSource",
     fileNames = readFiles
 )

pPb collision energy calculation

sqrt(sNN) = 2*sqrt(E_p * E_pPb) = 2*sqrt(4 * 4 * 82 / 208) = 5.02 TeV

-- DongHoMoon - 03 Dec 2010

Revision 112013-03-08 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

Added:
>
>
So, total uncertainty = sqrt( (2*eA_1/A_1)^2 + (2*eA_2/A_2)^2 + (2*eA_2/A_2)^2 ) // for the cases of three efficiencies.
 

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[<T_NN>(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0<cent<5| * (d^2_N)/(d_pt * d_eta)]/[<1/N_coll>|40<cent<60| * (d^2_N)/(d_pt * d_eta)]\

Python Tip

  • 255 arguments error
 readFiles = cms.untracked.vstring()
 readFiles.extend( [
     '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root'
 ] );
   
 process.source = cms.Source("PoolSource",
     fileNames = readFiles
 )

pPb collision energy calculation

sqrt(sNN) = 2*sqrt(E_p * E_pPb) = 2*sqrt(4 * 4 * 82 / 208) = 5.02 TeV

-- DongHoMoon - 03 Dec 2010

Revision 102013-01-16 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[<T_NN>(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0<cent<5| * (d^2_N)/(d_pt * d_eta)]/[<1/N_coll>|40<cent<60| * (d^2_N)/(d_pt * d_eta)]\

Python Tip

  • 255 arguments error
 readFiles = cms.untracked.vstring()
 readFiles.extend( [
     '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root'
 ] );
   
 process.source = cms.Source("PoolSource",
     fileNames = readFiles
 )
Added:
>
>

pPb collision energy calculation

sqrt(sNN) = 2*sqrt(E_p * E_pPb) = 2*sqrt(4 * 4 * 82 / 208) = 5.02 TeV
 

-- DongHoMoon - 03 Dec 2010

Revision 92013-01-07 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

R_AA

  • yield of Z / normalized Z yield in pp collisons
Changed:
<
<

>
>
  R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)] T_NN : nuclear overlap function = N_coll/crX_pp
Changed:
<
<
>
>
 
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
Changed:
<
<

>
>
  R_cp =[<1/N_coll>|0<cent<5| * (d^2_N)/(d_pt * d_eta)]/[<1/N_coll>|40<cent<60| * (d^2_N)/(d_pt * d_eta)]
Changed:
<
<
>
>
 

Python Tip

  • 255 arguments error
Changed:
<
<

>
>
  readFiles = cms.untracked.vstring() readFiles.extend( [ '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root' ] );

process.source = cms.Source("PoolSource", fileNames = readFiles )

Changed:
<
<
>
>
  -- DongHoMoon - 03 Dec 2010

Revision 82013-01-05 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0|40
Changed:
<
<

Python

>
>
Added:
>
>

Python Tip

 
  • 255 arguments error
 readFiles = cms.untracked.vstring()
 readFiles.extend( [
     '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root'
 ] );
   
 process.source = cms.Source("PoolSource",
     fileNames = readFiles
 )

-- DongHoMoon - 03 Dec 2010

Revision 72013-01-05 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0|40
Added:
>
>

Python

  • 255 arguments error
 readFiles = cms.untracked.vstring()
 readFiles.extend( [
     '/store/data/BeamCommissioning08/BeamHalo/RECO/CRUZET4_V4P_CSCSkim_trial_v3/0000/00BEE8CD-1181-DD11-8F58-001A4BA82F4C.root'
 ] );
   
 process.source = cms.Source("PoolSource",
     fileNames = readFiles
 )
  -- DongHoMoon - 03 Dec 2010

Revision 62012-07-06 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

   Dividing error:
   y = f/g >> dy = (f/g)' = f'/g - g'/g^2 
   dy/y = (f/g)'/(f/g) = f'/f -g'/g 
   | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
   final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y

Added:
>
>

efficiency of pair

The factor 2 comes from the from the fact that the two single muon efficiencies that make the pair efficiency are fully correlated. 
In that case the uncertainty on pair is just the sum of the uncertainties on the single efficiency. You can also simply derive it like this:

for eff_pair = eff_single^2

-> err_pair = sqrt( (deff_pair/deff_single)^2 err_single^2 )
                    = sqrt( (2*eff_single)^2*err_single^2)
                    = 2*eff_single*err_single

that's the expression for the absolute uncertainty, to get the relative uncertainty, we just divide by eff_pair

-> err_pair/eff_pair = 2*eff_single*err_single/(eff_single^2)
                                   = 2*err_single/eff_single


sqrt((eA/A)^2 + (eA/A)^2 + 2 (eA/A)^2) = sqrt( 4*(eA/A)^2 ) = 2 * eA/A

 

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0|40

-- DongHoMoon - 03 Dec 2010

Revision 52012-03-23 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g

   |dy| = sqrt( (df/f)^2 + (dg/g)^2 )

Changed:
<
<
final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )
>
>
final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y
  Therefore the error bar of multiplied two variables is sum of the each error of those.

Dividing error: y = f/g >> dy = (f/g)' = f'/g - g'/g^2 dy/y = (f/g)'/(f/g) = f'/f -g'/g | dy | = sqrt( (df/f)^2 + (dg/g)^2 )

Changed:
<
<
final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )
>
>
final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )*y
 

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0|40

-- DongHoMoon - 03 Dec 2010

Revision 42011-11-23 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f

Changed:
<
<
dy/y = df/f + dg/g = Err_f + Err_g
>
>
dy/y = df/f + dg/g
 
Added:
>
>
|dy| = sqrt( (df/f)^2 + (dg/g)^2 ) final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )
  Therefore the error bar of multiplied two variables is sum of the each error of those.

Dividing error:

Changed:
<
<
(x + dx)/(y + dy) = q + dq, q = x/y dq/q = dx/x + dy/y, dq = (dx/x + dy/y)*q dq = (dx/x + dy/y)x/y
>
>
y = f/g >> dy = (f/g)' = f'/g - g'/g^2 dy/y = (f/g)'/(f/g) = f'/f -g'/g | dy | = sqrt( (df/f)^2 + (dg/g)^2 )
Added:
>
>
final value is y + | dy | = y + sqrt( (df/f)^2 + (dg/g)^2 )
 
Deleted:
<
<
so, (x + dx)/(y + dy) = q + (dx/x + dy/y)*q

 

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0|40

-- DongHoMoon - 03 Dec 2010

Revision 32011-11-23 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g = Err_f + Err_g

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

Added:
>
>
Dividing error: (x + dx)/(y + dy) = q + dq, q = x/y dq/q = dx/x + dy/y, dq = (dx/x + dy/y)*q dq = (dx/x + dy/y)x/y

so, (x + dx)/(y + dy) = q + (dx/x + dy/y)*q

 

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0|40

-- DongHoMoon - 03 Dec 2010

Revision 22010-12-14 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g = Err_f + Err_g

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.
Changed:
<
<
>
>
Added:
>
>

R_AA

  • yield of Z / normalized Z yield in pp collisons
   R_AA = [(d^2_N)/(d_pt * d_eta)]/[(d^2_crX/d_pt*d_eta)]
   T_NN : nuclear overlap function
   = N_coll/crX_pp
  • 1/(2pi*pT) : invariant factor

R_cp

  • (yield of Z in the central collisions)/(yield of Z in the peripheral collisions)
   R_cp =[<1/N_coll>|0|40
 

-- DongHoMoon - 03 Dec 2010

Revision 12010-12-03 - DongHoMoon

 
META TOPICPARENT name="MDH0000"

Useful Analysis Tips

Error bar estimation of Two efficiency multiply

   y = f * g (f : Eff1, g : Eff2)
   dy = (@y/@f)df + (@y/@g)dg
   
   Relative error
   dy/y = [(@y/@f)df + (@y/@g)dg]/fg
   here, y = f*g, so (@y/@f) = g, (@y/@g) = f
   dy/y = df/f + dg/g = Err_f + Err_g

   Therefore
   the error bar of multiplied two variables
   is sum of the each error of those.

-- DongHoMoon - 03 Dec 2010

 
This site is powered by the TWiki collaboration platform Powered by Perl This site is powered by the TWiki collaboration platformCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding KoreaCmsWiki? Send feedback