[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.                     //
//                                                                           //
// Backgound 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.      //
// The default value for this is 1. 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 "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),
  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),
  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 (!fRunSimulation) {
    if (!gAlice->Generator()) {
      Error("RunSimulation", "gAlice has no generator object. "
	    "Check your config file: %s", fConfigFileName.Data());
      return kFALSE;
    }
    gAlice->Generator()->SetTrackingFlag(0);
  }

  Info("RunSimulation", "running gAlice");
  if (nEvents <= 0) nEvents = fNEvents;
  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());
      det->Hits2SDigits();
    }
  }

  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;
  Int_t signalPerBkgrd = 1;
  if (fBkgrdFileNames) {
    nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
    if (nStreams > 1) signalPerBkgrd = fBkgrdFileNames->At(0)->GetUniqueID();
  }
  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;
}

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