Adding AliReconstruction class (T.Kuhr)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Jan 2004 13:23:39 +0000 (13:23 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Jan 2004 13:23:39 +0000 (13:23 +0000)
18 files changed:
ITS/AliITS.cxx
ITS/AliITS.h
STEER/AliModule.h
STEER/AliReconstruction.cxx [new file with mode: 0644]
STEER/AliReconstruction.h [new file with mode: 0644]
STEER/STEERLinkDef.h
STEER/libSTEER.pkg
TOF/AliTOF.cxx
TOF/AliTOF.h
TOF/AliTOFpidESD.h
TOF/AliTOFtracker.cxx [new file with mode: 0644]
TOF/AliTOFtracker.h [new file with mode: 0644]
TOF/TOFLinkDef.h
TOF/libTOF.pkg
TPC/AliTPC.cxx
TPC/AliTPC.h
TRD/AliTRD.cxx
TRD/AliTRD.h

index 9191f19..fbf91f5 100644 (file)
@@ -108,6 +108,12 @@ the AliITS class.
 #include "AliITSsimulationSSD.h"
 #include "AliMC.h"
 #include "AliITSDigitizer.h"
+#include "AliITSclustererV2.h"
+#include "AliITStrackerV2.h"
+#include "AliITSpidESD.h"
+#include "AliV0vertexer.h"
+#include "AliCascadeVertexer.h"
+#include "AliESD.h"
 
 ClassImp(AliITS)
 
@@ -1761,3 +1767,85 @@ AliLoader* AliITS::MakeLoader(const char* topfoldername)
 }
 
 
