[u/mrichter/AliRoot.git] / STEER / AliReconstruction.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 the reconstruction                                      //
//                                                                           //
// Clusters and tracks are created for all detectors and all events by       //
// typing:                                                                   //
//                                                                           //
//   AliReconstruction rec;                                                  //
//   rec.Run();                                                              //
//                                                                           //
// The Run method returns kTRUE in case of successful execution.             //
// The name of the galice file can be changed from the default               //
// "galice.root" by passing it as argument to the AliReconstruction          //
// constructor or by                                                         //
//                                                                           //
//   rec.SetGAliceFile("...");                                               //
//                                                                           //
// The reconstruction can be switched on or off for individual detectors by  //
//                                                                           //
//   rec.SetRunReconstruction("...");                                        //
//                                                                           //
// The argument is a (case sensitive) string with the names of the           //
// detectors separated by a space. The special string "ALL" selects all      //
// available detectors. This is the default.                                 //
//                                                                           //
// The tracking in ITS, TPC and TRD and the creation of ESD tracks can be    //
// switched off by                                                           //
//                                                                           //
//   rec.SetRunTracking(kFALSE);                                             //
//                                                                           //
// The filling of additional ESD information can be steered by               //
//                                                                           //
//   rec.SetFillESD("...");                                                  //
//                                                                           //
// Again, the string specifies the list of detectors. The default is "ALL".  //
//                                                                           //
// The reconstruction requires digits as input. For the creation of digits   //
// have a look at the class AliSimulation.                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


#include "AliReconstruction.h"
#include "AliRunLoader.h"
#include "AliRun.h"
#include "AliModule.h"
#include "AliDetector.h"
#include "AliTracker.h"
#include "AliESD.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"
#include "AliESDpid.h"
#include "AliMagF.h"
#include <TArrayF.h>


ClassImp(AliReconstruction)


//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const char* gAliceFilename,
				     const char* name, const char* title) :
  TNamed(name, title),

  fRunReconstruction("ALL"),
  fRunTracking(kTRUE),
  fFillESD("ALL"),
  fGAliceFileName(gAliceFilename),
  fStopOnError(kFALSE),

  fRunLoader(NULL),
  fITSLoader(NULL),
  fITSTracker(NULL),
  fTPCLoader(NULL),
  fTPCTracker(NULL),
  fTRDLoader(NULL),
  fTRDTracker(NULL),
  fTOFLoader(NULL),
  fTOFTracker(NULL)
{
// create reconstruction object with default parameters

}

//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
  TNamed(rec),

  fRunReconstruction(rec.fRunReconstruction),
  fRunTracking(rec.fRunTracking),
  fFillESD(rec.fFillESD),
  fGAliceFileName(rec.fGAliceFileName),
  fStopOnError(rec.fStopOnError),

  fRunLoader(NULL),
  fITSLoader(NULL),
  fITSTracker(NULL),
  fTPCLoader(NULL),
  fTPCTracker(NULL),
  fTRDLoader(NULL),
  fTRDTracker(NULL),
  fTOFLoader(NULL),
  fTOFTracker(NULL)
{
// copy constructor

}

//_____________________________________________________________________________
AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
{
// assignment operator

  this->~AliReconstruction();
  new(this) AliReconstruction(rec);
  return *this;
}

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

  CleanUp();
}


//_____________________________________________________________________________
void AliReconstruction::SetGAliceFile(const char* fileName)
{
// set the name of the galice file

  fGAliceFileName = fileName;
}


