]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliSimulation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fixing warnings
[u/mrichter/AliRoot.git] / STEER / AliSimulation.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// class for running generation, simulation and digitization //
21// //
22// Hits, sdigits and digits are created for all detectors by typing: //
23// //
24// AliSimulation sim; //
25// sim.Run(); //
26// //
27// The Run method returns kTRUE in case of successful execution. //
28// The number of events can be given as argument to the Run method or it //
29// can be set by //
30// //
31// sim.SetNumberOfEvents(n); //
32// //
33// The name of the configuration file can be passed as argument to the //
34// AliSimulation constructor or can be specified by //
35// //
36// sim.SetConfigFile("..."); //
37// //
38// The generation of particles and the simulation of detector hits can be //
39// switched on or off by //
40// //
41// sim.SetRunGeneration(kTRUE); // generation of primary particles //
42// sim.SetRunSimulation(kFALSE); // but no tracking //
43// //
44// For which detectors sdigits and digits will be created, can be steered //
45// by //
46// //
47// sim.SetMakeSDigits("ALL"); // make sdigits for all detectors //
48// sim.SetMakeDigits("ITS TPC"); // make digits only for ITS and TPC //
49// //
50// The argument is a (case sensitive) string with the names of the //
51// detectors separated by a space. An empty string ("") can be used to //
52// disable the creation of sdigits or digits. The special string "ALL" //
53// selects all available detectors. This is the default. //
54// //
55// The creation of digits from hits instead of from sdigits can be selected //
56// by //
57// //
58// sim.SetMakeDigitsFromHits("TRD"); //
59// //
60// The argument is again a string with the selected detectors. Be aware that //
61// this feature is not available for all detectors and that merging is not //
62// possible, when digits are created directly from hits. //
63// //
64// Background events can be merged by calling //
65// //
66// sim.MergeWith("background/galice.root", 2); //
67// //
68// The first argument is the file name of the background galice file. The //
69// second argument is the number of signal events per background event. //
70// By default this number is calculated from the number of available //
71// background events. MergeWith can be called several times to merge more //
72// than two event streams. It is assumed that the sdigits were already //
73// produced for the background events. //
74// //
75// The output of raw data can be switched on by calling //
76// //
77// sim.SetWriteRawData("MUON"); // write raw data for MUON //
78// //
79// The default output format of the raw data are DDL files. They are //
80// converted to a DATE file, if a file name is given as second argument. //
81// For this conversion the program "dateStream" is required. If the file //
82// name has the extension ".root", the DATE file is converted to a root //
83// file. The program "alimdc" is used for this purpose. For the conversion //
84// to DATE and root format the two conversion programs have to be installed. //
85// Only the raw data in the final format is kept if the third argument is //
86// kTRUE. //
87// //
88// The methods RunSimulation, RunSDigitization, RunDigitization, //
89// RunHitsDigitization and WriteRawData can be used to run only parts of //
90// the full simulation chain. The creation of raw data DDL files and their //
91// conversion to the DATE or root format can be run directly by calling //
92// the methods WriteRawFiles, ConvertRawFilesToDate and ConvertDateToRoot. //
93// //
94// The default number of events per file, which is usually set in the //
95// config file, can be changed for individual detectors and data types //
96// by calling //
97// //
98// sim.SetEventsPerFile("PHOS", "Reconstructed Points", 3); //
99// //
100// The first argument is the detector, the second one the data type and the //
101// last one the number of events per file. Valid data types are "Hits", //
102// "Summable Digits", "Digits", "Reconstructed Points" and "Tracks". //
103// The number of events per file has to be set before the simulation of //
104// hits. Otherwise it has no effect. //
105// //
106///////////////////////////////////////////////////////////////////////////////
107
108#include <TCint.h>
109#include <TFile.h>
110#include <TGeoGlobalMagField.h>
111#include <TGeoManager.h>
112#include <TObjString.h>
113#include <TROOT.h>
114#include <TSystem.h>
115#include <TVirtualMC.h>
116#include <TVirtualMCApplication.h>
117#include <TDatime.h>
118
119#include "AliAlignObj.h"
120#include "AliCDBEntry.h"
121#include "AliCDBManager.h"
122#include "AliGRPManager.h"
123#include "AliCDBStorage.h"
124#include "AliCTPRawData.h"
125#include "AliCentralTrigger.h"
126#include "AliCentralTrigger.h"
127#include "AliCodeTimer.h"
128#include "AliDAQ.h"
129#include "AliDigitizer.h"
130#include "AliESDEvent.h"
131#include "AliGRPObject.h"
132#include "AliGenEventHeader.h"
133#include "AliGenerator.h"
134#include "AliGeomManager.h"
135#include "AliHLTSimulation.h"
136#include "AliHeader.h"
137#include "AliLego.h"
138#include "AliLegoGenerator.h"
139#include "AliLog.h"
140#include "AliMC.h"
141#include "AliMagF.h"
142#include "AliModule.h"
143#include "AliPDG.h"
144#include "AliRawReaderDate.h"
145#include "AliRawReaderFile.h"
146#include "AliRawReaderRoot.h"
147#include "AliRun.h"
148#include "AliRunDigitizer.h"
149#include "AliRunLoader.h"
150#include "AliSimulation.h"
151#include "AliSysInfo.h"
152#include "AliVertexGenFile.h"
153
154ClassImp(AliSimulation)
155
156AliSimulation *AliSimulation::fgInstance = 0;
157const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
158
159//_____________________________________________________________________________
160AliSimulation::AliSimulation(const char* configFileName,
161 const char* name, const char* title) :
162 TNamed(name, title),
163
164 fRunGeneration(kTRUE),
165 fRunSimulation(kTRUE),
166 fLoadAlignFromCDB(kTRUE),
167 fLoadAlObjsListOfDets("ALL"),
168 fMakeSDigits("ALL"),
169 fMakeDigits("ALL"),
170 fTriggerConfig(""),
171 fMakeDigitsFromHits(""),
172 fWriteRawData(""),
173 fRawDataFileName(""),
174 fDeleteIntermediateFiles(kFALSE),
175 fWriteSelRawData(kFALSE),
176 fStopOnError(kFALSE),
177 fNEvents(1),
178 fConfigFileName(configFileName),
179 fGAliceFileName("galice.root"),
180 fEventsPerFile(),
181 fBkgrdFileNames(NULL),
182 fAlignObjArray(NULL),
183 fUseBkgrdVertex(kTRUE),
184 fRegionOfInterest(kFALSE),
185 fCDBUri(""),
186 fQARefUri(""),
187 fSpecCDBUri(),
188 fRun(-1),
189 fSeed(0),
190 fInitCDBCalled(kFALSE),
191 fInitRunNumberCalled(kFALSE),
192 fSetRunNumberFromDataCalled(kFALSE),
193 fEmbeddingFlag(kFALSE),
194 fLego(NULL),
195 fKey(0),
196 fUseVertexFromCDB(0),
197 fUseMagFieldFromGRP(0),
198 fGRPWriteLocation(Form("local://%s", gSystem->pwd())),
199 fQADetectors("ALL"),
200 fQATasks("ALL"),
201 fRunQA(kTRUE),
202 fEventSpecie(AliRecoParam::kDefault),
203 fWriteQAExpertData(kTRUE),
204 fGeometryFile(),
205 fRunHLT("default"),
206 fpHLT(NULL),
207 fWriteGRPEntry(kTRUE)
208{
209// create simulation object with default parameters
210 fgInstance = this;
211 SetGAliceFile("galice.root");
212
213// for QA
214 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
215 qam->SetActiveDetectors(fQADetectors) ;
216 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
217 qam->SetTasks(fQATasks) ;
218}
219
220//_____________________________________________________________________________
221AliSimulation::~AliSimulation()
222{
223// clean up
224
225 fEventsPerFile.Delete();
226// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
227// delete fAlignObjArray; fAlignObjArray=0;
228
229 if (fBkgrdFileNames) {
230 fBkgrdFileNames->Delete();
231 delete fBkgrdFileNames;
232 }
233
234 fSpecCDBUri.Delete();
235 if (fgInstance==this) fgInstance = 0;
236
237 AliQAManager::QAManager()->ShowQA() ;
238 AliQAManager::Destroy() ;
239 AliCodeTimer::Instance()->Print();
240}
241
242
243//_____________________________________________________________________________
244void AliSimulation::SetNumberOfEvents(Int_t nEvents)
245{
246// set the number of events for one run
247
248 fNEvents = nEvents;
249}
250
251//_____________________________________________________________________________
252void AliSimulation::InitQA()
253{
254 // activate a default CDB storage
255 // First check if we have any CDB storage set, because it is used
256 // to retrieve the calibration and alignment constants
257
258 if (fInitCDBCalled) return;
259 fInitCDBCalled = kTRUE;
260
261 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
262 qam->SetActiveDetectors(fQADetectors) ;
263 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
264 qam->SetTasks(fQATasks) ;
265 if (fWriteQAExpertData)
266 qam->SetWriteExpert() ;
267
268 if (qam->IsDefaultStorageSet()) {
269 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
270 AliWarning("Default QA reference storage has been already set !");
271 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fQARefUri.Data()));
272 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
273 fQARefUri = qam->GetDefaultStorage()->GetURI();
274 } else {
275 if (fQARefUri.Length() > 0) {
276 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
277 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
278 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
279 } else {
280 fQARefUri="local://$ALICE_ROOT/QARef";
281 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
282 AliWarning("Default QA reference storage not yet set !!!!");
283 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
284 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
285 }
286 qam->SetDefaultStorage(fQARefUri);
287 }
288}
289
290//_____________________________________________________________________________
291void AliSimulation::InitCDB()
292{
293// activate a default CDB storage
294// First check if we have any CDB storage set, because it is used
295// to retrieve the calibration and alignment constants
296
297 if (fInitCDBCalled) return;
298 fInitCDBCalled = kTRUE;
299
300 AliCDBManager* man = AliCDBManager::Instance();
301 if (man->IsDefaultStorageSet())
302 {
303 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
304 AliWarning("Default CDB storage has been already set !");
305 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
306 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
307 fCDBUri = man->GetDefaultStorage()->GetURI();
308 }
309 else {
310 if (fCDBUri.Length() > 0)
311 {
312 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
313 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
314 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
315 } else {
316 fCDBUri="local://$ALICE_ROOT/OCDB";
317 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
318 AliWarning("Default CDB storage not yet set !!!!");
319 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
320 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
321
322 }
323 man->SetDefaultStorage(fCDBUri);
324 }
325
326 // Now activate the detector specific CDB storage locations
327 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
328 TObject* obj = fSpecCDBUri[i];
329 if (!obj) continue;
330 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
331 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
332 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
333 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
334 }
335
336}
337
338//_____________________________________________________________________________
339void AliSimulation::InitRunNumber(){
340// check run number. If not set, set it to 0 !!!!
341
342 if (fInitRunNumberCalled) return;
343 fInitRunNumberCalled = kTRUE;
344
345 AliCDBManager* man = AliCDBManager::Instance();
346 if (man->GetRun() >= 0)
347 {
348 AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
349 "Use external variable DC_RUN or AliSimulation::SetRun()!"));
350 }
351
352 if(fRun >= 0) {
353 AliDebug(2, Form("Setting CDB run number to: %d",fRun));
354 } else {
355 fRun=0;
356 AliWarning(Form("Run number not yet set !!!! Setting it now to: %d",
357 fRun));
358 }
359 man->SetRun(fRun);
360
361 man->Print();
362
363}
364
365//_____________________________________________________________________________
366void AliSimulation::SetCDBLock() {
367 // Set CDB lock: from now on it is forbidden to reset the run number
368 // or the default storage or to activate any further storage!
369
370 ULong_t key = AliCDBManager::Instance()->SetLock(1);
371 if (key) fKey = key;
372}
373
374//_____________________________________________________________________________
375void AliSimulation::SetDefaultStorage(const char* uri) {
376 // Store the desired default CDB storage location
377 // Activate it later within the Run() method
378
379 fCDBUri = uri;
380
381}
382
383//_____________________________________________________________________________
384void AliSimulation::SetQARefDefaultStorage(const char* uri) {
385 // Store the desired default CDB storage location
386 // Activate it later within the Run() method
387
388 fQARefUri = uri;
389 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
390}
391
392//_____________________________________________________________________________
393void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
394// Store a detector-specific CDB storage location
395// Activate it later within the Run() method
396
397 AliCDBPath aPath(calibType);
398 if(!aPath.IsValid()){
399 AliError(Form("Not a valid path: %s", calibType));
400 return;
401 }
402
403 TObject* obj = fSpecCDBUri.FindObject(calibType);
404 if (obj) fSpecCDBUri.Remove(obj);
405 fSpecCDBUri.Add(new TNamed(calibType, uri));
406
407}
408
409//_____________________________________________________________________________
410void AliSimulation::SetRunNumber(Int_t run)
411{
412// sets run number
413// Activate it later within the Run() method
414
415 fRun = run;
416}
417
418//_____________________________________________________________________________
419void AliSimulation::SetSeed(Int_t seed)
420{
421// sets seed number
422// Activate it later within the Run() method
423
424 fSeed = seed;
425}
426
427//_____________________________________________________________________________
428Bool_t AliSimulation::SetRunNumberFromData()
429{
430 // Set the CDB manager run number
431 // The run number is retrieved from gAlice
432
433 if (fSetRunNumberFromDataCalled) return kTRUE;
434 fSetRunNumberFromDataCalled = kTRUE;
435
436 AliCDBManager* man = AliCDBManager::Instance();
437 Int_t runData = -1, runCDB = -1;
438
439 AliRunLoader* runLoader = LoadRun("READ");
440 if (!runLoader) return kFALSE;
441 else {
442 runData = runLoader->GetHeader()->GetRun();
443 delete runLoader;
444 }
445
446 runCDB = man->GetRun();
447 if(runCDB >= 0) {
448 if (runCDB != runData) {
449 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
450 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
451 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
452 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
453 }
454
455 }
456
457 man->SetRun(runData);
458 fRun = runData;
459
460 if(man->GetRun() < 0) {
461 AliError("Run number not properly initalized!");
462 return kFALSE;
463 }
464
465 man->Print();
466
467 return kTRUE;
468}
469
470//_____________________________________________________________________________
471void AliSimulation::SetConfigFile(const char* fileName)
472{
473// set the name of the config file
474
475 fConfigFileName = fileName;
476}
477
478//_____________________________________________________________________________
479void AliSimulation::SetGAliceFile(const char* fileName)
480{
481// set the name of the galice file
482// the path is converted to an absolute one if it is relative
483
484 fGAliceFileName = fileName;
485 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
486 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
487 fGAliceFileName);
488 fGAliceFileName = absFileName;
489 delete[] absFileName;
490 }
491
492 AliDebug(2, Form("galice file name set to %s", fileName));
493}
494
495//_____________________________________________________________________________
496void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
497 Int_t nEvents)
498{
499// set the number of events per file for the given detector and data type
500// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
501
502 TNamed* obj = new TNamed(detector, type);
503 obj->SetUniqueID(nEvents);
504 fEventsPerFile.Add(obj);
505}
506
507//_____________________________________________________________________________
508Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
509{
510 // Read the alignment objects from CDB.
511 // Each detector is supposed to have the
512 // alignment objects in DET/Align/Data CDB path.
513 // All the detector objects are then collected,
514 // sorted by geometry level (starting from ALIC) and
515 // then applied to the TGeo geometry.
516 // Finally an overlaps check is performed.
517
518 if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
519 AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
520 return kFALSE;
521 }
522
523 // initialize CDB storage, run number, set CDB lock
524 InitCDB();
525// if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
526 SetCDBLock();
527
528 Bool_t delRunLoader = kFALSE;
529 if (!runLoader) {
530 runLoader = LoadRun("READ");
531 if (!runLoader) return kFALSE;
532 delRunLoader = kTRUE;
533 }
534
535 // Export ideal geometry
536 if(!IsGeometryFromFile()) AliGeomManager::GetGeometry()->Export("geometry.root");
537
538 // Load alignment data from CDB and apply to geometry through AliGeomManager
539 if(fLoadAlignFromCDB){
540
541 TString detStr = fLoadAlObjsListOfDets;
542 TString loadAlObjsListOfDets = "";
543
544 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
545 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
546 AliModule* det = (AliModule*) detArray->At(iDet);
547 if (!det || !det->IsActive()) continue;
548 if (IsSelected(det->GetName(), detStr)) {
549 //add det to list of dets to be aligned from CDB
550 loadAlObjsListOfDets += det->GetName();
551 loadAlObjsListOfDets += " ";
552 }
553 } // end loop over detectors
554 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
555 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
556 }else{
557 // Check if the array with alignment objects was
558 // provided by the user. If yes, apply the objects
559 // to the present TGeo geometry
560 if (fAlignObjArray) {
561 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
562 AliError("The misalignment of one or more volumes failed!"
563 "Compare the list of simulated detectors and the list of detector alignment data!");
564 if (delRunLoader) delete runLoader;
565 return kFALSE;
566 }
567 }
568 }
569
570 // Update the internal geometry of modules (ITS needs it)
571 TString detStr = fLoadAlObjsListOfDets;
572 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
573 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
574
575 AliModule* det = (AliModule*) detArray->At(iDet);
576 if (!det || !det->IsActive()) continue;
577 if (IsSelected(det->GetName(), detStr)) {
578 det->UpdateInternalGeometry();
579 }
580 } // end loop over detectors
581
582
583 if (delRunLoader) delete runLoader;
584
585 return kTRUE;
586}
587
588//_____________________________________________________________________________
589void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
590{
591// add a file with background events for merging
592
593 TObjString* fileNameStr = new TObjString(fileName);
594 fileNameStr->SetUniqueID(nSignalPerBkgrd);
595 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
596 fBkgrdFileNames->Add(fileNameStr);
597}
598
599void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
600{
601// add a file with background events for embeddin
602 MergeWith(fileName, nSignalPerBkgrd);
603 fEmbeddingFlag = kTRUE;
604}
605
606//_____________________________________________________________________________
607Bool_t AliSimulation::Run(Int_t nEvents)
608{
609// run the generation, simulation and digitization
610
611
612 AliCodeTimerAuto("",0)
613 AliSysInfo::AddStamp("Start_Run");
614
615 // Load run number and seed from environmental vars
616 ProcessEnvironmentVars();
617 AliSysInfo::AddStamp("ProcessEnvironmentVars");
618
619 gRandom->SetSeed(fSeed);
620
621 if (nEvents > 0) fNEvents = nEvents;
622
623 // create and setup the HLT instance
624 if (!fRunHLT.IsNull() && !CreateHLT()) {
625 if (fStopOnError) return kFALSE;
626 // disable HLT
627 fRunHLT="";
628 }
629
630 // generation and simulation -> hits
631 if (fRunGeneration) {
632 if (!RunSimulation()) if (fStopOnError) return kFALSE;
633 }
634 AliSysInfo::AddStamp("RunSimulation");
635
636 // initialize CDB storage from external environment
637 // (either CDB manager or AliSimulation setters),
638 // if not already done in RunSimulation()
639 InitCDB();
640 AliSysInfo::AddStamp("InitCDB");
641
642 // Set run number in CDBManager from data
643 // From this point on the run number must be always loaded from data!
644 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
645
646 // Set CDB lock: from now on it is forbidden to reset the run number
647 // or the default storage or to activate any further storage!
648 SetCDBLock();
649
650 // If RunSimulation was not called, load the geometry and misalign it
651 if (!AliGeomManager::GetGeometry()) {
652 // Initialize the geometry manager
653 AliGeomManager::LoadGeometry("geometry.root");
654 AliSysInfo::AddStamp("GetGeometry");
655// // Check that the consistency of symbolic names for the activated subdetectors
656// // in the geometry loaded by AliGeomManager
657// AliRunLoader* runLoader = LoadRun("READ");
658// if (!runLoader) return kFALSE;
659//
660// TString detsToBeChecked = "";
661// TObjArray* detArray = runLoader->GetAliRun()->Detectors();
662// for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
663// AliModule* det = (AliModule*) detArray->At(iDet);
664// if (!det || !det->IsActive()) continue;
665// detsToBeChecked += det->GetName();
666// detsToBeChecked += " ";
667// } // end loop over detectors
668// if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
669 if(!AliGeomManager::CheckSymNamesLUT("ALL"))
670 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
671
672 if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
673 // Misalign geometry
674 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
675 }
676 AliSysInfo::AddStamp("MissalignGeometry");
677
678
679 // hits -> summable digits
680 AliSysInfo::AddStamp("Start_sdigitization");
681 if (!fMakeSDigits.IsNull()) {
682 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
683
684 }
685 AliSysInfo::AddStamp("Stop_sdigitization");
686
687 AliSysInfo::AddStamp("Start_digitization");
688 // summable digits -> digits
689 if (!fMakeDigits.IsNull()) {
690 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
691 if (fStopOnError) return kFALSE;
692 }
693 }
694 AliSysInfo::AddStamp("Stop_digitization");
695
696
697
698 // hits -> digits
699 if (!fMakeDigitsFromHits.IsNull()) {
700 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
701 AliWarning(Form("Merging and direct creation of digits from hits "
702 "was selected for some detectors. "
703 "No merging will be done for the following detectors: %s",
704 fMakeDigitsFromHits.Data()));
705 }
706 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
707 if (fStopOnError) return kFALSE;
708 }
709 }
710
711 AliSysInfo::AddStamp("Hits2Digits");
712
713
714 // digits -> trigger
715 if (!RunTrigger(fTriggerConfig,fMakeDigits)) {
716 if (fStopOnError) return kFALSE;
717 }
718
719 AliSysInfo::AddStamp("RunTrigger");
720
721
722 // digits -> raw data
723 if (!fWriteRawData.IsNull()) {
724 if (!WriteRawData(fWriteRawData, fRawDataFileName,
725 fDeleteIntermediateFiles,fWriteSelRawData)) {
726 if (fStopOnError) return kFALSE;
727 }
728 }
729
730 AliSysInfo::AddStamp("WriteRaw");
731
732 // run HLT simulation on simulated digit data if raw data is not
733 // simulated, otherwise its called as part of WriteRawData
734 if (!fRunHLT.IsNull() && fWriteRawData.IsNull()) {
735 if (!RunHLT()) {
736 if (fStopOnError) return kFALSE;
737 }
738 }
739
740 AliSysInfo::AddStamp("RunHLT");
741
742 //QA
743 if (fRunQA) {
744 Bool_t rv = RunQA() ;
745 if (!rv)
746 if (fStopOnError)
747 return kFALSE ;
748 }
749
750 AliSysInfo::AddStamp("RunQA");
751
752 // Cleanup of CDB manager: cache and active storages!
753 AliCDBManager::Instance()->ClearCache();
754
755 return kTRUE;
756}
757
758//_______________________________________________________________________
759Bool_t AliSimulation::RunLego(const char *setup, Int_t nc1, Float_t c1min,
760 Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
761 Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener, Int_t nev)
762{
763 //
764 // Generates lego plots of:
765 // - radiation length map phi vs theta
766 // - radiation length map phi vs eta
767 // - interaction length map
768 // - g/cm2 length map
769 //
770 // ntheta bins in theta, eta
771 // themin minimum angle in theta (degrees)
772 // themax maximum angle in theta (degrees)
773 // nphi bins in phi
774 // phimin minimum angle in phi (degrees)
775 // phimax maximum angle in phi (degrees)
776 // rmin minimum radius
777 // rmax maximum radius
778 //
779 //
780 // The number of events generated = ntheta*nphi
781 // run input parameters in macro setup (default="Config.C")
782 //
783 // Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
784 //Begin_Html
785 /*
786 <img src="picts/AliRunLego1.gif">
787 */
788 //End_Html
789 //Begin_Html
790 /*
791 <img src="picts/AliRunLego2.gif">
792 */
793 //End_Html
794 //Begin_Html
795 /*
796 <img src="picts/AliRunLego3.gif">
797 */
798 //End_Html
799 //
800
801// run the generation and simulation
802
803 AliCodeTimerAuto("",0)
804
805 // initialize CDB storage and run number from external environment
806 // (either CDB manager or AliSimulation setters)
807 InitCDB();
808 InitRunNumber();
809 SetCDBLock();
810
811 if (!gAlice) {
812 AliError("no gAlice object. Restart aliroot and try again.");
813 return kFALSE;
814 }
815 if (gAlice->Modules()->GetEntries() > 0) {
816 AliError("gAlice was already run. Restart aliroot and try again.");
817 return kFALSE;
818 }
819
820 AliInfo(Form("initializing gAlice with config file %s",
821 fConfigFileName.Data()));
822
823 // Number of events
824 if (nev == -1) nev = nc1 * nc2;
825
826 // check if initialisation has been done
827 // If runloader has been initialized, set the number of events per file to nc1 * nc2
828
829 // Set new generator
830 if (!gener) gener = new AliLegoGenerator();
831 //
832 // Configure Generator
833
834 gener->SetRadiusRange(rmin, rmax);
835 gener->SetZMax(zmax);
836 gener->SetCoor1Range(nc1, c1min, c1max);
837 gener->SetCoor2Range(nc2, c2min, c2max);
838
839
840 //Create Lego object
841 fLego = new AliLego("lego",gener);
842
843 //__________________________________________________________________________
844
845 gAlice->Announce();
846
847 gROOT->LoadMacro(setup);
848 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
849
850 if(AliCDBManager::Instance()->GetRun() >= 0) {
851 SetRunNumber(AliCDBManager::Instance()->GetRun());
852 } else {
853 AliWarning("Run number not initialized!!");
854 }
855
856 AliRunLoader::Instance()->CdGAFile();
857
858 AliPDG::AddParticlesToPdgDataBase();
859
860 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
861
862 gAlice->GetMCApp()->Init();
863
864
865 //Must be here because some MCs (G4) adds detectors here and not in Config.C
866 gAlice->InitLoaders();
867 AliRunLoader::Instance()->MakeTree("E");
868
869 //
870 // Save stuff at the beginning of the file to avoid file corruption
871 AliRunLoader::Instance()->CdGAFile();
872 gAlice->Write();
873
874 //Save current generator
875 AliGenerator *gen=gAlice->GetMCApp()->Generator();
876 gAlice->GetMCApp()->ResetGenerator(gener);
877 //Prepare MC for Lego Run
878 gMC->InitLego();
879
880 //Run Lego Object
881
882
883 AliRunLoader::Instance()->SetNumberOfEventsPerFile(nev);
884 gMC->ProcessRun(nev);
885
886 // End of this run, close files
887 FinishRun();
888 // Restore current generator
889 gAlice->GetMCApp()->ResetGenerator(gen);
890 // Delete Lego Object
891 delete fLego;
892
893 return kTRUE;
894}
895
896//_____________________________________________________________________________
897Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
898{
899 // run the trigger
900
901 AliCodeTimerAuto("",0)
902
903 // initialize CDB storage from external environment
904 // (either CDB manager or AliSimulation setters),
905 // if not already done in RunSimulation()
906 InitCDB();
907
908 // Set run number in CDBManager from data
909 // From this point on the run number must be always loaded from data!
910 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
911
912 // Set CDB lock: from now on it is forbidden to reset the run number
913 // or the default storage or to activate any further storage!
914 SetCDBLock();
915
916 AliRunLoader* runLoader = LoadRun("READ");
917 if (!runLoader) return kFALSE;
918 TString trconfiguration = config;
919
920 if (trconfiguration.IsNull()) {
921 if(!fTriggerConfig.IsNull()) {
922 trconfiguration = fTriggerConfig;
923 }
924 else
925 AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
926 }
927
928 runLoader->MakeTree( "GG" );
929 AliCentralTrigger* aCTP = runLoader->GetTrigger();
930 // Load Configuration
931 if (!aCTP->LoadConfiguration( trconfiguration ))
932 return kFALSE;
933
934 // digits -> trigger
935 if( !aCTP->RunTrigger( runLoader , detectors ) ) {
936 if (fStopOnError) {
937 // delete aCTP;
938 return kFALSE;
939 }
940 }
941
942 delete runLoader;
943
944 return kTRUE;
945}
946
947//_____________________________________________________________________________
948Bool_t AliSimulation::WriteTriggerRawData()
949{
950 // Writes the CTP (trigger) DDL raw data
951 // Details of the format are given in the
952 // trigger TDR - pages 134 and 135.
953 AliCTPRawData writer;
954 writer.RawData();
955
956 return kTRUE;
957}
958
959//_____________________________________________________________________________
960Bool_t AliSimulation::RunSimulation(Int_t nEvents)
961{
962// run the generation and simulation
963
964 AliCodeTimerAuto("",0)
965
966 // initialize CDB storage and run number from external environment
967 // (either CDB manager or AliSimulation setters)
968 AliSysInfo::AddStamp("RunSimulation_Begin");
969 InitCDB();
970 AliSysInfo::AddStamp("RunSimulation_InitCDB");
971 InitRunNumber();
972 SetCDBLock();
973 AliSysInfo::AddStamp("RunSimulation_SetCDBLock");
974
975 if (!gAlice) {
976 AliError("no gAlice object. Restart aliroot and try again.");
977 return kFALSE;
978 }
979 if (gAlice->Modules()->GetEntries() > 0) {
980 AliError("gAlice was already run. Restart aliroot and try again.");
981 return kFALSE;
982 }
983
984 AliInfo(Form("initializing gAlice with config file %s",
985 fConfigFileName.Data()));
986
987 //
988 // Initialize ALICE Simulation run
989 //
990 gAlice->Announce();
991
992 //
993 // If requested set the mag. field from the GRP entry.
994 // After this the field is loccked and cannot be changed by Config.C
995 if (fUseMagFieldFromGRP) {
996 AliGRPManager grpM;
997 grpM.ReadGRPEntry();
998 grpM.SetMagField();
999 AliInfo("Field is locked now. It cannot be changed in Config.C");
1000 }
1001//
1002// Execute Config.C
1003 gROOT->LoadMacro(fConfigFileName.Data());
1004 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
1005 AliSysInfo::AddStamp("RunSimulation_Config");
1006
1007//
1008// If requested obtain the vertex position and vertex sigma_z from the CDB
1009// This overwrites the settings from the Config.C
1010 if (fUseVertexFromCDB) {
1011 Double_t vtxPos[3] = {0., 0., 0.};
1012 Double_t vtxSig[3] = {0., 0., 0.};
1013 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1014 if (entry) {
1015 AliESDVertex* vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1016 if (vertex) {
1017 if(vertex->GetXRes()>2.8) { // > pipe radius --> it's a dummy object, don't use it
1018 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1019 if (entry) vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1020 }
1021 }
1022 if (vertex) {
1023 vertex->GetXYZ(vtxPos);
1024 vertex->GetSigmaXYZ(vtxSig);
1025 AliInfo("Overwriting Config.C vertex settings !");
1026 AliInfo(Form("Vertex position from OCDB entry: x = %13.3f, y = %13.3f, z = %13.3f (sigma = %13.3f)\n",
1027 vtxPos[0], vtxPos[1], vtxPos[2], vtxSig[2]));
1028
1029 AliGenerator *gen = gAlice->GetMCApp()->Generator();
1030 gen->SetOrigin(vtxPos[0], vtxPos[1], vtxPos[2]); // vertex position
1031 gen->SetSigmaZ(vtxSig[2]);
1032 }
1033 }
1034 }
1035
1036 if(AliCDBManager::Instance()->GetRun() >= 0) {
1037 AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
1038 AliRunLoader::Instance()->SetNumberOfEventsPerRun(fNEvents);
1039 } else {
1040 AliWarning("Run number not initialized!!");
1041 }
1042
1043 AliRunLoader::Instance()->CdGAFile();
1044
1045
1046 AliPDG::AddParticlesToPdgDataBase();
1047
1048 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
1049 AliSysInfo::AddStamp("RunSimulation_GetField");
1050
1051 gAlice->GetMCApp()->Init();
1052 AliSysInfo::AddStamp("RunSimulation_InitMCApp");
1053
1054 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1055 gAlice->InitLoaders();
1056 AliRunLoader::Instance()->MakeTree("E");
1057 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1058 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1059 AliRunLoader::Instance()->LoadHits("all","RECREATE");
1060 //
1061 // Save stuff at the beginning of the file to avoid file corruption
1062 AliRunLoader::Instance()->CdGAFile();
1063 gAlice->Write();
1064 gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
1065 AliSysInfo::AddStamp("RunSimulation_InitLoaders");
1066 //___________________________________________________________________________________________
1067
1068 AliSysInfo::AddStamp("RunSimulation_TriggerDescriptor");
1069
1070 // Set run number in CDBManager
1071 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
1072
1073 AliRunLoader* runLoader = AliRunLoader::Instance();
1074 if (!runLoader) {
1075 AliError(Form("gAlice has no run loader object. "
1076 "Check your config file: %s", fConfigFileName.Data()));
1077 return kFALSE;
1078 }
1079 SetGAliceFile(runLoader->GetFileName());
1080
1081 // Misalign geometry
1082#if ROOT_VERSION_CODE < 331527
1083 AliGeomManager::SetGeometry(gGeoManager);
1084
1085 // Check that the consistency of symbolic names for the activated subdetectors
1086 // in the geometry loaded by AliGeomManager
1087 TString detsToBeChecked = "";
1088 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1089 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1090 AliModule* det = (AliModule*) detArray->At(iDet);
1091 if (!det || !det->IsActive()) continue;
1092 detsToBeChecked += det->GetName();
1093 detsToBeChecked += " ";
1094 } // end loop over detectors
1095 if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
1096 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
1097 MisalignGeometry(runLoader);
1098 AliSysInfo::AddStamp("RunSimulation_MisalignGeometry");
1099#endif
1100
1101// AliRunLoader* runLoader = AliRunLoader::Instance();
1102// if (!runLoader) {
1103// AliError(Form("gAlice has no run loader object. "
1104// "Check your config file: %s", fConfigFileName.Data()));
1105// return kFALSE;
1106// }
1107// SetGAliceFile(runLoader->GetFileName());
1108
1109 if (!gAlice->GetMCApp()->Generator()) {
1110 AliError(Form("gAlice has no generator object. "
1111 "Check your config file: %s", fConfigFileName.Data()));
1112 return kFALSE;
1113 }
1114
1115 // Write GRP entry corresponding to the setting found in Cofig.C
1116 if (fWriteGRPEntry)
1117 WriteGRPEntry();
1118 AliSysInfo::AddStamp("RunSimulation_WriteGRP");
1119
1120 if (nEvents <= 0) nEvents = fNEvents;
1121
1122 // get vertex from background file in case of merging
1123 if (fUseBkgrdVertex &&
1124 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
1125 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
1126 const char* fileName = ((TObjString*)
1127 (fBkgrdFileNames->At(0)))->GetName();
1128 AliInfo(Form("The vertex will be taken from the background "
1129 "file %s with nSignalPerBackground = %d",
1130 fileName, signalPerBkgrd));
1131 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
1132 gAlice->GetMCApp()->Generator()->SetVertexGenerator(vtxGen);
1133 }
1134
1135 if (!fRunSimulation) {
1136 gAlice->GetMCApp()->Generator()->SetTrackingFlag(0);
1137 }
1138
1139 // set the number of events per file for given detectors and data types
1140 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
1141 if (!fEventsPerFile[i]) continue;
1142 const char* detName = fEventsPerFile[i]->GetName();
1143 const char* typeName = fEventsPerFile[i]->GetTitle();
1144 TString loaderName(detName);
1145 loaderName += "Loader";
1146 AliLoader* loader = runLoader->GetLoader(loaderName);
1147 if (!loader) {
1148 AliError(Form("RunSimulation no loader for %s found\n Number of events per file not set for %s %s",
1149 detName, typeName, detName));
1150 continue;
1151 }
1152 AliDataLoader* dataLoader =
1153 loader->GetDataLoader(typeName);
1154 if (!dataLoader) {
1155 AliError(Form("no data loader for %s found\n"
1156 "Number of events per file not set for %s %s",
1157 typeName, detName, typeName));
1158 continue;
1159 }
1160 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
1161 AliDebug(1, Form("number of events per file set to %d for %s %s",
1162 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
1163 }
1164
1165 AliInfo("running gAlice");
1166 AliSysInfo::AddStamp("Start_ProcessRun");
1167
1168 // Create the Root Tree with one branch per detector
1169 //Hits moved to begin event -> now we are crating separate tree for each event
1170
1171 gMC->ProcessRun(nEvents);
1172
1173 // End of this run, close files
1174 if(nEvents>0) FinishRun();
1175
1176 AliSysInfo::AddStamp("Stop_ProcessRun");
1177 delete runLoader;
1178
1179 return kTRUE;
1180}
1181
1182//_____________________________________________________________________________
1183Bool_t AliSimulation::RunSDigitization(const char* detectors)
1184{
1185// run the digitization and produce summable digits
1186 static Int_t eventNr=0;
1187 AliCodeTimerAuto("",0) ;
1188
1189 // initialize CDB storage, run number, set CDB lock
1190 InitCDB();
1191 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1192 SetCDBLock();
1193
1194 AliRunLoader* runLoader = LoadRun();
1195 if (!runLoader) return kFALSE;
1196
1197 TString detStr = detectors;
1198 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1199 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1200 AliModule* det = (AliModule*) detArray->At(iDet);
1201 if (!det || !det->IsActive()) continue;
1202 if (IsSelected(det->GetName(), detStr)) {
1203 AliInfo(Form("creating summable digits for %s", det->GetName()));
1204 AliCodeTimerStart(Form("creating summable digits for %s", det->GetName()));
1205 det->Hits2SDigits();
1206 AliCodeTimerStop(Form("creating summable digits for %s", det->GetName()));
1207 AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
1208 }
1209 }
1210
1211 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1212 AliError(Form("the following detectors were not found: %s",
1213 detStr.Data()));
1214 if (fStopOnError) return kFALSE;
1215 }
1216 eventNr++;
1217 delete runLoader;
1218
1219 return kTRUE;
1220}
1221
1222
1223//_____________________________________________________________________________
1224Bool_t AliSimulation::RunDigitization(const char* detectors,
1225 const char* excludeDetectors)
1226{
1227// run the digitization and produce digits from sdigits
1228
1229 AliCodeTimerAuto("",0)
1230
1231 // initialize CDB storage, run number, set CDB lock
1232 InitCDB();
1233 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1234 SetCDBLock();
1235
1236 delete AliRunLoader::Instance();
1237 delete gAlice;
1238 gAlice = NULL;
1239
1240 Int_t nStreams = 1;
1241 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
1242 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
1243 AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
1244 // manager->SetEmbeddingFlag(fEmbeddingFlag);
1245 manager->SetInputStream(0, fGAliceFileName.Data());
1246 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
1247 const char* fileName = ((TObjString*)
1248 (fBkgrdFileNames->At(iStream-1)))->GetName();
1249 manager->SetInputStream(iStream, fileName);
1250 }
1251
1252 TString detStr = detectors;
1253 TString detExcl = excludeDetectors;
1254 manager->GetInputStream(0)->ImportgAlice();
1255 AliRunLoader* runLoader =
1256 AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
1257 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1258 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1259 AliModule* det = (AliModule*) detArray->At(iDet);
1260 if (!det || !det->IsActive()) continue;
1261 if (IsSelected(det->GetName(), detStr) &&
1262 !IsSelected(det->GetName(), detExcl)) {
1263 AliDigitizer* digitizer = det->CreateDigitizer(manager);
1264
1265 if (!digitizer) {
1266 AliError(Form("no digitizer for %s", det->GetName()));
1267 if (fStopOnError) return kFALSE;
1268 } else {
1269 digitizer->SetRegionOfInterest(fRegionOfInterest);
1270 }
1271 }
1272 }
1273
1274 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1275 AliError(Form("the following detectors were not found: %s",
1276 detStr.Data()));
1277 if (fStopOnError) return kFALSE;
1278 }
1279
1280 if (!manager->GetListOfTasks()->IsEmpty()) {
1281 AliInfo("executing digitization");
1282 manager->Exec("");
1283 }
1284
1285 delete manager;
1286
1287 return kTRUE;
1288}
1289
1290//_____________________________________________________________________________
1291Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
1292{
1293// run the digitization and produce digits from hits
1294
1295 AliCodeTimerAuto("",0)
1296
1297 // initialize CDB storage, run number, set CDB lock
1298 InitCDB();
1299 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1300 SetCDBLock();
1301
1302 AliRunLoader* runLoader = LoadRun("READ");
1303 if (!runLoader) return kFALSE;
1304
1305 TString detStr = detectors;
1306 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1307 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1308 AliModule* det = (AliModule*) detArray->At(iDet);
1309 if (!det || !det->IsActive()) continue;
1310 if (IsSelected(det->GetName(), detStr)) {
1311 AliInfo(Form("creating digits from hits for %s", det->GetName()));
1312 det->Hits2Digits();
1313 }
1314 }
1315
1316 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1317 AliError(Form("the following detectors were not found: %s",
1318 detStr.Data()));
1319 if (fStopOnError) return kFALSE;
1320 }
1321
1322 return kTRUE;
1323}
1324
1325//_____________________________________________________________________________
1326Bool_t AliSimulation::WriteRawData(const char* detectors,
1327 const char* fileName,
1328 Bool_t deleteIntermediateFiles,
1329 Bool_t selrawdata)
1330{
1331// convert the digits to raw data
1332// First DDL raw data files for the given detectors are created.
1333// If a file name is given, the DDL files are then converted to a DATE file.
1334// If deleteIntermediateFiles is true, the DDL raw files are deleted
1335// afterwards.
1336// If the file name has the extension ".root", the DATE file is converted
1337// to a root file.
1338// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
1339// 'selrawdata' flag can be used to enable writing of detectors raw data
1340// accoring to the trigger cluster.
1341
1342 AliCodeTimerAuto("",0)
1343 AliSysInfo::AddStamp("WriteRawData_Start");
1344
1345 TString detStr = detectors;
1346 if (!WriteRawFiles(detStr.Data())) {
1347 if (fStopOnError) return kFALSE;
1348 }
1349 AliSysInfo::AddStamp("WriteRawFiles");
1350
1351 // run HLT simulation on simulated DDL raw files
1352 // and produce HLT ddl raw files to be included in date/root file
1353 // bugfix 2009-06-26: the decision whether to write HLT raw data
1354 // is taken in RunHLT. Here HLT always needs to be run in order to
1355 // create HLT digits, unless its switched off. This is due to the
1356 // special placement of the HLT between the generation of DDL files
1357 // and conversion to DATE/Root file.
1358 detStr.ReplaceAll("HLT", "");
1359 if (!fRunHLT.IsNull()) {
1360 if (!RunHLT()) {
1361 if (fStopOnError) return kFALSE;
1362 }
1363 }
1364 AliSysInfo::AddStamp("WriteRawData_RunHLT");
1365
1366 TString dateFileName(fileName);
1367 if (!dateFileName.IsNull()) {
1368 Bool_t rootOutput = dateFileName.EndsWith(".root");
1369 if (rootOutput) dateFileName += ".date";
1370 TString selDateFileName;
1371 if (selrawdata) {
1372 selDateFileName = "selected.";
1373 selDateFileName+= dateFileName;
1374 }
1375 if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
1376 if (fStopOnError) return kFALSE;
1377 }
1378 AliSysInfo::AddStamp("ConvertRawFilesToDate");
1379 if (deleteIntermediateFiles) {
1380 AliRunLoader* runLoader = LoadRun("READ");
1381 if (runLoader) for (Int_t iEvent = 0;
1382 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1383 char command[256];
1384 snprintf(command, 256, "rm -r raw%d", iEvent);
1385 gSystem->Exec(command);
1386 }
1387 delete runLoader;
1388 }
1389
1390 if (rootOutput) {
1391 if (!ConvertDateToRoot(dateFileName, fileName)) {
1392 if (fStopOnError) return kFALSE;
1393 }
1394 AliSysInfo::AddStamp("ConvertDateToRoot");
1395 if (deleteIntermediateFiles) {
1396 gSystem->Unlink(dateFileName);
1397 }
1398 if (selrawdata) {
1399 TString selFileName = "selected.";
1400 selFileName += fileName;
1401 if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1402 if (fStopOnError) return kFALSE;
1403 }
1404 if (deleteIntermediateFiles) {
1405 gSystem->Unlink(selDateFileName);
1406 }
1407 }
1408 }
1409 }
1410
1411 return kTRUE;
1412}
1413
1414//_____________________________________________________________________________
1415Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1416{
1417// convert the digits to raw data DDL files
1418
1419 AliCodeTimerAuto("",0)
1420
1421 AliRunLoader* runLoader = LoadRun("READ");
1422 if (!runLoader) return kFALSE;
1423
1424 // write raw data to DDL files
1425 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1426 AliInfo(Form("processing event %d", iEvent));
1427 runLoader->GetEvent(iEvent);
1428 TString baseDir = gSystem->WorkingDirectory();
1429 char dirName[256];
1430 snprintf(dirName, 256, "raw%d", iEvent);
1431 gSystem->MakeDirectory(dirName);
1432 if (!gSystem->ChangeDirectory(dirName)) {
1433 AliError(Form("couldn't change to directory %s", dirName));
1434 if (fStopOnError) return kFALSE; else continue;
1435 }
1436
1437 ofstream runNbFile(Form("run%u",runLoader->GetHeader()->GetRun()));
1438 runNbFile.close();
1439
1440 TString detStr = detectors;
1441 if (IsSelected("HLT", detStr)) {
1442 // Do nothing. "HLT" will be removed from detStr and HLT raw
1443 // data files are generated in RunHLT.
1444 }
1445
1446 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1447 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1448 AliModule* det = (AliModule*) detArray->At(iDet);
1449 if (!det || !det->IsActive()) continue;
1450 if (IsSelected(det->GetName(), detStr)) {
1451 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
1452 det->Digits2Raw();
1453 }
1454 }
1455
1456 if (!WriteTriggerRawData())
1457 if (fStopOnError) return kFALSE;
1458
1459 gSystem->ChangeDirectory(baseDir);
1460 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1461 AliError(Form("the following detectors were not found: %s",
1462 detStr.Data()));
1463 if (fStopOnError) return kFALSE;
1464 }
1465 }
1466
1467 delete runLoader;
1468
1469 return kTRUE;
1470}
1471
1472//_____________________________________________________________________________
1473Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1474 const char* selDateFileName)
1475{
1476// convert raw data DDL files to a DATE file with the program "dateStream"
1477// The second argument is not empty when the user decides to write
1478// the detectors raw data according to the trigger cluster.
1479
1480 AliCodeTimerAuto("",0)
1481
1482 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1483 if (!path) {
1484 AliError("the program dateStream was not found");
1485 if (fStopOnError) return kFALSE;
1486 } else {
1487 delete[] path;
1488 }
1489
1490 AliRunLoader* runLoader = LoadRun("READ");
1491 if (!runLoader) return kFALSE;
1492
1493 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
1494 Bool_t selrawdata = kFALSE;
1495 if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1496
1497 char command[256];
1498 // Note the option -s. It is used in order to avoid
1499 // the generation of SOR/EOR events.
1500 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
1501 dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
1502 FILE* pipe = gSystem->OpenPipe(command, "w");
1503
1504 if (!pipe) {
1505 AliError(Form("Cannot execute command: %s",command));
1506 return kFALSE;
1507 }
1508
1509 Int_t selEvents = 0;
1510 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1511
1512 UInt_t detectorPattern = 0;
1513 runLoader->GetEvent(iEvent);
1514 if (!runLoader->LoadTrigger()) {
1515 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1516 detectorPattern = aCTP->GetClusterMask();
1517 // Check if the event was triggered by CTP
1518 if (selrawdata) {
1519 if (aCTP->GetClassMask()) selEvents++;
1520 }
1521 }
1522 else {
1523 AliWarning("No trigger can be loaded! Some fields in the event header will be empty !");
1524 if (selrawdata) {
1525 AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1526 selrawdata = kFALSE;
1527 }
1528 }
1529
1530 fprintf(pipe, "GDC DetectorPattern %u\n", detectorPattern);
1531 Float_t ldc = 0;
1532 Int_t prevLDC = -1;
1533
1534 // loop over detectors and DDLs
1535 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1536 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1537
1538 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1539 Int_t ldcID = Int_t(ldc + 0.0001);
1540 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1541
1542 char rawFileName[256];
1543 snprintf(rawFileName, 256, "raw%d/%s",
1544 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1545
1546 // check existence and size of raw data file
1547 FILE* file = fopen(rawFileName, "rb");
1548 if (!file) continue;
1549 fseek(file, 0, SEEK_END);
1550 unsigned long size = ftell(file);
1551 fclose(file);
1552 if (!size) continue;
1553
1554 if (ldcID != prevLDC) {
1555 fprintf(pipe, " LDC Id %d\n", ldcID);
1556 prevLDC = ldcID;
1557 }
1558 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1559 }
1560 }
1561 }
1562
1563 Int_t result = gSystem->ClosePipe(pipe);
1564
1565 if (!(selrawdata && selEvents > 0)) {
1566 delete runLoader;
1567 return (result == 0);
1568 }
1569
1570 AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1571
1572 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
1573 selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1574 FILE* pipe2 = gSystem->OpenPipe(command, "w");
1575
1576 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1577
1578 // Get the trigger decision and cluster
1579 UInt_t detectorPattern = 0;
1580 TString detClust;
1581 runLoader->GetEvent(iEvent);
1582 if (!runLoader->LoadTrigger()) {
1583 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1584 if (aCTP->GetClassMask() == 0) continue;
1585 detectorPattern = aCTP->GetClusterMask();
1586 detClust = AliDAQ::ListOfTriggeredDetectors(detectorPattern);
1587 AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1588 }
1589
1590 fprintf(pipe2, "GDC DetectorPattern %u\n", detectorPattern);
1591 Float_t ldc = 0;
1592 Int_t prevLDC = -1;
1593
1594 // loop over detectors and DDLs
1595 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1596 // Write only raw data from detectors that
1597 // are contained in the trigger cluster(s)
1598 if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1599
1600 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1601
1602 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1603 Int_t ldcID = Int_t(ldc + 0.0001);
1604 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1605
1606 char rawFileName[256];
1607 snprintf(rawFileName, 256, "raw%d/%s",
1608 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1609
1610 // check existence and size of raw data file
1611 FILE* file = fopen(rawFileName, "rb");
1612 if (!file) continue;
1613 fseek(file, 0, SEEK_END);
1614 unsigned long size = ftell(file);
1615 fclose(file);
1616 if (!size) continue;
1617
1618 if (ldcID != prevLDC) {
1619 fprintf(pipe2, " LDC Id %d\n", ldcID);
1620 prevLDC = ldcID;
1621 }
1622 fprintf(pipe2, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1623 }
1624 }
1625 }
1626
1627 Int_t result2 = gSystem->ClosePipe(pipe2);
1628
1629 delete runLoader;
1630 return ((result == 0) && (result2 == 0));
1631}
1632
1633//_____________________________________________________________________________
1634Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1635 const char* rootFileName)
1636{
1637// convert a DATE file to a root file with the program "alimdc"
1638
1639 // ALIMDC setup
1640 const Int_t kDBSize = 2000000000;
1641 const Int_t kTagDBSize = 1000000000;
1642 const Bool_t kFilter = kFALSE;
1643 const Int_t kCompression = 1;
1644
1645 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1646 if (!path) {
1647 AliError("the program alimdc was not found");
1648 if (fStopOnError) return kFALSE;
1649 } else {
1650 delete[] path;
1651 }
1652
1653 AliInfo(Form("converting DATE file %s to root file %s",
1654 dateFileName, rootFileName));
1655
1656 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1657 const char* tagDBFS = "/tmp/mdc1/tags";
1658
1659 // User defined file system locations
1660 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1661 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1662 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1663 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1664 if (gSystem->Getenv("ALIMDC_TAGDB"))
1665 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
1666
1667 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1668 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1669 gSystem->Exec(Form("rm -rf %s",tagDBFS));
1670
1671 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1672 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1673 gSystem->Exec(Form("mkdir %s",tagDBFS));
1674
1675 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1676 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1677 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1678
1679 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1680 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1681 gSystem->Exec(Form("rm -rf %s",tagDBFS));
1682
1683 return (result == 0);
1684}
1685
1686
1687//_____________________________________________________________________________
1688AliRunLoader* AliSimulation::LoadRun(const char* mode) const
1689{
1690// delete existing run loaders, open a new one and load gAlice
1691
1692 delete AliRunLoader::Instance();
1693 AliRunLoader* runLoader =
1694 AliRunLoader::Open(fGAliceFileName.Data(),
1695 AliConfig::GetDefaultEventFolderName(), mode);
1696 if (!runLoader) {
1697 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1698 return NULL;
1699 }
1700 runLoader->LoadgAlice();
1701 runLoader->LoadHeader();
1702 gAlice = runLoader->GetAliRun();
1703 if (!gAlice) {
1704 AliError(Form("no gAlice object found in file %s",
1705 fGAliceFileName.Data()));
1706 return NULL;
1707 }
1708 return runLoader;
1709}
1710
1711//_____________________________________________________________________________
1712Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1713{
1714// get or calculate the number of signal events per background event
1715
1716 if (!fBkgrdFileNames) return 1;
1717 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1718 if (nBkgrdFiles == 0) return 1;
1719
1720 // get the number of signal events
1721 if (nEvents <= 0) {
1722 AliRunLoader* runLoader =
1723 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
1724 if (!runLoader) return 1;
1725
1726 nEvents = runLoader->GetNumberOfEvents();
1727 delete runLoader;
1728 }
1729
1730 Int_t result = 0;
1731 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1732 // get the number of background events
1733 const char* fileName = ((TObjString*)
1734 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
1735 AliRunLoader* runLoader =
1736 AliRunLoader::Open(fileName, "BKGRD");
1737 if (!runLoader) continue;
1738 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1739 delete runLoader;
1740
1741 // get or calculate the number of signal per background events
1742 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1743 if (nSignalPerBkgrd <= 0) {
1744 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1745 } else if (result && (result != nSignalPerBkgrd)) {
1746 AliInfo(Form("the number of signal events per background event "
1747 "will be changed from %d to %d for stream %d",
1748 nSignalPerBkgrd, result, iBkgrdFile+1));
1749 nSignalPerBkgrd = result;
1750 }
1751
1752 if (!result) result = nSignalPerBkgrd;
1753 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
1754 AliWarning(Form("not enough background events (%d) for %d signal events "
1755 "using %d signal per background events for stream %d",
1756 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
1757 }
1758 }
1759
1760 return result;
1761}
1762
1763//_____________________________________________________________________________
1764Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1765{
1766// check whether detName is contained in detectors
1767// if yes, it is removed from detectors
1768
1769 // check if all detectors are selected
1770 if ((detectors.CompareTo("ALL") == 0) ||
1771 detectors.BeginsWith("ALL ") ||
1772 detectors.EndsWith(" ALL") ||
1773 detectors.Contains(" ALL ")) {
1774 detectors = "ALL";
1775 return kTRUE;
1776 }
1777
1778 // search for the given detector
1779 Bool_t result = kFALSE;
1780 if ((detectors.CompareTo(detName) == 0) ||
1781 detectors.BeginsWith(detName+" ") ||
1782 detectors.EndsWith(" "+detName) ||
1783 detectors.Contains(" "+detName+" ")) {
1784 detectors.ReplaceAll(detName, "");
1785 result = kTRUE;
1786 }
1787
1788 // clean up the detectors string
1789 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1790 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1791 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1792
1793 return result;
1794}
1795
1796//_____________________________________________________________________________
1797Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName, Int_t N)
1798{
1799//
1800// Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1801// These can be used for embedding of MC tracks into RAW data using the standard
1802// merging procedure.
1803//
1804// If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1805//
1806 if (!gAlice) {
1807 AliError("no gAlice object. Restart aliroot and try again.");
1808 return kFALSE;
1809 }
1810 if (gAlice->Modules()->GetEntries() > 0) {
1811 AliError("gAlice was already run. Restart aliroot and try again.");
1812 return kFALSE;
1813 }
1814
1815 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1816
1817 gAlice->Announce();
1818
1819 gROOT->LoadMacro(fConfigFileName.Data());
1820 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
1821
1822 if(AliCDBManager::Instance()->GetRun() >= 0) {
1823 SetRunNumber(AliCDBManager::Instance()->GetRun());
1824 } else {
1825 AliWarning("Run number not initialized!!");
1826 }
1827
1828 AliRunLoader::Instance()->CdGAFile();
1829
1830 AliPDG::AddParticlesToPdgDataBase();
1831
1832 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
1833
1834 gAlice->GetMCApp()->Init();
1835
1836 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1837 gAlice->InitLoaders();
1838 AliRunLoader::Instance()->MakeTree("E");
1839 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1840 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1841 AliRunLoader::Instance()->LoadHits("all","RECREATE");
1842
1843 //
1844 // Save stuff at the beginning of the file to avoid file corruption
1845 AliRunLoader::Instance()->CdGAFile();
1846 gAlice->Write();
1847//
1848// Initialize CDB
1849 InitCDB();
1850 //AliCDBManager* man = AliCDBManager::Instance();
1851 //man->SetRun(0); // Should this come from rawdata header ?
1852
1853 Int_t iDet;
1854 //
1855 // Get the runloader
1856 AliRunLoader* runLoader = AliRunLoader::Instance();
1857 //
1858 // Open esd file if available
1859 TFile* esdFile = 0;
1860 TTree* treeESD = 0;
1861 AliESDEvent* esd = 0;
1862 if (esdFileName && (strlen(esdFileName)>0)) {
1863 esdFile = TFile::Open(esdFileName);
1864 if (esdFile) {
1865 esd = new AliESDEvent();
1866 esdFile->GetObject("esdTree", treeESD);
1867 if (treeESD) esd->ReadFromTree(treeESD);
1868 }
1869 }
1870
1871 //
1872 // Create the RawReader
1873 TString fileName(rawDirectory);
1874 AliRawReader* rawReader = 0x0;
1875 if (fileName.EndsWith("/")) {
1876 rawReader = new AliRawReaderFile(fileName);
1877 } else if (fileName.EndsWith(".root")) {
1878 rawReader = new AliRawReaderRoot(fileName);
1879 } else if (!fileName.IsNull()) {
1880 rawReader = new AliRawReaderDate(fileName);
1881 }
1882 if (!rawReader) return (kFALSE);
1883
1884// if (!fEquipIdMap.IsNull() && fRawReader)
1885// fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1886 //
1887 // Get list of detectors
1888 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1889 //
1890 // Get Header
1891 AliHeader* header = runLoader->GetHeader();
1892 // Event loop
1893 Int_t nev = 0;
1894 while(kTRUE) {
1895 if (!(rawReader->NextEvent())) break;
1896 runLoader->SetEventNumber(nev);
1897 runLoader->GetHeader()->Reset(rawReader->GetRunNumber(),
1898 nev, nev);
1899 runLoader->TreeE()->Fill();
1900 runLoader->GetEvent(nev);
1901 AliInfo(Form("We are at event %d",nev));
1902 //
1903 // Detector loop
1904 TString detStr = fMakeSDigits;
1905 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1906 AliModule* det = (AliModule*) detArray->At(iDet);
1907 if (!det || !det->IsActive()) continue;
1908 if (IsSelected(det->GetName(), detStr)) {
1909 AliInfo(Form("Calling Raw2SDigits for %s", det->GetName()));
1910 det->Raw2SDigits(rawReader);
1911 rawReader->Reset();
1912 }
1913 } // detectors
1914
1915
1916 //
1917 // If ESD information available obtain reconstructed vertex and store in header.
1918 if (treeESD) {
1919 treeESD->GetEvent(nev);
1920 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1921 Double_t position[3];
1922 esdVertex->GetXYZ(position);
1923 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
1924 TArrayF mcV;
1925 mcV.Set(3);
1926 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1927 mcHeader->SetPrimaryVertex(mcV);
1928 header->Reset(0,nev);
1929 header->SetGenEventHeader(mcHeader);
1930 AliInfo(Form("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]));
1931 }
1932//
1933// Finish the event
1934 AliInfo(Form("Finished event %d",nev));
1935 nev++;
1936 if (N>0&&nev>=N)
1937 break;
1938 } // events
1939
1940 delete rawReader;
1941//
1942// Finish the run
1943 runLoader->CdGAFile();
1944 runLoader->WriteHeader("OVERWRITE");
1945 runLoader->WriteRunLoader();
1946
1947 return kTRUE;
1948}
1949
1950//_____________________________________________________________________________
1951void AliSimulation::FinishRun()
1952{
1953 //
1954 // Called at the end of the run.
1955 //
1956
1957 if(IsLegoRun())
1958 {
1959 AliDebug(1, "Finish Lego");
1960 AliRunLoader::Instance()->CdGAFile();
1961 fLego->FinishRun();
1962 }
1963
1964 // Clean detector information
1965 TIter next(gAlice->Modules());
1966 AliModule *detector;
1967 while((detector = dynamic_cast<AliModule*>(next()))) {
1968 AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
1969 detector->FinishRun();
1970 }
1971
1972 AliDebug(1, "AliRunLoader::Instance()->WriteHeader(OVERWRITE)");
1973 AliRunLoader::Instance()->WriteHeader("OVERWRITE");
1974
1975 // Write AliRun info and all detectors parameters
1976 AliRunLoader::Instance()->CdGAFile();
1977 gAlice->Write(0,TObject::kOverwrite);//write AliRun
1978 AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
1979
1980 if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();
1981 AliRunLoader::Instance()->Synchronize();
1982}
1983
1984//_____________________________________________________________________________
1985Int_t AliSimulation::GetDetIndex(const char* detector)
1986{
1987 // return the detector index corresponding to detector
1988 Int_t index = -1 ;
1989 for (index = 0; index < fgkNDetectors ; index++) {
1990 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
1991 break ;
1992 }
1993 return index ;
1994}
1995
1996//_____________________________________________________________________________
1997Bool_t AliSimulation::CreateHLT()
1998{
1999 // Init the HLT simulation.
2000 // The function loads the library and creates the instance of AliHLTSimulation.
2001 // the main reason for the decoupled creation is to set the transient OCDB
2002 // objects before the OCDB is locked
2003
2004 // load the library dynamically
2005 gSystem->Load(ALIHLTSIMULATION_LIBRARY);
2006
2007 // check for the library version
2008 AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
2009 if (!fctVersion) {
2010 AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
2011 return kFALSE;
2012 }
2013 if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
2014 AliWarning(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
2015 }
2016
2017 // print compile info
2018 typedef void (*CompileInfo)( const char*& date, const char*& time);
2019 CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
2020 if (fctInfo) {
2021 const char* date="";
2022 const char* time="";
2023 (*fctInfo)(date, time);
2024 if (!date) date="unknown";
2025 if (!time) time="unknown";
2026 AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
2027 } else {
2028 AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
2029 }
2030
2031 // create instance of the HLT simulation
2032 AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
2033 if (fctCreate==NULL || (fpHLT=(fctCreate()))==NULL) {
2034 AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
2035 return kFALSE;
2036 }
2037
2038 TString specObjects;
2039 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
2040 if (specObjects.Length()>0) specObjects+=" ";
2041 specObjects+=fSpecCDBUri[i]->GetName();
2042 }
2043
2044 AliHLTSimulationSetup_t fctSetup=(AliHLTSimulationSetup_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_SETUP));
2045 if (fctSetup==NULL || fctSetup(fpHLT, this, specObjects.Data())<0) {
2046 AliWarning(Form("failed to setup HLT simulation (function %p)", fctSetup));
2047 }
2048
2049 return kTRUE;
2050}
2051
2052//_____________________________________________________________________________
2053Bool_t AliSimulation::RunHLT()
2054{
2055 // Run the HLT simulation
2056 // HLT simulation is implemented in HLT/sim/AliHLTSimulation
2057 // Disabled if fRunHLT is empty, default vaule is "default".
2058 // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
2059 // The default simulation depends on the HLT component libraries and their
2060 // corresponding agents which define components and chains to run. See
2061 // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/
2062 // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/classAliHLTModuleAgent.html
2063 //
2064 // The libraries to be loaded can be specified as an option.
2065 // <pre>
2066 // AliSimulation sim;
2067 // sim.SetRunHLT("libAliHLTSample.so");
2068 // </pre>
2069 // will only load <tt>libAliHLTSample.so</tt>
2070
2071 // Other available options:
2072 // \li loglevel=<i>level</i> <br>
2073 // logging level for this processing
2074 // \li alilog=off
2075 // disable redirection of log messages to AliLog class
2076 // \li config=<i>macro</i>
2077 // configuration macro
2078 // \li chains=<i>configuration</i>
2079 // comma separated list of configurations to be run during simulation
2080 // \li rawfile=<i>file</i>
2081 // source for the RawReader to be created, the default is <i>./</i> if
2082 // raw data is simulated
2083
2084 int iResult=0;
2085
2086 if (!fpHLT && !CreateHLT()) {
2087 return kFALSE;
2088 }
2089 AliHLTSimulation* pHLT=fpHLT;
2090
2091 AliRunLoader* pRunLoader = LoadRun("READ");
2092 if (!pRunLoader) return kFALSE;
2093
2094 // initialize CDB storage, run number, set CDB lock
2095 // thats for the case of running HLT simulation without all the other steps
2096 // multiple calls are handled by the function, so we can just call
2097 InitCDB();
2098 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
2099 SetCDBLock();
2100
2101 // init the HLT simulation
2102 TString options;
2103 if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
2104 TString detStr = fWriteRawData;
2105 if (!IsSelected("HLT", detStr)) {
2106 options+=" writerawfiles=";
2107 } else {
2108 options+=" writerawfiles=HLT";
2109 }
2110
2111 if (!detStr.IsNull() && !options.Contains("rawfile=")) {
2112 // as a matter of fact, HLT will run reconstruction and needs the RawReader
2113 // in order to get detector data. By default, RawReaderFile is used to read
2114 // the already simulated ddl files. Date and Root files from the raw data
2115 // are generated after the HLT simulation.
2116 options+=" rawfile=./";
2117 }
2118
2119 AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
2120 if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, options.Data())))<0) {
2121 AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
2122 } else {
2123 // run the HLT simulation
2124 AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
2125 if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
2126 AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
2127 }
2128 }
2129
2130 // delete the instance
2131 AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
2132 if (fctDelete==NULL || fctDelete(pHLT)<0) {
2133 AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
2134 }
2135 pHLT=NULL;
2136
2137 return iResult>=0?kTRUE:kFALSE;
2138}
2139
2140//_____________________________________________________________________________
2141Bool_t AliSimulation::RunQA()
2142{
2143 // run the QA on summable hits, digits or digits
2144
2145 //if(!gAlice) return kFALSE;
2146 AliQAManager::QAManager()->SetRunLoader(AliRunLoader::Instance()) ;
2147
2148 TString detectorsw("") ;
2149 Bool_t rv = kTRUE ;
2150 AliQAManager::QAManager()->SetEventSpecie(fEventSpecie) ;
2151 detectorsw = AliQAManager::QAManager()->Run(fQADetectors.Data()) ;
2152 if ( detectorsw.IsNull() )
2153 rv = kFALSE ;
2154 return rv ;
2155}
2156
2157//_____________________________________________________________________________
2158Bool_t AliSimulation::SetRunQA(TString detAndAction)
2159{
2160 // Allows to run QA for a selected set of detectors
2161 // and a selected set of tasks among HITS, SDIGITS and DIGITS
2162 // all selected detectors run the same selected tasks
2163
2164 if (!detAndAction.Contains(":")) {
2165 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
2166 fRunQA = kFALSE ;
2167 return kFALSE ;
2168 }
2169 Int_t colon = detAndAction.Index(":") ;
2170 fQADetectors = detAndAction(0, colon) ;
2171 if (fQADetectors.Contains("ALL") ){
2172 TString tmp = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
2173 Int_t minus = fQADetectors.Last('-') ;
2174 TString toKeep = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
2175 TString toRemove("") ;
2176 while (minus >= 0) {
2177 toRemove = fQADetectors(minus+1, fQADetectors.Length()) ;
2178 toRemove = toRemove.Strip() ;
2179 toKeep.ReplaceAll(toRemove, "") ;
2180 fQADetectors.ReplaceAll(Form("-%s", toRemove.Data()), "") ;
2181 minus = fQADetectors.Last('-') ;
2182 }
2183 fQADetectors = toKeep ;
2184 }
2185 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
2186 if (fQATasks.Contains("ALL") ) {
2187 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
2188 } else {
2189 fQATasks.ToUpper() ;
2190 TString tempo("") ;
2191 if ( fQATasks.Contains("HIT") )
2192 tempo = Form("%d ", AliQAv1::kHITS) ;
2193 if ( fQATasks.Contains("SDIGIT") )
2194 tempo += Form("%d ", AliQAv1::kSDIGITS) ;
2195 if ( fQATasks.Contains("DIGIT") )
2196 tempo += Form("%d ", AliQAv1::kDIGITS) ;
2197 fQATasks = tempo ;
2198 if (fQATasks.IsNull()) {
2199 AliInfo("No QA requested\n") ;
2200 fRunQA = kFALSE ;
2201 return kTRUE ;
2202 }
2203 }
2204 TString tempo(fQATasks) ;
2205 tempo.ReplaceAll(Form("%d", AliQAv1::kHITS), AliQAv1::GetTaskName(AliQAv1::kHITS)) ;
2206 tempo.ReplaceAll(Form("%d", AliQAv1::kSDIGITS), AliQAv1::GetTaskName(AliQAv1::kSDIGITS)) ;
2207 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITS), AliQAv1::GetTaskName(AliQAv1::kDIGITS)) ;
2208 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
2209 fRunQA = kTRUE ;
2210 AliQAManager::QAManager()->SetActiveDetectors(fQADetectors) ;
2211 AliQAManager::QAManager()->SetTasks(fQATasks) ;
2212 for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++)
2213 AliQAManager::QAManager()->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
2214
2215 return kTRUE;
2216}
2217
2218//_____________________________________________________________________________
2219void AliSimulation::ProcessEnvironmentVars()
2220{
2221// Extract run number and random generator seed from env variables
2222
2223 AliInfo("Processing environment variables");
2224
2225 // Random Number seed
2226
2227 // first check that seed is not already set
2228 if (fSeed == 0) {
2229 if (gSystem->Getenv("CONFIG_SEED")) {
2230 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
2231 }
2232 } else {
2233 if (gSystem->Getenv("CONFIG_SEED")) {
2234 AliInfo(Form("Seed for random number generation already set (%d)"
2235 ": CONFIG_SEED variable ignored!", fSeed));
2236 }
2237 }
2238
2239 AliInfo(Form("Seed for random number generation = %d ", fSeed));
2240
2241 // Run Number
2242
2243 // first check that run number is not already set
2244 if(fRun < 0) {
2245 if (gSystem->Getenv("DC_RUN")) {
2246 fRun = atoi(gSystem->Getenv("DC_RUN"));
2247 }
2248 } else {
2249 if (gSystem->Getenv("DC_RUN")) {
2250 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
2251 }
2252 }
2253
2254 AliInfo(Form("Run number = %d", fRun));
2255}
2256
2257//---------------------------------------------------------------------
2258void AliSimulation::WriteGRPEntry()
2259{
2260 // Get the necessary information from galice (generator, trigger etc) and
2261 // write a GRP entry corresponding to the settings in the Config.C used
2262 // note that Hall probes and Cavern and Surface Atmos pressures are not simulated.
2263
2264
2265 AliInfo("Writing global run parameters entry into the OCDB");
2266
2267 AliGRPObject* grpObj = new AliGRPObject();
2268
2269 grpObj->SetRunType("PHYSICS");
2270 grpObj->SetTimeStart(0);
2271 TDatime curtime;
2272 grpObj->SetTimeStart(0);
2273 grpObj->SetTimeEnd(curtime.Convert());
2274 grpObj->SetBeamEnergyIsSqrtSHalfGeV(); // new format of GRP: store sqrt(s)/2 in GeV
2275
2276 const AliGenerator *gen = gAlice->GetMCApp()->Generator();
2277 Int_t a = 0;
2278 Int_t z = 0;
2279
2280 if (gen) {
2281 TString projectile;
2282 gen->GetProjectile(projectile,a,z);
2283 TString target;
2284 gen->GetTarget(target,a,z);
2285 TString beamType = projectile + "-" + target;
2286 beamType.ReplaceAll(" ","");
2287 if (!beamType.CompareTo("-")) {
2288 grpObj->SetBeamType("UNKNOWN");
2289 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2);
2290 }
2291 else {
2292 grpObj->SetBeamType(beamType);
2293 if (z != 0) {
2294 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 * a / z);
2295 } else {
2296 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 );
2297 }
2298 // Heavy ion run, the event specie is set to kHighMult
2299 fEventSpecie = AliRecoParam::kHighMult;
2300 if ((strcmp(beamType,"p-p") == 0) ||
2301 (strcmp(beamType,"p-") == 0) ||
2302 (strcmp(beamType,"-p") == 0) ||
2303 (strcmp(beamType,"P-P") == 0) ||
2304 (strcmp(beamType,"P-") == 0) ||
2305 (strcmp(beamType,"-P") == 0)) {
2306 // Proton run, the event specie is set to kLowMult
2307 fEventSpecie = AliRecoParam::kLowMult;
2308 }
2309 }
2310 } else {
2311 AliWarning("Unknown beam type and energy! Setting energy to 0");
2312 grpObj->SetBeamEnergy(0);
2313 grpObj->SetBeamType("UNKNOWN");
2314 }
2315
2316 UInt_t detectorPattern = 0;
2317 Int_t nDets = 0;
2318 TObjArray *detArray = gAlice->Detectors();
2319 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors-1; iDet++) {
2320 if (detArray->FindObject(AliDAQ::OfflineModuleName(iDet))) {
2321 detectorPattern |= (1 << iDet);
2322 nDets++;
2323 }
2324 }
2325 // CTP
2326 if (!fTriggerConfig.IsNull())
2327 detectorPattern |= (1 << AliDAQ::DetectorID("TRG"));
2328
2329 // HLT
2330 if (!fRunHLT.IsNull())
2331 detectorPattern |= (1 << AliDAQ::kHLTId);
2332
2333 grpObj->SetNumberOfDetectors((Char_t)nDets);
2334 grpObj->SetDetectorMask((Int_t)detectorPattern);
2335 grpObj->SetLHCPeriod("LHC08c");
2336 grpObj->SetLHCState("STABLE_BEAMS");
2337 //
2338 AliMagF *field = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2339 Float_t solenoidField = field ? TMath::Abs(field->SolenoidField()) : 0;
2340
2341 Float_t factorSol = field ? field->GetFactorSol() : 0;
2342 Float_t currentSol = TMath::Abs(factorSol)>1E-6 ?
2343 TMath::Nint(TMath::Abs(solenoidField/factorSol))/5.*30000.*TMath::Abs(factorSol) : 0;
2344 //
2345 Float_t factorDip = field ? field->GetFactorDip() : 0;
2346 Float_t currentDip = 6000.*TMath::Abs(factorDip);
2347 //
2348 grpObj->SetL3Current(currentSol,(AliGRPObject::Stats)0);
2349 grpObj->SetDipoleCurrent(currentDip,(AliGRPObject::Stats)0);
2350 grpObj->SetL3Polarity(factorSol>0 ? 0:1);
2351 grpObj->SetDipolePolarity(factorDip>0 ? 0:1);
2352 if (field) grpObj->SetUniformBMap(field->IsUniform()); // for special MC with k5kGUniform map
2353 grpObj->SetPolarityConventionLHC(); // LHC convention +/+ current -> -/- field main components
2354 //
2355 grpObj->SetCavernTemperature(0,(AliGRPObject::Stats)0);
2356
2357 //grpMap->Add(new TObjString("fCavernPressure"),new TObjString("0")); ---> not inserted in simulation with the new object, since it is now an AliDCSSensor
2358
2359 // Now store the entry in OCDB
2360 AliCDBManager* man = AliCDBManager::Instance();
2361
2362 man->SetLock(0, fKey);
2363
2364 AliCDBStorage* sto = man->GetStorage(fGRPWriteLocation.Data());
2365
2366
2367 AliCDBId id("GRP/GRP/Data", man->GetRun(), man->GetRun(), 1, 1);
2368 AliCDBMetaData *metadata= new AliCDBMetaData();
2369
2370 metadata->SetResponsible("alice-off@cern.ch");
2371 metadata->SetComment("Automatically produced GRP entry for Monte Carlo");
2372
2373 sto->Put(grpObj,id,metadata);
2374 man->SetLock(1, fKey);
2375}
2376
2377