#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)
///////////////////////////////////////////////////////////////////////
//______________________________________________________________________
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++){
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
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();
}
//______________________________________________________________________
fAverPosSq[i][j] += currentPos[i] * currentPos[j];
}
}
+
+ fVertexXY->Fill(currentPos[0],currentPos[1]);
+ fVertexZ->Fill(currentPos[2]);
+
fNoEventsContr++;
}
/* $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
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);
};
#include <AliITSVertexer3DTapan.h>
#include <AliITSRecPoint.h>
-#include <AliITSgeom.h>
+#include <AliITSgeomTGeo.h>
#include <AliESDVertex.h>
ClassImp(AliITSVertexer3DTapan)
// 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--) {
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(){}
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
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
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"
//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) {
"TStreamerInfo",
"RIO",
"TStreamerInfo()");
- TFitter *minuitFit = new TFitter(NFITPARAMS);
- TVirtualFitter::SetFitter(minuitFit);
int status;
if (argc<2) {
}
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
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 */
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);
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);
-}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff