Modifications to work with Stores (Philippe C.)
[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
b856a511 108#include <TVirtualMCApplication.h>
e8d02863 109#include <TGeoManager.h>
85a5290f 110#include <TObjString.h>
af7ba10c 111#include <TSystem.h>
bfbd5665 112#include <TFile.h>
85a5290f 113
87932dab 114#include "AliCodeTimer.h"
e8d02863 115#include "AliCDBStorage.h"
116#include "AliCDBEntry.h"
117#include "AliCDBManager.h"
25be1e5c 118#include "AliGeomManager.h"
e8d02863 119#include "AliAlignObj.h"
120#include "AliCentralTrigger.h"
362c9d61 121#include "AliDAQ.h"
af7ba10c 122#include "AliDigitizer.h"
123#include "AliGenerator.h"
e8d02863 124#include "AliLog.h"
af7ba10c 125#include "AliModule.h"
126#include "AliRun.h"
127#include "AliRunDigitizer.h"
128#include "AliRunLoader.h"
129#include "AliSimulation.h"
130#include "AliVertexGenFile.h"
a5a091ce 131#include "AliCentralTrigger.h"
007155cc 132#include "AliCTPRawData.h"
ca30848f 133#include "AliRawReaderFile.h"
134#include "AliESD.h"
135#include "AliHeader.h"
136#include "AliGenEventHeader.h"
b856a511 137#include "AliMC.h"
85a5290f 138
139ClassImp(AliSimulation)
140
b856a511 141AliSimulation *AliSimulation::fgInstance = 0;
85a5290f 142
143//_____________________________________________________________________________
024cf675 144AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
95601147 145 const char* name, const char* title) :
146 TNamed(name, title),
147
148 fRunGeneration(kTRUE),
149 fRunSimulation(kTRUE),
024cf675 150 fLoadAlignFromCDB(kTRUE),
25be1e5c 151 fLoadAlObjsListOfDets("ALL"),
95601147 152 fMakeSDigits("ALL"),
153 fMakeDigits("ALL"),
a5a091ce 154 fMakeTrigger(""),
95601147 155 fMakeDigitsFromHits(""),
0421c3d1 156 fWriteRawData(""),
06c7e392 157 fRawDataFileName(""),
158 fDeleteIntermediateFiles(kFALSE),
95601147 159 fStopOnError(kFALSE),
160
161 fNEvents(1),
162 fConfigFileName(configFileName),
163 fGAliceFileName("galice.root"),
18b43626 164 fEventsPerFile(),
95601147 165 fBkgrdFileNames(NULL),
995ad051 166 fAlignObjArray(NULL),
04bae0a0 167 fUseBkgrdVertex(kTRUE),
024cf675 168 fRegionOfInterest(kFALSE),
ec92bee0 169 fCDBUri(cdbUri),
ca30848f 170 fSpecCDBUri(),
171 fEmbeddingFlag(kFALSE)
85a5290f 172{
173// create simulation object with default parameters
b856a511 174 fgInstance = this;
0421c3d1 175 SetGAliceFile("galice.root");
85a5290f 176}
177
178//_____________________________________________________________________________
179AliSimulation::AliSimulation(const AliSimulation& sim) :
95601147 180 TNamed(sim),
181
182 fRunGeneration(sim.fRunGeneration),
183 fRunSimulation(sim.fRunSimulation),
024cf675 184 fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
25be1e5c 185 fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets),
95601147 186 fMakeSDigits(sim.fMakeSDigits),
187 fMakeDigits(sim.fMakeDigits),
a5a091ce 188 fMakeTrigger(sim.fMakeTrigger),
95601147 189 fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
0421c3d1 190 fWriteRawData(sim.fWriteRawData),
06c7e392 191 fRawDataFileName(""),
192 fDeleteIntermediateFiles(kFALSE),
95601147 193 fStopOnError(sim.fStopOnError),
194
195 fNEvents(sim.fNEvents),
196 fConfigFileName(sim.fConfigFileName),
197 fGAliceFileName(sim.fGAliceFileName),
18b43626 198 fEventsPerFile(),
95601147 199 fBkgrdFileNames(NULL),
995ad051 200 fAlignObjArray(NULL),
04bae0a0 201 fUseBkgrdVertex(sim.fUseBkgrdVertex),
024cf675 202 fRegionOfInterest(sim.fRegionOfInterest),
ec92bee0 203 fCDBUri(sim.fCDBUri),
ca30848f 204 fSpecCDBUri(),
205 fEmbeddingFlag(sim.fEmbeddingFlag)
85a5290f 206{
207// copy constructor
208
18b43626 209 for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
210 if (!sim.fEventsPerFile[i]) continue;
211 fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
212 }
213
85a5290f 214 fBkgrdFileNames = new TObjArray;
215 for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
216 if (!sim.fBkgrdFileNames->At(i)) continue;
217 fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
218 }
ec92bee0 219
220 for (Int_t i = 0; i < sim.fSpecCDBUri.GetEntriesFast(); i++) {
221 if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
222 }
b856a511 223 fgInstance = this;
85a5290f 224}
225
226//_____________________________________________________________________________
227AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
228{
229// assignment operator
230
231 this->~AliSimulation();
232 new(this) AliSimulation(sim);
233 return *this;
234}
235
236//_____________________________________________________________________________
237AliSimulation::~AliSimulation()
238{
239// clean up
240
18b43626 241 fEventsPerFile.Delete();
024cf675 242// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
243// delete fAlignObjArray; fAlignObjArray=0;
18b43626 244
95601147 245 if (fBkgrdFileNames) {
246 fBkgrdFileNames->Delete();
247 delete fBkgrdFileNames;
248 }
ec92bee0 249
250 fSpecCDBUri.Delete();
b856a511 251 if (fgInstance==this) fgInstance = 0;
87932dab 252
253 AliCodeTimer::Instance()->Print();
85a5290f 254}
255
256
257//_____________________________________________________________________________
258void AliSimulation::SetNumberOfEvents(Int_t nEvents)
259{
260// set the number of events for one run
261
262 fNEvents = nEvents;
263}
264
265//_____________________________________________________________________________
ec92bee0 266void AliSimulation::InitCDBStorage()
024cf675 267{
268// activate a default CDB storage
269// First check if we have any CDB storage set, because it is used
270// to retrieve the calibration and alignment constants
271
272 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 273 if (man->IsDefaultStorageSet())
024cf675 274 {
ec92bee0 275 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
276 AliWarning("Default CDB storage has been already set !");
277 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
278 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
279 fCDBUri = "";
280 }
281 else {
b8ec52f6 282 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
283 AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
284 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 285 man->SetDefaultStorage(fCDBUri);
286 }
287
288 // Now activate the detector specific CDB storage locations
289 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
290 TObject* obj = fSpecCDBUri[i];
291 if (!obj) continue;
b8ec52f6 292 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
293 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
294 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 295 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 296 }
727d0766 297 man->Print();
024cf675 298}
299
300//_____________________________________________________________________________
301void AliSimulation::SetDefaultStorage(const char* uri) {
ec92bee0 302// Store the desired default CDB storage location
303// Activate it later within the Run() method
024cf675 304
ec92bee0 305 fCDBUri = uri;
024cf675 306
307}
308
309//_____________________________________________________________________________
c3a7b59a 310void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 311// Store a detector-specific CDB storage location
312// Activate it later within the Run() method
024cf675 313
c3a7b59a 314 AliCDBPath aPath(calibType);
315 if(!aPath.IsValid()){
316 AliError(Form("Not a valid path: %s", calibType));
317 return;
318 }
319
320 TObject* obj = fSpecCDBUri.FindObject(calibType);
ec92bee0 321 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 322 fSpecCDBUri.Add(new TNamed(calibType, uri));
024cf675 323
324}
325
326//_____________________________________________________________________________
85a5290f 327void AliSimulation::SetConfigFile(const char* fileName)
328{
329// set the name of the config file
330
331 fConfigFileName = fileName;
332}
333
334//_____________________________________________________________________________
0421c3d1 335void AliSimulation::SetGAliceFile(const char* fileName)
336{
337// set the name of the galice file
338// the path is converted to an absolute one if it is relative
339
340 fGAliceFileName = fileName;
341 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
342 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
343 fGAliceFileName);
344 fGAliceFileName = absFileName;
345 delete[] absFileName;
346 }
ac1671c0 347
348 AliDebug(2, Form("galice file name set to %s", fileName));
0421c3d1 349}
350
351//_____________________________________________________________________________
18b43626 352void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
353 Int_t nEvents)
354{
355// set the number of events per file for the given detector and data type
356// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
357
358 TNamed* obj = new TNamed(detector, type);
359 obj->SetUniqueID(nEvents);
360 fEventsPerFile.Add(obj);
361}
362
363//_____________________________________________________________________________
6bae477a 364Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
365{
366 // Read the alignment objects from CDB.
367 // Each detector is supposed to have the
368 // alignment objects in DET/Align/Data CDB path.
369 // All the detector objects are then collected,
370 // sorted by geometry level (starting from ALIC) and
371 // then applied to the TGeo geometry.
372 // Finally an overlaps check is performed.
373
74ae4297 374 if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
375 AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
0717eed2 376 return kFALSE;
377 }
6bae477a 378 Bool_t delRunLoader = kFALSE;
379 if (!runLoader) {
380 runLoader = LoadRun("READ");
381 if (!runLoader) return kFALSE;
382 delRunLoader = kTRUE;
383 }
384
b856a511 385 // Export ideal geometry
74ae4297 386 AliGeomManager::GetGeometry()->Export("geometry.root");
b856a511 387
25be1e5c 388 // Load alignment data from CDB and apply to geometry through AliGeomManager
6bae477a 389 if(fLoadAlignFromCDB){
25be1e5c 390
391 TString detStr = fLoadAlObjsListOfDets;
392 TString loadAlObjsListOfDets = "";
393
394 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
395 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
396 AliModule* det = (AliModule*) detArray->At(iDet);
397 if (!det || !det->IsActive()) continue;
398 if (IsSelected(det->GetName(), detStr)) {
0717eed2 399 //add det to list of dets to be aligned from CDB
400 loadAlObjsListOfDets += det->GetName();
401 loadAlObjsListOfDets += " ";
25be1e5c 402 }
403 } // end loop over detectors
45daac75 404 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 405 }else{
406 // Check if the array with alignment objects was
407 // provided by the user. If yes, apply the objects
408 // to the present TGeo geometry
409 if (fAlignObjArray) {
45daac75 410 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
0717eed2 411 AliError("The misalignment of one or more volumes failed!"
412 "Compare the list of simulated detectors and the list of detector alignment data!");
413 if (delRunLoader) delete runLoader;
414 return kFALSE;
6bae477a 415 }
416 }
6bae477a 417 }
418
ef7ff1f9 419 // Update the internal geometry of modules (ITS needs it)
25be1e5c 420 TString detStr = fLoadAlObjsListOfDets;
ef7ff1f9 421 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
422 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
423
424 AliModule* det = (AliModule*) detArray->At(iDet);
425 if (!det || !det->IsActive()) continue;
426 if (IsSelected(det->GetName(), detStr)) {
427 det->UpdateInternalGeometry();
428 }
429 } // end loop over detectors
430
431
6bae477a 432 if (delRunLoader) delete runLoader;
433
434 return kTRUE;
435}
436
437
438//_____________________________________________________________________________
439Bool_t AliSimulation::SetRunNumber()
440{
441 // Set the CDB manager run number
442 // The run number is retrieved from gAlice
443
444 if(AliCDBManager::Instance()->GetRun() < 0) {
445 AliRunLoader* runLoader = LoadRun("READ");
446 if (!runLoader) return kFALSE;
447 else {
448 AliCDBManager::Instance()->SetRun(runLoader->GetAliRun()->GetRunNumber());
449 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
450 delete runLoader;
451 }
452 }
453 return kTRUE;
454}
455
456//_____________________________________________________________________________
85a5290f 457void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
458{
459// add a file with background events for merging
460
461 TObjString* fileNameStr = new TObjString(fileName);
462 fileNameStr->SetUniqueID(nSignalPerBkgrd);
95601147 463 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
85a5290f 464 fBkgrdFileNames->Add(fileNameStr);
465}
466
ca30848f 467void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
468{
469// add a file with background events for embeddin
470 MergeWith(fileName, nSignalPerBkgrd);
471 fEmbeddingFlag = kTRUE;
472}
85a5290f 473
474//_____________________________________________________________________________
475Bool_t AliSimulation::Run(Int_t nEvents)
476{
477// run the generation, simulation and digitization
478
87932dab 479 AliCodeTimerAuto("")
480
ec92bee0 481 InitCDBStorage();
b0314964 482
85a5290f 483 if (nEvents > 0) fNEvents = nEvents;
484
485 // generation and simulation -> hits
486 if (fRunGeneration) {
85a5290f 487 if (!RunSimulation()) if (fStopOnError) return kFALSE;
488 }
489
6bae477a 490 // Set run number in CDBManager (if it is not already set in RunSimulation)
491 if (!SetRunNumber()) if (fStopOnError) return kFALSE;
492
25be1e5c 493 // If RunSimulation was not called, load the geometry and misalign it
74ae4297 494 if (!AliGeomManager::GetGeometry()) {
495 // Initialize the geometry manager
45daac75 496 AliGeomManager::LoadGeometry("geometry.root");
74ae4297 497 if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
498 // Misalign geometry
25be1e5c 499 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
6bae477a 500 }
25be1e5c 501
85a5290f 502 // hits -> summable digits
503 if (!fMakeSDigits.IsNull()) {
504 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
505 }
506
507 // summable digits -> digits
508 if (!fMakeDigits.IsNull()) {
509 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
510 if (fStopOnError) return kFALSE;
511 }
512 }
513
514 // hits -> digits
515 if (!fMakeDigitsFromHits.IsNull()) {
95601147 516 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
ac1671c0 517 AliWarning(Form("Merging and direct creation of digits from hits "
518 "was selected for some detectors. "
519 "No merging will be done for the following detectors: %s",
520 fMakeDigitsFromHits.Data()));
85a5290f 521 }
522 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
523 if (fStopOnError) return kFALSE;
524 }
525 }
526
a5a091ce 527 // digits -> trigger
087426de 528 if (!RunTrigger(fMakeTrigger)) {
529 if (fStopOnError) return kFALSE;
a5a091ce 530 }
531
0421c3d1 532 // digits -> raw data
533 if (!fWriteRawData.IsNull()) {
06c7e392 534 if (!WriteRawData(fWriteRawData, fRawDataFileName,
535 fDeleteIntermediateFiles)) {
0421c3d1 536 if (fStopOnError) return kFALSE;
537 }
538 }
539
85a5290f 540 return kTRUE;
541}
542
543//_____________________________________________________________________________
a5a091ce 544Bool_t AliSimulation::RunTrigger(const char* descriptors)
545{
546 // run the trigger
547
87932dab 548 AliCodeTimerAuto("")
a5a091ce 549
bacbe0fd 550 AliRunLoader* runLoader = LoadRun("READ");
551 if (!runLoader) return kFALSE;
552 TString des = descriptors;
553
087426de 554 if (des.IsNull()) {
555 if (gAlice->GetTriggerDescriptor() != "") {
556 des = gAlice->GetTriggerDescriptor();
557 }
558 else {
559 AliWarning("No trigger descriptor is specified. Skipping the trigger simulation...");
560 return kTRUE;
561 }
562 }
563
0f46f5fa 564 runLoader->MakeTree( "GG" );
bacbe0fd 565 AliCentralTrigger* aCTP = runLoader->GetTrigger();
a5a091ce 566 // Load Descriptors
bacbe0fd 567 aCTP->LoadDescriptor( des );
a5a091ce 568
569 // digits -> trigger
bacbe0fd 570 if( !aCTP->RunTrigger( runLoader ) ) {
a5a091ce 571 if (fStopOnError) {
bacbe0fd 572 // delete aCTP;
a5a091ce 573 return kFALSE;
574 }
bacbe0fd 575 }
a5a091ce 576
bacbe0fd 577 delete runLoader;
a5a091ce 578
bacbe0fd 579 return kTRUE;
a5a091ce 580}
581
007155cc 582//_____________________________________________________________________________
583Bool_t AliSimulation::WriteTriggerRawData()
584{
585 // Writes the CTP (trigger) DDL raw data
586 // Details of the format are given in the
587 // trigger TDR - pages 134 and 135.
588 AliCTPRawData writer;
589 writer.RawData();
a5a091ce 590
007155cc 591 return kTRUE;
592}
a5a091ce 593
594//_____________________________________________________________________________
95601147 595Bool_t AliSimulation::RunSimulation(Int_t nEvents)
85a5290f 596{
597// run the generation and simulation
598
87932dab 599 AliCodeTimerAuto("")
4df28b43 600
95601147 601 if (!gAlice) {
ac1671c0 602 AliError("no gAlice object. Restart aliroot and try again.");
95601147 603 return kFALSE;
604 }
605 if (gAlice->Modules()->GetEntries() > 0) {
ac1671c0 606 AliError("gAlice was already run. Restart aliroot and try again.");
95601147 607 return kFALSE;
608 }
609
ac1671c0 610 AliInfo(Form("initializing gAlice with config file %s",
611 fConfigFileName.Data()));
815c2b38 612 StdoutToAliInfo(StderrToAliError(
613 gAlice->Init(fConfigFileName.Data());
614 ););
995ad051 615
087426de 616 // Get the trigger descriptor string
617 // Either from AliSimulation or from
618 // gAlice
619 if (fMakeTrigger.IsNull()) {
620 if (gAlice->GetTriggerDescriptor() != "")
621 fMakeTrigger = gAlice->GetTriggerDescriptor();
622 }
623 else
624 gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
625
6bae477a 626 // Set run number in CDBManager
024cf675 627 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
628
629 AliRunLoader* runLoader = gAlice->GetRunLoader();
630 if (!runLoader) {
631 AliError(Form("gAlice has no run loader object. "
632 "Check your config file: %s", fConfigFileName.Data()));
633 return kFALSE;
634 }
635 SetGAliceFile(runLoader->GetFileName());
636
6bae477a 637 // Misalign geometry
caf9c464 638#if ROOT_VERSION_CODE < 331527
74ae4297 639 AliGeomManager::SetGeometry(gGeoManager);
caf9c464 640 MisalignGeometry(runLoader);
641#endif
995ad051 642
024cf675 643// AliRunLoader* runLoader = gAlice->GetRunLoader();
644// if (!runLoader) {
645// AliError(Form("gAlice has no run loader object. "
646// "Check your config file: %s", fConfigFileName.Data()));
647// return kFALSE;
648// }
649// SetGAliceFile(runLoader->GetFileName());
85a5290f 650
04bae0a0 651 if (!gAlice->Generator()) {
ac1671c0 652 AliError(Form("gAlice has no generator object. "
653 "Check your config file: %s", fConfigFileName.Data()));
04bae0a0 654 return kFALSE;
655 }
05526d44 656 if (nEvents <= 0) nEvents = fNEvents;
04bae0a0 657
658 // get vertex from background file in case of merging
659 if (fUseBkgrdVertex &&
660 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
05526d44 661 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
04bae0a0 662 const char* fileName = ((TObjString*)
663 (fBkgrdFileNames->At(0)))->GetName();
ac1671c0 664 AliInfo(Form("The vertex will be taken from the background "
665 "file %s with nSignalPerBackground = %d",
666 fileName, signalPerBkgrd));
04bae0a0 667 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
668 gAlice->Generator()->SetVertexGenerator(vtxGen);
669 }
670
85a5290f 671 if (!fRunSimulation) {
85a5290f 672 gAlice->Generator()->SetTrackingFlag(0);
673 }
674
18b43626 675 // set the number of events per file for given detectors and data types
676 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
677 if (!fEventsPerFile[i]) continue;
678 const char* detName = fEventsPerFile[i]->GetName();
679 const char* typeName = fEventsPerFile[i]->GetTitle();
680 TString loaderName(detName);
681 loaderName += "Loader";
682 AliLoader* loader = runLoader->GetLoader(loaderName);
683 if (!loader) {
ac1671c0 684 AliError(Form("RunSimulation", "no loader for %s found\n"
685 "Number of events per file not set for %s %s",
686 detName, typeName, detName));
18b43626 687 continue;
688 }
689 AliDataLoader* dataLoader =
690 loader->GetDataLoader(typeName);
691 if (!dataLoader) {
ac1671c0 692 AliError(Form("no data loader for %s found\n"
693 "Number of events per file not set for %s %s",
694 typeName, detName, typeName));
18b43626 695 continue;
696 }
697 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
ac1671c0 698 AliDebug(1, Form("number of events per file set to %d for %s %s",
699 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
18b43626 700 }
701
ac1671c0 702 AliInfo("running gAlice");
815c2b38 703 StdoutToAliInfo(StderrToAliError(
704 gAlice->Run(nEvents);
705 ););
95601147 706
707 delete runLoader;
85a5290f 708
4df28b43 709
85a5290f 710 return kTRUE;
711}
712
713//_____________________________________________________________________________
95601147 714Bool_t AliSimulation::RunSDigitization(const char* detectors)
85a5290f 715{
716// run the digitization and produce summable digits
717
87932dab 718 AliCodeTimerAuto("")
4df28b43 719
95601147 720 AliRunLoader* runLoader = LoadRun();
721 if (!runLoader) return kFALSE;
722
85a5290f 723 TString detStr = detectors;
95601147 724 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 725 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
726 AliModule* det = (AliModule*) detArray->At(iDet);
727 if (!det || !det->IsActive()) continue;
728 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 729 AliInfo(Form("creating summable digits for %s", det->GetName()));
87932dab 730 AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
85a5290f 731 det->Hits2SDigits();
732 }
733 }
734
735 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 736 AliError(Form("the following detectors were not found: %s",
737 detStr.Data()));
85a5290f 738 if (fStopOnError) return kFALSE;
739 }
740
95601147 741 delete runLoader;
742
85a5290f 743 return kTRUE;
744}
745
746
747//_____________________________________________________________________________
95601147 748Bool_t AliSimulation::RunDigitization(const char* detectors,
749 const char* excludeDetectors)
85a5290f 750{
751// run the digitization and produce digits from sdigits
752
87932dab 753 AliCodeTimerAuto("")
4df28b43 754
95601147 755 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
756 if (gAlice) delete gAlice;
757 gAlice = NULL;
758
759 Int_t nStreams = 1;
05526d44 760 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
761 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
85a5290f 762 AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
ca30848f 763 // manager->SetEmbeddingFlag(fEmbeddingFlag);
85a5290f 764 manager->SetInputStream(0, fGAliceFileName.Data());
765 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
766 const char* fileName = ((TObjString*)
767 (fBkgrdFileNames->At(iStream-1)))->GetName();
768 manager->SetInputStream(iStream, fileName);
769 }
770
771 TString detStr = detectors;
772 TString detExcl = excludeDetectors;
95601147 773 manager->GetInputStream(0)->ImportgAlice();
774 AliRunLoader* runLoader =
775 AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
776 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 777 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
778 AliModule* det = (AliModule*) detArray->At(iDet);
779 if (!det || !det->IsActive()) continue;
780 if (IsSelected(det->GetName(), detStr) &&
781 !IsSelected(det->GetName(), detExcl)) {
4df28b43 782 AliDigitizer* digitizer = det->CreateDigitizer(manager);
ca30848f 783
4df28b43 784 if (!digitizer) {
ac1671c0 785 AliError(Form("no digitizer for %s", det->GetName()));
85a5290f 786 if (fStopOnError) return kFALSE;
4df28b43 787 } else {
788 digitizer->SetRegionOfInterest(fRegionOfInterest);
85a5290f 789 }
790 }
791 }
792
793 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 794 AliError(Form("the following detectors were not found: %s",
795 detStr.Data()));
85a5290f 796 if (fStopOnError) return kFALSE;
797 }
798
799 if (!manager->GetListOfTasks()->IsEmpty()) {
ac1671c0 800 AliInfo("executing digitization");
85a5290f 801 manager->Exec("");
802 }
95601147 803
85a5290f 804 delete manager;
805
806 return kTRUE;
807}
808
809//_____________________________________________________________________________
95601147 810Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
85a5290f 811{
812// run the digitization and produce digits from hits
813
87932dab 814 AliCodeTimerAuto("")
4df28b43 815
591f51bb 816 AliRunLoader* runLoader = LoadRun("READ");
95601147 817 if (!runLoader) return kFALSE;
818
85a5290f 819 TString detStr = detectors;
95601147 820 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 821 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
822 AliModule* det = (AliModule*) detArray->At(iDet);
823 if (!det || !det->IsActive()) continue;
824 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 825 AliInfo(Form("creating digits from hits for %s", det->GetName()));
85a5290f 826 det->Hits2Digits();
827 }
828 }
829
830 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 831 AliError(Form("the following detectors were not found: %s",
832 detStr.Data()));
85a5290f 833 if (fStopOnError) return kFALSE;
834 }
835
b17cac0f 836 delete runLoader;
591f51bb 837 //PH Temporary fix to avoid interference with the PHOS loder/getter
838 //PH The problem has to be solved in more general way 09/06/05
95601147 839
85a5290f 840 return kTRUE;
841}
842
0421c3d1 843//_____________________________________________________________________________
06c7e392 844Bool_t AliSimulation::WriteRawData(const char* detectors,
845 const char* fileName,
846 Bool_t deleteIntermediateFiles)
0421c3d1 847{
848// convert the digits to raw data
06c7e392 849// First DDL raw data files for the given detectors are created.
850// If a file name is given, the DDL files are then converted to a DATE file.
851// If deleteIntermediateFiles is true, the DDL raw files are deleted
852// afterwards.
853// If the file name has the extension ".root", the DATE file is converted
854// to a root file.
855// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
0421c3d1 856
87932dab 857 AliCodeTimerAuto("")
0421c3d1 858
06c7e392 859 if (!WriteRawFiles(detectors)) {
860 if (fStopOnError) return kFALSE;
861 }
862
863 TString dateFileName(fileName);
864 if (!dateFileName.IsNull()) {
865 Bool_t rootOutput = dateFileName.EndsWith(".root");
866 if (rootOutput) dateFileName += ".date";
867 if (!ConvertRawFilesToDate(dateFileName)) {
868 if (fStopOnError) return kFALSE;
869 }
870 if (deleteIntermediateFiles) {
871 AliRunLoader* runLoader = LoadRun("READ");
872 if (runLoader) for (Int_t iEvent = 0;
873 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
874 char command[256];
875 sprintf(command, "rm -r raw%d", iEvent);
876 gSystem->Exec(command);
877 }
878 }
879
880 if (rootOutput) {
881 if (!ConvertDateToRoot(dateFileName, fileName)) {
882 if (fStopOnError) return kFALSE;
883 }
884 if (deleteIntermediateFiles) {
885 gSystem->Unlink(dateFileName);
886 }
887 }
888 }
889
06c7e392 890 return kTRUE;
891}
892
893//_____________________________________________________________________________
894Bool_t AliSimulation::WriteRawFiles(const char* detectors)
895{
896// convert the digits to raw data DDL files
897
87932dab 898 AliCodeTimerAuto("")
899
06c7e392 900 AliRunLoader* runLoader = LoadRun("READ");
0421c3d1 901 if (!runLoader) return kFALSE;
902
06c7e392 903 // write raw data to DDL files
0421c3d1 904 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
ac1671c0 905 AliInfo(Form("processing event %d", iEvent));
0421c3d1 906 runLoader->GetEvent(iEvent);
907 TString baseDir = gSystem->WorkingDirectory();
908 char dirName[256];
909 sprintf(dirName, "raw%d", iEvent);
910 gSystem->MakeDirectory(dirName);
911 if (!gSystem->ChangeDirectory(dirName)) {
ac1671c0 912 AliError(Form("couldn't change to directory %s", dirName));
0421c3d1 913 if (fStopOnError) return kFALSE; else continue;
914 }
915
916 TString detStr = detectors;
917 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
918 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
919 AliModule* det = (AliModule*) detArray->At(iDet);
920 if (!det || !det->IsActive()) continue;
921 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 922 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
0421c3d1 923 det->Digits2Raw();
924 }
925 }
926
007155cc 927 if (!WriteTriggerRawData())
928 if (fStopOnError) return kFALSE;
929
0421c3d1 930 gSystem->ChangeDirectory(baseDir);
931 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 932 AliError(Form("the following detectors were not found: %s",
933 detStr.Data()));
0421c3d1 934 if (fStopOnError) return kFALSE;
935 }
936 }
937
938 delete runLoader;
87932dab 939
06c7e392 940 return kTRUE;
941}
0421c3d1 942
06c7e392 943//_____________________________________________________________________________
944Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
945{
946// convert raw data DDL files to a DATE file with the program "dateStream"
947
87932dab 948 AliCodeTimerAuto("")
949
06c7e392 950 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
951 if (!path) {
ac1671c0 952 AliError("the program dateStream was not found");
06c7e392 953 if (fStopOnError) return kFALSE;
954 } else {
955 delete[] path;
956 }
0421c3d1 957
06c7e392 958 AliRunLoader* runLoader = LoadRun("READ");
959 if (!runLoader) return kFALSE;
960
ac1671c0 961 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
06c7e392 962 char command[256];
f28a8d2d 963 // Note the option -s. It is used in order to avoid
964 // the generation of SOR/EOR events.
965 sprintf(command, "dateStream -s -D -o %s -# %d -C",
06c7e392 966 dateFileName, runLoader->GetNumberOfEvents());
967 FILE* pipe = gSystem->OpenPipe(command, "w");
968
969 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
970 fprintf(pipe, "GDC\n");
971 Float_t ldc = 0;
972 Int_t prevLDC = -1;
973
974 // loop over detectors and DDLs
362c9d61 975 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
976 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
06c7e392 977
362c9d61 978 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
06c7e392 979 Int_t ldcID = Int_t(ldc + 0.0001);
362c9d61 980 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
06c7e392 981
982 char rawFileName[256];
362c9d61 983 sprintf(rawFileName, "raw%d/%s",
984 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
06c7e392 985
986 // check existence and size of raw data file
987 FILE* file = fopen(rawFileName, "rb");
988 if (!file) continue;
989 fseek(file, 0, SEEK_END);
990 unsigned long size = ftell(file);
aa04f81b 991 fclose(file);
992 if (!size) continue;
06c7e392 993
994 if (ldcID != prevLDC) {
995 fprintf(pipe, " LDC Id %d\n", ldcID);
996 prevLDC = ldcID;
997 }
998 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
999 }
1000 }
1001 }
1002
1003 Int_t result = gSystem->ClosePipe(pipe);
1004
1005 delete runLoader;
1006 return (result == 0);
1007}
1008
1009//_____________________________________________________________________________
1010Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1011 const char* rootFileName)
1012{
1013// convert a DATE file to a root file with the program "alimdc"
1014
1015 // ALIMDC setup
f28a8d2d 1016 const Int_t kDBSize = 2000000000;
c83eb8f4 1017 const Int_t kTagDBSize = 1000000000;
06c7e392 1018 const Bool_t kFilter = kFALSE;
f28a8d2d 1019 const Int_t kCompression = 0;
06c7e392 1020
1021 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1022 if (!path) {
ac1671c0 1023 AliError("the program alimdc was not found");
06c7e392 1024 if (fStopOnError) return kFALSE;
1025 } else {
1026 delete[] path;
1027 }
1028
ac1671c0 1029 AliInfo(Form("converting DATE file %s to root file %s",
1030 dateFileName, rootFileName));
06c7e392 1031
f732bd7d 1032 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1033 const char* tagDBFS = "/tmp/mdc1/tags";
f732bd7d 1034
1035 // User defined file system locations
1036 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1037 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1038 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1039 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1040 if (gSystem->Getenv("ALIMDC_TAGDB"))
1041 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
f732bd7d 1042
1043 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1044 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1045 gSystem->Exec(Form("rm -rf %s",tagDBFS));
f732bd7d 1046
1047 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1048 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1049 gSystem->Exec(Form("mkdir %s",tagDBFS));
f732bd7d 1050
1051 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1052 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1053 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1054
1055 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1056 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1057 gSystem->Exec(Form("rm -rf %s",tagDBFS));
06c7e392 1058
1059 return (result == 0);
0421c3d1 1060}
1061
85a5290f 1062
1063//_____________________________________________________________________________
06c7e392 1064AliRunLoader* AliSimulation::LoadRun(const char* mode) const
95601147 1065{
1066// delete existing run loaders, open a new one and load gAlice
1067
1068 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
1069 AliRunLoader* runLoader =
1070 AliRunLoader::Open(fGAliceFileName.Data(),
06c7e392 1071 AliConfig::GetDefaultEventFolderName(), mode);
95601147 1072 if (!runLoader) {
ac1671c0 1073 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
95601147 1074 return NULL;
1075 }
1076 runLoader->LoadgAlice();
1077 gAlice = runLoader->GetAliRun();
1078 if (!gAlice) {
ac1671c0 1079 AliError(Form("no gAlice object found in file %s",
1080 fGAliceFileName.Data()));
95601147 1081 return NULL;
1082 }
1083 return runLoader;
1084}
1085
1086//_____________________________________________________________________________
05526d44 1087Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1088{
1089// get or calculate the number of signal events per background event
1090
1091 if (!fBkgrdFileNames) return 1;
1092 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1093 if (nBkgrdFiles == 0) return 1;
1094
1095 // get the number of signal events
1096 if (nEvents <= 0) {
1097 AliRunLoader* runLoader =
ca30848f 1098 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
05526d44 1099 if (!runLoader) return 1;
ca30848f 1100
05526d44 1101 nEvents = runLoader->GetNumberOfEvents();
1102 delete runLoader;
1103 }
1104
1105 Int_t result = 0;
1106 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1107 // get the number of background events
1108 const char* fileName = ((TObjString*)
1109 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
ca30848f 1110 AliRunLoader* runLoader =
05526d44 1111 AliRunLoader::Open(fileName, "BKGRD");
1112 if (!runLoader) continue;
1113 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1114 delete runLoader;
ca30848f 1115
05526d44 1116 // get or calculate the number of signal per background events
1117 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1118 if (nSignalPerBkgrd <= 0) {
1119 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1120 } else if (result && (result != nSignalPerBkgrd)) {
ac1671c0 1121 AliInfo(Form("the number of signal events per background event "
1122 "will be changed from %d to %d for stream %d",
1123 nSignalPerBkgrd, result, iBkgrdFile+1));
05526d44 1124 nSignalPerBkgrd = result;
1125 }
1126
1127 if (!result) result = nSignalPerBkgrd;
1128 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
ac1671c0 1129 AliWarning(Form("not enough background events (%d) for %d signal events "
1130 "using %d signal per background events for stream %d",
1131 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
05526d44 1132 }
1133 }
1134
1135 return result;
1136}
1137
1138//_____________________________________________________________________________
85a5290f 1139Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1140{
1141// check whether detName is contained in detectors
1142// if yes, it is removed from detectors
1143
1144 // check if all detectors are selected
1145 if ((detectors.CompareTo("ALL") == 0) ||
1146 detectors.BeginsWith("ALL ") ||
1147 detectors.EndsWith(" ALL") ||
1148 detectors.Contains(" ALL ")) {
1149 detectors = "ALL";
1150 return kTRUE;
1151 }
1152
1153 // search for the given detector
1154 Bool_t result = kFALSE;
1155 if ((detectors.CompareTo(detName) == 0) ||
1156 detectors.BeginsWith(detName+" ") ||
1157 detectors.EndsWith(" "+detName) ||
1158 detectors.Contains(" "+detName+" ")) {
1159 detectors.ReplaceAll(detName, "");
1160 result = kTRUE;
1161 }
1162
1163 // clean up the detectors string
1164 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1165 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1166 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1167
1168 return result;
1169}
ca30848f 1170
1171Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName)
1172{
1173//
1174// Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1175// These can be used for embedding of MC tracks into RAW data using the standard
1176// merging procedure.
1177//
1178// If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1179//
1180 if (!gAlice) {
1181 AliError("no gAlice object. Restart aliroot and try again.");
1182 return kFALSE;
1183 }
1184 if (gAlice->Modules()->GetEntries() > 0) {
1185 AliError("gAlice was already run. Restart aliroot and try again.");
1186 return kFALSE;
1187 }
1188
1189 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1190 StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
1191//
1192// Initialize CDB
1193 InitCDBStorage();
1194 AliCDBManager* man = AliCDBManager::Instance();
1195 man->SetRun(0); // Should this come from rawdata header ?
1196
1197 Int_t iDet;
1198 //
1199 // Get the runloader
1200 AliRunLoader* runLoader = gAlice->GetRunLoader();
1201 //
1202 // Open esd file if available
1203 TFile* esdFile = TFile::Open(esdFileName);
1204 Bool_t esdOK = (esdFile != 0);
1205 AliESD* esd = new AliESD;
1206 TTree* treeESD = 0;
1207 if (esdOK) {
1208 treeESD = (TTree*) esdFile->Get("esdTree");
1209 if (!treeESD) {
1210 AliWarning("No ESD tree found");
1211 esdOK = kFALSE;
1212 } else {
1213 treeESD->SetBranchAddress("ESD", &esd);
1214 }
1215 }
1216 //
1217 // Create the RawReader
1218 AliRawReaderFile* rawReader = new AliRawReaderFile(rawDirectory);
1219 //
1220 // Get list of detectors
1221 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1222 //
1223 // Get Header
1224 AliHeader* header = runLoader->GetHeader();
1225 //
1226 // Event loop
1227 Int_t nev = 0;
1228 while(kTRUE) {
1229 if (!(rawReader->NextEvent())) break;
1230 //
1231 // Detector loop
1232 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1233 AliModule* det = (AliModule*) detArray->At(iDet);
1234 AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
1235 det->Raw2SDigits(rawReader);
1236 rawReader->Reset();
1237 } // detectors
1238
1239 //
1240 // If ESD information available obtain reconstructed vertex and store in header.
1241 if (esdOK) {
1242 treeESD->GetEvent(nev);
1243 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1244 Double_t position[3];
1245 esdVertex->GetXYZ(position);
1246 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
1247 TArrayF mcV;
1248 mcV.Set(3);
1249 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1250 mcHeader->SetPrimaryVertex(mcV);
1251 header->Reset(0,nev);
1252 header->SetGenEventHeader(mcHeader);
1253 printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
1254 }
1255 nev++;
1256//
1257// Finish the event
1258 runLoader->TreeE()->Fill();
1259 runLoader->SetNextEvent();
1260 } // events
1261
1262 delete rawReader;
1263//
1264// Finish the run
1265 runLoader->CdGAFile();
1266 runLoader->WriteHeader("OVERWRITE");
1267 runLoader->WriteRunLoader();
1268
1269 return kTRUE;
1270}