[u/mrichter/AliRoot.git] / STEER / AliSimulation.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// class for running generation, simulation and digitization                 //
//                                                                           //
// Hits, sdigits and digits are created for all detectors by typing:         //
//                                                                           //
//   AliSimulation sim;                                                      //
//   sim.Run();                                                              //
//                                                                           //
// The Run method returns kTRUE in case of successful execution.             //
// The number of events can be given as argument to the Run method or it     //
// can be set by                                                             //
//                                                                           //
//   sim.SetNumberOfEvents(n);                                               //
//                                                                           //
// The name of the configuration file can be passed as argument to the       //
// AliSimulation constructor or can be specified by                          //
//                                                                           //
//   sim.SetConfigFile("...");                                               //
//                                                                           //
// The generation of particles and the simulation of detector hits can be    //
// switched on or off by                                                     //
//                                                                           //
//   sim.SetRunGeneration(kTRUE);   // generation of primary particles       //
//   sim.SetRunSimulation(kFALSE);  // but no tracking                       //
//                                                                           //
// For which detectors sdigits and digits will be created, can be steered    //
// by                                                                        //
//                                                                           //
//   sim.SetMakeSDigits("ALL");     // make sdigits for all detectors        //
//   sim.SetMakeDigits("ITS TPC");  // make digits only for ITS and TPC      //
//                                                                           //
// The argument is a (case sensitive) string with the names of the           //
// detectors separated by a space. An empty string ("") can be used to       //
// disable the creation of sdigits or digits. The special string "ALL"       //
// selects all available detectors. This is the default.                     //
//                                                                           //
// The creation of digits from hits instead of from sdigits can be selected  //
// by                                                                        //
//                                                                           //
//   sim.SetMakeDigitsFromHits("TRD");                                       //
//                                                                           //
// The argument is again a string with the selected detectors. Be aware that //
// this feature is not available for all detectors and that merging is not   //
// possible, when digits are created directly from hits.                     //
//                                                                           //
// Background events can be merged by calling                                //
//                                                                           //
//   sim.MergeWith("background/galice.root", 2);                             //
//                                                                           //
// The first argument is the file name of the background galice file. The    //
// second argument is the number of signal events per background event.      //
// By default this number is calculated from the number of available         //
// background events. MergeWith can be called several times to merge more    //
// than two event streams. It is assumed that the sdigits were already       //
// produced for the background events.                                       //
//                                                                           //
// The methods RunSimulation, RunSDigitization, RunDigitization and          //
// RunHitsDigitization can be used to run only parts of the full simulation  //
// chain.                                                                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


#include "AliSimulation.h"
#include "AliRunLoader.h"
#include "AliRun.h"
#include "AliModule.h"
#include "AliGenerator.h"
#include "AliVertexGenFile.h"
#include "AliRunDigitizer.h"
#include "AliDigitizer.h"
#include <TObjString.h>


ClassImp(AliSimulation)


//_____________________________________________________________________________
AliSimulation::AliSimulation(const char* configFileName,
			     const char* name, const char* title) :
  TNamed(name, title),

  fRunGeneration(kTRUE),
  fRunSimulation(kTRUE),
  fMakeSDigits("ALL"),
  fMakeDigits("ALL"),
  fMakeDigitsFromHits(""),
  fStopOnError(kFALSE),

  fNEvents(1),
  fConfigFileName(configFileName),
  fGAliceFileName("galice.root"),
  fBkgrdFileNames(NULL),
  fUseBkgrdVertex(kTRUE),
  fRegionOfInterest(kTRUE)
{
// create simulation object with default parameters

}

//_____________________________________________________________________________
AliSimulation::AliSimulation(const AliSimulation& sim) :
  TNamed(sim),

  fRunGeneration(sim.fRunGeneration),
  fRunSimulation(sim.fRunSimulation),
  fMakeSDigits(sim.fMakeSDigits),
  fMakeDigits(sim.fMakeDigits),
  fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
  fStopOnError(sim.fStopOnError),

  fNEvents(sim.fNEvents),
  fConfigFileName(sim.fConfigFileName),
  fGAliceFileName(sim.fGAliceFileName),
  fBkgrdFileNames(NULL),
  fUseBkgrdVertex(sim.fUseBkgrdVertex),
  fRegionOfInterest(sim.fRegionOfInterest)
{
// copy constructor

  fBkgrdFileNames = new TObjArray;
  for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
    if (!sim.fBkgrdFileNames->At(i)) continue;
    fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
  }
}

