MUON/READMEsim.txt

   1 // $Id$
   2
   3 /*! \page README_sim Simulation
   4
   5 The simulation encompasses the following tasks :
   6
   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.
  14
  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.
  18
  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.
  24
  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.
  27
  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.
  30
  31 \section sim_s1  How to run a MUON generation
  32
  33 You only need to run the simulation part of the test script
  34 AlirootRun_MUONtest.sh
  35
  36
  37 \section sim_s2 Tracking parameters, cuts, energy loss and physics processes
  38
  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.
  47
  48 \section sim_s3  Tracking of particle in the magnetic field
  49
  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:
  58 <pre>
  59   AliMagFMaps* field = new AliMagFMaps("Maps","Maps", TRACKING, FACTOR, MAXB, AliMagFMaps::k5kG);
  60   gAlice->SetField(field);
  61 </pre>
  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
  65
  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
  90
  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:
 110 <pre>
 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);
 118 gener->SetImpactParameterRange(0.,5.); // 10% most centra PbPb collisions
 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();
 123 </pre>
 124
 125 \section sim_s6 How to simulate events with misaligned geometry in local CDB
 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
 138 - Tell AliSimulation you want to use your local CDB for
 139 MUON/Align/Data
 140 To do this you need to instantiate the AliCDBManager, set the
 141 default storage and set the specific storage for MUON/Align/Data,
 142 before instantiating AliSimulation (see for example the commented
 143 lines AlirootRun_MUONtest.sh).
 144
 145 <pre>
 146 aliroot -b  >& testSim.out << EOF
 147 AliCDBManager* man = AliCDBManager::Instance();
 148 man->SetDefaultStorage("local://$ALICE_ROOT");
 149 man->SetSpecificStorage("MUON/align/Data","local://ResMisAlignCDB");
 150 AliSimulation MuonSim("$ALICE_ROOT/MUON/Config.C");
 151 MuonSim.SetWriteRawData("MUON");
 152 MuonSim.Run(10);
 153 .q
 154 EOF
 155 </pre>
 156
 157 \section sim_s7 How to Merge events
 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
 165 Config.C simulated file).
 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
 173 <pre>
 174 aliroot -b << EOF
 175 AliSimulation HijingSim("$HIJING_SIM/YourConfigForHIJING.C")
 176 HijingSim.Run(5)
 177 .q
 178 EOF
 179 </pre>
 180
 181 You cand build YourConfigFroHIJING.C File from the
 182 ConfigPPR file in AliRoot/macros module.
 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
 189 <pre>
 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
 209 </pre>
 210
 211 \section sim_s8 On track numbering
 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
 226 with ntracks = AliMUONMCDataInterface::NumberOfTracks(event) and is usually smaller than "nPart".
 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:
 234 <pre>
 235 for (Int_t itr = 0; itr < ntracks; itr++) {
 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);
 245     }
 246 }
 247 </pre>
 248
 249 where mcDataInterface has been obtained by
 250 AliMUONMCDataInterface mcDataInterface("galice.root");
 251
 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:
 261 (shown here using the simple, but not fast, DataInterface interfaces) :
 262
 263 <pre>
 264 AliMUONMCDataInterface mcdi("galice.root");
 265 AliMUONDataInterface di("galice.root");
 266
 267 AliMUONVDigitStore* digitStore = di.DigitStore(event);
 268 AliMUONVDigit* mDigit = ... get some digit from the digitStore
 269
 270 for (int tr = 0; tr < mDigit->Ntracks(); tr++)
 271 {
 272    Int_t hitTrackID = mDigit->Track(tr);
 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    }
 283 }
 284 </pre>
 285
 286 This chapter is defined in the READMEsim.txt file.
 287
 288 */