Update of the meanvertexer: possibility of calling AliITSVertexer3DTapan, added histo...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Sep 2008 16:13:34 +0000 (16:13 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Sep 2008 16:13:34 +0000 (16:13 +0000)
ITS/AliITSMeanVertexer.cxx
ITS/AliITSMeanVertexer.h
ITS/AliITSVertexer3DTapan.cxx
ITS/AliITSVertexer3DTapan.h
ITS/ITSSPDVertexDiamondda.cxx

index 47135002a60ef8aa7c0b46ef6b101e2c7513fc7b..95e5adad343c55044397f02628e061a82305d5c1 100644 (file)
@@ -1,6 +1,7 @@
 #include <TFile.h>
+#include <TH1.h>
+#include <TH2.h>
 #include "AliGeomManager.h"
-#include "AliHeader.h"
 #include "AliITSDetTypeRec.h"
 #include "AliITSInitGeometry.h"
 #include "AliITSMeanVertexer.h"
 #include "AliRawReaderRoot.h"
 #include "AliRunLoader.h"
 #include "AliITSVertexer3D.h"
+#include "AliITSVertexer3DTapan.h"
 #include "AliESDVertex.h"
 #include "AliMeanVertex.h"
 #include "AliMultiplicity.h"
 
-const TString AliITSMeanVertexer::fgkMVFileNameDefault = "MeanVertex.root";
-
-
 ClassImp(AliITSMeanVertexer)
 
 ///////////////////////////////////////////////////////////////////////
@@ -40,18 +39,15 @@ ClassImp(AliITSMeanVertexer)
 
 //______________________________________________________________________
 AliITSMeanVertexer::AliITSMeanVertexer():TObject(),
-fLoaderFileName(),
-fGeometryFileName(),
-fMVFileName(),
-fRawReader(),
-fRunLoader(),
+fDetTypeRec(NULL),
+fVertexXY(NULL),
+fVertexZ(NULL),
 fNoEventsContr(0),
 fTotTracklets(0.),
 fAverTracklets(0.),
 fSigmaOnAverTracks(0.), 
 fFilterOnContributors(0),
-fFilterOnTracklets(0),
-fWriteVertices(kFALSE)
+fFilterOnTracklets(0)
 {
   // Default Constructor
   for(Int_t i=0;i<3;i++){
@@ -60,208 +56,93 @@ fWriteVertices(kFALSE)
     fAverPos[i] = 0.;
     for(Int_t j=0; j<3;j++)fAverPosSq[i][j] = 0.;
   }
-  
-}
-
-//______________________________________________________________________
-AliITSMeanVertexer::AliITSMeanVertexer(TString &filename):TObject(),
-fLoaderFileName(),
-fGeometryFileName(),
-fMVFileName(fgkMVFileNameDefault),
-fRawReader(),
-fRunLoader(),
-fNoEventsContr(0),
-fTotTracklets(0.),
-fAverTracklets(0.),
-fSigmaOnAverTracks(0.), 
-fFilterOnContributors(0),
-fFilterOnTracklets(0),
-fWriteVertices(kTRUE)
-{
-  // Standard constructor
-
-  for(Int_t i=0;i<3;i++){
-    fWeighPos[i] = 0.;
-    fWeighSig[i] = 0.;
-    fAverPos[i] = 0.;
-    for(Int_t j=0; j<3;j++)fAverPosSq[i][j] = 0.;
-  }
-  SetLoaderFileName();
-  SetGeometryFileName();
 
-  Init(filename);
-}
-//______________________________________________________________________
-AliITSMeanVertexer::AliITSMeanVertexer(TString &filename, 
-                                       TString &loaderfilename, 
-                                      TString &geometryfilename):TObject(),
-fLoaderFileName(),
-fGeometryFileName(),
-fMVFileName(fgkMVFileNameDefault),
-fRawReader(),
-fRunLoader(),
-fNoEventsContr(0), 
-fTotTracklets(0.),
-fAverTracklets(0.),
-fSigmaOnAverTracks(0.), 
-fFilterOnContributors(0),
-fFilterOnTracklets(0),
-fWriteVertices(kTRUE)
-{
-  // Standard constructor with explicit geometry file name assignment
-  for(Int_t i=0;i<3;i++){
-    fWeighPos[i] = 0.;
-    fWeighSig[i] = 0.;
-    fAverPos[i] = 0.;
-    for(Int_t j=0; j<3;j++)fAverPosSq[i][j] = 0.;
-  }
-  SetLoaderFileName(loaderfilename);
-  SetGeometryFileName(geometryfilename);
-  Init(filename);
+  // Histograms initialization
+  const Float_t xLimit = 2.0, yLimit = 2.0, zLimit = 50.0;
+  const Float_t xDelta = 0.02, yDelta = 0.02, zDelta = 0.2;
+  fVertexXY = new TH2F("VertexXY","Vertex Diamond (Y vs X)",
+                      2*(Int_t)(xLimit/xDelta),-xLimit,xLimit,
+                      2*(Int_t)(yLimit/yDelta),-yLimit,yLimit);
+  fVertexZ  = new TH1F("VertexZ"," Longitudinal Vertex Profile",
+                      2*(Int_t)(zLimit/zDelta),-zLimit,zLimit);
 }
 
 //______________________________________________________________________
-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");
-  }
-  // if file name ends with root a raw reader ROOT is assumed
-  if(filename.EndsWith(".root")){
-    fRawReader = new AliRawReaderRoot(filename);
-  }
-  else {  // DATE raw reader is assumed
-    fRawReader = new AliRawReaderDate(filename);
-  }
-  fRunLoader = AliRunLoader::Open(fLoaderFileName.Data(),AliConfig::GetDefaultEventFolderName(),"recreate");
-  fRunLoader->MakeTree("E");
-  Int_t iEvent = 0;
-  while (fRawReader->NextEvent()) {
-    fRunLoader->SetEventNumber(iEvent);
-    fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(), 
-                                  iEvent, iEvent);
-    fRunLoader->MakeTree("H");
-    fRunLoader->TreeE()->Fill();
-    iEvent++;
-  }
-  fRawReader->RewindEvents();
-  fRunLoader->SetNumberOfEventsPerFile(iEvent);
-  fRunLoader->WriteHeader("OVERWRITE");
- Int_t retval = AliConfig::Instance()->AddDetector(fRunLoader->GetEventFolder(),"ITS","ITS");
- if(retval != 0)AliFatal("Not able to add ITS detector");
-  AliITSLoader *loader = new AliITSLoader("ITS",fRunLoader->GetEventFolder()->GetName());
-  fRunLoader->AddLoader(loader);
-  fRunLoader->CdGAFile();
-  fRunLoader->Write(0, TObject::kOverwrite);
+Bool_t AliITSMeanVertexer::Init() {
+  // Initialize filters
   // Initialize geometry
+  // Initialize ITS classes
  
-  AliGeomManager::LoadGeometry(fGeometryFileName.Data());
+  AliGeomManager::LoadGeometry();
+  if (!AliGeomManager::ApplyAlignObjsFromCDB("ITS")) return kFALSE;
 
   AliITSInitGeometry initgeom;
   AliITSgeom *geom = initgeom.CreateAliITSgeom();
+  if (!geom) return kFALSE;
   printf("Geometry name: %s \n",(initgeom.GetGeometryName()).Data());
-  loader->SetITSgeom(geom);
+
+  AliITSDetTypeRec *fDetTypeRec = new AliITSDetTypeRec();
+  fDetTypeRec->SetITSgeom(geom);
+  fDetTypeRec->SetDefaults();
+  fDetTypeRec->SetDefaultClusterFindersV2(kTRUE);
+
   // Initialize filter values to their defaults
   SetFilterOnContributors();
   SetFilterOnTracklets();
-}
-
-//______________________________________________________________________
-AliITSMeanVertexer::AliITSMeanVertexer(const AliITSMeanVertexer &vtxr) : TObject(vtxr),
-fLoaderFileName(vtxr.fLoaderFileName),
-fGeometryFileName(vtxr.fGeometryFileName),
-fMVFileName(vtxr.fMVFileName),
-fRawReader(vtxr.fRawReader),
-fRunLoader(vtxr.fRunLoader),
-fNoEventsContr(vtxr.fNoEventsContr),
-fTotTracklets(vtxr.fTotTracklets),
-fAverTracklets(vtxr.fAverTracklets),
-fSigmaOnAverTracks(vtxr.fSigmaOnAverTracks),  
-fFilterOnContributors(vtxr.fFilterOnContributors),
-fFilterOnTracklets(vtxr.fFilterOnTracklets),
-fWriteVertices(vtxr.fWriteVertices)
-{
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  AliFatal("Copy constructor not allowed\n");
 
-}
-
-//______________________________________________________________________
-AliITSMeanVertexer& AliITSMeanVertexer::operator=(const AliITSMeanVertexer&  /* vtxr */ ){
-  // Assignment operator
-  AliError("Assignment operator not allowed\n");
-  return *this;
+  return kTRUE;
 }
 
 //______________________________________________________________________
 AliITSMeanVertexer::~AliITSMeanVertexer() {
   // Destructor
-  delete fRawReader;
-  delete fRunLoader;
-
+  delete fDetTypeRec;
+  delete fVertexXY;
+  delete fVertexZ;
 }
 
 //______________________________________________________________________