//_____________________________________________________________________________
AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
{
// assignment operator

  this->~AliSimulation();
  new(this) AliSimulation(sim);
  return *this;
}

//_____________________________________________________________________________
AliSimulation::~AliSimulation()
{
// clean up

  if (fBkgrdFileNames) {
    fBkgrdFileNames->Delete();
    delete fBkgrdFileNames;
  }
}


//_____________________________________________________________________________
void AliSimulation::SetNumberOfEvents(Int_t nEvents)
{
// set the number of events for one run

  fNEvents = nEvents;
}

//_____________________________________________________________________________
void AliSimulation::SetConfigFile(const char* fileName)
{
// set the name of the config file

  fConfigFileName = fileName;
}

//_____________________________________________________________________________
void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
{
// add a file with background events for merging

  TObjString* fileNameStr = new TObjString(fileName);
  fileNameStr->SetUniqueID(nSignalPerBkgrd);
  if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
  fBkgrdFileNames->Add(fileNameStr);
}


//_____________________________________________________________________________
Bool_t AliSimulation::Run(Int_t nEvents)
{
// run the generation, simulation and digitization

  if (nEvents > 0) fNEvents = nEvents;

  // generation and simulation -> hits
  if (fRunGeneration) {
    if (!RunSimulation()) if (fStopOnError) return kFALSE;
  }

  // hits -> summable digits
  if (!fMakeSDigits.IsNull()) {
    if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
  }

  // summable digits -> digits
  if (!fMakeDigits.IsNull()) {
    if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
      if (fStopOnError) return kFALSE;
    }
  }

  // hits -> digits
  if (!fMakeDigitsFromHits.IsNull()) {
    if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
      Warning("Run", "Merging and direct creation of digits from hits " 
	      "was selected for some detectors. "
	      "No merging will be done for the following detectors: %s",
	      fMakeDigitsFromHits.Data());
    }
    if (!RunHitsDigitization(fMakeDigitsFromHits)) {
      if (fStopOnError) return kFALSE;
    }
  }

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliSimulation::RunSimulation(Int_t nEvents)
{
// run the generation and simulation

  TStopwatch stopwatch;
  stopwatch.Start();

  if (!gAlice) {
    Error("RunSimulation", "no gAlice object. Restart aliroot and try again.");
    return kFALSE;
  }
  if (gAlice->Modules()->GetEntries() > 0) {
    Error("RunSimulation", 
	  "gAlice was already run. Restart aliroot and try again.");
    return kFALSE;
  }

  Info("RunSimulation", "initializing gAlice with config file %s",
       fConfigFileName.Data());
  gAlice->Init(fConfigFileName.Data());
  AliRunLoader* runLoader = gAlice->GetRunLoader();
  if (!runLoader) {
    Error("RunSimulation", "gAlice has no run loader object. "
	  "Check your config file: %s", fConfigFileName.Data());
    return kFALSE;
  }
  fGAliceFileName = runLoader->GetFileName();

  if (!gAlice->Generator()) {
    Error("RunSimulation", "gAlice has no generator object. "
	  "Check your config file: %s", fConfigFileName.Data());
    return kFALSE;
  }
  if (nEvents <= 0) nEvents = fNEvents;

  // get vertex from background file in case of merging
  if (fUseBkgrdVertex &&
      fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
    Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
    const char* fileName = ((TObjString*)
			    (fBkgrdFileNames->At(0)))->GetName();
    Info("RunSimulation", "The vertex will be taken from the background "
	 "file %s with nSignalPerBackground = %d", 
	 fileName, signalPerBkgrd);
    AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
    gAlice->Generator()->SetVertexGenerator(vtxGen);
  }

  if (!fRunSimulation) {
    gAlice->Generator()->SetTrackingFlag(0);
  }

  Info("RunSimulation", "running gAlice");
  gAlice->Run(nEvents);

  delete runLoader;

  Info("RunSimulation", "execution time:");
  stopwatch.Print();

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliSimulation::RunSDigitization(const char* detectors)
{
// run the digitization and produce summable digits

  TStopwatch stopwatch;
  stopwatch.Start();

  AliRunLoader* runLoader = LoadRun();
  if (!runLoader) return kFALSE;

  TString detStr = detectors;
  TObjArray* detArray = runLoader->GetAliRun()->Detectors();
  for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
    AliModule* det = (AliModule*) detArray->At(iDet);
    if (!det || !det->IsActive()) continue;
    if (IsSelected(det->GetName(), detStr)) {
      Info("RunSDigitization", "creating summable digits for %s", 
	   det->GetName());
      TStopwatch stopwatchDet;
      stopwatchDet.Start();
      det->Hits2SDigits();
      Info("RunSDigitization", "execution time for %s:", det->GetName());
      stopwatchDet.Print();
    }
  }

  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
    Error("RunSDigitization", "the following detectors were not found: %s", 
	  detStr.Data());
    if (fStopOnError) return kFALSE;
  }

  delete runLoader;

  Info("RunSDigitization", "execution time:");
  stopwatch.Print();

  return kTRUE;
}