//_____________________________________________________________________________
Bool_t AliReconstruction::Run()
{
// run the reconstruction

  // open the run loader
  fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
  if (!fRunLoader) {
    Error("Run", "no run loader found in file %s", 
	  fGAliceFileName.Data());
    CleanUp();
    return kFALSE;
  }
  fRunLoader->LoadgAlice();
  AliRun* aliRun = fRunLoader->GetAliRun();
  if (!aliRun) {
    Error("Run", "no gAlice object found in file %s", 
	  fGAliceFileName.Data());
    CleanUp();
    return kFALSE;
  }
  gAlice = aliRun;

  // local reconstruction
  if (!fRunReconstruction.IsNull()) {
    if (!RunReconstruction(fRunReconstruction)) {
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
  }
  if (!fRunTracking && fFillESD.IsNull()) return kTRUE;

  if (fRunTracking) {
    // get loaders and trackers
    fITSLoader = fRunLoader->GetLoader("ITSLoader");
    if (!fITSLoader) {
      Error("Run", "no ITS loader found");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
    fITSTracker = NULL;
    if (aliRun->GetDetector("ITS")) {
      fITSTracker = aliRun->GetDetector("ITS")->CreateTracker();
    }
    if (!fITSTracker) {
      Error("Run", "couldn't create a tracker for ITS");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
    
    fTPCLoader = fRunLoader->GetLoader("TPCLoader");
    if (!fTPCLoader) {
      Error("Run", "no TPC loader found");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
    fTPCTracker = NULL;
    if (aliRun->GetDetector("TPC")) {
      fTPCTracker = aliRun->GetDetector("TPC")->CreateTracker();
    }
    if (!fTPCTracker) {
      Error("Run", "couldn't create a tracker for TPC");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
    
    fTRDLoader = fRunLoader->GetLoader("TRDLoader");
    if (!fTRDLoader) {
      Error("Run", "no TRD loader found");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
    fTRDTracker = NULL;
    if (aliRun->GetDetector("TRD")) {
      fTRDTracker = aliRun->GetDetector("TRD")->CreateTracker();
    }
    if (!fTRDTracker) {
      Error("Run", "couldn't create a tracker for TRD");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
    
    fTOFLoader = fRunLoader->GetLoader("TOFLoader");
    if (!fTOFLoader) {
      Error("Run", "no TOF loader found");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
    fTOFTracker = NULL;
    if (aliRun->GetDetector("TOF")) {
      fTOFTracker = aliRun->GetDetector("TOF")->CreateTracker();
    }
    if (!fTOFTracker) {
      Error("Run", "couldn't create a tracker for TOF");
      if (fStopOnError) {CleanUp(); return kFALSE;}
    }
  }
  // create the ESD output file
  TFile* file = TFile::Open("AliESDs.root", "RECREATE");
  if (!file->IsOpen()) {
    Error("Run", "opening AliESDs.root failed");
    if (fStopOnError) {CleanUp(file); return kFALSE;}    
  }

  // loop over events
  for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
    Info("Run", "processing event %d", iEvent);
    AliESD* esd = new AliESD;
    fRunLoader->GetEvent(iEvent);
    esd->SetRunNumber(aliRun->GetRunNumber());
    esd->SetEventNumber(aliRun->GetEvNumber());
    esd->SetMagneticField(aliRun->Field()->SolenoidField());

    // barrel tracking
    if (fRunTracking) {
      if (!RunTracking(esd)) {
	if (fStopOnError) {CleanUp(file); return kFALSE;}
      }
    }

    // fill ESD
    if (!fFillESD.IsNull()) {
      if (!FillESD(esd, fFillESD)) {
	if (fStopOnError) {CleanUp(file); return kFALSE;}
      }
    }

    // combined PID
    AliESDpid::MakePID(esd);

    // write ESD
    char name[100]; 
    sprintf(name, "ESD%d", iEvent);
    file->cd();
    if (!esd->Write(name)) {
      Error("Run", "writing ESD failed");
      if (fStopOnError) {CleanUp(file); return kFALSE;}
    }
    delete esd;
  }

  CleanUp(file);

  return kTRUE;
}


//_____________________________________________________________________________
Bool_t AliReconstruction::RunReconstruction(const TString& detectors)
{
// run the reconstruction

  TStopwatch stopwatch;
  stopwatch.Start();

  TString detStr = detectors;
  TObjArray* detArray = fRunLoader->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("RunReconstruction", "running reconstruction for %s", 
	   det->GetName());
      TStopwatch stopwatchDet;
      stopwatchDet.Start();
      det->Reconstruct();
      Info("RunReconstruction", "execution time for %s:", det->GetName());
      stopwatchDet.Print();
    }
  }

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

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

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliReconstruction::RunTracking(AliESD* esd)
{
// run the barrel tracking

  TStopwatch stopwatch;
  stopwatch.Start();

  // get the primary vertex (from MC for the moment)
  TArrayF vertex(3);     
  fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vertex);
  Double_t vtxPos[3] = {vertex[0], vertex[1], vertex[2]};
  Double_t vtxCov[6] = {
    0.005,
    0.000, 0.005,
    0.000, 0.000, 0.010
  };
  Double_t vtxErr[3] = {vtxCov[0], vtxCov[2], vtxCov[5]}; // diag. elements
  esd->SetVertex(vtxPos, vtxCov);
  fITSTracker->SetVertex(vtxPos, vtxErr);
  fTPCTracker->SetVertex(vtxPos, vtxErr);
  fTRDTracker->SetVertex(vtxPos, vtxErr);

  // TPC tracking
  Info("RunTracking", "TPC tracking");
  fTPCLoader->LoadRecPoints("read");
  TTree* tpcTree = fTPCLoader->TreeR();
  if (!tpcTree) {
    Error("RunTracking", "Can't get the TPC cluster tree");
    return kFALSE;
  }     
  fTPCTracker->LoadClusters(tpcTree);
  if (fTPCTracker->Clusters2Tracks(esd) != 0) {
    Error("RunTracking", "TPC Clusters2Tracks failed");
    return kFALSE;
  }

  fRunLoader->GetAliRun()->GetDetector("TPC")->FillESD(esd); // preliminary PID
  AliESDpid::MakePID(esd);                  // for the ITS tracker

  // ITS tracking
  Info("RunTracking", "ITS tracking");
  fITSLoader->LoadRecPoints("read");
  TTree* itsTree = fITSLoader->TreeR();
  if (!itsTree) {
    Error("RunTracking", "Can't get the ITS cluster tree");
    return kFALSE;
  }     
  fITSTracker->LoadClusters(itsTree);
  if (fITSTracker->Clusters2Tracks(esd) != 0) {
    Error("RunTracking", "ITS Clusters2Tracks failed");
    return kFALSE;
  }

  // ITS back propagation
  Info("RunTracking", "ITS back propagation");
  if (fITSTracker->PropagateBack(esd) != 0) {
    Error("RunTracking", "ITS backward propagation failed");
    return kFALSE;
  }

  // TPC back propagation
  Info("RunTracking", "TPC back propagation");
  if (fTPCTracker->PropagateBack(esd) != 0) {
    Error("RunTracking", "TPC backward propagation failed");
    return kFALSE;
  }

  // TRD back propagation
  Info("RunTracking", "TRD back propagation");
  fTRDLoader->LoadRecPoints("read");
  TTree* trdTree = fTRDLoader->TreeR();
  if (!trdTree) {
    Error("RunTracking", "Can't get the TRD cluster tree");
    return kFALSE;
  }     
  fTRDTracker->LoadClusters(trdTree);
  if (fTRDTracker->PropagateBack(esd) != 0) {
    Error("RunTracking", "TRD backward propagation failed");
    return kFALSE;
  }

  // TOF back propagation
  Info("RunTracking", "TOF back propagation");
  fTOFLoader->LoadDigits("read");
  TTree* tofTree = fTOFLoader->TreeD();
  if (!tofTree) {
    Error("RunTracking", "Can't get the TOF digits tree");
    return kFALSE;
  }     
  fTOFTracker->LoadClusters(tofTree);
  if (fTOFTracker->PropagateBack(esd) != 0) {
    Error("RunTracking", "TOF backward propagation failed");
    return kFALSE;
  }
  fTOFTracker->UnloadClusters();
  fTOFLoader->UnloadDigits();

  // TRD inward refit
  Info("RunTracking", "TRD inward refit");
  if (fTRDTracker->RefitInward(esd) != 0) {
    Error("RunTracking", "TRD inward refit failed");
    return kFALSE;
  }
  fTRDTracker->UnloadClusters();
  fTRDLoader->UnloadRecPoints();
    
  // TPC inward refit
  Info("RunTracking", "TPC inward refit");
  if (fTPCTracker->RefitInward(esd) != 0) {
    Error("RunTracking", "TPC inward refit failed");
    return kFALSE;
  }
  fTPCTracker->UnloadClusters();
  fTPCLoader->UnloadRecPoints();
    
  // ITS inward refit
  Info("RunTracking", "ITS inward refit");
  if (fITSTracker->RefitInward(esd) != 0) {
    Error("RunTracking", "ITS inward refit failed");
    return kFALSE;
  }
  fITSTracker->UnloadClusters();
  fITSLoader->UnloadRecPoints();

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

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliReconstruction::FillESD(AliESD* esd, const TString& detectors)
{
// fill the event summary data

  TStopwatch stopwatch;
  stopwatch.Start();

  TString detStr = detectors;
  TObjArray* detArray = fRunLoader->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("FillESD", "filling ESD for %s", 
	   det->GetName());
      det->FillESD(esd);
    }
  }

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

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

  return kTRUE;
}


//_____________________________________________________________________________
Bool_t AliReconstruction::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;
}

//_____________________________________________________________________________
void AliReconstruction::CleanUp(TFile* file)
{
// delete trackers and the run loader and close and delete the file

  delete fITSTracker;
  fITSTracker = NULL;
  delete fTPCTracker;
  fTPCTracker = NULL;
  delete fTRDTracker;
  fTRDTracker = NULL;
  delete fTOFTracker;
  fTOFTracker = NULL;

  delete fRunLoader;
  fRunLoader = NULL;

  if (file) {
    file->Close();
    delete file;
  }
}
Commit	Line	Data
596a855f	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 the reconstruction //
	21	// //
	22	// Clusters and tracks are created for all detectors and all events by //
	23	// typing: //
	24	// //
	25	// AliReconstruction rec; //
	26	// rec.Run(); //
	27	// //
	28	// The Run method returns kTRUE in case of successful execution. //
	29	// The name of the galice file can be changed from the default //
e583c30d	30	// "galice.root" by passing it as argument to the AliReconstruction //
e583c30d	31	// constructor or by //
596a855f	32	// //
	33	// rec.SetGAliceFile("..."); //
	34	// //
	35	// The reconstruction can be switched on or off for individual detectors by //
	36	// //
	37	// rec.SetRunReconstruction("..."); //
	38	// //
	39	// The argument is a (case sensitive) string with the names of the //
	40	// detectors separated by a space. The special string "ALL" selects all //
	41	// available detectors. This is the default. //
	42	// //
	43	// The tracking in ITS, TPC and TRD and the creation of ESD tracks can be //
	44	// switched off by //
	45	// //
	46	// rec.SetRunTracking(kFALSE); //
	47	// //
	48	// The filling of additional ESD information can be steered by //
	49	// //
	50	// rec.SetFillESD("..."); //
	51	// //
	52	// Again, the string specifies the list of detectors. The default is "ALL". //
	53	// //
	54	// The reconstruction requires digits as input. For the creation of digits //
	55	// have a look at the class AliSimulation. //
	56	// //
	57	///////////////////////////////////////////////////////////////////////////////
	58
	59
	60	#include "AliReconstruction.h"
	61	#include "AliRunLoader.h"
	62	#include "AliRun.h"
	63	#include "AliModule.h"
	64	#include "AliDetector.h"
	65	#include "AliTracker.h"
	66	#include "AliESD.h"
	67	#include "AliHeader.h"
	68	#include "AliGenEventHeader.h"
	69	#include "AliESDpid.h"
a866ac60	70	#include "AliMagF.h"
596a855f	71	#include <TArrayF.h>
	72
	73
	74	ClassImp(AliReconstruction)
	75
	76
	77	//_____________________________________________________________________________
e583c30d	78	AliReconstruction::AliReconstruction(const char* gAliceFilename,
	79	const char* name, const char* title) :
	80	TNamed(name, title),
	81
	82	fRunReconstruction("ALL"),
	83	fRunTracking(kTRUE),
	84	fFillESD("ALL"),
	85	fGAliceFileName(gAliceFilename),
	86	fStopOnError(kFALSE),
	87
	88	fRunLoader(NULL),
	89	fITSLoader(NULL),
	90	fITSTracker(NULL),
	91	fTPCLoader(NULL),
	92	fTPCTracker(NULL),
	93	fTRDLoader(NULL),
	94	fTRDTracker(NULL),
	95	fTOFLoader(NULL),
	96	fTOFTracker(NULL)
596a855f	97	{
	98	// create reconstruction object with default parameters
	99
596a855f	100	}
	101
	102	//_____________________________________________________________________________
	103	AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
e583c30d	104	TNamed(rec),
	105
	106	fRunReconstruction(rec.fRunReconstruction),
	107	fRunTracking(rec.fRunTracking),
	108	fFillESD(rec.fFillESD),
	109	fGAliceFileName(rec.fGAliceFileName),
	110	fStopOnError(rec.fStopOnError),
	111
	112	fRunLoader(NULL),
	113	fITSLoader(NULL),
	114	fITSTracker(NULL),
	115	fTPCLoader(NULL),
	116	fTPCTracker(NULL),
	117	fTRDLoader(NULL),
	118	fTRDTracker(NULL),
	119	fTOFLoader(NULL),
	120	fTOFTracker(NULL)
596a855f	121	{
	122	// copy constructor
	123
596a855f	124	}
	125
	126	//_____________________________________________________________________________
	127	AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
	128	{
	129	// assignment operator
	130
	131	this->~AliReconstruction();
	132	new(this) AliReconstruction(rec);
	133	return *this;
	134	}
	135
	136	//_____________________________________________________________________________
	137	AliReconstruction::~AliReconstruction()
	138	{
	139	// clean up
	140
e583c30d	141	CleanUp();
596a855f	142	}
	143
	144
	145	//_____________________________________________________________________________
	146	void AliReconstruction::SetGAliceFile(const char* fileName)
	147	{
	148	// set the name of the galice file
	149
	150	fGAliceFileName = fileName;
	151	}
	152
	153
	154	//_____________________________________________________________________________
	155	Bool_t AliReconstruction::Run()
	156	{
	157	// run the reconstruction
	158
	159	// open the run loader
596a855f	160	fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
	161	if (!fRunLoader) {
	162	Error("Run", "no run loader found in file %s",
	163	fGAliceFileName.Data());
e583c30d	164	CleanUp();
596a855f	165	return kFALSE;
	166	}
	167	fRunLoader->LoadgAlice();
e583c30d	168	AliRun* aliRun = fRunLoader->GetAliRun();
e583c30d	169	if (!aliRun) {
596a855f	170	Error("Run", "no gAlice object found in file %s",
596a855f	171	fGAliceFileName.Data());
e583c30d	172	CleanUp();
596a855f	173	return kFALSE;
596a855f	174	}
e583c30d	175	gAlice = aliRun;
596a855f	176
	177	// local reconstruction
	178	if (!fRunReconstruction.IsNull()) {
	179	if (!RunReconstruction(fRunReconstruction)) {
e583c30d	180	if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f	181	}
	182	}
	183	if (!fRunTracking && fFillESD.IsNull()) return kTRUE;
	184
96ae9b65	185	if (fRunTracking) {
	186	// get loaders and trackers
	187	fITSLoader = fRunLoader->GetLoader("ITSLoader");
	188	if (!fITSLoader) {
	189	Error("Run", "no ITS loader found");
	190	if (fStopOnError) {CleanUp(); return kFALSE;}
	191	}
	192	fITSTracker = NULL;
	193	if (aliRun->GetDetector("ITS")) {
	194	fITSTracker = aliRun->GetDetector("ITS")->CreateTracker();
	195	}
	196	if (!fITSTracker) {
	197	Error("Run", "couldn't create a tracker for ITS");
	198	if (fStopOnError) {CleanUp(); return kFALSE;}
	199	}
	200
	201	fTPCLoader = fRunLoader->GetLoader("TPCLoader");
	202	if (!fTPCLoader) {
	203	Error("Run", "no TPC loader found");
	204	if (fStopOnError) {CleanUp(); return kFALSE;}
	205	}
	206	fTPCTracker = NULL;
	207	if (aliRun->GetDetector("TPC")) {
	208	fTPCTracker = aliRun->GetDetector("TPC")->CreateTracker();
	209	}
	210	if (!fTPCTracker) {
	211	Error("Run", "couldn't create a tracker for TPC");
	212	if (fStopOnError) {CleanUp(); return kFALSE;}
	213	}
	214
	215	fTRDLoader = fRunLoader->GetLoader("TRDLoader");
	216	if (!fTRDLoader) {
	217	Error("Run", "no TRD loader found");
	218	if (fStopOnError) {CleanUp(); return kFALSE;}
	219	}
	220	fTRDTracker = NULL;
	221	if (aliRun->GetDetector("TRD")) {
	222	fTRDTracker = aliRun->GetDetector("TRD")->CreateTracker();
	223	}
	224	if (!fTRDTracker) {
	225	Error("Run", "couldn't create a tracker for TRD");
	226	if (fStopOnError) {CleanUp(); return kFALSE;}
	227	}
	228
	229	fTOFLoader = fRunLoader->GetLoader("TOFLoader");
	230	if (!fTOFLoader) {
	231	Error("Run", "no TOF loader found");
	232	if (fStopOnError) {CleanUp(); return kFALSE;}
	233	}
	234	fTOFTracker = NULL;
	235	if (aliRun->GetDetector("TOF")) {
	236	fTOFTracker = aliRun->GetDetector("TOF")->CreateTracker();
	237	}
	238	if (!fTOFTracker) {
	239	Error("Run", "couldn't create a tracker for TOF");
	240	if (fStopOnError) {CleanUp(); return kFALSE;}
	241	}
596a855f	242	}
596a855f	243	// create the ESD output file
	244	TFile* file = TFile::Open("AliESDs.root", "RECREATE");
	245	if (!file->IsOpen()) {
	246	Error("Run", "opening AliESDs.root failed");
e583c30d	247	if (fStopOnError) {CleanUp(file); return kFALSE;}
596a855f	248	}
	249
	250	// loop over events
	251	for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
	252	Info("Run", "processing event %d", iEvent);
	253	AliESD* esd = new AliESD;
	254	fRunLoader->GetEvent(iEvent);
e583c30d	255	esd->SetRunNumber(aliRun->GetRunNumber());
	256	esd->SetEventNumber(aliRun->GetEvNumber());
	257	esd->SetMagneticField(aliRun->Field()->SolenoidField());
596a855f	258
	259	// barrel tracking
	260	if (fRunTracking) {
	261	if (!RunTracking(esd)) {
e583c30d	262	if (fStopOnError) {CleanUp(file); return kFALSE;}
596a855f	263	}
	264	}
	265
	266	// fill ESD
	267	if (!fFillESD.IsNull()) {
	268	if (!FillESD(esd, fFillESD)) {
e583c30d	269	if (fStopOnError) {CleanUp(file); return kFALSE;}
596a855f	270	}
	271	}
	272
	273	// combined PID
	274	AliESDpid::MakePID(esd);
	275
	276	// write ESD
	277	char name[100];
	278	sprintf(name, "ESD%d", iEvent);
	279	file->cd();
	280	if (!esd->Write(name)) {
	281	Error("Run", "writing ESD failed");
e583c30d	282	if (fStopOnError) {CleanUp(file); return kFALSE;}
596a855f	283	}
d9b8978b	284	delete esd;
596a855f	285	}
596a855f	286
e583c30d	287	CleanUp(file);
596a855f	288
	289	return kTRUE;
	290	}
	291
	292
	293	//_____________________________________________________________________________
	294	Bool_t AliReconstruction::RunReconstruction(const TString& detectors)
	295	{
	296	// run the reconstruction
	297
030b532d	298	TStopwatch stopwatch;
	299	stopwatch.Start();
	300
596a855f	301	TString detStr = detectors;
e583c30d	302	TObjArray* detArray = fRunLoader->GetAliRun()->Detectors();
596a855f	303	for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
	304	AliModule* det = (AliModule*) detArray->At(iDet);
	305	if (!det \|\| !det->IsActive()) continue;
	306	if (IsSelected(det->GetName(), detStr)) {
	307	Info("RunReconstruction", "running reconstruction for %s",
	308	det->GetName());
030b532d	309	TStopwatch stopwatchDet;
030b532d	310	stopwatchDet.Start();
596a855f	311	det->Reconstruct();
030b532d	312	Info("RunReconstruction", "execution time for %s:", det->GetName());
030b532d	313	stopwatchDet.Print();
596a855f	314	}
	315	}
	316
	317	if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
	318	Error("RunReconstruction", "the following detectors were not found: %s",
	319	detStr.Data());
	320	if (fStopOnError) return kFALSE;
	321	}
	322
030b532d	323	Info("RunReconstruction", "execution time:");
	324	stopwatch.Print();
	325
596a855f	326	return kTRUE;
	327	}
	328
	329	//_____________________________________________________________________________
	330	Bool_t AliReconstruction::RunTracking(AliESD* esd)
	331	{
	332	// run the barrel tracking
	333
030b532d	334	TStopwatch stopwatch;
	335	stopwatch.Start();
	336
596a855f	337	// get the primary vertex (from MC for the moment)
	338	TArrayF vertex(3);
	339	fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vertex);
	340	Double_t vtxPos[3] = {vertex[0], vertex[1], vertex[2]};
	341	Double_t vtxCov[6] = {
	342	0.005,
	343	0.000, 0.005,
	344	0.000, 0.000, 0.010
	345	};
	346	Double_t vtxErr[3] = {vtxCov[0], vtxCov[2], vtxCov[5]}; // diag. elements
	347	esd->SetVertex(vtxPos, vtxCov);
	348	fITSTracker->SetVertex(vtxPos, vtxErr);
	349	fTPCTracker->SetVertex(vtxPos, vtxErr);
	350	fTRDTracker->SetVertex(vtxPos, vtxErr);
	351
