Enable multievent run reconstruction (M.Ivanov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jul 2001 15:07:43 +0000 (15:07 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jul 2001 15:07:43 +0000 (15:07 +0000)
ITS/AliITStrackerV2.cxx
ITS/AliITStrackerV2.h
TPC/AliBarrelReconstruction.C

index 1d80bb0..3b447b2 100644 (file)
@@ -40,11 +40,13 @@ extern TRandom *gRandom;
 AliITStrackerV2::AliITSlayer AliITStrackerV2::fLayers[kMaxLayer]; // ITS layers
 
 AliITStrackerV2::
-AliITStrackerV2(const AliITSgeom *geom) throw (const Char_t *) {
+AliITStrackerV2(const AliITSgeom *geom, Int_t eventn) throw (const Char_t *) {
   //--------------------------------------------------------------------
   //This is the AliITStracker constructor
   //It also reads clusters from a root file
   //--------------------------------------------------------------------
+  fEventN = eventn;  //MI change add event number  - used to generate identifier 
   fYV=fZV=0.;
 
   AliITSgeom *g=(AliITSgeom*)geom;
@@ -90,7 +92,12 @@ if (phi<0) phi += 2*TMath::Pi();
 
   try {
      //Read clusters
-     TTree *cTree=(TTree*)gDirectory->Get("cTree");
+    //MI change 
+    char   cname[100]; 
+    sprintf(cname,"TreeC_ITS_%d",eventn);
+     TTree *cTree=(TTree*)gDirectory->Get(cname);
+    //     TTree *cTree=(TTree*)gDirectory->Get("cTree");
+
      if (!cTree) throw 
         ("AliITStrackerV2::AliITStrackerV2 can't get cTree !\n");
 
@@ -156,8 +163,13 @@ Int_t AliITStrackerV2::Clusters2Tracks(const TFile *inp, TFile *out) {
      return 2;
   }
 
-  in->cd();
-  TTree *tpcTree=(TTree*)in->Get("TPCf");
+  in->cd(); 
+  //
+  char   tname[100];
+  sprintf(tname,"TreeT_TPC_%d",fEventN);
+  TTree *tpcTree=(TTree*)in->Get(tname);
+  //TTree *tpcTree=(TTree*)in->Get("TPCf");
+
   if (!tpcTree) {
      cerr<<"AliITStrackerV2::Clusters2Tracks() ";
      cerr<<"can't get a tree with TPC tracks !\n";
@@ -249,8 +261,8 @@ cout<<fBestTrack.GetNumberOfClusters()<<" number of clusters\n\n";
     }
 
   }
-
-  itsTree.Write();
+  sprintf(tname,"TreeT_ITS_%d",fEventN);
+  itsTree.Write(tname);
   savedir->cd();
   cerr<<"Number of TPC tracks: "<<nentr<<endl;
   cerr<<"Number of prolonged tracks: "<<ntrk<<endl;
index f76d827..b524f73 100644 (file)
@@ -21,14 +21,14 @@ class TFile;
 class AliITStrackerV2 : public AliTracker {
 public:
   AliITStrackerV2():AliTracker(){}
-  AliITStrackerV2(const AliITSgeom *geom) throw (const Char_t *);
+  AliITStrackerV2(const AliITSgeom *geom, Int_t event) throw (const Char_t *);
 
   AliCluster *GetCluster(Int_t index) const;
   Int_t Clusters2Tracks(const TFile *in, TFile *out);
   Int_t PropagateBack(const TFile *in, TFile *out);
 
 private:
-
+  Int_t fEventN;  //event number
   Double_t GetEffectiveThickness(Double_t phi, Double_t z) const;
 
   void  FollowProlongation();
index d77ba45..aeccbef 100644 (file)
   #include "AliITStrackerV2.h"
 #endif
 
-Int_t TPCFindClusters(const Char_t *inname, const Char_t *outname);
-Int_t TPCFindTracks(const Char_t *inname, const Char_t *outname);
-Int_t TPCSortTracks(const Char_t *inname, const Char_t *outname);
+Int_t TPCFindClusters(const Char_t *inname, const Char_t *outname, Int_t n);
+Int_t TPCFindTracks(const Char_t *inname, const Char_t *outname, Int_t n);
+Int_t TPCSortTracks(const Char_t *inname, const Char_t *inname2, const Char_t *outname,  Int_t n);
 Int_t TPCPropagateBack(const Char_t *inname, const Char_t *outname);
 
-Int_t ITSFindClusters(const Char_t *inname, const Char_t *outname);
-Int_t ITSFindTracks(const Char_t *inname, const Char_t *outname);
+Int_t ITSFindClusters(const Char_t *inname,  const Char_t *outname, Int_t n);
+Int_t ITSFindTracks(const Char_t *inname, const Char_t *inname2, const Char_t *outname, Int_t n);
 Int_t ITSPropagateBack(const Char_t *inname, const Char_t *outname);
 
 
-Int_t AliBarrelReconstruction() {
+Int_t AliBarrelReconstruction(Int_t n) {
    const Char_t *TPCdigName="rfio:galice.root";
    const Char_t *TPCclsName="AliTPCclusters.root";
    const Char_t *TPCtrkName="AliTPCtracks.root";
+   const Char_t *TPCtrkNameS="AliTPCtracksSorted.root";
+
 
    const Char_t *ITSdigName="rfio:galice.root";
    const Char_t *ITSclsName="AliITSclustersV2.root";
@@ -45,41 +47,44 @@ Int_t AliBarrelReconstruction() {
 
    AliKalmanTrack::SetConvConst(100/0.299792458/0.2/gAlice->Field()->Factor());
 
+    
 // ********** Find TPC clusters *********** //
-   if (TPCFindClusters(TPCdigName,TPCclsName)) {
+   if (TPCFindClusters(TPCdigName,TPCclsName, n)) {
       cerr<<"Failed to get TPC clusters !\n";
       return 1;
    }      
 
 // ********** Find TPC tracks *********** //
-   if (TPCFindTracks(TPCclsName,TPCtrkName)) {
+    if (TPCFindTracks(TPCclsName,TPCtrkName,n)) {
       cerr<<"Failed to get TPC tracks !\n";
       return 1;
-   }
-
+    }
+  
 // ********** Sort and label TPC tracks *********** //
-   if (TPCSortTracks(TPCclsName,TPCtrkName)) {
+   if (TPCSortTracks(TPCclsName,TPCtrkName,TPCtrkNameS,n)) {
       cerr<<"Failed to sort TPC tracks !\n";
       return 1;
-   }
-
+    }
+   
 // ********** Find ITS clusters *********** //
-   if (ITSFindClusters(ITSdigName,ITSclsName)) {
+   if (ITSFindClusters(ITSdigName,ITSclsName,n)) {
       cerr<<"Failed to get ITS clusters !\n";
       return 1;
    }
-
+   
 // ********** Find ITS tracks *********** //
-   {TFile *clsFile=TFile::Open(ITSclsName);
-   if (ITSFindTracks(TPCtrkName,ITStrkName)) {
+   {
+     //TFile *clsFile=TFile::Open(ITSclsName);
+   if (ITSFindTracks(TPCtrkNameS,ITSclsName,ITStrkName,n)) {
       cerr<<"Failed to get ITS tracks !\n";
       return 1;
    }
-   clsFile->Close();}
-
+   //clsFile->Close();
+   }
+   return 1;
 // ********** Back propagation of the ITS tracks *********** //
    {TFile *clsFile=TFile::Open(ITSclsName);
-   if (ITSPropagateBack(ITStrkName,TPCtrkName)) {
+   if (ITSPropagateBack(ITStrkName,TPCtrkNameS)) {
       cerr<<"Failed to propagate back the ITS tracks !\n";
       return 1;
    }
@@ -98,7 +103,7 @@ Int_t AliBarrelReconstruction() {
 }
 
 
-Int_t TPCFindClusters(const Char_t *inname, const Char_t *outname) {
+Int_t TPCFindClusters(const Char_t *inname, const Char_t *outname, Int_t n) {
    Int_t rc=0;
    const Char_t *name="TPCFindClusters";
    cerr<<'\n'<<name<<"...\n";
@@ -112,8 +117,12 @@ Int_t TPCFindClusters(const Char_t *inname, const Char_t *outname) {
    AliTPCv2 tpc;
    tpc.SetParam(param);
 
-   tpc.Digits2Clusters(out);
-
+   //tpc.Digits2Clusters(out); //MI change
+   for (Int_t i=0;i<n;i++){
+     printf("Processing event %d\n",i);
+     tpc.Digits2Clusters(out,i);
+     //         AliTPCclusterer::Digits2Clusters(dig, out, i);
+   }
    in->Close();
    out->Close();
    gBenchmark->Stop(name);
@@ -122,7 +131,7 @@ Int_t TPCFindClusters(const Char_t *inname, const Char_t *outname) {
    return rc;
 }
 
-Int_t TPCFindTracks(const Char_t *inname, const Char_t *outname) {
+Int_t TPCFindTracks(const Char_t *inname, const Char_t *outname, Int_t n) {
    Int_t rc=0;
    const Char_t *name="TPCFindTracks";
    cerr<<'\n'<<name<<"...\n";
@@ -132,10 +141,18 @@ Int_t TPCFindTracks(const Char_t *inname, const Char_t *outname) {
    AliTPCParam *param=(AliTPCParam *)in->Get("75x40_100x60");
    if (!param) {cerr<<"TPC parameters have not been found !\n"; return 1;}
 
-   AliTPCtracker *tracker=new AliTPCtracker(param);
-   rc=tracker->Clusters2Tracks(0,out);
-   delete tracker;
+   //AliTPCtracker *tracker=new AliTPCtracker(param);
+   //rc=tracker->Clusters2Tracks(0,out);
+   //delete tracker;
+
+   for (Int_t i=0;i<n;i++){
+     printf("Processing event %d\n",i);
+     AliTPCtracker *tracker = new AliTPCtracker(param,i);
+     //Int_t rc=
+       tracker->Clusters2Tracks(0,out);
+     delete tracker;
+   }
+
    in->Close();
    out->Close();
    gBenchmark->Stop(name);
@@ -143,57 +160,71 @@ Int_t TPCFindTracks(const Char_t *inname, const Char_t *outname) {
 
    return rc;
 }
-
-Int_t TPCSortTracks(const Char_t *inname, const Char_t *outname) {
+Int_t TPCSortTracks(const Char_t *inname, const Char_t *inname2, const Char_t * outname,  Int_t eventn){
    Int_t rc=0;
    const Char_t *name="TPCSortTracks";
    cerr<<'\n'<<name<<"...\n";
    gBenchmark->Start(name);
 
-   TFile *out=TFile::Open(outname);
-   TFile *in =TFile::Open(inname);
-   AliTPCParam *param=(AliTPCParam *)in->Get("75x40_100x60");
+   TFile *out =TFile::Open(outname,"recreate");
+   TFile *in1 =TFile::Open(inname);
+   TFile *in2 =TFile::Open(inname2);
+
+
+   AliTPCParam *param=(AliTPCParam *)in1->Get("75x40_100x60");
    if (!param) {cerr<<"TPC parameters have not been found !\n"; return 1;}
 
-   TObjArray tarray(10000);
-   AliTPCtrack *iotrack=0;
-   Int_t i;
 
-   out->cd();
-   TTree *tracktree=(TTree*)out->Get("TPCf");
-   TBranch *tbranch=tracktree->GetBranch("tracks");
-   Int_t nentr=(Int_t)tracktree->GetEntries();
-   for (i=0; i<nentr; i++) {
+
+   // loop over events 
+   for (Int_t event=0;event<eventn; event++){
+     TObjArray tarray(10000);
+     AliTPCtrack *iotrack=0;
+     Int_t i;
+
+
+     in2->cd();
+     char   tname[100];
+     sprintf(tname,"TreeT_TPC_%d",event);
+
+     TTree *tracktree=(TTree*)in2->Get(tname);
+     TBranch *tbranch=tracktree->GetBranch("tracks");
+     Int_t nentr=(Int_t)tracktree->GetEntries();
+     for (i=0; i<nentr; i++) {
        iotrack=new AliTPCtrack;
        tbranch->SetAddress(&iotrack);
        tracktree->GetEvent(i);
        tarray.AddLast(iotrack);
-   }   
-   tarray.Sort();
-   out->Close();
-   
-   //assign thacks GEANT labels
-   in->cd();
-   AliTPCtracker *tracker = new AliTPCtracker(param);
-   tracker->LoadInnerSectors();
-   tracker->LoadOuterSectors();
-   for (i=0; i<nentr; i++) {
+     }   
+     tarray.Sort();
+     // in2->Close();
+     
+     //assign thacks GEANT labels
+     in1->cd();
+     AliTPCtracker *tracker = new AliTPCtracker(param,event);
+     tracker->LoadInnerSectors();
+     tracker->LoadOuterSectors();
+     for (i=0; i<nentr; i++) {
        iotrack=(AliTPCtrack*)tarray.UncheckedAt(i);
        tracker->CookLabel(iotrack,0.1);
-   }   
-   delete tracker;
-   in->Close();
-   //end of GEANT label assignment
-
-   out=TFile::Open(outname,"recreate");
-   tracktree=new TTree("TPCf","Tree with TPC tracks");
-   tracktree->Branch("tracks","AliTPCtrack",&iotrack,32000,0);
-   for (i=0; i<nentr; i++) {
+     }   
+     delete tracker;
+     //in->Close();
+     //end of GEANT label assignment
+     
+     tracktree=new TTree(tname,"Tree with TPC tracks");
+     tracktree->Branch("tracks","AliTPCtrack",&iotrack,32000,0);
+     for (i=0; i<nentr; i++) {
        iotrack=(AliTPCtrack*)tarray.UncheckedAt(i);
        tracktree->Fill();
+     }
+     out->cd();
+     tracktree->Write();
    }
-   tracktree->Write();
+
    out->Close();
+   in2->Close();
+   in1->Close();
 
    gBenchmark->Stop(name);
    gBenchmark->Show(name);
@@ -201,7 +232,7 @@ Int_t TPCSortTracks(const Char_t *inname, const Char_t *outname) {
    return rc;
 }
 
-Int_t ITSFindClusters(const Char_t *inname, const Char_t *outname) {
+Int_t ITSFindClusters(const Char_t *inname, const Char_t *outname, Int_t n) {
    Int_t rc=0;
    const Char_t *name="ITSFindClusters";
    cerr<<'\n'<<name<<"...\n";
@@ -213,42 +244,65 @@ Int_t ITSFindClusters(const Char_t *inname, const Char_t *outname) {
       cerr<<"Can't get gAlice !\n";
       return 1;
    }
-   Int_t ev=0;
-   gAlice->GetEvent(ev);
+
    AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
    if (!ITS) { cerr<<"Can't get the ITS !\n"; return 1;}
-
-   gAlice->MakeTree("R"); ITS->MakeBranch("R",0);
-   //////////////// Taken from ITSHitsToFastPoints.C ///////////////////////
-   AliITSsimulationFastPoints *sim = new AliITSsimulationFastPoints();
-   for (Int_t i=0;i<3;i++) { ITS->SetSimulationModel(i,sim); }
-   Int_t nsignal=25;
-   Int_t size=-1;
-   Int_t bgr_ev=Int_t(ev/nsignal);
-   ITS->HitsToFastRecPoints(ev,bgr_ev,size," ","All"," ");
-   //////////////////////////////////////////////////////////////////////////
-
-   gAlice->GetEvent(ev);
-
    AliITSgeom *geom=ITS->GetITSgeom();
-   out->cd();
+   out->cd();   
    geom->Write();
-
-   TClonesArray *clusters=new TClonesArray("AliITSclusterV2",10000);
-   TTree *cTree=new TTree("cTree","ITS clusters");
-   cTree->Branch("Clusters",&clusters);
-
-   TTree *pTree=gAlice->TreeR();
-   if (!pTree) { cerr<<"Can't get TreeR !\n"; return 1; }
-   TBranch *branch=pTree->GetBranch("ITSRecPoints");
-   if (!branch) { cerr<<"Can't get ITSRecPoints branch !\n"; return 1;}
-   TClonesArray *points=new TClonesArray("AliITSRecPoint",10000);
-   branch->SetAddress(&points);
-
-   TClonesArray &cl=*clusters;
-   Int_t nclusters=0;
-   Int_t nentr=(Int_t)pTree->GetEntries();
-   for (Int_t i=0; i<nentr; i++) {
+     
+   Int_t ev=0;
+   for (ev = 0; ev<n; ev++){
+     in->cd();   // !!!! MI directory must point to galice. - othervise problem with Tree -connection
+     gAlice->GetEvent(ev);
+     //gAlice->TreeR()->Reset();   //reset reconstructed tree
+
+     
+     TTree *pTree=gAlice->TreeR();
+     if (!pTree){
+       gAlice->MakeTree("R");
+       pTree = gAlice->TreeR();
+     }
+     TBranch *branch=pTree->GetBranch("ITSRecPoints");
+     if (!branch) {
+       //if not reconstructed ITS branch do reconstruction 
+       ITS->MakeBranch("R",0);
+       //////////////// Taken from ITSHitsToFastPoints.C ///////////////////////
+       AliITSsimulationFastPoints *sim = new AliITSsimulationFastPoints();
+       for (Int_t i=0;i<3;i++) { ITS->SetSimulationModel(i,sim); }
+       Int_t nsignal=25;
+       Int_t size=-1;
+       Int_t bgr_ev=Int_t(ev/nsignal);
+       ITS->HitsToFastRecPoints(ev,bgr_ev,size," ","All"," ");
+       //////////////////////////////////////////////////////////////////////////
+       gAlice->GetEvent(ev);   //MI comment  - in HitsToFast... they reset treeR to 0 
+       //they overwrite full reconstructed event ???? ... so lets connect TreeR one more
+       //time
+     }
+
+
+     
+     out->cd();
+     TClonesArray *clusters=new TClonesArray("AliITSclusterV2",10000);
+     char   cname[100];
+     sprintf(cname,"TreeC_ITS_%d",ev);
+  
+     TTree *cTree=new TTree(cname,"ITS clusters");
+     cTree->Branch("Clusters",&clusters);
+     
+     pTree=gAlice->TreeR();
+     if (!pTree) { cerr<<"Can't get TreeR !\n"; return 1; }
+     branch=pTree->GetBranch("ITSRecPoints");
+     if (!branch) { cerr<<"Can't get ITSRecPoints branch !\n"; return 1;}
+     TClonesArray *points=new TClonesArray("AliITSRecPoint",10000);
+     branch->SetAddress(&points);
+     
+     TClonesArray &cl=*clusters;
+     Int_t nclusters=0;
+     Int_t nentr=(Int_t)pTree->GetEntries();
+     AliITSgeom *geom=ITS->GetITSgeom();
+
+     for (Int_t i=0; i<nentr; i++) {
        if (!pTree->GetEvent(i)) {cTree->Fill(); continue;}
        Int_t lay,lad,det; geom->GetModuleId(i,lay,lad,det);
        Float_t x,y,zshift; geom->GetTrans(lay,lad,det,x,y,zshift); 
@@ -258,39 +312,40 @@ Int_t ITSFindClusters(const Char_t *inname, const Char_t *outname) {
        Int_t ncl=points->GetEntriesFast();
        nclusters+=ncl;
        for (Int_t j=0; j<ncl; j++) {
-          AliITSRecPoint *p=(AliITSRecPoint*)points->UncheckedAt(j);
-          Float_t lp[5];
-          lp[0]=-p->GetX()-yshift; if (lay==1) lp[0]=-lp[0];
-          lp[1]=p->GetZ()+zshift;
-          lp[2]=p->GetSigmaX2();
-          lp[3]=p->GetSigmaZ2();
-          lp[4]=p->GetQ();
-          Int_t lab[6]; 
-          lab[0]=p->GetLabel(0);lab[1]=p->GetLabel(1);lab[2]=p->GetLabel(2);
-          lab[3]=ndet;
-
-          Int_t label=lab[0];
-          TParticle *part=(TParticle*)gAlice->Particle(label);
-          label=-3;
-          while (part->P() < 0.005) {
-             Int_t m=part->GetFirstMother();
-             if (m<0) {cerr<<"Primary momentum: "<<part->P()<<endl; break;}
-             label=m;
-             part=(TParticle*)gAlice->Particle(label);
-          }
-          if      (lab[1]<0) lab[1]=label;
-          else if (lab[2]<0) lab[2]=label;
-          else cerr<<"No empty labels !\n";
-
-          new(cl[j]) AliITSclusterV2(lab,lp);
+        AliITSRecPoint *p=(AliITSRecPoint*)points->UncheckedAt(j);
+        Float_t lp[5];
+        lp[0]=-p->GetX()-yshift; if (lay==1) lp[0]=-lp[0];
+        lp[1]=p->GetZ()+zshift;
+        lp[2]=p->GetSigmaX2();
+        lp[3]=p->GetSigmaZ2();
+        lp[4]=p->GetQ();
+        Int_t lab[6]; 
+        lab[0]=p->GetLabel(0);lab[1]=p->GetLabel(1);lab[2]=p->GetLabel(2);
+        lab[3]=ndet;
+        
+        Int_t label=lab[0];
+        TParticle *part=(TParticle*)gAlice->Particle(label);
+        label=-3;
+        while (part->P() < 0.005) {
+          Int_t m=part->GetFirstMother();
+          if (m<0) {cerr<<"Primary momentum: "<<part->P()<<endl; break;}
+          label=m;
+          part=(TParticle*)gAlice->Particle(label);
+        }
+        if      (lab[1]<0) lab[1]=label;
+        else if (lab[2]<0) lab[2]=label;
+        else cerr<<"No empty labels !\n";
+        
+        new(cl[j]) AliITSclusterV2(lab,lp);
        }
        cTree->Fill(); clusters->Delete();
        points->Delete();
-   }
-   cTree->Write();
-   cerr<<"Number of clusters: "<<nclusters<<endl;
+     }
+     cTree->Write();
+     cerr<<"Number of clusters: "<<nclusters<<endl;
+     delete cTree; delete clusters; delete points;
 
-   delete cTree; delete clusters; delete points;
+   }
 
    delete gAlice; gAlice=0;
    in->Close();
@@ -301,20 +356,28 @@ Int_t ITSFindClusters(const Char_t *inname, const Char_t *outname) {
    return rc;
 }
 
-Int_t ITSFindTracks(const Char_t *inname, const Char_t *outname) {
+Int_t ITSFindTracks(const Char_t * inname, const Char_t *inname2, const Char_t *outname, Int_t n) {
    Int_t rc=0;
    const Char_t *name="ITSFindTracks";
    cerr<<'\n'<<name<<"...\n";
    gBenchmark->Start(name);
 
-   AliITSgeom *geom=(AliITSgeom*)gFile->Get("AliITSgeom");
-   if (!geom) { cerr<<"can't get ITS geometry !\n"; return 1;}
-   AliITStrackerV2 tracker(geom);
 
    TFile *out=TFile::Open(outname,"recreate");
    TFile *in =TFile::Open(inname);
-   rc=tracker.Clusters2Tracks(in,out);
+   TFile *in2 =TFile::Open(inname2);
+
+   AliITSgeom *geom=(AliITSgeom*)gFile->Get("AliITSgeom");
+   if (!geom) { cerr<<"can't get ITS geometry !\n"; return 1;}
+
+
+   for (Int_t i=0;i<n;i++){
+     AliITStrackerV2 tracker(geom,i);
+     rc=tracker.Clusters2Tracks(in,out);
+   }
+
    in->Close();
+   in2->Close();
    out->Close();
 
    gBenchmark->Stop(name);
@@ -324,7 +387,9 @@ Int_t ITSFindTracks(const Char_t *inname, const Char_t *outname) {
 }
 
 Int_t ITSPropagateBack(const Char_t *inname, const Char_t *outname) {
-   Int_t rc=0;
+   
+  Int_t rc=0;
+  /*
    const Char_t *name="ITSPropagateBack";
    cerr<<'\n'<<name<<"...\n";
    gBenchmark->Start(name);
@@ -341,7 +406,7 @@ Int_t ITSPropagateBack(const Char_t *inname, const Char_t *outname) {
 
    gBenchmark->Stop(name);
    gBenchmark->Show(name);
-
+  */
    return rc;
 }