//_____________________________________________________________________________
Bool_t AliSimulation::RunDigitization(const char* detectors, 
				      const char* excludeDetectors)
{
// run the digitization and produce digits from sdigits

  TStopwatch stopwatch;
  stopwatch.Start();

  while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
  if (gAlice) delete gAlice;
  gAlice = NULL;

  Int_t nStreams = 1;
  if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
  Int_t signalPerBkgrd = GetNSignalPerBkgrd();
  AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
  manager->SetInputStream(0, fGAliceFileName.Data());
  for (Int_t iStream = 1; iStream < nStreams; iStream++) {
    const char* fileName = ((TObjString*)
			    (fBkgrdFileNames->At(iStream-1)))->GetName();
    manager->SetInputStream(iStream, fileName);
  }

  TString detStr = detectors;
  TString detExcl = excludeDetectors;
  manager->GetInputStream(0)->ImportgAlice();
  AliRunLoader* runLoader = 
    AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
  TObjArray* detArray = runLoader->GetAliRun()->Detectors();
  for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
    AliModule* det = (AliModule*) detArray->At(iDet);
    if (!det || !det->IsActive()) continue;
    if (IsSelected(det->GetName(), detStr) && 
	!IsSelected(det->GetName(), detExcl)) {
      AliDigitizer* digitizer = det->CreateDigitizer(manager);
      if (!digitizer) {
	Error("RunDigitization", "no digitizer for %s", det->GetName());
	if (fStopOnError) return kFALSE;
      } else {
	digitizer->SetRegionOfInterest(fRegionOfInterest);
      }
    }
  }

  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
    Error("RunDigitization", "the following detectors were not found: %s", 
	  detStr.Data());
    if (fStopOnError) return kFALSE;
  }

  if (!manager->GetListOfTasks()->IsEmpty()) {
    Info("RunDigitization", "executing digitization");
    manager->Exec("");
  }

  delete manager;

  Info("RunDigitization", "execution time:");
  stopwatch.Print();

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
{
// run the digitization and produce digits from hits

  TStopwatch stopwatch;
  stopwatch.Start();

  AliRunLoader* runLoader = LoadRun();
  if (!runLoader) return kFALSE;

  TString detStr = detectors;
  TObjArray* detArray = runLoader->GetAliRun()->Detectors();
  for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
    AliModule* det = (AliModule*) detArray->At(iDet);
    if (!det || !det->IsActive()) continue;
    if (IsSelected(det->GetName(), detStr)) {
      Info("RunHitsDigitization", "creating digits from hits for %s", 
	   det->GetName());
      det->Hits2Digits();
    }
  }

  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
    Error("RunHitsDigitization", "the following detectors were not found: %s", 
	  detStr.Data());
    if (fStopOnError) return kFALSE;
  }

  delete runLoader;

  Info("RunHitsDigitization", "execution time:");
  stopwatch.Print();

  return kTRUE;
}


