temporary place holder
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 23 Jun 2008 17:32:52 +0000 (17:32 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 23 Jun 2008 17:32:52 +0000 (17:32 +0000)
PWG2/RESONANCES/AliRsnPair.cxx
PWG2/RESONANCES/AliRsnPair.h

index 063e8d5..fa0e3b6 100644 (file)
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-//-------------------------------------------------------------------------
-//                     Class AliRsnPair
-//-------------------------------------------------------------------------
-// This class computes the invariant mass spectrum of a specified pair of
-// particles, throughout a list of AliRsnEvents, and returns it as a TH1D.
-// This object is not supposed to be used directly: an AliRsnAnalysis
-// should be initialized in a macro and filled with one or more AliRsnPair's
-// which are then processed with a given sample of events.
-//   
-// author: A. Pulvirenti
-// email : alberto.pulvirenti@ct.infn.it
-//-------------------------------------------------------------------------
-
-#include <Riostream.h>
-
-#include <TH1.h>
-#include <TString.h>
-#include <TRefArray.h>
-#include <TClonesArray.h>
-
 #include "AliLog.h"
-#include "AliRsnParticle.h"
-#include "AliRsnDaughter.h"
-#include "AliRsnDaughterCut.h"
-#include "AliRsnDaughterCutPair.h"
+
 #include "AliRsnEvent.h"
+#include "AliRsnPairParticle.h"
+#include "AliRsnPairDef.h"
 
 #include "AliRsnPair.h"
 
-ClassImp(AliRsnPair)
-//--------------------------------------------------------------------------------------------------------
-AliRsnPair::AliRsnPair() :
-  TNamed(),
-  fForMixing(kFALSE),
-  fStoreOnlyTrue(kFALSE),
-  fTrueMotherPDG(0),
-  fPtMin(0.0),
-  fPtMax(0.0),
-  fVtMax(0.0),
-  fCutsPair(0x0),
-  fHistogram(0x0)
+ClassImp ( AliRsnPair )
+
+AliRsnPair::AliRsnPair()
+    : TObject() ,fPairDef(),
+    fPairType ( kESDNoPID )
 {
-//
-// Empty constructor.
-// Initializes the data members to default values:
-//  - default (empty string) name and title for the object
-//  - switch off the 'fStoreOnlyTrue' flag;
-//  - assume working with real data (no PDG code of the mother);
-//  - no cuts of any kind;
-//  - no definition of particles in the pair;
-//  - histogram undefined.
-// When using this constructor, all analysis elements (particles, histogram)
-// must be defined before starting event processing.
-//
-
-       Int_t i;
-       for (i = 0; i < 2; i++) {
-               fMass[i] = 0.0;
-               fCharge[i] = '0';
-               fType[i] = AliRsnPID::kUnknown;
-               fCutsSingle[i] = 0x0;
-       }
+  fCurrentCutMgr=0;
+  fMass[0]=-1.0;
+  fMass[1]=-1.0;
+  fRsnMVEventBuffer=0;
+  fNumOfMixEvent=0;
+  fIsSignSame = kFALSE;
+  fIsFilledOnlyInHistRange = kTRUE;
+
 }
-//--------------------------------------------------------------------------------------------------------
-AliRsnPair::AliRsnPair
-(const char *name, const char *title, Int_t nbins, Double_t min, Double_t max, 
- Double_t ptmin, Double_t ptmax, Double_t dmax) :
-  TNamed(name, title),
-  fForMixing(kFALSE),
-  fStoreOnlyTrue(kFALSE),
-  fTrueMotherPDG(0),
-  fPtMin(ptmin),
-  fPtMax(ptmax),
-  fVtMax(dmax),
-  fCutsPair(0x0),
-  fHistogram(0x0)
+
+AliRsnPair::AliRsnPair ( AliRsnPair::EPairType type, AliRsnPairDef * pairDef,Int_t numOfMix) : TObject(),
+    fPairDef ( *pairDef ),
+    fPairType ( type )
 {
-//
-// Constructor with arguments.
-// This constructor allows to define some of the initialization values:
-//  - name and title of the object
-//  - histogram binning and edges
-// The other parameters are initialized as in the default constructor.
-//
-
-       Int_t i;
-       for (i = 0; i < 2; i++) {
-               fMass[i] = 0.0;
-               fCharge[i] = '0';
-               fType[i] = AliRsnPID::kUnknown;
-               fCutsSingle[i] = 0x0;
-       }
-       fHistogram = new TH1D(Form("histo_%s", name), "AliRsnPair::fHistogram", nbins, min, max);
+  fCurrentCutMgr=0;
+  fMass[0]=-1.0;
+  fMass[1]=-1.0;
+  fRsnMVEventBuffer=0;
+  fNumOfMixEvent=numOfMix;
+  fIsSignSame = kFALSE;
+  fIsFilledOnlyInHistRange = kTRUE;
 }
-//--------------------------------------------------------------------------------------------------------
-AliRsnPair::AliRsnPair(const AliRsnPair &copy) :
-  TNamed(copy),
-  fForMixing(copy.fForMixing),
-  fStoreOnlyTrue(copy.fStoreOnlyTrue),
-  fTrueMotherPDG(copy.fTrueMotherPDG),
-  fPtMin(copy.fPtMin),
-  fPtMax(copy.fPtMax),
-  fVtMax(copy.fVtMax),
-  fCutsPair(0x0),
-  fHistogram(0x0)
+
+AliRsnPair::~AliRsnPair()
 {
-//
-// Copy constructor.
-// Default behavior as a copy constructor for what concerns non-array data-members.
-// The arrays are cloned if they are not NULL.
-//
-
-       if (copy.fHistogram) fHistogram = (TH1D*)(copy.fHistogram->Clone());
-       if (copy.fCutsPair) fCutsPair = (TObjArray*)(copy.fCutsPair->Clone());
-       
-       Int_t i;
-       for (i = 0; i < 2; i++) {
-               fMass[i] = copy.fMass[i];
-               fCharge[i] = copy.fCharge[i];
-               fType[i] = copy.fType[i];
-               if (copy.fCutsSingle[i]) fCutsSingle[i] = (TObjArray*)copy.fCutsSingle[i]->Clone();
-       }
 }
-//--------------------------------------------------------------------------------------------------------
-const AliRsnPair& AliRsnPair::operator=(const AliRsnPair &copy)
+
+TString AliRsnPair::GetEffMassHistName ( Int_t index )
 {
-//
-// Assignment operator.
-// Default behavior like copy constructor.
-//
-
-       fHistogram = 0x0;
-       fCutsPair = 0x0;
-       fCutsSingle[0] = fCutsSingle[1] = 0x0;
-
-    fForMixing = copy.fForMixing;
-       fStoreOnlyTrue = copy.fStoreOnlyTrue;
-       fTrueMotherPDG = copy.fTrueMotherPDG;
-       if (copy.fHistogram) fHistogram = (TH1D*)(copy.fHistogram->Clone());
-       if (copy.fCutsPair) fCutsPair = (TObjArray*)(copy.fCutsPair->Clone());
-    
-    fPtMin = copy.fPtMin;
-    fPtMax = copy.fPtMax;
-    fVtMax = copy.fVtMax;
-       
-       Int_t i;
-       for (i = 0; i < 2; i++) {
-               fMass[i] = copy.fMass[i];
-               fCharge[i] = copy.fCharge[i];
-               fType[i] = copy.fType[i];
-               if (copy.fCutsSingle[i]) fCutsSingle[i] = (TObjArray*)copy.fCutsSingle[i]->Clone();
-       }
-       
-       return (*this);
+
+  fCurrentCutMgr = ( AliRsnCutMgr* ) fCutMgrs.UncheckedAt ( index );
+
+  TString sName;
+  sName += GetPairTypeName ( fPairType );
+  sName += GetESDParticleName ( fPairDef.GetType( 0 ) );
+  sName += fPairDef.GetCharge ( 0 );
+  sName += GetESDParticleName ( fPairDef.GetType( 1 ) );
+  sName += fPairDef.GetCharge ( 1 );
+  sName += "_";
+  if ( fCurrentCutMgr )
+    sName += fCurrentCutMgr->GetName();
+  else
+    sName += "NoCut";
+  sName += "_";
+  sName += "[";
+  sName += Form ( "%.2f", fPairDef.GetMin() );
+  sName += "-";
+  sName += Form ( "%.2f",fPairDef.GetMax() );
+  sName += "]";
+
+  return sName;
+}
+
+TString AliRsnPair::GetEffMassHistTitle ( Int_t index )
+{
+
+  fCurrentCutMgr= ( AliRsnCutMgr* ) fCutMgrs.UncheckedAt ( index );
+
+  TString sTitle;
+  sTitle += GetPairTypeName ( fPairType );
+  sTitle += GetESDParticleName ( fPairDef.GetType ( 0 ) );
+  sTitle += fPairDef.GetCharge ( 0 );
+  sTitle += GetESDParticleName ( fPairDef.GetType ( 1 ) );
+  sTitle += fPairDef.GetCharge ( 1 );
+  sTitle += " ";
+  if ( fCurrentCutMgr )
+    sTitle += fCurrentCutMgr->GetTitle();
+  else
+    sTitle += "NoCut";
+  return sTitle;
 }
-//--------------------------------------------------------------------------------------------------------
-void AliRsnPair::Clear(Option_t* /*option*/)
+
+TH1F * AliRsnPair::GenerateEffMassHist ( Int_t index )
 {
-//
-// Clear arrays and histogram.
-// For the sake of security, all pointers are also set explicitly to NULL.
-//
-       fCutsSingle[0]->Delete();
-       fCutsSingle[1]->Delete();
-       fCutsPair->Delete();
-       
-       delete fCutsSingle[0];
-       delete fCutsSingle[1];
-       delete fCutsPair;
-       delete fHistogram;
-       
-       fCutsSingle[0] = fCutsSingle[1] = fCutsPair = 0;
-       fHistogram = 0;
+  return new TH1F ( GetEffMassHistName ( index ).Data(),GetEffMassHistTitle ( index ).Data(),fPairDef.GetNBins(),fPairDef.GetMin(),fPairDef.GetMax() );
+
 }
-//--------------------------------------------------------------------------------------------------------
-void AliRsnPair::SetPair
-(Char_t charge1, AliRsnPID::EType type1, Char_t charge2, AliRsnPID::EType type2)
+
+TString AliRsnPair::GetESDParticleName (  AliRsnPID::EType type )
 {
-//
-// This method allows to set at once all the parameters of the particles in the pair.
-// The mass must not be specified, and it is retrieved from TDatabasePDG,
-// using a static method defined in AliRsnDaughter class.
-//
-
-       fCharge[0] = charge1;
-       fType[0] = type1;
-       SetMass(0, AliRsnPID::ParticleMass(type1));
-
-       fCharge[1] = charge2;
-       fType[1] = type2;
-       SetMass(1, AliRsnPID::ParticleMass(type2));
+
+  switch ( type )
+  {
+    case AliRsnPID::kElectron : return ( "e" );break;
+    case AliRsnPID::kMuon     : return ( "mu" );break;
+    case AliRsnPID::kPion     : return ( "pi" );break;
+    case AliRsnPID::kKaon     : return ( "K" );break;
+    case AliRsnPID::kProton   : return ( "p" );break;
+    case AliRsnPID::kUnknown  : return ( "unknown" );
+    default:
+      AliWarning ( "Unrecognized value of EParticle argument" );
+      break;
+  }
+
+  return "";
+
 }
-//--------------------------------------------------------------------------------------------------------
-void AliRsnPair::AddCutPair(AliRsnDaughterCutPair *cut)
+
+TString AliRsnPair::GetPairTypeName ( EPairType type )
 {
-//
-// Add a pair cut.
-// If the cut array is NULL, it is initialized here.
-//
+  switch ( type )
+  {
+    case kESDNoPID : return ( "ESDNOPID_" );break;
+    case kESDNoPIDMix : return ( "ESDNOPIDMIX_" );break;
+    case kESDNormal : return ( "ESDNORMAL_" );break;
+    case kESDMix : return ( "ESDMIX_" );break;
+    case kMCNoPID : return ( "MCNOPID_" );break;
+    case kMCNormal : return ( "MCNORMAL_" );break;
+    case kMCMix : return ( "MCMIX_" );break;
+    case kMCSignalOnly : return ( "MCSIGNAL_" );break;
+    case kMCBackgroundOnly : return ( "MCBKGONLY_" );break;
+    default:
+      AliWarning ( "Unrecognized value of EPairTypeName argument" );
+      break;
+  }
 
-       if (!fCutsPair) fCutsPair = new TObjArray(0);
-       fCutsPair->AddLast(cut);
+  return "NOTYPE";
 }
-//--------------------------------------------------------------------------------------------------------
-void AliRsnPair::AddCutSingle(Int_t i, AliRsnDaughterCut *cut)
+
+void AliRsnPair::AddCutMgr ( AliRsnCutMgr * theValue )
 {
-//
-// Add a single particle cut.
-// If the cut array is NULL, it is initialized here.
-//
-
-       if (i < 0 || i > 1) return;
-       if (!fCutsSingle[i]) fCutsSingle[i] = new TObjArray(0);
-       fCutsSingle[i]->AddLast(cut);
+  fCutMgrs.Add ( theValue );
 }
-//--------------------------------------------------------------------------------------------------------
-Stat_t AliRsnPair::Process(AliRsnEvent *event1, AliRsnEvent *event2, Bool_t usePID)
+
+void AliRsnPair::ProcessPair ( AliRsnEvent * event,TH1F*hist ,Int_t index )
 {
-//
-// Scans the two events specified in argument to fill the histogram.
-// This method essentially calls the AliRsnPair::Fill() method one or many times.
-// When the "noPID" argument is kFALSE, the analysis is done with identified particles
-// and this causes the Fill() method to be called only once, for the two lists of
-// identified particles of the two kinds specified in AliRsnPair datamembers.
-// When the "noPID" argument is kTRUE, the analysis is done with all collections
-// of particles of the same sign as specified in the two arguments of the pair.
-// ---
-// Particles of type #1 are taken in 'event1', and particles of type #2 are taken in 'event2'.
-// When doing single-event analysis (for resonance signal or like-sign background),
-// the second argument can be simply skipped.
-// When doing event mixing, the two arguments must be not null and different.
-// If argument #1 is NULL, an error is raised, while if argument #2 is NULL, no error is raised,
-// and 'event2' argument is set equal to 'event1' (= single event processing).
-// ---
-// Return value is the total number of pairs processed.
-//
-
-       // preliminary checks
-       if (!event1) {
-               // argument #1 cannot be NULL
-               AliError("Argument #1 cannot be NULL.");
-               return 0.0;
-       }
-       if (!event2) {
-               // if argument #2 is NULL, it is put equal to argument #1
-               event2 = event1;
-       }
-    
-    // define if same indexes must be summed or not depending if
-    // the two events are the same or not
-    Bool_t skipSameIndex = (event1 == event2);
-    
-    TRefArray *list1, *list2;
-    if (usePID) {
-        // analysis with PID: only two collections are processed
-       list1 = event1->GetTracks(fCharge[0], fType[0]);
-       list2 = event2->GetTracks(fCharge[1], fType[1]);
+  AliDebug ( AliLog::kDebug+2,"<-" );
+
+  switch ( fPairType )
+  {
+    case kESDNoPID :
+      DoESDNoPID ( event,hist,index );
+      break;
+    case kESDNoPIDMix :
+      DoESDNoPIDMix ( event,hist,index );
+      break;
+    case kESDNormal :
+      DoESDNormal ( event,hist,index );
+      break;
+    case kESDMix :
+      DoESDMix ( event,hist,index );
+      break;
+    case kMCNoPID :
+      DoMCNoPID ( event,hist,index );
+      break;
+    case kMCNormal :
+      DoMCNormal ( event,hist,index );
+      break;
+    case kMCSignalOnly :
+      DoMCNormal ( event,hist,index );
+      break;
+    case kMCBackgroundOnly :
+      DoMCNormal ( event,hist,index );
+      break;
+    default:
+      AliWarning ( "Wrong fPaitType Skipping pair..." );
+      break;
+  }
+
+  AliDebug ( AliLog::kDebug+2,"->" );
+}
+
+void AliRsnPair::DoCleanUpAfterOneEvent()
+{
+}
+
+void AliRsnPair::DoLoopPairESD ( AliRsnEvent * event1, TArrayI * array1, AliRsnEvent * event2, TArrayI * array2, TH1F * hist, Int_t index )
+{
+  AliDebug ( AliLog::kDebug+2,"<-" );
+
+  AliDebug ( AliLog::kDebug+2,Form ( "NumArray1 = %d\tNumArray2 = %d",array1->GetSize(),array2->GetSize() ) );
+
+  fCurrentCutMgr= ( AliRsnCutMgr* ) fCutMgrs.UncheckedAt ( index );
+  Int_t startj=0;
+  Double_t effMass=0;
+  Double_t histMin = fPairDef.GetMin();
+  Double_t histMax = fPairDef.GetMax();
+  AliRsnDaughter *daughter1=0;
+  AliRsnDaughter *daughter2=0;
+  Int_t  howManuFilledHist=0;
+  for ( Int_t i=0;i<array1->GetSize();i++ )
+  {
+
+
+    daughter1 = ( AliRsnDaughter * ) event1->GetTrack(array1->At ( i ) );
+    if ( !daughter1 ) continue;
+
+    if ( fCurrentCutMgr )
+      if ( ! ( fCurrentCutMgr->IsSelected ( AliRsnCut::kParticle,daughter1 ) ) ) continue;
+
+    daughter2 = 0;
+    if ( fIsSignSame ) startj=i+1;
+    for ( Int_t j=startj;j<array2->GetSize();j++ )
+    {
+      daughter2 = ( AliRsnDaughter * ) event2->GetTrack(array2->At ( j ) );
+      if ( !daughter2 ) continue;
+
+      if ( fCurrentCutMgr )
+        if ( ! ( fCurrentCutMgr->IsSelected ( AliRsnCut::kParticle,daughter2 ) ) ) continue;
+
+//       AliRsnPairParticle effMassPart;
+      fEffMassParticle.FillPairParticle( daughter1 ,daughter2 );
+      if ( fCurrentCutMgr )
+        if ( ! ( fCurrentCutMgr->IsSelected ( AliRsnCut::kPair,&fEffMassParticle ) ) ) continue;
+
+
+      if ( fMass[0]<0.0&&fMass[1]<0.0 )
+        effMass =  fEffMassParticle.GetESDEffectiveMass() ;
+      else
+        effMass =  fEffMassParticle.GetESDEffectiveMass ( fMass[0],fMass[1] ) ;
+
+//       if ( fIsSignSame )
+//         if ( effMass < 0.988 )
+//       {
+      //
+//         effMassPart.PrintInfo("pt");
+//         AliInfo(Form("effMass = %f",effMass));
+//       }
+
+
+      if ( fIsFilledOnlyInHistRange )
+        if ( ! ( ( effMass>=histMin ) && ( effMass<=histMax ) ) ) continue;
+
+      hist->Fill ( effMass );
+
+      howManuFilledHist++;
+      AliDebug ( AliLog::kDebug+2,Form ( "i=%d j=%d",i,j ) );
+    }
+  }
+
+//   AliInfo (Form ( "%d",tmpNum));
+
+  AliDebug ( AliLog::kDebug+2,Form ( "NumOfFilledHist = %d",howManuFilledHist ) );
+
+  AliDebug ( AliLog::kDebug+2,"->" );
+}
+
+void AliRsnPair::DoLoopPairMC ( AliRsnEvent * event1, TArrayI * array1, AliRsnEvent * event2, TArrayI * array2, TH1F * hist, Int_t index )
+{
+  AliDebug ( AliLog::kDebug+2,"<-" );
+
+  AliDebug ( AliLog::kDebug+2,Form ( "NumArray1 = %d\tNumArray2 = %d",array1->GetSize(),array2->GetSize() ) );
+
+  fCurrentCutMgr = ( AliRsnCutMgr* ) fCutMgrs.UncheckedAt ( index );
+  Int_t startj=0;
+  Double_t effMass=0;
+  Double_t histMin = fPairDef.GetMin();
+  Double_t histMax = fPairDef.GetMax();
+  AliRsnDaughter *daughter1=0;
+  AliRsnDaughter *daughter2=0;
+  Int_t  howManuFilledHist=0;
+  Bool_t isSignal=kFALSE;
+  for ( Int_t i=0;i<array1->GetSize();i++ )
+  {
+
+    daughter1 = ( AliRsnDaughter * ) event1->GetTrack( array1->At ( i ) );
+    if ( !daughter1 ) continue;
+
+    if ( fCurrentCutMgr )
+      if ( ! ( fCurrentCutMgr->IsSelected ( AliRsnCut::kParticle,daughter1 ) ) ) continue;
+
+    daughter2 = 0;
+    if ( fIsSignSame ) startj=i+1;
+    for ( Int_t j=startj;j<array2->GetSize();j++ )
+    {
+      daughter2 = ( AliRsnDaughter * ) event2->GetTrack(array2->At ( j ) );
+      if ( !daughter2 ) continue;
+
+      if ( fCurrentCutMgr )
+        if ( ! ( fCurrentCutMgr->IsSelected ( AliRsnCut::kParticle,daughter2 ) ) ) continue;
+
+//       AliRsnPairParticle effMassPart;
+      fEffMassParticle.FillPairParticle( daughter1 ,daughter2 );
+      if ( fCurrentCutMgr )
+        if ( ! ( fCurrentCutMgr->IsSelected ( AliRsnCut::kPair,&fEffMassParticle ) ) ) continue;
+
+      
+      if ( ( fPairType == kMCSignalOnly ) || ( fPairType == kMCBackgroundOnly ) )
+      {
+        isSignal = ( daughter1->GetMCInfo()->MotherPDG() == fPairDef.GetMotherPDG() ) && ( daughter2->GetMCInfo()->MotherPDG() == fPairDef.GetMotherPDG() );
+        if ( ( fPairType == kMCSignalOnly ) && ( !isSignal ) ) continue;
+        if ( ( fPairType == kMCBackgroundOnly ) && ( isSignal ) ) continue;
+      }
+      
+      if ( fMass[0]<0.0&&fMass[1]<0.0 )
+        effMass =  fEffMassParticle.GetMCEffectiveMass() ;
+      else
+        effMass =  fEffMassParticle.GetMCEffectiveMass ( fMass[0],fMass[1] ) ;
+
+//       if ( fIsSignSame )
+//         if ( effMass < 0.988 )
+//       {
+      //
+//         effMassPart.PrintInfo("pt");
+//         AliInfo(Form("effMass = %f",effMass));
+//       }
+
+
+      if ( fIsFilledOnlyInHistRange )
+        if ( ! ( ( effMass>=histMin ) && ( effMass<=histMax ) ) ) continue;
+
+      hist->Fill ( effMass );
+
+      howManuFilledHist++;
+      AliDebug ( AliLog::kDebug+2,Form ( "i=%d j=%d",i,j ) );
     }
-    else {
-        // analysis without PID: directly take the two arrays with all particles of a given sign
-        list1 = event1->GetCharged(fCharge[0]);
-        list2 = event2->GetCharged(fCharge[1]);
+  }
+
+//   AliInfo (Form ( "%d",tmpNum));
+
+  AliDebug ( AliLog::kDebug+2,Form ( "NumOfFilledHist = %d",howManuFilledHist ) );
+
+  AliDebug ( AliLog::kDebug+2,"->" );
+}
+
+void AliRsnPair::DoESDNoPID ( AliRsnEvent * event, TH1F * hist ,Int_t index )
+{
+
+  Char_t chargeChar1 = fPairDef.GetCharge ( 0 );
+  Char_t chargeChar2 = fPairDef.GetCharge ( 1 );
+  
+  Int_t chargeIndex1 = fPairDef.GetCharge ( 0 ) =='+'? 0 : 1;
+  Int_t chargeIndex2 = fPairDef.GetCharge ( 1 ) =='+'? 0 : 1;
+  
+  fIsSignSame = ( chargeIndex1 == chargeIndex2 );
+  Int_t numOfTracks = event->GetMultiplicity();
+//   if (numOfTracks<=0) return;
+  
+//   AliInfo(Form("%d", numOfTracks));
+  Int_t counter1=0,counter2=0;
+  TArrayI array1 ( numOfTracks ),array2 ( numOfTracks );
+  TArrayI *arraytmp=0;
+//   AliRsnDaughter *dtmp=0;
+  Int_t j;
+  for ( Int_t i=0; i < AliRsnPID::kSpecies ;i++ )
+  {
+    arraytmp = ( TArrayI* ) event->GetTracksArray ( chargeChar1, (AliRsnPID::EType )i );
+    for ( j=0;j< arraytmp->GetSize();j++ )
+    {
+      array1.AddAt ( arraytmp->At ( j ),counter1++ );
     }
-    
-    /*
-    TRefArray *list[2];
-    Short_t i;
-    for (i = 0; i < 2; i++) {
-        if (usePID) {
-            // analysis with PID: only two collections are processed
-          list[i] = event1->GetTracks(fCharge[i], fType[i]);
-        }
-        else {
-            // analysis without PID: directly take the two arrays with all particles of a given sign
-          list[i] = event1->GetCharged(fCharge[i]);
-        }
+    arraytmp = ( TArrayI* ) event->GetTracksArray ( chargeChar2, (AliRsnPID::EType )i );
+    for ( j=0;j< arraytmp->GetSize();j++ )
+    {
+      array2.AddAt ( arraytmp->At ( j ),counter2++ );
     }
-    Stat_t nPairs = Fill(list[0], list[1], skipSameIndex);
-    */
-    
-    Stat_t nPairs = Fill(list1, list2, skipSameIndex);
-    return nPairs;
+  }
+
+  array1.Set ( counter1 );
+  array2.Set ( counter2 );
+
+//   AliInfo(Form("%d %d",array1.GetSize(),array2.GetSize()));
+  DoLoopPairESD ( event,&array1,event,&array2,hist,index );
+
 }
-//--------------------------------------------------------------------------------------------------------
-Stat_t AliRsnPair::Fill(TRefArray *list1, TRefArray *list2, Bool_t skipSameIndex)
+
+void AliRsnPair::DoESDNoPIDMix ( AliRsnEvent * event, TH1F * hist, Int_t index )
 {
-//
-// [PRIVATE METHOD]
-// This is the core of the pair work flow.
-// It loops on all particles contained in the two lists passed as arguments,
-// and for each pair it computes the invariant mass and fills its histogram.
-// Third argument (skipSameIndex) is a security flag: 
-// when the two lists come from the same event, two tracks with the same index 
-// must not be summed, and setting to kTRUE this flag this is ensured.
-// When it is kFALSE, this check is not done (event mixing).
-// ---
-// Before starting the operation, it checks that the two arguments are meaningful.
-// ---
-// Return value is the number of pairs processed.
-//
-
-       // define two 'cursor' objects
-       AliRsnDaughter *track1 = 0, *track2 = 0;
-       
-       // preliminary checks
-       if (!list1) {
-               AliError("List #1 cannot be NULL.");
-               return 0.0;
-       }
-    if (!list2) {
-               AliError("List #2 cannot be NULL.");
-               return 0.0;
-       }
+
+  Char_t chargeChar1 = fPairDef.GetCharge ( 0 );
+  Char_t chargeChar2 = fPairDef.GetCharge ( 1 );
+  
+  Int_t chargeIndex1 = fPairDef.GetCharge ( 0 ) =='+'? 0 : 1;
+  Int_t chargeIndex2 = fPairDef.GetCharge ( 1 ) =='+'? 0 : 1;
+  
+  fIsSignSame = ( chargeIndex1 == chargeIndex2 );
+
+  Long64_t currBuffIndex = GetRsnMVEventBuffer()->GetEventsBufferIndex();
+  if ( currBuffIndex < 2 ) return;
+
+  
+  AliRsnEvent *evCurrEvent = ( AliRsnEvent * ) GetRsnMVEventBuffer()->GetEvent ( currBuffIndex-1 );
+  if ( ! evCurrEvent ) {AliWarning ( Form ( "Event Not found" ) ); return;}
+  
+  Int_t numOfTracks = evCurrEvent->GetMultiplicity();
+  Int_t counter1=0;
+  TArrayI arrayCurrEvent ( numOfTracks );
+  TArrayI *arraytmp=0;
+  Int_t j;
+  for ( Int_t i=0; i < AliRsnPID::kSpecies ;i++ )
+  {
+    arraytmp = ( TArrayI* ) evCurrEvent->GetTracksArray ( chargeChar1,(AliRsnPID::EType ) i );
+    for ( j=0;j< arraytmp->GetSize();j++ )
+    {
+      arrayCurrEvent.AddAt ( arraytmp->At ( j ),counter1++ );
+    }
+  }
+  
+  arrayCurrEvent.Set ( counter1 );
+  
+  Int_t numMix = 0;
+  for ( Int_t i=currBuffIndex-2;i>=0;i-- )
+  {
+    if ( ++numMix>fNumOfMixEvent ) break;
+
+
+    AliRsnEvent *evMix = ( AliRsnEvent * ) GetRsnMVEventBuffer()->GetEvent ( i ) ;
+//     if ( ! evMix ) {AliWarning ( Form ( "Event evMix Not found" ) ); continue;}
+    numOfTracks = evMix->GetMultiplicity();
+    Int_t counter2=0;
+    TArrayI arrayMix ( numOfTracks );
+    arraytmp=0;
+    for ( Int_t i=0; i < AliRsnPID::kSpecies ;i++ )
+    {
+      arraytmp = ( TArrayI* ) evMix->GetTracksArray ( chargeChar2,(AliRsnPID::EType ) i );
+      if (arraytmp->GetSize() > numOfTracks) {AliError(Form("%d %d",arraytmp->GetSize(),numOfTracks));continue;}
+      for ( j=0;j< arraytmp->GetSize();j++ )
+      {
+        arrayMix.AddAt ( arraytmp->At ( j ),counter2++ );
+      }
+    }
     
-    // create histogram if it is not present
-       if (!fHistogram) {
-               AliError("Histogram undefined.");
-               return 0.0;
-       }
-       
-       // define iterators for the two collections
-       TRefArrayIter iter1(list1);
-       TRefArrayIter iter2(list2);
-       
-       // define temporary variables for better code readability
-       Stat_t nPairs = 0;
-       Int_t  pdgRef = TMath::Abs(fTrueMotherPDG);
-       
-       // loop on particle of type 1 (in 'event1')
-       while ( (track1 = (AliRsnDaughter*)iter1.Next()) ) {
-               // check against impact parameter cut
-        if (fVtMax > 0.0 && track1->Vt() > fVtMax) continue;
-        // check against 1-particle cuts (particle type #1)
-        if (!SingleCutCheck(0, track1)) continue;
-               // loop on particles of type #2 (in 'event2')
-               iter2.Reset();
-               while ( (track2 = (AliRsnDaughter*)iter2.Next()) ) {
-                       // skip the case when particle 2 is the same as particle 1
-                       if (skipSameIndex && (track1->Index() == track2->Index())) continue;
-            // check against impact parameter cut
-            if (fVtMax > 0.0 && track2->Vt() > fVtMax) continue;
-                       // check against 1-particle cuts (particle type #2)
-                       if (!SingleCutCheck(1, track2)) continue;
-                       // check against 2-particle cuts
-                       if (!PairCutCheck(track1, track2)) continue;
-                       // compute total 4-momentum
-                       track1->SetM(fMass[0]);
-                       track2->SetM(fMass[1]);
-                       AliRsnDaughter sum = AliRsnDaughter::Sum(*track1, *track2);
-            // reject wrong pairs with mass = 0
-            if (sum.M() <= 1E-4) continue;
-            // check transverse momentum bin
-            if (fPtMin > 0.0 && sum.Pt() < fPtMin) continue;
-            if (fPtMax > 0.0 && sum.Pt() > fPtMax) continue;
-                       // if the choice to get ONLY true pairs is selected, a check is made on the mothers
-                        if (fStoreOnlyTrue) {
-                            AliRsnParticle *part = sum.GetParticle();
-                            if (!part) continue;
-                            if (TMath::Abs(part->PDG()) != pdgRef) continue;
-            }
-                       // fill histogram
-                       fHistogram->Fill(sum.M());
-                       nPairs++;
-               } // end loop 2
-       } // end loop 1
-       
-       return nPairs;
+    arrayMix.Set ( counter2  );
+    DoLoopPairESD ( evCurrEvent,&arrayCurrEvent,evMix,&arrayMix,hist,index );
+  }
 }
-//--------------------------------------------------------------------------------------------------------
-Bool_t AliRsnPair::SingleCutCheck(Int_t ipart, AliRsnDaughter *track) const
+
+void AliRsnPair::DoESDNormal ( AliRsnEvent * event, TH1F * hist ,Int_t index )
+{
+
+  Int_t chargeIndex1 = fPairDef.GetCharge ( 0 ) =='+'? 0 : 1;
+  Int_t chargeIndex2 = fPairDef.GetCharge ( 1 ) =='+'? 0 : 1;
+  fIsSignSame = ( chargeIndex1 == chargeIndex2 );
+
+  TArrayI *array1 = ( TArrayI* ) event->GetTracksArray ( chargeIndex1, fPairDef.GetType( 0 ) );
+  TArrayI *array2 = ( TArrayI* ) event->GetTracksArray ( chargeIndex2, fPairDef.GetType( 1 ) );
+  
+  DoLoopPairESD ( event, array1,event,array2,hist,index );
+}
+
+void AliRsnPair::PrepareMixForPair ( AliRsnEvent * event,TTree *tree )
+{
+}
+
+void AliRsnPair::DoESDMix ( AliRsnEvent * event, TH1F * hist, Int_t index )
+{
+  Int_t chargeIndex1 = fPairDef.GetCharge ( 0 ) =='+'? 0 : 1;
+  Int_t chargeIndex2 = fPairDef.GetCharge ( 1 ) =='+'? 0 : 1;
+  fIsSignSame = ( chargeIndex1 == chargeIndex2 );
+
+  Long64_t currBuffIndex = GetRsnMVEventBuffer()->GetEventsBufferIndex();
+  if ( currBuffIndex < 2 ) return;
+
+  AliRsnEvent *evCurrEvent = ( AliRsnEvent * ) GetRsnMVEventBuffer()->GetEvent ( currBuffIndex-1 );
+  if ( ! evCurrEvent ) {AliWarning ( Form ( "Event Not found" ) ); return;}
+  TArrayI  *arrayCurrEvent = ( TArrayI* ) evCurrEvent->GetTracksArray ( chargeIndex1, fPairDef.GetType ( 0 ) );
+
+  Int_t numMix = 0;
+  TArrayI* arrayMix=0;
+  for ( Int_t i=currBuffIndex-2;i>=0;i-- )
+  {
+    if ( ++numMix>fNumOfMixEvent ) break;
+
+
+    AliRsnEvent *evMix = ( AliRsnEvent * ) GetRsnMVEventBuffer()->GetEvent ( i ) ;
+    if ( ! evMix ) {AliWarning ( Form ( "Event Not found" ) ); continue;}
+    arrayMix = ( TArrayI* ) evMix->GetTracksArray ( chargeIndex2,fPairDef.GetType ( 1 ) );
+    DoLoopPairESD ( evCurrEvent,arrayCurrEvent,evMix,arrayMix,hist,index );
+  }
+
+}
+
+void AliRsnPair::DoMCNoPID ( AliRsnEvent * event, TH1F * hist ,Int_t index )
 {
-//
-// [PRIVATE METHOD]
-// Checks a track against single particle cuts (if defined)
-//
-
-       if (ipart < 0 || ipart > 1) {
-               AliError(Form("Required cuts collection for particle index %d [allowed 0 or 1]", ipart));
-               return kFALSE;
-       }
-       if (!fCutsSingle[ipart]) return kTRUE;
-    if (fCutsSingle[ipart]->IsEmpty()) return kTRUE;
-               
-       TObjArrayIter iter(fCutsSingle[ipart]);
-       AliRsnDaughterCut *cut = 0;
-       while ( (cut = (AliRsnDaughterCut*)iter.Next()) ) {
-               if (!cut->Pass(track)) return kFALSE;
-       }
-       
-       return kTRUE;
+
+/*
+  Int_t chargeIndex1 = fPairDef.GetCharge ( 0 ) =='+'? 0 : 1;
+  Int_t chargeIndex2 = fPairDef.GetCharge ( 1 ) =='+'? 0 : 1;
+  fIsSignSame = ( chargeIndex1 == chargeIndex2 );
+
+//   TRefArray array1,array2;
+//   TRefArray *arraytmp=0;
+//   AliRsnDaughter *dtmp=0;
+//   for ( Int_t i=0; i < AliRsnPID::kSpecies ;i++ )
+//   {
+//     arraytmp = ( TRefArray* ) event->GetMCTrackRefs ( chargeIndex1, i );
+//     for ( Int_t j=0;j< arraytmp->GetEntriesFast();j++ )
+//     {
+//       dtmp = ( AliRsnDaughter * ) arraytmp->At ( j );
+//       array1.Add ( dtmp );
+//     }
+//     arraytmp = ( TRefArray* ) event->GetMCTrackRefs ( chargeIndex2, i );
+//     for ( Int_t j=0;j< arraytmp->GetEntriesFast();j++ )
+//     {
+//       dtmp = ( AliRsnDaughter * ) arraytmp->At ( j );
+//       array2.Add ( dtmp );
+//     }
+//   }
+//   DoLoopPairMC ( &array1,&array2,hist,index );
+
+  Int_t numOfTracks = event->GetMultiplicity();
+//   AliInfo(Form("%d",numOfTracks));
+  Int_t counter1=0,counter2=0;
+  TArrayI array1 ( numOfTracks ),array2 ( numOfTracks );
+  TArrayI *arraytmp=0;
+  Int_t j;
+  for ( Int_t i=0; i < AliRsnPID::kSpecies ;i++ )
+  {
+    arraytmp = ( TArrayI* ) event->GetMCTrackArray ( chargeIndex1, i );
+    for ( j=0;j< arraytmp->GetSize();j++ )
+    {
+      array1.AddAt ( arraytmp->At ( j ),counter1++ );
+    }
+    arraytmp = ( TArrayI* ) event->GetMCTrackArray ( chargeIndex2, i );
+    for ( j=0;j< arraytmp->GetSize();j++ )
+    {
+      array2.AddAt ( arraytmp->At ( j ),counter2++ );
+    }
+  }
+
+  array1.Set ( counter1 );
+  array2.Set ( counter2 );
+
+//   AliInfo(Form("%d %d",array1.GetSize(),array2.GetSize()));
+  DoLoopPairMC ( event,&array1,event,&array2,hist,index );*/
+
 }
-//--------------------------------------------------------------------------------------------------------
-Bool_t AliRsnPair::PairCutCheck(AliRsnDaughter *track1, AliRsnDaughter *track2) const
+
+void AliRsnPair::DoMCNormal ( AliRsnEvent * event, TH1F * hist ,Int_t index )
 {
-//
-// [PRIVATE METHOD]
-// Checks a pair against pair cuts (if defined)
-//
-       if (fCutsPair == 0x0) return kTRUE;
-    if (fCutsPair->IsEmpty()) return kTRUE;
-       
-       TObjArrayIter iter(fCutsPair);
-       AliRsnDaughterCutPair *cut = 0;
-       while ( (cut = (AliRsnDaughterCutPair*)iter.Next()) ) {
-               if (!cut->Pass(track1, track2)) return kFALSE;
-       }
-       
-       return kTRUE;
+//   Int_t chargeIndex1 = fPairDef.GetCharge ( 0 ) =='+'? 0 : 1;
+//   Int_t chargeIndex2 = fPairDef.GetCharge ( 1 ) =='+'? 0 : 1;
+//   fIsSignSame = ( chargeIndex1 == chargeIndex2 );
+// //   TRefArray *array1 = ( TRefArray* ) event->GetMCTrackRefs ( chargeIndex1, ( Int_t ) fPairDef.GetESDParticle ( 0 ) );
+// //   TRefArray *array2 = ( TRefArray* ) event->GetMCTrackRefs ( chargeIndex2, ( Int_t ) fPairDef.GetESDParticle ( 1 ) );
+// //
+// //   DoLoopPairMC ( array1,array2,hist,index );
+// 
+//   TArrayI *array1 = ( TArrayI* ) event->GetMCTrackArray ( chargeIndex1, ( Int_t ) fPairDef.GetESDParticle ( 0 ) );
+//   TArrayI *array2 = ( TArrayI* ) event->GetMCTrackArray ( chargeIndex2, ( Int_t ) fPairDef.GetESDParticle ( 1 ) );
+//   DoLoopPairMC ( event, array1, event,array2,hist,index );
+// 
+
 }
+
+
index 21ebc03..874f612 100644 (file)
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               *
- **************************************************************************/
-
-//-------------------------------------------------------------------------
-//                      Class AliRsnAnalysis
-//             Reconstruction and analysis of K* Rsn
-// ........................................
-// ........................................
-// ........................................
-// ........................................
-// 
-// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
-//-------------------------------------------------------------------------
-
-#ifndef ALIRSNPAIR_H
-#define ALIRSNPAIR_H
-
-#include <TNamed.h>
+#ifndef ALIRSNMVPAIR_H
+#define ALIRSNMVPAIR_H
+
+#include <TObject.h>
+#include <TH1.h>
+#include <TClonesArray.h>
+#include <TTree.h>
+
+#include "AliRsnDaughter.h"
+#include "AliRsnPairParticle.h"
+#include "AliRsnCutSet.h"
+#include "AliRsnCutMgr.h"
+#include "AliRsnPairDef.h"
 #include "AliRsnPID.h"
 
-class TH1D;
-class TRefArray;
-class TObjArray;
+#include "AliRsnEventBuffer.h"
+
 class AliRsnEvent;
-class AliRsnDaughter;
-class AliRsnDaughterCut;
-class AliRsnDaughterCutPair;
+class AliRsnCut;
+
 
-class AliRsnPair : public TNamed
+/**
+  @author Martin Vala <Martin.Vala@cern.ch>
+*/
+class AliRsnPair : public TObject
 {
+  public:
+    enum EPairType
+    {
+      kESDNoPID = 0,kESDNoPIDMix,
+      kESDNormal, kESDMix,
+      kMCNoPID,
+      kMCNormal, kMCMix,
+      kMCSignalOnly, kMCBackgroundOnly,
+      kLastIndex
+    };
+
+    AliRsnPair();
+    AliRsnPair ( AliRsnPair::EPairType type , AliRsnPairDef *pairDef,Int_t numOfMix = 0 );
+    ~AliRsnPair();
+
+    TString         GetESDParticleName ( AliRsnPID::EType type );
+    TString         GetPairTypeName ( EPairType type );
+
+    TH1F            *GenerateEffMassHist ( Int_t index = 0 );
+
+    void            ProcessPair ( AliRsnEvent *event,TH1F *hist,Int_t index=0 );
+
+    void            DoCleanUpAfterOneEvent();
+
+    void            AddCutMgr ( AliRsnCutMgr* theValue );
+    AliRsnCutMgr* GetCutMgr ( Int_t index ) { return ( AliRsnCutMgr* ) fCutMgrs.At ( index );}
+    TObjArray*      GetCutMgr () { return &fCutMgrs;}
+    Int_t           GetNumOfCutMgr () { return fCutMgrs.GetEntriesFast();}
+
+    void SetMass ( Double_t theValue ) { fMass[0] = theValue; fMass[1] = theValue;}
+    void SetMass ( Double_t theValue , Int_t index ) { fMass[index] = theValue; }
+    Double_t GetMass ( Int_t index=0 ) const { return fMass[index]; }
+
+    TString GetEffMassHistName ( Int_t index = 0 );
+    TString GetEffMassHistTitle ( Int_t index = 0 );
+
+    void SetNumOfMixEvent ( const Int_t& theValue ) { fNumOfMixEvent = theValue; }
+    Int_t GetNumOfMixEvent() const { return fNumOfMixEvent;}
+
+    void SetIsFilledOnlyInHistRange ( const Bool_t& theValue ) { fIsFilledOnlyInHistRange = theValue; }
+
+    void                    PrepareMixForPair ( AliRsnEvent * event,TTree *tree );
+
+    void SetRsnMVEventBuffer ( AliRsnEventBuffer* theValue ) { fRsnMVEventBuffer = theValue; }
+    AliRsnEventBuffer* GetRsnMVEventBuffer() const { return fRsnMVEventBuffer; }
+
+
+  private:
+
+    AliRsnPairDef          fPairDef;                // pair definition
+    AliRsnPair::EPairType  fPairType;               // pair type
+  
+    AliRsnCutMgr          *fCurrentCutMgr;          // cut manager
+    TObjArray               fCutMgrs;               // array of cuts
+
+    Double_t                fMass[2];               // mass for nopid
+
+    AliRsnPairParticle      fEffMassParticle;
+
+    Int_t                   fNumOfMixEvent;         // number of events to be mix with current one
+    AliRsnEventBuffer      *fRsnMVEventBuffer;      // event buffer for event mixing
+
+    Bool_t                  fIsSignSame;            // flag for same sign
+
+    Bool_t                  fIsFilledOnlyInHistRange; // flag filling histogram
+
+    void                    DoLoopPairESD ( AliRsnEvent *event1, TArrayI *array1,AliRsnEvent *event2, TArrayI *array2 ,TH1F *hist,Int_t index=0 );
+    void                    DoLoopPairMC ( AliRsnEvent *event1, TArrayI*array1,AliRsnEvent *event2, TArrayI*array2 ,TH1F *hist,Int_t index=0 );
+
+    void                    DoESDNoPID ( AliRsnEvent *event,TH1F *hist ,Int_t index=0 );
+    void                    DoESDNoPIDMix ( AliRsnEvent *event,TH1F *hist,Int_t index=0 );
+    void                    DoESDNormal ( AliRsnEvent *event,TH1F *hist,Int_t index=0 );
+    void                    DoESDMix ( AliRsnEvent *event,TH1F *hist,Int_t index=0 );
+
+    void                    DoMCNoPID ( AliRsnEvent *event,TH1F *hist,Int_t index=0 );
+    void                    DoMCNormal ( AliRsnEvent *event,TH1F *hist,Int_t index=0 );
 
-public:
-       
-       AliRsnPair();
-       AliRsnPair(const char *name, const char *title, 
-                  Int_t nbins, Double_t min, Double_t max,
-                  Double_t ptmin = 0., Double_t ptmax = 0., Double_t dmax = 0.);
-       AliRsnPair(const AliRsnPair &copy);
-       const AliRsnPair& operator=(const AliRsnPair &copy);
-       virtual ~AliRsnPair() {Clear();}
-       virtual void Clear(Option_t *option = "");
-       
-       /* getters */
-       TH1D*             GetHistogram() {return fHistogram;}
-       Char_t            GetCharge(Int_t i) const {if (i>=0&&i<2) return fCharge[i]; else return 0;}
-       AliRsnPID::EType  GetParticle(Int_t i) const {if (i>=0&&i<2) return fType[i]; else return AliRsnPID::kUnknown;}
-       Double_t          GetMass(Int_t i) const {if (i>=0&&i<2) return fMass[i]; else return 0.0;}
-       Bool_t            StoreOnlyTruePairs() const {return fStoreOnlyTrue;}
-       Bool_t            IsForMixing() const {return fForMixing;}
-       
-       /* setters */
-       void SetMass(Int_t i, Double_t value) {if (i>=0&&i<2) fMass[i] = value;}
-       void SetTrueMotherPDG(Int_t pdg) {fTrueMotherPDG = pdg;}
-       void SetPair(Char_t charge1, AliRsnPID::EType pid1, Char_t charge2, AliRsnPID::EType pid2);
-    void SetPtBin(Double_t min, Double_t max) {fPtMin = min; fPtMax = max;}
-    void SetImpactMax(Double_t max) {fVtMax = max;}
-    void SetStoreOnlyTrue(Bool_t doit = kTRUE) {fStoreOnlyTrue = doit;}
-    void SetForMixing(Bool_t doit = kTRUE) {fForMixing = doit;}
-       
-       /* working parameters */
-       void   AddCutPair(AliRsnDaughterCutPair *cut);
-       void   AddCutSingle(Int_t i, AliRsnDaughterCut *cut);
-       Stat_t Process(AliRsnEvent *event1, AliRsnEvent *event2 = 0, Bool_t usePID = kTRUE);
-       
-private:
-
-       /* private functions */
-       void   InitHistogram(Int_t nbins, Double_t min, Double_t max);
-       Bool_t SingleCutCheck(Int_t ipart, AliRsnDaughter *track) const;
-       Bool_t PairCutCheck(AliRsnDaughter *track1, AliRsnDaughter *track2) const;
-    Stat_t Fill(TRefArray *list1, TRefArray *list2, Bool_t skipSameIndex = kTRUE);
-
-       /* flags */
-       Bool_t               fForMixing;       // flag is true for objects created for event mixing
-       Bool_t               fStoreOnlyTrue;   // output = only spectra of true pairs
-       
-       /* parameters */
-       Int_t                fTrueMotherPDG;   // PDG code of true mother (if known)
-       Double_t             fMass[2];         // nominal mass of particles
-       Char_t               fCharge[2];       // charge of particles
-       AliRsnPID::EType     fType[2];         // particles types
-    
-    /* basic cuts */
-    Double_t             fPtMin;           // minimum allowed pt for the pair
-    Double_t             fPtMax;           // maximum allowed pt for the pair
-    Double_t             fVtMax;           // maximum transverse impact parameter for each track
-       
-       /* cuts */
-       TObjArray           *fCutsSingle[2];   // single-particle cuts
-       TObjArray           *fCutsPair;        // pair cuts
-       
-       /* output */
-       TH1D                *fHistogram;       // invariant mass distribution
-       
-       /* ROOT dictionary */
-       ClassDef(AliRsnPair, 1) 
+    ClassDef ( AliRsnPair, 1 );
 };
 
 #endif