-void AliITSMeanVertexer::Reconstruct(){
+Bool_t AliITSMeanVertexer::Reconstruct(AliRawReader *rawReader, Bool_t mode){
   // Performs SPD local reconstruction
-  AliITSLoader* loader = static_cast<AliITSLoader*>(fRunLoader->GetLoader("ITSLoader"));
-  if (!loader) {
-    AliFatal("ITS loader not found");
-    return;
+  // and vertex finding
+  // returns true in case a vertex is found
+
+  // Run SPD cluster finder
+  TTree* clustersTree = new TTree("TreeR", "Reconstructed Points Container"); //make a tree
+  fDetTypeRec->DigitsToRecPoints(rawReader,clustersTree,"SPD");
+
+  Bool_t vtxOK = kFALSE;
+  AliESDVertex *vtx = NULL;
+  // Run Tapan's vertex-finder
+  if (!mode) {
+    AliITSVertexer3DTapan *vertexer1 = new AliITSVertexer3DTapan(1000);
+    vtx = vertexer1->FindVertexForCurrentEvent(clustersTree);
+    delete vertexer1;
+    if (TMath::Abs(vtx->GetChi2()) < 0.1) vtxOK = kTRUE;
   }
-  AliITSDetTypeRec* rec = new AliITSDetTypeRec();
-  rec->SetITSgeom(loader->GetITSgeom());
-  rec->SetDefaults();
-
-  rec->SetDefaultClusterFindersV2(kTRUE);
-
-  Int_t nEvents = fRunLoader->GetNumberOfEvents();
-  fRawReader->RewindEvents();
-  for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
-    fRawReader->NextEvent();
-    fRunLoader->GetEvent(iEvent);
-    AliDebug(1,Form(">>>>>>>   Processing event number: %d",iEvent));
-    loader->LoadRecPoints("update");
-    loader->CleanRecPoints();
-    loader->MakeRecPointsContainer();
-    TTree *tR = loader->TreeR();
-    if(!tR){
-      AliFatal("Tree R pointer not found - Abort \n");
-      break;
-    }
-    rec->DigitsToRecPoints(fRawReader,tR,"SPD");
-    rec->ResetRecPoints();
-    rec->ResetClusters();    
-    loader->WriteRecPoints("OVERWRITE");
-    loader->UnloadRecPoints();
+  else {
+  // Run standard vertexer3d
+    AliITSVertexer3D *vertexer2 = new AliITSVertexer3D();
+    AliESDVertex *vtx = vertexer2->FindVertexForCurrentEvent(clustersTree);
+    AliMultiplicity *mult = vertexer2->GetMultiplicity();
+    delete vertexer2;
+    if(Filter(vtx,mult)) vtxOK = kTRUE;
   }
+  delete clustersTree;
+  if (vtxOK) AddToMean(vtx);
+  if (vtx) delete vtx;
 
+  return vtxOK;
 }
 
 //______________________________________________________________________
-void AliITSMeanVertexer::DoVertices(){
-  // Loop on all events and compute 3D vertices
-  AliITSLoader* loader = static_cast<AliITSLoader*>(fRunLoader->GetLoader("ITSLoader"));
-  AliITSVertexer3D *dovert = new AliITSVertexer3D();
-  AliESDVertex *vert = 0;
-  Int_t nevents = fRunLoader->TreeE()->GetEntries();
-  for(Int_t i=0; i<nevents; i++){
-    fRunLoader->GetEvent(i);
-    TTree* cltree = loader->TreeR();
-    vert = dovert->FindVertexForCurrentEvent(cltree);
-    AliMultiplicity *mult = dovert->GetMultiplicity();
-    if(Filter(vert,mult)){
-      AddToMean(vert); 
-      if(fWriteVertices){
-       loader->PostVertex(vert);
-       loader->WriteVertices();
-      }
-    }
-    else {
-      if(vert)delete vert;
-    }
-  }
+void AliITSMeanVertexer::WriteVertices(const char *filename){
+  // Compute mean vertex and
+  // store it along with the histograms
+  // in a file
+  
+  TFile fmv(filename,"update");
+
   if(ComputeMean()){
     Double_t cov[6];
     cov[0] =  fAverPosSq[0][0];  // variance x
@@ -270,19 +151,24 @@ void AliITSMeanVertexer::DoVertices(){
     cov[3] =  fAverPosSq[0][2];  // cov xz
     cov[4] =  fAverPosSq[1][2];  // cov yz
     cov[5] =  fAverPosSq[2][2];  // variance z
-    AliMeanVertex mv(fWeighPos,fWeighSig,cov,nevents,fTotTracklets,fAverTracklets,fSigmaOnAverTracks);
+    AliMeanVertex mv(fWeighPos,fWeighSig,cov,fNoEventsContr,fTotTracklets,fAverTracklets,fSigmaOnAverTracks);
     mv.SetTitle("Mean Vertex");
-    mv.SetName("Meanvertex");
+    mv.SetName("MeanVertex");
     AliDebug(1,Form("Contrib av. trk = %10.2f ",mv.GetAverageNumbOfTracklets()));
     AliDebug(1,Form("Sigma %10.4f ",mv.GetSigmaOnAvNumbOfTracks()));
-    TFile fmv(fMVFileName.Data(),"recreate");
-    mv.Write();
-    fmv.Close();
+    // we have to add chi2 here
+    AliESDVertex vtx(fWeighPos,cov,0,fAverTracklets,"MeanVertexPos");
+
+    mv.Write(mv.GetName(),TObject::kOverwrite);
+    vtx.Write(vtx.GetName(),TObject::kOverwrite);
   }
   else {
     AliError(Form("Evaluation of mean vertex not possible. Number of used events = %d",fNoEventsContr));
   }
-  delete dovert;
+
+  fVertexXY->Write(fVertexXY->GetName(),TObject::kOverwrite);
+  fVertexZ->Write(fVertexZ->GetName(),TObject::kOverwrite);
+  fmv.Close();
 }
 
 //______________________________________________________________________
@@ -319,6 +205,10 @@ void AliITSMeanVertexer::AddToMean(AliESDVertex *vert){
       fAverPosSq[i][j] += currentPos[i] * currentPos[j];
     }
   }
+
+  fVertexXY->Fill(currentPos[0],currentPos[1]);
+  fVertexZ->Fill(currentPos[2]);
+
   fNoEventsContr++;
 }
 
index 7c0fda26b70123f1d7feae4e6266fe0f9e0fec97..b9a9e760c9c6206aec1b79bb165298820790167a 100644 (file)
 /* $Id$ */
 
 class TObject;
+class TH1F;
+class TH2F;
 class AliRawReader;
-class AliRunLoader;
 class AliMultiplicity;
 class AliESDVertex;
 
 class AliITSMeanVertexer : public TObject {
 
  public:
-    // default constructor
+  // default constructor
     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);   
-    // constructor with explicit assignment of names for geometry and loaders
-    AliITSMeanVertexer(TString &filename, TString &loaderfilename, 
-                       TString &geometryfilename);
     virtual ~AliITSMeanVertexer();
-    void SetLoaderFileName(TString fn="ITSMeanVertexer.root")
-                           {fLoaderFileName = fn;}
-    void SetGeometryFileName(TString fn="geometry.root")
-                           {fGeometryFileName = fn;}
-    void SetMeanVertexFileName(TString fn) {fMVFileName = fn;}
-    void SetFilterOnContributors(Int_t nc=1){fFilterOnContributors = nc;}
-    void SetFilterOnTracklets(Int_t nc=1){fFilterOnTracklets = nc;}
-    void SetWriteVertices(Bool_t action){fWriteVertices = action;}
-    Bool_t GetWriteVertices() const {return fWriteVertices;}
-    void Reconstruct();
-    void DoVertices();
+    Bool_t Init();
+    void   SetFilterOnContributors(Int_t nc=1){fFilterOnContributors = nc;}
+    void   SetFilterOnTracklets(Int_t nc=1){fFilterOnTracklets = nc;}
+    Bool_t Reconstruct(AliRawReader *rawReader, Bool_t mode = kTRUE);
+    void   WriteVertices(const char *filename);
 
  
- protected:
-    // copy constructor (NO copy allowed: the constructor is protected
-    // to avoid misuse)
+ private:
+    // copy constructor (NO copy allowed)
     AliITSMeanVertexer(const AliITSMeanVertexer& vtxr);
     // assignment operator (NO assignment allowed)
     AliITSMeanVertexer& operator=(const AliITSMeanVertexer& /* vtxr */);
-    void Init(TString &filename);  // initialization invoked by constructors
+
     Bool_t Filter(AliESDVertex *vert,AliMultiplicity *mult);
-    void AddToMean(AliESDVertex *vert);
+    void   AddToMean(AliESDVertex *vert);
     Bool_t ComputeMean();
 
-    static const TString fgkMVFileNameDefault;  //! default for fMVFileName
-    TString fLoaderFileName;   //! name of the local file containing loaders
-    TString fGeometryFileName; //! name of the file containing the geometry
-    TString fMVFileName;       //! name of the file containing the mean vertex
-    AliRawReader *fRawReader;  //! rawreader object
-    AliRunLoader *fRunLoader;  //! run loader
+    AliITSDetTypeRec *fDetTypeRec; //! ITS reco class
+    TH2F    *fVertexXY;        //! histogram with transverse vertex distribution (vertex diamond)
+    TH1F    *fVertexZ;         //! histogram with longitudinal vertex distribution
+
     Double_t fWeighPos[3];     //! weighted average position
     Double_t fWeighSig[3];     //! errors on weighted average position
     Double_t fAverPos[3];      //! average position
@@ -70,7 +58,6 @@ class AliITSMeanVertexer : public TObject {
     Float_t fSigmaOnAverTracks; //! RMS of fAverTracklets
     Int_t fFilterOnContributors; //! Numb. of contrib must be > fFilter...
     Int_t fFilterOnTracklets; //! Numb. of tracklets must be > fFilterOnTr...
-    Bool_t fWriteVertices; //! if kTRUE all the vertices are saved to a file
 
   ClassDef(AliITSMeanVertexer,0);
 };
index 887dec742a81fad3f325979b1c1d82a939aadfa3..57b20d9e62573d3b31a35737945261b4d73b6d78 100644 (file)
@@ -25,7 +25,7 @@
 
 #include <AliITSVertexer3DTapan.h>
 #include <AliITSRecPoint.h>
-#include <AliITSgeom.h>
+#include <AliITSgeomTGeo.h>
 #include <AliESDVertex.h>
 
 ClassImp(AliITSVertexer3DTapan)
@@ -49,22 +49,10 @@ void AliITSVertexer3DTapan::LoadClusters(TTree *cTree) {
        //         local cluster X"-axis
        //
 
-       //       Double_t rot[9];   fITSgeom->GetRotMatrix(i,rot);
-       Int_t    lay,lad,det; fITSgeom->GetModuleId(i,lay,lad,det);
+       Int_t    lay,lad,det; AliITSgeomTGeo::GetModuleId(i,lay,lad,det);
 
        if (lay>2) break;  //load the SPD clusters only
 
-       /*
-       Float_t  tx,ty,tz;  fITSgeom->GetTrans(lay,lad,det,tx,ty,tz);
-
-       Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
-       Double_t phi=TMath::Pi()/2+alpha;
-
-       if (lay==1) phi+=TMath::Pi();
-       Double_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
-       Double_t r=tx*cp+ty*sp;
-       */
-
        Int_t ncl=clusters->GetEntriesFast();
        Float_t hPhi;
        while (ncl--) {
index 2d0bc7284c40787ab2d5bb65a1eb15643d56622b..14210e10a96c4adea5198063e2b001bf2bc6e73c 100644 (file)
 
 class TTree;
 class AliESDVertex;
-class AliITSgeom;
 
 class AliITSVertexer3DTapan : public AliITSVertexer {
 public:
-  AliITSVertexer3DTapan(Int_t n=10000):fITSgeom(0),
-    fX1(n),fY1(n),fZ1(n), fPhi1(n), ficlu1(0),
-    fX2(n),fY2(n),fZ2(n), fPhi2(n), ficlu2(0) {;}
-  AliITSVertexer3DTapan(const AliITSgeom *g, Int_t n=10000): fITSgeom(g),
+  AliITSVertexer3DTapan(Int_t n=10000):
     fX1(n),fY1(n),fZ1(n), fPhi1(n), ficlu1(0),
     fX2(n),fY2(n),fZ2(n), fPhi2(n), ficlu2(0) {;}
   virtual ~AliITSVertexer3DTapan(){}
@@ -52,8 +48,6 @@ private:
   AliITSVertexer3DTapan(AliITSVertexer3DTapan &);
   AliITSVertexer3DTapan& operator=(const AliITSVertexer3DTapan &);
 
-  const AliITSgeom *fITSgeom;   //the ITS geometry  
-
   TArrayD fX1;     // X position of cluster on layer 1 of ITS
   TArrayD fY1;     // Y position of cluster on layer 1 of ITS
   TArrayD fZ1;     // Z position of cluster on layer 1 of ITS
@@ -66,7 +60,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,2);
+  ClassDef(AliITSVertexer3DTapan,3);
 };
 
 #endif
index 572eba98edd6fbacdb5c0be59e4ebcaa59ccb46c..4964252d871540c4b60b668467f2e57d6a33b391 100644 (file)
@@ -9,16 +9,9 @@ Output Files:
 Trigger types used: PHYSICS
 */
 
-#define X_LIMIT 2.0
-#define Y_LIMIT 2.0
-#define Z_LIMIT 50.0
-#define X_DELTA 0.02
-#define Y_DELTA 0.02
-#define Z_DELTA 0.2
 #define OUTPUT_FILE "SPDVertexDiamondDA.root"
 #define CDB_STORAGE "local://$ALICE_ROOT"
 #define N_EVENTS_AUTOSAVE 50
-#define NFITPARAMS 5
 
 extern "C" {
 #include "daqDA.h"
@@ -32,26 +25,11 @@ extern "C" {
 //int amore::da::Updated(char const*) {}
 #endif
 
-#include <TTree.h>
-#include <TH1.h>
-#include <TH2.h>
-#include <TF2.h>
-#include <TFile.h>
 #include <TPluginManager.h>
 #include <TROOT.h>
-#include <TFitter.h>
 
 #include "AliRawReaderDate.h"
-#include "AliGeomManager.h"
 #include "AliCDBManager.h"
-#include "AliESDVertex.h"
-#include "AliITSDetTypeRec.h"
-#include "AliITSInitGeometry.h"
-#include "AliITSVertexer3DTapan.h"
-
-TF2 *fitFcn = 0x0;
-
-AliESDVertex* FitVertexDiamond(TH2F *hXY, TH1F *hZ);
 
 int main(int argc, char **argv) {
 
@@ -60,8 +38,6 @@ int main(int argc, char **argv) {
                                        "TStreamerInfo",
                                        "RIO",
                                        "TStreamerInfo()"); 
-  TFitter *minuitFit = new TFitter(NFITPARAMS);
-  TVirtualFitter::SetFitter(minuitFit);
 
   int status;
   if (argc<2) {
@@ -105,29 +81,17 @@ int main(int argc, char **argv) {
   }
   int runNr = atoi(getenv("DATE_RUN_NUMBER"));
 
-  // Histograms initialization
-  TH2F *hXY = new TH2F("hXY","Vertex Diamond (Y vs X)",
-                      2*(Int_t)(X_LIMIT/X_DELTA),-X_LIMIT,X_LIMIT,
-                      2*(Int_t)(Y_LIMIT/Y_DELTA),-Y_LIMIT,Y_LIMIT);
-  TH1F *hZ  = new TH1F("hZ"," Longitudinal Vertex Profile",
-                      2*(Int_t)(Z_LIMIT/Z_DELTA),-Z_LIMIT,Z_LIMIT);
-
   // Global initializations
   AliCDBManager *man = AliCDBManager::Instance();
   man->SetDefaultStorage(CDB_STORAGE);
   man->SetRun(runNr);
-  AliGeomManager::LoadGeometry("geometry.root");
-  AliGeomManager::ApplyAlignObjsFromCDB("ITS");
-
-  // ITS initializations
-  AliITSInitGeometry initgeom;
-  AliITSgeom *geom = initgeom.CreateAliITSgeom();
-  printf("Geometry name: %s\n",(initgeom.GetGeometryName()).Data());
 
-  AliITSDetTypeRec *detTypeRec = new AliITSDetTypeRec();
-  detTypeRec->SetITSgeom(geom);
-  detTypeRec->SetDefaults();
-  detTypeRec->SetDefaultClusterFindersV2(kTRUE);
+  // Init mean vertexer
+  AliITSMeanVertexer *mv = new AliITSMeanVertexer();
+  if (!mv->Init()) {
+    printf("Initialization of mean vertexer object failed ! Check the log for details");
+    return -1;
+  }
 
   // Initialization of AMORE sender
 #ifdef ALI_AMORE
@@ -173,43 +137,14 @@ int main(int argc, char **argv) {
       nevents_physics++;
       AliRawReader *rawReader = new AliRawReaderDate((void*)event);
 
-      // Run SPD cluster finder
-      TTree* clustersTree = new TTree("TreeR", "Reconstructed Points Container"); //make a tree
-      detTypeRec->DigitsToRecPoints(rawReader,clustersTree,"SPD");
-
-      // Run vertex-finder
-      AliITSVertexer3DTapan *vertexer = new AliITSVertexer3DTapan(geom,1000);
-      AliESDVertex *vtx = vertexer->FindVertexForCurrentEvent(clustersTree);
+      // Run mean-vertexer reco
+      if (mv->Reconstruct(rawReader)) nevents_with_vertex++;
 
-      if (TMath::Abs(vtx->GetChi2()) < 0.1) {
-       // Fill the vertex into the histos
-       nevents_with_vertex++;
-       hXY->Fill(vtx->GetXv(),vtx->GetYv());
-       hZ->Fill(vtx->GetZv());
+      // Auto save
+      if ((nevents_physics%N_EVENTS_AUTOSAVE) == 0)
+       mv->WriteVertices(OUTPUT_FILE);
 
-       // Auto save
-       if ((nevents_with_vertex%N_EVENTS_AUTOSAVE) == 0) {
-         TFile outFile(OUTPUT_FILE, "update");
-         AliESDVertex *fitVtx = FitVertexDiamond(hXY,hZ);
-         if (fitVtx) {
-           fitVtx->Write(fitVtx->GetName(),TObject::kOverwrite);
-           TH1 *fithXY = fitFcn->CreateHistogram();
-           fithXY->Write(fithXY->GetName(),TObject::kOverwrite);
-           delete fithXY;
-         }
-         hXY->Write(hXY->GetName(),TObject::kOverwrite);
-         hZ->Write(hZ->GetName(),TObject::kOverwrite);
-         outFile.Close();
-         delete fitVtx;
-       }
-      }
-
-      delete vtx;
-      delete vertexer;
-
-      delete clustersTree;
       delete rawReader;
-
     }
     
     /* free resources */
@@ -221,33 +156,16 @@ int main(int argc, char **argv) {
       break;
     }
   }
-  
-  if (detTypeRec) delete detTypeRec;
 
-  // Store the final histograms
-  TFile outFile(OUTPUT_FILE, "update");
-  if (nevents_with_vertex > N_EVENTS_AUTOSAVE) { 
-    // Fit XY & Z histograms
-    AliESDVertex *fitVtx = FitVertexDiamond(hXY,hZ);
-    if (fitVtx) {
-      fitVtx->Write(fitVtx->GetName(),TObject::kOverwrite);
-      TH1 *fithXY = fitFcn->CreateHistogram();
-      fithXY->Write(fithXY->GetName(),TObject::kOverwrite);
-      delete fithXY;
-    }
-    delete fitVtx;
-  }
-  hXY->Write(hXY->GetName(),TObject::kOverwrite);
-  hZ->Write(hZ->GetName(),TObject::kOverwrite);
-  outFile.Close();
+  mv->WriteVertices(OUTPUT_FILE);
 
 #ifdef ALI_AMORE
   // send the histos to AMORE pool
-  printf("AMORE send status: %d",vtxAmore.Send(hXY->GetName(),hXY));
+  printf("AMORE send status: %d",vtxAmore.Send(mv->GetVertexXY()->GetName(),mv->GetVertexXY()));
+  printf("AMORE send status: %d",vtxAmore.Send(mv->GetVertexZ()->GetName(),mv->GetVertexZ()));
 #endif
 
-  delete minuitFit;
-  TVirtualFitter::SetFitter(0);
+  delete mv;
 
   /* write report */
   printf("Run #%s, received %d events with vertex, out of %d physics and out of %d total events\n",getenv("DATE_RUN_NUMBER"),nevents_with_vertex,nevents_physics,nevents_total);
@@ -261,42 +179,3 @@ int main(int argc, char **argv) {
   
   return status;
 }
-
-Double_t fitFunction(Double_t *x, Double_t *par) {
-
-  Double_t t1 =   x[0] - par[1];
-  Double_t t2 =   x[1] - par[2];
-
-  return par[0]*TMath::Exp(-0.5*(t1*t1/(par[3]*par[3])+t2*t2/(par[4]*par[4])));
-}
-
-AliESDVertex* FitVertexDiamond(TH2F *hXY, TH1F *hZ)
-{
-
-  if (!fitFcn) {
-    fitFcn = new TF2("fitFcn",fitFunction,
-                    -X_LIMIT,X_LIMIT,
-                    -Y_LIMIT,Y_LIMIT,NFITPARAMS);
-    fitFcn->SetNpx(2*(Int_t)(X_LIMIT/X_DELTA));
-    fitFcn->SetNpy(2*(Int_t)(Y_LIMIT/Y_DELTA));
-    fitFcn->SetParameters(hXY->GetMaximum(),0,0,hXY->GetRMS(1),hXY->GetRMS(2));
-    fitFcn->Update();
-  }
-
-  if (hXY->Fit("fitFcn","L0V+") != 0) {
-    printf("XY fit failed!");
-    return 0x0;
-  }
-  
-  Double_t pos[3],poserr[3];
-  pos[0] = fitFcn->GetParameter(1);
-  pos[1] = fitFcn->GetParameter(2);
-  poserr[0] = fitFcn->GetParameter(3);
-  poserr[1] = fitFcn->GetParameter(4);
-
-  // Could be replaced by something more robust...
-  pos[2] = hZ->GetMean();
-  poserr[2] = hZ->GetRMS();
-  return new AliESDVertex(pos,poserr);
-}