//_____________________________________________________________________________
AliRunLoader* AliSimulation::LoadRun() const
{
// delete existing run loaders, open a new one and load gAlice

  while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
  AliRunLoader* runLoader = 
    AliRunLoader::Open(fGAliceFileName.Data(), 
		       AliConfig::fgkDefaultEventFolderName, "UPDATE");
  if (!runLoader) {
    Error("LoadRun", "no run loader found in file %s", 
	  fGAliceFileName.Data());
    return NULL;
  }
  runLoader->LoadgAlice();
  gAlice = runLoader->GetAliRun();
  if (!gAlice) {
    Error("LoadRun", "no gAlice object found in file %s", 
	  fGAliceFileName.Data());
    return NULL;
  }
  return runLoader;
}

//_____________________________________________________________________________
Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
{
// get or calculate the number of signal events per background event

  if (!fBkgrdFileNames) return 1;
  Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
  if (nBkgrdFiles == 0) return 1;

  // get the number of signal events
  if (nEvents <= 0) {
    AliRunLoader* runLoader = 
      AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
    if (!runLoader) return 1;
    nEvents = runLoader->GetNumberOfEvents();
    delete runLoader;
  }

  Int_t result = 0;
  for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
    // get the number of background events
    const char* fileName = ((TObjString*)
			    (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
    AliRunLoader* runLoader = 
      AliRunLoader::Open(fileName, "BKGRD");
    if (!runLoader) continue;
    Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
    delete runLoader;

    // get or calculate the number of signal per background events
    Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
    if (nSignalPerBkgrd <= 0) {
      nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
    } else if (result && (result != nSignalPerBkgrd)) {
      Info("GetNSignalPerBkgrd", "the number of signal events per "
	   "background event will be changed from %d to %d for stream %d", 
	   nSignalPerBkgrd, result, iBkgrdFile+1);
      nSignalPerBkgrd = result;
    }

    if (!result) result = nSignalPerBkgrd;
    if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
      Warning("GetNSignalPerBkgrd", "not enough background events (%d) for "
	      "%d signal events using %d signal per background events for "
	      "stream %d", 
	      nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1);
    }
  }

  return result;
}

//_____________________________________________________________________________
Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
{
// check whether detName is contained in detectors
// if yes, it is removed from detectors

  // check if all detectors are selected
  if ((detectors.CompareTo("ALL") == 0) ||
      detectors.BeginsWith("ALL ") ||
      detectors.EndsWith(" ALL") ||
      detectors.Contains(" ALL ")) {
    detectors = "ALL";
    return kTRUE;
  }

  // search for the given detector
  Bool_t result = kFALSE;
  if ((detectors.CompareTo(detName) == 0) ||
      detectors.BeginsWith(detName+" ") ||
      detectors.EndsWith(" "+detName) ||
      detectors.Contains(" "+detName+" ")) {
    detectors.ReplaceAll(detName, "");
    result = kTRUE;
  }

  // clean up the detectors string
  while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
  while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
  while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);

  return result;
}
Commit	Line	Data
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 //
95601147	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	// //
95601147	75	// The methods RunSimulation, RunSDigitization, RunDigitization and //
	76	// RunHitsDigitization can be used to run only parts of the full simulation //
	77	// chain. //
	78	// //
85a5290f	79	///////////////////////////////////////////////////////////////////////////////
	80
	81
	82	#include "AliSimulation.h"
	83	#include "AliRunLoader.h"
	84	#include "AliRun.h"
	85	#include "AliModule.h"
	86	#include "AliGenerator.h"
04bae0a0	87	#include "AliVertexGenFile.h"
85a5290f	88	#include "AliRunDigitizer.h"
4df28b43	89	#include "AliDigitizer.h"
85a5290f	90	#include <TObjString.h>
	91
	92
	93	ClassImp(AliSimulation)
	94
	95
	96	//_____________________________________________________________________________
