Removal of the run-loaders from the algorithmic part of the vertexers code. Some...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 5 Jun 2008 10:20:09 +0000 (10:20 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 5 Jun 2008 10:20:09 +0000 (10:20 +0000)
27 files changed:
HLT/ITS/AliHLTITSVertexerZ.cxx
HLT/ITS/AliHLTITSVertexerZ.h
ITS/AliITSFindPrimaryVertex.C
ITS/AliITSFindTracksSA.C
ITS/AliITSMeanVertexer.cxx
ITS/AliITSMeanVertexer.h
ITS/AliITSReconstructor.cxx
ITS/AliITSVertexer.cxx
ITS/AliITSVertexer.h
ITS/AliITSVertexer3D.cxx
ITS/AliITSVertexer3D.h
ITS/AliITSVertexer3DTapan.cxx
ITS/AliITSVertexer3DTapan.h
ITS/AliITSVertexerCosmics.cxx
ITS/AliITSVertexerCosmics.h
ITS/AliITSVertexerFast.cxx
ITS/AliITSVertexerFast.h
ITS/AliITSVertexerIons.cxx
ITS/AliITSVertexerIons.h
ITS/AliITSVertexerZ.cxx
ITS/AliITSVertexerZ.h
ITS/AliITSVertexerZTest.C
ITS/DoVerticesSPD.C
ITS/ITSSPDVertexDiamondda.cxx
STEER/AliReconstruction.cxx
STEER/AliVertexer.cxx
STEER/AliVertexer.h

index 466ab8e4fbfd8d84244aa301b10c5dc0751b032b..3d025ec484b3428b7ffcdd4cf0becec2762e194f 100644 (file)
@@ -42,8 +42,8 @@ AliHLTITSVertexerZ::AliHLTITSVertexerZ():
   SetBinWidthFine();
 }
 
-AliHLTITSVertexerZ::AliHLTITSVertexerZ(TString filename,Float_t x0, Float_t y0):
-  AliITSVertexerZ(filename,x0,y0),
+AliHLTITSVertexerZ::AliHLTITSVertexerZ(Float_t x0, Float_t y0):
+  AliITSVertexerZ(x0,y0),
   fZCombf(0),
   fStepFine(0)
 {
@@ -57,55 +57,6 @@ AliHLTITSVertexerZ::~AliHLTITSVertexerZ()
   if (fZCombf) delete fZCombf;
 }
 