+//_____________________________________________________________________________
+void AliITS::Reconstruct() const
+{
+// reconstruct clusters
+
+  AliLoader* loader = GetLoader();
+  loader->LoadRecPoints("recreate");
+  loader->LoadDigits("read");
+
+  AliITSclustererV2 clusterer(GetITSgeom());
+  AliRunLoader* runLoader = loader->GetRunLoader();
+  Int_t nEvents = runLoader->GetNumberOfEvents();
+
+  for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
+    runLoader->GetEvent(iEvent);
+
+    TTree* treeClusters = loader->TreeR();
+    if (!treeClusters) {
+      loader->MakeTree("R");
+      treeClusters = loader->TreeR();
+    }
+    TTree* treeDigits = loader->TreeD();
+    if (!treeDigits) {
+      Error("Reconstruct", "Can't get digits tree !");
+      return;
+    }
+
+    clusterer.Digits2Clusters(treeDigits, treeClusters);
+         
+    loader->WriteRecPoints("OVERWRITE");
+  }
+
+  loader->UnloadRecPoints();
+  loader->UnloadDigits();
+}
+
+//_____________________________________________________________________________
+AliTracker* AliITS::CreateTracker() const
+{
+// create an ITS tracker
+
+  return new AliITStrackerV2(GetITSgeom());
+}
+
+//_____________________________________________________________________________
+void AliITS::FillESD(AliESD* esd) const
+{
+// make PID, find V0s and cascades
+
+  Double_t parITS[] = {34., 0.15, 10.};
+  AliITSpidESD itsPID(parITS);
+  itsPID.MakePID(esd);
+
+  // V0 finding
+  Double_t cuts[]={33,  // max. allowed chi2
+                  0.16,// min. allowed negative daughter's impact parameter 
+                  0.05,// min. allowed positive daughter's impact parameter 
+                  0.080,// max. allowed DCA between the daughter tracks
+                  0.998,// max. allowed cosine of V0's pointing angle
+                  0.9,  // min. radius of the fiducial volume
+                  2.9   // max. radius of the fiducial volume
+  };
+  AliV0vertexer vtxer(cuts);
+  Double_t vtx[3], cvtx[6];
+  esd->GetVertex(vtx, cvtx);
+  vtxer.SetVertex(vtx);
+  vtxer.Tracks2V0vertices(esd);
+
+  // cascade finding
+  Double_t cts[]={33.,    // max. allowed chi2
+                 0.05,   // min. allowed V0 impact parameter 
+                 0.008,  // window around the Lambda mass 
+                 0.035,  // min. allowed bachelor's impact parameter 
+                 0.10,   // max. allowed DCA between a V0 and a track
+                 0.9985, //max. allowed cosine of the cascade pointing angle
+                 0.9,    // min. radius of the fiducial volume
+                 2.9     // max. radius of the fiducial volume
+  };
+  AliCascadeVertexer cvtxer=AliCascadeVertexer(cts);
+  cvtxer.V0sTracks2CascadeVertices(esd);
+}
+
index 715bd7f..e0e8920 100644 (file)
@@ -180,6 +180,10 @@ class AliITS : public AliDetector {
     void ResetRecPoints();
     // Return pointer to rec points 
     TClonesArray  *RecPoints()   {return fRecPoints;}
+
+    virtual void Reconstruct() const;
+    virtual AliTracker* CreateTracker() const;
+    virtual void FillESD(AliESD* esd) const;
      
  protected:
     //================== Data Members ==================================
index ebb6553..d70269c 100644 (file)
@@ -90,9 +90,9 @@ public:
   virtual void        SDigits2Digits() {}
   virtual void        Hits2Digits() {}
   virtual void        Digits2Reco() {}
-  virtual void        Reconstruct() {}
-  virtual AliTracker* CreateTracker() {return NULL;}
-  virtual void        FillESD(AliESD* /*esd*/) {}
+  virtual void        Reconstruct() const {}
+  virtual AliTracker* CreateTracker() const {return NULL;}
+  virtual void        FillESD(AliESD* /*esd*/) const {}
   virtual void        Digits2Raw() {}
   virtual void        Raw2Digits() {}
   virtual void        Browse(TBrowser *) {}
diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx
new file mode 100644 (file)
index 0000000..a529206
--- /dev/null
@@ -0,0 +1,481 @@
+/**************************************************************************
+ * 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                                                          //
+//                                                                           //
+//   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 <TArrayF.h>
+
+
+ClassImp(AliReconstruction)
+
+
+//_____________________________________________________________________________
+AliReconstruction::AliReconstruction(const char* name, const char* title) :
+  TNamed(name, title)
+{
+// create reconstruction object with default parameters
+
+  Init();
+}
+
+//_____________________________________________________________________________
+AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
+  TNamed(rec)
+{
+// copy constructor
+
+  fRunReconstruction = rec.fRunReconstruction;
+  fRunTracking = rec.fRunTracking;
+  fStopOnError = rec.fStopOnError;
+
+  fGAliceFileName = rec.fGAliceFileName;
+
+  fRunLoader = NULL;
+}
+
+//_____________________________________________________________________________
+AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
+{
+// assignment operator
+
+  this->~AliReconstruction();
+  new(this) AliReconstruction(rec);
+  return *this;
+}
+
+//_____________________________________________________________________________
+AliReconstruction::~AliReconstruction()
+{
+// clean up
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::Init()
+{
+// set default parameters
+
+  fRunReconstruction = "ALL";
+  fRunTracking = kTRUE;
+  fFillESD = "ALL";
+  fStopOnError = kFALSE;
+
+  fGAliceFileName = "galice.root";
+
+  fRunLoader = NULL;
+}
+
+
+//_____________________________________________________________________________
+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
+  if (fRunLoader) delete fRunLoader;
+  fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
+  if (!fRunLoader) {
+    Error("Run", "no run loader found in file %s", 
+         fGAliceFileName.Data());
+    return kFALSE;
+  }
+  fRunLoader->LoadgAlice();
+  gAlice = fRunLoader->GetAliRun();
+  if (!gAlice) {
+    Error("Run", "no gAlice object found in file %s", 
+         fGAliceFileName.Data());
+    return kFALSE;
+  }
+
+  // local reconstruction
+  if (!fRunReconstruction.IsNull()) {
+    if (!RunReconstruction(fRunReconstruction)) {
+      if (fStopOnError) return kFALSE;
+    }
+  }
+  if (!fRunTracking && fFillESD.IsNull()) return kTRUE;
+
+  // get loaders and trackers
+  fITSLoader = fRunLoader->GetLoader("ITSLoader");
+  if (!fITSLoader) {
+    Error("Run", "no ITS loader found");
+    if (fStopOnError) return kFALSE;
+  }
+  fITSTracker = NULL;
+  if (gAlice->GetDetector("ITS")) {
+    fITSTracker = gAlice->GetDetector("ITS")->CreateTracker();
+  }
+  if (!fITSTracker) {
+    Error("Run", "couldn't create a tracker for ITS");
+    if (fStopOnError) return kFALSE;
+  }
+
+  fTPCLoader = fRunLoader->GetLoader("TPCLoader");
+  if (!fTPCLoader) {
+    Error("Run", "no TPC loader found");
+    if (fStopOnError) return kFALSE;
+  }
+  fTPCTracker = NULL;
+  if (gAlice->GetDetector("TPC")) {
+    fTPCTracker = gAlice->GetDetector("TPC")->CreateTracker();
+  }
+  if (!fTPCTracker) {
+    Error("Run", "couldn't create a tracker for TPC");
+    if (fStopOnError) return kFALSE;
+  }
+
+  fTRDLoader = fRunLoader->GetLoader("TRDLoader");
+  if (!fTRDLoader) {
+    Error("Run", "no TRD loader found");
+    if (fStopOnError) return kFALSE;
+  }
+  fTRDTracker = NULL;
+  if (gAlice->GetDetector("TRD")) {
+    fTRDTracker = gAlice->GetDetector("TRD")->CreateTracker();
+  }
+  if (!fTRDTracker) {
+    Error("Run", "couldn't create a tracker for TRD");
+    if (fStopOnError) return kFALSE;
+  }
+
+  fTOFLoader = fRunLoader->GetLoader("TOFLoader");
+  if (!fTOFLoader) {
+    Error("Run", "no TOF loader found");
+    if (fStopOnError) return kFALSE;
+  }
+  fTOFTracker = NULL;
+  if (gAlice->GetDetector("TOF")) {
+    fTOFTracker = gAlice->GetDetector("TOF")->CreateTracker();
+  }
+  if (!fTOFTracker) {
+    Error("Run", "couldn't create a tracker for TOF");
+    if (fStopOnError) 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) 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(gAlice->GetRunNumber());
+    esd->SetEventNumber(gAlice->GetEvNumber());
+
+    // barrel tracking
+    if (fRunTracking) {
+      if (!RunTracking(esd)) {
+       if (fStopOnError) return kFALSE;
+      }
+    }
+
+    // fill ESD
+    if (!fFillESD.IsNull()) {
+      if (!FillESD(esd, fFillESD)) {
+       if (fStopOnError) 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) return kFALSE;
+    }
+  }
+
+  file->Close();
+
+  return kTRUE;
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunReconstruction(const TString& detectors)
+{
+// run the reconstruction
+
+  TString detStr = detectors;
+  TObjArray* detArray = gAlice->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());
+      det->Reconstruct();
+    }
+  }
+
+  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+    Error("RunReconstruction", "the following detectors were not found: %s", 
+         detStr.Data());
+    if (fStopOnError) return kFALSE;
+  }
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunTracking(AliESD* esd)
+{
+// run the barrel tracking
+
+  // 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 inward fit
+  Info("RunTracking", "TPC inward fit");
+  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 inward track fit failed");
+    return kFALSE;
+  }
+
+  // ITS inward fit
+  Info("RunTracking", "ITS inward fit");
+  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 inward track fit 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();
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillESD(AliESD* esd, const TString& detectors)
+{
+// fill the event summary data
+
+  TString detStr = detectors;
+  TObjArray* detArray = gAlice->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;
+  }
+
+  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;
+}
diff --git a/STEER/AliReconstruction.h b/STEER/AliReconstruction.h
new file mode 100644 (file)
index 0000000..ac05845
--- /dev/null
@@ -0,0 +1,63 @@
+#ifndef ALIRECONSTRUCTION_H
+#define ALIRECONSTRUCTION_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include <TNamed.h>
+#include <TString.h>
+
+class AliRunLoader;
+class AliLoader;
+class AliTracker;
+class AliESD;
+
+
+class AliReconstruction: public TNamed {
+public:
+  AliReconstruction(const char* name = "AliReconstruction", 
+                   const char* title = "reconstruction");
+  AliReconstruction(const AliReconstruction& rec);
+  AliReconstruction& operator = (const AliReconstruction& rec);
+  virtual ~AliReconstruction();
+
+  void           SetGAliceFile(const char* fileName);
+
+  void           SetRunReconstruction(const char* detectors) {
+    fRunReconstruction = detectors;};
+  void           SetRunTracking(Bool_t run) {fRunTracking = run;};
+  void           SetFillESD(const char* detectors) {fFillESD = detectors;};
+
+  virtual Bool_t Run();
+
+private:
+  void           Init();
+
+  Bool_t         IsSelected(TString detName, TString& detectors) const;
+
+  Bool_t         RunReconstruction(const TString& detectors);
+  Bool_t         RunTracking(AliESD* esd);
+  Bool_t         FillESD(AliESD* esd, const TString& detectors);
+
+  TString        fRunReconstruction;  // run the reconstr. for these detectors
+  Bool_t         fRunTracking;        // run the barrel tracking
+  TString        fFillESD;            // fill ESD for these detectors
+  Bool_t         fStopOnError;        // stop or continue on errors
+
+  TString        fGAliceFileName;     // name of the galice file
+
+  AliRunLoader*  fRunLoader;          //! current run loader object
+  AliLoader*     fITSLoader;          //! loader for ITS
+  AliTracker*    fITSTracker;         //! tracker for ITS
+  AliLoader*     fTPCLoader;          //! loader for TPC
+  AliTracker*    fTPCTracker;         //! tracker for TPC
+  AliLoader*     fTRDLoader;          //! loader for TRD
+  AliTracker*    fTRDTracker;         //! tracker for TRD
+  AliLoader*     fTOFLoader;          //! loader for TOF
+  AliTracker*    fTOFTracker;         //! tracker for TOF
+
+  ClassDef(AliReconstruction, 1)      // class for running the reconstruction
+};
+
+#endif
index f93bf4a..e9fef67 100644 (file)
@@ -79,6 +79,7 @@
 #pragma link C++ class  AliBarrelTrack+;
 #pragma link C++ class  AliMC+;
 #pragma link C++ class  AliSimulation+;
+#pragma link C++ class  AliReconstruction+;
 #endif
 
 
index d9c94fa..1c6621d 100644 (file)
@@ -17,7 +17,7 @@ AliGausCorr.cxx AliTrackReference.cxx AliESD.cxx \
 AliTrackMap.cxx AliTrackMapper.cxx AliCollisionGeometry.cxx \
 AliMemoryWatcher.cxx AliBarrelTrack.cxx \
 AliESDtrack.cxx AliESDCaloTrack.cxx AliESDMuonTrack.cxx AliESDv0.cxx AliESDcascade.cxx AliESDvertex.cxx AliESDpid.cxx \
-AliMC.cxx AliSimulation.cxx
+AliMC.cxx AliSimulation.cxx AliReconstruction.cxx
 HDRS:= $(SRCS:.cxx=.h) 
 
 DHDR= STEERLinkDef.h
index 6913f5e..5c58a30 100644 (file)
@@ -71,6 +71,7 @@
 #include "AliTOFhitT0.h"
 #include "AliMC.h"
 #include "AliTOFDigitizer.h"
+#include "AliTOFtracker.h"
  
 ClassImp(AliTOF)
  
@@ -983,3 +984,13 @@ void AliTOF::CreateSDigitsArray() {
 //
   fSDigits       = new TClonesArray("AliTOFSDigit",  1000);
 }
+
+////////////////////////////////////////////////////////////////////////
+AliTracker* AliTOF::CreateTracker() const
+{
+// create a TOF tracker
+
+  Double_t parPID[] = {130., 5.};
+  return new AliTOFtracker(GetGeometry(), parPID);
+}
+
index d271a9f..17ff7ec 100644 (file)
@@ -91,6 +91,8 @@ public:
   void CreateSDigitsArray();
   AliTOFGeometry *GetGeometry() const { return fTOFGeometry; }; 
 
+  virtual AliTracker* CreateTracker() const;
+
   Int_t   fNevents ;        // Number of events to digitize
 
 protected:
index 6336748..938b4e7 100644 (file)
@@ -10,6 +10,7 @@
 //-------------------------------------------------------
 
 #include <TObject.h>
+#include <TMath.h>
 
 class AliTOFGeometry;
 class AliESD;
diff --git a/TOF/AliTOFtracker.cxx b/TOF/AliTOFtracker.cxx
new file mode 100644 (file)
index 0000000..c54deb1
--- /dev/null
@@ -0,0 +1,22 @@
+/**************************************************************************
+ * 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$ */
+
+#include "AliTOFtracker.h"
+
+
+ClassImp(AliTOFtracker)
+
diff --git a/TOF/AliTOFtracker.h b/TOF/AliTOFtracker.h
new file mode 100644 (file)
index 0000000..a9c19b6
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALITOFTRACKER_H
+#define ALITOFTRACKER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "AliTracker.h"
+#include "AliTOFpidESD.h"
+
+class AliTOFGeometry;
+
+
+class AliTOFtracker : public AliTracker {
+public:
+
+  AliTOFtracker(AliTOFGeometry* geom, Double_t parPID[2]) 
+    {fGeom = geom; fTOFpid = new AliTOFpidESD(parPID);};
+  virtual ~AliTOFtracker() {delete fTOFpid;}
+  virtual Int_t Clusters2Tracks(AliESD* /*event*/) {return -1;};
+  virtual Int_t PropagateBack(AliESD* event) {return fTOFpid->MakePID(event);};
+  virtual Int_t RefitInward(AliESD* /*event*/) {return -1;};
+
+  virtual Int_t LoadClusters(TTree* tree) 
+    {return fTOFpid->LoadClusters(tree, fGeom);};
+  virtual void UnloadClusters() {fTOFpid->UnloadClusters();};
+  virtual AliCluster *GetCluster(Int_t index) const {return NULL;};
+
+private:
+  AliTOFpidESD*    fTOFpid;  // TOF PID
+  AliTOFGeometry*  fGeom;    // TOF geometry
+
+  ClassDef(AliTOFtracker, 1) // TOF tracker (wrapper for AliTOFpidESD)
+};
+
+#endif
+
+
index 36c5402..17955f9 100644 (file)
@@ -36,5 +36,6 @@
 #pragma link C++ class  AliTOFDigitMap+;
 
 #pragma link C++ class  AliTOFpidESD+;
+#pragma link C++ class  AliTOFtracker+;
 
 #endif
index 4016aeb..36f967f 100644 (file)
@@ -3,7 +3,7 @@ SRCS  = AliTOF.cxx  AliTOFGeometry.cxx AliTOFv4T0.cxx  AliTOFhit.cxx  AliTOFhitT
         AliTOFRawDigit.cxx  AliTOFDigitizer.cxx  AliTOFSDigitizer.cxx  AliTOFMerger.cxx  \
         AliTOFSDigit.cxx  AliTOFHitMap.cxx  AliTOFPad.cxx  AliTOFRecHit.cxx  AliTOFTrack.cxx  \
         AliTOFReconstructioner.cxx  AliTOFProb.cxx  AliTOFTrackV2.cxx  AliTOFReconstructionerV2.cxx  \
-        AliTOFDigitMap.cxx  AliTOFpidESD.cxx
+        AliTOFDigitMap.cxx  AliTOFpidESD.cxx  AliTOFtracker.cxx
 
 
 HDRS:= $(SRCS:.cxx=.h)
index 82d8de5..3186190 100644 (file)
@@ -78,6 +78,9 @@
 #include "AliTrackReference.h"
 #include "AliMC.h"
 #include "AliTPCDigitizer.h"
+#include "AliTPCclusterer.h"
+#include "AliTPCtracker.h"
+#include "AliTPCpidESD.h"
 
 
 ClassImp(AliTPC) 
@@ -327,6 +330,62 @@ void AliTPC::Clusters2Tracks() const
   "Dummy function !  Call AliTPCtracker::Clusters2Tracks(...) instead !");
  }
 