85555ca8	352	// TPC tracking
85555ca8	353	Info("RunTracking", "TPC tracking");
596a855f	354	fTPCLoader->LoadRecPoints("read");
	355	TTree* tpcTree = fTPCLoader->TreeR();
	356	if (!tpcTree) {
	357	Error("RunTracking", "Can't get the TPC cluster tree");
	358	return kFALSE;
	359	}
	360	fTPCTracker->LoadClusters(tpcTree);
	361	if (fTPCTracker->Clusters2Tracks(esd) != 0) {
85555ca8	362	Error("RunTracking", "TPC Clusters2Tracks failed");
596a855f	363	return kFALSE;
	364	}
	365
e583c30d	366	fRunLoader->GetAliRun()->GetDetector("TPC")->FillESD(esd); // preliminary PID
85555ca8	367	AliESDpid::MakePID(esd); // for the ITS tracker
	368
	369	// ITS tracking
	370	Info("RunTracking", "ITS tracking");
596a855f	371	fITSLoader->LoadRecPoints("read");
	372	TTree* itsTree = fITSLoader->TreeR();
	373	if (!itsTree) {
	374	Error("RunTracking", "Can't get the ITS cluster tree");
	375	return kFALSE;
	376	}
	377	fITSTracker->LoadClusters(itsTree);
	378	if (fITSTracker->Clusters2Tracks(esd) != 0) {
85555ca8	379	Error("RunTracking", "ITS Clusters2Tracks failed");
596a855f	380	return kFALSE;
	381	}
	382
	383	// ITS back propagation
	384	Info("RunTracking", "ITS back propagation");
	385	if (fITSTracker->PropagateBack(esd) != 0) {
	386	Error("RunTracking", "ITS backward propagation failed");
	387	return kFALSE;
	388	}
	389
	390	// TPC back propagation
	391	Info("RunTracking", "TPC back propagation");
	392	if (fTPCTracker->PropagateBack(esd) != 0) {
	393	Error("RunTracking", "TPC backward propagation failed");
	394	return kFALSE;
	395	}
	396
	397	// TRD back propagation
	398	Info("RunTracking", "TRD back propagation");
	399	fTRDLoader->LoadRecPoints("read");
	400	TTree* trdTree = fTRDLoader->TreeR();
	401	if (!trdTree) {
	402	Error("RunTracking", "Can't get the TRD cluster tree");
	403	return kFALSE;
	404	}
	405	fTRDTracker->LoadClusters(trdTree);
	406	if (fTRDTracker->PropagateBack(esd) != 0) {
	407	Error("RunTracking", "TRD backward propagation failed");
	408	return kFALSE;
	409	}
	410
	411	// TOF back propagation
	412	Info("RunTracking", "TOF back propagation");
	413	fTOFLoader->LoadDigits("read");
	414	TTree* tofTree = fTOFLoader->TreeD();
	415	if (!tofTree) {
	416	Error("RunTracking", "Can't get the TOF digits tree");
	417	return kFALSE;
	418	}
	419	fTOFTracker->LoadClusters(tofTree);
	420	if (fTOFTracker->PropagateBack(esd) != 0) {
	421	Error("RunTracking", "TOF backward propagation failed");
	422	return kFALSE;
	423	}
	424	fTOFTracker->UnloadClusters();
	425	fTOFLoader->UnloadDigits();
	426
	427	// TRD inward refit
	428	Info("RunTracking", "TRD inward refit");
	429	if (fTRDTracker->RefitInward(esd) != 0) {
	430	Error("RunTracking", "TRD inward refit failed");
	431	return kFALSE;
	432	}
	433	fTRDTracker->UnloadClusters();
	434	fTRDLoader->UnloadRecPoints();
	435
	436	// TPC inward refit
	437	Info("RunTracking", "TPC inward refit");
	438	if (fTPCTracker->RefitInward(esd) != 0) {
	439	Error("RunTracking", "TPC inward refit failed");
	440	return kFALSE;
	441	}
	442	fTPCTracker->UnloadClusters();
	443	fTPCLoader->UnloadRecPoints();
