MUON/READMEshuttle.txt

   1 // $Id$
   2
   3 /*!
   4
   5 \page README_shuttle Shuttle
   6
   7 How to test the Shuttle preprocessor(s) for MUON.
   8
   9 We will get two "logical" MUON preprocessors : one for the tracker and one for the trigger.
  10 Both will manage several subtasks (e.g. the tracker one will handle pedestals,
  11  gains and deadchannels, while the trigger one will handle masks and trigger lut)
  12 "Physically", only one class will manage both the tracker and the trigger : AliMUONPreprocessor.
  13 Depending on the subsystem and on the task to be performed (based on the run type), this class
  14  will instanciate the correct set of AliMUONVSubProcessor(s) which does the actual job.
  15 Output of most processors will end up in OCDB (Offine Condition DataBase). A set of helper functions
  16  to peek at this OCDB are gathered in AiMUONCDB class.
  17
  18
  19 \section shuttle_s1 TestMUONPreprocessor.C
  20
  21 This is the master macro used to check the MUON part of the Shuttle.
  22 Depending on what you want to test, you'll have to modify the input files
  23 (using shuttle->AddInputFile) and/or the run type (using shuttle->AddInputRunParameter())
  24
  25
  26 \section shuttle_s2 AliMUONPreprocessor(const TString& detName)
  27
  28 Depending on how this one is constructed, and depending on the runtype, it will
  29  perform differents tasks. Note that for the moment the runtypes are "fake", i.e.
  30  put by hand in the TestMUONPreprocessor.C macro, and might not correspond to
  31  the final values to be used by the DAQ.
  32
  33 <pre>
  34 detName   runType                     task to be done           worker class (AliMUONVSubprocessor child)
  35 --------------------------------------------------------------------------------------------------------
  36 MCH       PEDESTAL_RUN                read ASCII ped files      AliMUONPedestalSubprocessor
  37                                       and put them into OCDB
  38
  39 MCH       GMS                         read GMS alignment files  AliMUONGMSSubprocessor
  40                                       and put them into OCDB
  41
  42 MCH       PHYSICS                     read DCS HV values and    AliMUONHVSubprocessor
  43                                       put them into OCDB
  44
  45 MCH       ELECTRONICS_CALIBRATION_RUN read ASCII gain files     prototype only = AliMUONGainSubprocessor
  46                                       and put them into OCDB
  47
  48 MTR       to be defined               to be defined             to be done
  49 </pre>
  50
  51
  52 \section shuttle_s3 Pedestals
  53
  54 Two options here. You can either use a pre-done set of ASCII pedestals files (generated as
  55  explained below for the 2nd option), located at /afs/cern.ch/user/l/laphecet/public/LDC*.ped,
  56  or build you own set.
  57
  58 We've written an AliMUONPedestalEventGenerator which creates fake pedestal events. The pedestal values
  59 are taken from the Offline Condition DataBase (OCDB) (which is itself fakely filled
  60 using the WritePedestals() method of AliMUONCDB class
  61
  62 So first generate a valid pedestal CDB entry by using the AliMUONCDB class
  63
  64 <pre>
  65 root[] const char* cdbpath="local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB"; // where to put the CDB
  66 root[] AliMUONCDB cdb(cdbpath)
  67 root[] Bool_t defaultValues = kFALSE; // to generate random values instead of plain zeros...
  68 root[] Int_t startRun = 80;
  69 root[] Int_t endRun = 80;
  70 root[] cdb.WritePedestals(defaultValues, startRun, endRun);
  71 </pre>
  72
  73 Expected output is (don't worry about the warnings, they are harmless) :
  74
  75 <pre>
  76 I-AliMUONCDB::ManuList: Generating ManuList...
  77 I-AliMUONCDB::ManuList: Manu List generated.
  78 I-AliMUONCDB::MakePedestalStore: 16828 Manus and 1064008 channels.
  79 I-AliMUONCDB::WritePedestals: Ngenerated = 1064008
  80 I-AliCDBManager::Init: AliEn classes enabled in Root. AliCDBGrid factory registered.
  81 I-AliCDBManager::SetDefaultStorage: Setting Default storage to: local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB
  82 I-AliCDBLocal::PutEntry: CDB object stored into file ($ALICE_ROOT)/SHUTTLE/TestShuttle/TestCDB/MUON/Calib/Pedestals/Run80_80_v0_s0.root
  83 </pre>
  84
  85 Then use the AliMUONPedestalEventGenerator to produce simulated pedestal events.
  86
  87 Usage (from the Root prompt) :
  88 <pre>
  89 AliCDBManager::Instance()->SetDefaultStorage(cdbpath); // so you will read
  90 // back pedestals values generated in the previous step
  91 const char* dateFileName = "raw.date"; // base filename for the output
  92 Int_t runNumber = 80; // run number used to fetch the pedestals from the OCDB
  93 Int_t nevents = 100; // # of events to generate. 100 should be enough
  94 gSystem->Load("libMUONshuttle"); // needed or not depending on whether it's already loaded or not
  95 AliMUONPedestalEventGenerator ped(runNumber,nevents,dateFileName);
  96 ped.Exec("");
  97 </pre>
  98
  99 It *will* take a lot of time (mainly due to the fact that we're writing a
 100 bunch of ASCII files = DDL files), so please be patient.
 101
 102 The output should be the normal simulated sequence of MUON.Hits.root, MUON.SDigits.root,
 103  MUON.Digits.root, raw/*.ddl files and raw.date.LDCi where i=0-3 (i.e. one DATE file
 104 per LDC, as will be used in real life), the latter ones being roughly 100 MB each.
 105
 106 // FIXME : instructions below should be replaced with usage of MUONTRKda
 107 //
 108
 109 The raw.date.LDC* files are then processed using the makeped online program
 110 (currently found, pending an agreement on where to put online programs under cvs,
 111  under /afs/cern.ch/user/a/abaldiss/public/v16; Please contact Alberto to check
 112  it's the latest version) which outputs manus-*.ped ASCII files (one per LDC) :
 113
 114 <pre>
 115  makeped -f raw.date.LCDi -a LDCi.ped (i=0,1,2,3)
 116
 117  (repeat for each LDC)
 118 </pre>
 119
 120 The LDCi.ped files are the input for the pedestal subprocessor,
 121 which is tested using the TestMUONPreprocessor.C macro.
 122 The output of the pedestal subprocessor (upon success only) is written into the OCDB.
 123 Difference between the input and the output can be inferred using the diff() function
 124 of MUONCDB.C macro.
 125
 126
 127 \section shuttle_s4 Gains
 128
 129 Like pedestals, you have two options here. You can either use a pre-done set of
 130 ASCII gain files (generated as explained below for the 2nd option),
 131 located at /afs/cern.ch/user/l/laphecet/public/LDC*.gains,  or build you own set.
 132
 133 We've written an AliMUONGainEventGenerator which creates fake gain events.
 134 The pedestal and gain values are taken from the Offline Condition DataBase (OCDB)
 135  (which is itself fakely filled using the WritePedestals() and WriteGains()
 136  methods of AliMUONCDB class).
 137
 138 So first you need to generate a valid pedestal CDB entry and a valid gain CDB
 139 entry by using the AliMUONCDB class, from the Root prompt:
 140
 141 <pre>
 142 const char* cdbpath="local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB"; // where to put the CDB
 143 AliMUONCDB cdb(cdbpath)
 144 Bool_t defaultValues = kFALSE; // to generate random values instead of plain zeros...
 145 Int_t gainRun = 80;
 146 Int_t pedRun = 81;
 147 cdb.WritePedestals(defaultValues, pedRun, pedRun);
 148 cdb.WriteGains(defaultValues, gainRun, gainRun);
 149 </pre>
 150
 151 Expected output is (don't worry about the warnings, they are harmless) :
 152
 153 Then use the AliMUONGainEventGenerator to produce simulated gain events : the output
 154 will be n x 4 date files (n is the number of fake injections, currently 9, and 4
 155  is the number of LDCs)
 156
 157 Usage (again, from the Root prompt) :
 158
 159 <pre>
 160 const char* cdbpath="local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB"; // where to get the CDB
 161 AliCDBManager::Instance()->SetDefaultStorage(cdbpath); // so you will read
 162 // back pedestals and gain values generated in the previous step
 163 const char* dateFileName = "raw.date"; // base filename for the output
 164 Int_t gainRunNumber = 80; // run number used to fetch gains from OCDB
 165 Int_t pedRunNumber = 81; // run number used to fetch the pedestals from the OCDB
 166 // generated ped files will be for r = 81, 83, etc...
 167 Int_t nevents = 100; // # of events to generate. 100 should be enough for testing, but 1000 would be better for prod
 168 gSystem->Load("libMUONshuttle"); // needed or not depending on whether it's already loaded or not
 169 AliMUONGainEventGenerator g(gainRunNumber,pedRunNumber,nevents,dateFileName);
 170 g.Exec("");
 171 </pre>
 172
 173 It *will* take a lot of time (mainly due to the fact that we're writing a
 174 bunch of ASCII files = DDL files), so please be patient.
 175
 176 The output should be a sequence of directories, RUN81, RUN82, etc..., each
 177 containing the normal simulated sequence of MUON.Hits.root, MUON.SDigits.root,
 178  MUON.Digits.root, raw/*.ddl files and raw.date.LDCi where i=0-3 (i.e. one DATE file
 179 per LDC, as will be used in real life), the latter ones being roughly 100 MB each.
 180
 181 <pre>
 182 // FIXME
 183 // Below should follow instructions on how to feed the MUONTRKda with the
 184 // generated files.
 185 </pre>
 186
 187
 188 \section shuttle_s5 HV
 189
 190 HV DCS values are created in CreateDCSAliasMap() of TestMUONPreprocessor.C
 191 You might want to modify this function to create a given set of error conditions
 192  in order to test whether the HVSubprocessor is reacting properly to those errors.
 193
 194
 195 \section shuttle_s6 GMS
 196
 197 The GMS alignment data for testing can be generated with
 198 the macro MUONGenerateTestGMS.C:
 199 The matrices of TGeoHMatrix type, with TObject::fUniqueID equal to the geometry
 200 module Id, are put in a TClonesArray and saved in the Root file with a
 201 key "GMSarray".
 202
 203 This chapter is defined in the READMEshuttle.txt file.
 204
 205 */
 206