SCT parametric simulation

From Charm-Tau Detector
(Difference between revisions)
Jump to: navigation, search
(Configure example)
(Configure example)
Line 1: Line 1:
 
= Configure example =
 
= Configure example =
  
There is an example of running the entire chain from generating particles to running an analysis tool. A more detailed description of the algorithms and their parameters is presented below.
+
There are some examples to run the parametric simulation
 
+
{| class="wikitable"
<pre>
+
|-
from Configurables import ApplicationMgr
+
! Using tools
 
+
! Link
from Gaudi.Configuration import *
+
|-
from Configurables import GenAlg, EvtGenInterface
+
| Read from a ROOT-file, write to a ROOT-file
from Configurables import HepMCToEDMConverter
+
| [https://git.inp.nsk.su/sctau/aurora/-/blob/master/Simulation/SctParSimAlg/jobOptions/sctparsim_test_read.py sctparsim_test_read.py]
from Configurables import ScTauDataSvc
+
|-
 
+
| Generate using the particle gun, write to a ROOT-file
from Configurables import Gaudi__ParticlePropertySvc
+
| [https://git.inp.nsk.su/sctau/aurora/-/blob/master/Simulation/SctParSimAlg/jobOptions/sctparsim_test_particle_gun.py sctparsim_test_particle_gun.py]
from PathResolver import PathResolver
+
|-
 
+
| Generate using <code>EvtGen</code>, write to a ROOT-file
############################
+
| [https://git.inp.nsk.su/sctau/aurora/-/blob/master/Simulation/SctParSimAlg/jobOptions/sctparsim_test_evtgen.py sctparsim_test_evtgen.py]
####  Event generation  ####
+
|-
############################
+
| Generate using <code>EvtGen</code>, use the analysis tool
podioevent = ScTauDataSvc("EventDataSvc")
+
| [https://git.inp.nsk.su/sctau/aurora/-/blob/master/Simulation/SctParSimAlg/jobOptions/sct_run_test_analisis.py sct_run_test_analisis.py]
 
+
|}
# Particle service
+
particlePropertySvc = Gaudi__ParticlePropertySvc(
+
    "ParticlePropertySvc",
+
    ParticlePropertiesFile=PathResolver.FindDataFile('GenParticleData/ParticleTable.txt')
+
)
+
 
+
# EvtGen
+
evtgen = EvtGenInterface('SignalProvider')
+
#evtgen.userdec = "./mydec.dec"
+
#evtgen.rootParticle = "J/psi"
+
 
+
gen = GenAlg('EvtGenAlg', SignalProvider=evtgen)
+
gen.hepmc.Path = 'hepmc'
+
 
+
# HepMC3 to PODIO
+
edm = HepMCToEDMConverter("Converter")
+
edm.hepmc.Path=gen.hepmc.Path
+
edm.genparticles.Path="allGenParticles"
+
edm.genvertices.Path="allGenVertices"
+
 
+
############################
+
# SctParSim
+
############################
+
from Configurables import SctParSimAlg
+
 
+
sct_alg = SctParSimAlg('SctAlg')
+
#sct_alg.CaloSystemTool.caloClSizeEGamma = 0.2 # Example how to change a subsystem parameter
+
 
+
############################
+
# Podio output
+
############################
+
out = PodioOutput('out', filename=ofile)
+
out.outputCommands = ["keep *"]
+
 
+
############################       
+
# Analisis                         
+
############################
+
from Configurables import EventLoader
+
from Configurables import NtupleAlg, NTupleSvc
+
from Configurables import ParticleCombinerAlg
+
 
+
evlo = EventLoader('EvtLoader')
+
evlo.pcl.Path = 'Particles' # Branch (in the input ROOT-file) for reading
+
evlo.pListMap.Path = 'Lists1'
+
evlo.plists = [['gamma']] # Partilce list for further analisis
+
 
+
# Select particle combinations     
+
cmbr = ParticleCombinerAlg('Cmbr',
+
    decStr = 'pi0 -> gamma gamma', # Investigated decay
+
    cutStr = 'E > 0.5', # Selection criteria
+
    selfConj = True # if neutral particle True, else False
+
)
+
 
+
cmbr.pListMapI = evlo.pListMap.Path
+
cmbr.pListMapO.Path = 'Lists2'
+
 
+
# Select variables to save to n-tuple
+
tupl = NtupleAlg('piTuple')
+
tupl.listName = 'pi0'
+
tupl.fileName = 'scttuple/tup'
+
 
+
# List contains the particle parametes to write an output file
+
tupl.vars = [['px_mc', 'py_mc', 'pz_mc', 'E', 'pi0 -> ^gamma ^gamma'],
+
    ['M', ''],
+
]
+
 
+
tupl.pListMapI.Path = cmbr.pListMapO.Path
+
NTupleSvc(Output = ["scttuple DATAFILE='tup.root' OPT='NEW' TYP='ROOT'"])
+
 
+
 
+
############################       
+
# Running algorithms               
+
############################
+
 
+
options= {
+
    'TopAlg' : [gen, edm, sct_alg, evlo, cmbr, tupl, out],
+
    'EvtSel' : 'NONE',
+
    'ExtSvc' : [particlePropertySvc, podioevent],
+
    'EvtMax' : 10000,
+
    'StatusCodeCheck' : True,
+
    'AuditAlgorithms' : True,
+
    'AuditTools'      : True,
+
    'AuditServices'  : True,
+
    'OutputLevel'    : INFO,
+
    'HistogramPersistency' : 'ROOT',
+
}
+
 
+
ApplicationMgr(**options)
+
</pre>
+
  
 
== Event generation ==
 
== Event generation ==

Revision as of 17:08, 22 November 2021

Contents

Configure example

There are some examples to run the parametric simulation

Using tools Link
Read from a ROOT-file, write to a ROOT-file sctparsim_test_read.py
Generate using the particle gun, write to a ROOT-file sctparsim_test_particle_gun.py
Generate using EvtGen, write to a ROOT-file sctparsim_test_evtgen.py
Generate using EvtGen, use the analysis tool sct_run_test_analisis.py

Event generation

The "Event generation" block may contain other options: to read a ROOT file, to generate using the particle gun tool and to generate using EvtGen.

Podio input

It is possible to read the particle parameters from a ROOT file.

You have to import the library

from Configurables import PodioInput

and to create the algorithm instance

podioevent = ScTauDataSvc("EventDataSvc", input="fileName.root")
podioinput = PodioInput("PodioReader", OutputLevel=INFO, collections=['allGenParticles'])

The reading algorithm has the following parameters:

  • input - an input file name
  • collections - a name of a branch with MC particles

Particle gun

To use the particle gun algorithm, it is necessary to import the following libraries

from Configurables import ParticleGun
from Configurables import GenAlg
from Configurables import HepMCToEDMConverter
from Configurables import HepMCFileWriter

from Configurables import Gaudi__ParticlePropertySvc
from PathResolver import PathResolver

and to write the following strings

particlePropertySvc = Gaudi__ParticlePropertySvc(
    "ParticlePropertySvc",
    ParticlePropertiesFile=PathResolver.FindDataFile('GenParticleData/ParticleTable.txt')
)

from math import pi
guntool = ParticleGun("PdgCodes", PdgCodes=[211])
guntool.OutputLevel=DEBUG

guntool.MomentumMin = 0 * units.MeV 
guntool.MomentumMax = 4 * units.GeV

guntool.ThetaMin = 0 * units.rad 
guntool.ThetaMax = pi * units.rad 

guntool.PhiMin = 0 * units.rad
guntool.PhiMax = 2 * pi * units.rad 

gun = GenAlg("ParticleGun", SignalProvider=guntool)
gun.hepmc.Path = "hepmc"

writer = HepMCFileWriter("HepMCFileWriter")
writer.hepmc.Path="hepmc"

hepmc_converter = HepMCToEDMConverter("Converter")
hepmc_converter.hepmc.Path="hepmc"
hepmc_converter.genparticles.Path="allGenParticles"
hepmc_converter.genvertices.Path="allGenVertices"

Some parameters can be changed:

  • PdgCodes - a list containing particles PDG codes to generate
  • MomentumMin - a minimum particle momentum
  • MomentumMax - a maximum particle momentum
  • ThetaMin - a minimum theta angle
  • ThetaMax - a maximum theta angle
  • PhiMin - a minimum phi angle
  • PhiMax - a maximum phi angle

EvtGen

More information about EvtGen is here.

EvtGen interface has the following parameters:

  • dec - EvtGen users decay file. It can be one of the included in Aurora files or absolute path to your own decay file. Inclusive MC generation does not require user decay file
  • root - root particle for EvtGen. vpho (virtual photon) should be used for non-resonant processes
    • Acceptable root particles: vpho, J/psi, psi(2S), psi(3770), psi(4040), psi(4160), psi(4415). For more details see Generation/GenTools/GenWrappers/python/EvtGenTools.py in Aurora.
  • ecms - center-of-mass energy (mass of the root particle). The parameter ecms must be set for virtual photon while for other root particles (J/\psi, \psi(2S), ...) this parameter is optional. Mean mass of the root particle is adopted if ecms is omitted.
  • nevt - number if events to be gnerated
  • ip - uniform 3D smearing (in mm) for the primary vertex
  • ofile - output file name

One can change these parameters to change behaviour of EvtGen and to produce arbitrary MC sample.

SctParSim

To run the parametric simulation, the script has to have two lines:

from Configurables import SctParSimAlg
sct_alg = SctParSimAlg('SctAlg')

To change some detector parameters, write strings of the following structure

sct_alg.detectorSubsystemName.parameter = mean

The full parameters list is here.

Analysis

The analysis tool has the following parameters:

  • EventLoader
    • pcl.Path - a branch (in the input ROOT-file) for reading
    • plists - a partilce list for further analisis. if it is necessary to consider not only positive, but also negative particles, the label "сс" is used. For example [['K+ cc'], ['pi+ cc']]. Also it is possible to write a kinematic constraint; for example [['K+ cc', 'p > 0.5'], ['pi+ cc']] (kaons don't have the momentum less then 0.5 GeV)
  • ParticleCombinerAlg
    • decStr - an investigated decay
    • cutStr - a selection criteria
    • selfConj - if neutral particle True, else False
  • NtupleAlg
    • vars - a list contains the particle parameters to write an output file. A particle in the decay string can be selected using the "^" symbol. If a decay isn't written (), the information about parameters will be about a parent particle.

More information about the analysis tool is here.

Podio output

It is possible to write the particle parameters to a ROOT file.

You have to import the library

from Configurables import PodioOutput

and to create the algorithm instance

out = PodioOutput('out', filename=ofile)
out.outputCommands = ["keep *"]

The reading algorithm has the parameter: filename - an output file name.

Running algorithm

Some necessary parametrs to run the algorithms:

  • TopAlg - a list of the using algorithms
  • EvtMax - a number of events
Personal tools