Chages concerning coding convetion requirements.
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Nov 2003 09:27:46 +0000 (09:27 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Nov 2003 09:27:46 +0000 (09:27 +0000)
HBTAN/AliHBTReaderITSv1.cxx
HBTAN/AliHBTReaderITSv1.h
HBTAN/AliHBTReaderPPprod.cxx [deleted file]
HBTAN/AliHBTReaderPPprod.h [deleted file]
HBTAN/AliHBTTwoTrackEffFctn.cxx
HBTAN/AliHBTTwoTrackEffFctn.h
HBTAN/HBTAnalysisLinkDef.h
HBTAN/hbtanalysis.C
HBTAN/libHBTAN.pkg

index 82c3e33..a4043d9 100644 (file)
@@ -1,3 +1,12 @@
+//____________________________________________________________________
+//////////////////////////////////////////////////////////////////////
+//                                                                  //
+//  class AliHBTReaderITSv1                                         //
+//                                                                  //
+//  Reader for ITSv1 tracks. Not maintained since v1 is not         //
+//  supposed to be used                                             //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
 
 #include "AliHBTReaderITSv1.h"
 #include "AliHBTEvent.h"
 #include <TObjString.h>
 
 #include <AliRun.h>
+#include <AliStack.h>
 #include <AliMagF.h>
 #include <AliKalmanTrack.h>
 #include <AliITSIOTrack.h>
-#include "AliMC.h"
 
 ClassImp(AliHBTReaderITSv1)
 /********************************************************************/
@@ -108,7 +117,6 @@ Int_t AliHBTReaderITSv1::GetNumberOfTrackEvents()
 
 Int_t AliHBTReaderITSv1::Read(AliHBTRun* particles, AliHBTRun *tracks)
 {
- cout<<"AliHBTReaderITSv1::Read()"<<endl;
  Int_t Nevents = 0;
  AliITSIOTrack *iotrack=new AliITSIOTrack;
  Int_t currentdir = 0;
@@ -171,7 +179,7 @@ Int_t AliHBTReaderITSv1::Read(AliHBTRun* particles, AliHBTRun *tracks)
       
       gAliceFile->cd();
       gAlice->GetEvent(currentEvent);
-      gAlice->GetMCApp()->Particles();
+      gAlice->Stack()->Particles();
 
       Int_t nentr=(Int_t)tracktree->GetEntries();
       
@@ -189,7 +197,7 @@ Int_t AliHBTReaderITSv1::Read(AliHBTRun* particles, AliHBTRun *tracks)
            continue;
          }
 
-        TParticle *p = (TParticle*)gAlice->GetMCApp()->Particle(label);
+        TParticle *p = (TParticle*)gAlice->Stack()->Particle(label);
         if(!p)
          {
            Warning("Read","Can not get particle with label &d",label);
index 68e7bbc..d4289b5 100644 (file)
@@ -1,5 +1,15 @@
 #ifndef ALIHBTREADERITSV1_H
 #define ALIHBTREADERITSV1_H
+//____________________________________________________________________
+//////////////////////////////////////////////////////////////////////
+//                                                                  //
+//  class AliHBTReaderITSv1                                         //
+//                                                                  //
+//  Reader for ITSv1 tracks. Not maintained since v1 is not         //
+//  supposed to be used                                             //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
+
 
 #include "AliHBTReader.h"
 
@@ -27,8 +37,8 @@ class AliHBTReaderITSv1: public AliHBTReader
     Int_t GetNumberOfTrackEvents();//returns number of track events
     
   protected:
-    TString fITSTracksFileName;
-    TString fGAliceFileName;
+    TString fITSTracksFileName; //name of the file with tracks
+    TString fGAliceFileName;//name of the file containing Run Loader
     
     AliHBTRun* fParticles; //!simulated particles
     AliHBTRun* fTracks; //!reconstructed tracks (particles)
@@ -37,9 +47,8 @@ class AliHBTReaderITSv1: public AliHBTReader
    
     TFile* OpenTrackFile(Int_t);//opens files to be read for given directoru nomber in fDirs Array
     TFile* OpenGAliceFile(Int_t);
-
+    
   private:
-  public:
     ClassDef(AliHBTReaderITSv1,1)
 };
 
diff --git a/HBTAN/AliHBTReaderPPprod.cxx b/HBTAN/AliHBTReaderPPprod.cxx
deleted file mode 100644 (file)
index 6ab9762..0000000
+++ /dev/null
@@ -1,397 +0,0 @@
-#include "AliHBTReaderPPprod.h"
-
-#include <Riostream.h>
-#include <Riostream.h>
-#include <TString.h>
-#include <TTree.h>
-#include <TFile.h>
-
-#include <AliTPCtrack.h>
-#include <AliTPCParam.h>
-#include <AliTPCtracker.h>
-
-#include "AliRun.h"
-#include "AliHBTRun.h"
-#include "AliHBTEvent.h"
-#include "AliHBTParticle.h"
-#include "AliHBTParticleCut.h"
-
-
-ClassImp(AliHBTReaderPPprod)
-
-AliHBTReaderPPprod::
- AliHBTReaderPPprod(const Char_t* trackfilename,const Char_t* clusterfilename,
-                 const Char_t* goodtracksfilename,const Char_t* galicefilename):
-                 fTrackFileName(trackfilename),fClusterFileName(clusterfilename),
-                 fGAliceFileName(galicefilename),
-                 fGoodTPCTracksFileName(goodtracksfilename)
-{
-  //constructor, only file names are set
-  //Defaults:
-  //  trackfilename = "AliTPCtracks.root"
-  //  clusterfilename = "AliTPCclusters.root"
-  //  goodtracksfilename = "good_tracks_tpc"
-  //  galicefilename = ""  - this means: Do not open gAlice file - 
-  //                         just leave the global pointer untached
-  
-  fParticles = new AliHBTRun();
-  fTracks    = new AliHBTRun();
-
-  fTracksFile   = 0x0;  //files are opened during reading only
-  fClustersFile = 0x0;
-  
-  fIsRead = kFALSE;
-}
-/********************************************************************/
-
-AliHBTReaderPPprod::~AliHBTReaderPPprod()
- {
-   delete fParticles;
-   delete fTracks;
- }
-/********************************************************************/
-
-AliHBTEvent* AliHBTReaderPPprod::GetParticleEvent(Int_t n)
- {
- //returns Nth event with simulated particles
-   if (!fIsRead) Read(fParticles,fTracks);
-   return fParticles->GetEvent(n);
- }
-/********************************************************************/
-AliHBTEvent* AliHBTReaderPPprod::GetTrackEvent(Int_t n)
- {
- //returns Nth event with reconstructed tracks
-   if (!fIsRead) Read(fParticles,fTracks);
-   return fTracks->GetEvent(n);
- }
-/********************************************************************/
-
-Int_t AliHBTReaderPPprod::GetNumberOfPartEvents()
- {
- //returns number of events of particles
-   if (!fIsRead) Read(fParticles,fTracks);
-   return fParticles->GetNumberOfEvents();
- }
-
-/********************************************************************/
-Int_t AliHBTReaderPPprod::GetNumberOfTrackEvents()
- {
- //returns number of events of tracks
-  if (!fIsRead) Read(fParticles,fTracks);
-  return fTracks->GetNumberOfEvents();
- }
-/********************************************************************/
-
-
-Int_t AliHBTReaderPPprod::Read(AliHBTRun* particles, AliHBTRun *tracks)
- {
- //reads data and puts put to the particles and tracks objects
- //reurns 0 if everything is OK
- //
-  cout<<"New I/O not implemented\n";
-  return 0;
-   
-  Int_t i; //iterator and some temprary values
-  Int_t Nevents;
-  if (!particles) //check if an object is instatiated
-   {
-     Error("AliHBTReaderPPprod::Read"," particles object must instatiated before passing it to the reader");
-   }
-  if (!tracks)  //check if an object is instatiated
-   {
-     Error("AliHBTReaderPPprod::Read"," tracks object must instatiated before passing it to the reader");
-   }
-  particles->Reset();//clear runs == delete all old events
-  tracks->Reset();
-    
-  if( (i=OpenFiles()) )
-   {
-     Error("AliHBTReaderPPprod::Read","Exiting due to problems with opening files. Errorcode %d",i);
-     return i;
-   }
-  
-  AliGoodTracksPP *goodTPCTracks = new AliGoodTracksPP(fGoodTPCTracksFileName);
-  if (!goodTPCTracks)
-   {
-     Error("AliHBTReaderPPprod::Read","Exiting due to problems with opening files. Errorcode %d",i);
-     return 1;
-   }
-
-  Nevents = 100;
-
-  fClustersFile->cd();
-  AliTPCParam *TPCParam= (AliTPCParam*)fClustersFile->Get("75x40_100x60");
-  if (!TPCParam) 
-    { 
-     Error("AliHBTReaderPPprod::Read","TPC parameters have not been found !\n");
-     return 1;
-    }
-
-  TObjArray *tarray = new TObjArray(5000);
-  tarray->SetOwner();//  this causes memory leak, but in some cases deleting is infinite loop
-  
-  for(Int_t currentEvent =0; currentEvent<Nevents;currentEvent++)
-   {
-     cout<<"Reading Event "<<currentEvent<<endl;
-     /**************************************/
-      /**************************************/
-       /**************************************/ 
-         fTracksFile->cd();
-         Char_t  treename[100];
-         sprintf(treename,"TreeT_TPC_%d",currentEvent);
-   
-         TTree *tracktree=0;
-         
-         tracktree=(TTree*)fTracksFile->Get(treename);
-         if (!tracktree) 
-          {
-            Error("AliHBTReaderPPprod::Read","Can't get a tree with TPC tracks !\n"); 
-            return 1;
-          }
-   
-         TBranch *trackbranch=tracktree->GetBranch("tracks");
-         if (!trackbranch) 
-          {
-            Error("AliHBTReaderPPprod::Read","Can't get a branch with TPC tracks !\n"); 
-            return 2;
-          }
-         Int_t NTPCtracks=(Int_t)tracktree->GetEntries();
-         cout<<"Found "<<NTPCtracks<<" TPC tracks.\n";
-         //Copy tracks to array
-         
-         AliTPCtrack *iotrack=0;
-         
-         fClustersFile->cd();
-printf("This method is not converted to the NewIO !\n"); //I.B.
-return 1; //I.B.
-         AliTPCtracker *tracker = new AliTPCtracker(TPCParam); //I.B.
-         //AliTPCtracker *tracker = new AliTPCtracker(TPCParam,currentEvent,"");
-         if (!tracker) 
-          {
-            Error("AliHBTReaderPPprod::Read","Can't get a tracker !\n"); 
-            return 3;
-          }
-tracker->LoadClusters(0);//I.Belikov, "0" should be a pointer to a tree
-   
-         for (i=0; i<NTPCtracks; i++)
-          {
-            iotrack=new AliTPCtrack;
-            trackbranch->SetAddress(&iotrack);
-            tracktree->GetEvent(i);
-            tracker->CookLabel(iotrack,0.1);
-            tarray->AddLast(iotrack);
-          }
-        
-         
-         fTracksFile->Delete(treename);//delete tree from memmory (and leave untached on disk)- we do not need it any more
-         fTracksFile->Delete("tracks");
-         
-         delete tracker;
-         
-         tracker = 0x0;
-         trackbranch = 0x0;
-         tracktree = 0x0;
-
-         Int_t & ngood = goodTPCTracks->fGoodInEvent[currentEvent];
-   
-         Double_t xk;
-         Double_t par[5];
-         Float_t phi, lam, pt;
-         Int_t label;
-         Bool_t found;
-   
-         for (i=0; i<ngood; i++)
-          { 
-            const struct GoodTrack & gt = goodTPCTracks->GetTrack(currentEvent,i);
-            
-            if(Pass(gt.code)) continue;
-            
-            label = gt.lab;
-            found = kFALSE; //guard in case we don't find track with such a label
-            for (Int_t j=0;j<NTPCtracks;j++)
-              {
-                iotrack = (AliTPCtrack*)tarray->At(j);
-                if (iotrack->GetLabel() == label) 
-                  {
-                    found = kTRUE;
-                    break;
-                  }
-              }  
-            if(!found) 
-              {
-                Warning("Read",
-                "Sth is going wrong with tracks - there is no TPC track corresponding to goodtrack.\nGood tack label %d",label);
-                continue; //put comunicate on the screen and continue loop
-              }
-        
-            Double_t mass = TDatabasePDG::Instance()->GetParticle(gt.code)->Mass();
-            Double_t pEtot = TMath::Sqrt(gt.px*gt.px + gt.py*gt.py + gt.pz*gt.pz + mass*mass);
-            
-            AliHBTParticle* part = new AliHBTParticle(gt.code,i, gt.px, gt.py, gt.pz, pEtot, gt.x, gt.y, gt.z, 0.0);
-            if(Pass(part)) continue;
-            
-         
-            iotrack->PropagateTo(gt.x);
-            iotrack->GetExternalParameters(xk,par);
-            phi=TMath::ASin(par[2]) + iotrack->GetAlpha();
-            if (phi<-TMath::Pi()) phi+=2*TMath::Pi();
-            if (phi>=TMath::Pi()) phi-=2*TMath::Pi();
-            lam=par[3]; 
-            pt=1.0/TMath::Abs(par[4]);
-            
-            Double_t tpx = pt * TMath::Cos(phi); //track x coordinate of momentum
-            Double_t tpy = pt * TMath::Sin(phi); //track x coordinate of momentum
-            Double_t tpz = pt * lam;
-            
-            Double_t tEtot = TMath::Sqrt( tpx*tpx + tpy*tpy + tpz*tpz + mass*mass);
-            
-            AliHBTParticle* track = new AliHBTParticle(gt.code,i, tpx, tpy , tpz, tEtot, 0., 0., 0., 0.);
-            if(Pass(track)) continue;
-            
-            particles->AddParticle(currentEvent,part);
-            tracks->AddParticle(currentEvent,track);
-
-          }
-         tarray->Clear();
-       /**************************************/
-      /**************************************/
-     /**************************************/  
-   }
-  
-  CloseFiles();
-  delete tarray;
-  delete goodTPCTracks;
-  fIsRead = kTRUE;
-  return 0;
- }
-
-/********************************************************************/
-Int_t AliHBTReaderPPprod::OpenFiles()
-{
-   fTracksFile = 0;
-   fTracksFile=TFile::Open("AliTPCtracks.root");
-   if (!fTracksFile->IsOpen()) 
-     {
-       Error("AliHBTReaderPPprod::OpenFiles","Can't open AliTPCtracks.root");
-       return 1;
-     }
-   
-   fClustersFile = 0;
-   
-   fClustersFile=TFile::Open("AliTPCclusters.root");
-   if (!fClustersFile->IsOpen()) 
-    {
-      Error("AliHBTReaderPPprod::OpenFiles","Can't open AliTPCclusters.root");
-      return 2;
-    }
-
-    
-
- return 0; 
-}
-  
-
-
-/********************************************************************/
-  
-void AliHBTReaderPPprod::CloseFiles()
-{
-  fTracksFile->Close();
-  fClustersFile->Close();
-}
-
-/********************************************************************/
-
-/********************************************************************/
-/********************************************************************/
-/********************************************************************/
-
-
-AliGoodTracksPP::~AliGoodTracksPP()
-{
- delete [] fGoodInEvent;
- for (Int_t i = 0;i<fNevents;i++)
-   delete [] fData[i];
- delete [] fData;
-}
-/********************************************************************/
-AliGoodTracksPP::AliGoodTracksPP(const TString& infilename)
-{
-
-  fNevents = 100;
-  ifstream in(infilename.Data());
-
-  if(!in)
-    {
-      cerr<<"Can not open file with Good TPC Tracks named:"<<infilename.Data()<<endl;
-      delete this;
-      return;
-    }
-
-  
-  fGoodInEvent = new Int_t[fNevents];
-  fData = new struct GoodTrack* [fNevents];
-
-  Int_t i;
-  for( i = 0;i<fNevents;i++)
-   {
-    fGoodInEvent[i] =0;
-    fData[i] = new struct GoodTrack[500];
-   }
-  Float_t tmp;
-  Int_t evno;
-  while(in>>evno)
-   {
-    if(fGoodInEvent[evno]>=500)
-     {
-      cerr<<"AliGoodTracksPP::AliGoodTracksPP() : Not enough place in the array\n";
-      continue;
-     }
-    in>>fData[evno][fGoodInEvent[evno]].lab;
-    in>>fData[evno][fGoodInEvent[evno]].code;
-    in>>fData[evno][fGoodInEvent[evno]].px;
-    in>>fData[evno][fGoodInEvent[evno]].py;
-    in>>fData[evno][fGoodInEvent[evno]].pz;
-    in>>fData[evno][fGoodInEvent[evno]].x;
-    in>>fData[evno][fGoodInEvent[evno]].y;
-    in>>fData[evno][fGoodInEvent[evno]].z;
-    
-    in>>tmp;
-    in>>tmp;
-    in>>tmp;
-    
- /* cout<<evno<<" ";
-  cout<<fData[evno][fGoodInEvent[evno]].lab;
-  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].code;
-  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].px;
-  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].py;
-  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].pz;
-  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].x;
-  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].y;
-  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].z;
-  cout<<"\n";
- */ 
-  fGoodInEvent[evno]++;
- }
- in.close();
- cout<<"AliGoodTracksPP::AliGoodTracksPP()  ....  Done\n";
-}
-
-
-
-const GoodTrack& AliGoodTracksPP::GetTrack(Int_t event, Int_t n) const
- {
-  
-  if( (event>fNevents) || (event<0))
-   {
-     gAlice->Fatal("AliGoodTracksPP::GetTrack","No such Event %d",event);
-   }
-  if( (n>fGoodInEvent[event]) || (n<0))
-   {
-     gAlice->Fatal("AliGoodTracksPP::GetTrack","No such Good TPC Track %d",n);
-   }
-  return fData[event][n];
-
- }
diff --git a/HBTAN/AliHBTReaderPPprod.h b/HBTAN/AliHBTReaderPPprod.h
deleted file mode 100644 (file)
index 09b504c..0000000
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef ALIHBTREADERPPPROD_H
-#define ALIHBTREADERPPPROD_H
-
-#include "AliHBTReader.h"
-#include "AliHBTReaderTPC.h"
-
-//This reader reads tracks AliTPCtracks.root
-//                  particles form tpc_good_tracks 
-//I am aware that this file is temporary however we do not have any other PID yet
-//Piotr.Skowronski@cern.ch
-
-#include <TString.h>
-class TFile;
-
-class AliHBTReaderPPprod: public AliHBTReader
-{
-  public:
-    AliHBTReaderPPprod(const Char_t* trackfilename = "AliTPCtracks.root",
-                       const Char_t* clusterfilename = "AliTPCclusters.root", 
-                       const Char_t* goodtracksfilename = "good_tracks_tpc",
-                       const Char_t* galicefilename = "");
-
-    virtual ~AliHBTReaderPPprod();
-    
-    Int_t Read(AliHBTRun* particles, AliHBTRun *tracks); //reads tracks and particles and puts them in runs
-    
-    AliHBTEvent* GetParticleEvent(Int_t); //returns pointer to event with particles 
-    AliHBTEvent* GetTrackEvent(Int_t);//returns pointer to event with particles 
-    Int_t GetNumberOfPartEvents(); //returns number of particle events
-    Int_t GetNumberOfTrackEvents();//returns number of track events
-    
-  protected:
-    //in the future this class is will read global tracking
-
-    
-    Int_t OpenFiles(); //opens files to be read
-    void CloseFiles(); //close files
-    
-    AliHBTRun* fParticles; //!simulated particles
-    AliHBTRun* fTracks; //!reconstructed tracks (particles)
-
-    TString fTrackFileName; //name of the file with tracks
-    TString fClusterFileName;//name of the file with clusters
-    TString fGAliceFileName;//name of the file with galice.root
-    TString fGoodTPCTracksFileName; //name of text file with good tracks
-    
-    TFile *fTracksFile; //file with tracks
-    TFile *fClustersFile;//file with clusters
-    
-    Bool_t fIsRead; //flag indicating if the data are already read
-    
-    
-  private:
-  public:
-    ClassDef(AliHBTReaderPPprod,1)
-};
-
-struct GoodTrack //data of good tracks produced by AliTPCComparison.C
- {
-  Int_t lab;
-  Int_t code;
-  Float_t px,py,pz;
-  Float_t x,y,z;
- };
-
-
-class AliGoodTracksPP
- { 
-   //container for good tracks
-   //this class is for internal use only
-   
-   friend class AliHBTReaderPPprod;
-   
-   private:
-     AliGoodTracksPP(const TString& infilename = TString("good_tracks_tpc")); //constructor
-     virtual ~AliGoodTracksPP(); //dctor
-   
-     const GoodTrack& GetTrack(Int_t event, Int_t n) const; //returns reference to the nth good track in event "event"
-
-     Int_t  fNevents;  //Number of events
-     Int_t* fGoodInEvent; //Numbers of good track in event
-     struct GoodTrack **fData;
- };
-
-
-#endif
index 464e1e6..261369e 100644 (file)
@@ -1,20 +1,28 @@
 #include "AliHBTTwoTrackEffFctn.h"
+//____________________________________________________________________
+//////////////////////////////////////////////////////////////////////
+//                                                                  //
+//  class AliHBTTwoTrackEffFctn                                     //
+//                                                                  //
+//  classes for calculating two track efficiency of the tracking    //
+//  binning is done using value of simulated pair montum difference // 
+//  pair must be recontructed, that is why we need both pairs       //
+//  (simulated and recontructed), thus functions are "two pair"     //
+//  Piotr.Skowronski@cern.ch                                        //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
 
 
-/******************************************************************/
-/******************************************************************/
-/******************************************************************/
 ClassImp(AliHBTTwoTrackEffFctn)
 /******************************************************************/
 
 AliHBTTwoTrackEffFctn::AliHBTTwoTrackEffFctn()
- {
- }
+{
+  //def ctor
+}
 /******************************************************************/
 
-AliHBTTwoTrackEffFctn::
-AliHBTTwoTrackEffFctn(Int_t nbins, Double_t maxval, Double_t minval):
+AliHBTTwoTrackEffFctn::AliHBTTwoTrackEffFctn(Int_t nbins, Double_t maxval, Double_t minval):
      AliHBTOnePairFctn1D("TwoTrackEff","Two Track Efficiency",nbins,maxval,minval)
 {
 //contructor
@@ -24,6 +32,8 @@ AliHBTTwoTrackEffFctn(Int_t nbins, Double_t maxval, Double_t minval):
  GetNumerator()->GetXaxis()->SetTitle("dP [GeV]");
  GetDenominator()->GetXaxis()->SetTitle("dP [GeV]");
 }
+/******************************************************************/
+
 TH1* AliHBTTwoTrackEffFctn::GetResult()
 {
 //returns ratio of numerator and denominator
@@ -45,6 +55,7 @@ AliHBTTwoTrackEffFctn3D::AliHBTTwoTrackEffFctn3D()
 {
 //Set Axis Title
 }
+/******************************************************************/
 
 void AliHBTTwoTrackEffFctn3D::GetValues(AliHBTPair* pair, Double_t& x, Double_t&y ,Double_t& z)
 {
index 464de73..857ef62 100644 (file)
@@ -1,10 +1,17 @@
 #ifndef AliHBTTwoTrackEffFctn_H
 #define AliHBTTwoTrackEffFctn_H
-//classes for calculating two track efficiency of the tracking
-//binning is done using value of simulated pair montum difference
-//pair must be recontructed, that is why we need both pairs 
-//(simulated and recontructed), thus functions are "two pair"
-//Piotr.Skowronski@cern.ch
+//____________________________________________________________________
+//////////////////////////////////////////////////////////////////////
+//                                                                  //
+//  class AliHBTTwoTrackEffFctn                                     //
+//                                                                  //
+//  classes for calculating two track efficiency of the tracking    //
+//  binning is done using value of simulated pair montum difference // 
+//  pair must be recontructed, that is why we need both pairs       //
+//  (simulated and recontructed), thus functions are "two pair"     //
+//  Piotr.Skowronski@cern.ch                                        //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
 #include "AliHBTPair.h"
 #include "AliHBTFunction.h"
 
@@ -18,7 +25,6 @@ class AliHBTTwoTrackEffFctn: public AliHBTOnePairFctn1D
   protected:
     Double_t GetValue(AliHBTPair* pair){return pair->GetDeltaP();}
   private:
-  public:
     ClassDef(AliHBTTwoTrackEffFctn,1)
  };
 
@@ -34,7 +40,6 @@ class AliHBTTwoTrackEffFctn3D: public AliHBTOnePairFctn3D
   protected:
     void GetValues(AliHBTPair*,Double_t&, Double_t&,Double_t&);
   private:
-  public:
     ClassDef(AliHBTTwoTrackEffFctn3D,1)
  };
 #endif
index 363e119..cfbb6c6 100644 (file)
@@ -72,7 +72,6 @@
 #pragma link C++ class AliHBTReaderTPC+;
 #pragma link C++ class AliHBTReaderITSv1+;
 #pragma link C++ class AliHBTReaderITSv2+;
-#pragma link C++ class AliHBTReaderPPprod+;
 #pragma link C++ class AliHBTReaderKineTree+;
 #pragma link C++ class AliHBTReaderInternal+;
 
index 206a18c..2ffa506 100644 (file)
@@ -137,6 +137,26 @@ void hbtanalysis(Option_t* datatype, Option_t* processopt="TracksAndParticles",
   
   analysis->SetReader(reader);
 
+  /***********************************************************/    
+  /*****   W E I G H T S        ******************************/    
+  /***********************************************************/    
+
+  AliHBTLLWeights::Instance()->SetParticlesTypes(kPiPlus,kPiPlus);
+  AliHBTLLWeights::Instance()->SetColoumb(kFALSE);
+  AliHBTLLWeights::Instance()->SetStrongInterSwitch(kFALSE);
+
+  AliHBTLLWeights::Instance()->SetRandomPosition(kFALSE);
+//AliHBTLLWeights::Instance()->SetR1dw(8.0);
+
+  AliHBTLLWeights::Instance()->Init();
+  AliHBTLLWeights::Instance()->Set();
+
+  //example function
+  AliHBTWeightTheorQInvFctn  *wqinvcfP = new AliHBTWeightTheorQInvFctn(nbins,qmax);
+  wqinvcfP->SetNumberOfBinsToScale(binstoscale);
+  wqinvcfP->Rename("wqinvcfP","Lednicky Q_{inv} Theoretical Correlation Function "+system);
+  analysis->AddParticleFunction(wqinvcfP);
+
   /************************************************************/
   /****   Q INV Correlation Function   ************************/
   /************************************************************/
index da9bbe1..5004fe1 100644 (file)
@@ -1,7 +1,7 @@
 SRCS          =       AliHBTWeights.cxx AliHBTCrab.cxx AliHBTAnalysis.cxx  \
 AliHBTReader.cxx      AliHBTReaderKineTree.cxx \
 AliHBTReaderESD.cxx   AliHBTReaderInternal.cxx \
-AliHBTReaderTPC.cxx   AliHBTReaderPPprod.cxx \
+AliHBTReaderTPC.cxx   \
 AliHBTReaderITSv1.cxx AliHBTReaderITSv2.cxx    \
 AliHBTParticle.cxx    AliHBTParticleCut.cxx \
 AliHBTPair.cxx        AliHBTPairCut.cxx \