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