-//______________________________________________________________________
-AliHLTITSVertexerZ::AliHLTITSVertexerZ(const AliHLTITSVertexerZ &vtxr) :
-  AliITSVertexerZ(vtxr),
-  fZCombf(vtxr.fZCombf),
-  fStepFine(vtxr.fStepFine)
-{
-  // Copy constructor
-
-}
-
-//______________________________________________________________________
-AliHLTITSVertexerZ& AliHLTITSVertexerZ::operator=(const AliHLTITSVertexerZ&  vtxr )
-{
-  // Assignment operator
-  this->~AliHLTITSVertexerZ();
-  new(this) AliHLTITSVertexerZ(vtxr);
-  fZCombf = vtxr.fZCombf;
-  fStepFine = vtxr.fStepFine;
-
-  return *this;
-}
-//______________________________________________________________________
-AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
-  // Defines the AliESDVertex for the current event
-
-  fCurrentVertex = 0;
-  AliRunLoader *rl =AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  itsLoader->LoadRecPoints();
-  rl->GetEvent(evnumber);
-
-  /*  if(!fITS)  {
-    fITS = (AliITS*)gAlice->GetModule("ITS");
-    if(!fITS) {
-      Error("FindVertexForCurrentEvent","AliITS object was not found");
-      return fCurrentVertex;
-    }
-  }
-  */
-
-  // fITS->SetTreeAddress();
-  rl->CdGAFile();
-
-  AliITSgeom* geom=itsLoader->GetITSgeom();
-  TTree *tR = itsLoader->TreeR();
-  
-  return FindVertexForCurrentEvent(geom,tR);
-}
-
 //______________________________________________________________________
 AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR){
   // Defines the AliESDVertex for the current event
@@ -176,8 +127,8 @@ AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTr
       lc[0]=-recp->GetY()+yshift;
       lc[2]=-recp->GetZ()+zshift[module%4];
       geom->LtoG(module,lc,gc);
-      gc[0]-=fNominalPos[0];
-      gc[1]-=fNominalPos[1];
+      gc[0]-=GetNominalPos()[0];
+      gc[1]-=GetNominalPos()[1];
       Float_t xc1,yc1;
       xc1=gc[0];
       yc1=gc[1];
@@ -205,8 +156,8 @@ AliESDVertex* AliHLTITSVertexerZ::FindVertexForCurrentEvent(AliITSgeom *geom,TTr
       lc[0]=recp->GetY()+yshift;
       lc[2]=-recp->GetZ()+zshift[module%4];
       geom->LtoG(module,lc,gc);
-      gc[0]-=fNominalPos[0];
-      gc[1]-=fNominalPos[1];
+      gc[0]-=GetNominalPos()[0];
+      gc[1]-=GetNominalPos()[1];
       Float_t xc2,yc2;
       xc2=gc[0];
       yc2=gc[1];
index 7375db76e710562b2d4e7a47c75b303b835eb1cb..9679f165612b01e3fe52eb70d90f497a84359601 100644 (file)
@@ -26,22 +26,21 @@ class AliITSgeom;
 class AliHLTITSVertexerZ : public AliITSVertexerZ {
 public:
   AliHLTITSVertexerZ();
-  AliHLTITSVertexerZ(TString filename,Float_t x0=0., Float_t y0=0.);
+  AliHLTITSVertexerZ(Float_t x0, Float_t y0);
   virtual ~AliHLTITSVertexerZ();
 
-  AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb);
   AliESDVertex* FindVertexForCurrentEvent(AliITSgeom *geom,TTree *tR);
 
   void SetBinWidthFine(Float_t bw=0.0005){fStepFine = bw;}
 
- protected:
+ private:
   AliHLTITSVertexerZ(const AliHLTITSVertexerZ &vtxr);
   AliHLTITSVertexerZ& operator=(const AliHLTITSVertexerZ&  vtxr );
 
   TH1F *fZCombf;           //! histogram with fine z distribution
   Float_t fStepFine;       // bin width for fZCombf histogram
 
-  ClassDef(AliHLTITSVertexerZ,2)   //HLT ITS vertexer
+  ClassDef(AliHLTITSVertexerZ,3)   //HLT ITS vertexer
 };
 
 typedef AliHLTITSVertexerZ AliL3ITSVertexerZ; // for backward compatibility
index f280000479e952278dda37b0062b303e1c692d57..17a97e0f73748ee951abeb4563b9fa8856c72042 100644 (file)
@@ -1,5 +1,7 @@
 #if !defined(__CINT__) || defined(__MAKECINT__)
+#include <TROOT.h>
 #include <TClassTable.h>
+#include <TStopwatch.h>
 #include <TFile.h>
 #include <TTree.h>
 #include <Riostream.h>
@@ -10,6 +12,7 @@
 #include <AliRunLoader.h>
 #include <AliITSVertexerIons.h>
 #include <AliITSLoader.h>
+#include <AliGenHijingEventHeader.h>
 #include <unistd.h>
 
 #endif
@@ -37,12 +40,16 @@ void AliITSFindPrimaryVertex(Int_t evNumber1=0,Int_t NumbofEv=1, const char *fil
   // Open output file for vertices (default name: ITS.Vertex.root 
   // and Create vertexer
 
-  AliITSVertexerIons *vertexer = new AliITSVertexerIons("default");
+  AliITSVertexerIons *vertexer = new AliITSVertexerIons();
+  vertexer->Init("default");
   //vertexer->SetDebug(1);
   
   AliESDVertex *V;
   //   Loop over events 
    
+  AliITSLoader* itsloader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
+  itsloader->LoadRecPoints("read");
+
   for (int nev=evNumber1; nev< evNumber2; nev++) {
     cout<<"=============================================================\n";
     cout<<" Processing event "<<nev<<endl;
@@ -60,7 +67,8 @@ void AliITSFindPrimaryVertex(Int_t evNumber1=0,Int_t NumbofEv=1, const char *fil
     TStopwatch timer;
     timer.Start();
 
-    V=vertexer->FindVertexForCurrentEvent(nev);
+    TTree* cltree = itsloader->TreeR();
+    V=vertexer->FindVertexForCurrentEvent(cltree);
 
     TVector3 vtrue(primaryVertex[0],primaryVertex[1],primaryVertex[2]);
     TVector3 vfound(V->GetXv(),V->GetYv(),V->GetZv());
index 53b55d31e978e2716b4a998abdbd985ebd83fb26..31def66c57b7df0067420d4c195abaaa6eb2357a 100644 (file)
@@ -6,7 +6,7 @@
   #include "AliITSVertexerFast.h"
   #include "AliRun.h"
   #include "AliRunLoader.h"
-  #include "AliTPCLoader.h"
+//  #include "AliTPCLoader.h"
   #include "AliITSLoader.h"
   #include "TStopwatch.h"
   #include "AliMagF.h"
@@ -78,10 +78,12 @@ Int_t AliITSFindTracksSA(Int_t evin=0,Int_t nevents=1,char *opt="onlyITS+6/6",co
    for(Int_t iev=evin;iev<nevents;iev++){
      rl->GetEvent(iev);
      itsl->LoadRecPoints();
+
      //AliITSVertexerPPZ* vertexer = new AliITSVertexerPPZ("vertici.root");
      Double_t smear[3]={0.0150,0.0150,0.0150};
      AliITSVertexerFast* vertexer = new AliITSVertexerFast(smear);
-     AliITSVertex* vert = vertexer->FindVertexForCurrentEvent(iev);
+     TTree* cltree = itsl->TreeR();
+     AliITSVertex* vert = vertexer->FindVertexForCurrentEvent(cltree);
      AliITStrackerSA tracker(geom,vert);  
      tracker.SetEventNumber(iev);
      
index 05f47294772650c28707844bcc052280985eedaf..69548b9000dd88e845584850261fdba75e5507ec 100644 (file)
@@ -64,7 +64,7 @@ fWriteVertices(kFALSE)
 }
 
 //______________________________________________________________________
-AliITSMeanVertexer::AliITSMeanVertexer(TString filename):TObject(),
+AliITSMeanVertexer::AliITSMeanVertexer(TString &filename):TObject(),
 fLoaderFileName(),
 fGeometryFileName(),
 fMVFileName(fgkMVFileNameDefault),
@@ -92,9 +92,9 @@ fWriteVertices(kTRUE)
   Init(filename);
 }
 //______________________________________________________________________
-AliITSMeanVertexer::AliITSMeanVertexer(TString filename, 
-                                       TString loaderfilename, 
-                                      TString geometryfilename):TObject(),
+AliITSMeanVertexer::AliITSMeanVertexer(TString &filename, 
+                                       TString &loaderfilename, 
+                                      TString &geometryfilename):TObject(),
 fLoaderFileName(),
 fGeometryFileName(),
 fMVFileName(fgkMVFileNameDefault),
@@ -121,7 +121,7 @@ fWriteVertices(kTRUE)
 }
 
 //______________________________________________________________________
-void AliITSMeanVertexer::Init(TString filename){
+void AliITSMeanVertexer::Init(TString &filename){
   // Initialization part common to different constructors
   if(filename.IsNull()){
     AliFatal("Please, provide a valid file name for raw data file\n");
@@ -244,12 +244,13 @@ void AliITSMeanVertexer::Reconstruct(){
 void AliITSMeanVertexer::DoVertices(){
   // Loop on all events and compute 3D vertices
   AliITSLoader* loader = static_cast<AliITSLoader*>(fRunLoader->GetLoader("ITSLoader"));
-  AliITSVertexer3D *dovert = new AliITSVertexer3D("ITS.Vert3D.root");
+  AliITSVertexer3D *dovert = new AliITSVertexer3D();
   AliESDVertex *vert = 0;
   Int_t nevents = fRunLoader->TreeE()->GetEntries();
   for(Int_t i=0; i<nevents; i++){
     fRunLoader->GetEvent(i);
-    vert = dovert->FindVertexForCurrentEvent(i);
+    TTree* cltree = loader->TreeR();
+    vert = dovert->FindVertexForCurrentEvent(cltree);
     AliMultiplicity *mult = dovert->GetMultiplicity();
     if(Filter(vert,mult)){
       AddToMean(vert); 
index 613e3de8214a51130bfaef274fb8c84c515b231f..7c0fda26b70123f1d7feae4e6266fe0f9e0fec97 100644 (file)
@@ -25,10 +25,10 @@ class AliITSMeanVertexer : public TObject {
     AliITSMeanVertexer();   
     // standard constructor. filename is the name of the file containing
     // raw data either in ROOT or DATE format according to file extension
-    AliITSMeanVertexer(TString filename);   
+    AliITSMeanVertexer(TString &filename);   
     // constructor with explicit assignment of names for geometry and loaders
-    AliITSMeanVertexer(TString filename, TString loaderfilename, 
-                       TString geometryfilename);
+    AliITSMeanVertexer(TString &filename, TString &loaderfilename, 
+                       TString &geometryfilename);
     virtual ~AliITSMeanVertexer();
     void SetLoaderFileName(TString fn="ITSMeanVertexer.root")
                            {fLoaderFileName = fn;}
@@ -49,7 +49,7 @@ class AliITSMeanVertexer : public TObject {
     AliITSMeanVertexer(const AliITSMeanVertexer& vtxr);
     // assignment operator (NO assignment allowed)
     AliITSMeanVertexer& operator=(const AliITSMeanVertexer& /* vtxr */);
-    void Init(TString filename);  // initialization invoked by constructors
+    void Init(TString &filename);  // initialization invoked by constructors
     Bool_t Filter(AliESDVertex *vert,AliMultiplicity *mult);
     void AddToMean(AliESDVertex *vert);
     Bool_t ComputeMean();
index 97e24aeedb9750eaba5dde8a865aad1b922fed24..8e771f62655d10ea56d65701bf2dd932a342661c 100644 (file)
@@ -179,7 +179,7 @@ AliVertexer* AliITSReconstructor::CreateVertexer() const
   TString selectedVertexer = GetOption();
   if(selectedVertexer.Contains("ions") || selectedVertexer.Contains("IONS")){
     Info("CreateVertexer","a AliITSVertexerIons object has been selected\n");
-    return new AliITSVertexerIons("null");
+    return new AliITSVertexerIons();
   }
   if(selectedVertexer.Contains("smear") || selectedVertexer.Contains("SMEAR")){
     Double_t smear[3]={0.005,0.005,0.01};
@@ -188,7 +188,7 @@ AliVertexer* AliITSReconstructor::CreateVertexer() const
   }
   if(selectedVertexer.Contains("3d") || selectedVertexer.Contains("3D")){
     Info("CreateVertexer","a AliITSVertexer3D object has been selected\n");
-    return new AliITSVertexer3D("null");
+    return new AliITSVertexer3D();
   }
   if(selectedVertexer.Contains("cosmics") || selectedVertexer.Contains("COSMICS")){
     Info("CreateVertexer","a AliITSVertexerCosmics object has been selected\n");
@@ -196,7 +196,7 @@ AliVertexer* AliITSReconstructor::CreateVertexer() const
   }
   // by default an AliITSVertexerZ object is instatiated
   Info("CreateVertexer","a AliITSVertexerZ object has been selected\n");
-  return new AliITSVertexerZ("null");
+  return new AliITSVertexerZ();
 }
 
 //_____________________________________________________________________________
index 9c60a1f18348c2d89c7d07f6341989f03f30c3a9..250b9cca5b18cdad8533bf2468c15f47ac6a832d 100644 (file)
@@ -1,9 +1,8 @@
-#include <AliESDVertex.h>
+#include "AliLog.h"
+#include "AliMultiplicity.h"
 #include "AliITSgeomTGeo.h"
 #include "AliITSVertexer.h"
-#include "AliRunLoader.h"
 #include "AliITSLoader.h"
-#include "AliMultiplicity.h"
 #include "AliITSMultReconstructor.h"
 
 const Float_t AliITSVertexer::fgkPipeRadius = 3.0;
@@ -20,62 +19,14 @@ ClassImp(AliITSVertexer)
 //______________________________________________________________________
 AliITSVertexer::AliITSVertexer():AliVertexer(),
 fLadders(), 
-fLadOnLay2(0)   {
-  // Default Constructor
-  SetLaddersOnLayer2();
-}
-
-AliITSVertexer::AliITSVertexer(TString filename):AliVertexer(),
-fLadders(), 
-fLadOnLay2(0)
+fLadOnLay2(0),
+fFirstEvent(0),
+fLastEvent(-1)
 {
-  // Standard constructor
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  if(!rl){
-    Fatal("AliITSVertexer","Run Loader not found");
-  }
-  /*
-  if(rl->LoadgAlice()){
-    Fatal("AliITSVertexer","The AliRun object is not available - nothing done");
-  }
-  */
-  fCurrentVertex  = 0;   
-  SetFirstEvent(0);
-  SetLastEvent(0);
-  //  rl->LoadHeader();
-  AliITSLoader* itsLoader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  if(!filename.Contains("default"))itsLoader->SetVerticesFileName(filename);
-  if(!filename.Contains("null"))itsLoader->LoadVertices("recreate");
-
-  //  Int_t lst;
-  SetLastEvent(rl->GetNumberOfEvents()-1);
-  /*
-  if(rl->TreeE()){
-    lst = static_cast<Int_t>(rl->TreeE()->GetEntries());
-    SetLastEvent(lst-1);
-  }
-  */
+  // Default Constructor
   SetLaddersOnLayer2();
 }
 
-//______________________________________________________________________
-AliITSVertexer::AliITSVertexer(const AliITSVertexer &vtxr) : AliVertexer(vtxr),
-fLadders(), 
-fLadOnLay2(0) 
-{
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSVertexer","Copy constructor not allowed\n");
-}
-
-//______________________________________________________________________
-AliITSVertexer& AliITSVertexer::operator=(const AliITSVertexer& /* vtxr */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
-
 //______________________________________________________________________
 AliITSVertexer::~AliITSVertexer() {
   // Destructor
@@ -83,7 +34,7 @@ AliITSVertexer::~AliITSVertexer() {
 }
 
 //______________________________________________________________________
-void AliITSVertexer::FindMultiplicity(Int_t evnumber){
+void AliITSVertexer::FindMultiplicity(TTree *itsClusterTree){
   // Invokes AliITSMultReconstructor to determine the
   // charged multiplicity in the pixel layers
   if(fMult){delete fMult; fMult = 0;}
@@ -95,13 +46,9 @@ void AliITSVertexer::FindMultiplicity(Int_t evnumber){
     return;
   }
   AliITSMultReconstructor* multReco = new AliITSMultReconstructor();
-  AliRunLoader *rl =AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader = (AliITSLoader*)rl->GetLoader("ITSLoader");
-  itsLoader->LoadRecPoints();
-  rl->GetEvent(evnumber);
-  TTree* itsClusterTree = itsLoader->TreeR();
+
   if (!itsClusterTree) {
-    AliError(" Can't get the ITS cluster tree !\n");
+    AliError(" Invalid ITS cluster tree !\n");
     return;
   }
   Double_t vtx[3];
@@ -138,7 +85,7 @@ void AliITSVertexer::FindMultiplicity(Int_t evnumber){
   delete [] phs;
   delete [] labels;
   delete [] labelsL2;
-  itsLoader->UnloadRecPoints();
+
   delete multReco;
   return;
 }
@@ -148,9 +95,6 @@ void AliITSVertexer::SetLaddersOnLayer2(Int_t ladwid){
   // Calculates the array of ladders on layer 2 to be used with a 
   // given ladder on layer 1
   fLadOnLay2=ladwid;
-  //  AliRunLoader *rl =AliRunLoader::GetRunLoader();
-  //  AliITSLoader* itsLoader = (AliITSLoader*)rl->GetLoader("ITSLoader");
-  //  AliITSgeom* geom = itsLoader->GetITSgeom();
   Int_t ladtot1=AliITSgeomTGeo::GetNLadders(1);
   if(fLadders) delete [] fLadders;
   fLadders=new UShort_t[ladtot1];
@@ -185,6 +129,22 @@ void AliITSVertexer::SetLaddersOnLayer2(Int_t ladwid){
   }
 }
 
+#include "AliRunLoader.h"
+
+//______________________________________________________________________
+void AliITSVertexer::Init(TString filename){
+  // Initialize the vertexer in case of
+  // analysis of an entire file
+  AliRunLoader *rl = AliRunLoader::GetRunLoader();
+  if(!rl){
+    Fatal("AliITSVertexer","Run Loader not found");
+  }
+  if (fLastEvent < 0) SetLastEvent(rl->GetNumberOfEvents()-1);
+
+  AliITSLoader* itsloader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
+  if(!filename.Contains("default"))itsloader->SetVerticesFileName(filename);
+  if(!filename.Contains("null"))itsloader->LoadVertices("recreate");
+}
 
 //______________________________________________________________________
 void AliITSVertexer::WriteCurrentVertex(){
@@ -198,3 +158,22 @@ void AliITSVertexer::WriteCurrentVertex(){
   rc = itsLoader->WriteVertices();
 }
 
+//______________________________________________________________________
+void AliITSVertexer::FindVertices(){
+  // computes the vertices of the events in the range FirstEvent - LastEvent
+
+  AliRunLoader *rl = AliRunLoader::GetRunLoader();
+  AliITSLoader* itsloader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
+  itsloader->LoadRecPoints("read");
+  for(Int_t i=fFirstEvent;i<=fLastEvent;i++){
+    rl->GetEvent(i);
+    TTree* cltree = itsloader->TreeR();
+    FindVertexForCurrentEvent(cltree);
+    if(fCurrentVertex){
+      WriteCurrentVertex();
+    }
+    else {
+      AliDebug(1,Form("Vertex not found for event %d",i));
+    }
+  }
+}
index dea1b0445b67dcc2062d98da1ae0d992eff1cbac..7d82a04a7bb5e5483e4de952b5ee45021cfa16bf 100644 (file)
 ///////////////////////////////////////////////////////////////////
 
 class TString;
-class TClonesArray;
-
 
 class AliITSVertexer : public AliVertexer {
 
  public:
     // default constructor
     AliITSVertexer();   
-    // standard constructor     
-    AliITSVertexer(TString filename); 
     virtual ~AliITSVertexer();
-    virtual void FindMultiplicity(Int_t evnumber);
-    virtual void WriteCurrentVertex();
+    virtual AliESDVertex *FindVertexForCurrentEvent(TTree *itsClusterTree)=0;
+    virtual void PrintStatus() const = 0;
+
+    void FindMultiplicity(TTree *itsClusterTree);
+    void SetFirstEvent(Int_t ev){fFirstEvent = ev;}
+    void SetLastEvent(Int_t ev){fLastEvent = ev;}
     const Float_t GetPipeRadius()const {return fgkPipeRadius;}
-    virtual void SetLaddersOnLayer2(Int_t ladwid=4);
+    void SetLaddersOnLayer2(Int_t ladwid=4);
+
+    // Methods containing run-loaders, should be moved to some other class
+    void Init(TString filename);
+    void WriteCurrentVertex();
+    void FindVertices();
 
  protected:
+    static const Float_t fgkPipeRadius;  // beam pipe radius (cm)
+    UShort_t *fLadders; // array with layer1-layer2 ladders correspondances  
+    Int_t fLadOnLay2;   // (2*fLadOnLay2+1)=number of layer2 ladders 
+                      // associated to a layer1 ladder
+ private:
     // copy constructor (NO copy allowed: the constructor is protected
     // to avoid misuse)
     AliITSVertexer(const AliITSVertexer& vtxr);
     // assignment operator (NO assignment allowed)
     AliITSVertexer& operator=(const AliITSVertexer& /* vtxr */);
 
-    static const Float_t fgkPipeRadius;  // beam pipe radius (cm)
-    UShort_t *fLadders; // array with layer1-layer2 ladders correspondances  
-    Int_t fLadOnLay2;   // (2*fLadOnLay2+1)=number of layer2 ladders 
-                      // associated to a layer1 ladder
+    Int_t fFirstEvent;          // First event to be processed by FindVertices
+    Int_t fLastEvent;           // Last event to be processed by FindVertices 
 
-  ClassDef(AliITSVertexer,4);
+  ClassDef(AliITSVertexer,5);
 };
 
 #endif
index 7d6a11f8d3c2e3681ec43ad9366ab8a474dac4bd..c3dd5e994d0f0e8eac8794d4bffa5506d7f055ea 100644 (file)
@@ -18,8 +18,6 @@
 #include "AliLog.h"
 #include "AliStrLine.h"
 #include "AliTracker.h"
-#include "AliRunLoader.h"
-#include "AliITSLoader.h"
 #include "AliITSDetTypeRec.h"
 #include "AliITSRecPoint.h"
 #include "AliITSgeomTGeo.h"
@@ -38,7 +36,7 @@ ClassImp(AliITSVertexer3D)
 
 //______________________________________________________________________
 AliITSVertexer3D::AliITSVertexer3D():AliITSVertexer(),
-fLines(),
+fLines("AliStrLine",1000),
 fVert3D(),
 fCoarseDiffPhiCut(0.),
 fCoarseMaxRCut(0.),
@@ -62,32 +60,6 @@ fMeanPtSelTrk(0.)
   SetMeanPtSelTracks();
 }
 
-//______________________________________________________________________
-AliITSVertexer3D::AliITSVertexer3D(TString fn): AliITSVertexer(fn),
-fLines("AliStrLine",1000),
-fVert3D(),
-fCoarseDiffPhiCut(0.),     
-fCoarseMaxRCut(0.),
-fMaxRCut(0.),
-fZCutDiamond(0.),
-fMaxZCut(0.),
-fDCAcut(0.),
-fDiffPhiMax(0.),
-fMeanPSelTrk(0.),
-fMeanPtSelTrk(0.)
-{
-  // Standard constructor
-  SetCoarseDiffPhiCut();
-  SetCoarseMaxRCut();
-  SetMaxRCut();
-  SetZCutDiamond();
-  SetMaxZCut();
-  SetDCAcut();
-  SetDiffPhiMax();
-  SetMeanPSelTracks();
-  SetMeanPtSelTracks();
-}
-
 //______________________________________________________________________
 AliITSVertexer3D::~AliITSVertexer3D() {
   // Destructor
@@ -104,13 +76,13 @@ void AliITSVertexer3D::ResetVert3D(){
   fVert3D.SetNContributors(0);
 }
 //______________________________________________________________________
-AliESDVertex* AliITSVertexer3D::FindVertexForCurrentEvent(Int_t evnumber){
+AliESDVertex* AliITSVertexer3D::FindVertexForCurrentEvent(TTree *itsClusterTree){
   // Defines the AliESDVertex for the current event
   ResetVert3D();
-  AliDebug(1,Form("FindVertexForCurrentEvent - 3D - PROCESSING EVENT %d",evnumber));
+  AliDebug(1,"FindVertexForCurrentEvent - 3D - PROCESSING NEXT EVENT");
   fLines.Clear();
 
-  Int_t nolines = FindTracklets(evnumber,0);
+  Int_t nolines = FindTracklets(itsClusterTree,0);
   fCurrentVertex = 0;
   if(nolines<2)return fCurrentVertex;
   Int_t rc=Prepare3DVertex(0);
@@ -122,7 +94,7 @@ AliESDVertex* AliITSVertexer3D::FindVertexForCurrentEvent(Int_t evnumber){
   end of debug lines  */
   if(fVert3D.GetNContributors()>0){
     fLines.Clear("C");
-    nolines = FindTracklets(evnumber,1);
+    nolines = FindTracklets(itsClusterTree,1);
     if(nolines>=2){
       rc=Prepare3DVertex(1);
       if(rc==0) fVert3D=AliVertexerTracks::TrackletVertexFinder(&fLines,0);
@@ -145,24 +117,18 @@ AliESDVertex* AliITSVertexer3D::FindVertexForCurrentEvent(Int_t evnumber){
     fCurrentVertex->SetName("Vertex");
     fCurrentVertex->SetDispersion(fVert3D.GetDispersion());
   }
-  FindMultiplicity(evnumber);
+  FindMultiplicity(itsClusterTree);
   return fCurrentVertex;
 }  
 
 //______________________________________________________________________
-Int_t AliITSVertexer3D::FindTracklets(Int_t evnumber, Int_t optCuts){
+Int_t AliITSVertexer3D::FindTracklets(TTree *itsClusterTree, Int_t optCuts){
   // All the possible combinations between recpoints on layer 1and 2 are
   // considered. Straight lines (=tracklets)are formed. 
   // The tracklets are processed in Prepare3DVertex
-  AliRunLoader *rl =AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader = (AliITSLoader*)rl->GetLoader("ITSLoader");
-  //  AliITSgeom* geom = itsLoader->GetITSgeom();
-  itsLoader->LoadRecPoints();
-  rl->GetEvent(evnumber);
-
   AliITSDetTypeRec detTypeRec;
 
-  TTree *tR = itsLoader->TreeR();
+  TTree *tR = itsClusterTree;
   detTypeRec.SetTreeAddressR(tR);
   TClonesArray *itsRec  = 0;
   // lc1 and gc1 are local and global coordinates for layer 1
@@ -210,7 +176,6 @@ Int_t AliITSVertexer3D::FindTracklets(Int_t evnumber, Int_t optCuts){
     detTypeRec.ResetRecPoints();
   }
   if(nrpL1 == 0 || nrpL2 == 0){
-    itsLoader->UnloadRecPoints();
     return -1;
   }
   AliDebug(1,Form("RecPoints on Layer 1,2 = %d, %d\n",nrpL1,nrpL2));
@@ -340,22 +305,6 @@ Int_t AliITSVertexer3D::FindTracklets(Int_t evnumber, Int_t optCuts){
   return nolines;
 }
 
-//______________________________________________________________________
-void AliITSVertexer3D::FindVertices(){
-  // computes the vertices of the events in the range FirstEvent - LastEvent
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  itsLoader->ReloadRecPoints();
-  for(Int_t i=fFirstEvent;i<=fLastEvent;i++){
-    rl->GetEvent(i);
-    FindVertexForCurrentEvent(i);
-    if(fCurrentVertex){
-      WriteCurrentVertex();
-    }
-  }
-}
-
-
 //______________________________________________________________________
 Int_t  AliITSVertexer3D::Prepare3DVertex(Int_t optCuts){
   // Finds the 3D vertex information using tracklets
@@ -512,5 +461,4 @@ void AliITSVertexer3D::PrintStatus() const {
   printf("Cut on DCA - tracklet to tracklet and to vertex %f\n",fDCAcut);
   printf(" Max Phi difference: %f\n",fDiffPhiMax);
   printf("=======================================================\n");
-
 }
index 4f3a49cd4043cf524ac1feeca44d57a50eaa950b..d270cddacae30ea70fcbb7d7ce9be75a48f29627 100644 (file)
@@ -19,13 +19,9 @@ class AliITSVertexer3D : public AliITSVertexer {
  public:
 
   AliITSVertexer3D();
-  AliITSVertexer3D(TString filename);
   virtual ~AliITSVertexer3D();
-  virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb);
-  virtual void FindVertices();
+  virtual AliESDVertex* FindVertexForCurrentEvent(TTree *itsClusterTree);
   AliESDVertex GetVertex3D() const {return fVert3D;}
-//   virtual void MakeTracklet(Double_t *pA, Double_t *pB, Int_t &nolines); */
-//   virtual void MakeTracklet(Float_t *pA, Float_t *pB, Int_t &nolines); */
   virtual void PrintStatus() const;
   void SetCoarseDiffPhiCut(Float_t dphi = 0.5){fCoarseDiffPhiCut=dphi;}
   void SetCoarseMaxRCut(Float_t rad = 2.5){fCoarseMaxRCut=rad;}
@@ -41,7 +37,7 @@ class AliITSVertexer3D : public AliITSVertexer {
 protected:
   AliITSVertexer3D(const AliITSVertexer3D& vtxr);
   AliITSVertexer3D& operator=(const AliITSVertexer3D& /* vtxr */);
-  Int_t FindTracklets(Int_t evnumber, Int_t optCuts);
+  Int_t FindTracklets(TTree *itsClusterTree, Int_t optCuts);
   Int_t Prepare3DVertex(Int_t optCuts);
   void ResetVert3D();
 
@@ -58,7 +54,7 @@ protected:
   Float_t fMeanPSelTrk; // GeV, mean P for tracks with dphi<0.01 rad
   Float_t fMeanPtSelTrk; // GeV, mean Pt for tracks with dphi<0.01 rad
 
-  ClassDef(AliITSVertexer3D,4);
+  ClassDef(AliITSVertexer3D,6);
 
 };
 
index 2de134291656d7dbd607cb35f7f9489471191100..887dec742a81fad3f325979b1c1d82a939aadfa3 100644 (file)
@@ -30,7 +30,7 @@
 
 ClassImp(AliITSVertexer3DTapan)
 
-Int_t AliITSVertexer3DTapan::LoadClusters(TTree *cTree) {
+void AliITSVertexer3DTapan::LoadClusters(TTree *cTree) {
   //--------------------------------------------------------------------
   //This function loads the SPD clusters
   //--------------------------------------------------------------------
@@ -92,15 +92,14 @@ Int_t AliITSVertexer3DTapan::LoadClusters(TTree *cTree) {
    }
    ficlu1 = nc1; ficlu2 = nc2;
    AliInfo(Form("Number of clusters: %d (first layer) and %d (second layer)",ficlu1,ficlu2));
-   return 0;
 }
 
-void AliITSVertexer3DTapan::FindVertexForCurrentEvent(AliESDVertex *vtx) {
+AliESDVertex *AliITSVertexer3DTapan::FindVertexForCurrentEvent(TTree *cTree) {
   //
   // This function reconstructs ....
   //
   //
-  if (vtx==0) return; 
+  LoadClusters(cTree);
 
   Double_t pos[3], postemp[3], sigpos[3];
   Int_t ncontr, ncontrtemp;
@@ -151,8 +150,8 @@ void AliITSVertexer3DTapan::FindVertexForCurrentEvent(AliESDVertex *vtx) {
   }
   AliInfo(Form("Final step: %d %f %f %f st=%d",ncontr,pos[0],pos[1],pos[2],vtxstatus));
 
-  new(vtx) AliESDVertex(pos,sigpos,(Double_t)vtxstatus,ncontr,"AliITSVertexer3DTapan");
-  return;
+  return new AliESDVertex(pos,sigpos,(Double_t)vtxstatus,ncontr,"AliITSVertexer3DTapan");
+
 }
 
 
index 3f0c2f8c4e2854bc83541006b2530ac4fe67c92b..2d0bc7284c40787ab2d5bb65a1eb15643d56622b 100644 (file)
 //////////////////////////////////////////////////////////////////////////
 
 #include <TArrayD.h>
+#include "AliITSVertexer.h"
 
 class TTree;
 class AliESDVertex;
 class AliITSgeom;
 
-class AliITSVertexer3DTapan : public TObject {
+class AliITSVertexer3DTapan : public AliITSVertexer {
 public:
   AliITSVertexer3DTapan(Int_t n=10000):fITSgeom(0),
     fX1(n),fY1(n),fZ1(n), fPhi1(n), ficlu1(0),
@@ -37,11 +38,11 @@ public:
     fX1(n),fY1(n),fZ1(n), fPhi1(n), ficlu1(0),
     fX2(n),fY2(n),fZ2(n), fPhi2(n), ficlu2(0) {;}
   virtual ~AliITSVertexer3DTapan(){}
-
-  Int_t LoadClusters(TTree *cf);
-  void FindVertexForCurrentEvent(AliESDVertex *vtx);
+  virtual AliESDVertex *FindVertexForCurrentEvent(TTree *cTree);
+  virtual void PrintStatus() const {}
 
 protected:
+  void LoadClusters(TTree *cTree);
   void CalculatePhi(Float_t fx, Float_t fy, Float_t & phi);
   void CalculateVertex3d1(Double_t pos[3], Float_t cuts[3], Int_t &ncontr);
   void CalculateVertex3d2(Double_t pos[3], Float_t cuts[3], Int_t &ncontr, Double_t sigpos[3]);
@@ -65,7 +66,7 @@ private:
   TArrayD fPhi2;    // Phi position of cluster on layer 2 of ITS
   Int_t   ficlu2;    // Number of clusters on layer 2 of ITS
    
-  ClassDef(AliITSVertexer3DTapan,1);
+  ClassDef(AliITSVertexer3DTapan,2);
 };
 
 #endif
index 2578e29e2951ecec27743719aeea4a56dc03caf1..83d046367913ee4a0c07d98d7bd68dc9cb3de57a 100644 (file)
  **************************************************************************/
 
 #include <TClonesArray.h>
+#include <TTree.h>
 #include "AliLog.h"
 #include "AliESDVertex.h"
-#include "AliRunLoader.h"
-#include "AliITSLoader.h"
 #include "AliITSgeomTGeo.h"
 #include "AliITSRecPoint.h"
 #include "AliITSReconstructor.h"
@@ -83,20 +82,14 @@ fMinDist2Vtxs(0)
   SetMinDist2Vtxs();
 }
 //--------------------------------------------------------------------------
-AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(Int_t evnumber
+AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(TTree *itsClusterTree
 {
   // Defines the AliESDVertex for the current event
 
   fCurrentVertex = 0;
-  AliRunLoader *rl =AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader = (AliITSLoader*)rl->GetLoader("ITSLoader");
-  itsLoader->LoadRecPoints();
-  rl->GetEvent(evnumber);
-
-  TTree *rpTree = itsLoader->TreeR();
 
   TClonesArray *recpoints=new TClonesArray("AliITSRecPoint",10000);
-  rpTree->SetBranchAddress("ITSRecPoints",&recpoints);
+  itsClusterTree->SetBranchAddress("ITSRecPoints",&recpoints);
 
   Int_t lay,lad,det; 
 
@@ -114,7 +107,7 @@ AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(Int_t evnumber)
     }
     Int_t nHitModules=0;
     for(Int_t imodule=fFirst[ilayer]; imodule<=fLast[ilayer]; imodule++) {
-      rpTree->GetEvent(imodule);
+      itsClusterTree->GetEvent(imodule);
       AliITSgeomTGeo::GetModuleId(imodule,lay,lad,det);
       lay -= 1;  // AliITSgeomTGeo gives layer from 1 to 6, we want 0 to 5
       if(lay!=ilayer) AliFatal("Layer mismatch!");
@@ -136,7 +129,6 @@ AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(Int_t evnumber)
   if(ilayer>4 || ilayer2>5) {
     AliWarning("Not enough clusters");
     delete recpoints;
-    itsLoader->UnloadRecPoints();
     fCurrentVertex = new AliESDVertex(pos,err,"cosmics");
     fCurrentVertex->SetTitle("cosmics fake vertex (failed)");
     fCurrentVertex->SetNContributors(ncontributors);
@@ -165,7 +157,7 @@ AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(Int_t evnumber)
 
   // Collect clusters in the selected layer and the outer one
   for(Int_t imodule=fFirst[ilayer]; imodule<=fLast[ilayer2]; imodule++) {
-    rpTree->GetEvent(imodule);
+    itsClusterTree->GetEvent(imodule);
     AliITSgeomTGeo::GetModuleId(imodule,lay,lad,det);
     lay -= 1; // AliITSgeomTGeo gives layer from 1 to 6, we want 0 to 5
     nRecPoints=recpoints->GetEntriesFast();
@@ -201,7 +193,6 @@ AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(Int_t evnumber)
        //AliFatal("More than arrSize clusters per layer");
        AliWarning("Too many clusters per layer");
        delete recpoints;
-       itsLoader->UnloadRecPoints();
        fCurrentVertex = new AliESDVertex(pos,err,"cosmics");
        fCurrentVertex->SetTitle("cosmics fake vertex (failed)");
        fCurrentVertex->SetNContributors(ncontributors);
@@ -317,26 +308,10 @@ AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(Int_t evnumber)
   //fCurrentVertex->Print();
 
   delete recpoints;
-  itsLoader->UnloadRecPoints();
 
   return fCurrentVertex;
 }  
-//-------------------------------------------------------------------------
-void AliITSVertexerCosmics::FindVertices()
-{
-  // computes the vertices of the events in the range FirstEvent - LastEvent
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  itsLoader->ReloadRecPoints();
-  for(Int_t i=fFirstEvent;i<=fLastEvent;i++){
-    //  printf("Processing event %d\n",i);
-    rl->GetEvent(i);
-    FindVertexForCurrentEvent(i);
-    if(fCurrentVertex){
-      WriteCurrentVertex();
-    }
-  }
-}
+
 //-------------------------------------------------------------------------
 void AliITSVertexerCosmics::PrintStatus() const 
 {
index f1686e5b5922b627c5d7c0503550fbb7434ac289..301c3a2c158f156c415fdb8a98f4ebdf134c91f4 100644 (file)
@@ -20,9 +20,8 @@ class AliITSVertexerCosmics : public AliITSVertexer {
 
   AliITSVertexerCosmics();
   virtual ~AliITSVertexerCosmics() {}
-  AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb);
-  void FindVertices();
-  void PrintStatus() const;
+  virtual AliESDVertex* FindVertexForCurrentEvent(TTree *itsClusterTree);
+  virtual void PrintStatus() const;
   void SetFirstLastModules(Int_t ilayer=0,Int_t m1=0,Int_t m2=79) 
     {fFirst[ilayer] = m1; fLast[ilayer] = m2;}
   void SetMaxDistOnOuterLayer(Double_t max=0.1) {fMaxDistOnOuterLayer=max;}
@@ -40,7 +39,7 @@ class AliITSVertexerCosmics : public AliITSVertexer {
   Double_t fMaxVtxRadius[6];    // maximum radial pos of vertex
   Double_t fMinDist2Vtxs;    // minimum distance between two vertices
 
-  ClassDef(AliITSVertexerCosmics,2); // vertexer for cosmics
+  ClassDef(AliITSVertexerCosmics,4); // vertexer for cosmics
 };
 
 #endif
index e54e6142cde19545edb0f4df7071999df3a881fa..7a598449b6176be5f2bc2ca6e9fc15873123b65d 100644 (file)
@@ -70,11 +70,12 @@ AliITSVertexerFast::~AliITSVertexerFast(){
 }
 
 //______________________________________________________________________
-AliESDVertex* AliITSVertexerFast::FindVertexForCurrentEvent(Int_t evnumb){
+AliESDVertex* AliITSVertexerFast::FindVertexForCurrentEvent(TTree *itsClusterTree){
   // Defines the AliITSVertex for the current event
+  AliWarning(Form("This class should be used only with simulated events!! Input cluster tree (%p) will not be used!!",itsClusterTree));
+
   fCurrentVertex = 0;
   AliRunLoader *rl =AliRunLoader::GetRunLoader();
-  rl->GetEvent(evnumb);
   TArrayF primaryVertex(3);  // true vertex
   AliHeader* header = rl->GetAliRun()->GetHeader();
   AliGenEventHeader* genEventHeader = header->GenEventHeader();   
@@ -86,59 +87,18 @@ AliESDVertex* AliITSVertexerFast::FindVertexForCurrentEvent(Int_t evnumb){
     vrttrue[k] = static_cast<Double_t>(primaryVertex[k]);
     vrtx[k] = gRandom->Gaus(vrttrue[k],fSmear[k]);
   }
-  char name[30];
-  sprintf(name,"Vertex_%d",evnumb);
-  fCurrentVertex = new AliESDVertex(vrtx,fSmear,name);
+  fCurrentVertex = new AliESDVertex(vrtx,fSmear,"Smeared Generated Vertex");
   return fCurrentVertex;
   
 }
 
-//______________________________________________________________________
-void AliITSVertexerFast::FindVertices(){
-  // computes the vertices of the events in the range FirstEvent - LastEvent
-
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  AliITSLoader* iTSloader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  iTSloader->ReloadRecPoints();
-  for(Int_t i=fFirstEvent;i<=fLastEvent;i++){
-    rl->GetEvent(i);
-    FindVertexForCurrentEvent(i);   
-    if(fCurrentVertex) WriteCurrentVertex();
-    else {
-      cout<<"Vertex not found for event "<<i<<endl;
-
-    }
-
-  }
-
-}
-
 //________________________________________________________
 void AliITSVertexerFast::PrintStatus() const {
   // Print current status
   cout <<"=======================================================\n";
 
-  cout<<"First event to be processed "<<fFirstEvent;
-  cout<<"\n Last event to be processed "<<fLastEvent<<endl;
   cout<<"RMS for gaussian smearing: ";
   for(Int_t k=0;k<3;k++)cout<<" "<<fSmear[k];
   cout<<endl;
 }
 
-//______________________________________________________________________
-AliITSVertexerFast::AliITSVertexerFast(const AliITSVertexerFast &vtxr) : 
-  AliITSVertexer(vtxr),
-fSmear(0)  {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSVertexerFast","Copy constructor not allowed\n");
-}
-
-//______________________________________________________________________
-AliITSVertexerFast& AliITSVertexerFast::operator=(const 
-                    AliITSVertexerFast& /* vtxr */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
index 6763af844227a9eaec7aced1718df5090c1411c5..15bdb1aa7ccea7b4073aaa8306801138f423be2d 100644 (file)
@@ -20,11 +20,11 @@ class AliITSVertexerFast : public AliITSVertexer {
   AliITSVertexerFast();
   AliITSVertexerFast(Double_t *smear);
   virtual ~AliITSVertexerFast(); 
-  virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb);
-  virtual void FindVertices();
+  virtual AliESDVertex* FindVertexForCurrentEvent(TTree *itsClusterTree);
+
   virtual void PrintStatus() const;
 
- protected:
+ private:
 
   // copy constructor (NO copy allowed: the constructor is protected
   // to avoid misuse)
@@ -35,7 +35,7 @@ class AliITSVertexerFast : public AliITSVertexer {
   Double_t *fSmear;         // rms of gaussians used for smearing
 
 
-ClassDef(AliITSVertexerFast,1);
+ClassDef(AliITSVertexerFast,2);
 };
 
 #endif
index eef9f19ac0a93bf7ceba306f2680256529835a11..65f3ddb0e967b4f84ca5c3fc7a465fa6dd7ee153 100644 (file)
@@ -43,35 +43,6 @@ fMaxDeltaZ(0){
   SetMaxDeltaZ();
 }
 
-//______________________________________________________________________
-AliITSVertexerIons::AliITSVertexerIons(TString fn):AliITSVertexer(fn),
-fNpThreshold(0),
-fMaxDeltaPhi(0),
-fMaxDeltaZ(0) {
-  // Standard constructor
-  
-  //fITS = 0;
-  SetNpThreshold();
-  SetMaxDeltaPhi();
-  SetMaxDeltaZ();
-}
-/*
-//______________________________________________________________________
-AliITSVertexerIons::AliITSVertexerIons(const AliITSVertexerIons &source):AliITSVertexer(source) {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSVertexerIons","Copy constructor not allowed\n");
-}
-*/
-//_________________________________________________________________________
-//AliITSVertexerIons& AliITSVertexerIons::operator=(const AliITSVertexerIons &/*source*/) {
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  //Error("= operator","Assignment operator not allowed\n");
-  //return *this;
-//}
-
-
 //______________________________________________________________________
 AliITSVertexerIons::~AliITSVertexerIons() {
   // Default Destructor
@@ -79,24 +50,14 @@ AliITSVertexerIons::~AliITSVertexerIons() {
 }
 
 //______________________________________________________________________
-AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){ 
+AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(TTree *itsClusterTree){ 
 // Defines the AliESDVertex for the current event
 
   fCurrentVertex = 0;
 
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  AliITSLoader* itsloader = (AliITSLoader*)rl->GetLoader("ITSLoader");
-  /*
-  TDirectory * olddir = gDirectory;
-  rl->CdGAFile();
-  AliITSgeom* g2  = (AliITSgeom*)gDirectory->Get("AliITSgeom");
-  olddir->cd(); 
-  */
-
-  TTree *tr =  itsloader->TreeR();
   AliITSDetTypeRec detTypeRec;
 
-  detTypeRec.SetTreeAddressR(tr);
+  detTypeRec.SetTreeAddressR(itsClusterTree);
 
   TClonesArray  *recpoints = detTypeRec.RecPoints();
   AliITSRecPoint *pnt;
@@ -128,7 +89,7 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
   Int_t np1=0, np2=0;
   for(Int_t i=AliITSgeomTGeo::GetModuleIndex(1,1,1);i<=AliITSgeomTGeo::GetModuleIndex(2,1,1)-1;i++) {
     detTypeRec.ResetRecPoints();
-    tr->GetEvent(i);
+    itsClusterTree->GetEvent(i);
     npoints = recpoints->GetEntries();
     for (Int_t ipoint=0;ipoint<npoints;ipoint++) {
       pnt = (AliITSRecPoint*)recpoints->UncheckedAt(ipoint);
@@ -163,8 +124,8 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
   if(np1<fNpThreshold) {
     Warning("FindVertexForCurrentEvent","AliITSVertexerIons finder is not reliable for low multiplicity events. Switching to AliITSVertexerZ with default parameters...\n");
     Warning("FindVertexForCurrentEvent","N rec points = %d - Threshold is %d",np1,fNpThreshold);
-    AliITSVertexerZ *dovert = new AliITSVertexerZ("default");
-    fCurrentVertex =dovert->FindVertexForCurrentEvent(rl->GetEventNumber());
+    AliITSVertexerZ *dovert = new AliITSVertexerZ();
+    fCurrentVertex =dovert->FindVertexForCurrentEvent(itsClusterTree);
     delete dovert;
     return fCurrentVertex;
   }
@@ -235,7 +196,6 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
     Double_t resolution[3]={0,0,0};
     Double_t snr[3]={0,0,0};
     Char_t name[30];
-    AliDebug(1,Form("Vertex found for event %d",evnumber));
     sprintf(name,"Vertex");
     fCurrentVertex = new AliESDVertex(position,resolution,snr,name);
     return fCurrentVertex;
@@ -292,7 +252,6 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
   Double_t snr[3]={0,0,0};
   
   Char_t name[30];
-  AliDebug(1,Form("Vertex found for event %d",evnumber));
   sprintf(name,"Vertex");
   fCurrentVertex = new AliESDVertex(position,resolution,snr,name);
 
@@ -308,30 +267,10 @@ void AliITSVertexerIons::PhiFunc(Double_t &x,Double_t &y,Double_t &phi) {
   if(y<0 && x>0) phi=(TMath::ATan((Double_t)(y/x))*57.29578)+360;;
 }
 
-//______________________________________________________________________
-void AliITSVertexerIons::FindVertices(){
-  // computes the vertices of the events in the range FirstEvent - LastEvent
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  AliITSLoader* itsloader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  itsloader->LoadRecPoints("read");
-  for(Int_t i=fFirstEvent;i<=fLastEvent;i++){
-    rl->GetEvent(i);
-    FindVertexForCurrentEvent(i);
-    if(fCurrentVertex){
-      WriteCurrentVertex();
-    }
-    else {
-      AliDebug(1,Form("Vertex not found for event %d",i));
-    }
-  }
-}
-
 //________________________________________________________
 void AliITSVertexerIons::PrintStatus() const {
   // Print current status
   cout <<"=======================================================\n";
-  cout<<"First event to be processed "<<fFirstEvent;
-  cout<<"\n Last event to be processed "<<fLastEvent<<endl;
   if(fCurrentVertex)fCurrentVertex->PrintStatus();
 }
 
index 24e9bbdba6a85dd75a697e30fcfae87b14e089e2..edd8e816ac92b8e99c3df4f75971f956a3ae1a50 100644 (file)
@@ -26,10 +26,8 @@ class AliITSVertexerIons : public AliITSVertexer {
 
  public:
   AliITSVertexerIons();
-  AliITSVertexerIons(TString fn); 
   virtual ~AliITSVertexerIons(); // destructor
-  virtual AliESDVertex* FindVertexForCurrentEvent(Int_t event);
-  virtual void FindVertices();
+  virtual AliESDVertex* FindVertexForCurrentEvent(TTree *itsClusterTree);
   virtual void PhiFunc(Double_t &x,Double_t &y,Double_t &phi);
   virtual void PrintStatus() const;
   Int_t GetNpThreshold() const {return fNpThreshold;}
@@ -48,7 +46,7 @@ class AliITSVertexerIons : public AliITSVertexer {
   AliITSVertexerIons(const AliITSVertexerIons &source); // copy constructor (NO copy allowed: the constructor is protected to avoid misuse)   
   AliITSVertexerIons& operator=(const AliITSVertexerIons &source); // assignment operator (NO assignment allowed)
 
-  ClassDef(AliITSVertexerIons,4);
+  ClassDef(AliITSVertexerIons,5);
 };
 
 #endif
index f3edf0db3320ba5e61eb239d3e4874fb09625ac2..cd5b87357f63941ab247da096d61cbfda8a9802f 100644 (file)
@@ -18,8 +18,7 @@
 #include<TH1.h>
 #include <TString.h>
 #include<TTree.h>
-#include "AliRunLoader.h"
-#include "AliITSLoader.h"
+#include "AliESDVertex.h"
 #include "AliITSgeomTGeo.h"
 #include "AliITSDetTypeRec.h"
 #include "AliITSRecPoint.h"
@@ -67,7 +66,7 @@ fWindowWidth(0) {
 }
 
 //______________________________________________________________________
-AliITSVertexerZ::AliITSVertexerZ(TString fn, Float_t x0, Float_t y0):AliITSVertexer(fn),
+AliITSVertexerZ::AliITSVertexerZ(Float_t x0, Float_t y0):AliITSVertexer(),
 fFirstL1(0),
 fLastL1(0),
 fFirstL2(0),
@@ -97,35 +96,6 @@ fWindowWidth(0) {
 
 }
 
-//______________________________________________________________________
-AliITSVertexerZ::AliITSVertexerZ(const AliITSVertexerZ &vtxr) : AliITSVertexer(vtxr),
-fFirstL1(vtxr.fFirstL1),
-fLastL1(vtxr.fLastL1),
-fFirstL2(vtxr.fFirstL2),
-fLastL2(vtxr.fLastL2),
-fDiffPhiMax(vtxr.fDiffPhiMax),
-fZFound(vtxr.fZFound),
-fZsig(vtxr.fZsig),
-fZCombc(vtxr.fZCombc),
-fLowLim(vtxr.fLowLim),
-fHighLim(vtxr.fHighLim),
-fStepCoarse(vtxr.fStepCoarse),
-fTolerance(vtxr.fTolerance),
-fMaxIter(vtxr.fMaxIter),
-fWindowWidth(vtxr.fWindowWidth){
-  // Copy constructor
-
-}
-
-//______________________________________________________________________
-AliITSVertexerZ& AliITSVertexerZ::operator=(const AliITSVertexerZ&  vtxr ){
-  // Assignment operator
-
-  this->~AliITSVertexerZ();
-  new(this) AliITSVertexerZ(vtxr);
-  return *this;
-}
-
 //______________________________________________________________________
 AliITSVertexerZ::~AliITSVertexerZ() {
   // Destructor
@@ -197,36 +167,30 @@ Int_t AliITSVertexerZ::GetPeakRegion(TH1F*h, Int_t &binmin, Int_t &binmax) const
   return npeaks;
 }
 //______________________________________________________________________
-AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
+AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(TTree *itsClusterTree){
   // Defines the AliESDVertex for the current event
-  VertexZFinder(evnumber);
+  VertexZFinder(itsClusterTree);
   Int_t ntrackl=0;
   for(Int_t iteraz=0;iteraz<fMaxIter;iteraz++){
     if(fCurrentVertex) ntrackl=fCurrentVertex->GetNContributors();
     if(!fCurrentVertex || ntrackl==0 || ntrackl==-1){
       Float_t diffPhiMaxOrig=fDiffPhiMax;
       fDiffPhiMax=GetPhiMaxIter(iteraz);
-      VertexZFinder(evnumber);
+      VertexZFinder(itsClusterTree);
       fDiffPhiMax=diffPhiMaxOrig;
     }
   }
-  FindMultiplicity(evnumber);
+  FindMultiplicity(itsClusterTree);
   return fCurrentVertex;
 }  
 
 //______________________________________________________________________
-void AliITSVertexerZ::VertexZFinder(Int_t evnumber){
+void AliITSVertexerZ::VertexZFinder(TTree *itsClusterTree){
   // Defines the AliESDVertex for the current event
   fCurrentVertex = 0;
-  AliRunLoader *rl =AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader = (AliITSLoader*)rl->GetLoader("ITSLoader");
-  //  AliITSgeom* geom = itsLoader->GetITSgeom();
-  itsLoader->LoadRecPoints();
-  rl->GetEvent(evnumber);
-
   AliITSDetTypeRec detTypeRec;
 
-  TTree *tR = itsLoader->TreeR();
+  TTree *tR = itsClusterTree;
   detTypeRec.SetTreeAddressR(tR);
   TClonesArray *itsRec  = 0;
   // lc1 and gc1 are local and global coordinates for layer 1
@@ -257,7 +221,6 @@ void AliITSVertexerZ::VertexZFinder(Int_t evnumber){
   }
   if(nrpL1 == 0 || nrpL2 == 0){
     ResetHistograms();
-    itsLoader->UnloadRecPoints();
     fCurrentVertex = new AliESDVertex(0.,5.3,-2);
     return;
   }
@@ -303,8 +266,8 @@ void AliITSVertexerZ::VertexZFinder(Int_t evnumber){
       // Global coordinates of this recpoints
       */
       recp->GetGlobalXYZ(gc1);
-      gc1[0]-=fNominalPos[0]; // Possible beam offset in the bending plane
-      gc1[1]-=fNominalPos[1]; //   "               "
+      gc1[0]-=GetNominalPos()[0]; // Possible beam offset in the bending plane
+      gc1[1]-=GetNominalPos()[1]; //   "               "
       Float_t r1=TMath::Sqrt(gc1[0]*gc1[0]+gc1[1]*gc1[1]);
       Float_t phi1 = TMath::ATan2(gc1[1],gc1[0]);
       if(phi1<0)phi1+=2*TMath::Pi();
@@ -325,8 +288,8 @@ void AliITSVertexerZ::VertexZFinder(Int_t evnumber){
            geom->LtoG(modul2,lc2,gc2);
            */
            recp->GetGlobalXYZ(gc2);
-           gc2[0]-=fNominalPos[0];
-           gc2[1]-=fNominalPos[1];
+           gc2[0]-=GetNominalPos()[0];
+           gc2[1]-=GetNominalPos()[1];
            Float_t r2=TMath::Sqrt(gc2[0]*gc2[0]+gc2[1]*gc2[1]);
            Float_t phi2 = TMath::ATan2(gc2[1],gc2[0]);
            if(phi2<0)phi2+=2*TMath::Pi();
@@ -361,7 +324,6 @@ void AliITSVertexerZ::VertexZFinder(Int_t evnumber){
   if(contents<1.){
     //    Warning("FindVertexForCurrentEvent","Insufficient number of rec. points\n");
     ResetHistograms();
-    itsLoader->UnloadRecPoints();
     fCurrentVertex = new AliESDVertex(0.,5.3,-1);
     points.Clear();
     return;
@@ -413,7 +375,6 @@ void AliITSVertexerZ::VertexZFinder(Int_t evnumber){
   fCurrentVertex->SetTitle("vertexer: B");
   points.Clear();
   ResetHistograms();
-  itsLoader->UnloadRecPoints();
   return;
 }
 
@@ -424,22 +385,6 @@ void AliITSVertexerZ::ResetHistograms(){
   fZCombc = 0;
 }
 
-//______________________________________________________________________
-void AliITSVertexerZ::FindVertices(){
-  // computes the vertices of the events in the range FirstEvent - LastEvent
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  AliITSLoader* itsLoader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  itsLoader->ReloadRecPoints();
-  for(Int_t i=fFirstEvent;i<=fLastEvent;i++){
-    //  cout<<"Processing event "<<i<<endl;
-    rl->GetEvent(i);
-    FindVertexForCurrentEvent(i);
-    if(fCurrentVertex){
-      WriteCurrentVertex();
-    }
-  }
-}
-
 //________________________________________________________
 void AliITSVertexerZ::PrintStatus() const {
   // Print current status
@@ -452,8 +397,6 @@ void AliITSVertexerZ::PrintStatus() const {
   cout <<"Limits for Z histograms: "<<fLowLim<<"; "<<fHighLim<<endl;
   cout <<"Bin sizes for coarse z histos "<<fStepCoarse<<endl;
   cout <<" Current Z "<<fZFound<<"; Z sig "<<fZsig<<endl;
-  cout <<"First event to be processed "<<fFirstEvent;
-  cout <<"\n Last event to be processed "<<fLastEvent<<endl;
   if(fZCombc){
     cout<<"fZCombc exists - entries="<<fZCombc->GetEntries()<<endl;
   }
index d95c7cc9568efc8885ff4492bf8eaea141e1047e..99d10ada2806e78251ee641547efe449dfa3a884 100644 (file)
@@ -19,7 +19,7 @@ class AliITSVertexerZ : public AliITSVertexer {
  public:
 
   AliITSVertexerZ();
-  AliITSVertexerZ(TString filename,Float_t x0=0., Float_t y0=0.);
+  AliITSVertexerZ(Float_t x0, Float_t y0);
   virtual ~AliITSVertexerZ();
   // The number of contributors set in the AliESDVertex object is the
   // number of tracklets used to determine the vertex position
@@ -27,8 +27,7 @@ class AliITSVertexerZ : public AliITSVertexer {
   // and by default the Z coordinate is set to 0
   // Number of contributors = -1  --> No tracklets 
   // Number of contributors = -2  --> No SPD recpoints
-  virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb);
-  virtual void FindVertices();
+  virtual AliESDVertex* FindVertexForCurrentEvent(TTree *itsClusterTree);
   virtual void PrintStatus() const;
   void SetDiffPhiMax(Float_t pm = 0.01){fDiffPhiMax = pm;}
   void ConfigIterations(Int_t noiter=3,Float_t *ptr=0);
@@ -47,10 +46,8 @@ class AliITSVertexerZ : public AliITSVertexer {
   Float_t GetTolerance() const {return fTolerance;}
   //  virtual void MakeTracklet(Double_t * /* pA */, Double_t * /*pB */, Int_t & /* nolines */) {} // implemented in a derived class
  protected:
-  AliITSVertexerZ(const AliITSVertexerZ& vtxr);
-  AliITSVertexerZ& operator=(const AliITSVertexerZ& vtxr );
   void ResetHistograms();
-  void VertexZFinder(Int_t evnumber);
+  void VertexZFinder(TTree *itsClusterTree);
   Float_t GetPhiMaxIter(Int_t i) const {return fPhiDiffIter[i];}
 
 
@@ -70,8 +67,11 @@ class AliITSVertexerZ : public AliITSVertexer {
   Int_t fMaxIter;            // Maximum number of iterations (<=5)
   Float_t fPhiDiffIter[5];   // Delta phi used in iterations
   Float_t fWindowWidth;      // Z window width for symmetrization
+ private:
+  AliITSVertexerZ(const AliITSVertexerZ& vtxr);
+  AliITSVertexerZ& operator=(const AliITSVertexerZ& vtxr );
 
-  ClassDef(AliITSVertexerZ,7);
+  ClassDef(AliITSVertexerZ,10);
 };
 
 #endif
index 9e0d2d0e018f22484d843c411af465cce3123f99..9c70bb291025d7a090dd1feb6c1cc3583eee3f2f 100644 (file)
@@ -42,13 +42,16 @@ void AliITSVertexerZTest(Float_t delphi=0.05,Float_t window=3.,Float_t initx=0.,
   
   AliGeomManager::LoadGeometry("geometry.root");
 
-  AliITSVertexerZ *dovert = new AliITSVertexerZ("default",initx,inity);
+  AliITSVertexerZ *dovert = new AliITSVertexerZ(initx,inity);
+  dovert->Init("default");
   //dovert->SetDebug(0);
   //  dovert->SetDiffPhiMax(delphi);
   //  dovert->SetWindow(window);
   dovert->PrintStatus();
   Int_t sigmazero=0;
   AliESDVertex *vert = 0;
+  AliITSLoader* itsloader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
+  itsloader->LoadRecPoints("read");
   for(Int_t i=0; i<rl->TreeE()->GetEntries(); i++){
     rl->GetEvent(i);
     // The true Z coord. is fetched for comparison
@@ -56,7 +59,8 @@ void AliITSVertexerZTest(Float_t delphi=0.05,Float_t window=3.,Float_t initx=0.,
     AliGenEventHeader* genEventHeader = header->GenEventHeader();
     TArrayF primaryVertex(3);
     genEventHeader->PrimaryVertex(primaryVertex);
-    vert = dovert->FindVertexForCurrentEvent(i);
+    TTree* cltree = itsloader->TreeR();
+    vert = dovert->FindVertexForCurrentEvent(cltree);
     if(kDebug>0){
       // Prints the results
       cout <<"========================================================\n";
index f8df7ee59a99fe8740f913a137d2b8fe90e54fc7..5b54f2d172bf73bce02e7393581a73795bccde4f 100644 (file)
@@ -88,8 +88,10 @@ Bool_t DoVerticesSPD(Int_t optdebug=1){
 //   tree->SetBranchAddress("ESD", &esd);
 
   Double_t xnom=0.,ynom=0.;
-  AliITSVertexerZ *vertz = new AliITSVertexerZ("default",xnom,ynom);
-  AliITSVertexer3D *vert3d = new AliITSVertexer3D("default");
+  AliITSVertexerZ *vertz = new AliITSVertexerZ(xnom,ynom);
+  vertz->Init("default");
+  AliITSVertexer3D *vert3d = new AliITSVertexer3D();
+  vert3d->Init("default");
   //  vert3d->SetDebug(10);
   //  vertz->ConfigIterations(5);
 
@@ -130,7 +132,9 @@ Bool_t DoVerticesSPD(Int_t optdebug=1){
     }
     if(optdebug) printf(" dNch/dy = %f\n",dNchdy);
  
-    AliESDVertex* vtxz = vertz->FindVertexForCurrentEvent(iEvent);
+    TTree* cltree = ITSloader->TreeR();
+
+    AliESDVertex* vtxz = vertz->FindVertexForCurrentEvent(cltree);
     AliMultiplicity *alimult = vertz->GetMultiplicity();
     Int_t ntrklets=0,nrecp1=0;
     if(alimult) {
@@ -141,7 +145,7 @@ Bool_t DoVerticesSPD(Int_t optdebug=1){
       }
     }
 
-    AliESDVertex* vtx3d = vert3d->FindVertexForCurrentEvent(iEvent);
+    AliESDVertex* vtx3d = vert3d->FindVertexForCurrentEvent(cltree);
 
     TDirectory *current = gDirectory;
     fint->cd();
index 86b7bab6ed706f398b5c7454c11606544a459a23..572eba98edd6fbacdb5c0be59e4ebcaa59ccb46c 100644 (file)
@@ -29,7 +29,7 @@ extern "C" {
 
 #ifdef ALI_AMORE
 #include <AmoreDA.h>
-int amore::da::Updated(char const*) {}
+//int amore::da::Updated(char const*) {}
 #endif
 
 #include <TTree.h>
@@ -179,9 +179,7 @@ int main(int argc, char **argv) {
 
       // Run vertex-finder
       AliITSVertexer3DTapan *vertexer = new AliITSVertexer3DTapan(geom,1000);
-      vertexer->LoadClusters(clustersTree);
-      AliESDVertex *vtx = new AliESDVertex();
-      vertexer->FindVertexForCurrentEvent(vtx);
+      AliESDVertex *vtx = vertexer->FindVertexForCurrentEvent(clustersTree);
 
       if (TMath::Abs(vtx->GetChi2()) < 0.1) {
        // Fill the vertex into the histos
index 3d8c9a6e4097e7462449c30539870a33ffd8f27d..72f35db12f00cb5ff6dfd35442a505deab2bac3e 100644 (file)
@@ -1535,11 +1535,22 @@ Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
   }
 
   if (fVertexer) {
-    if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
     AliInfo("running the ITS vertex finder");
-    if (fLoader[0]) fLoader[0]->LoadRecPoints();
-    vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
-    if (fLoader[0]) fLoader[0]->UnloadRecPoints();
+    if (fLoader[0]) {
+      fLoader[0]->LoadRecPoints();
+      TTree* cltree = fLoader[0]->TreeR();
+      if (cltree) {
+       if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
+       vertex = fVertexer->FindVertexForCurrentEvent(cltree);
+      }
+      else {
+       AliError("Can't get the ITS cluster tree");
+      }
+      fLoader[0]->UnloadRecPoints();
+    }
+    else {
+      AliError("Can't get the ITS loader");
+    }
     if(!vertex){
       AliWarning("Vertex not found");
       vertex = new AliESDVertex();
index 4b41e37d984f82aa32cf1f4a0e819aae6613385c..cad4a0e9c052b40908473e091edcc9fcaca39f81 100644 (file)
@@ -18,6 +18,7 @@
 #include "AliLog.h"
 #include "AliESDVertex.h"
 #include "AliVertexer.h"
+#include "AliMultiplicity.h"
 
 ClassImp(AliVertexer)
 
@@ -30,10 +31,8 @@ ClassImp(AliVertexer)
 
 //______________________________________________________________________
 AliVertexer::AliVertexer() :
-  fCurrentVertex(0),
-  fFirstEvent(0),
-  fLastEvent(0),
-  fMult()
+  fCurrentVertex(NULL),
+  fMult(NULL)
 {
   //
   // Default Constructor
@@ -42,38 +41,11 @@ AliVertexer::AliVertexer() :
   for(Int_t i=0;i<6;i++)fNominalCov[i]=0.;
 }
 
-
-//______________________________________________________________________
-AliVertexer::AliVertexer(const AliVertexer &vtxr) : 
-  TObject(vtxr),
-  fCurrentVertex(vtxr.fCurrentVertex),
-  fFirstEvent(vtxr.fFirstEvent),
-  fLastEvent(vtxr.fLastEvent),
-  fMult(vtxr.fMult)
-{
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  AliFatal("Copy constructor not allowed");
-}
-
-//______________________________________________________________________
-AliVertexer& AliVertexer::operator=(const AliVertexer& /* vtxr */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  AliFatal("Assignment operator not allowed");
-  return *this;
-}
-
 //______________________________________________________________________
 AliVertexer::~AliVertexer() {
   // Default Destructor
 
   if(fMult) delete fMult;
-  // The objects pointed by the following pointers are not owned
-  // by this class and are not deleted
-
-    fCurrentVertex  = 0;
-
 }
 
 
index 2d2a05c5f21ed296317a8036ed7133c3b2e5aee3..adc2ddd651858654bd50c23493741f7d9792e900 100644 (file)
@@ -1,19 +1,17 @@
 #ifndef ALIVERTEXER_H
 #define ALIVERTEXER_H
 
-#include<TObject.h>
-#include<AliMultiplicity.h>
-
 ///////////////////////////////////////////////////////////////////
 //                                                               //
 // Base class for primary vertex reconstruction                  //
 //                                                               //
 ///////////////////////////////////////////////////////////////////
 
-class TFile;
-class TString;
-class TTRee;
+#include<TObject.h>
+
+class TTree;
 class AliESDVertex;
+class AliMultiplicity;
 
 
 class AliVertexer : public TObject {
@@ -23,40 +21,36 @@ class AliVertexer : public TObject {
     AliVertexer();  
  
     // destructor
-    virtual ~AliVertexer(); 
+    virtual ~AliVertexer();
     // computes the vertex for the current event
-    virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb)=0; 
+    virtual AliESDVertex* FindVertexForCurrentEvent(TTree *clustersTree)=0; 
     // computes the vertex for each event and stores it on file
-    virtual void FindVertices()= 0;
-    virtual AliMultiplicity* GetMultiplicity() const {return fMult;}
+    AliMultiplicity* GetMultiplicity() const {return fMult;}
     virtual void PrintStatus() const = 0;
-    virtual void SetFirstEvent(Int_t ev){fFirstEvent = ev;}
-    virtual void SetLastEvent(Int_t ev){fLastEvent = ev;}
-    virtual void SetVtxStart(Double_t x,Double_t y,Double_t z) 
-           { fNominalPos[0]=x; fNominalPos[1]=y; fNominalPos[2]=z; }
-    virtual void SetVtxStartSigma(Double_t sx,Double_t sy,Double_t sz) 
-           { fNominalCov[0]=sx*sx; fNominalCov[2]=sy*sy; fNominalCov[5]=sz*sz;
-             fNominalCov[1]=0.; fNominalCov[3]=0.; fNominalCov[4]=0.; }
-    virtual void SetVtxStart(AliESDVertex *vtx);
-    virtual void WriteCurrentVertex() = 0;
+    void SetVtxStart(Double_t x,Double_t y,Double_t z) 
+      { fNominalPos[0]=x; fNominalPos[1]=y; fNominalPos[2]=z; }
+    void SetVtxStartSigma(Double_t sx,Double_t sy,Double_t sz) 
+      { fNominalCov[0]=sx*sx; fNominalCov[2]=sy*sy; fNominalCov[5]=sz*sz;
+      fNominalCov[1]=0.; fNominalCov[3]=0.; fNominalCov[4]=0.; }
+    void SetVtxStart(AliESDVertex *vtx);
+
+    const Double_t* GetNominalPos() const {return fNominalPos;}
 
  protected:
+    AliESDVertex *fCurrentVertex; //! pointer to the current vertex
+    AliMultiplicity *fMult;     //! Multiplicity object
+ private:
     // copy constructor (NO copy allowed: the constructor is protected
     // to avoid misuse)
     AliVertexer(const AliVertexer& vtxr);
     // assignment operator (NO assignment allowed)
     AliVertexer& operator=(const AliVertexer& /* vtxr */);
 
-    AliESDVertex *fCurrentVertex;  //! pointer to the vertex of the current
-                                   //  event
-    Int_t fFirstEvent;          // First event to be processed by FindVertices
-    Int_t fLastEvent;           // Last event to be processed by FindVertices 
     Double_t  fNominalPos[3];   // initial knowledge on vertex position
     Double_t  fNominalCov[6];   // initial knowledge on vertex position
-    AliMultiplicity *fMult;     //! Multiplicity object
 
-  ClassDef(AliVertexer,3);
+  ClassDef(AliVertexer,4);
 };
 
 #endif