+
+//_____________________________________________________________________________
+void AliTPC::Reconstruct() const
+{
+// reconstruct clusters
+
+  AliLoader* loader = GetLoader();
+  loader->LoadRecPoints("recreate");
+  loader->LoadDigits("read");
+
+  AliTPCclusterer clusterer(fTPCParam);
+  AliRunLoader* runLoader = loader->GetRunLoader();
+  Int_t nEvents = runLoader->GetNumberOfEvents();
+
+  for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
+    runLoader->GetEvent(iEvent);
+
+    TTree* treeClusters = loader->TreeR();
+    if (!treeClusters) {
+      loader->MakeTree("R");
+      treeClusters = loader->TreeR();
+    }
+    TTree* treeDigits = loader->TreeD();
+    if (!treeDigits) {
+      Error("Reconstruct", "Can't get digits tree !");
+      return;
+    }
+
+    clusterer.Digits2Clusters(treeDigits, treeClusters);
+         
+    loader->WriteRecPoints("OVERWRITE");
+  }
+
+  loader->UnloadRecPoints();
+  loader->UnloadDigits();
+}
+
+//_____________________________________________________________________________
+AliTracker* AliTPC::CreateTracker() const
+{
+// create a TPC tracker
+
+  return new AliTPCtracker(fTPCParam);
+}
+
+//_____________________________________________________________________________
+void AliTPC::FillESD(AliESD* esd) const
+{
+// make PID
+
+  Double_t parTPC[] = {47., 0.10, 10.};
+  AliTPCpidESD tpcPID(parTPC);
+  tpcPID.MakePID(esd);
+}
+
+
 //_____________________________________________________________________________
 void AliTPC::CreateMaterials()
 {
@@ -835,7 +894,6 @@ void    AliTPC::SetActiveSectors(Int_t flag)
       } 
     }    
   }
