Difference: AnalysisTips (1 vs. 14)

Useful Analysis Tips

usage of git hub

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

Useful Analysis Tips

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

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

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

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
 )

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

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
 )

-- DongHoMoon - 03 Dec 2010

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

• 1/(2pi*pT) : invariant factor

R_cp

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

Python Tip

• 255 arguments error

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

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

• 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

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

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

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

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 )

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 )

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

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

Dividing error:

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

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.

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

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

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