444
445	// ITS inward refit
446	Info("RunTracking", "ITS inward refit");
447	if (fITSTracker->RefitInward(esd) != 0) {
448	Error("RunTracking", "ITS inward refit failed");
449	return kFALSE;
450	}
451	fITSTracker->UnloadClusters();
452	fITSLoader->UnloadRecPoints();
453
030b532d	454	Info("RunTracking", "execution time:");
	455	stopwatch.Print();
	456
596a855f	457	return kTRUE;
	458	}
	459
	460	//_____________________________________________________________________________
	461	Bool_t AliReconstruction::FillESD(AliESD* esd, const TString& detectors)
	462	{
	463	// fill the event summary data
	464
030b532d	465	TStopwatch stopwatch;
	466	stopwatch.Start();
	467
596a855f	468	TString detStr = detectors;
e583c30d	469	TObjArray* detArray = fRunLoader->GetAliRun()->Detectors();
596a855f	470	for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
	471	AliModule* det = (AliModule*) detArray->At(iDet);
	472	if (!det \|\| !det->IsActive()) continue;
	473	if (IsSelected(det->GetName(), detStr)) {
	474	Info("FillESD", "filling ESD for %s",
	475	det->GetName());
	476	det->FillESD(esd);
	477	}
	478	}
	479
	480	if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
	481	Error("FillESD", "the following detectors were not found: %s",
	482	detStr.Data());
	483	if (fStopOnError) return kFALSE;
	484	}
	485