95601147	97	AliSimulation::AliSimulation(const char* configFileName,
	98	const char* name, const char* title) :
	99	TNamed(name, title),
	100
	101	fRunGeneration(kTRUE),
	102	fRunSimulation(kTRUE),
	103	fMakeSDigits("ALL"),
	104	fMakeDigits("ALL"),
	105	fMakeDigitsFromHits(""),
	106	fStopOnError(kFALSE),
	107
	108	fNEvents(1),
	109	fConfigFileName(configFileName),
	110	fGAliceFileName("galice.root"),
	111	fBkgrdFileNames(NULL),
04bae0a0	112	fUseBkgrdVertex(kTRUE),
95601147	113	fRegionOfInterest(kTRUE)
85a5290f	114	{
	115	// create simulation object with default parameters
	116
85a5290f	117	}
	118
	119	//_____________________________________________________________________________
	120	AliSimulation::AliSimulation(const AliSimulation& sim) :
95601147	121	TNamed(sim),
	122
	123	fRunGeneration(sim.fRunGeneration),
	124	fRunSimulation(sim.fRunSimulation),
	125	fMakeSDigits(sim.fMakeSDigits),
	126	fMakeDigits(sim.fMakeDigits),
	127	fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
	128	fStopOnError(sim.fStopOnError),
	129
	130	fNEvents(sim.fNEvents),
	131	fConfigFileName(sim.fConfigFileName),
	132	fGAliceFileName(sim.fGAliceFileName),
	133	fBkgrdFileNames(NULL),
04bae0a0	134	fUseBkgrdVertex(sim.fUseBkgrdVertex),
95601147	135	fRegionOfInterest(sim.fRegionOfInterest)
85a5290f	136	{
	137	// copy constructor
	138
85a5290f	139	fBkgrdFileNames = new TObjArray;
	140	for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
	141	if (!sim.fBkgrdFileNames->At(i)) continue;
	142	fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
	143	}
85a5290f	144	}
	145
	146	//_____________________________________________________________________________
	147	AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
	148	{
	149	// assignment operator
	150
	151	this->~AliSimulation();
	152	new(this) AliSimulation(sim);
	153	return *this;
	154	}
	155
	156	//_____________________________________________________________________________
	157	AliSimulation::~AliSimulation()
	158	{
	159	// clean up
	160
95601147	161	if (fBkgrdFileNames) {
	162	fBkgrdFileNames->Delete();
	163	delete fBkgrdFileNames;
	164	}
85a5290f	165	}
	166
	167
	168	//_____________________________________________________________________________
	169	void AliSimulation::SetNumberOfEvents(Int_t nEvents)
	170	{
	171	// set the number of events for one run
	172
	173	fNEvents = nEvents;
	174	}
	175
	176	//_____________________________________________________________________________
	177	void AliSimulation::SetConfigFile(const char* fileName)
	178	{
	179	// set the name of the config file
	180
	181	fConfigFileName = fileName;
	182	}
	183
	184	//_____________________________________________________________________________
	185	void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
	186	{
	187	// add a file with background events for merging
	188
	189	TObjString* fileNameStr = new TObjString(fileName);
	190	fileNameStr->SetUniqueID(nSignalPerBkgrd);
95601147	191	if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
85a5290f	192	fBkgrdFileNames->Add(fileNameStr);
	193	}
	194
	195
	196	//_____________________________________________________________________________
	197	Bool_t AliSimulation::Run(Int_t nEvents)
	198	{
	199	// run the generation, simulation and digitization
	200
	201	if (nEvents > 0) fNEvents = nEvents;
	202
	203	// generation and simulation -> hits
	204	if (fRunGeneration) {
85a5290f	205	if (!RunSimulation()) if (fStopOnError) return kFALSE;
	206	}
	207
85a5290f	208	// hits -> summable digits
	209	if (!fMakeSDigits.IsNull()) {
	210	if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
	211	}
	212
	213	// summable digits -> digits
	214	if (!fMakeDigits.IsNull()) {
	215	if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
	216	if (fStopOnError) return kFALSE;
	217	}
	218	}
	219
	220	// hits -> digits
	221	if (!fMakeDigitsFromHits.IsNull()) {
95601147	222	if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
85a5290f	223	Warning("Run", "Merging and direct creation of digits from hits "
	224	"was selected for some detectors. "
	225	"No merging will be done for the following detectors: %s",
	226	fMakeDigitsFromHits.Data());
	227	}
	228	if (!RunHitsDigitization(fMakeDigitsFromHits)) {
	229	if (fStopOnError) return kFALSE;
	230	}
	231	}
	232
	233	return kTRUE;
	234	}
	235
	236	//_____________________________________________________________________________
