1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // class for running generation, simulation and digitization //
22 // Hits, sdigits and digits are created for all detectors by typing: //
24 // AliSimulation sim; //
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 //
31 // sim.SetNumberOfEvents(n); //
33 // The name of the configuration file can be passed as argument to the //
34 // AliSimulation constructor or can be specified by //
36 // sim.SetConfigFile("..."); //
38 // The generation of particles and the simulation of detector hits can be //
39 // switched on or off by //
41 // sim.SetRunGeneration(kTRUE); // generation of primary particles //
42 // sim.SetRunSimulation(kFALSE); // but no tracking //
44 // For which detectors sdigits and digits will be created, can be steered //
47 // sim.SetMakeSDigits("ALL"); // make sdigits for all detectors //
48 // sim.SetMakeDigits("ITS TPC"); // make digits only for ITS and TPC //
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. //
55 // The creation of digits from hits instead of from sdigits can be selected //
58 // sim.SetMakeDigitsFromHits("TRD"); //
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. //
64 // Background events can be merged by calling //
66 // sim.MergeWith("background/galice.root", 2); //
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. //
75 // The output of raw data can be switched on by calling //
77 // sim.SetWriteRawData("MUON"); // write raw data for MUON //
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 //
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. //
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 //
98 // sim.SetEventsPerFile("PHOS", "Reconstructed Points", 3); //
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. //
106 ///////////////////////////////////////////////////////////////////////////////
110 #include <TGeoGlobalMagField.h>
111 #include <TGeoManager.h>
112 #include <TObjString.h>
115 #include <TVirtualMC.h>
116 #include <TVirtualMCApplication.h>
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"
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"
138 #include "AliLegoGenerator.h"
142 #include "AliModule.h"
144 #include "AliRawReaderDate.h"
145 #include "AliRawReaderFile.h"
146 #include "AliRawReaderRoot.h"
148 #include "AliDigitizationInput.h"
149 #include "AliRunLoader.h"
150 #include "AliSimulation.h"
151 #include "AliSysInfo.h"
152 #include "AliVertexGenFile.h"
154 ClassImp(AliSimulation)
156 AliSimulation *AliSimulation::fgInstance = 0;
157 const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE"
158 // #ifdef MFT_UPGRADE
165 //_____________________________________________________________________________
166 AliSimulation::AliSimulation(const char* configFileName,
167 const char* name, const char* title) :
170 fRunGeneration(kTRUE),
171 fRunSimulation(kTRUE),
172 fLoadAlignFromCDB(kTRUE),
173 fLoadAlObjsListOfDets("ALL"),
177 fMakeDigitsFromHits(""),
179 fRawDataFileName(""),
180 fDeleteIntermediateFiles(kFALSE),
181 fWriteSelRawData(kFALSE),
182 fStopOnError(kFALSE),
184 fConfigFileName(configFileName),
185 fGAliceFileName("galice.root"),
187 fBkgrdFileNames(NULL),
188 fAlignObjArray(NULL),
189 fUseBkgrdVertex(kTRUE),
190 fRegionOfInterest(kFALSE),
196 fInitCDBCalled(kFALSE),
197 fInitRunNumberCalled(kFALSE),
198 fSetRunNumberFromDataCalled(kFALSE),
199 fEmbeddingFlag(kFALSE),
202 fUseVertexFromCDB(0),
203 fUseMagFieldFromGRP(0),
204 fGRPWriteLocation(Form("local://%s", gSystem->pwd())),
205 fUseTimeStampFromCDB(0),
211 fEventSpecie(AliRecoParam::kDefault),
212 fWriteQAExpertData(kTRUE),
216 fWriteGRPEntry(kTRUE)
218 // create simulation object with default parameters
220 SetGAliceFile("galice.root");
223 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
224 qam->SetActiveDetectors(fQADetectors) ;
225 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
226 qam->SetTasks(fQATasks) ;
229 //_____________________________________________________________________________
230 AliSimulation::~AliSimulation()
234 fEventsPerFile.Delete();
235 // if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
236 // delete fAlignObjArray; fAlignObjArray=0;
238 if (fBkgrdFileNames) {
239 fBkgrdFileNames->Delete();
240 delete fBkgrdFileNames;
243 fSpecCDBUri.Delete();
244 if (fgInstance==this) fgInstance = 0;
246 AliQAManager::QAManager()->ShowQA() ;
247 AliQAManager::Destroy() ;
248 AliCodeTimer::Instance()->Print();
252 //_____________________________________________________________________________
253 void AliSimulation::SetNumberOfEvents(Int_t nEvents)
255 // set the number of events for one run
260 //_____________________________________________________________________________
261 void AliSimulation::InitQA()
263 // activate a default CDB storage
264 // First check if we have any CDB storage set, because it is used
265 // to retrieve the calibration and alignment constants
267 if (fInitCDBCalled) return;
268 fInitCDBCalled = kTRUE;
270 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
271 qam->SetActiveDetectors(fQADetectors) ;
272 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
273 qam->SetTasks(fQATasks) ;
274 if (fWriteQAExpertData)
275 qam->SetWriteExpert() ;
277 if (qam->IsDefaultStorageSet()) {
278 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
279 AliWarning("Default QA reference storage has been already set !");
280 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fQARefUri.Data()));
281 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
282 fQARefUri = qam->GetDefaultStorage()->GetURI();
284 if (fQARefUri.Length() > 0) {
285 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
286 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
287 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
289 fQARefUri="local://$ALICE_ROOT/QARef";
290 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
291 AliWarning("Default QA reference storage not yet set !!!!");
292 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
293 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
295 qam->SetDefaultStorage(fQARefUri);
299 //_____________________________________________________________________________
300 void AliSimulation::InitCDB()
302 // activate a default CDB storage
303 // First check if we have any CDB storage set, because it is used
304 // to retrieve the calibration and alignment constants
306 if (fInitCDBCalled) return;
307 fInitCDBCalled = kTRUE;
309 AliCDBManager* man = AliCDBManager::Instance();
310 if (man->IsDefaultStorageSet())
312 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
313 AliWarning("Default CDB storage has been already set !");
314 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
315 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
316 fCDBUri = man->GetDefaultStorage()->GetURI();
319 if (fCDBUri.Length() > 0)
321 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
322 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
323 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
325 fCDBUri="local://$ALICE_ROOT/OCDB";
326 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
327 AliWarning("Default CDB storage not yet set !!!!");
328 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
329 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
332 man->SetDefaultStorage(fCDBUri);
335 // Now activate the detector specific CDB storage locations
336 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
337 TObject* obj = fSpecCDBUri[i];
339 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
340 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
341 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
342 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
347 //_____________________________________________________________________________
348 void AliSimulation::InitRunNumber(){
349 // check run number. If not set, set it to 0 !!!!
351 if (fInitRunNumberCalled) return;
352 fInitRunNumberCalled = kTRUE;
354 AliCDBManager* man = AliCDBManager::Instance();
355 if (man->GetRun() >= 0)
357 AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
358 "Use external variable DC_RUN or AliSimulation::SetRun()!"));
362 AliDebug(2, Form("Setting CDB run number to: %d",fRun));
365 AliWarning(Form("Run number not yet set !!!! Setting it now to: %d",
374 //_____________________________________________________________________________
375 void AliSimulation::SetCDBLock() {
376 // Set CDB lock: from now on it is forbidden to reset the run number
377 // or the default storage or to activate any further storage!
379 ULong_t key = AliCDBManager::Instance()->SetLock(1);
383 //_____________________________________________________________________________
384 void AliSimulation::SetDefaultStorage(const char* uri) {
385 // Store the desired default CDB storage location
386 // Activate it later within the Run() method
392 //_____________________________________________________________________________
393 void AliSimulation::SetQARefDefaultStorage(const char* uri) {
394 // Store the desired default CDB storage location
395 // Activate it later within the Run() method
398 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
401 //_____________________________________________________________________________
402 void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
403 // Store a detector-specific CDB storage location
404 // Activate it later within the Run() method
406 AliCDBPath aPath(calibType);
407 if(!aPath.IsValid()){
408 AliError(Form("Not a valid path: %s", calibType));
412 TObject* obj = fSpecCDBUri.FindObject(calibType);
413 if (obj) fSpecCDBUri.Remove(obj);
414 fSpecCDBUri.Add(new TNamed(calibType, uri));
418 //_____________________________________________________________________________
419 void AliSimulation::SetRunNumber(Int_t run)
422 // Activate it later within the Run() method
427 //_____________________________________________________________________________
428 void AliSimulation::SetSeed(Int_t seed)
431 // Activate it later within the Run() method
436 //_____________________________________________________________________________
437 Bool_t AliSimulation::SetRunNumberFromData()
439 // Set the CDB manager run number
440 // The run number is retrieved from gAlice
442 if (fSetRunNumberFromDataCalled) return kTRUE;
443 fSetRunNumberFromDataCalled = kTRUE;
445 AliCDBManager* man = AliCDBManager::Instance();
446 Int_t runData = -1, runCDB = -1;
448 AliRunLoader* runLoader = LoadRun("READ");
449 if (!runLoader) return kFALSE;
451 runData = runLoader->GetHeader()->GetRun();
455 runCDB = man->GetRun();
457 if (runCDB != runData) {
458 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
459 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
460 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
461 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
466 man->SetRun(runData);
469 if(man->GetRun() < 0) {
470 AliError("Run number not properly initalized!");
479 //_____________________________________________________________________________
480 void AliSimulation::SetConfigFile(const char* fileName)
482 // set the name of the config file
484 fConfigFileName = fileName;
487 //_____________________________________________________________________________
488 void AliSimulation::SetGAliceFile(const char* fileName)
490 // set the name of the galice file
491 // the path is converted to an absolute one if it is relative
493 fGAliceFileName = fileName;
494 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
495 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
497 fGAliceFileName = absFileName;
498 delete[] absFileName;
501 AliDebug(2, Form("galice file name set to %s", fileName));
504 //_____________________________________________________________________________
505 void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
508 // set the number of events per file for the given detector and data type
509 // ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
511 TNamed* obj = new TNamed(detector, type);
512 obj->SetUniqueID(nEvents);
513 fEventsPerFile.Add(obj);
516 //_____________________________________________________________________________
517 Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
519 // Read the alignment objects from CDB.
520 // Each detector is supposed to have the
521 // alignment objects in DET/Align/Data CDB path.
522 // All the detector objects are then collected,
523 // sorted by geometry level (starting from ALIC) and
524 // then applied to the TGeo geometry.
525 // Finally an overlaps check is performed.
527 if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
528 AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
532 // initialize CDB storage, run number, set CDB lock
534 // if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
537 Bool_t delRunLoader = kFALSE;
539 runLoader = LoadRun("READ");
540 if (!runLoader) return kFALSE;
541 delRunLoader = kTRUE;
544 // Export ideal geometry
545 if(!IsGeometryFromFile()) AliGeomManager::GetGeometry()->Export("geometry.root");
547 // Load alignment data from CDB and apply to geometry through AliGeomManager
548 if(fLoadAlignFromCDB){
550 TString detStr = fLoadAlObjsListOfDets;
551 TString loadAlObjsListOfDets = "";
553 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
554 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
555 AliModule* det = (AliModule*) detArray->At(iDet);
556 if (!det || !det->IsActive()) continue;
557 if (IsSelected(det->GetName(), detStr)) {
558 //add det to list of dets to be aligned from CDB
559 loadAlObjsListOfDets += det->GetName();
560 loadAlObjsListOfDets += " ";
562 } // end loop over detectors
563 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
564 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
566 // Check if the array with alignment objects was
567 // provided by the user. If yes, apply the objects
568 // to the present TGeo geometry
569 if (fAlignObjArray) {
570 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
571 AliError("The misalignment of one or more volumes failed!"
572 "Compare the list of simulated detectors and the list of detector alignment data!");
573 if (delRunLoader) delete runLoader;
579 // Update the internal geometry of modules (ITS needs it)
580 TString detStr = fLoadAlObjsListOfDets;
581 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
582 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
584 AliModule* det = (AliModule*) detArray->At(iDet);
585 if (!det || !det->IsActive()) continue;
586 if (IsSelected(det->GetName(), detStr)) {
587 det->UpdateInternalGeometry();
589 } // end loop over detectors
592 if (delRunLoader) delete runLoader;
597 //_____________________________________________________________________________
598 void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
600 // add a file with background events for merging
602 TObjString* fileNameStr = new TObjString(fileName);
603 fileNameStr->SetUniqueID(nSignalPerBkgrd);
604 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
605 fBkgrdFileNames->Add(fileNameStr);
608 void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
610 // add a file with background events for embeddin
611 MergeWith(fileName, nSignalPerBkgrd);
612 fEmbeddingFlag = kTRUE;
615 //_____________________________________________________________________________
616 Bool_t AliSimulation::Run(Int_t nEvents)
618 // run the generation, simulation and digitization
621 AliCodeTimerAuto("",0)
622 AliSysInfo::AddStamp("Start_Run");
624 // Load run number and seed from environmental vars
625 ProcessEnvironmentVars();
626 AliSysInfo::AddStamp("ProcessEnvironmentVars");
628 gRandom->SetSeed(fSeed);
630 if (nEvents > 0) fNEvents = nEvents;
632 // create and setup the HLT instance
633 if (!fRunHLT.IsNull() && !CreateHLT()) {
634 if (fStopOnError) return kFALSE;
639 // generation and simulation -> hits
640 if (fRunGeneration) {
641 if (!RunSimulation()) if (fStopOnError) return kFALSE;
643 AliSysInfo::AddStamp("RunSimulation");
645 // initialize CDB storage from external environment
646 // (either CDB manager or AliSimulation setters),
647 // if not already done in RunSimulation()
649 AliSysInfo::AddStamp("InitCDB");
651 // Set run number in CDBManager from data
652 // From this point on the run number must be always loaded from data!
653 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
655 // Set CDB lock: from now on it is forbidden to reset the run number
656 // or the default storage or to activate any further storage!
659 // If RunSimulation was not called, load the geometry and misalign it
660 if (!AliGeomManager::GetGeometry()) {
661 // Initialize the geometry manager
662 AliGeomManager::LoadGeometry("geometry.root");
663 AliSysInfo::AddStamp("GetGeometry");
664 // // Check that the consistency of symbolic names for the activated subdetectors
665 // // in the geometry loaded by AliGeomManager
666 // AliRunLoader* runLoader = LoadRun("READ");
667 // if (!runLoader) return kFALSE;
669 // TString detsToBeChecked = "";
670 // TObjArray* detArray = runLoader->GetAliRun()->Detectors();
671 // for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
672 // AliModule* det = (AliModule*) detArray->At(iDet);
673 // if (!det || !det->IsActive()) continue;
674 // detsToBeChecked += det->GetName();
675 // detsToBeChecked += " ";
676 // } // end loop over detectors
677 // if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
678 if(!AliGeomManager::CheckSymNamesLUT("ALL"))
679 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
681 if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
683 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
685 AliSysInfo::AddStamp("MissalignGeometry");
688 // hits -> summable digits
689 AliSysInfo::AddStamp("Start_sdigitization");
690 if (!fMakeSDigits.IsNull()) {
691 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
694 AliSysInfo::AddStamp("Stop_sdigitization");
696 AliSysInfo::AddStamp("Start_digitization");
697 // summable digits -> digits
698 if (!fMakeDigits.IsNull()) {
699 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
700 if (fStopOnError) return kFALSE;
703 AliSysInfo::AddStamp("Stop_digitization");
708 if (!fMakeDigitsFromHits.IsNull()) {
709 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
710 AliWarning(Form("Merging and direct creation of digits from hits "
711 "was selected for some detectors. "
712 "No merging will be done for the following detectors: %s",
713 fMakeDigitsFromHits.Data()));
715 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
716 if (fStopOnError) return kFALSE;
720 AliSysInfo::AddStamp("Hits2Digits");
724 if (!fTriggerConfig.IsNull() && !RunTrigger(fTriggerConfig,fMakeDigits)) {
725 if (fStopOnError) return kFALSE;
728 AliSysInfo::AddStamp("RunTrigger");
731 // digits -> raw data
732 if (!fWriteRawData.IsNull()) {
733 if (!WriteRawData(fWriteRawData, fRawDataFileName,
734 fDeleteIntermediateFiles,fWriteSelRawData)) {
735 if (fStopOnError) return kFALSE;
739 AliSysInfo::AddStamp("WriteRaw");
741 // run HLT simulation on simulated digit data if raw data is not
742 // simulated, otherwise its called as part of WriteRawData
743 if (!fRunHLT.IsNull() && fWriteRawData.IsNull()) {
745 if (fStopOnError) return kFALSE;
749 AliSysInfo::AddStamp("RunHLT");
753 Bool_t rv = RunQA() ;
759 AliSysInfo::AddStamp("RunQA");
761 // Cleanup of CDB manager: cache and active storages!
762 AliCDBManager::Instance()->ClearCache();
767 //_______________________________________________________________________
768 Bool_t AliSimulation::RunLego(const char *setup, Int_t nc1, Float_t c1min,
769 Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
770 Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener, Int_t nev)
773 // Generates lego plots of:
774 // - radiation length map phi vs theta
775 // - radiation length map phi vs eta
776 // - interaction length map
777 // - g/cm2 length map
779 // ntheta bins in theta, eta
780 // themin minimum angle in theta (degrees)
781 // themax maximum angle in theta (degrees)
783 // phimin minimum angle in phi (degrees)
784 // phimax maximum angle in phi (degrees)
785 // rmin minimum radius
786 // rmax maximum radius
789 // The number of events generated = ntheta*nphi
790 // run input parameters in macro setup (default="Config.C")
792 // Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
795 <img src="picts/AliRunLego1.gif">
800 <img src="picts/AliRunLego2.gif">
805 <img src="picts/AliRunLego3.gif">
810 // run the generation and simulation
812 AliCodeTimerAuto("",0)
814 // initialize CDB storage and run number from external environment
815 // (either CDB manager or AliSimulation setters)
821 AliError("no gAlice object. Restart aliroot and try again.");
824 if (gAlice->Modules()->GetEntries() > 0) {
825 AliError("gAlice was already run. Restart aliroot and try again.");
829 AliInfo(Form("initializing gAlice with config file %s",
830 fConfigFileName.Data()));
833 if (nev == -1) nev = nc1 * nc2;
835 // check if initialisation has been done
836 // If runloader has been initialized, set the number of events per file to nc1 * nc2
839 if (!gener) gener = new AliLegoGenerator();
841 // Configure Generator
843 gener->SetRadiusRange(rmin, rmax);
844 gener->SetZMax(zmax);
845 gener->SetCoor1Range(nc1, c1min, c1max);
846 gener->SetCoor2Range(nc2, c2min, c2max);
850 fLego = new AliLego("lego",gener);
852 //__________________________________________________________________________
856 gROOT->LoadMacro(setup);
857 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
859 if(AliCDBManager::Instance()->GetRun() >= 0) {
860 SetRunNumber(AliCDBManager::Instance()->GetRun());
862 AliWarning("Run number not initialized!!");
865 AliRunLoader::Instance()->CdGAFile();
867 AliPDG::AddParticlesToPdgDataBase();
869 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
871 gAlice->GetMCApp()->Init();
874 //Must be here because some MCs (G4) adds detectors here and not in Config.C
875 gAlice->InitLoaders();
876 AliRunLoader::Instance()->MakeTree("E");
879 // Save stuff at the beginning of the file to avoid file corruption
880 AliRunLoader::Instance()->CdGAFile();
883 //Save current generator
884 AliGenerator *gen=gAlice->GetMCApp()->Generator();
885 gAlice->GetMCApp()->ResetGenerator(gener);
886 //Prepare MC for Lego Run
892 AliRunLoader::Instance()->SetNumberOfEventsPerFile(nev);
893 gMC->ProcessRun(nev);
895 // End of this run, close files
897 // Restore current generator
898 gAlice->GetMCApp()->ResetGenerator(gen);
899 // Delete Lego Object
905 //_____________________________________________________________________________
906 Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
910 AliCodeTimerAuto("",0)
912 // initialize CDB storage from external environment
913 // (either CDB manager or AliSimulation setters),
914 // if not already done in RunSimulation()
917 // Set run number in CDBManager from data
918 // From this point on the run number must be always loaded from data!
919 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
921 // Set CDB lock: from now on it is forbidden to reset the run number
922 // or the default storage or to activate any further storage!
925 AliRunLoader* runLoader = LoadRun("READ");
926 if (!runLoader) return kFALSE;
927 TString trconfiguration = config;
929 if (trconfiguration.IsNull()) {
930 if(!fTriggerConfig.IsNull()) {
931 trconfiguration = fTriggerConfig;
934 AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
937 runLoader->MakeTree( "GG" );
938 AliCentralTrigger* aCTP = runLoader->GetTrigger();
939 // Load Configuration
940 if (!aCTP->LoadConfiguration( trconfiguration ))
944 if( !aCTP->RunTrigger( runLoader , detectors ) ) {
956 //_____________________________________________________________________________
957 Bool_t AliSimulation::WriteTriggerRawData()
959 // Writes the CTP (trigger) DDL raw data
960 // Details of the format are given in the
961 // trigger TDR - pages 134 and 135.
962 AliCTPRawData writer;
968 //_____________________________________________________________________________
969 Bool_t AliSimulation::RunSimulation(Int_t nEvents)
971 // run the generation and simulation
973 AliCodeTimerAuto("",0)
975 // initialize CDB storage and run number from external environment
976 // (either CDB manager or AliSimulation setters)
977 AliSysInfo::AddStamp("RunSimulation_Begin");
979 AliSysInfo::AddStamp("RunSimulation_InitCDB");
982 AliSysInfo::AddStamp("RunSimulation_SetCDBLock");
985 AliError("no gAlice object. Restart aliroot and try again.");
988 if (gAlice->Modules()->GetEntries() > 0) {
989 AliError("gAlice was already run. Restart aliroot and try again.");
993 AliInfo(Form("initializing gAlice with config file %s",
994 fConfigFileName.Data()));
997 // Initialize ALICE Simulation run
1002 // If requested set the mag. field from the GRP entry.
1003 // After this the field is loccked and cannot be changed by Config.C
1004 if (fUseMagFieldFromGRP) {
1006 grpM.ReadGRPEntry();
1008 AliInfo("Field is locked now. It cannot be changed in Config.C");
1012 gROOT->LoadMacro(fConfigFileName.Data());
1013 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
1014 AliSysInfo::AddStamp("RunSimulation_Config");
1017 // If requested obtain the vertex position and vertex sigma_z from the CDB
1018 // This overwrites the settings from the Config.C
1019 if (fUseVertexFromCDB) {
1020 Double_t vtxPos[3] = {0., 0., 0.};
1021 Double_t vtxSig[3] = {0., 0., 0.};
1022 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1024 AliESDVertex* vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1026 if(vertex->GetXRes()>2.8) { // > pipe radius --> it's a dummy object, don't use it
1027 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1028 if (entry) vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1032 vertex->GetXYZ(vtxPos);
1033 vertex->GetSigmaXYZ(vtxSig);
1034 AliInfo("Overwriting Config.C vertex settings !");
1035 AliInfo(Form("Vertex position from OCDB entry: x = %13.3f, y = %13.3f, z = %13.3f (sigma = %13.3f)\n",
1036 vtxPos[0], vtxPos[1], vtxPos[2], vtxSig[2]));
1038 AliGenerator *gen = gAlice->GetMCApp()->Generator();
1039 gen->SetOrigin(vtxPos[0], vtxPos[1], vtxPos[2]); // vertex position
1040 gen->SetSigmaZ(vtxSig[2]);
1045 // If requested we take the SOR and EOR time-stamps from the GRP and use them
1046 // in order to generate the event time-stamps
1047 if (fUseTimeStampFromCDB) {
1049 grpM.ReadGRPEntry();
1050 const AliGRPObject *grpObj = grpM.GetGRPData();
1051 if (!grpObj || (grpObj->GetTimeEnd() <= grpObj->GetTimeStart())) {
1052 AliError("Missing GRP or bad SOR/EOR time-stamps! Switching off the time-stamp generation from GRP!");
1053 fTimeStart = fTimeEnd = 0;
1054 fUseTimeStampFromCDB = kFALSE;
1057 fTimeStart = grpObj->GetTimeStart();
1058 fTimeEnd = grpObj->GetTimeEnd();
1062 if(AliCDBManager::Instance()->GetRun() >= 0) {
1063 AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
1064 AliRunLoader::Instance()->SetNumberOfEventsPerRun(fNEvents);
1066 AliWarning("Run number not initialized!!");
1069 AliRunLoader::Instance()->CdGAFile();
1072 AliPDG::AddParticlesToPdgDataBase();
1074 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
1075 AliSysInfo::AddStamp("RunSimulation_GetField");
1077 gAlice->GetMCApp()->Init();
1078 AliSysInfo::AddStamp("RunSimulation_InitMCApp");
1080 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1081 gAlice->InitLoaders();
1082 AliRunLoader::Instance()->MakeTree("E");
1083 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1084 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1085 AliRunLoader::Instance()->LoadHits("all","RECREATE");
1087 // Save stuff at the beginning of the file to avoid file corruption
1088 AliRunLoader::Instance()->CdGAFile();
1090 gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
1091 AliSysInfo::AddStamp("RunSimulation_InitLoaders");
1092 //___________________________________________________________________________________________
1094 AliSysInfo::AddStamp("RunSimulation_TriggerDescriptor");
1096 // Set run number in CDBManager
1097 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
1099 AliRunLoader* runLoader = AliRunLoader::Instance();
1101 AliError(Form("gAlice has no run loader object. "
1102 "Check your config file: %s", fConfigFileName.Data()));
1105 SetGAliceFile(runLoader->GetFileName());
1107 // Misalign geometry
1108 #if ROOT_VERSION_CODE < 331527
1109 AliGeomManager::SetGeometry(gGeoManager);
1111 // Check that the consistency of symbolic names for the activated subdetectors
1112 // in the geometry loaded by AliGeomManager
1113 TString detsToBeChecked = "";
1114 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1115 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1116 AliModule* det = (AliModule*) detArray->At(iDet);
1117 if (!det || !det->IsActive()) continue;
1118 detsToBeChecked += det->GetName();
1119 detsToBeChecked += " ";
1120 } // end loop over detectors
1121 if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
1122 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
1123 MisalignGeometry(runLoader);
1124 AliSysInfo::AddStamp("RunSimulation_MisalignGeometry");
1127 // AliRunLoader* runLoader = AliRunLoader::Instance();
1128 // if (!runLoader) {
1129 // AliError(Form("gAlice has no run loader object. "
1130 // "Check your config file: %s", fConfigFileName.Data()));
1133 // SetGAliceFile(runLoader->GetFileName());
1135 if (!gAlice->GetMCApp()->Generator()) {
1136 AliError(Form("gAlice has no generator object. "
1137 "Check your config file: %s", fConfigFileName.Data()));
1141 // Write GRP entry corresponding to the setting found in Cofig.C
1144 AliSysInfo::AddStamp("RunSimulation_WriteGRP");
1146 if (nEvents <= 0) nEvents = fNEvents;
1148 // get vertex from background file in case of merging
1149 if (fUseBkgrdVertex &&
1150 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
1151 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
1152 const char* fileName = ((TObjString*)
1153 (fBkgrdFileNames->At(0)))->GetName();
1154 AliInfo(Form("The vertex will be taken from the background "
1155 "file %s with nSignalPerBackground = %d",
1156 fileName, signalPerBkgrd));
1157 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
1158 gAlice->GetMCApp()->Generator()->SetVertexGenerator(vtxGen);
1161 if (!fRunSimulation) {
1162 gAlice->GetMCApp()->Generator()->SetTrackingFlag(0);
1165 // set the number of events per file for given detectors and data types
1166 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
1167 if (!fEventsPerFile[i]) continue;
1168 const char* detName = fEventsPerFile[i]->GetName();
1169 const char* typeName = fEventsPerFile[i]->GetTitle();
1170 TString loaderName(detName);
1171 loaderName += "Loader";
1172 AliLoader* loader = runLoader->GetLoader(loaderName);
1174 AliError(Form("RunSimulation no loader for %s found\n Number of events per file not set for %s %s",
1175 detName, typeName, detName));
1178 AliDataLoader* dataLoader =
1179 loader->GetDataLoader(typeName);
1181 AliError(Form("no data loader for %s found\n"
1182 "Number of events per file not set for %s %s",
1183 typeName, detName, typeName));
1186 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
1187 AliDebug(1, Form("number of events per file set to %d for %s %s",
1188 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
1191 AliInfo("running gAlice");
1192 AliSysInfo::AddStamp("Start_ProcessRun");
1194 // Create the Root Tree with one branch per detector
1195 //Hits moved to begin event -> now we are crating separate tree for each event
1197 gMC->ProcessRun(nEvents);
1199 // End of this run, close files
1200 if(nEvents>0) FinishRun();
1202 AliSysInfo::AddStamp("Stop_ProcessRun");
1208 //_____________________________________________________________________________
1209 Bool_t AliSimulation::RunSDigitization(const char* detectors)
1211 // run the digitization and produce summable digits
1212 static Int_t eventNr=0;
1213 AliCodeTimerAuto("",0) ;
1215 // initialize CDB storage, run number, set CDB lock
1217 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1220 AliRunLoader* runLoader = LoadRun();
1221 if (!runLoader) return kFALSE;
1223 TString detStr = detectors;
1224 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1225 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1226 AliModule* det = (AliModule*) detArray->At(iDet);
1227 if (!det || !det->IsActive()) continue;
1228 if (IsSelected(det->GetName(), detStr)) {
1229 AliInfo(Form("creating summable digits for %s", det->GetName()));
1230 AliCodeTimerStart(Form("creating summable digits for %s", det->GetName()));
1231 det->Hits2SDigits();
1232 AliCodeTimerStop(Form("creating summable digits for %s", det->GetName()));
1233 AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
1237 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1238 AliError(Form("the following detectors were not found: %s",
1240 if (fStopOnError) return kFALSE;
1249 //_____________________________________________________________________________
1250 Bool_t AliSimulation::RunDigitization(const char* detectors,
1251 const char* excludeDetectors)
1253 // run the digitization and produce digits from sdigits
1255 AliCodeTimerAuto("",0)
1257 // initialize CDB storage, run number, set CDB lock
1259 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1262 delete AliRunLoader::Instance();
1267 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
1268 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
1269 AliDigitizationInput digInp(nStreams, signalPerBkgrd);
1270 // digInp.SetEmbeddingFlag(fEmbeddingFlag);
1271 digInp.SetRegionOfInterest(fRegionOfInterest);
1272 digInp.SetInputStream(0, fGAliceFileName.Data());
1273 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
1274 const char* fileName = ((TObjString*)(fBkgrdFileNames->At(iStream-1)))->GetName();
1275 digInp.SetInputStream(iStream, fileName);
1278 detArr.SetOwner(kTRUE);
1279 TString detStr = detectors;
1280 TString detExcl = excludeDetectors;
1281 if (!static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice()) {
1282 AliError("Error occured while getting gAlice from Input 0");
1285 AliRunLoader* runLoader = AliRunLoader::GetRunLoader(digInp.GetInputStream(0)->GetFolderName());
1286 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1287 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1288 AliModule* det = (AliModule*) detArray->At(iDet);
1289 if (!det || !det->IsActive()) continue;
1290 if (!IsSelected(det->GetName(), detStr) || IsSelected(det->GetName(), detExcl)) continue;
1291 AliDigitizer* digitizer = det->CreateDigitizer(&digInp);
1292 if (!digitizer || !digitizer->Init()) {
1293 AliError(Form("no digitizer for %s", det->GetName()));
1294 if (fStopOnError) return kFALSE;
1297 detArr.AddLast(digitizer);
1298 AliInfo(Form("Created digitizer from SDigits -> Digits for %s", det->GetName()));
1301 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1302 AliError(Form("the following detectors were not found: %s", detStr.Data()));
1303 if (fStopOnError) return kFALSE;
1306 Int_t ndigs = detArr.GetEntriesFast();
1307 Int_t eventsCreated = 0;
1308 AliRunLoader* outRl = digInp.GetOutRunLoader();
1309 while ((eventsCreated++ < fNEvents) || (fNEvents < 0)) {
1310 if (!digInp.ConnectInputTrees()) break;
1311 digInp.InitEvent(); //this must be after call of Connect Input tress.
1312 if (outRl) outRl->SetEventNumber(eventsCreated-1);
1313 static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice(); // use gAlice of the first input stream
1314 for (int id=0;id<ndigs;id++) ((AliDigitizer*)detArr[id])->Digitize("");
1315 digInp.FinishEvent();
1317 digInp.FinishGlobal();
1322 //_____________________________________________________________________________
1323 Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
1325 // run the digitization and produce digits from hits
1327 AliCodeTimerAuto("",0)
1329 // initialize CDB storage, run number, set CDB lock
1331 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1334 AliRunLoader* runLoader = LoadRun("READ");
1335 if (!runLoader) return kFALSE;
1337 TString detStr = detectors;
1338 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1339 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1340 AliModule* det = (AliModule*) detArray->At(iDet);
1341 if (!det || !det->IsActive()) continue;
1342 if (IsSelected(det->GetName(), detStr)) {
1343 AliInfo(Form("creating digits from hits for %s", det->GetName()));
1348 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1349 AliError(Form("the following detectors were not found: %s",
1351 if (fStopOnError) return kFALSE;
1357 //_____________________________________________________________________________
1358 Bool_t AliSimulation::WriteRawData(const char* detectors,
1359 const char* fileName,
1360 Bool_t deleteIntermediateFiles,
1363 // convert the digits to raw data
1364 // First DDL raw data files for the given detectors are created.
1365 // If a file name is given, the DDL files are then converted to a DATE file.
1366 // If deleteIntermediateFiles is true, the DDL raw files are deleted
1368 // If the file name has the extension ".root", the DATE file is converted
1370 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
1371 // 'selrawdata' flag can be used to enable writing of detectors raw data
1372 // accoring to the trigger cluster.
1374 AliCodeTimerAuto("",0)
1375 AliSysInfo::AddStamp("WriteRawData_Start");
1377 TString detStr = detectors;
1378 if (!WriteRawFiles(detStr.Data())) {
1379 if (fStopOnError) return kFALSE;
1381 AliSysInfo::AddStamp("WriteRawFiles");
1383 // run HLT simulation on simulated DDL raw files
1384 // and produce HLT ddl raw files to be included in date/root file
1385 // bugfix 2009-06-26: the decision whether to write HLT raw data
1386 // is taken in RunHLT. Here HLT always needs to be run in order to
1387 // create HLT digits, unless its switched off. This is due to the
1388 // special placement of the HLT between the generation of DDL files
1389 // and conversion to DATE/Root file.
1390 detStr.ReplaceAll("HLT", "");
1391 if (!fRunHLT.IsNull()) {
1393 if (fStopOnError) return kFALSE;
1396 AliSysInfo::AddStamp("WriteRawData_RunHLT");
1398 TString dateFileName(fileName);
1399 if (!dateFileName.IsNull()) {
1400 Bool_t rootOutput = dateFileName.EndsWith(".root");
1401 if (rootOutput) dateFileName += ".date";
1402 TString selDateFileName;
1404 selDateFileName = "selected.";
1405 selDateFileName+= dateFileName;
1407 if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
1408 if (fStopOnError) return kFALSE;
1410 AliSysInfo::AddStamp("ConvertRawFilesToDate");
1411 if (deleteIntermediateFiles) {
1412 AliRunLoader* runLoader = LoadRun("READ");
1413 if (runLoader) for (Int_t iEvent = 0;
1414 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1416 snprintf(command, 256, "rm -r raw%d", iEvent);
1417 gSystem->Exec(command);
1423 if (!ConvertDateToRoot(dateFileName, fileName)) {
1424 if (fStopOnError) return kFALSE;
1426 AliSysInfo::AddStamp("ConvertDateToRoot");
1427 if (deleteIntermediateFiles) {
1428 gSystem->Unlink(dateFileName);
1431 TString selFileName = "selected.";
1432 selFileName += fileName;
1433 if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1434 if (fStopOnError) return kFALSE;
1436 if (deleteIntermediateFiles) {
1437 gSystem->Unlink(selDateFileName);
1446 //_____________________________________________________________________________
1447 Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1449 // convert the digits to raw data DDL files
1451 AliCodeTimerAuto("",0)
1453 AliRunLoader* runLoader = LoadRun("READ");
1454 if (!runLoader) return kFALSE;
1456 // write raw data to DDL files
1457 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1458 AliInfo(Form("processing event %d", iEvent));
1459 runLoader->GetEvent(iEvent);
1460 TString baseDir = gSystem->WorkingDirectory();
1462 snprintf(dirName, 256, "raw%d", iEvent);
1463 gSystem->MakeDirectory(dirName);
1464 if (!gSystem->ChangeDirectory(dirName)) {
1465 AliError(Form("couldn't change to directory %s", dirName));
1466 if (fStopOnError) return kFALSE; else continue;
1469 ofstream runNbFile(Form("run%u",runLoader->GetHeader()->GetRun()));
1472 TString detStr = detectors;
1473 if (IsSelected("HLT", detStr)) {
1474 // Do nothing. "HLT" will be removed from detStr and HLT raw
1475 // data files are generated in RunHLT.
1478 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1479 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1480 AliModule* det = (AliModule*) detArray->At(iDet);
1481 if (!det || !det->IsActive()) continue;
1482 if (IsSelected(det->GetName(), detStr)) {
1483 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
1488 if (!WriteTriggerRawData())
1489 if (fStopOnError) return kFALSE;
1491 gSystem->ChangeDirectory(baseDir);
1492 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1493 AliError(Form("the following detectors were not found: %s",
1495 if (fStopOnError) return kFALSE;
1504 //_____________________________________________________________________________
1505 Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1506 const char* selDateFileName)
1508 // convert raw data DDL files to a DATE file with the program "dateStream"
1509 // The second argument is not empty when the user decides to write
1510 // the detectors raw data according to the trigger cluster.
1512 AliCodeTimerAuto("",0)
1514 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1516 AliError("the program dateStream was not found");
1517 if (fStopOnError) return kFALSE;
1522 AliRunLoader* runLoader = LoadRun("READ");
1523 if (!runLoader) return kFALSE;
1525 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
1526 Bool_t selrawdata = kFALSE;
1527 if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1530 // Note the option -s. It is used in order to avoid
1531 // the generation of SOR/EOR events.
1532 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
1533 dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
1534 FILE* pipe = gSystem->OpenPipe(command, "w");
1537 AliError(Form("Cannot execute command: %s",command));
1541 Int_t selEvents = 0;
1542 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1544 UInt_t detectorPattern = 0;
1545 runLoader->GetEvent(iEvent);
1546 if (!runLoader->LoadTrigger()) {
1547 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1548 detectorPattern = aCTP->GetClusterMask();
1549 // Check if the event was triggered by CTP
1551 if (aCTP->GetClassMask()) selEvents++;
1555 AliWarning("No trigger can be loaded! Some fields in the event header will be empty !");
1557 AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1558 selrawdata = kFALSE;
1562 fprintf(pipe, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
1566 // loop over detectors and DDLs
1567 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1568 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1570 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1571 Int_t ldcID = Int_t(ldc + 0.0001);
1572 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1574 char rawFileName[256];
1575 snprintf(rawFileName, 256, "raw%d/%s",
1576 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1578 // check existence and size of raw data file
1579 FILE* file = fopen(rawFileName, "rb");
1580 if (!file) continue;
1581 fseek(file, 0, SEEK_END);
1582 unsigned long size = ftell(file);
1584 if (!size) continue;
1586 if (ldcID != prevLDC) {
1587 fprintf(pipe, " LDC Id %d\n", ldcID);
1590 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1595 Int_t result = gSystem->ClosePipe(pipe);
1597 if (!(selrawdata && selEvents > 0)) {
1599 return (result == 0);
1602 AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1604 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
1605 selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1606 FILE* pipe2 = gSystem->OpenPipe(command, "w");
1608 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1610 // Get the trigger decision and cluster
1611 UInt_t detectorPattern = 0;
1613 runLoader->GetEvent(iEvent);
1614 if (!runLoader->LoadTrigger()) {
1615 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1616 if (aCTP->GetClassMask() == 0) continue;
1617 detectorPattern = aCTP->GetClusterMask();
1618 detClust = AliDAQ::ListOfTriggeredDetectors(detectorPattern);
1619 AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1622 fprintf(pipe2, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
1626 // loop over detectors and DDLs
1627 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1628 // Write only raw data from detectors that
1629 // are contained in the trigger cluster(s)
1630 if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1632 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1634 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1635 Int_t ldcID = Int_t(ldc + 0.0001);
1636 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1638 char rawFileName[256];
1639 snprintf(rawFileName, 256, "raw%d/%s",
1640 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1642 // check existence and size of raw data file
1643 FILE* file = fopen(rawFileName, "rb");
1644 if (!file) continue;
1645 fseek(file, 0, SEEK_END);
1646 unsigned long size = ftell(file);
1648 if (!size) continue;
1650 if (ldcID != prevLDC) {
1651 fprintf(pipe2, " LDC Id %d\n", ldcID);
1654 fprintf(pipe2, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1659 Int_t result2 = gSystem->ClosePipe(pipe2);
1662 return ((result == 0) && (result2 == 0));
1665 //_____________________________________________________________________________
1666 Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1667 const char* rootFileName)
1669 // convert a DATE file to a root file with the program "alimdc"
1672 const Int_t kDBSize = 2000000000;
1673 const Int_t kTagDBSize = 1000000000;
1674 const Bool_t kFilter = kFALSE;
1675 const Int_t kCompression = 1;
1677 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1679 AliError("the program alimdc was not found");
1680 if (fStopOnError) return kFALSE;
1685 AliInfo(Form("converting DATE file %s to root file %s",
1686 dateFileName, rootFileName));
1688 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1689 const char* tagDBFS = "/tmp/mdc1/tags";
1691 // User defined file system locations
1692 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1693 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1694 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1695 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1696 if (gSystem->Getenv("ALIMDC_TAGDB"))
1697 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
1699 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1700 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1701 gSystem->Exec(Form("rm -rf %s",tagDBFS));
1703 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1704 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1705 gSystem->Exec(Form("mkdir %s",tagDBFS));
1707 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1708 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1709 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1711 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1712 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1713 gSystem->Exec(Form("rm -rf %s",tagDBFS));
1715 return (result == 0);
1719 //_____________________________________________________________________________
1720 AliRunLoader* AliSimulation::LoadRun(const char* mode) const
1722 // delete existing run loaders, open a new one and load gAlice
1724 delete AliRunLoader::Instance();
1725 AliRunLoader* runLoader =
1726 AliRunLoader::Open(fGAliceFileName.Data(),
1727 AliConfig::GetDefaultEventFolderName(), mode);
1729 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1732 runLoader->LoadgAlice();
1733 runLoader->LoadHeader();
1734 gAlice = runLoader->GetAliRun();
1736 AliError(Form("no gAlice object found in file %s",
1737 fGAliceFileName.Data()));
1743 //_____________________________________________________________________________
1744 Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1746 // get or calculate the number of signal events per background event
1748 if (!fBkgrdFileNames) return 1;
1749 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1750 if (nBkgrdFiles == 0) return 1;
1752 // get the number of signal events
1754 AliRunLoader* runLoader =
1755 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
1756 if (!runLoader) return 1;
1758 nEvents = runLoader->GetNumberOfEvents();
1763 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1764 // get the number of background events
1765 const char* fileName = ((TObjString*)
1766 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
1767 AliRunLoader* runLoader =
1768 AliRunLoader::Open(fileName, "BKGRD");
1769 if (!runLoader) continue;
1770 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1773 // get or calculate the number of signal per background events
1774 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1775 if (nSignalPerBkgrd <= 0) {
1776 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1777 } else if (result && (result != nSignalPerBkgrd)) {
1778 AliInfo(Form("the number of signal events per background event "
1779 "will be changed from %d to %d for stream %d",
1780 nSignalPerBkgrd, result, iBkgrdFile+1));
1781 nSignalPerBkgrd = result;
1784 if (!result) result = nSignalPerBkgrd;
1785 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
1786 AliWarning(Form("not enough background events (%d) for %d signal events "
1787 "using %d signal per background events for stream %d",
1788 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
1795 //_____________________________________________________________________________
1796 Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1798 // check whether detName is contained in detectors
1799 // if yes, it is removed from detectors
1801 // check if all detectors are selected
1802 if ((detectors.CompareTo("ALL") == 0) ||
1803 detectors.BeginsWith("ALL ") ||
1804 detectors.EndsWith(" ALL") ||
1805 detectors.Contains(" ALL ")) {
1810 // search for the given detector
1811 Bool_t result = kFALSE;
1812 if ((detectors.CompareTo(detName) == 0) ||
1813 detectors.BeginsWith(detName+" ") ||
1814 detectors.EndsWith(" "+detName) ||
1815 detectors.Contains(" "+detName+" ")) {
1816 detectors.ReplaceAll(detName, "");
1820 // clean up the detectors string
1821 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1822 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1823 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1828 //_____________________________________________________________________________
1829 Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName, Int_t N)
1832 // Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1833 // These can be used for embedding of MC tracks into RAW data using the standard
1834 // merging procedure.
1836 // If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1839 AliError("no gAlice object. Restart aliroot and try again.");
1842 if (gAlice->Modules()->GetEntries() > 0) {
1843 AliError("gAlice was already run. Restart aliroot and try again.");
1847 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1851 gROOT->LoadMacro(fConfigFileName.Data());
1852 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
1854 if(AliCDBManager::Instance()->GetRun() >= 0) {
1855 SetRunNumber(AliCDBManager::Instance()->GetRun());
1857 AliWarning("Run number not initialized!!");
1860 AliRunLoader::Instance()->CdGAFile();
1862 AliPDG::AddParticlesToPdgDataBase();
1864 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
1866 gAlice->GetMCApp()->Init();
1868 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1869 gAlice->InitLoaders();
1870 AliRunLoader::Instance()->MakeTree("E");
1871 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1872 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1873 AliRunLoader::Instance()->LoadHits("all","RECREATE");
1876 // Save stuff at the beginning of the file to avoid file corruption
1877 AliRunLoader::Instance()->CdGAFile();
1882 //AliCDBManager* man = AliCDBManager::Instance();
1883 //man->SetRun(0); // Should this come from rawdata header ?
1887 // Get the runloader
1888 AliRunLoader* runLoader = AliRunLoader::Instance();
1890 // Open esd file if available
1893 AliESDEvent* esd = 0;
1894 if (esdFileName && (strlen(esdFileName)>0)) {
1895 esdFile = TFile::Open(esdFileName);
1897 esd = new AliESDEvent();
1898 esdFile->GetObject("esdTree", treeESD);
1899 if (treeESD) esd->ReadFromTree(treeESD);
1904 // Create the RawReader
1905 TString fileName(rawDirectory);
1906 AliRawReader* rawReader = 0x0;
1907 if (fileName.EndsWith("/")) {
1908 rawReader = new AliRawReaderFile(fileName);
1909 } else if (fileName.EndsWith(".root")) {
1910 rawReader = new AliRawReaderRoot(fileName);
1911 } else if (!fileName.IsNull()) {
1912 rawReader = new AliRawReaderDate(fileName);
1914 if (!rawReader) return (kFALSE);
1916 // if (!fEquipIdMap.IsNull() && fRawReader)
1917 // fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1919 // Get list of detectors
1920 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1923 AliHeader* header = runLoader->GetHeader();
1927 if (!(rawReader->NextEvent())) break;
1928 runLoader->SetEventNumber(nev);
1929 runLoader->GetHeader()->Reset(rawReader->GetRunNumber(),
1931 runLoader->GetEvent(nev);
1932 AliInfo(Form("We are at event %d",nev));
1935 TString detStr = fMakeSDigits;
1936 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1937 AliModule* det = (AliModule*) detArray->At(iDet);
1938 if (!det || !det->IsActive()) continue;
1939 if (IsSelected(det->GetName(), detStr)) {
1940 AliInfo(Form("Calling Raw2SDigits for %s", det->GetName()));
1941 det->Raw2SDigits(rawReader);
1948 // If ESD information available obtain reconstructed vertex and store in header.
1950 treeESD->GetEvent(nev);
1951 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1952 Double_t position[3];
1953 esdVertex->GetXYZ(position);
1954 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
1957 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1958 mcHeader->SetPrimaryVertex(mcV);
1959 header->Reset(0,nev);
1960 header->SetGenEventHeader(mcHeader);
1961 AliInfo(Form("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]));
1965 runLoader->TreeE()->Fill();
1966 AliInfo(Form("Finished event %d",nev));
1975 runLoader->CdGAFile();
1976 runLoader->WriteHeader("OVERWRITE");
1977 runLoader->WriteRunLoader();
1982 //_____________________________________________________________________________
1983 void AliSimulation::FinishRun()
1986 // Called at the end of the run.
1991 AliDebug(1, "Finish Lego");
1992 AliRunLoader::Instance()->CdGAFile();
1996 // Clean detector information
1997 TIter next(gAlice->Modules());
1998 AliModule *detector;
1999 while((detector = dynamic_cast<AliModule*>(next()))) {
2000 AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
2001 detector->FinishRun();
2004 AliDebug(1, "AliRunLoader::Instance()->WriteHeader(OVERWRITE)");
2005 AliRunLoader::Instance()->WriteHeader("OVERWRITE");
2007 // Write AliRun info and all detectors parameters
2008 AliRunLoader::Instance()->CdGAFile();
2009 gAlice->Write(0,TObject::kOverwrite);//write AliRun
2010 AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
2012 if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();
2013 AliRunLoader::Instance()->Synchronize();
2016 //_____________________________________________________________________________
2017 Int_t AliSimulation::GetDetIndex(const char* detector)
2019 // return the detector index corresponding to detector
2021 for (index = 0; index < fgkNDetectors ; index++) {
2022 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2028 //_____________________________________________________________________________
2029 Bool_t AliSimulation::CreateHLT()
2031 // Init the HLT simulation.
2032 // The function loads the library and creates the instance of AliHLTSimulation.
2033 // the main reason for the decoupled creation is to set the transient OCDB
2034 // objects before the OCDB is locked
2036 // load the library dynamically
2037 gSystem->Load(ALIHLTSIMULATION_LIBRARY);
2039 // check for the library version
2040 AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
2042 AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
2045 if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
2046 AliWarning(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
2049 // print compile info
2050 typedef void (*CompileInfo)( const char*& date, const char*& time);
2051 CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
2053 const char* date="";
2054 const char* time="";
2055 (*fctInfo)(date, time);
2056 if (!date) date="unknown";
2057 if (!time) time="unknown";
2058 AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
2060 AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
2063 // create instance of the HLT simulation
2064 AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
2065 if (fctCreate==NULL || (fpHLT=(fctCreate()))==NULL) {
2066 AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
2070 TString specObjects;
2071 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
2072 if (specObjects.Length()>0) specObjects+=" ";
2073 specObjects+=fSpecCDBUri[i]->GetName();
2076 AliHLTSimulationSetup_t fctSetup=(AliHLTSimulationSetup_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_SETUP));
2077 if (fctSetup==NULL || fctSetup(fpHLT, this, specObjects.Data())<0) {
2078 AliWarning(Form("failed to setup HLT simulation (function %p)", fctSetup));
2084 //_____________________________________________________________________________
2085 Bool_t AliSimulation::RunHLT()
2087 // Run the HLT simulation
2088 // HLT simulation is implemented in HLT/sim/AliHLTSimulation
2089 // Disabled if fRunHLT is empty, default vaule is "default".
2090 // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
2091 // The default simulation depends on the HLT component libraries and their
2092 // corresponding agents which define components and chains to run. See
2093 // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/
2094 // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/classAliHLTModuleAgent.html
2096 // The libraries to be loaded can be specified as an option.
2098 // AliSimulation sim;
2099 // sim.SetRunHLT("libAliHLTSample.so");
2101 // will only load <tt>libAliHLTSample.so</tt>
2103 // Other available options:
2104 // \li loglevel=<i>level</i> <br>
2105 // logging level for this processing
2107 // disable redirection of log messages to AliLog class
2108 // \li config=<i>macro</i>
2109 // configuration macro
2110 // \li chains=<i>configuration</i>
2111 // comma separated list of configurations to be run during simulation
2112 // \li rawfile=<i>file</i>
2113 // source for the RawReader to be created, the default is <i>./</i> if
2114 // raw data is simulated
2118 if (!fpHLT && !CreateHLT()) {
2121 AliHLTSimulation* pHLT=fpHLT;
2123 AliRunLoader* pRunLoader = LoadRun("READ");
2124 if (!pRunLoader) return kFALSE;
2126 // initialize CDB storage, run number, set CDB lock
2127 // thats for the case of running HLT simulation without all the other steps
2128 // multiple calls are handled by the function, so we can just call
2130 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
2133 // init the HLT simulation
2135 if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
2136 TString detStr = fWriteRawData;
2137 if (!IsSelected("HLT", detStr)) {
2138 options+=" writerawfiles=";
2140 options+=" writerawfiles=HLT";
2143 if (!detStr.IsNull() && !options.Contains("rawfile=")) {
2144 // as a matter of fact, HLT will run reconstruction and needs the RawReader
2145 // in order to get detector data. By default, RawReaderFile is used to read
2146 // the already simulated ddl files. Date and Root files from the raw data
2147 // are generated after the HLT simulation.
2148 options+=" rawfile=./";
2151 AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
2152 if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, options.Data())))<0) {
2153 AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
2155 // run the HLT simulation
2156 AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
2157 if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
2158 AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
2162 // delete the instance
2163 AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
2164 if (fctDelete==NULL || fctDelete(pHLT)<0) {
2165 AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
2169 return iResult>=0?kTRUE:kFALSE;
2172 //_____________________________________________________________________________
2173 Bool_t AliSimulation::RunQA()
2175 // run the QA on summable hits, digits or digits
2177 //if(!gAlice) return kFALSE;
2178 AliQAManager::QAManager()->SetRunLoader(AliRunLoader::Instance()) ;
2180 TString detectorsw("") ;
2182 AliQAManager::QAManager()->SetEventSpecie(fEventSpecie) ;
2183 detectorsw = AliQAManager::QAManager()->Run(fQADetectors.Data()) ;
2184 if ( detectorsw.IsNull() )
2189 //_____________________________________________________________________________
2190 Bool_t AliSimulation::SetRunQA(TString detAndAction)
2192 // Allows to run QA for a selected set of detectors
2193 // and a selected set of tasks among HITS, SDIGITS and DIGITS
2194 // all selected detectors run the same selected tasks
2196 if (!detAndAction.Contains(":")) {
2197 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
2201 Int_t colon = detAndAction.Index(":") ;
2202 fQADetectors = detAndAction(0, colon) ;
2203 if (fQADetectors.Contains("ALL") ){
2204 TString tmp = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
2205 Int_t minus = fQADetectors.Last('-') ;
2206 TString toKeep = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
2207 TString toRemove("") ;
2208 while (minus >= 0) {
2209 toRemove = fQADetectors(minus+1, fQADetectors.Length()) ;
2210 toRemove = toRemove.Strip() ;
2211 toKeep.ReplaceAll(toRemove, "") ;
2212 fQADetectors.ReplaceAll(Form("-%s", toRemove.Data()), "") ;
2213 minus = fQADetectors.Last('-') ;
2215 fQADetectors = toKeep ;
2217 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
2218 if (fQATasks.Contains("ALL") ) {
2219 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
2221 fQATasks.ToUpper() ;
2223 if ( fQATasks.Contains("HIT") )
2224 tempo = Form("%d ", AliQAv1::kHITS) ;
2225 if ( fQATasks.Contains("SDIGIT") )
2226 tempo += Form("%d ", AliQAv1::kSDIGITS) ;
2227 if ( fQATasks.Contains("DIGIT") )
2228 tempo += Form("%d ", AliQAv1::kDIGITS) ;
2230 if (fQATasks.IsNull()) {
2231 AliInfo("No QA requested\n") ;
2236 TString tempo(fQATasks) ;
2237 tempo.ReplaceAll(Form("%d", AliQAv1::kHITS), AliQAv1::GetTaskName(AliQAv1::kHITS)) ;
2238 tempo.ReplaceAll(Form("%d", AliQAv1::kSDIGITS), AliQAv1::GetTaskName(AliQAv1::kSDIGITS)) ;
2239 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITS), AliQAv1::GetTaskName(AliQAv1::kDIGITS)) ;
2240 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
2242 AliQAManager::QAManager()->SetActiveDetectors(fQADetectors) ;
2243 AliQAManager::QAManager()->SetTasks(fQATasks) ;
2244 for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++)
2245 AliQAManager::QAManager()->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
2250 //_____________________________________________________________________________
2251 void AliSimulation::ProcessEnvironmentVars()
2253 // Extract run number and random generator seed from env variables
2255 AliInfo("Processing environment variables");
2257 // Random Number seed
2259 // first check that seed is not already set
2261 if (gSystem->Getenv("CONFIG_SEED")) {
2262 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
2265 if (gSystem->Getenv("CONFIG_SEED")) {
2266 AliInfo(Form("Seed for random number generation already set (%d)"
2267 ": CONFIG_SEED variable ignored!", fSeed));
2271 AliInfo(Form("Seed for random number generation = %d ", fSeed));
2275 // first check that run number is not already set
2277 if (gSystem->Getenv("DC_RUN")) {
2278 fRun = atoi(gSystem->Getenv("DC_RUN"));
2281 if (gSystem->Getenv("DC_RUN")) {
2282 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
2286 AliInfo(Form("Run number = %d", fRun));
2289 //---------------------------------------------------------------------
2290 void AliSimulation::WriteGRPEntry()
2292 // Get the necessary information from galice (generator, trigger etc) and
2293 // write a GRP entry corresponding to the settings in the Config.C used
2294 // note that Hall probes and Cavern and Surface Atmos pressures are not simulated.
2297 AliInfo("Writing global run parameters entry into the OCDB");
2299 AliGRPObject* grpObj = new AliGRPObject();
2301 grpObj->SetRunType("PHYSICS");
2302 grpObj->SetTimeStart(fTimeStart);
2303 grpObj->SetTimeEnd(fTimeEnd);
2304 grpObj->SetBeamEnergyIsSqrtSHalfGeV(); // new format of GRP: store sqrt(s)/2 in GeV
2306 const AliGenerator *gen = gAlice->GetMCApp()->Generator();
2312 gen->GetProjectile(projectile,a,z);
2314 gen->GetTarget(target,a,z);
2315 TString beamType = projectile + "-" + target;
2316 beamType.ReplaceAll(" ","");
2317 if (!beamType.CompareTo("-")) {
2318 grpObj->SetBeamType("UNKNOWN");
2319 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2);
2322 grpObj->SetBeamType(beamType);
2324 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 * a / z);
2326 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 );
2328 // Heavy ion run, the event specie is set to kHighMult
2329 fEventSpecie = AliRecoParam::kHighMult;
2330 if ((strcmp(beamType,"p-p") == 0) ||
2331 (strcmp(beamType,"p-") == 0) ||
2332 (strcmp(beamType,"-p") == 0) ||
2333 (strcmp(beamType,"P-P") == 0) ||
2334 (strcmp(beamType,"P-") == 0) ||
2335 (strcmp(beamType,"-P") == 0)) {
2336 // Proton run, the event specie is set to kLowMult
2337 fEventSpecie = AliRecoParam::kLowMult;
2341 AliWarning("Unknown beam type and energy! Setting energy to 0");
2342 grpObj->SetBeamEnergy(0);
2343 grpObj->SetBeamType("UNKNOWN");
2346 UInt_t detectorPattern = 0;
2348 TObjArray *detArray = gAlice->Detectors();
2349 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors-1; iDet++) {
2350 if (detArray->FindObject(AliDAQ::OfflineModuleName(iDet))) {
2351 AliDebug(1, Form("Detector #%d found: %s", iDet, AliDAQ::OfflineModuleName(iDet)));
2352 detectorPattern |= (1 << iDet);
2357 if (!fTriggerConfig.IsNull())
2358 detectorPattern |= (1 << AliDAQ::DetectorID("TRG"));
2361 if (!fRunHLT.IsNull())
2362 detectorPattern |= (1 << AliDAQ::kHLTId);
2364 grpObj->SetNumberOfDetectors((Char_t)nDets);
2365 grpObj->SetDetectorMask((Int_t)detectorPattern);
2366 grpObj->SetLHCPeriod("LHC08c");
2367 grpObj->SetLHCState("STABLE_BEAMS");
2369 AliMagF *field = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2370 Float_t solenoidField = field ? TMath::Abs(field->SolenoidField()) : 0;
2372 Float_t factorSol = field ? field->GetFactorSol() : 0;
2373 Float_t currentSol = TMath::Abs(factorSol)>1E-6 ?
2374 TMath::Nint(TMath::Abs(solenoidField/factorSol))/5.*30000.*TMath::Abs(factorSol) : 0;
2376 Float_t factorDip = field ? field->GetFactorDip() : 0;
2377 Float_t currentDip = 6000.*TMath::Abs(factorDip);
2379 grpObj->SetL3Current(currentSol,(AliGRPObject::Stats)0);
2380 grpObj->SetDipoleCurrent(currentDip,(AliGRPObject::Stats)0);
2381 grpObj->SetL3Polarity(factorSol>0 ? 0:1);
2382 grpObj->SetDipolePolarity(factorDip>0 ? 0:1);
2383 if (field) grpObj->SetUniformBMap(field->IsUniform()); // for special MC with k5kGUniform map
2384 grpObj->SetPolarityConventionLHC(); // LHC convention +/+ current -> -/- field main components
2386 grpObj->SetCavernTemperature(0,(AliGRPObject::Stats)0);
2388 //grpMap->Add(new TObjString("fCavernPressure"),new TObjString("0")); ---> not inserted in simulation with the new object, since it is now an AliDCSSensor
2390 // Now store the entry in OCDB
2391 AliCDBManager* man = AliCDBManager::Instance();
2393 man->SetLock(0, fKey);
2395 AliCDBStorage* sto = man->GetStorage(fGRPWriteLocation.Data());
2398 AliCDBId id("GRP/GRP/Data", man->GetRun(), man->GetRun(), 1, 1);
2399 AliCDBMetaData *metadata= new AliCDBMetaData();
2401 metadata->SetResponsible("alice-off@cern.ch");
2402 metadata->SetComment("Automatically produced GRP entry for Monte Carlo");
2404 sto->Put(grpObj,id,metadata);
2405 man->SetLock(1, fKey);
2408 //_____________________________________________________________________________
2409 time_t AliSimulation::GenerateTimeStamp() const
2411 // Generate event time-stamp according to
2412 // SOR/EOR time from GRP
2413 if (fUseTimeStampFromCDB)
2414 return fTimeStart + gRandom->Integer(fTimeEnd-fTimeStart);