]>
Commit | Line | Data |
---|---|---|
518eb852 | 1 | // $Id$ |
50837721 | 2 | |
91509ec6 | 3 | /*! \page README_sim Simulation |
518eb852 | 4 | |
91509ec6 | 5 | The simulation encompasses the following tasks : |
d55fa8e9 | 6 | |
91509ec6 | 7 | - Generation of MC particles (the kinematics of the event ends up in the TreeK |
8 | of Kinematics#.root) | |
9 | ||
10 | - Tracking particles through the detector using | |
11 | the Virtual Monte Carlo, producing AliMUONHit objects, that end up in | |
12 | the TreeH of MUON.Hits#.root file(s). This part is steered by AliMUON and its child | |
13 | AliMUONv1 classes. | |
6b1e4b22 | 14 | |
91509ec6 | 15 | - Converting MC hits into AliMUONVDigit, called SDigits, that end up in the TreeS |
16 | of the MUON.SDigits#.root file(s). A S(ummable)Digit is a pad with its associated | |
17 | charge, but no noise or electronics response function applied. Steered by AliMUONSDigitizerV2 class. | |
d55fa8e9 | 18 | |
91509ec6 | 19 | - Converting SDigits into Digits, by applying electronics calibrations. Actually, we de-calibrate |
20 | the digits at this stage, by adding a pedestal and dividing by a gain, more or less. Steered | |
21 | by AliMUONDigitizerV3 class. Digits end up in TreeD of MUON.Digits#.root file(s). In addition, | |
22 | for the trigger, we create AliMUONLocalTrigger, AliMUONRegionalTrigger and AliMUONGlobalTrigger objects | |
23 | at this stage, that ends up in TreeD as well. | |
518eb852 | 24 | |
91509ec6 | 25 | - Convert the Digits into RAW data, in a format that should be exactly the same as real data from the |
26 | DAQ. Performed by AliMUONRawWriter. | |
518eb852 | 27 | |
91509ec6 | 28 | From there on, the reconstruction can proceed, in the very same way for real or simulated data, |
29 | as long as they are in RAW format. | |
7f42a16f | 30 | |
91509ec6 | 31 | \section sim_s1 How to run a MUON generation |
518eb852 | 32 | |
d55fa8e9 | 33 | You only need to run the simulation part of the test script |
34 | AlirootRun_MUONtest.sh | |
88cb7938 | 35 | |
b3ba6823 | 36 | |
91509ec6 | 37 | \section sim_s2 Tracking parameters, cuts, energy loss and physics processes |
518eb852 | 38 | |
02d8f072 | 39 | Tracking parameters in MUON are automatically defined by GEANT |
40 | MUON takes the default values of CUTs and physics processes | |
41 | defined by the Config files, except for the gas mixture medium | |
42 | of the tracking chambers. The CUT's and physics processes of | |
43 | the gas mixture medium is then defined in the galice.cuts file | |
44 | in the data directory. In particular ILOSS parameter MUST be | |
45 | equal unity (1) in order simulate a realistic energy loss | |
46 | distribution (mean value and fluctuations) in the active gas. | |
a88eb0d0 | 47 | |
91509ec6 | 48 | \section sim_s3 Tracking of particle in the magnetic field |
518eb852 | 49 | |
a88eb0d0 | 50 | GEANT has two ways for tracking charged particles in the |
51 | magnetic field: HELIX et RKUTA. | |
52 | HELIX is faster and works well if the gradient of magnetic | |
53 | field is small. | |
54 | For MUON, HELIX is a not a good approximation and we must | |
55 | use RKUTA to get the optimal mass resolution of the | |
56 | spectrometer. The choice of HELIX or RKUTA is done in the | |
57 | config file when the magnetic field is defined: | |
518eb852 | 58 | <pre> |
b97b210c | 59 | AliMagFMaps* field = new AliMagFMaps("Maps","Maps", TRACKING, FACTOR, MAXB, AliMagFMaps::k5kG); |
a88eb0d0 | 60 | gAlice->SetField(field); |
518eb852 | 61 | </pre> |
a88eb0d0 | 62 | TRACKING must be 1 for RKUTA and 2 for HELIX (the default value for aliroot is 2 (HELIX)) |
63 | FACTOR allows you to set the magnetic field to 0, just putting FACTOR=0. Default value is 1. | |
64 | MAXB is the maximum magnetic field which is 10.T | |
2b32c661 | 65 | |
e6168aff | 66 | \section sim_s4 Tailing effect |
67 | ||
68 | The control to turn on/off the parametrized tailing effect: | |
69 | <pre> | |
70 | AliMUON::SetTailEffect(Bool_t), | |
71 | </pre> | |
72 | ||
73 | The parameter to tune increase/decrease the tailing effect is kept inside, | |
74 | AliMUONResponseV0::DisIntegrate(). This parameter is an integer number | |
75 | (excluding zero and four), the higher the value is the less is the tailing | |
76 | effect: | |
77 | <pre> | |
78 | Int_t para = 5; | |
79 | </pre> | |
80 | Zero is excluded because it gives straight line transformation, and four | |
81 | is excluded because the AliRoot simulation chain spends VERY VERY long | |
82 | time in AliMUONResponseV0::DisIntegrate method, which reason was not yet | |
83 | understood. The parameter for 1, 2, 3, 5, 6, 7, 8, 9, 10 were checked with | |
84 | no slowing down problem, however parameters greater than 6 give almost no | |
85 | tailing effect since they basically correspond to higher order polynomial | |
86 | transform. | |
87 | ||
88 | ||
89 | \section sim_s5 MUON cocktail generator | |
518eb852 | 90 | |
f4f795ed | 91 | There is a MUON cocktail generator of the muon sources in the |
92 | EVGEN directory. This class derives from AliGenCocktail. | |
93 | In the init of this class I have filled the cocktail with | |
94 | the muon sources: J/Psi, Upsilon, Open Charm, Open Beauty, | |
95 | Pion, Kaons. The code needs only the production cross section | |
96 | at 4pi (for the moment this values are in the code since I | |
97 | prefere them do not be modified), and the code calculates the | |
98 | rate of particles in the acceptance, making the scaling based | |
99 | on the number of collisions for the hard probes and on the | |
100 | number of participants for soft sources: Pions and Kaons. | |
101 | ||
102 | In the Genereate of this class all entries in the cocktail | |
103 | are called and we define a "primordial trigger" with requires | |
104 | a minimum number of muons above a Pt cut in the required acceptance. | |
105 | In order to normalized to the real number of simulated events, | |
106 | there are 2 data members in the class fNsuceeded adn fNGenerate | |
107 | which tell us what is the biais source. | |
108 | ||
109 | Enclose an example to use this generator: | |
518eb852 | 110 | <pre> |
f4f795ed | 111 | AliGenMUONCocktail * gener = new AliGenMUONCocktail(); |
112 | gener->SetPtRange(1.,100.); // Transverse momentum range | |
113 | gener->SetPhiRange(0.,360.); // Azimuthal angle range | |
114 | gener->SetYRange(-4.0,-2.4); | |
115 | gener->SetMuonPtCut(1.); | |
116 | gener->SetMuonThetaCut(171.,178.); | |
117 | gener->SetMuonMultiplicity(2); | |
35e21dec | 118 | gener->SetImpactParameterRange(0.,5.); // 10% most centra PbPb collisions |
f4f795ed | 119 | gener->SetVertexSmear(kPerTrack); |
120 | gener->SetOrigin(0,0,0); // Vertex position | |
121 | gener->SetSigma(0,0,0.0); // Sigma in (X,Y,Z) (cm) on IP position | |
122 | gener->Init(); | |
518eb852 | 123 | </pre> |
f4f795ed | 124 | |
e6168aff | 125 | \section sim_s6 How to simulate events with misaligned geometry in local CDB |
d228b279 | 126 | |
127 | If you want to use a misaligned geometry to simulate some | |
128 | events you can use a local CDB. For this need to follow | |
129 | the next steps: | |
130 | ||
131 | - Generate misaligned data in local CDB. | |
132 | You can use MUONGenerateGeometryData.C as described above in | |
133 | the corresponding section. Let's assume you used the default | |
134 | residual misalignment settings, then you have a local CDB in | |
135 | your working directory called ResMisAlignCDB containing | |
136 | misalignement data (ResMisAlignCDB/MUON/Align). | |
137 | ||
0d24599f | 138 | - Tell AliSimulation you want to use your local CDB for |
139 | MUON/Align/Data | |
d228b279 | 140 | To do this you need to instantiate the AliCDBManager, set the |
0d24599f | 141 | default storage and set the specific storage for MUON/Align/Data, |
142 | before instantiating AliSimulation (see for example the commented | |
d228b279 | 143 | lines AlirootRun_MUONtest.sh). |
144 | ||
518eb852 | 145 | <pre> |
d228b279 | 146 | aliroot -b >& testSim.out << EOF |
147 | AliCDBManager* man = AliCDBManager::Instance(); | |
162637e4 | 148 | man->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); |
0d24599f | 149 | man->SetSpecificStorage("MUON/align/Data","local://ResMisAlignCDB"); |
d228b279 | 150 | AliSimulation MuonSim("$ALICE_ROOT/MUON/Config.C"); |
151 | MuonSim.SetWriteRawData("MUON"); | |
152 | MuonSim.Run(10); | |
153 | .q | |
154 | EOF | |
518eb852 | 155 | </pre> |
29fc2c86 | 156 | |
e6168aff | 157 | \section sim_s7 How to Merge events |
cd85a354 | 158 | |
159 | You can merge 2 types of simulated events. For example, | |
160 | you can simulate Hijing events, and then simulate muons | |
161 | merging both. | |
162 | ||
163 | Merging is done at the sdigits level, so Kinematics files | |
164 | of the merged events will just correspond to the | |
d55fa8e9 | 165 | Config.C simulated file). |
cd85a354 | 166 | |
167 | You must, first, do the Hijing simulation and store it | |
168 | in directory $HIJING_SIM. Note that for merging you | |
169 | won't need Kinematics files of the Hijing simulation... | |
170 | ||
171 | Hijing simulation | |
172 | ||
518eb852 | 173 | <pre> |
cd85a354 | 174 | aliroot -b << EOF |
d55fa8e9 | 175 | AliSimulation HijingSim("$HIJING_SIM/YourConfigForHIJING.C") |
cd85a354 | 176 | HijingSim.Run(5) |
177 | .q | |
178 | EOF | |
518eb852 | 179 | </pre> |
cd85a354 | 180 | |
d55fa8e9 | 181 | You cand build YourConfigFroHIJING.C File from the |
182 | ConfigPPR file in AliRoot/macros module. | |
cd85a354 | 183 | |
184 | Then you can do muon simulation and reconstruction | |
185 | merging both simulated events. In next example, we are | |
186 | merging 20 times each Hijing event in order to simulate | |
187 | 100 muons merged with 5 Hijing events. | |
188 | ||
518eb852 | 189 | <pre> |
cd85a354 | 190 | aliroot -b << EOF |
191 | AliSimulation MuonSim("$ALICE_ROOT/MUON/Config.C") | |
192 | MuonSim.MergeWith("$HIJING_SIM/galice.root",20) //parameters are the Hijing simulation file and the number of times we use each Hijing event | |
193 | MuonSim.Run(100) // number of muon (Config.C) events | |
194 | .q | |
195 | EOF | |
196 | ||
197 | ||
198 | aliroot -b << EOF | |
199 | TPluginManager * pluginmanager = gROOT->GetPluginManager() | |
200 | pluginmanager->AddHandler("AliReconstructor","MUON","AliMUONReconstructor","MUON","AliMUONReconstructor()") | |
201 | AliReconstruction MuonRec("galice.root") | |
202 | MuonRec.SetRunTracking("") | |
203 | MuonRec.SetRunVertexFinder(kFALSE) | |
204 | MuonRec.SetRunLocalReconstruction("MUON") | |
205 | MuonRec.SetFillESD("MUON") | |
206 | MuonRec.Run() | |
207 | .q | |
208 | EOF | |
518eb852 | 209 | </pre> |
cd85a354 | 210 | |
e6168aff | 211 | \section sim_s8 On track numbering |
d228b279 | 212 | |
213 | All generated particles, including primary and secondary | |
214 | particles are put on the stack. The secondary particles are kept | |
215 | in the stack only if they gave a hit in *any* of the ALICE detectors | |
216 | The number of all particles placed on the stack for a given event | |
217 | can be obtained with | |
218 | Int_t nPart = AliStack::GetNtrack(); | |
219 | Looping from 0 to nPart via AliStack::Particle(ipart) | |
220 | gives the particle listing as obtained from the particle generator (primaries) | |
221 | and Monte Carlo (secondaries). | |
222 | ||
223 | The particle response in the detector, a hit, is registered | |
224 | in the hits tree and the hits are filled with each primary track. | |
225 | The total number of "tracks" (fills of the tree) can be obtained | |
c58ae721 | 226 | with ntracks = AliMUONMCDataInterface::NumberOfTracks(event) and is usually smaller than "nPart". |
d228b279 | 227 | Since particles can also deposit hits in other detectors than |
228 | the MUON spectrometer, there will be many "tracks" (fills) in the hit-tree | |
229 | without a hit in MUON. | |
230 | ||
231 | The correspondence between "track ID" in the hits-tree ("itr") and the | |
232 | particle ID for particles on the stack (i.e. generated particles) can be | |
233 | obtained via: | |
518eb852 | 234 | <pre> |
d228b279 | 235 | for (Int_t itr = 0; itr < ntracks; itr++) { |
c58ae721 | 236 | AliMUONVHitStore* hitStore = mcDataInterface.HitStore(event,itr); |
237 | //track "itr" of the hits-tree | |
238 | Int_t nhitstot = hitStore->GetSize(); | |
239 | AliMUONHit* mHit; | |
240 | TIter next(hitStore->CreateIterator()); | |
241 | while ( ( mHit = static_cast<AliMUONHit*>(next()) ) ) | |
242 | { | |
243 | Int_t id = mHit->Track(); //gives particle ID on stack | |
244 | TParticle* particle = mcDataInterface.Stack(event)->Particle(id); | |
d228b279 | 245 | } |
246 | } | |
518eb852 | 247 | </pre> |
d228b279 | 248 | |
c58ae721 | 249 | where mcDataInterface has been obtained by |
250 | AliMUONMCDataInterface mcDataInterface("galice.root"); | |
251 | ||
d228b279 | 252 | During the procedure to go from hits to digits, the hits |
253 | are summed up such that more than one track can contribute | |
254 | to a given digit. As a consequence the method | |
255 | Int_t AliMUONDigit::Track(Int_t trackID) | |
256 | takes an argument, where "trackID" runs from 0 to | |
257 | AliMUONDigit::Ntracks() to provide the reference to *all* | |
258 | tracks that contributed to it. The returned track ID is the one | |
259 | referred to in the hit-tree. To know which is the generated particle | |
260 | that deposited a given digit one has to follow the sequence of the kind: | |
c58ae721 | 261 | (shown here using the simple, but not fast, DataInterface interfaces) : |
262 | ||
518eb852 | 263 | <pre> |
c58ae721 | 264 | AliMUONMCDataInterface mcdi("galice.root"); |
265 | AliMUONDataInterface di("galice.root"); | |
d228b279 | 266 | |
c58ae721 | 267 | AliMUONVDigitStore* digitStore = di.DigitStore(event); |
268 | AliMUONVDigit* mDigit = ... get some digit from the digitStore | |
d228b279 | 269 | |
c58ae721 | 270 | for (int tr = 0; tr < mDigit->Ntracks(); tr++) |
271 | { | |
d228b279 | 272 | Int_t hitTrackID = mDigit->Track(tr); |
c58ae721 | 273 | // get the hits corresponding to this trackID |
274 | AliMUONHitStore* hitStore = mcdi.HitStore(event,hitTrackID); | |
275 | // loop over the hits | |
276 | TIter hNext(hitStore->CreateIterator()); | |
277 | AliMUONHit* mHit; | |
278 | while ( ( mHit = static_cast<AliMUONHit*>(hNext()) ) ) | |
279 | { | |
280 | Int_t numPart = mHit->Track(); //gives ID of particle on the stack | |
281 | Int_t idTrack = mHit->Particle(); //gives flavour code of the particle | |
282 | } | |
d228b279 | 283 | } |
518eb852 | 284 | </pre> |
d228b279 | 285 | |
91509ec6 | 286 | This chapter is defined in the READMEsim.txt file. |
23567f21 | 287 | |
518eb852 | 288 | */ |