030b532d	486	Info("FillESD", "execution time:");
	487	stopwatch.Print();
	488
596a855f	489	return kTRUE;
	490	}
	491
	492
	493	//_____________________________________________________________________________
	494	Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
	495	{
	496	// check whether detName is contained in detectors
	497	// if yes, it is removed from detectors
	498
	499	// check if all detectors are selected
	500	if ((detectors.CompareTo("ALL") == 0) \|\|
	501	detectors.BeginsWith("ALL ") \|\|
	502	detectors.EndsWith(" ALL") \|\|
	503	detectors.Contains(" ALL ")) {
	504	detectors = "ALL";
	505	return kTRUE;
	506	}
	507
	508	// search for the given detector
	509	Bool_t result = kFALSE;
	510	if ((detectors.CompareTo(detName) == 0) \|\|
	511	detectors.BeginsWith(detName+" ") \|\|
	512	detectors.EndsWith(" "+detName) \|\|
	513	detectors.Contains(" "+detName+" ")) {
	514	detectors.ReplaceAll(detName, "");
	515	result = kTRUE;
	516	}
	517
	518	// clean up the detectors string
	519	while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
	520	while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
	521	while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
	522
	523	return result;
	524	}
e583c30d	525
	526	//_____________________________________________________________________________
	527	void AliReconstruction::CleanUp(TFile* file)
	528	{
	529	// delete trackers and the run loader and close and delete the file
	530
	531	delete fITSTracker;
	532	fITSTracker = NULL;
	533	delete fTPCTracker;
	534	fTPCTracker = NULL;
	535	delete fTRDTracker;
	536	fTRDTracker = NULL;
	537	delete fTOFTracker;
	538	fTOFTracker = NULL;
	539
	540	delete fRunLoader;
	541	fRunLoader = NULL;
	542
	543	if (file) {
	544	file->Close();
	545	delete file;
	546	}
	547	}