5 \page README_shuttle Shuttle
7 How to test the Shuttle preprocessor(s) for MUON.
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.
19 \section shuttle_s1 TestMUONPreprocessor.C
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())
26 \section shuttle_s2 AliMUONPreprocessor(const TString& detName)
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.
34 detName runType task to be done worker class (AliMUONVSubprocessor child)
35 --------------------------------------------------------------------------------------------------------
36 MCH PEDESTAL read ASCII ped files AliMUONPedestalSubprocessor
37 and put them into OCDB
39 MCH GMS read GMS alignment files AliMUONGMSSubprocessor
40 and put them into OCDB
42 MCH PHYSICS read DCS HV values and AliMUONHVSubprocessor
45 MCH CALIBRATION read ASCII gain files AliMUONGainSubprocessor
46 and put them into OCDB
48 MTR to be defined to be defined to be done
52 \section shuttle_s3 Pedestals
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,
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
62 So first generate a valid pedestal CDB entry by using the AliMUONCDB class. There's one
63 little trick : you should first point to the "default" OCDB (local://$ALICE_ROOT) in
64 order to get the mapping loaded, then only you can play with another OCDB.
65 Or, alternatively, you can put the mapping stuff in the test OCDB, like this :
68 root[] AliMpDDLStore::ReadData(); // read mapping from ASCII files
69 root[] const char* cdbpath="local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB"; // where to put the CDB
70 root[] AliCDBManager::Instance()->SetDefaultStorage(cdbpath);
71 root[] AliMpCDB::WriteMpSegmentation();
72 root[] AliMpCDB::WriteDDLStore();
75 If you've not put the mapping in the test database, then you must start with the default OCDB, load the mapping, and then only switch to the
79 root[] AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT"); // only if you've not put the mapping in test OCDB
80 root[] AliCDBManager::Instance()->SetRun(0); // only if you've not put the mapping in test OCDB
81 root[] AliMpCDB::LoadDDLStore(); // only if you've not put the mapping in test OCDB
82 // below are lines to be executed whatever you did with the mapping...
83 root[] const char* cdbpath="local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB"; // where to put the CDB
84 root[] AliMUONCDB cdb(cdbpath)
85 root[] Bool_t defaultValues = kFALSE; // to generate random values instead of plain zeros...
86 root[] Int_t startRun = 80;
87 root[] Int_t endRun = 80;
88 root[] cdb.WritePedestals(defaultValues, startRun, endRun);
91 Expected output is (don't worry about the warnings, they are harmless) :
94 I-AliMUONCDB::ManuList: Generating ManuList...
95 I-AliMUONCDB::ManuList: Manu List generated.
96 I-AliMUONCDB::MakePedestalStore: 16828 Manus and 1064008 channels.
97 I-AliMUONCDB::WritePedestals: Ngenerated = 1064008
98 I-AliCDBManager::Init: AliEn classes enabled in Root. AliCDBGrid factory registered.
99 I-AliCDBManager::SetDefaultStorage: Setting Default storage to: local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB
100 I-AliCDBLocal::PutEntry: CDB object stored into file ($ALICE_ROOT)/SHUTTLE/TestShuttle/TestCDB/MUON/Calib/Pedestals/Run80_80_v0_s0.root
103 Then use the AliMUONPedestalEventGenerator to produce simulated pedestal events.
105 Usage (from the Root prompt) :
107 AliMpCDB::LoadDDLStore2(); // load mapping from "default" OCDB=local://$ALICE_ROOT
108 AliCDBManager::Instance()->SetDefaultStorage(cdbpath); // so you will read
109 // back pedestals values generated in the previous step
110 const char* dateFileName = "raw.date"; // base filename for the output
111 Int_t runNumber = 80; // run number used to fetch the pedestals from the OCDB
112 Int_t nevents = 100; // # of events to generate. 100 should be enough
113 gSystem->Load("libMUONshuttle"); // needed or not depending on whether it's already loaded or not
114 AliMUONPedestalEventGenerator ped(runNumber,nevents,dateFileName);
118 It *will* take a lot of time (mainly due to the fact that we're writing a
119 bunch of ASCII files = DDL files), so please be patient.
121 The output should be the normal simulated sequence of MUON.Hits.root, MUON.SDigits.root,
122 MUON.Digits.root, raw/*.ddl files and raw.date.LDCi where i=0-3 (i.e. one DATE file
123 per LDC, as will be used in real life), the latter ones being roughly 100 MB each.
125 // FIXME : instructions below should be replaced with usage of MUONTRKda
128 The raw.date.LDC* files are then processed using the DA online program (which is not built by default, but must be made
129 explicitely using make daqDA-MCH from $ALICE_ROOT, and requires some DATE setup..., see \ref READMEmchda.txt )
132 MUONTRKda.exe -f raw.date.LCDi -a LDCi.ped (i=0,1,2,3)
134 (repeat for each LDC)
137 The LDCi.ped files are the input for the pedestal subprocessor,
138 which is tested using the TestMUONPreprocessor.C macro.
139 The output of the pedestal subprocessor (upon success only) is written into the OCDB.
140 Difference between the input and the output can be inferred using the diff() function
144 \section shuttle_s4 Gains
146 Like pedestals, you have two options here. You can either use a pre-done set of
147 ASCII gain files (generated as explained below for the 2nd option),
148 located at /afs/cern.ch/user/l/laphecet/public/LDC*.gains, or build you own set.
150 We've written an AliMUONGainEventGenerator which creates fake gain events.
151 The pedestal and gain values are taken from the Offline Condition DataBase (OCDB)
152 (which is itself fakely filled using the WritePedestals() and WriteGains()
153 methods of AliMUONCDB class).
155 So first you need to generate a valid pedestal CDB entry and a valid gain CDB
156 entry by using the AliMUONCDB class, from the Root prompt:
159 const char* cdbpath="local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB"; // where to put the CDB
160 AliMUONCDB cdb(cdbpath)
161 Bool_t defaultValues = kFALSE; // to generate random values instead of plain zeros...
164 cdb.WritePedestals(defaultValues, pedRun, pedRun);
165 cdb.WriteGains(defaultValues, gainRun, gainRun);
168 Expected output is (don't worry about the warnings, they are harmless) :
170 Then use the AliMUONGainEventGenerator to produce simulated gain events : the output
171 will be n x 4 date files (n is the number of fake injections, currently 9, and 4
172 is the number of LDCs)
174 Usage (again, from the Root prompt) :
177 const char* cdbpath="local://$ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB"; // where to get the CDB
178 AliCDBManager::Instance()->SetDefaultStorage(cdbpath); // so you will read
179 // back pedestals and gain values generated in the previous step
180 const char* dateFileName = "raw.date"; // base filename for the output
181 Int_t gainRunNumber = 80; // run number used to fetch gains from OCDB
182 Int_t pedRunNumber = 81; // run number used to fetch the pedestals from the OCDB
183 // generated ped files will be for r = 81, 83, etc...
184 Int_t nevents = 100; // # of events to generate. 100 should be enough for testing, but 1000 would be better for prod
185 gSystem->Load("libMUONshuttle"); // needed or not depending on whether it's already loaded or not
186 AliMUONGainEventGenerator g(gainRunNumber,pedRunNumber,nevents,dateFileName);
190 It *will* take a lot of time (mainly due to the fact that we're writing a
191 bunch of ASCII files = DDL files), so please be patient.
193 The output should be a sequence of directories, RUN81, RUN82, etc..., each
194 containing the normal simulated sequence of MUON.Hits.root, MUON.SDigits.root,
195 MUON.Digits.root, raw/*.ddl files and raw.date.LDCi where i=0-3 (i.e. one DATE file
196 per LDC, as will be used in real life), the latter ones being roughly 100 MB each.
200 // Below should follow instructions on how to feed the MUONTRKda with the
205 \section shuttle_s5 HV
207 HV DCS values are created in CreateDCSAliasMap() of TestMUONPreprocessor.C
208 You might want to modify this function to create a given set of error conditions
209 in order to test whether the HVSubprocessor is reacting properly to those errors.
212 \section shuttle_s6 GMS
214 The GMS alignment data for testing can be generated with
215 the macro MUONGenerateTestGMS.C:
216 The matrices of TGeoHMatrix type, with TObject::fUniqueID equal to the geometry
217 module Id, are put in a TClonesArray and saved in the Root file with a
220 This chapter is defined in the READMEshuttle.txt file.