-  
 }  
 
 
index a3ffeaf..cd8541d 100644 (file)
@@ -66,6 +66,10 @@ public:
   virtual void  Digits2Clusters(Int_t eventnumber=0) const;
   virtual void  Clusters2Tracks() const;
 
+  virtual void  Reconstruct() const;
+  virtual AliTracker* CreateTracker() const;
+  virtual void  FillESD(AliESD* esd) const;
+
   Int_t         GetNsectors() const  {return fNsectors;}
   virtual void  MakeBranch(Option_t *opt=" ");
   virtual void  ResetDigits();
index 2ab09c3..d08d5e1 100644 (file)
@@ -56,6 +56,9 @@
 #include "AliTRDtrackHits.h"  
 #include "AliTrackReference.h"
 #include "AliMC.h"
+#include "AliTRDclusterizerV1.h"
+#include "AliTRDparameter.h"
+#include "AliTRDtracker.h"
 
 ClassImp(AliTRD)
  
@@ -1300,6 +1303,39 @@ void AliTRD::AddHit2(Int_t track, Int_t det, Float_t *hits, Int_t q
 }
 
 
+//_____________________________________________________________________________
+void AliTRD::Reconstruct() const
+{
+// reconstruct clusters
+
+  AliTRDclusterizerV1 clusterer("clusterer", "TRD clusterizer");
+  AliRunLoader* runLoader = GetLoader()->GetRunLoader();
+  runLoader->CdGAFile();
+  AliTRDparameter* trdParam = (AliTRDparameter*) gFile->Get("TRDparameter"); 
+  if (!trdParam) {
+    Error("Reconstruct", "no TRD parameters found");
+    return;
+  }
+  trdParam->ReInit();
+  clusterer.SetParameter(trdParam);
+  Int_t nEvents = runLoader->GetNumberOfEvents();
+
+  for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
+    clusterer.Open(runLoader->GetFileName(), iEvent);
+    clusterer.ReadDigits();
+    clusterer.MakeClusters();
+    clusterer.WriteClusters(-1);
+  }
+}
+
+//_____________________________________________________________________________
+AliTracker* AliTRD::CreateTracker() const
+{
+// create a TRD tracker
+
+  GetLoader()->GetRunLoader()->CdGAFile();
+  return new AliTRDtracker(gFile);
+}
 
 
 
index 8e460ff..c3e57de 100644 (file)
@@ -99,6 +99,9 @@ class AliTRD : public AliDetector {
   virtual void       FinishPrimary();
   virtual void       RemapTrackHitIDs(Int_t *map);
 
+  virtual void       Reconstruct() const;
+  virtual AliTracker* CreateTracker() const;
+
  protected:
 
   Int_t                fGasMix;             //  Gas mixture. 0: Xe/Isobutane 1: Xe/CO2