95601147	237	Bool_t AliSimulation::RunSimulation(Int_t nEvents)
85a5290f	238	{
	239	// run the generation and simulation
	240
4df28b43	241	TStopwatch stopwatch;
	242	stopwatch.Start();
	243
95601147	244	if (!gAlice) {
	245	Error("RunSimulation", "no gAlice object. Restart aliroot and try again.");
	246	return kFALSE;
	247	}
	248	if (gAlice->Modules()->GetEntries() > 0) {
	249	Error("RunSimulation",
	250	"gAlice was already run. Restart aliroot and try again.");
	251	return kFALSE;
	252	}
	253
85a5290f	254	Info("RunSimulation", "initializing gAlice with config file %s",
	255	fConfigFileName.Data());
	256	gAlice->Init(fConfigFileName.Data());
95601147	257	AliRunLoader* runLoader = gAlice->GetRunLoader();
95601147	258	if (!runLoader) {
85a5290f	259	Error("RunSimulation", "gAlice has no run loader object. "
	260	"Check your config file: %s", fConfigFileName.Data());
	261	return kFALSE;
	262	}
95601147	263	fGAliceFileName = runLoader->GetFileName();
85a5290f	264
04bae0a0	265	if (!gAlice->Generator()) {
	266	Error("RunSimulation", "gAlice has no generator object. "
	267	"Check your config file: %s", fConfigFileName.Data());
	268	return kFALSE;
	269	}
05526d44	270	if (nEvents <= 0) nEvents = fNEvents;
04bae0a0	271
	272	// get vertex from background file in case of merging
	273	if (fUseBkgrdVertex &&
	274	fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
05526d44	275	Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
04bae0a0	276	const char* fileName = ((TObjString*)
	277	(fBkgrdFileNames->At(0)))->GetName();
	278	Info("RunSimulation", "The vertex will be taken from the background "
	279	"file %s with nSignalPerBackground = %d",
	280	fileName, signalPerBkgrd);
	281	AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
	282	gAlice->Generator()->SetVertexGenerator(vtxGen);
	283	}
	284
85a5290f	285	if (!fRunSimulation) {
85a5290f	286	gAlice->Generator()->SetTrackingFlag(0);
	287	}
	288
4df28b43	289	Info("RunSimulation", "running gAlice");
95601147	290	gAlice->Run(nEvents);
	291
	292	delete runLoader;
85a5290f	293
4df28b43	294	Info("RunSimulation", "execution time:");
	295	stopwatch.Print();
	296
85a5290f	297	return kTRUE;
	298	}
	299
	300	//_____________________________________________________________________________
95601147	301	Bool_t AliSimulation::RunSDigitization(const char* detectors)
85a5290f	302	{
	303	// run the digitization and produce summable digits
	304
4df28b43	305	TStopwatch stopwatch;
	306	stopwatch.Start();
	307
95601147	308	AliRunLoader* runLoader = LoadRun();
	309	if (!runLoader) return kFALSE;
	310
85a5290f	311	TString detStr = detectors;
95601147	312	TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f	313	for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
	314	AliModule* det = (AliModule*) detArray->At(iDet);
	315	if (!det \|\| !det->IsActive()) continue;
	316	if (IsSelected(det->GetName(), detStr)) {
	317	Info("RunSDigitization", "creating summable digits for %s",
	318	det->GetName());
de76655b	319	TStopwatch stopwatchDet;
de76655b	320	stopwatchDet.Start();
85a5290f	321	det->Hits2SDigits();
de76655b	322	Info("RunSDigitization", "execution time for %s:", det->GetName());
de76655b	323	stopwatchDet.Print();
85a5290f	324	}
	325	}
	326
	327	if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
	328	Error("RunSDigitization", "the following detectors were not found: %s",
	329	detStr.Data());
	330	if (fStopOnError) return kFALSE;
	331	}
	332
