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