95601147	333	delete runLoader;
95601147	334
4df28b43	335	Info("RunSDigitization", "execution time:");
	336	stopwatch.Print();
	337
85a5290f	338	return kTRUE;
	339	}
	340
	341
	342	//_____________________________________________________________________________
95601147	343	Bool_t AliSimulation::RunDigitization(const char* detectors,
95601147	344	const char* excludeDetectors)
85a5290f	345	{
	346	// run the digitization and produce digits from sdigits
	347
4df28b43	348	TStopwatch stopwatch;
	349	stopwatch.Start();
	350
95601147	351	while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
	352	if (gAlice) delete gAlice;
	353	gAlice = NULL;
	354
	355	Int_t nStreams = 1;
05526d44	356	if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
05526d44	357	Int_t signalPerBkgrd = GetNSignalPerBkgrd();
85a5290f	358	AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
	359	manager->SetInputStream(0, fGAliceFileName.Data());
	360	for (Int_t iStream = 1; iStream < nStreams; iStream++) {
	361	const char* fileName = ((TObjString*)
	362	(fBkgrdFileNames->At(iStream-1)))->GetName();
	363	manager->SetInputStream(iStream, fileName);
	364	}
	365
	366	TString detStr = detectors;
	367	TString detExcl = excludeDetectors;
95601147	368	manager->GetInputStream(0)->ImportgAlice();
	369	AliRunLoader* runLoader =
	370	AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
	371	TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f	372	for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
	373	AliModule* det = (AliModule*) detArray->At(iDet);
	374	if (!det \|\| !det->IsActive()) continue;
	375	if (IsSelected(det->GetName(), detStr) &&
	376	!IsSelected(det->GetName(), detExcl)) {
4df28b43	377	AliDigitizer* digitizer = det->CreateDigitizer(manager);
4df28b43	378	if (!digitizer) {
85a5290f	379	Error("RunDigitization", "no digitizer for %s", det->GetName());
85a5290f	380	if (fStopOnError) return kFALSE;
4df28b43	381	} else {
4df28b43	382	digitizer->SetRegionOfInterest(fRegionOfInterest);
85a5290f	383	}
	384	}
	385	}
	386
	387	if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
	388	Error("RunDigitization", "the following detectors were not found: %s",
	389	detStr.Data());
	390	if (fStopOnError) return kFALSE;
	391	}
	392
	393	if (!manager->GetListOfTasks()->IsEmpty()) {
	394	Info("RunDigitization", "executing digitization");
	395	manager->Exec("");
	396	}
95601147	397
85a5290f	398	delete manager;
85a5290f	399
4df28b43	400	Info("RunDigitization", "execution time:");
	401	stopwatch.Print();
	402
85a5290f	403	return kTRUE;
	404	}
	405
	406	//_____________________________________________________________________________
95601147	407	Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
85a5290f	408	{
	409	// run the digitization and produce digits from hits
	410
4df28b43	411	TStopwatch stopwatch;
	412	stopwatch.Start();
	413
95601147	414	AliRunLoader* runLoader = LoadRun();
	415	if (!runLoader) return kFALSE;
	416
85a5290f	417	TString detStr = detectors;
95601147	418	TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f	419	for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
	420	AliModule* det = (AliModule*) detArray->At(iDet);
	421	if (!det \|\| !det->IsActive()) continue;
	422	if (IsSelected(det->GetName(), detStr)) {
	423	Info("RunHitsDigitization", "creating digits from hits for %s",
	424	det->GetName());
	425	det->Hits2Digits();
	426	}
	427	}
	428
	429	if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
	430	Error("RunHitsDigitization", "the following detectors were not found: %s",
	431	detStr.Data());
	432	if (fStopOnError) return kFALSE;
	433	}
	434
95601147	435	delete runLoader;
95601147	436
4df28b43	437	Info("RunHitsDigitization", "execution time:");
	438	stopwatch.Print();
	439
85a5290f	440	return kTRUE;
	441	}
	442
	443
95601147	444	//_____________________________________________________________________________
	445	AliRunLoader* AliSimulation::LoadRun() const
	446	{
	447	// delete existing run loaders, open a new one and load gAlice
	448
	449	while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
	450	AliRunLoader* runLoader =
	451	AliRunLoader::Open(fGAliceFileName.Data(),
	452	AliConfig::fgkDefaultEventFolderName, "UPDATE");
	453	if (!runLoader) {
	454	Error("LoadRun", "no run loader found in file %s",
	455	fGAliceFileName.Data());
	456	return NULL;
	457	}
	458	runLoader->LoadgAlice();
	459	gAlice = runLoader->GetAliRun();
	460	if (!gAlice) {
	461	Error("LoadRun", "no gAlice object found in file %s",
	462	fGAliceFileName.Data());
	463	return NULL;
	464	}
	465	return runLoader;
	466	}
	467
85a5290f	468	//_____________________________________________________________________________
05526d44	469	Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
	470	{
	471	// get or calculate the number of signal events per background event
	472
	473	if (!fBkgrdFileNames) return 1;
	474	Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
	475	if (nBkgrdFiles == 0) return 1;
	476
	477	// get the number of signal events
	478	if (nEvents <= 0) {
	479	AliRunLoader* runLoader =
	480	AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
	481	if (!runLoader) return 1;
	482	nEvents = runLoader->GetNumberOfEvents();
	483	delete runLoader;
	484	}
	485
	486	Int_t result = 0;
	487	for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
	488	// get the number of background events
	489	const char* fileName = ((TObjString*)
	490	(fBkgrdFileNames->At(iBkgrdFile)))->GetName();
	491	AliRunLoader* runLoader =
	492	AliRunLoader::Open(fileName, "BKGRD");
	493	if (!runLoader) continue;
	494	Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
	495	delete runLoader;
	496
	497	// get or calculate the number of signal per background events
	498	Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
	499	if (nSignalPerBkgrd <= 0) {
	500	nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
	501	} else if (result && (result != nSignalPerBkgrd)) {
	502	Info("GetNSignalPerBkgrd", "the number of signal events per "
	503	"background event will be changed from %d to %d for stream %d",
	504	nSignalPerBkgrd, result, iBkgrdFile+1);
	505	nSignalPerBkgrd = result;
	506	}
	507
	508	if (!result) result = nSignalPerBkgrd;
	509	if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
	510	Warning("GetNSignalPerBkgrd", "not enough background events (%d) for "
	511	"%d signal events using %d signal per background events for "
	512	"stream %d",
	513	nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1);
	514	}
	515	}
	516
	517	return result;
	518	}
	519
	520	//_____________________________________________________________________________
85a5290f	521	Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
	522	{
	523	// check whether detName is contained in detectors
	524	// if yes, it is removed from detectors
	525
	526	// check if all detectors are selected
	527	if ((detectors.CompareTo("ALL") == 0) \|\|
	528	detectors.BeginsWith("ALL ") \|\|
	529	detectors.EndsWith(" ALL") \|\|
	530	detectors.Contains(" ALL ")) {
	531	detectors = "ALL";
	532	return kTRUE;
	533	}
	534
	535	// search for the given detector
	536	Bool_t result = kFALSE;
	537	if ((detectors.CompareTo(detName) == 0) \|\|
	538	detectors.BeginsWith(detName+" ") \|\|
	539	detectors.EndsWith(" "+detName) \|\|
	540	detectors.Contains(" "+detName+" ")) {
	541	detectors.ReplaceAll(detName, "");
	542	result = kTRUE;
	543	}
	544
	545	// clean up the detectors string
	546	while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
	547	while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
	548	while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
	549
	550	return result;
	551	}