Package upgrade.
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 23 Jun 2008 17:37:56 +0000 (17:37 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 23 Jun 2008 17:37:56 +0000 (17:37 +0000)
After discussion and merging strategy with Martin Vala, we defined a common base for our
internal AOD (AliRsnEvent & AliRsnDaughter) and for the cut system.
We defined the read standards for conversion from ESD and AOD or MC, and some support
classes for analysis. The "Simple" classes work for a simpler version of analysis which
is complete but probably could be improved.
This is a version which works, but it waits for another contribution which is in
development.

40 files changed:
PWG2/RESONANCES/AliRsnAnalysisAT.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisAT.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisSimple.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisSimple.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisSimpleTask.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalysisSimpleTask.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalyzerSimple.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnAnalyzerSimple.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnBaseAT.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnBaseAT.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCut.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCut.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutMgr.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutMgr.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutSet.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnCutSet.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnDaughter.cxx
PWG2/RESONANCES/AliRsnDaughter.h
PWG2/RESONANCES/AliRsnEvent.cxx
PWG2/RESONANCES/AliRsnEvent.h
PWG2/RESONANCES/AliRsnEventBuffer.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnEventBuffer.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnMCInfo.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnMCInfo.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPID.cxx
PWG2/RESONANCES/AliRsnPID.h
PWG2/RESONANCES/AliRsnPIDIndex.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPIDIndex.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPIDWeightsMgr.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairDef.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairDef.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairParticle.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairParticle.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairSimple.cxx [new file with mode: 0644]
PWG2/RESONANCES/AliRsnPairSimple.h [new file with mode: 0644]
PWG2/RESONANCES/AliRsnReader.cxx
PWG2/RESONANCES/AliRsnReader.h
PWG2/RESONANCES/AliRsnReaderTaskSE.cxx [moved from PWG2/RESONANCES/AliRsnReaderTask.cxx with 53% similarity]
PWG2/RESONANCES/AliRsnReaderTaskSE.h [moved from PWG2/RESONANCES/AliRsnReaderTask.h with 60% similarity]

diff --git a/PWG2/RESONANCES/AliRsnAnalysisAT.cxx b/PWG2/RESONANCES/AliRsnAnalysisAT.cxx
new file mode 100644 (file)
index 0000000..6e4ed0f
--- /dev/null
@@ -0,0 +1,280 @@
+#include <TSystem.h>
+#include <TFile.h>
+
+#include "AliLog.h"
+
+#include "AliAnalysisManager.h"
+#include "AliRsnPairMgr.h"
+#include "AliRsnEventBuffer.h"
+
+#include "AliMCEventHandler.h"
+
+#include "AliRsnAnalysisAT.h"
+
+ClassImp ( AliRsnAnalysisAT )
+AliRsnAnalysisAT::AliRsnAnalysisAT ( const char * name )
+    : AliRsnBaseAT ( name )
+{
+  InitIOVars ();
+  DefineInput ( 1, AliRsnPairMgr::Class() );
+
+  DefineOutput ( 0, TList::Class() );
+}
+
+AliRsnAnalysisAT::~AliRsnAnalysisAT()
+{
+}
+
+void AliRsnAnalysisAT::InitIOVars()
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+  AliRsnBaseAT::InitIOVars();
+
+  fPairMgr = 0;
+  fRsnMVEventBuffer = 0;
+  fOutList = 0;
+
+  for ( Int_t i=0;i<100 ;i++ )
+    for ( Int_t j=0;j<100 ;j++ )
+    {
+      fHist[i][j] = 0;
+    }
+
+  AliDebug ( AliLog::kDebug, "->" );
+}
+
+void AliRsnAnalysisAT::LocalInit()
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+  fPairMgr = dynamic_cast<AliRsnPairMgr*> ( GetInputData ( 1 ) );
+  fPairMgr->PrintPairs();
+  AliDebug ( AliLog::kDebug, "->" );
+}
+
+Bool_t AliRsnAnalysisAT::Notify()
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+  fChain[0] = ( TChain* ) GetInputData ( 0 );
+  if ( fChain[0] )
+  {
+    TFile *f = fChain[0]->GetCurrentFile();
+    if ( f ) { AliInfo ( Form ( "Processing file %s",  f->GetName() ) );}
+    else AliError ( "fTree->GetCurrentFile() is 0" );
+    AliInfo ( Form ( "NumOfEvents %d",  fChain[0]->GetTree()->GetEntries() ) );
+  }
+  else
+  {
+    AliError ( "fChain[0] not available" );
+  }
+
+  AliDebug ( AliLog::kDebug, "->" );
+  return   AliRsnBaseAT::Notify();
+}
+
+void AliRsnAnalysisAT::CreateOutputObjects()
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+
+  fPairMgr = dynamic_cast<AliRsnPairMgr*> ( GetInputData ( 1 ) );
+  OpenFile ( 0 );
+  fOutList = new TList();
+
+  AliRsnPair *def=0;
+  for ( Int_t i=0;i< fPairMgr->GetPairs()->GetEntriesFast();i++ )
+  {
+    def = ( AliRsnPair * ) fPairMgr->GetPairs()->At ( i );
+    for ( Int_t j=0;j<def->GetCutMgr()->GetEntriesFast() ;j++ )
+    {
+      fHist[i][j] = def->GenerateEffMassHist ( j );
+      fOutList->Add ( fHist[i][j] );
+    }
+  }
+
+  fRsnMVEventBuffer = new AliRsnEventBuffer ( 1000 );
+//   fRsnMVEventBuffer = new AliRsnEventBuffer ( 100 ,kFALSE );
+  AliDebug ( AliLog::kDebug, "->" );
+
+}
+
+void AliRsnAnalysisAT::Exec ( Option_t * option )
+{
+  TTree *tree = ( ( TChain* ) GetInputData ( 0 ) )->GetTree();
+  Long64_t ientry = ( Long64_t ) tree->GetReadEntry();
+
+  if ( ientry%100==0 )
+    AliInfo ( Form ( "Event #%d",ientry ) );
+
+//   AliRsnEvent *curEvent = GetRsnMVEventFromInputType();
+//   if ( !curEvent ) { AliError ( "Could not get AliRsnEvent from GetRsnMVEventFromInputType(). Skipping..." ); return; }
+
+//   ProcessEventAnalysis ( curEvent );
+//   PostEventProcess();
+
+//   if (ientry%10000==0)
+//   AliInfo(Form("Event #%d",ientry));
+  PostData ( 0, fOutList );
+}
+
+void AliRsnAnalysisAT::Terminate ( Option_t * )
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+  fOutList = dynamic_cast<TList*> ( GetOutputData ( 0 ) );
+  if ( !fOutList ) { AliError ( " fOutList not available" ); return; }
+  fOutList->Print();
+
+  AliDebug ( AliLog::kDebug, "->" );
+}
+
+void AliRsnAnalysisAT::Cleanup()
+{
+  AliInfo ( Form ( "Cleaning up in worker %s ...",gSystem->HostName() ) );
+//   fRsnMVEventBuffer->ClearBuffer();
+//   AliRsnPair *def = ( AliRsnPair * ) fPairMgr->GetPairs()->At ( 0 );
+//   def->DoCleanUpAfterOneEvent();
+}
+
+void AliRsnAnalysisAT::ProcessEventAnalysis ( AliRsnEvent *curEvent )
+{
+
+
+
+  fRsnMVEventBuffer->AddEvent ( curEvent );
+  AliRsnPair *def=0;
+  AliRsnEvent *event=0;
+  Int_t numOfTracks;
+  for ( Int_t i=0;i< fPairMgr->GetPairs()->GetEntriesFast();i++ )
+  {
+    def = ( AliRsnPair * ) fPairMgr->GetPairs()->At ( i );
+    def->SetRsnMVEventBuffer ( fRsnMVEventBuffer );
+    for ( Int_t j=0;j<def->GetCutMgr()->GetEntriesFast() ;j++ )
+    {
+      event = fRsnMVEventBuffer->GetCurrentEvent();
+      numOfTracks = event->GetMultiplicity();
+//       AliInfo ( Form ( "%d",event->GetMultiplicity() ) );
+
+      if ( numOfTracks>0 )
+        def->ProcessPair ( event ,fHist[i][j] ,j );
+    }
+  }
+
+}
+
+
+
+AliRsnEvent * AliRsnAnalysisAT::GetRsnMVEventFromInputType ( const Short_t & index )
+{
+  switch ( fInputType[index] )
+  {
+    case kAOD:
+    {
+      return GetRsnMVFromAOD ( index );
+      break;
+    }
+    case kESD:
+    {
+      AliWarning ( "Not Implemented Yet ..." );
+      return GetRsnMVFromESD ( index );
+      break;
+    }
+    case kESDMC:
+    {
+      AliWarning ( "Not Implemented Yet ..." );
+      return GetRsnMVFromESDMC ( index );
+      break;
+    }
+    case kMC:
+      AliWarning ( "Not Implemented Yet ..." );
+      return ( AliRsnEvent* ) 0x0;
+      break;
+    case kRSN:
+    {
+      return GetRsnMVFromRSN();
+      break;
+    }
+    default:
+      AliError ( "Type not supported ..." );
+      return ( AliRsnEvent* ) 0x0;
+      break;
+  }
+  return ( AliRsnEvent* ) 0x0;
+}
+
+void AliRsnAnalysisAT::PostEventProcess ( const Short_t & index )
+{
+  switch ( fInputType[index] )
+  {
+    case kAOD:
+      break;
+    case kESD:
+      break;
+    case kESDMC:
+      break;
+    case kMC:
+      break;
+    case kRSN:
+    {
+      if ( fRsnMVEventBuffer->GetDeleteBufferWhenReset() == kFALSE )
+      {
+        fRSN[index] = ( AliRsnEvent* ) fRsnMVEventBuffer->GetNextEvent();
+        SetBranchAddress ( 0 , "RsnEvents", &fRSN[index] );
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+}
+
+AliRsnEvent * AliRsnAnalysisAT::GetRsnMVFromAOD ( const Short_t & index )
+{
+
+  if ( !fAOD[index] ) { AliError ( "fAOD not available." ); return ( AliRsnEvent * ) 0x0; }
+
+
+//   fRSN[0] = new AliRsnEvent();
+//   fRSN[0]->Init();
+//   fRSN[0]->BuildEvent ( fAOD[index] );
+//   return fRSN[0];
+
+  return ( AliRsnEvent* ) 0x0;
+
+}
+
+AliRsnEvent * AliRsnAnalysisAT::GetRsnMVFromESD ( const Short_t & index )
+{
+  if ( !fESD[index] ) { AliError ( "fESD not available." ); return ( AliRsnEvent * ) 0x0; }
+
+//   fRSN[0] = new AliRsnEvent();
+//   fRSN[0]->Init();
+//   fRSN[0]->BuildEvent ( fESD[index] );
+//   return fRSN[0];
+
+  return ( AliRsnEvent* ) 0x0;
+}
+
+AliRsnEvent * AliRsnAnalysisAT::GetRsnMVFromESDMC ( const Short_t & index )
+{
+
+  if ( !fESD[index] ) { AliError ( "fESD not available." ); return ( AliRsnEvent * ) 0x0; }
+  AliMCEventHandler* mcHandler = dynamic_cast<AliMCEventHandler*> ( AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler() );
+  if ( !mcHandler ) { AliError ( "Could not retrieve MC event handler" ); return ( AliRsnEvent * ) 0x0; }
+
+//   fRSN[0] = new AliRsnEvent();
+//   fRSN[0]->Init();
+//   fRSN[0]->BuildEvent ( fESD[index] ,mcHandler );
+//   return fRSN[0];
+
+  return ( AliRsnEvent* ) 0x0;
+}
+
+AliRsnEvent * AliRsnAnalysisAT::GetRsnMVFromRSN ( const Short_t & index )
+{
+  AliRsnEvent *event = fRSN[index];
+  if ( fRsnMVEventBuffer->GetDeleteBufferWhenReset() == kTRUE )
+  {
+    event = ( AliRsnEvent * ) fRSN[index]->Clone();
+  }
+//   AliInfo ( Form ( "%p %p",event,fRSN[index] ) );
+  return event;
+}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisAT.h b/PWG2/RESONANCES/AliRsnAnalysisAT.h
new file mode 100644 (file)
index 0000000..5841e79
--- /dev/null
@@ -0,0 +1,46 @@
+#ifndef AliRsnAnalysisAT_h
+#define AliRsnAnalysisAT_h
+
+#include "AliRsnBaseAT.h"
+
+class AliRsnEvent;
+
+/**
+  @author Martin Vala <Martin.Vala@cern.ch>
+*/
+class AliRsnAnalysisAT : public AliRsnBaseAT
+{
+  public:
+    AliRsnAnalysisAT ( const char *name = "AliRsnAnalysisAT");
+
+    ~AliRsnAnalysisAT();
+
+    virtual void    InitIOVars();
+    virtual void    LocalInit();
+    virtual Bool_t  Notify();
+    virtual void    CreateOutputObjects();
+    virtual void    Exec ( Option_t *option );
+    virtual void    Terminate ( Option_t * );
+    virtual void    Cleanup ();
+
+  private:
+    AliRsnPairMgr *fPairMgr;
+
+    TList           *fOutList;              // List of output
+    TH1F            *fHist[100][100];       // output histograms
+    
+    AliRsnEventBuffer *fRsnMVEventBuffer;
+    
+    void            ProcessEventAnalysis(AliRsnEvent *curEvent);
+    void            PostEventProcess(const Short_t &index=0);
+    AliRsnEvent*  GetRsnMVEventFromInputType(const Short_t &index=0);
+    
+    AliRsnEvent*  GetRsnMVFromAOD(const Short_t &index=0);
+    AliRsnEvent*  GetRsnMVFromESD(const Short_t &index=0);
+    AliRsnEvent*  GetRsnMVFromESDMC(const Short_t &index=0);
+    AliRsnEvent*  GetRsnMVFromRSN(const Short_t &index=0);
+    
+    ClassDef ( AliRsnAnalysisAT, 1 );
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnAnalysisSimple.cxx b/PWG2/RESONANCES/AliRsnAnalysisSimple.cxx
new file mode 100644 (file)
index 0000000..b4d60df
--- /dev/null
@@ -0,0 +1,191 @@
+/**************************************************************************
+ * 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 AliRsnAnalysisSimple
+//-------------------------------------------------------------------------
+// This class is a manager to process one or more pair analysis with a
+// given event sample, specified as a TTree passed to this object.
+// Each single pair analysis must be defined with its specifications, like
+// histogram binning, cuts and everything else.
+// This class utiliy consists in defining a unique event sample which is
+// used for all pairs analysis, and all kinds of event mixing (if required).
+// All histograms computed in a single execution, are then saved into a file.
+// This object contains a two TObjArray's:
+//  - one to contain single event pair analysis objects (signal, like-sign)
+//  - one to contain all event-mixing pair analysis objects
+// When a new pair is added, it must be then specified in what container it
+// must be placed, in order to avoid meaningless results.
+//
+// author: A. Pulvirenti
+// email : alberto.pulvirenti@ct.infn.it
+//-------------------------------------------------------------------------
+
+#include <TH1.h>
+#include <TTree.h>
+#include <TFile.h>
+#include <TArray.h>
+#include <TClonesArray.h>
+
+#include "AliLog.h"
+#include "AliRsnPID.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnEvent.h"
+#include "AliRsnEventBuffer.h"
+#include "AliRsnPairSimple.h"
+#include "AliRsnAnalyzerSimple.h"
+#include "AliRsnAnalysisSimple.h"
+
+ClassImp(AliRsnAnalysisSimple)
+
+//_____________________________________________________________________________
+AliRsnAnalysisSimple::AliRsnAnalysisSimple(AliRsnAnalyzerSimple *ana, AliRsnPID *pid) :
+  TObject(),
+  fInitialized(kFALSE),
+  fStep(1000),
+  fTree(0x0),
+  fPID(pid),
+  fAnalyzer(ana)
+{
+//
+// Constructor
+// Initializes all pointers and collections to NULL.
+//
+
+    strcpy(fFileName, "default.root");
+}
+
+
+//_____________________________________________________________________________
+void AliRsnAnalysisSimple::Clear(Option_t *option)
+{
+//
+// Clear heap
+//
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisSimple::SetEventsTree(TTree *tree)
+{
+//
+// Set the tree containing the events to be processed.
+// Counts also the number of events and stores it in a private datamember.
+// This can avoid the time-wasting entries count in a long TChain.
+//
+    fTree = tree;
+    AliInfo(Form("Total number of events to be processed: %d", fTree->GetEntries()));
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnAnalysisSimple::Initialize()
+{
+//
+// Various initialization processes
+//
+    // check process objects
+    if (!fPID) {
+        AliError("PID not initialized");
+        return kFALSE;
+    }
+    if (!fAnalyzer) {
+        AliError("Analyzer not initialized");
+        return kFALSE;
+    }
+
+    // set reference to PID method to all pairs
+    AliRsnPairSimple *pair = 0;
+    TObjArrayIter pairIterator(fAnalyzer->GetPairs());
+    while ( (pair = (AliRsnPairSimple*)pairIterator.Next()) ) {
+        pair->SetPIDMethod(fPID->GetMethod());
+    }
+    if (fAnalyzer->GetMixPairs() && !fAnalyzer->GetMixPairs()->IsEmpty()) {
+        TObjArrayIter mixIterator(fAnalyzer->GetMixPairs());
+        while ( (pair = (AliRsnPairSimple*)mixIterator.Next()) ) {
+            pair->SetPIDMethod(fPID->GetMethod());
+        }
+    }
+
+    // initialize analyzer
+    fAnalyzer->Init();
+
+    // at the end, update flag for initialization
+    fInitialized = kTRUE;
+
+    return kTRUE;
+}
+
+//_____________________________________________________________________________
+Stat_t AliRsnAnalysisSimple::Process()
+{
+//
+// Computes all invariant mass distributions defined in the AliRsnPair objects collected.
+// Depending on the kind of background evaluation method, computes also this one.
+//
+
+    // check initialization
+    if (!fInitialized) {
+        AliError("Analysis not initialized. Use method 'Initialize()'");
+        return 0.0;
+    }
+
+    // set cursor object
+    AliRsnEvent *event = 0x0;
+    fTree->SetBranchAddress("rsnEvents", &event);
+
+    // output counter
+    Stat_t nPairs = 0.0;
+
+       // loop on events
+       Int_t i, nEvents = (Int_t)fTree->GetEntries();
+    for (i = 0; i < nEvents; i++) {
+        // message
+        if ((i % fStep) == 0) AliInfo(Form("Processing event %d", i));
+        // get entry
+        fTree->GetEntry(i);
+        if (!event) continue;
+        fPID->Identify(event);
+        nPairs += fAnalyzer->Process(event);
+    }
+
+    return nPairs;
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisSimple::SaveOutput() const
+{
+//
+// Writes histograms in current directory
+//
+    TFile *file = TFile::Open(fFileName, "RECREATE");
+    AliRsnPairSimple *pair = 0;
+    TH1D *hist = 0;
+    TObjArrayIter pairIterator(fAnalyzer->GetPairs());
+    while ( (pair = (AliRsnPairSimple*)pairIterator.Next()) ) {
+        hist = pair->GetHistogram();
+        if (hist) hist->Write();
+        hist = pair->GetHistogramMC();
+        if (hist) hist->Write();
+    }
+    if (fAnalyzer->GetMixPairs() && !fAnalyzer->GetMixPairs()->IsEmpty()) {
+       TObjArrayIter mixIterator(fAnalyzer->GetMixPairs());
+        while ( (pair = (AliRsnPairSimple*)mixIterator.Next()) ) {
+            hist = pair->GetHistogram();
+            if (hist) hist->Write();
+            hist = pair->GetHistogramMC();
+            if (hist) hist->Write();
+        }
+       }
+       file->Close();
+}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisSimple.h b/PWG2/RESONANCES/AliRsnAnalysisSimple.h
new file mode 100644 (file)
index 0000000..090b52e
--- /dev/null
@@ -0,0 +1,67 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+
+//-------------------------------------------------------------------------
+//                      Class AliRsnAnalysisSimple
+//             Reconstruction and analysis of K* Rsn
+// ........................................
+// ........................................
+// ........................................
+// ........................................
+//
+// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
+//-------------------------------------------------------------------------
+
+#ifndef AliRsnAnalysisSimple_H
+#define AliRsnAnalysisSimple_H
+
+#include "AliRsnPID.h"
+
+class TTree;
+class TArrayI;
+class TObjArray;
+class AliRsnPairSimple;
+class AliRsnPID;
+class AliRsnEventBuffer;
+class AliRsnAnalyzerSimple;
+
+class AliRsnAnalysisSimple : public TObject
+{
+public:
+
+    AliRsnAnalysisSimple(AliRsnAnalyzerSimple *ana = 0x0, AliRsnPID *pid = 0x0);
+    virtual ~AliRsnAnalysisSimple() {Clear();}
+    virtual void Clear(Option_t *option = "C");
+
+    /* setters */
+    void    SetAnalyzer(AliRsnAnalyzerSimple *analyzer) {fAnalyzer = analyzer;}
+    void    SetEventsTree(TTree *tree);
+    void    SetFileName(char *fname) {strcpy(fFileName, fname);}
+    void    SetStep(Int_t step) {fStep = step;}
+    void    SetPID(AliRsnPID *pid) {fPID = pid;}
+
+    /* working routines */
+    Bool_t  Initialize();
+    Stat_t  Process();
+    void    SaveOutput() const;
+
+private:
+
+    AliRsnAnalysisSimple(const AliRsnAnalysisSimple &copy) :
+      TObject(copy),fInitialized(kFALSE),fStep(1000),fTree(0x0),fPID(0x0),fAnalyzer(0x0) { }
+    AliRsnAnalysisSimple& operator=(const AliRsnAnalysisSimple & /*copy*/) { return (*this); }
+
+    Bool_t                fInitialized;     // flag to check initialization
+    Int_t                 fStep;            // progress step
+    Char_t                fFileName[250];   // output file name
+       TTree                *fTree;            //! TTree of events
+    AliRsnPID            *fPID;             //! PID object
+       AliRsnAnalyzerSimple *fAnalyzer;        //! analyzer
+
+       // Rsn analysis implementation
+       ClassDef(AliRsnAnalysisSimple,1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnAnalysisSimpleTask.cxx b/PWG2/RESONANCES/AliRsnAnalysisSimpleTask.cxx
new file mode 100644 (file)
index 0000000..567efd5
--- /dev/null
@@ -0,0 +1,231 @@
+/**************************************************************************
+ * 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 AliRsnAnalysisSimpleTask
+// ------------------------
+// Reader for conversion of ESD output into the internal format
+// used for resonance study.
+// ---
+// original author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
+// ---
+// adapted for Analysis Framework
+// by    : R. Vernet                          (email: renaud.vernet@cern.ch)
+//----------------------------------------------------------------------------------
+
+#include <TChain.h>
+
+#include "AliLog.h"
+#include "AliVEvent.h"
+#include "AliMCEventHandler.h"
+#include "AliInputEventHandler.h"
+#include "AliAnalysisManager.h"
+
+#include "AliMCEvent.h"
+
+#include "AliRsnEvent.h"
+#include "AliRsnReader.h"
+#include "AliRsnPID.h"
+#include "AliRsnPairSimple.h"
+#include "AliRsnAnalyzerSimple.h"
+#include "AliRsnAnalysisSimpleTask.h"
+
+ClassImp(AliRsnAnalysisSimpleTask)
+
+//_____________________________________________________________________________
+AliRsnAnalysisSimpleTask::AliRsnAnalysisSimpleTask() :
+  AliAnalysisTask(),
+  fEvent(0x0),
+  fMC(0x0),
+  fReader(0x0),
+  fPID(0x0),
+  fAnalyzer(0x0),
+  fCurrEvent(0x0),
+  fHistograms(0x0)
+{
+//
+// Default constructor (not recommended)
+//
+}
+
+//_____________________________________________________________________________
+AliRsnAnalysisSimpleTask::AliRsnAnalysisSimpleTask(const char *name) :
+  AliAnalysisTask(name, ""),
+  fEvent(0x0),
+  fMC(0x0),
+  fReader(0x0),
+  fPID(0x0),
+  fAnalyzer(0x0),
+  fCurrEvent(0x0),
+  fHistograms(0x0)
+{
+//
+// Working constructor (recommended)
+//
+
+    DefineInput (0, TChain::Class());
+    DefineOutput (0, TList::Class());
+}
+
+//_____________________________________________________________________________
+AliRsnAnalysisSimpleTask::AliRsnAnalysisSimpleTask(const AliRsnAnalysisSimpleTask& obj) :
+  AliAnalysisTask(obj),
+  fEvent(0x0),
+  fMC(0x0),
+  fReader(obj.fReader),
+  fPID(obj.fPID),
+  fAnalyzer(obj.fAnalyzer),
+  fCurrEvent(0x0),
+  fHistograms(0x0)
+{
+//
+// Copy constructor (not recommended)
+//
+}
+
+//_____________________________________________________________________________
+AliRsnAnalysisSimpleTask& AliRsnAnalysisSimpleTask::operator=(const AliRsnAnalysisSimpleTask& /*obj*/)
+{
+//
+// Assignment operator (not recommended)
+//
+
+    AliInfo("Not implemented. Avoid using the assignment operator");
+    return *this;
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisSimpleTask::CreateOutputObjects()
+{
+//
+// Create the output container
+//
+
+    // check for presence of NECESSARY data-members
+    if (!fReader) {
+        AliFatal("Event reader not initialized. Impossible to continue. Aborting with fatal error.");
+        return;
+    }
+    if (!fPID) {
+        AliFatal("PID manager not initialized. Impossible to continue. Aborting with fatal error.");
+        return;
+    }
+    if (!fAnalyzer) {
+        AliFatal("Analysis manager not initialized. Impossible to continue. Aborting with fatal error.");
+        return;
+    }
+
+    // OpenFile (0);
+
+    // output histogram list
+    fHistograms = new TList(0);
+
+    // initialize analyzer
+    fAnalyzer->Init();
+
+    // store all histograms in the pairs into the list
+    TObjArray *array = fAnalyzer->GetPairs();
+    AliRsnPairSimple *pair;
+    if (array) {
+        TObjArrayIter iter(array);
+        while ( (pair = (AliRsnPairSimple*)iter.Next()) ) {
+            fHistograms->AddLast((TObject*)pair->GetHistogram());
+            fHistograms->AddLast((TObject*)pair->GetHistogramMC());
+        }
+    }
+    array = fAnalyzer->GetMixPairs();
+    if (array) {
+        TObjArrayIter iter(array);
+        while ( (pair = (AliRsnPairSimple*)iter.Next()) ) {
+            fHistograms->AddLast((TObject*)pair->GetHistogram());
+            fHistograms->AddLast((TObject*)pair->GetHistogramMC());
+        }
+    }
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisSimpleTask::ConnectInputData(Option_t *)
+{
+//
+// Connect the input data
+//
+
+    // connect ESD
+    AliInputEventHandler *inH = dynamic_cast<AliInputEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+    if (!inH) {
+               AliError("Could not get InputHandler");
+       }
+       else {
+               fEvent = inH->GetEvent();
+       }
+
+       // connect MC
+    AliMCEventHandler* mcH = dynamic_cast<AliMCEventHandler*>((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
+    if (!mcH) {
+               AliError("Could not get MCInputHandler");
+       }
+    else {
+               fMC = mcH->MCEvent();
+       }
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisSimpleTask::Exec(Option_t */*option*/)
+{
+//
+// Loops on input container to store data of all tracks.
+// Uses the AliRsnReader methods to save them in the output.
+//
+
+    // check ESD and MC events
+    if (!fEvent) {
+        AliWarning("Event not available here");
+        return;
+    }
+    if (!fMC) {
+        AliWarning("MC event not available here");
+        return;
+    }
+
+    // clear previous event
+    if (!fCurrEvent) {
+        fCurrEvent = new AliRsnEvent;
+        fCurrEvent->Init();
+    }
+    else fCurrEvent->Clear();
+
+    // read event, identify
+    if (!fReader->Fill(fCurrEvent, fEvent, fMC)) AliWarning("Failed reading");
+    if (!fPID->Identify(fCurrEvent)) AliWarning("Failed PID");
+    AliInfo(Form("Collected %d tracks", fCurrEvent->GetMultiplicity()));
+
+    // process event with analyzer
+    fPID->Identify(fCurrEvent);
+    fAnalyzer->Process(fCurrEvent);
+
+    // post collected data
+    PostData (0, fHistograms);
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalysisSimpleTask::Terminate(Option_t */*option*/)
+{
+//
+// Terminate analysis
+//
+
+    AliDebug(1, "Terminating");
+    AliAnalysisTask::Terminate();
+}
diff --git a/PWG2/RESONANCES/AliRsnAnalysisSimpleTask.h b/PWG2/RESONANCES/AliRsnAnalysisSimpleTask.h
new file mode 100644 (file)
index 0000000..a90989b
--- /dev/null
@@ -0,0 +1,66 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+
+//----------------------------------------------------------------------------------
+//  Class AliRsnAnalysisSimpleTask
+// ------------------------
+// Reader for conversion of ESD output into the internal format
+// used for resonance study.
+// ---
+// original author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
+// ---
+// adapted for Analysis Framework
+// by    : R. Vernet                          (email: renaud.vernet@cern.ch)
+//----------------------------------------------------------------------------------
+
+#ifndef AliRsnAnalysisSimpleTask_H
+#define AliRsnAnalysisSimpleTask_H
+
+#include "AliAnalysisTask.h"
+
+class TList;
+class AliVEvent;
+class AliMCEvent;
+class AliRsnPID;
+class AliRsnReader;
+class AliRsnEvent;
+class AliRsnAnalyzerSimple;
+
+class AliRsnAnalysisSimpleTask : public AliAnalysisTask
+{
+public:
+
+    AliRsnAnalysisSimpleTask();
+    AliRsnAnalysisSimpleTask(const char *name);
+    virtual ~AliRsnAnalysisSimpleTask() { }
+    
+    // Implementation of interface methods
+    virtual void ConnectInputData (Option_t *);
+    virtual void CreateOutputObjects();
+    virtual void Exec (Option_t *option);
+    virtual void Terminate(Option_t *option);
+    
+    // setters
+    void SetReader(AliRsnReader *reader) {fReader = reader;}
+    void SetPID(AliRsnPID *pid) {fPID = pid;}
+    void SetAnalyzer(AliRsnAnalyzerSimple *analyzer) {fAnalyzer = analyzer;}
+    
+private:
+
+    AliRsnAnalysisSimpleTask(const AliRsnAnalysisSimpleTask&);
+    AliRsnAnalysisSimpleTask& operator=(const AliRsnAnalysisSimpleTask&);
+
+    AliVEvent*            fEvent;      // input event
+       AliMCEvent*           fMC;         // corresponding MC event
+    AliRsnReader*         fReader;     // read manager
+    AliRsnPID*            fPID;        // particle identification manager
+    AliRsnAnalyzerSimple* fAnalyzer;   // analyzer
+    AliRsnEvent*          fCurrEvent;  // current event pointer -> for moving among methods
+    TList*                fHistograms; // list of output histograms
+
+    ClassDef(AliRsnAnalysisSimpleTask, 1); // implementation of RsnReader as ReaderTaskSE
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnAnalyzerSimple.cxx b/PWG2/RESONANCES/AliRsnAnalyzerSimple.cxx
new file mode 100644 (file)
index 0000000..be054ee
--- /dev/null
@@ -0,0 +1,169 @@
+/**************************************************************************
+ * 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 AliRsnAnalyzerSimple
+//
+// Implementation of the event processing which returns histograms of
+// invariant mass for resonances and backgrounds evaluation.
+//
+// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
+//=========================================================================
+
+#include <TTree.h>
+#include <TFile.h>
+#include <TArray.h>
+#include <TClonesArray.h>
+
+#include "AliLog.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnEvent.h"
+#include "AliRsnEventBuffer.h"
+#include "AliRsnPairSimple.h"
+#include "AliRsnAnalyzerSimple.h"
+
+ClassImp(AliRsnAnalyzerSimple)
+
+//_____________________________________________________________________________
+AliRsnAnalyzerSimple::AliRsnAnalyzerSimple(Int_t bufferSize) :
+  TObject(),
+  fBufferSize(bufferSize),
+  fMixMultCut(10),
+  fMixVzCut(0.5),
+  fNMix(10),
+  fPairs(0x0),
+  fMixPairs(0x0),
+  fBuffer(0x0)
+{
+//
+// Constructor
+// Initializes all pointers and collections to NULL.
+//
+}
+
+
+//_____________________________________________________________________________
+void AliRsnAnalyzerSimple::Clear(Option_t *option)
+{
+//
+// Clear heap
+//
+    fPairs->Clear(option);
+    fMixPairs->Clear(option);
+    delete fBuffer;
+    fBuffer = 0;
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalyzerSimple::AddPair(AliRsnPairSimple *pair)
+{
+//
+// Add a pair of particle types to be analyzed.
+// Second argument tells if the added object is for event mixing.
+//
+    Bool_t mixing = pair->IsForMixing();
+    TObjArray* &target = mixing ? fMixPairs : fPairs;
+    if (!target) target = new TObjArray(0);
+    target->AddLast(pair);
+}
+
+//_____________________________________________________________________________
+void AliRsnAnalyzerSimple::Init()
+{
+//
+// Initialize what needs to.
+//
+
+    // buffer
+    fBuffer = new AliRsnEventBuffer(fBufferSize, kFALSE);
+
+    // histograms
+    AliRsnPairSimple *pair = 0;
+    if (fPairs) {
+        TObjArrayIter pairIterator(fPairs);
+        while ( (pair = (AliRsnPairSimple*)pairIterator.Next()) ) pair->InitHistograms();
+    }
+    if (fMixPairs) {
+        TObjArrayIter mixIterator(fMixPairs);
+        while ( (pair = (AliRsnPairSimple*)mixIterator.Next()) ) pair->InitHistograms();
+    }
+}
+
+//_____________________________________________________________________________
+Stat_t AliRsnAnalyzerSimple::Process(AliRsnEvent *event)
+{
+//
+// Computes all invariant mass distributions defined in the AliRsnPair objects collected.
+// Depending on the kind of background evaluation method, computes also this one.
+//
+
+    // skip empty events
+    if (event->GetMultiplicity() < 1) return 0.0;
+
+    // create buffer if not already present
+    if (!fBuffer) Init();
+
+    // initialize output values and utility variables
+    Stat_t nPairs = 0;
+    AliRsnPairSimple *pair = 0x0;
+
+    // break here if NULL argument is passed
+    if (!event) {
+        AliError("NULL event passed");
+        return 0.0;
+    }
+
+    // loop over the collection of pair defs
+    if (fPairs) {
+        TObjArrayIter pairIterator(fPairs);
+        while ( (pair = (AliRsnPairSimple*)pairIterator.Next()) ) {
+            nPairs += pair->Process(event, event);
+        }
+    }
+    if (fMixPairs) {
+        // variables for mixing
+        Int_t    mult1, mult2, i, j, count = 0;
+        Double_t vz1, vz2;
+        // add this event to buffer
+        fBuffer->AddEvent(event);
+        // event mixing
+        vz1 = event->GetPrimaryVertexZ();
+        mult1 = event->GetMultiplicity();
+        if (!fBuffer->NEmptySlots()) {
+            i = fBuffer->GetEventsBufferIndex();
+            j = i+1;
+            for (;;j++) {
+                if (count >= fNMix) break;
+                if (j == fBufferSize) j = 0;
+                if (j == i) break;
+                AliRsnEvent *evmix = fBuffer->GetEvent(j);
+                if (!evmix) continue;
+                vz2 = evmix->GetPrimaryVertexZ();
+                mult2 = evmix->GetMultiplicity();
+                if (TMath::Abs(vz1 - vz2) <= fMixVzCut && TMath::Abs(mult1- mult2) <= fMixMultCut) {
+                    // loop over the collection of pair defs
+                    TObjArrayIter mixIterator(fMixPairs);
+                    while ( (pair = (AliRsnPairSimple*)mixIterator.Next()) ) {
+                        nPairs += pair->Process(event, evmix);
+                        nPairs += pair->Process(evmix, event);
+                    }
+                    count++;
+                }
+            }
+        }
+    }
+
+    return nPairs;
+}
diff --git a/PWG2/RESONANCES/AliRsnAnalyzerSimple.h b/PWG2/RESONANCES/AliRsnAnalyzerSimple.h
new file mode 100644 (file)
index 0000000..7bbf4aa
--- /dev/null
@@ -0,0 +1,68 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+
+//=========================================================================
+// Class AliRsnAnalyzerSimple
+//
+// Implementation of the event processing which returns histograms of
+// invariant mass for resonances and backgrounds evaluation.
+//
+// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
+//=========================================================================
+
+#ifndef AliRsnAnalyzerSimple_H
+#define AliRsnAnalyzerSimple_H
+
+#include "AliRsnPID.h"
+
+class TObjArray;
+class AliRsnPairSimple;
+class AliRsnEventBuffer;
+
+class AliRsnAnalyzerSimple : public TObject
+{
+public:
+
+    AliRsnAnalyzerSimple(Int_t bufferSize = 1000);
+    virtual ~AliRsnAnalyzerSimple() {Clear();}
+
+    // setters
+    void    SetBufferSize(Int_t value) {fBufferSize = value;}
+    void    SetMixMultiplicityCut(Int_t cut) {fMixMultCut = cut;}
+    void    SetMixVzCut(Double_t cut) {fMixVzCut = cut;}
+    void    SetNMix(Int_t value) {fNMix = value;}
+
+    // getters
+    TObjArray* GetPairs() {return fPairs;}
+    TObjArray* GetMixPairs() {return fMixPairs;}
+
+    // working routines
+    void         Init();
+    virtual void Clear(Option_t *option = "C");
+    void         AddPair(AliRsnPairSimple *pair);
+    Stat_t       Process(AliRsnEvent *event);
+
+private:
+
+    AliRsnAnalyzerSimple(const AliRsnAnalyzerSimple &copy) :
+      TObject(copy),fBufferSize(1000),
+      fMixMultCut(10),fMixVzCut(0.5),fNMix(10),
+      fPairs(0x0),fMixPairs(0x0),fBuffer(0x0) { }
+    AliRsnAnalyzerSimple& operator=(const AliRsnAnalyzerSimple & /*copy*/) { return (*this); }
+
+    Int_t         fBufferSize;       // size of buffer
+    Int_t         fMixMultCut;       // multiplicity cut for event mixing
+    Double_t      fMixVzCut;         // difference in VZ cut for event mixing
+    Int_t         fNMix;             // number of events for mixing
+
+    TObjArray         *fPairs;       //! collection of particle pairs to be read for 1-event analysis
+    TObjArray         *fMixPairs;    //! collection of particle pairs to be read for event-mixing
+    AliRsnEventBuffer *fBuffer;      //! buffer for event mixing
+
+    // Rsn analyzer implementation
+    ClassDef(AliRsnAnalyzerSimple,1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnBaseAT.cxx b/PWG2/RESONANCES/AliRsnBaseAT.cxx
new file mode 100644 (file)
index 0000000..5a33621
--- /dev/null
@@ -0,0 +1,190 @@
+#include "TChain.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TCanvas.h"
+
+#include "AliLog.h"
+
+#include "AliAnalysisManager.h"
+#include "AliAnalysisTask.h"
+
+#include "AliESDEvent.h"
+#include "AliAODEvent.h"
+#include "AliRsnEvent.h"
+
+
+#include "AliESDInputHandler.h"
+#include "AliMCEventHandler.h"
+#include "AliAODInputHandler.h"
+
+#include "AliRsnBaseAT.h"
+
+
+ClassImp ( AliRsnBaseAT );
+
+//________________________________________________________________________
+AliRsnBaseAT::AliRsnBaseAT ( const char *name /*,Bool_t isSecondChain*/ )
+    : AliAnalysisTask ( name, "" ) /*,fIsSecondChain ( isSecondChain )*/
+{
+  InitIOVars ();
+  DefineInput ( 0, TChain::Class() );
+//   if ( IsSecondChain() )
+//     DefineInput ( 1, TChain::Class() );
+}
+
+void AliRsnBaseAT::InitIOVars ()
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+
+  fNumOfEvents=0;
+  for ( Int_t i=0;i<3;i++ )
+  {
+    fChain[i]=0;
+    fRSN[i] = 0;
+    fESD[i] = 0;
+    fAOD[i] = 0;
+    fInputType[i] = kRSN;
+  }
+  
+  fAnalysisMgr=0;
+  
+  AliDebug ( AliLog::kDebug, "->" );
+}
+
+Bool_t AliRsnBaseAT::Notify()
+{
+  return AliAnalysisTask::Notify();
+}
+
+//________________________________________________________________________
+void AliRsnBaseAT::ConnectInputData ( Option_t * )
+{
+  ConnectInputDataByInputType ( fInputType[0],0 );
+//   if ( IsSecondChain() )
+//     ConnectInputDataByInputType ( fInputType[1],1 );
+
+}
+
+void AliRsnBaseAT::ConnectInputDataByInputType ( EInputType type ,Short_t inputIndex )
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+
+  switch ( type )
+  {
+    case kAOD:
+    {
+      ConnectAOD ( inputIndex );
+      break;
+    }
+    case kESD:
+    {
+      ConnectESD ( inputIndex );
+      break;
+    }
+    case kESDMC:
+    {
+      ConnectESDMC ( inputIndex );
+      break;
+    }
+    case kMC:
+      AliError ( "Not Implemented Yet ..." );
+      break;
+    case kRSN:
+    {
+      ConnectRSN ( inputIndex );
+      break;
+    }
+    default:
+      AliError ( "Type not supported ..." );
+      break;
+  }
+  AliDebug ( AliLog::kDebug, "->" );
+}
+
+void AliRsnBaseAT::ConnectRSN ( Short_t inputIndex )
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+  char ** address = ( char ** ) GetBranchAddress ( inputIndex, "RsnEvents" );
+  if ( address )
+  {
+    fRSN[inputIndex] = ( AliRsnEvent* ) ( *address );
+  }
+  else
+  {
+//     fRSN[inputIndex] = new AliRsnEvent();
+    fRSN[inputIndex] = 0;
+    SetBranchAddress ( inputIndex, "RsnEvents", &fRSN[inputIndex] );
+  }
+  AliDebug ( AliLog::kDebug, "->" );
+}
+
+void AliRsnBaseAT::ConnectESD(Short_t inputIndex)
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+
+//   fAnalysisMgr->SetInputEventHandler ( new AliESDInputHandler() );
+
+  TTree* tree = dynamic_cast<TTree*> ( GetInputData ( inputIndex ) );
+  if ( !tree ) { AliError ( "Could not read chain from input slot 0" ); }
+  else
+  {
+    // Disable all branches, we want to process only MC
+    tree->SetBranchStatus ( "*", kFALSE );
+    tree->SetBranchStatus ( "fTracks.*", kTRUE );
+
+    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> ( AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler() );
+
+    if ( !esdH ) { AliError ( "Could not get ESDInputHandler" ); }
+    else
+      fESD[inputIndex] = esdH->GetEvent();
+  }
+  AliDebug ( AliLog::kDebug, "->" );
+
+}
+
+void AliRsnBaseAT::ConnectESDMC(Short_t inputIndex)
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+
+//   fAnalysisMgr->SetInputEventHandler ( new AliESDInputHandler() );
+//   fAnalysisMgr->SetMCtruthEventHandler ( new AliMCEventHandler() );
+
+
+  TTree* tree = dynamic_cast<TTree*> ( GetInputData ( inputIndex ) );
+  if ( !tree ) { AliError ( "Could not read chain from input slot 0" ); }
+  else
+  {
+    // Disable all branches, we want to process only MC
+    tree->SetBranchStatus ( "*", kFALSE );
+    tree->SetBranchStatus ( "fTracks.*", kTRUE );
+
+    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> ( AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler() );
+
+    if ( !esdH ) { AliError ( "Could not get ESDInputHandler" ); }
+    else
+      fESD[inputIndex] = esdH->GetEvent();
+  }
+  AliDebug ( AliLog::kDebug, "->" );
+
+}
+
+void AliRsnBaseAT::ConnectAOD(Short_t inputIndex)
+{
+  AliDebug ( AliLog::kDebug, "<-" );
+  
+  //   fAnalysisMgr->SetInputEventHandler ( new AliAODInputHandler());
+  
+  TTree* tree = dynamic_cast<TTree*> ( GetInputData ( inputIndex ) );
+  if ( !tree ) { AliError ( "Could not read chain from input slot 0" );}
+  else
+  {
+    AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*> ( AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler() );
+
+    if ( !aodH ) { AliError ( "Could not get AODInputHandler" ); }
+    else
+    {
+      fAOD[inputIndex] = aodH->GetEvent();
+    }
+  }
+  AliDebug ( AliLog::kDebug, "->" );
+}
diff --git a/PWG2/RESONANCES/AliRsnBaseAT.h b/PWG2/RESONANCES/AliRsnBaseAT.h
new file mode 100644 (file)
index 0000000..727393c
--- /dev/null
@@ -0,0 +1,71 @@
+#ifndef AliRsnBaseAT_cxx\r
+#define AliRsnBaseAT_cxx\r
+\r
+#include <TChain.h>\r
+\r
+#include "AliAnalysisTask.h"\r
+\r
+class AliAnalysisManager;\r
+\r
+class AliESDEvent;\r
+class AliAODEvent;\r
+class AliRsnEvent;\r
+\r
+\r
+class AliRsnBaseAT : public AliAnalysisTask\r
+{\r
+  public:\r
+    AliRsnBaseAT ( const char *name = "AliRsnBaseAT" );\r
+    virtual ~AliRsnBaseAT() {}\r
+\r
+    enum EInputType\r
+    {\r
+      kAOD = 0,\r
+      kESD,\r
+      kESDMC,\r
+      kMC,\r
+      kRSN,\r
+      kLastIndex\r
+    };\r
+\r
+    virtual void   InitIOVars();\r
+    virtual void   LocalInit() {;}\r
+    virtual Bool_t Notify();\r
+    virtual void   ConnectInputData ( Option_t * );\r
+    virtual void   CreateOutputObjects() {;}\r
+    virtual void   Exec ( Option_t *option ) {;}\r
+    virtual void   Terminate ( Option_t * ) {;}\r
+\r
+    void SetInputType (EInputType& theValue, Short_t inputIndex=0) { fInputType[inputIndex] = theValue; }\r
+    EInputType GetInputType ( Short_t inputIndex=0 ) { return fInputType[inputIndex]; }\r
+\r
+    TChain* GetChain ( const Int_t& index = 0) const { return fChain[index]; }\r
+\r
+    AliRsnEvent *GetRSNEvent ( Int_t index=0 ) { return fRSN[index]; }\r
+\r
+    void SetAnalysisMgr ( AliAnalysisManager* theValue ) { fAnalysisMgr = theValue; }\r
+    AliAnalysisManager* GetAnalysisMgr() const { return fAnalysisMgr; }\r
+\r
+  protected:\r
+    \r
+    Long64_t      fNumOfEvents;\r
+\r
+    TChain        *fChain[2];         // input chain\r
+    EInputType    fInputType[2];      // input type\r
+\r
+    AliRsnEvent *fRSN[2];           // RsnMV event\r
+    AliESDEvent   *fESD[2];           // ESD event\r
+    AliAODEvent   *fAOD[2];           // AOD event\r
+\r
+    AliAnalysisManager *fAnalysisMgr; // pointer to current AnalysisMgr\r
+\r
+    virtual void  ConnectInputDataByInputType ( EInputType type ,Short_t inputIndex=0 );\r
+    virtual void  ConnectRSN ( Short_t inputIndex );\r
+    virtual void  ConnectESD ( Short_t inputIndex );\r
+    virtual void  ConnectESDMC ( Short_t inputIndex );\r
+    virtual void  ConnectAOD ( Short_t inputIndex );\r
+\r
+    ClassDef ( AliRsnBaseAT, 1 );\r
+};\r
+\r
+#endif\r
diff --git a/PWG2/RESONANCES/AliRsnCut.cxx b/PWG2/RESONANCES/AliRsnCut.cxx
new file mode 100644 (file)
index 0000000..732f37f
--- /dev/null
@@ -0,0 +1,349 @@
+/**************************************************************************
+ * 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 AliRsnCut
+//
+// General implementation of a single cut strategy, which can be:
+// - a value contained in a given interval  [--> IsBetween()]
+// - a value equal to a given reference     [--> IsEqual()  ]
+// In all cases, the reference value(s) is (are) given as data members
+// and each kind of cut requires a given value type (Int, UInt, Double),
+// but the cut check procedure is then automatized and chosen thanks to
+// an enumeration of the implemented cut types.
+// At the end, the user (or any other point which uses this object) has
+// to use the method IsSelected() to check if this cut has been passed.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//=========================================================================
+
+#include "AliLog.h"
+
+#include "AliRsnDaughter.h"
+#include "AliRsnMCInfo.h"
+#include "AliRsnPairParticle.h"
+#include "AliRsnPairDef.h"
+#include "AliRsnCut.h"
+
+const Double_t AliRsnCut::fgkDSmallNumber = 1e-100;
+const Double_t AliRsnCut::fgkDBigNumber = 1e10;
+const Int_t    AliRsnCut::fgkIBigNumber = 32767;
+
+ClassImp (AliRsnCut)
+
+//________________________________________________________________________________________________________________
+AliRsnCut::AliRsnCut() :
+  TNamed(),
+  fDMin(-fgkDBigNumber),
+  fDMax( fgkDBigNumber),
+  fIMin(-fgkIBigNumber),
+  fIMax( fgkIBigNumber),
+  fUIMin(0),
+  fUIMax(2 * (UInt_t)fgkIBigNumber),
+  fRsnCutType (kLastCutType),
+  fRsnCutVarType (kDouble_t)
+{
+//
+// Constructor
+//
+}
+
+//________________________________________________________________________________________________________________
+AliRsnCut::AliRsnCut (const char *name, const char *title, ERsnCutType type) :
+  TNamed (name,title),
+  fDMin(-fgkDBigNumber),
+  fDMax( fgkDBigNumber),
+  fIMin(-fgkIBigNumber),
+  fIMax( fgkIBigNumber),
+  fUIMin(0),
+  fUIMax(2 * (UInt_t)fgkIBigNumber),
+  fRsnCutType (type),
+  fRsnCutVarType (kDouble_t)
+{
+//
+// Constructor with arguments but not limits
+//
+}
+
+//________________________________________________________________________________________________________________
+AliRsnCut::AliRsnCut (const char *name, const char *title, ERsnCutType type, Double_t min, Double_t max) :
+  TNamed (name,title),
+  fDMin(min),
+  fDMax(max),
+  fIMin(-fgkIBigNumber),
+  fIMax( fgkIBigNumber),
+  fUIMin(0),
+  fUIMax(2 * (UInt_t)fgkIBigNumber),
+  fRsnCutType (type),
+  fRsnCutVarType (kDouble_t)
+{
+//
+// Constructor with arguments and limits
+//
+}
+
+//________________________________________________________________________________________________________________
+AliRsnCut::AliRsnCut (const char * name, const char * title, ERsnCutType type, Int_t min, Int_t max) :
+  TNamed (name,title),
+  fDMin(-fgkDBigNumber),
+  fDMax( fgkDBigNumber),
+  fIMin(min),
+  fIMax(max),
+  fUIMin(0),
+  fUIMax(2 * (UInt_t)fgkIBigNumber),
+  fRsnCutType (type),
+  fRsnCutVarType (kInt_t)
+{
+//
+// Constructor with arguments and limits
+//
+}
+
+//________________________________________________________________________________________________________________
+AliRsnCut::AliRsnCut (const char * name, const char * title, ERsnCutType type, UInt_t min, UInt_t max) :
+  TNamed (name,title),
+  fDMin(-fgkDBigNumber),
+  fDMax( fgkDBigNumber),
+  fIMin(-fgkIBigNumber),
+  fIMax( fgkIBigNumber),
+  fUIMin(min),
+  fUIMax(max),
+  fRsnCutType (type),
+  fRsnCutVarType (kUInt_t)
+{
+//
+// Constructor with arguments and limits
+//
+}
+
+//________________________________________________________________________________________________________________
+AliRsnCut::~ AliRsnCut()
+{
+//
+// Destructor.
+// Does absolutely nothing.
+//
+}
+
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::IsBetween (const Double_t & theValue)
+{
+//
+// Interval check.
+// Question: "Is the argument included between fDMin and fDMax?"
+// (not implemented for integer values because usually it is not used with them)
+//
+    return ((theValue >= fDMin) && (theValue <= fDMax));
+}
+
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::IsEqual (const Int_t &theValue)
+{
+//
+// Reference check.
+// Question: "Is the argument equal to fIMin?" (fIMax is assumed never used)
+//
+    return (theValue == fIMin);
+}
+
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::IsEqual (const UInt_t &theValue)
+{
+//
+// Reference check.
+// Question: "Is the argument equal to fUIMin?" (fUIMax is assumed never used)
+//
+    return (theValue == fUIMin);
+}
+
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::IsEqual (const Double_t &theValue)
+{
+//
+// Reference check.
+// Question: "Is the argument reasonably close to fDMin?" (fDMax is assumed never used)
+// Here, "reasonably close" means that the difference is smaller than the
+// 'fgkSmallNumber' global static data member of this class
+//
+    return (TMath::Abs (theValue - fDMin) < fgkDSmallNumber);
+}
+
+//________________________________________________________________________________________________________________
+void AliRsnCut::SetCutValues (ERsnCutType type, const Double_t & theValue, const Double_t & theValue2)
+{
+//
+// (Re)assignment of cut values
+//
+    fRsnCutType = type;
+    fDMin = theValue;
+    fDMax = theValue2;
+}
+
+//________________________________________________________________________________________________________________
+void AliRsnCut::SetCutValues (ERsnCutType type, const Int_t& theValue, const Int_t& theValue2)
+{
+//
+// (Re)assignment of cut values
+//
+    fRsnCutType = type;
+    fIMin = theValue;
+    fIMax = theValue2;
+}
+
+//________________________________________________________________________________________________________________
+void AliRsnCut::SetCutValues (ERsnCutType type, const UInt_t& theValue, const UInt_t& theValue2)
+{
+//
+// (Re)assignment of cut values
+//
+    fRsnCutType = type;
+    fUIMin = theValue;
+    fUIMax = theValue2;
+}
+
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::IsSelected(ECutSetType type, AliRsnDaughter *daughter)
+{
+//
+// Core of the whole class.
+// According to the kind of cut selected in the enumeration,
+// checks the cut taking the right values from the argument.
+// Depending on the second argument type, only some cuts are checked
+// (the ones for that type of object), otherwise kTRUE is returned in order
+// not to act as a cleaning factor for an AND with other cuts.
+//
+    AliDebug (AliLog::kDebug, "<-");
+    AliRsnMCInfo *mcinfo = daughter->GetMCInfo();
+
+    // check type
+    if (type != kParticle) {
+        AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnDaughter)", type, kParticle, daughter->ClassName()));
+        return kTRUE;
+    }
+
+    switch (fRsnCutType) {
+        case kMomentum:
+            return IsBetween (daughter->P());
+        case kTransMomentum:
+            return IsBetween (daughter->Pt());
+        case kEta:
+            return IsBetween (daughter->Eta());
+        case kRadialImpactParam:
+            return IsBetween (daughter->Vt());
+        case kMomentumMC:
+            if (mcinfo) return IsBetween (mcinfo->P());
+            else return kTRUE;
+        case kTransMomentumMC:
+            if (mcinfo) return IsBetween (mcinfo->P());
+            else return kTRUE;
+        case kStatus:
+            return daughter->CheckFlag(fUIMin);
+        case kChargePos:
+            return (daughter->Charge() > 0);
+        case kChargeNeg:
+            return (daughter->Charge() < 0);
+        case kPIDType:
+            return IsEqual((Int_t)daughter->PIDType());
+        /*
+        case kEtaMC:
+            if (mcinfo) return IsBetween (mcinfo->Eta());
+            else return kTRUE;
+        case kMcVt:
+            if (mcinfo) return IsBetween (mcinfo->Vt());
+            else return kTRUE;
+        case kEsdNSigma:
+            return IsBetween (daughter->GetNSigma());
+        case kEsdNSigmaCalculate:
+            return IsBetween (daughter->GetESDInfo()->GetNSigmaCalculate());
+        */
+    }
+
+    return kTRUE;
+}
+
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::IsSelected(ECutSetType type, AliRsnPairParticle * pair)
+{
+    AliDebug (AliLog::kDebug, "<-");
+
+    // check type
+    if (type != kPair) {
+        AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnPairParticle)", type, kPair, pair->ClassName()));
+        return kTRUE;
+    }
+
+    switch (fRsnCutType) {
+        case kMomentum:
+            return IsBetween (pair->GetP());
+        case kTransMomentum:
+            return IsBetween (pair->GetPt());
+        /*
+        case kEta:
+            return IsBetween (daughter->Eta());
+        */
+        case kMomentumMC:
+            return IsBetween (pair->GetPMC());
+        case kTransMomentumMC:
+            return IsBetween (pair->GetPtMC());
+        case kRestMomentum:
+            return CheckRestMomentum(pair);
+        case kIsPdgEqual:
+            return pair->IsPDGEqual();
+        case kIsLabelEqual:
+            return pair->IsLabelEqual();
+        case kIsTruePair:
+            return pair->IsTruePair(fIMin);
+    }
+
+    return kTRUE;
+}
+
+//________________________________________________________________________________________________________________
+void AliRsnCut::PrintAllValues()
+{
+  AliInfo (Form ("fRsnCutType=%d fRsnCutVarType=%d",fRsnCutType,fRsnCutVarType));
+  AliInfo (Form ("fDMin=%.2e fDMax=%.2e",fDMin,fDMax));
+  AliInfo (Form ("fIMin=%d fIMax=%d",fIMin,fIMax));
+  AliInfo (Form ("fUIMin=%d fUIMax=%d",fUIMin,fUIMax));
+}
+
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::CheckRestMomentum(AliRsnPairParticle *pair)
+{
+//
+// Check the cut on daughter momenta in rest reference frame of mother
+//
+
+    Double_t beta = pair->GetP() / pair->GetMass();
+    Double_t gamma = 1. / TMath::Sqrt(1. - beta*beta);
+
+    Double_t p1labP = 0.0, p1labT, p1restP, p1restTot;
+    p1labP += pair->GetDaughter(0)->Px() * pair->GetP(0);
+    p1labP += pair->GetDaughter(0)->Py() * pair->GetP(1);
+    p1labP += pair->GetDaughter(0)->Pz() * pair->GetP(2);
+    p1labP /= pair->GetP();
+
+    p1labT = TMath::Sqrt(pair->GetDaughter(0)->P2() - p1labP*p1labP);
+
+    p1restP = gamma*p1labP - beta*gamma*pair->GetDaughter(0)->E();
+
+    p1restTot = TMath::Sqrt(p1restP*p1restP + p1labT*p1labT);
+
+    return IsBetween(p1restTot);
+}
+
+
+
diff --git a/PWG2/RESONANCES/AliRsnCut.h b/PWG2/RESONANCES/AliRsnCut.h
new file mode 100644 (file)
index 0000000..7bc5b99
--- /dev/null
@@ -0,0 +1,115 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+
+//=========================================================================
+// Class AliRsnCut
+//
+// General implementation of a single cut strategy, which can be:
+// - a value contained in a given interval  [--> IsBetween()]
+// - a value equal to a given reference     [--> IsEqual()  ]
+// In all cases, the reference value(s) is (are) given as data members
+// and each kind of cut requires a given value type (Int, UInt, Double),
+// but the cut check procedure is then automatized and chosen thanks to
+// an enumeration of the implemented cut types.
+// At the end, the user (or any other point which uses this object) has
+// to use the method IsSelected() to check if this cut has been passed.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//=========================================================================
+
+#ifndef ALIRSNCUT_H
+#define ALIRSNCUT_H
+
+#include "TNamed.h"
+
+class AliRsnDaughter;
+class AliRsnPairParticle;
+class AliRsnPairDef;
+
+class AliRsnCut : public TNamed
+{
+public:
+    enum ERsnCutType
+    {
+        kMomentum = 0,
+        kTransMomentum,
+        kEta,
+        kRadialImpactParam,
+        kMomentumMC,
+        kTransMomentumMC,
+        kEtaMC,
+        kRestMomentum,
+        kNSigma,
+        kNSigmaCalculate,
+        kStatus,
+        kIsPdgEqual,
+        kIsLabelEqual,
+        kIsTruePair,
+        kChargePos,
+        kChargeNeg,
+        kPIDType,
+        kLastCutType
+    };
+
+    enum ERsnCutVarType
+    {
+        kDouble_t = 0,
+        kInt_t,
+        kUInt_t
+    };
+
+    enum ECutSetType
+    {
+        kParticle = 0,
+        kPair,
+        kMixEventFinderCut,
+        kLastCutSetIndex
+    };
+
+    AliRsnCut();
+    AliRsnCut (const char *name, const char *title, ERsnCutType type);
+    AliRsnCut (const char *name, const char *title, ERsnCutType type, Double_t min, Double_t max = 1e-100);
+    AliRsnCut (const char *name, const char *title, ERsnCutType type, Int_t min, Int_t max = 32767);
+    AliRsnCut (const char *name, const char *title, ERsnCutType type, UInt_t min, UInt_t max = 65534);
+
+    ~AliRsnCut();
+
+    void      SetCutValues (ERsnCutType type, const Double_t& theValue, const Double_t& theValue2);
+    void      SetCutValues (ERsnCutType type, const Int_t& theValue, const Int_t& theValue2);
+    void      SetCutValues (ERsnCutType type, const UInt_t& theValue, const UInt_t& theValue2);
+
+    Bool_t    IsSelected (ECutSetType type,  AliRsnDaughter *daughter);
+    Bool_t    IsSelected (ECutSetType type,  AliRsnPairParticle *pair);
+
+    void      PrintAllValues();
+
+    Bool_t    IsBetween (const Double_t &theValue);
+    Bool_t    IsEqual (const Int_t &theValue);
+    Bool_t    IsEqual (const UInt_t &theValue);
+    Bool_t    IsEqual (const Double_t &theValue);
+
+private:
+
+    Bool_t CheckRestMomentum(AliRsnPairParticle *pair);
+
+    Double_t        fDMin;          // min. double value
+    Double_t        fDMax;          // max. double value
+    Int_t           fIMin;          // min. int value
+    Int_t           fIMax;          // max. int value
+    UInt_t          fUIMin;         // min. uint value
+    UInt_t          fUIMax;         // max. uint value
+
+    ERsnCutType     fRsnCutType;    // cut type
+    ERsnCutVarType  fRsnCutVarType; // variable type
+
+    static const Double_t fgkDSmallNumber;  // small double value
+    static const Double_t fgkDBigNumber;    // big double value
+    static const Int_t    fgkIBigNumber;    // big int value
+
+    ClassDef (AliRsnCut, 1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnCutMgr.cxx b/PWG2/RESONANCES/AliRsnCutMgr.cxx
new file mode 100644 (file)
index 0000000..c1f9090
--- /dev/null
@@ -0,0 +1,70 @@
+#include "AliLog.h"
+
+#include "AliRsnDaughter.h"
+#include "AliRsnCutSet.h"
+#include "AliRsnCutMgr.h"
+
+ClassImp ( AliRsnCutMgr )
+
+AliRsnCutMgr::AliRsnCutMgr()
+    : TNamed("defaultName","default Tilte")
+{
+  for ( Int_t i=0 ;i<AliRsnCut::kLastCutSetIndex ;i++ )
+  {
+    fCutSets[i] = 0;
+  }
+
+}
+
+AliRsnCutMgr::AliRsnCutMgr ( const char * name, const char * title )
+    : TNamed ( name,title )
+{
+
+  for ( Int_t i=0 ;i<AliRsnCut::kLastCutSetIndex ;i++ )
+  {
+    fCutSets[i] = 0 ;
+  }
+
+}
+
+AliRsnCutMgr::~AliRsnCutMgr()
+{
+  for ( Int_t i=0 ;i<AliRsnCut::kLastCutSetIndex ;i++ )
+  {
+    delete fCutSets[i];
+  }
+
+}
+
+void AliRsnCutMgr::SetCutSet ( AliRsnCut::ECutSetType type, AliRsnCutSet* cutset )
+{
+  if ( !fCutSets[type] )
+    fCutSets[type] = ( AliRsnCutSet* ) cutset->Clone() ;
+  AliDebug (AliLog::kDebug ,Form ( "DatasetName %s",fCutSets[type]->GetName() ) );
+}
+
+
+Bool_t AliRsnCutMgr::IsSelected ( AliRsnCut::ECutSetType type,TObject *obj )
+{
+  AliDebug ( AliLog::kDebug,"<-" );
+
+  if (!fCutSets[type]) return kTRUE;
+
+  switch ( type )
+  {
+    case AliRsnCut::kParticle:
+//       AliDebug ( AliLog::kDebug,"kParticle" );
+      return fCutSets[type]->IsSelected (type, ( AliRsnDaughter * ) obj );
+      break;
+    case AliRsnCut::kPair:
+//       AliInfo ( Form("%p" ,fCutSets[type]));
+      return fCutSets[type]->IsSelected (type, ( AliRsnPairParticle * ) obj );
+      break;
+    default:
+      AliWarning ( "Wrong ECutSetType selected." );
+      return kTRUE;
+      break;
+
+  }
+  return kTRUE;
+}
diff --git a/PWG2/RESONANCES/AliRsnCutMgr.h b/PWG2/RESONANCES/AliRsnCutMgr.h
new file mode 100644 (file)
index 0000000..5f3b2a6
--- /dev/null
@@ -0,0 +1,44 @@
+#ifndef ALIRSNMVCUTMGR_H
+#define ALIRSNMVCUTMGR_H
+
+#include "TNamed.h"
+#include "TObjArray.h"
+
+#include "AliRsnCut.h"
+// #include "AliRsnCutSet.h"
+// class AliRsnCut;
+class AliRsnCutSet;
+
+/**
+  @author Martin Vala <Martin.Vala@cern.ch>
+*/
+class AliRsnCutMgr : public TNamed
+{
+  public:
+    
+//     enum ECutSetType {
+//       kParticle= 0,
+//       kPair,
+//       kMixEventFinderCut,
+//       kLastCutSetIndex
+//     };
+
+    
+    AliRsnCutMgr();
+    AliRsnCutMgr(const char *name, const char* title);
+
+    ~AliRsnCutMgr();
+    
+    void SetCutSet(AliRsnCut::ECutSetType type,AliRsnCutSet* cutset);
+    AliRsnCutSet* GetCutSet(AliRsnCut::ECutSetType type) { return fCutSets[type];}
+    
+    Bool_t IsSelected(AliRsnCut::ECutSetType type,TObject *obj);
+
+  private:
+
+    AliRsnCutSet *fCutSets[AliRsnCut::kLastCutSetIndex];
+    
+    ClassDef ( AliRsnCutMgr,1 );
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnCutSet.cxx b/PWG2/RESONANCES/AliRsnCutSet.cxx
new file mode 100644 (file)
index 0000000..4c07d3f
--- /dev/null
@@ -0,0 +1,228 @@
+#include "AliLog.h"
+
+#include "AliRsnCut.h"
+#include "AliRsnExpression.h"
+
+#include "AliRsnCutSet.h"
+
+ClassImp ( AliRsnCutSet )
+
+AliRsnCutSet::AliRsnCutSet()
+    : TNamed(),fNumOfCuts ( 0 ),
+    fCutScheme ( "" ),
+    fCutSchemeIndexed ( "" ),
+    fBoolValues ( 0 ),fIsScheme ( kFALSE )
+{
+  fBoolValues = new Bool_t[1];
+//   fExpression = new AliRsnExpression ( fCutSchemeIndexed );
+  fExpression = 0;
+  AliRsnExpression::sCutSet = this;
+}
+
+AliRsnCutSet::AliRsnCutSet ( TString name )
+    : TNamed ( name,name ),fNumOfCuts ( 0 ),
+    fCutScheme ( "" ),
+    fCutSchemeIndexed ( "" ),
+    fBoolValues ( 0 ),fIsScheme ( kFALSE )
+{
+  fBoolValues = new Bool_t[1];
+  fExpression = 0;
+  AliRsnExpression::sCutSet = this;
+}
+
+AliRsnCutSet::AliRsnCutSet ( const AliRsnCutSet & copy )
+    :    TNamed ( ( TNamed ) copy ),fCuts ( copy.fCuts ),fNumOfCuts ( copy.fNumOfCuts ),
+    fCutScheme ( copy.fCutScheme ),
+    fCutSchemeIndexed ( copy.fCutSchemeIndexed ),
+    fIsScheme ( copy.fIsScheme ),
+    fExpression ( copy.fExpression )
+{
+  AliRsnExpression::sCutSet = this;
+}
+
+AliRsnCutSet::~AliRsnCutSet()
+{
+  delete fExpression;
+  delete [] fBoolValues;
+}
+
+void AliRsnCutSet::AddCut ( AliRsnCut * cut )
+{
+  AliDebug ( AliLog::kDebug,"<-" );
+  fCuts.Add ( cut );
+  fNumOfCuts++;
+  if ( fBoolValues )
+    delete fBoolValues;
+  fBoolValues = new Bool_t[fNumOfCuts];
+  for ( Int_t i=0;i<fNumOfCuts ; i++ )
+  {
+    fBoolValues[i] = kTRUE;
+  }
+
+  AliDebug ( AliLog::kDebug,Form ( "%d",fCuts.GetEntriesFast() ) );
+  AliDebug ( AliLog::kDebug,"->" );
+}
+
+void AliRsnCutSet::ShowCuts ( )
+{
+//   AliRsnCut *cut;
+//   for ( Int_t i=0; i<fCuts.GetEntriesFast() ;i++ )
+//   {
+//     cut = ( AliRsnCut* ) fCuts.At ( i );
+//     AliInfo ( Form ( "%s (\"%s\") [%.2f - %.2f]",cut->GetName(),cut->GetTitle(),cut->GetMin(),cut->GetMax() ) );
+//   }
+}
+
+Bool_t AliRsnCutSet::IsSelected ( AliRsnCut::ECutSetType type, AliRsnDaughter *daughter )
+{
+  if ( !fNumOfCuts )
+    return kTRUE;
+
+  Bool_t boolReturn = kTRUE;
+  AliRsnCut *cut;
+  for ( Int_t i=0; i<fNumOfCuts ;i++ )
+  {
+    cut = ( AliRsnCut* ) fCuts.At ( i );
+    fBoolValues[i] = cut->IsSelected ( type,daughter );
+//     AliInfo(Form("%s %d",cut->GetName(),fBoolValues[i]));
+  }
+
+  if ( fIsScheme )
+    boolReturn = Passed();
+
+  return boolReturn;
+}
+
+Bool_t AliRsnCutSet::IsSelected ( AliRsnCut::ECutSetType type, AliRsnPairParticle * pair )
+{
+  if ( !fNumOfCuts )
+    return kTRUE;
+
+  Bool_t boolReturn = kTRUE;
+  AliRsnCut *cut;
+  for ( Int_t i=0; i<fNumOfCuts ;i++ )
+  {
+    cut = ( AliRsnCut* ) fCuts.At ( i );
+    fBoolValues[i] = cut->IsSelected (type,pair );
+//     AliInfo(Form("%s %d",cut->GetName(),fBoolValues[i]));
+  }
+
+  if ( fIsScheme )
+    boolReturn = Passed();
+
+  return boolReturn;
+}
+
+
+void AliRsnCutSet::SetCutScheme ( const TString & theValue )
+{
+  AliDebug ( AliLog::kDebug,"<-" );
+  fCutScheme = theValue;
+  SetCutSchemeIndexed ( theValue );
+  fIsScheme = kTRUE;
+  AliDebug ( AliLog::kDebug,"->" );
+}
+
+
+void AliRsnCutSet::SetCutSchemeIndexed ( TString theValue )
+{
+  AliDebug ( AliLog::kDebug,"<-" );
+//   fCutSchemeIndexed = theValue;
+  fCutSchemeIndexed = GetCutSchemeIndexed();
+  AliDebug ( AliLog::kDebug,"->" );
+}
+
+Int_t AliRsnCutSet::GetIndexByCutName ( TString s )
+{
+  AliRsnCut *cut;
+  for ( Int_t i=0 ;i< fCuts.GetEntriesFast() ;i++ )
+  {
+    cut = ( AliRsnCut* ) fCuts.At ( i );
+//     if ( !cut->GetName().CompareTo ( s ) )
+    if ( !s.CompareTo ( cut->GetName() ) )
+    {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+Bool_t AliRsnCutSet::Passed()
+{
+  AliRsnExpression::sCutSet = this;
+  if ( !fExpression )
+  {
+    fExpression = new AliRsnExpression ( fCutSchemeIndexed );
+    AliDebug ( AliLog::kDebug,"fExpression was created." );
+  }
+  return fExpression->Value ( *GetCuts() );
+}
+
+Bool_t AliRsnCutSet::IsValidScheme()
+{
+  return ( ! ( ShowCutScheme().Contains ( "Error" ) ) );
+}
+
+TString AliRsnCutSet::ShowCutScheme()
+{
+  return fExpression->Unparse();
+}
+
+Int_t AliRsnCutSet::TestExpression ( TString opt )
+{
+//   AliRsnCut *cut1 = new AliRsnCut ( "aaa","aaa" );
+//   cut1->SetCutValues ( AliRsnCut::kEsdPt,0.0,1.0 );
+//   AliRsnCut *cut2 = new AliRsnCut ( "bbb","bbb" );
+//   cut2->SetCutValues ( AliRsnCut::kEsdPt,1.,2.0 );
+//   AliRsnCut *cut3 = new AliRsnCut ( "ccc","ccc" );
+//   cut3->SetCutValues ( AliRsnCut::kEsdPt,2.0,3.0 );
+//
+//   AliRsnCutSet* set  = new AliRsnCutSet ( "setOne" );
+//   set->AddCut ( cut1 );
+//   set->AddCut ( cut2 );
+//   set->AddCut ( cut3 );
+//
+//   set->SetCutScheme ( "(aaa&!(ccc))&(bbb&!(ccc))" );
+//
+//   set->ShowCuts ();
+
+  return 0;
+}
+
+void AliRsnCutSet::PrintSetInfo()
+{
+
+
+  AliInfo ( "========== Rsn Cut Set info ==============" );
+  AliInfo ( Form ( "Sheme : %s",fCutScheme.Data() ) );
+  AliInfo ( Form ( "Sheme : %s",fCutSchemeIndexed.Data() ) );
+  AliInfo ( Form ( "Num of Cuts: %d", fCuts.GetEntriesFast() ) );
+  AliInfo ( "====== Cuts ======" );
+  AliRsnCut *cut;
+  for ( Int_t i=0 ;i< fCuts.GetEntriesFast() ;i++ )
+  {
+    cut = ( AliRsnCut* ) fCuts.At ( i );
+    if ( cut )
+      AliInfo ( Form ( "%d %d",i,fBoolValues[i] ) );
+
+  }
+  AliInfo ( "========== END Rsn Cut Mgr info ==============" );
+
+}
+
+TString AliRsnCutSet::GetCutSchemeIndexed()
+{
+  AliDebug ( AliLog::kDebug,"<-" );
+  TString str ( fCutScheme );
+  AliDebug ( AliLog::kDebug,Form ( "Num of cuts %d",fCuts.GetEntriesFast() ) );
+  AliRsnCut *cut;
+  for ( Int_t i=0; i<fCuts.GetEntriesFast();i++ )
+  {
+    cut = ( AliRsnCut* ) fCuts.At ( i );
+    str.ReplaceAll ( cut->GetName(),Form ( "%d",i ) );
+  }
+  AliDebug ( AliLog::kDebug,"->" );
+  return str;
+}
+
diff --git a/PWG2/RESONANCES/AliRsnCutSet.h b/PWG2/RESONANCES/AliRsnCutSet.h
new file mode 100644 (file)
index 0000000..80bf542
--- /dev/null
@@ -0,0 +1,66 @@
+#ifndef ALIRSNCUTSET_H
+#define ALIRSNCUTSET_H
+
+#include <TNamed.h>
+#include <TObjArray.h>
+
+#include "AliRsnCut.h"
+// class AliRsnCut; 
+class AliRsnCutMgr;
+
+class AliRsnDaughter;
+class AliRsnExpression;
+class AliRsnPairParticle;
+
+class AliRsnCutSet : public TNamed
+{
+  
+  public:
+    AliRsnCutSet();
+    AliRsnCutSet ( TString name );
+    AliRsnCutSet ( const AliRsnCutSet &copy );
+
+    ~AliRsnCutSet();
+
+    void      AddCut ( AliRsnCut* cut );
+//     void      SetCutScheme ( TString sheme ) {fCutScheme = sheme;}
+
+    void      ShowCuts();
+    Int_t     GetIndexByCutName ( TString s );
+    Bool_t    Passed();
+    Bool_t    IsValidScheme();
+    TString   ShowCutScheme();
+    Int_t     TestExpression ( TString opt="short" );
+    void      PrintSetInfo();
+
+    Bool_t    IsSelected (AliRsnCut::ECutSetType type, AliRsnDaughter *daughter );
+    Bool_t    IsSelected (AliRsnCut::ECutSetType type, AliRsnPairParticle *pair );
+//     Bool_t    IsSelected ( AliRsnEffectiveParticle *pair );
+//     Bool_t    IsSelected(TObject*obj);
+
+    void SetBoolValue ( Bool_t theValue,Int_t index ) { fBoolValues[index] = theValue; }
+    Bool_t GetBoolValue ( Int_t index ) const { return fBoolValues[index]; }
+
+    void SetCutScheme ( const TString& theValue );
+    TString GetCutScheme() const { return fCutScheme; }
+
+    void SetCutSchemeIndexed ( TString theValue );
+    TString   GetCutSchemeIndexed();
+
+    TObjArray *GetCuts() { return &fCuts; }
+
+
+  private:
+    TObjArray     fCuts;                  // array of cuts
+    Int_t         fNumOfCuts;             // number of cuts
+    TString       fCutScheme;             // cut scheme
+    TString       fCutSchemeIndexed;      // cut scheme indexed
+
+    Bool_t        *fBoolValues;           //[fNumOfCuts]
+    Bool_t        fIsScheme;              // is scheme
+    AliRsnExpression  *fExpression;     // pointer to AliRsnExpression
+
+    ClassDef ( AliRsnCutSet,1 );
+};
+
+#endif
index e6b368095103921d33ff7072a90e946fd871d06a..2a5a932252c8bc26935fd4bd7fb42324b64cf9ec 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// ***********************
-// *** AliRsnDaughter ****
-// ***********************
-// 
+//=========================================================================
+// Class AliRsnDaughter
+//
+//
 // Light-weight 'track' object into an internal format used
 // for further steps of resonance analysis.
 // Provides converters from all kinds of input track type
@@ -24,6 +24,7 @@
 // Contains also a facility to compute invariant mass of a pair.
 //
 // author: A. Pulvirenti --- email: alberto.pulvirenti@ct.infn.it
+//=========================================================================
 
 #include <Riostream.h>
 
@@ -36,7 +37,7 @@
 #include "AliMCParticle.h"
 
 #include "AliRsnPID.h"
-#include "AliRsnParticle.h"
+#include "AliRsnMCInfo.h"
 #include "AliRsnDaughter.h"
 
 ClassImp(AliRsnDaughter)
@@ -49,14 +50,13 @@ AliRsnDaughter::AliRsnDaughter() :
   fCharge(0),
   fFlags(0),
   fPIDType(AliRsnPID::kUnknown),
-  fPIDProb(0.0),
   fMass(0.0),
-  fParticle(0x0)
+  fMCInfo(0x0)
 {
-//=========================================================
+//
 // Default constructor.
 // Initializes all data-members with meaningless values.
-//=========================================================
+//
 
     Int_t i;
     for (i = 0; i < AliRsnPID::kSpecies; i++) {
@@ -65,6 +65,7 @@ AliRsnDaughter::AliRsnDaughter() :
             fV[i] = 0.0;
         }
         fPIDWeight[i] = 0.0;
+        fPIDProb[i] = 0.0;
     }
 }
 
@@ -76,13 +77,12 @@ AliRsnDaughter::AliRsnDaughter(const AliRsnDaughter &copy) :
   fCharge(copy.fCharge),
   fFlags(copy.fFlags),
   fPIDType(copy.fPIDType),
-  fPIDProb(copy.fPIDProb),
   fMass(copy.fMass),
-  fParticle(0x0)
+  fMCInfo(0x0)
 {
-//=========================================================
+//
 // Copy constructor.
-//=========================================================
+//
 
     Int_t i;
     for (i = 0; i < AliRsnPID::kSpecies; i++) {
@@ -91,30 +91,32 @@ AliRsnDaughter::AliRsnDaughter(const AliRsnDaughter &copy) :
             fV[i] = copy.fV[i];
         }
         fPIDWeight[i] = copy.fPIDWeight[i];
+        fPIDProb[i] = copy.fPIDProb[i];
     }
 
-    // initialize particle object 
+    // initialize particle object
     // only if it is present in the template object
-    if (copy.fParticle) fParticle = new AliRsnParticle(*(copy.fParticle));
+    if (copy.fMCInfo) fMCInfo = new AliRsnMCInfo(*(copy.fMCInfo));
 }
 
 //_____________________________________________________________________________
-AliRsnDaughter::AliRsnDaughter(AliESDtrack *track) :
+AliRsnDaughter::AliRsnDaughter(AliESDtrack *track, Bool_t useTPC) :
   AliVParticle(),
   fIndex(-1),
   fLabel(-1),
   fCharge(0),
   fFlags(0),
   fPIDType(AliRsnPID::kUnknown),
-  fPIDProb(0.0),
   fMass(0.0),
-  fParticle(0x0)
+  fMCInfo(0x0)
 {
-//=========================================================
+//
 // Constructor to get data from an ESD track.
-//=========================================================
+//
 
-    Adopt(track);
+    Int_t i;
+    for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0;
+    Adopt(track, useTPC);
 }
 
 //_____________________________________________________________________________
@@ -125,14 +127,15 @@ AliRsnDaughter::AliRsnDaughter(AliAODTrack *track) :
   fCharge(0),
   fFlags(0),
   fPIDType(AliRsnPID::kUnknown),
-  fPIDProb(0.0),
   fMass(0.0),
-  fParticle(0x0)
+  fMCInfo(0x0)
 {
-//=========================================================
+//
 // Constructor to get data from an AOD track.
-//=========================================================
+//
 
+    Int_t i;
+    for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0;
     Adopt(track);
 }
 
@@ -144,26 +147,27 @@ AliRsnDaughter::AliRsnDaughter(AliMCParticle *track) :
   fCharge(0),
   fFlags(0),
   fPIDType(AliRsnPID::kUnknown),
-  fPIDProb(0.0),
   fMass(0.0),
-  fParticle(0x0)
+  fMCInfo(0x0)
 {
-//=========================================================
+//
 // Constructor to get data from an MC track.
-//=========================================================
+//
 
+    Int_t i;
+    for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDProb[i] = 0.0;
     Adopt(track);
 }
 
 //_____________________________________________________________________________
 AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter &copy)
 {
-//=========================================================
+//
 // Assignment operator.
 // Works like the copy constructor and returns a reference
 // to the initialized object for which it is called.
-//=========================================================
-    
+//
+
     fIndex  = copy.fIndex;
     fLabel  = copy.fLabel;
     fCharge = copy.fCharge;
@@ -176,20 +180,20 @@ AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter &copy)
             fV[i] = copy.fV[i];
         }
         fPIDWeight[i] = copy.fPIDWeight[i];
+        fPIDProb[i] = copy.fPIDProb[i];
     }
-    
+
     fPIDType = copy.fPIDType;
-    fPIDProb = copy.fPIDProb;
     fMass    = copy.fMass;
-    
-    // initialize particle object 
+
+    // initialize particle object
     // only if it is present in the template object;
     // otherwise, it is just cleared and not replaced with anything
-    if (fParticle) {
-        delete fParticle;
-        fParticle = 0x0;
+    if (fMCInfo) {
+        delete fMCInfo;
+        fMCInfo = 0x0;
     }
-    if (copy.fParticle) fParticle = new AliRsnParticle(*(copy.fParticle));
+    if (copy.fMCInfo) fMCInfo = new AliRsnMCInfo(*(copy.fMCInfo));
 
     return (*this);
 }
@@ -197,23 +201,23 @@ AliRsnDaughter& AliRsnDaughter::operator=(const AliRsnDaughter &copy)
 //_____________________________________________________________________________
 AliRsnDaughter::~AliRsnDaughter()
 {
-//=========================================================
+//
 // Destructor
-//=========================================================
+//
 
-    if (fParticle) {
-        delete fParticle;
-        fParticle = 0;
+    if (fMCInfo) {
+        delete fMCInfo;
+        fMCInfo = 0;
     }
 }
 
 //_____________________________________________________________________________
 void AliRsnDaughter::SetPIDWeight(Int_t i, Double_t value)
 {
-//=========================================================
+//
 // I the argument 'i' is in the correct range,
 // sets the i-th PID weight to 'value'
-//=========================================================
+//
 
     if (i >= 0 && i < AliRsnPID::kSpecies) fPIDWeight[i] = value;
     else {
@@ -221,15 +225,28 @@ void AliRsnDaughter::SetPIDWeight(Int_t i, Double_t value)
     }
 }
 
+//_____________________________________________________________________________
+void AliRsnDaughter::SetPIDProb(Int_t i, Double_t value)
+{
+//
+// I the argument 'i' is in the correct range,
+// sets the i-th PID probability to 'value'
+//
+
+    if (i >= 0 && i < AliRsnPID::kSpecies) fPIDProb[i] = value;
+    else {
+        AliError(Form("Cannot set a weight related to slot %d", i));
+    }
+}
 
 //_____________________________________________________________________________
 void AliRsnDaughter::SetPIDWeights(const Double_t *pid)
 {
-//=========================================================
+//
 // Sets ALL PID weights at once.
 // The passed array is supposed to have at least as many
 // slots as the number of allowed particle species.
-//=========================================================
+//
 
    Int_t i;
    for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDWeight[i] = pid[i];
@@ -237,38 +254,50 @@ void AliRsnDaughter::SetPIDWeights(const Double_t *pid)
 
 
 //_____________________________________________________________________________
-Bool_t AliRsnDaughter::Adopt(AliESDtrack* esdTrack)
+Bool_t AliRsnDaughter::Adopt(AliESDtrack* esdTrack, Bool_t useTPCInnerParam)
 {
-//=========================================================
+//
 // Copies data from an AliESDtrack into "this":
 //  - charge sign
 //  - momentum
 //  - point of closest approach to primary vertex
 //  - ESD pid weights
 // In case of errors returns kFALSE, otherwise kTRUE.
-//=========================================================
+//
 
     if (!esdTrack) {
         AliError("Passed NULL object: nothing done");
         return kFALSE;
     }
-       
+
     // copy momentum and vertex
-    esdTrack->GetPxPyPz(fP);
-    esdTrack->GetXYZ(fV);
+    if (!useTPCInnerParam) {
+        esdTrack->GetPxPyPz(fP);
+        esdTrack->GetXYZ(fV);
+    }
+    else {
+        if (!esdTrack->GetTPCInnerParam()) return kFALSE;
+        esdTrack->GetTPCInnerParam()->GetPxPyPz(fP);
+        esdTrack->GetTPCInnerParam()->GetXYZ(fV);
+    }
 
     // copy PID weights
     Int_t    i;
     Double_t pid[5];
-    esdTrack->GetESDpid(pid);
+    if (!useTPCInnerParam) {
+        esdTrack->GetESDpid(pid);
+    }
+    else {
+        esdTrack->GetTPCpid(pid);
+    }
     for (i = 0; i < 5; i++) fPIDWeight[i] = pid[i];
-    
+
     // copy flags
     fFlags = esdTrack->GetStatus();
-    
+
     // copy charge sign
     fCharge = (Short_t)esdTrack->Charge();
+
     return kTRUE;
 }
 
@@ -276,20 +305,20 @@ Bool_t AliRsnDaughter::Adopt(AliESDtrack* esdTrack)
 //_____________________________________________________________________________
 Bool_t AliRsnDaughter::Adopt(AliAODTrack* aodTrack)
 {
-//=========================================================
+//
 // Copies data from an AliAODtrack into "this":
 //  - charge sign
 //  - momentum
 //  - point of closest approach to primary vertex
 //  - ESD pid weights
 // In case of errors returns kFALSE, otherwise kTRUE.
-//=========================================================
+//
 
     if (!aodTrack) {
         AliError("Passed NULL object: nothing done");
         return kFALSE;
     }
-       
+
     // copy momentum  and vertex
     fP[0] = aodTrack->Px();
     fP[1] = aodTrack->Py();
@@ -297,11 +326,11 @@ Bool_t AliRsnDaughter::Adopt(AliAODTrack* aodTrack)
     fV[0] = aodTrack->Xv();
     fV[1] = aodTrack->Yv();
     fV[2] = aodTrack->Zv();
-    
+
     // copy PID weights
     Int_t i;
     for (i = 0; i < 5; i++) fPIDWeight[i] = aodTrack->PID()[i];
-    
+
     // copy sign
     fCharge = aodTrack->Charge();
 
@@ -312,7 +341,7 @@ Bool_t AliRsnDaughter::Adopt(AliAODTrack* aodTrack)
 //_____________________________________________________________________________
 Bool_t AliRsnDaughter::Adopt(AliMCParticle *mcParticle)
 {
-//=========================================================
+//
 // Copies data from a MCParticle into "this":
 //  - charge sign
 //  - momentum
@@ -321,20 +350,20 @@ Bool_t AliRsnDaughter::Adopt(AliMCParticle *mcParticle)
 //  - true PDG code
 //  - mother
 // In case of errors returns kFALSE, otherwise kTRUE.
-//=========================================================
+//
 
     if (!mcParticle) {
         AliError("Passed NULL object: nothing done");
         return kFALSE;
     }
-       
+
        // retrieve the TParticle object from the argument
        TParticle *particle = mcParticle->Particle();
        if (!particle) {
           AliError("AliMCParticle::Particle() returned NULL");
           return kFALSE;
     }
-       
+
     // copy momentum  and vertex
     fP[0] = particle->Px();
     fP[1] = particle->Py();
@@ -342,7 +371,7 @@ Bool_t AliRsnDaughter::Adopt(AliMCParticle *mcParticle)
     fV[0] = particle->Vx();
     fV[1] = particle->Vy();
     fV[2] = particle->Vz();
-    
+
     // recognize charge sign from PDG code sign
     Int_t pdg = particle->GetPdgCode();
     Int_t absPDG = TMath::Abs(pdg);
@@ -356,19 +385,18 @@ Bool_t AliRsnDaughter::Adopt(AliMCParticle *mcParticle)
         fCharge = 0;
         return kFALSE;
     }
-    
+
     // identify track perfectly using PDG code
     fPIDType = AliRsnPID::InternalType(pdg);
-    fPIDProb = 1.0;
     fMass = AliRsnPID::ParticleMass(fPIDType);
-    
+
     // flags and PID weights make no sense with MC tracks
     fFlags = 0;
     for (pdg = 0; pdg < AliRsnPID::kSpecies; pdg++) fPIDWeight[pdg] = 0.0;
     fPIDWeight[fPIDType] = 1.0;
-    
+
     // copy other MC info (mother PDG code cannot be retrieved here)
-    InitParticle(particle);
+    InitMCInfo(particle);
 
     return kTRUE;
 }
@@ -376,7 +404,7 @@ Bool_t AliRsnDaughter::Adopt(AliMCParticle *mcParticle)
 //_____________________________________________________________________________
 void AliRsnDaughter::Print(Option_t *option) const
 {
-//=========================================================
+//
 // Prints the values of data members, using the options:
 // - P --> momentum
 // - V --> DCA vertex
@@ -384,18 +412,18 @@ void AliRsnDaughter::Print(Option_t *option) const
 // - F --> flags
 // - I --> identification (PID, probability and mass)
 // - W --> PID weights
-// - M --> Montecarlo (from AliRsnParticle)
+// - M --> Montecarlo (from AliRsnMCInfo)
 // - ALL --> All oprions switched on
 //
 // Index and label are printed by default.
-//=========================================================
+//
 
     TString opt(option);
     opt.ToUpper();
-    
+
     cout << ".......Index            : " << fIndex << endl;
     cout << ".......Label            : " << fLabel << endl;
-    
+
     if (opt.Contains("P") || opt.Contains("ALL")) {
         cout << ".......Px, Py, Pz, Pt   : " << Px() << ' ' << Py() << ' ' << Pz() << ' ' << Pt() << endl;
     }
@@ -410,7 +438,9 @@ void AliRsnDaughter::Print(Option_t *option) const
     }
     if (opt.Contains("I") || opt.Contains("ALL")) {
         cout << ".......PID              : " << AliRsnPID::ParticleName(fPIDType) << endl;
-        cout << ".......PID probability  : " << fPIDProb << endl;
+        if (fPIDType > 0 && fPIDType < AliRsnPID::kSpecies) {
+            cout << ".......PID probability  : " << fPIDProb[fPIDType] << endl;
+        }
         cout << ".......Mass             : " << fMass << endl;
     }
     if (opt.Contains("W") || opt.Contains("ALL")) {
@@ -420,10 +450,10 @@ void AliRsnDaughter::Print(Option_t *option) const
         cout << endl;
     }
     if (opt.Contains("M") || opt.Contains("ALL")) {
-        if (fParticle) {
-            cout << ".......PDG code         : " << fParticle->PDG() << endl;
-            cout << ".......Mother (label)   : " << fParticle->Mother() << endl;
-            cout << ".......Mother (PDG code): " << fParticle->MotherPDG() << endl;
+        if (fMCInfo) {
+            cout << ".......PDG code         : " << fMCInfo->PDG() << endl;
+            cout << ".......Mother (label)   : " << fMCInfo->Mother() << endl;
+            cout << ".......Mother (PDG code): " << fMCInfo->MotherPDG() << endl;
         }
         else {
             cout << ".......MC info not present" << endl;
@@ -431,109 +461,57 @@ void AliRsnDaughter::Print(Option_t *option) const
     }
 }
 
-
 //_____________________________________________________________________________
-AliRsnDaughter AliRsnDaughter::Sum(AliRsnDaughter t1, AliRsnDaughter t2)
+void AliRsnDaughter::InitMCInfo()
 {
-//=========================================================
-// Creates an AliRsnDaughter object composing momenta
-// of the particles passed as arguments.
-// The vector momentum of the returned object is 
-// the sum of the ones of the arguments.
-// The mass of the object is set to the invariant mass
-// computed from the relativistic sum of the 4-momenta
-// of the two arguments.
-// Finally, if both arguments have the same 'fMother' 
-// (when this MC information is available), it is set
-// also as the 'fMother' of the returned object, together
-// with its PDG code.
-//=========================================================
-
-    // create a 'default' new AliRsnDaughter
-    AliRsnDaughter out;
-    
-    // define the momentum of the sum as the 
-    // relativistic sum of 4-momenta of arguments
-    Double_t etot  = t1.E()  + t2.E();
-    Double_t pxTot = t1.Px() + t2.Px();
-    Double_t pyTot = t1.Py() + t2.Py();
-    Double_t pzTot = t1.Pz() + t2.Pz();
-    Double_t mass  = TMath::Sqrt(etot*etot - pxTot*pxTot - pyTot*pyTot - pzTot*pzTot);
-    out.SetM(mass);
-    out.SetP(pxTot, pyTot, pzTot);
-    
-    // if both arguments have MC info, it is used here
-    // to check if they (in the truth MC) are daughters
-    // of the same resonance and, if this is the case,
-    // details of that resonance are set into the 
-    // 'fParticle' object of the sum
-    Int_t mum1, mum2;
-    if (t1.GetParticle() && t2.GetParticle()) {
-        out.InitParticle();
-        mum1 = t1.GetParticle()->Mother();
-        mum2 = t2.GetParticle()->Mother();
-        if (mum1 == mum2 && mum1 >= 0) {
-            out.SetLabel(mum1);
-            out.GetParticle()->SetPDG(t1.GetParticle()->MotherPDG());
-        }
-    }
-
-    return out;
-}
-
-
-//_____________________________________________________________________________
-void AliRsnDaughter::InitParticle()
-{
-//=========================================================
+//
 // Initializes the particle object with default constructor.
-//=========================================================
+//
 
-    fParticle = new AliRsnParticle;
+    fMCInfo = new AliRsnMCInfo;
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnDaughter::InitParticle(TParticle *particle)
+Bool_t AliRsnDaughter::InitMCInfo(TParticle *particle)
 {
-//=========================================================
+//
 // Copies data from an MC particle into the object which
 // contains all MC details taken from kinematics info.
 // If requested by second argument, momentum and vertex
 // of the Particle are copied into the 'fP' and 'fV'
 // data members, to simulate a perfect reconstruction.
-// If something goes wrong, returns kFALSE, 
+// If something goes wrong, returns kFALSE,
 // otherwise returns kTRUE.
-//=========================================================
+//
 
     // retrieve the TParticle object pointed by this MC track
     if (!particle) {
         AliError("Passed NULL particle object");
         return kFALSE;
     }
-       
+
     // initialize object if not initialized yet
-    if (fParticle) delete fParticle;
-    fParticle = new AliRsnParticle;
-    fParticle->Adopt(particle);
+    if (fMCInfo) delete fMCInfo;
+    fMCInfo = new AliRsnMCInfo;
+    fMCInfo->Adopt(particle);
 
     return kTRUE;
 }
 
-
 //_____________________________________________________________________________
-Bool_t AliRsnDaughter::InitParticle(AliMCParticle *mcParticle)
+Bool_t AliRsnDaughter::InitMCInfo(AliMCParticle *mcParticle)
 {
-//=========================================================
+//
 // Copies data from an MC particle into the object which
 // contains all MC details taken from kinematics info.
 // If requested by second argument, momentum and vertex
 // of the Particle are copied into the 'fP' and 'fV'
 // data members, to simulate a perfect reconstruction.
-// If something goes wrong, returns kFALSE, 
+// If something goes wrong, returns kFALSE,
 // otherwise returns kTRUE.
-//=========================================================
+//
 
     // retrieve the TParticle object pointed by this MC track
     TParticle *particle = mcParticle->Particle();
-    return InitParticle(particle);
+    return InitMCInfo(particle);
 }
index 407548720e43672eb1c8434ffcc32141df082499..06f70744f22ec8a7d22dde4f0ae64342eecd8402 100644 (file)
@@ -3,17 +3,15 @@
  * See cxx source for full Copyright notice                               *
  **************************************************************************/
 
-// ***********************
-// *** AliRsnDaughter ****
-// ***********************
-// 
-// Light-weight 'track' object into an internal format used
-// for further steps of resonance analysis.
-// Provides converters from all kinds of input track type
-// (ESD, AOD and MC).
-// Contains also a facility to compute invariant mass of a pair.
+//=============================================================================
+// Class AliRsnDaughter
+//
+// Light-weight 'track' AOD object which contains all required track details
+// which are used for resonance analysis.
+// Provides converters from all kinds of input track type: ESD, AOD and MC.
 //
 // author: A. Pulvirenti --- email: alberto.pulvirenti@ct.infn.it
+//=============================================================================
 
 #ifndef ALIRSNDAUGHTER_H
 #define ALIRSNDAUGHTER_H
@@ -29,90 +27,90 @@ class AliESDtrack;
 class AliAODTrack;
 class AliMCParticle;
 
-class AliRsnParticle;
+class AliRsnMCInfo;
 
 class AliRsnDaughter : public AliVParticle
 {
-public:
+  public:
 
     AliRsnDaughter();
-    AliRsnDaughter(const AliRsnDaughter &copy);
-    AliRsnDaughter(AliESDtrack *track);
-    AliRsnDaughter(AliAODTrack *track);
-    AliRsnDaughter(AliMCParticle *track);
+    AliRsnDaughter (const AliRsnDaughter &copy);
+    AliRsnDaughter (AliESDtrack *track, Bool_t useTPCInnerParam = kFALSE);
+    AliRsnDaughter (AliAODTrack *track);
+    AliRsnDaughter (AliMCParticle *track);
     virtual ~AliRsnDaughter();
-    AliRsnDaughter& operator=(const AliRsnDaughter& copy);
+    AliRsnDaughter& operator= (const AliRsnDaughter& copy);
 
     // 4-momentum
-    virtual Double_t E()  const {return TMath::Sqrt(fMass*fMass + P2());}
+    virtual Double_t E()  const {return TMath::Sqrt (fMass*fMass + P2());}
     virtual Double_t M()  const {return fMass;}
-    virtual Double_t P2() const {return Px()*Px() + Py()*Py() + Pz()*Pz();}
-    virtual Double_t P()  const {return TMath::Sqrt(P2());}
+    virtual Double_t P2() const {return Px() *Px() + Py() *Py() + Pz() *Pz();}
+    virtual Double_t P()  const {return TMath::Sqrt (P2());}
     virtual Double_t Px() const {return fP[0];}
     virtual Double_t Py() const {return fP[1];}
     virtual Double_t Pz() const {return fP[2];}
-    virtual Double_t Pt() const {return TMath::Sqrt(Px()*Px() + Py()*Py());}
+    virtual Double_t Pt() const {return TMath::Sqrt (Px() *Px() + Py() *Py());}
     virtual Double_t OneOverPt() const {return 1.0 / Pt();}
-    virtual Bool_t   PxPyPz(Double_t p[3]) const {p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE;}
-    void             SetPx(Double_t value) {fP[0] = value;}
-    void             SetPy(Double_t value) {fP[1] = value;}
-    void             SetPz(Double_t value) {fP[2] = value;}
-    void             SetP(Double_t px, Double_t py, Double_t pz) {SetPx(px); SetPy(py); SetPz(pz);}
-    void             SetM(Double_t m) {fMass = m;}
+    virtual Bool_t   PxPyPz (Double_t p[3]) const {p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE;}
+    void             SetPx (Double_t value) {fP[0] = value;}
+    void             SetPy (Double_t value) {fP[1] = value;}
+    void             SetPz (Double_t value) {fP[2] = value;}
+    void             SetP (Double_t px, Double_t py, Double_t pz) {SetPx (px); SetPy (py); SetPz (pz);}
+    void             SetM (Double_t m) {fMass = m;}
 
     // DCA vertex
     virtual Double_t Xv() const {return fV[0];}
     virtual Double_t Yv() const {return fV[1];}
     virtual Double_t Zv() const {return fV[2];}
-    virtual Double_t Vt() const {return TMath::Sqrt(Xv()*Xv() + Yv()*Yv());}
-    virtual Bool_t   XvYvZv(Double_t x[3]) const {x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE;}
-    void             SetVx(Double_t value) {fV[0] = value;}
-    void             SetVy(Double_t value) {fV[1] = value;}
-    void             SetVz(Double_t value) {fV[2] = value;}
-    void             SetV(Double_t vx, Double_t vy, Double_t vz) {SetVx(vx); SetVy(vy); SetVz(vz);}
+    virtual Double_t Vt() const {return TMath::Sqrt (Xv() *Xv() + Yv() *Yv());}
+    virtual Bool_t   XvYvZv (Double_t x[3]) const {x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE;}
+    void             SetVx (Double_t value) {fV[0] = value;}
+    void             SetVy (Double_t value) {fV[1] = value;}
+    void             SetVz (Double_t value) {fV[2] = value;}
+    void             SetV (Double_t vx, Double_t vy, Double_t vz) {SetVx (vx); SetVy (vy); SetVz (vz);}
 
     // Orientation
-    virtual Double_t Phi() const {return TMath::ATan2(Py(), Px());}
-    virtual Double_t Theta() const {return TMath::ATan2(Pt(), Pz());}
-    virtual Double_t Eta() const {return -TMath::Log(TMath::Tan(0.5*Theta()));}
-    virtual Double_t Y() const {return TMath::Log((E() + Pz()) / (E() - Pz()));}
+    virtual Double_t Phi() const {return TMath::ATan2 (Py(), Px());}
+    virtual Double_t Theta() const {return TMath::ATan2 (Pt(), Pz());}
+    virtual Double_t Eta() const {return -TMath::Log (TMath::Tan (0.5*Theta()));}
+    virtual Double_t Y() const {return TMath::Log ((E() + Pz()) / (E() - Pz()));}
 
     // Charge
     virtual Short_t Charge() const {return fCharge;}
-    void            SetCharge(Short_t value) {fCharge = value;}
+    void            SetCharge (Short_t value) {fCharge = value;}
 
     // PID
     virtual const Double_t* PID() const {return fPIDWeight;}
     AliRsnPID::EType        PIDType() const {return fPIDType;}
-    Double_t                PIDProb() {return fPIDProb;}
-    void                    SetPIDType(AliRsnPID::EType type) {fPIDType = type;}
-    void                    SetPIDProb(Double_t value) {fPIDProb = value;}
-    void                    SetPIDWeight(Int_t i, Double_t value);
-    void                    SetPIDWeights(const Double_t *pid);
+    const Double_t*         PIDProb() const {return fPIDProb;}
+    void                    SetPIDType (AliRsnPID::EType type) {fPIDType = type;}
+    void                    SetPIDProb (Int_t i, Double_t value);
+    void                    SetPIDWeight (Int_t i, Double_t value);
+    void                    SetPIDWeights (const Double_t *pid);
 
     // check that contains a given ESD flag
-    Bool_t    CheckFlag(ULong_t flag) {return (fFlags & flag);}
+    Bool_t  CheckFlag (ULong_t flag) {return (fFlags & flag);}
 
     // information getters from objects
-    Bool_t    Adopt(AliESDtrack *track);
-    Bool_t    Adopt(AliAODTrack *track);
-    Bool_t    Adopt(AliMCParticle *track);
+    Bool_t  Adopt (AliESDtrack *track, Bool_t useTPCInnerParam = kFALSE);
+    Bool_t  Adopt (AliAODTrack *track);
+    Bool_t  Adopt (AliMCParticle *track);
 
     // position in stack/array
-    Int_t Index() const {return fIndex;}
-    Int_t Label() const {return fLabel;}
-    void  SetIndex(Int_t value) {fIndex = value;}
-    void  SetLabel(Int_t value) {fLabel = value;}
+    Int_t   Index() const {return fIndex;}
+    Int_t   Label() const {return fLabel;}
+    void    SetIndex (Int_t value) {fIndex = value;}
+    void    SetLabel (Int_t value) {fLabel = value;}
 
     // Utilities
-    void                   Print(Option_t *option = "ALL") const;
-    static AliRsnDaughter  Sum(AliRsnDaughter t1, AliRsnDaughter t2);
-    AliRsnParticle        *GetParticle() {return fParticle;}
-    void                   InitParticle();
-    Bool_t                 InitParticle(TParticle *particle);
-    Bool_t                 InitParticle(AliMCParticle *mcParticle);
+    void    Print (Option_t *option = "ALL") const;
+    void    InitMCInfo();
+    Bool_t  InitMCInfo (TParticle *particle);
+    Bool_t  InitMCInfo (AliMCParticle *mcParticle);
+
+    AliRsnMCInfo* GetMCInfo() const { return fMCInfo; }
 
-private:
+  private:
 
     Int_t              fIndex;    // index of source object (ESD/AOD/MC) in its collection
     Int_t              fLabel;    // label assigned to the track (act. by GEANT3)
@@ -124,13 +122,13 @@ private:
     Double_t           fV[3];     // DCA vertex (x, y, z)
 
     AliRsnPID::EType   fPIDType;  // assigned PID
-    Double_t           fPIDProb;  // probability related to assigned PID
+    Double_t           fPIDProb[AliRsnPID::kSpecies];   // probability related to assigned PID
     Double_t           fPIDWeight[AliRsnPID::kSpecies]; // PID weights
     Double_t           fMass;     // mass (defined by PID)
 
-    AliRsnParticle    *fParticle; // reference to particle object (if any)
+    AliRsnMCInfo      *fMCInfo;   // reference to particle object (if any)
 
-    ClassDef(AliRsnDaughter, 3)
+    ClassDef (AliRsnDaughter, 3);
 };
 
 #endif
index 96926eed9523e6c1aaa7d49d55ec340a7c491b14..8a7e7acb0a955cb2b6db29a9acb9fedb8ce02f2d 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-//-------------------------------------------------------------------------
-//                      Class AliRsnEvent
-//                     -------------------
-//           Simple collection of reconstructed tracks
-//           selected from an ESD event
-//           to be used for analysis.
-//           .........................................
-// 
-// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
-//-------------------------------------------------------------------------
 
-#include <Riostream.h>
+//
+// *** Class AliRsnEvent ***
+//
+// A container for a collection of AliRsnDaughter objects from an event.
+// Contains also the primary vertex, useful for some cuts.
+// In order to retrieve easily the tracks which have been identified
+// as a specific type and charge, there is an array of indexes which
+// allows to avoid to loop on all tracks and have only the neede ones.
+//
+// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it)
+//          M. Vala (email: martin.vala@cern.ch)
+//
 
-#include <TString.h>
-#include <TRefArray.h>
-#include <TClonesArray.h>
+#include <Riostream.h>
 
 #include "AliLog.h"
-#include "AliESDtrack.h"
-#include "AliAODTrack.h"
-#include "AliRsnDaughter.h"
 
+#include "AliRsnDaughter.h"
 #include "AliRsnEvent.h"
+#include "AliRsnMCInfo.h"
 
-ClassImp(AliRsnEvent)
+ClassImp (AliRsnEvent)
 
 //_____________________________________________________________________________
 AliRsnEvent::AliRsnEvent() :
-  fSource(kUnknown),
-  fPVx(0.0),
-  fPVy(0.0),
-  fPVz(0.0),
-  fTracks(0x0),
-  fPos(0x0),
-  fNeg(0x0)
+    TNamed ("rsnEvent", ""),
+    fPVx (0.0),
+    fPVy (0.0),
+    fPVz (0.0),
+    fTracks (0x0),
+    fNoPID(0x0),
+    fPerfectPID (0x0),
+    fRealisticPID (0x0)
 {
-//=========================================================
-// Default constructor 
+//
+// Default constructor
 // (implemented but not recommended for direct use)
-//=========================================================
-
-    Int_t i;
-    for (i = 0; i <= AliRsnPID::kSpecies; i++) {
-        fPosID[i] = 0x0;
-        fNegID[i] = 0x0;
-    }
+//
 }
 
 //_____________________________________________________________________________
-AliRsnEvent::AliRsnEvent(const AliRsnEvent &event) :
-  TObject((TObject)event),
-  fSource(event.fSource),
-  fPVx(event.fPVx),
-  fPVy(event.fPVy),
-  fPVz(event.fPVz),
-  fTracks(0x0),
-  fPos(0x0),
-  fNeg(0x0)
+AliRsnEvent::AliRsnEvent (const AliRsnEvent &event) :
+    TNamed (event),
+    fPVx (event.fPVx),
+    fPVy (event.fPVy),
+    fPVz (event.fPVz),
+    fTracks (0x0),
+    fNoPID(0x0),
+    fPerfectPID (0x0),
+    fRealisticPID (0x0)
 {
-//=========================================================
+//
 // Copy constructor.
-// Creates new instances of all collections 
-// to store a copy of all objects.
-//=========================================================
-    
-    // initialize arrays
-    Init();
-    
-    // duplcate entries
-    AliRsnDaughter *track = 0;
-    TObjArrayIter iter(event.fTracks);
-    while ( (track = (AliRsnDaughter*)iter.Next()) ) {
-        AliRsnDaughter *ref = AddTrack(*track);
-        if (!ref) AliWarning(Form("Problem occurred when copying track #%d", fTracks->IndexOf(ref)));
-    }
-    
-    // fill PID arrays
-    FillPIDArrays();
+// Copies all the tracks from the argument's collection
+// to this' one, and then recreates the PID index arrays,
+// trusting on the PID informations in the copied tracks.
+//
+
+    // during track copy, counts how many faults happen
+    Int_t errors = Fill (event.fTracks);
+    if (errors) AliWarning (Form ("%d errors occurred in copy", errors));
+
+    // fill PID index arrays
+    // FillPIDArrays();
+
+    if (event.fNoPID) fNoPID = new AliRsnPIDIndex(*(event.fNoPID));
+    if (event.fPerfectPID) fPerfectPID = new AliRsnPIDIndex(*(event.fPerfectPID));
+    if (event.fRealisticPID) fRealisticPID = new AliRsnPIDIndex(*(event.fRealisticPID));
 }
 
 //_____________________________________________________________________________
-AliRsnEvent& AliRsnEvent::operator=(const AliRsnEvent &event)
+AliRsnEvent& AliRsnEvent::operator= (const AliRsnEvent &event)
 {
-//=========================================================
-// Assignment operator.
-// Creates new instances of all collections 
-// to store a copy of all objects.
-//=========================================================
-    
-    // copy source info
-    fSource = event.fSource;
-    
+//
+// Works in the same way as the copy constructor.
+//
+    // copy name and title
+    SetName (event.GetName());
+    SetTitle (event.GetTitle());
+
     // copy primary vertex and initialize track counter to 0
     fPVx = event.fPVx;
     fPVy = event.fPVy;
     fPVz = event.fPVz;
-        
-    // initialize with size of argument
-    Init();
 
-    // loop on collection of argument's tracks and store a copy here
-    AliRsnDaughter *track = 0;
-    TObjArrayIter iter(event.fTracks);
-    while ( (track = (AliRsnDaughter*)iter.Next()) ) {
-        AliRsnDaughter *ref = AddTrack(*track);
-        if (!ref) AliWarning(Form("Problem occurred when copying track #%d", fTracks->IndexOf(ref)));
-    }
-    
+    // add tracks from array of argument
+    Int_t errors = Fill (event.fTracks);
+    if (errors) AliWarning (Form ("%d errors occurred in copy", errors));
+
     // fill PID arrays
-    FillPIDArrays();
-    
-    // return the newly created object
+    // FillPIDArrays();
+    if (event.fNoPID) {
+        if (!fNoPID) fNoPID = new AliRsnPIDIndex(*(event.fNoPID));
+        else (*fNoPID) = *(event.fNoPID);
+    }
+    if (event.fPerfectPID) {
+        if (!fPerfectPID) fPerfectPID = new AliRsnPIDIndex(*(event.fPerfectPID));
+        else (*fPerfectPID) = *(event.fPerfectPID);
+    }
+    if (event.fRealisticPID) {
+        if (!fRealisticPID) fRealisticPID = new AliRsnPIDIndex(*(event.fRealisticPID));
+        else (*fRealisticPID) = *(event.fRealisticPID);
+    }
+
+    // return this object
     return (*this);
 }
 
 //_____________________________________________________________________________
 AliRsnEvent::~AliRsnEvent()
 {
-//=========================================================
+//
 // Destructor.
-// Deletes the collection objects.
-// If statements are present because if the event is 
-// destroyed before that any track is added to it, then
-// its collection classes will not be initialized.
-//=========================================================
-    
+// Deletes the TClonesArray, after clearing its content.
+// Other memory-allocating arrays are cleared by their
+// destructor, which is automatically called from here.
+//
+
     Clear();
-    
     if (fTracks) delete fTracks;
-    if (fPos) delete fPos;
-    if (fNeg) delete fNeg;
-    
-    Int_t i;
-    for (i = 0; i <= AliRsnPID::kSpecies; i++) {
-        if (fPosID[i]) delete fPosID[i];
-        if (fNegID[i]) delete fNegID[i];
-    }
 }
 
 //_____________________________________________________________________________
 void AliRsnEvent::Init()
 {
-//=========================================================
-// Initialize arrays
-//=========================================================
-    
-    fTracks = new TClonesArray("AliRsnDaughter", 0);
-    fTracks->BypassStreamer(kFALSE);
-    fPos = new TRefArray;
-    fNeg = new TRefArray;
-    
-    Int_t i;
-    for (i = 0; i <= AliRsnPID::kSpecies; i++) {
-        fPosID[i] = new TRefArray;
-        fNegID[i] = new TRefArray;
-    }
+//
+// Initialize TClonesArray data-member.
+//
+
+    fTracks = new TClonesArray ("AliRsnDaughter", 1);
+    //fTracks->BypassStreamer (kFALSE);
 }
 
 //_____________________________________________________________________________
-AliRsnDaughter* AliRsnEvent::AddTrack(AliRsnDaughter track)
+void AliRsnEvent::Clear (Option_t* /*option*/)
 {
-//=========================================================
-// Stores a track into the array and proper references.
-//=========================================================
-    
+//
+// Empties the collections (does not delete the objects).
+// The track collection is emptied only at the end.
+// Since some objects could be uninitialized, some
+// "if" statement are used.
+//
+
+    if (fTracks) fTracks->Delete();
+    delete fNoPID;
+    fNoPID = 0x0;
+    delete fPerfectPID;
+    fPerfectPID = 0x0;
+    delete fRealisticPID;
+    fRealisticPID = 0x0;
+}
+
+//_____________________________________________________________________________
+AliRsnDaughter* AliRsnEvent::AddTrack (AliRsnDaughter track)
+{
+//
+// Stores a new track into the array and returns
+// a reference pointer to it (which is NULL in case of errors).
+//
+
     Int_t nextIndex = fTracks->GetEntriesFast();
     TClonesArray &tracks = (*fTracks);
-    AliRsnDaughter *copy = new (tracks[nextIndex]) AliRsnDaughter(track);
-    if (!copy) return 0x0;
-    if (copy->Charge() > 0) {
-        fPos->Add(copy);
-        return copy;
-    }
-    else if (copy->Charge() < 0) {
-        fNeg->Add(copy);
-        return copy;
-    }
-    else {
-        return 0x0;
+    AliRsnDaughter *copy = new (tracks[nextIndex]) AliRsnDaughter (track);
+    return copy;
+}
+
+//_____________________________________________________________________________
+AliRsnDaughter* AliRsnEvent::GetTrack(Int_t index)
+{
+//
+// Returns one track in the collection
+// given the absolute index in the global TClonesArray
+//
+    return (AliRsnDaughter*) fTracks->UncheckedAt (index);
+}
+
+//_____________________________________________________________________________
+TArrayI* AliRsnEvent::GetCharged (Char_t sign)
+{
+//
+// Returns an array with the indexes of all tracks with a given charge
+// (arg can be '+' or '-'), irrespective of its PID.
+// When the argument is wrong, a NULL pointer is returned.
+//
+    if (fNoPID) return fNoPID->GetTracksArray(sign, AliRsnPID::kUnknown);
+    return 0x0;
+}
+
+//_____________________________________________________________________________
+TArrayI * AliRsnEvent::GetTracksArray
+(AliRsnPID::EMethod pidtype, Char_t sign, AliRsnPID::EType type)
+{
+//
+// Returns an array of indexes of all tracks in this event
+// which match the charge sign and PID type in the arguments,
+// according to one of the allowed PID methods (perfect or realistic).
+// It retrieves this array from the AliRsnPIDIndex data members.
+// If the arguments are wrong a NULL pointer is returned.
+//
+
+    switch (pidtype) {
+        case AliRsnPID::kRealistic:
+            if (fRealisticPID) {
+                return fRealisticPID->GetTracksArray (sign, type);
+            }
+            break;
+        case AliRsnPID::kPerfect:
+            if (fPerfectPID) {
+                return fPerfectPID->GetTracksArray (sign, type);
+            }
+            break;
+        default:
+            AliError ("Handled PID methods here are only kPerfect and kRealistic. Nothing done.");
+            return 0x0;
     }
+
+    return 0x0;
 }
 
 //_____________________________________________________________________________
-void AliRsnEvent::Clear(Option_t* /*option*/)
+void AliRsnEvent::FillPIDArrays()
 {
-//=========================================================
-// Empties the collections (does not delete the objects).
-// The track collection is emptied only at the end.
-// Again, since the objects could be uninitialized, some
-// if statement are used.
-//=========================================================
-    
-    if (fPos) fPos->Delete();
-    if (fNeg) fNeg->Delete();
-    
-    Int_t i;
-    for (i = 0; i <= AliRsnPID::kSpecies; i++) {
-        if (fPosID[i]) fPosID[i]->Delete();
-        if (fNegID[i]) fNegID[i]->Delete();
+//
+// Initializes and fills the AliRsnPIDIndex objects containing
+// arrays of indexes for each possible charge and PID type.
+// This method is the unique way to do this, for safety reasons.
+//
+
+    if (fNoPID) delete fNoPID;
+    if (fPerfectPID) delete fPerfectPID;
+    if (fRealisticPID) delete fRealisticPID;
+    fNoPID = new AliRsnPIDIndex;
+    fPerfectPID = new AliRsnPIDIndex;
+    fRealisticPID = new AliRsnPIDIndex;
+
+    // loop on tracks and create references
+    Int_t i, icharge, type;
+    Short_t charge;
+    AliRsnMCInfo *mcinfo = 0;
+    AliRsnDaughter *track = 0;
+    TObjArrayIter iter(fTracks);
+    while ( (track = (AliRsnDaughter*) iter.Next()) ) {
+        charge = track->Charge();
+        type = (Int_t)track->PIDType();
+        i = fTracks->IndexOf(track);
+        mcinfo = track->GetMCInfo();
+        if (charge > 0) icharge = 0;
+        else if (charge < 0) icharge = 1;
+        else {
+            AliError("Found particle with ZERO charge!!!");
+            continue;
+        }
+        // add to charged array
+        fNoPID->AddIndex(i, icharge, (Int_t)AliRsnPID::kUnknown);
+        // add to realistic PID array
+        fRealisticPID->AddIndex (i, icharge, (Int_t)type);
+        // add to perfect PID array (needs MCInfo present)
+        if (mcinfo) {
+            fPerfectPID->AddIndex (i, icharge, (Int_t)AliRsnPID::InternalType(mcinfo->PDG()));
+        }
     }
-    
-    if (fTracks) fTracks->Delete();
+
+    // adjusts the size of arrays
+    if (fNoPID) fNoPID->SetCorrectIndexSize();
+    if (fPerfectPID) fPerfectPID->SetCorrectIndexSize();
+    if (fRealisticPID) fRealisticPID->SetCorrectIndexSize();
 }
 
 //_____________________________________________________________________________
-void AliRsnEvent::Print(Option_t *option) const
+void AliRsnEvent::Print (Option_t *option) const
 {
-//=========================================================
+//
 // Lists the details of the event, and the ones of each
-// contained track, usind the Dump method of the track.
+// contained track.
 // The options are passed to AliRsnDaughter::Print().
 // Look at that method to understand option values.
-//=========================================================
+//
 
     cout << "...Multiplicity     : " << fTracks->GetEntries() << endl;
     cout << "...Primary vertex   : " << fPVx << ' ' << fPVy << ' ' << fPVz << endl;
-    
-    TObjArrayIter iter(fTracks);
+
+    TObjArrayIter iter (fTracks);
     AliRsnDaughter *d = 0;
-    while ( (d = (AliRsnDaughter*)iter.Next()) ) {
-        cout << "....Track #" << fTracks->IndexOf(d) << endl;
-        d->Print(option);
+    while ((d = (AliRsnDaughter*) iter.Next())) {
+        cout << "....Track #" << fTracks->IndexOf (d) << endl;
+        d->Print (option);
     }
 }
 
 //_____________________________________________________________________________
-Int_t AliRsnEvent::GetMultiplicity() const 
+Int_t AliRsnEvent::GetMultiplicity() const
 {
-//=========================================================
+//
 // Get number of all tracks
-//=========================================================
-    
+//
+
     if (!fTracks) return 0;
     return fTracks->GetEntries();
 }
 
 //_____________________________________________________________________________
-Int_t AliRsnEvent::GetNPos() const 
+Int_t AliRsnEvent::GetNCharged (Char_t sign)
 {
-//=========================================================
-// Get number of positive tracks
-//=========================================================
-    
-    if (!fPos) return 0;
-    return fPos->GetEntries();
-}
+//
+// Get number of charged tracks
+//
 
-//_____________________________________________________________________________
-Int_t AliRsnEvent::GetNNeg() const 
-{
-//=========================================================
-// Get number of negative tracks
-//=========================================================
-    
-    if (!fNeg) return 0;
-    return fNeg->GetEntries();
+    Int_t icharge;
+    icharge = ChargeIndex (sign);
+    if (icharge < 0) return 0;
+    TArrayI *charged = GetCharged(sign);
+    if (!charged) return 0;
+    return charged->GetSize();
 }
 
 //_____________________________________________________________________________
-TRefArray* AliRsnEvent::GetTracks(Char_t sign, AliRsnPID::EType refType)
+Int_t AliRsnEvent::Fill (TObjArray *array)
 {
-//=========================================================
-// Returns the particle collection specified in argument.
-// Arguments :
-//   1) sign of particle ('+' or '-')
-//   2) PID of particle (from AliRsnPID::EType)
-//=========================================================
-    
-    if (sign == '+') {
-        if (refType >= AliRsnPID::kElectron && refType <= AliRsnPID::kSpecies) {
-            return fPosID[refType];
-        }
-        else {
-            AliError(Form("Index %d out of range", refType));
-            return 0x0;
-        }
-    }
-    else if (sign == '-') {
-        if (refType >= AliRsnPID::kElectron && refType <= AliRsnPID::kSpecies) {
-            return fNegID[refType];
-        }
-        else {
-            AliError(Form("Index %d out of range", refType));
-            return 0x0;
+//
+// Fills the data-member TClonesArray of tracks with
+// the ones stored in the array passed as argument.
+// If this data-member is already present, it is cleared.
+// Returns the number of tracks which raised problems
+// while attempting to add them. Zero is the best.
+//
+
+    // clear the array if it is already instantiated,
+    // create if otherwise
+    if (fTracks) fTracks->Delete();
+    else Init();
+
+    // copy argument entries into data-member
+    Int_t errors = 0;
+    AliRsnDaughter *track = 0;
+    TObjArrayIter iter (array);
+    while ((track = (AliRsnDaughter*) iter.Next())) {
+        AliRsnDaughter *ref = AddTrack (*track);
+        if (!ref) {
+            AliWarning (Form ("Problem occurred when copying track #%d from passed array", array->IndexOf (track)));
+            errors++;
         }
     }
-    else {
-        AliError(Form("Character '%c' not recognized as charge sign", sign));
-        return 0x0;
-    }
+
+    return errors;
 }
 
 //_____________________________________________________________________________
-void AliRsnEvent::FillPIDArrays()
+Int_t AliRsnEvent::ChargeIndex (Char_t sign) const
+//
+// Returns the array index corresponding to charge
+// 0 for positive, 1 for negative
+//
 {
-//=========================================================
-// Initializes and fills all the TRefArrays containing 
-// references to particles identified as each available
-// PID type (from AliRsnPID).
-// This method is the unique way to do this, because it 
-// cannot be assumed that the track PID is known when
-// it is added to this event by AddTrack.
-// Of course, if tracks have not been identified, this 
-// method will do nothing and all tracks will be placed
-// in the TRefArray of 'Unknown' particles and the 
-// GetTracks() method will not work properly.
-//=========================================================
-
-    // clear arrays if they are present
-    // initialize them if they are still 0x0
-    Int_t i;
-    for (i = 0; i <= AliRsnPID::kSpecies; i++) {
-        if (fPosID[i]) fPosID[i]->Delete(); else fPosID[i] = new TRefArray;
-        if (fNegID[i]) fNegID[i]->Delete(); else fNegID[i] = new TRefArray;
-    }
-    
-    // loop on tracks and create references
-    Short_t           charge;
-    AliRsnPID::EType  type;
-    AliRsnDaughter   *track = 0;
-    TObjArrayIter     iter(fTracks);
-    while ( (track = (AliRsnDaughter*)iter.Next()) ) {
-        charge = track->Charge();
-        type = track->PIDType();
-        i = (Int_t)type;
-        if (charge > 0) {
-            fPosID[i]->Add(track);
-        }
-        else if (charge < 0) {
-            fNegID[i]->Add(track);
-        }
-        else {
-            AliError("Found particle with ZERO charge!!!");
-        }
+    if (sign == '+') return 0;
+    else if (sign == '-') return 1;
+    else {
+        AliError (Form ("Character '%c' not recognized as charge sign", sign));
+        return -1;
     }
 }
-
index 223ecf2b70a6b589b2ad80bdef7c235e3c083f33..ec82f4094f3a4436fd0f8bc4875c3e5bebb36932 100644 (file)
@@ -5,89 +5,80 @@
 
 /* $Id$ */
 
-//-------------------------------------------------------------------------
-//                      Class AliRsnEvent
-//  Simple collection of reconstructed tracks, selected from an ESD event
-// 
-// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
-//-------------------------------------------------------------------------
+//
+// *** Class AliRsnEvent ***
+//
+// A container for a collection of AliRsnDaughter objects from an event.
+// Contains also the primary vertex, useful for some cuts.
+// In order to retrieve easily the tracks which have been identified
+// as a specific type and charge, there is an array of indexes which
+// allows to avoid to loop on all tracks and have only the neede ones.
+//
+// authors: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it)
+//          M. Vala (email: martin.vala@cern.ch)
+//
 
 #ifndef ALIRSNEVENT_H
 #define ALIRSNEVENT_H
 
-class TTree;
-class TParticle;
-class TRefArray;
-class TClonesArray;
-
-class AliESDtrack;
-class AliAODTrack;
 class AliRsnDaughter;
 
+#include <TNamed.h>
+#include <TArrayI.h>
+#include <TClonesArray.h>
 #include "AliRsnPID.h"
+#include "AliRsnPIDIndex.h"
 
-class AliRsnEvent : public TObject
+class AliRsnEvent : public TNamed
 {
-public:
-
-    enum ESource {
-        kUnknown = 0,
-        kESD,
-        kAOD,
-        kMC
-    };
-       
+  public:
+
     AliRsnEvent();
-    AliRsnEvent(const AliRsnEvent& copy);
-    AliRsnEvent& operator=(const AliRsnEvent& copy);
+    AliRsnEvent (const AliRsnEvent& copy);
+    AliRsnEvent& operator= (const AliRsnEvent& copy);
     virtual ~AliRsnEvent();
 
     // Array management
     void            Init();
-    AliRsnDaughter* AddTrack(AliRsnDaughter track);
-    void            Clear(Option_t *option = "");
-    void            Print(Option_t *option = "") const;
-    TClonesArray*   GetAllTracks() {return fTracks;}
-    TRefArray*      GetTracks(Char_t sign, AliRsnPID::EType type);
-    TRefArray*      GetCharged(Char_t sign) {if (sign=='+') return fPos; else if (sign=='-') return fNeg; else return 0x0;}
+    void            Clear (Option_t *option = "");
+    AliRsnDaughter* AddTrack (AliRsnDaughter track);
+    AliRsnDaughter* GetTrack (Int_t index);
+    TClonesArray*   GetTracks() {return fTracks;}
+    TArrayI*        GetCharged (Char_t sign);
+    TArrayI*        GetTracksArray (AliRsnPID::EMethod pidtype, Char_t sign, AliRsnPID::EType type);
     void            FillPIDArrays();
+    void            Print (Option_t *option = "") const;
 
     // Primary vertex
     Double_t GetPrimaryVertexX() const {return fPVx;}
-       Double_t GetPrimaryVertexY() const {return fPVy;}
-       Double_t GetPrimaryVertexZ() const {return fPVz;}
-    void     GetPrimaryVertex(Double_t &x, Double_t &y, Double_t &z) const {x=fPVx;y=fPVy;z=fPVz;}
-    void     GetPrimaryVertex(Double_t* &v) {GetPrimaryVertex(v[0], v[1], v[2]);}
-    void     SetPrimaryVertexX(Double_t value) {fPVx = value;}
-       void     SetPrimaryVertexY(Double_t value) {fPVy = value;}
-       void     SetPrimaryVertexZ(Double_t value) {fPVz = value;}
-    void     SetPrimaryVertex(Double_t x, Double_t y, Double_t z) {fPVx=x;fPVy=y;fPVz=z;}
-    void     SetPrimaryVertex(Double_t* &v) {SetPrimaryVertex(v[0], v[1], v[2]);}
+    Double_t GetPrimaryVertexY() const {return fPVy;}
+    Double_t GetPrimaryVertexZ() const {return fPVz;}
+    void     GetPrimaryVertex (Double_t &x, Double_t &y, Double_t &z) const {x=fPVx;y=fPVy;z=fPVz;}
+    void     SetPrimaryVertexX (Double_t value) {fPVx = value;}
+    void     SetPrimaryVertexY (Double_t value) {fPVy = value;}
+    void     SetPrimaryVertexZ (Double_t value) {fPVz = value;}
+    void     SetPrimaryVertex (Double_t x, Double_t y, Double_t z) {fPVx=x;fPVy=y;fPVz=z;}
 
     // Multiplicity
     Int_t GetMultiplicity() const;
-    Int_t GetNPos() const;
-    Int_t GetNNeg() const;
-    
-    // Source type
-    void    SetSource(ESource source) {fSource = source;}
-    ESource GetSource() {return fSource;}
-    
-private:
-
-    ESource        fSource;                          // type of source event
-
-    Double_t       fPVx;                             // position of
-    Double_t       fPVy;                             // primary
-    Double_t       fPVz;                             // vertex
-
-    TClonesArray  *fTracks;                          // collection of particles
-    TRefArray     *fPos;                             // ref array to all positive particles
-    TRefArray     *fNeg;                             // ref array to all negative particles
-    TRefArray     *fPosID[AliRsnPID::kSpecies + 1];  // ref array to pos particles of each PID
-    TRefArray     *fNegID[AliRsnPID::kSpecies + 1];  // ref array to pos particles of each PID
-
-    ClassDef(AliRsnEvent,1);
+    Int_t GetNCharged (Char_t sign);
+
+  private:
+
+    Int_t ChargeIndex (Char_t sign) const;
+    Int_t Fill (TObjArray *array);
+
+    Double_t        fPVx;                 // position of
+    Double_t        fPVy;                 // primary
+    Double_t        fPVz;                 // vertex
+
+    TClonesArray   *fTracks;              // collection of particles
+
+    AliRsnPIDIndex *fNoPID;               // array index only for charged tracks
+    AliRsnPIDIndex *fPerfectPID;          // array index for perfect PID
+    AliRsnPIDIndex *fRealisticPID;        // array index for realistic PID (largest prob)
+
+    ClassDef (AliRsnEvent, 2);
 };
 
 #endif
diff --git a/PWG2/RESONANCES/AliRsnEventBuffer.cxx b/PWG2/RESONANCES/AliRsnEventBuffer.cxx
new file mode 100644 (file)
index 0000000..1abdf07
--- /dev/null
@@ -0,0 +1,143 @@
+/**************************************************************************
+ * 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 AliRsnEventBuffer
+//
+// Implements a temporary buffer of many AliRsnEvent objects
+// which is useful for event mixing.
+//
+// author: Martin Vala (Martin.Vala@cern.ch)
+// revised by: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#include "AliLog.h"
+#include "AliRsnEventBuffer.h"
+
+ClassImp (AliRsnEventBuffer)
+
+//_____________________________________________________________________________
+AliRsnEventBuffer::AliRsnEventBuffer (Int_t buffSize, Bool_t deleteBufferWhenReset) :
+  fDeleteBufferWhenReset (deleteBufferWhenReset),
+  fEventsBufferSize (buffSize),
+  fEventsBufferIndex (-1)
+{
+//
+// Constructor.
+// Initializes to NULL all AliRsnEvent pointers.
+//
+
+    Int_t i;
+    for (i = 0; i < fEventsBufferSize; i++) fEventsBuffer[i] = 0;
+}
+
+//_____________________________________________________________________________
+AliRsnEventBuffer::~AliRsnEventBuffer()
+{
+//
+// Destructor.
+// Actually does nothing.
+//
+
+    //ClearBuffer();
+}
+
+//_____________________________________________________________________________
+void AliRsnEventBuffer::ClearBuffer()
+{
+//
+// Clears buffer, resetting all pointers.
+// If an event is on the HEAP, it is deleted.
+//
+    Int_t i;
+    for (i = 0; i < fEventsBufferSize; i++) {
+        AliDebug(1, Form ("Clearing slot #%p in buffer", fEventsBuffer[i]));
+        if (fEventsBuffer[i]->IsOnHeap()) delete fEventsBuffer[i];
+        fEventsBuffer[i] = 0;
+    }
+}
+
+//_____________________________________________________________________________
+void AliRsnEventBuffer::ResetIndex()
+{
+//
+// Resets the index for accessing events in buffer
+//
+    fEventsBufferIndex = -1;
+    if (fDeleteBufferWhenReset == kTRUE) ClearBuffer();
+}
+
+//_____________________________________________________________________________
+void AliRsnEventBuffer::AddEvent (AliRsnEvent * event)
+{
+//
+// Insert a new event in the buffer.
+// Since the buffer has a fixed size, when the last index is reached,
+// the new event replaces the oldest one in the buffer
+//
+
+    if (fEventsBufferIndex >= fEventsBufferSize - 1) ResetIndex();
+    fEventsBufferIndex++;
+    if (fEventsBuffer[fEventsBufferIndex])
+        *fEventsBuffer[fEventsBufferIndex] = *event;
+    else
+        fEventsBuffer[fEventsBufferIndex] = new AliRsnEvent(*event);
+}
+
+//_____________________________________________________________________________
+AliRsnEvent* AliRsnEventBuffer::GetCurrentEvent()
+{
+//
+// Returns the current event in the buffer
+//
+    return GetEvent(fEventsBufferIndex);
+}
+
+//_____________________________________________________________________________
+AliRsnEvent * AliRsnEventBuffer::GetNextEvent()
+{
+//
+// Returns next event in the buffer w.r. to current
+//
+    if (fEventsBufferIndex == fEventsBufferSize - 1) return GetEvent (0);
+    else return GetEvent (fEventsBufferIndex + 1);
+}
+
+//_____________________________________________________________________________
+AliRsnEvent * AliRsnEventBuffer::GetEvent (Int_t index)
+{
+//
+// Returns an event in the buffer, provided its index
+//
+    if (index < 0 || index >= fEventsBufferSize) {
+        AliError(Form("Index out of range (index = %d , size = %d)", index, fEventsBufferSize));
+        return 0x0;
+    }
+    return (AliRsnEvent*)fEventsBuffer[index];
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnEventBuffer::NEmptySlots()
+{
+//
+// Tells if the buffer is completely filled or has empty slots
+//
+    Int_t i, counter = 0;
+    for (i = 0; i < fEventsBufferSize; i++) {
+        if (!fEventsBuffer[i]) counter++;
+    }
+    
+    return counter;
+}
diff --git a/PWG2/RESONANCES/AliRsnEventBuffer.h b/PWG2/RESONANCES/AliRsnEventBuffer.h
new file mode 100644 (file)
index 0000000..7d54639
--- /dev/null
@@ -0,0 +1,59 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+//
+// Class AliRsnEventBuffer
+//
+// Implements a temporary buffer of many AliRsnEvent objects
+// which is useful for event mixing.
+//
+// author: Martin Vala (Martin.Vala@cern.ch)
+// revised by: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef AliRsnEventBuffer_h
+#define AliRsnEventBuffer_h
+
+#include "AliRsnEvent.h"
+
+class AliRsnEventBuffer : public TObject
+{
+public:
+
+    AliRsnEventBuffer (Int_t buffsize = 1000, Bool_t deleteBufferWhenReset=kTRUE);
+    ~AliRsnEventBuffer();
+
+    void ClearBuffer();
+    void ResetIndex();
+
+    void AddEvent (AliRsnEvent *event);
+    AliRsnEvent *GetEvent (Int_t index) ;
+    AliRsnEvent *GetCurrentEvent ();
+    AliRsnEvent *GetNextEvent ();
+
+    void SetEventsBufferSize (const Int_t& theValue) { fEventsBufferSize = theValue; }
+    Int_t GetEventsBufferSize() const { return fEventsBufferSize; }
+    Int_t GetEventsBufferIndex() const { return fEventsBufferIndex; }
+
+    void SetDeleteBufferWhenReset (const Bool_t& theValue = kTRUE) { fDeleteBufferWhenReset = theValue; }
+    Bool_t GetDeleteBufferWhenReset() const { return fDeleteBufferWhenReset; }
+    
+    Int_t NEmptySlots();
+
+  private:
+  
+    AliRsnEventBuffer (const AliRsnEventBuffer& /*buf*/) :
+      fDeleteBufferWhenReset(0),fEventsBufferSize(0),fEventsBufferIndex(0) {}
+    const AliRsnEventBuffer& operator=(const AliRsnEventBuffer& /*buf*/) {return (*this);}
+
+    Bool_t       fDeleteBufferWhenReset;  // flag if buffer should be deleted when reset is done
+    Int_t        fEventsBufferSize;       // buffer size
+    Int_t        fEventsBufferIndex;      // current buffer index
+    AliRsnEvent *fEventsBuffer[10000];    // array of events
+
+    ClassDef (AliRsnEventBuffer, 1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnMCInfo.cxx b/PWG2/RESONANCES/AliRsnMCInfo.cxx
new file mode 100644 (file)
index 0000000..5781539
--- /dev/null
@@ -0,0 +1,67 @@
+#include "AliLog.h"
+
+#include "AliRsnMCInfo.h"
+
+ClassImp ( AliRsnMCInfo )
+
+//_____________________________________________________________________________
+AliRsnMCInfo::AliRsnMCInfo() : TObject(),
+    fEnergy ( 0 ),
+    fPDG ( 0 ),
+    fMother ( -1 ),
+    fMotherPDG ( 0 )
+{
+//
+// Default constructor.
+// Initializes all data-members with meaningless values.
+//
+  for ( Int_t i = 0; i < 3; i++ ) fP[i] = 0.0;
+}
+
+//_____________________________________________________________________________
+AliRsnMCInfo::AliRsnMCInfo ( const AliRsnMCInfo & copy ) : TObject ( copy ),
+    fEnergy ( copy.fEnergy ),
+    fPDG ( copy.fPDG ),
+    fMother ( copy.fMother ),
+    fMotherPDG ( copy.fMotherPDG )
+{
+//
+// Copy constructor.
+// Initializes all data-members with meaningless values.
+//
+  
+  for ( Int_t i = 0; i < 3; i++ ) fP[i] = copy.fP[i];
+  
+}
+
+//_____________________________________________________________________________
+AliRsnMCInfo::~AliRsnMCInfo()
+{
+}
+
+//_____________________________________________________________________________
+void AliRsnMCInfo::Adopt ( TParticle * particle )
+{
+//
+// Copies data from a TParticle into "this":
+//  - PDG code
+//  - GEANT label of mother (if any, otherwise -1)
+// If the argument is NULL, nothing is done, and an alert
+// is given by the method.
+//
+
+    if (!particle) {
+        AliError ( "NULL argument passed. Nothing done." );
+        return;
+    }
+    
+    fP[0] = particle->Px();
+    fP[1] = particle->Py();
+    fP[2] = particle->Pz();
+    
+    fEnergy = particle->Energy();
+    
+    fPDG    = particle->GetPdgCode();
+    fMother = particle->GetFirstMother();
+    fMotherPDG = ( Short_t ) 0;
+}
diff --git a/PWG2/RESONANCES/AliRsnMCInfo.h b/PWG2/RESONANCES/AliRsnMCInfo.h
new file mode 100644 (file)
index 0000000..3783ef3
--- /dev/null
@@ -0,0 +1,51 @@
+#ifndef AliRsnMCInfo_h
+#define AliRsnMCInfo_h
+
+#include <AliVParticle.h>
+#include <TParticle.h>
+
+class AliRsnMCInfo : public TObject
+{
+public:
+    AliRsnMCInfo();
+    AliRsnMCInfo ( const AliRsnMCInfo &copy );
+
+    ~AliRsnMCInfo();
+    void Adopt ( TParticle *part );
+
+    // 4-momentum
+    virtual Double_t E()  const {return fEnergy;}
+    virtual Double_t M()  const {return TMath::Sqrt (fEnergy*fEnergy - P2());}
+    virtual Double_t P2() const {return Px()*Px() + Py()*Py() + Pz()*Pz();}
+    virtual Double_t P()  const {return TMath::Sqrt ( P2() );}
+    virtual Double_t Px() const {return fP[0];}
+    virtual Double_t Py() const {return fP[1];}
+    virtual Double_t Pz() const {return fP[2];}
+    virtual Double_t Pt() const {return TMath::Sqrt ( Px() *Px() + Py() *Py() );}
+    virtual Double_t OneOverPt() const {return 1.0 / Pt();}
+    virtual Bool_t   PxPyPz ( Double_t p[3] ) const {p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE;}
+    void             SetPx ( Double_t value ) {fP[0] = value;}
+    void             SetPy ( Double_t value ) {fP[1] = value;}
+    void             SetPz ( Double_t value ) {fP[2] = value;}
+    void             SetP ( Double_t px, Double_t py, Double_t pz ) {SetPx ( px ); SetPy ( py ); SetPz ( pz );}
+    void             SetE ( Double_t e ) {fEnergy = e;}
+
+    Int_t     PDG() const {return fPDG;}
+    Int_t     Mother() const {return fMother;}
+    Short_t   MotherPDG() const {return fMotherPDG;}
+    void      SetPDG ( Int_t pdg ) {fPDG = pdg;}
+    void      SetMother ( Int_t mlabel ) {fMother = mlabel;}
+    void      SetMotherPDG ( Int_t pdg ) {fMotherPDG = ( Short_t ) pdg;}
+
+private:
+
+    Double_t  fP[3];          // MC momentum
+    Double_t  fEnergy;        // MC energy
+    Int_t     fPDG;           // PDG code
+    Int_t     fMother;        // GEANT label of mother particle
+    Short_t   fMotherPDG;     // PDG code of mother particle
+
+    ClassDef ( AliRsnMCInfo,1 );
+};
+
+#endif
index 783d8f5a26a64e95470b94177350c3a01397893b..079550f42bf0dfb489f092ec2f511530881a859f 100644 (file)
@@ -12,7 +12,7 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+
 //-------------------------------------------------------------------------
 //                      Class AliRsnPID
 //                     -------------------
@@ -20,7 +20,7 @@
 //           selected from an ESD event
 //           to be used for analysis.
 //           .........................................
-// 
+//
 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
 //-------------------------------------------------------------------------
 
@@ -30,7 +30,7 @@
 #include <TDatabasePDG.h>
 
 #include "AliLog.h"
-#include "AliRsnParticle.h"
+#include "AliRsnMCInfo.h"
 #include "AliRsnDaughter.h"
 #include "AliRsnEvent.h"
 
@@ -38,7 +38,7 @@
 
 ClassImp(AliRsnPID)
 
-const char* AliRsnPID::fgkParticleName[AliRsnPID::kSpecies + 1] = 
+const char* AliRsnPID::fgkParticleNameLong[AliRsnPID::kSpecies + 1] =
 {
   "electron",
   "muon",
@@ -48,7 +48,27 @@ const char* AliRsnPID::fgkParticleName[AliRsnPID::kSpecies + 1] =
   "unknown"
 };
 
-const Int_t AliRsnPID::fgkParticlePDG[AliRsnPID::kSpecies + 1] = 
+const char* AliRsnPID::fgkParticleNameShort[AliRsnPID::kSpecies + 1] =
+{
+  "e",
+  "mu",
+  "pi",
+  "K",
+  "p",
+  "unk"
+};
+
+const char* AliRsnPID::fgkParticleNameLatex[AliRsnPID::kSpecies + 1] =
+{
+  "e",
+  "#mu",
+  "#pi",
+  "K",
+  "p",
+  "?"
+};
+
+const Int_t AliRsnPID::fgkParticlePDG[AliRsnPID::kSpecies + 1] =
 {
     11,
     13,
@@ -64,15 +84,15 @@ AliRsnPID::AliRsnPID() :
   fMaxPt(10.0),
   fMinProb(0.0)
 {
-//=========================================================
-// Default constructor 
+//
+// Default constructor
 // Sets a default setup:
 //  - realistic PID
 //  - no lower limit for probability
 //  - upper limit of 10 GeV for Pt
 //  - suitable values for prior probabilities
-//=========================================================
-    
+//
+
     fPrior[kElectron] = 0.20;
        fPrior[kMuon    ] = 0.20;
        fPrior[kPion    ] = 0.83;
@@ -87,11 +107,11 @@ AliRsnPID::AliRsnPID(const AliRsnPID &event) :
   fMaxPt(event.fMaxPt),
   fMinProb(event.fMinProb)
 {
-//=========================================================
+//
 // Copy constructor.
 // Implemented to manage the array safely.
-//=========================================================
-    
+//
+
     Int_t i;
     for (i = 0; i < kSpecies; i++) fPrior[i] = event.fPrior[i];
 }
@@ -99,33 +119,33 @@ AliRsnPID::AliRsnPID(const AliRsnPID &event) :
 //_____________________________________________________________________________
 AliRsnPID& AliRsnPID::operator=(const AliRsnPID &event)
 {
-//=========================================================
+//
 // Assignment operator.
 // Implemented to manage the array safely.
-//=========================================================
-    
+//
+
     fMethod = event.fMethod;
     fMaxPt = event.fMaxPt;
     fMinProb = event.fMinProb;
-    
+
     Int_t i;
     for (i = 0; i < kSpecies; i++) fPrior[i] = event.fPrior[i];
-    
+
     // return the newly created object
     return (*this);
 }
 
 //_____________________________________________________________________________
 AliRsnPID::EType AliRsnPID::InternalType(Int_t pdg)
-//=========================================================
+//
 // Return the internal enum value corresponding to the PDG
 // code passed as argument, if possible.
 // Otherwise, returns 'kUnknown' by default.
-//=========================================================
+//
 {
     EType value;
     Int_t absPDG = TMath::Abs(pdg);
-    
+
        switch (absPDG) {
         case 11:
             value = kElectron;
@@ -152,11 +172,11 @@ AliRsnPID::EType AliRsnPID::InternalType(Int_t pdg)
 //_____________________________________________________________________________
 Int_t AliRsnPID::PDGCode(EType type)
 {
-//=========================================================
+//
 // Returns the PDG code of the particle type
 // specified as argument (w.r. to the internal enum)
-//=========================================================
-    
+//
+
     if (type >= kElectron && type <= kUnknown) {
         return fgkParticlePDG[type];
     }
@@ -166,28 +186,44 @@ Int_t AliRsnPID::PDGCode(EType type)
 }
 
 //_____________________________________________________________________________
-const char* AliRsnPID::ParticleName(EType type)
+const char* AliRsnPID::ParticleName(EType type, Bool_t shortName)
 {
-//=========================================================
+//
 // Returns the name of the particle type
 // specified as argument (w.r. to the internal enum)
-//=========================================================
+//
 
     if (type >= kElectron && type <= kUnknown) {
-        return fgkParticleName[type];
+        return shortName ? fgkParticleNameShort[type] : fgkParticleNameLong[type];
     }
     else {
-        return "unknown";
+        return shortName ? "unk" : "unknown";
+    }
+}
+
+//_____________________________________________________________________________
+const char* AliRsnPID::ParticleNameLatex(EType type)
+{
+//
+// Returns the name of the particle type
+// specified as argument (w.r. to the internal enum)
+//
+
+    if (type >= kElectron && type <= kUnknown) {
+        return fgkParticleNameLatex[type];
+    }
+    else {
+        return "?";
     }
 }
 
 //_____________________________________________________________________________
 Double_t AliRsnPID::ParticleMass(EType type)
 {
-//=========================================================
+//
 // Returns the mass corresponding to the particle type
 // specified as argument (w.r. to the internal enum)
-//=========================================================
+//
     TDatabasePDG *db = TDatabasePDG::Instance();
     Int_t pdg = PDGCode(type);
     return db->GetParticle(pdg)->Mass();
@@ -196,7 +232,7 @@ Double_t AliRsnPID::ParticleMass(EType type)
 //_____________________________________________________________________________
 Bool_t AliRsnPID::IdentifyRealistic(AliRsnDaughter *daughter)
 {
-//=========================================================
+//
 // Uses the Bayesian combination of prior probabilities
 // with the PID weights of the passed object to compute
 // the overall PID probabilities for each particle type.
@@ -208,96 +244,113 @@ Bool_t AliRsnPID::IdentifyRealistic(AliRsnDaughter *daughter)
 // or the probability is smaller than the cut defined (fMinProb),
 // the track is considered unidentified.
 //
-// If the identification procedure encounters errors, 
+// If the identification procedure encounters errors,
 // the return value will be "FALSE", otherwise it is "TRUE".
-//=========================================================
+//
 
-    // retrieve PID weights from argument
-    Int_t i;
+    // reset all PID probabilities to 0.0
+    Unidentify(daughter, 0.0);
+
+    // check the transverse momentum:
+    // if it is larger than the cut, the particle is unidentified
+    // setting all its probabilities to 1.0
+    if (daughter->Pt() > fMaxPt) {
+        Unidentify(daughter, 1.0);
+        return kTRUE;
+    }
+
+    // 0 - retrieve PID weights from argument
+    Int_t     i;
+    Double_t  sum    = 0.0;
     Double_t *prob   = new Double_t[kSpecies];
     Double_t *weight = new Double_t[kSpecies];
     for (i = 0; i < kSpecies; i++) weight[i] = (daughter->PID())[i];
-       
+
     // step 1 - compute the normalization factor
-    Double_t sum = 0.0;
     for (i = 0; i < kSpecies; i++) {
         prob[i] = fPrior[i] * weight[i];
         sum += prob[i];
     }
-    if (sum <= 0.0) {
-        AliError(Form("Sum of weights = %f < 0.0", sum));
-        Unidentify(daughter);
+    if (sum <= (Double_t)0.) {
+        AliError(Form("Sum of weights = %f < 0", sum));
         return kFALSE;
     }
-       
-       // step 2 - normalize PID weights
+
+       // step 2 - normalize PID weights and update daughter data-member
     for (i = 0; i < kSpecies; i++) {
         prob[i] /= sum;
+        daughter->SetPIDProb(i, prob[i]);
     }
-       
-       // step 3 - finds the maximum probability
-    Int_t imax = 0;
+
+       // step 3 - find the maximum probability and update daughter data members
+    Int_t    imax = 0;
+    Double_t pmax = prob[0];
     for (i = 1; i < kSpecies; i++) {
-        if (prob[i] > prob[imax]) imax = i;
+        if (prob[i] > pmax) {
+            imax = i;
+            pmax = prob[i];
+        }
     }
-    
-    // step 4 - update daughter data members
-    //          and check pt & prob
-    Double_t pt      = daughter->Pt();
-    EType    type    = (EType)imax;
-    Double_t maxProb = prob[imax];
-    if (pt <= fMaxPt && maxProb >= fMinProb) {
+    EType type = (EType)imax;
+    if (pmax >= fMinProb) {
         daughter->SetPIDType(type);
-        daughter->SetPIDProb(maxProb);
         daughter->SetM(ParticleMass(type));
     }
     else {
-        Unidentify(daughter);
+        daughter->SetPIDType(kUnknown);
     }
-    
+
     return kTRUE;
 }
 
 //_____________________________________________________________________________
 Bool_t AliRsnPID::IdentifyPerfect(AliRsnDaughter *daughter)
 {
-//=========================================================
+//
 // Uses the true PDG code to make a perfect identification.
-// If the true PDG code does not correspond to any 
-// of the expected PID types, gives a warning, sets the 
+// If the true PDG code does not correspond to any
+// of the expected PID types, gives a warning, sets the
 // PID to 'unknown' and returns kFALSE.
 // Otherwise, returns kTRUE.
-//=========================================================
+//
+
+    // reset all PID probabilities to 0.0
+    Unidentify(daughter, 0.0);
 
-    // retrieve true PDG code from argument
-    AliRsnParticle *particle = daughter->GetParticle();
+    // if the MCInfo is not present, the particle cannot be identified perfectly
+    // in this case, to notice the error, the probs are maintained all to 0.0
+    AliRsnMCInfo *particle = daughter->GetMCInfo();
     if (!particle) {
         AliWarning("Particle object not initialized: impossible to do perfect PID");
-        Unidentify(daughter);
         return kFALSE;
     }
+
+    // convert the PDG into the internal enum
     Int_t pdgCode = particle->PDG();
     EType type = InternalType(pdgCode);
-    if (type == kUnknown) {
-        //AliWarning(Form("Unrecognized PDG code = %d -- set PID to Unknown", pdgCode));
-        Unidentify(daughter);
-        return kFALSE;
-    }
-    else {
+
+    // if the type is one of the available ones in the PID enum
+    // (e, mu, pi, K, p)
+    // the corresponding probability is set to 1, and the other remain 0
+    if (type >= 0 && type < kSpecies) {
         daughter->SetPIDType(type);
-        daughter->SetPIDProb(1.0);
+        daughter->SetPIDProb(type, 1.0);
         daughter->SetM(ParticleMass(type));
         return kTRUE;
     }
+
+    return kFALSE;
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnPID::Unidentify(AliRsnDaughter *daughter)
+Bool_t AliRsnPID::Unidentify(AliRsnDaughter *daughter, Double_t value)
 {
-//=========================================================
+//
 // Sets the PID to 'unknown' to every track.
-//=========================================================
+//
 
+    Int_t i;
+    for (i = 0; i < kSpecies; i++) daughter->SetPIDProb(i, value);
     daughter->SetPIDType(kUnknown);
     return kTRUE;
 }
@@ -305,12 +358,12 @@ Bool_t AliRsnPID::Unidentify(AliRsnDaughter *daughter)
 //_____________________________________________________________________________
 Bool_t AliRsnPID::Identify(AliRsnDaughter *daughter)
 {
-//=========================================================
+//
 // Recalls one of the above methods, according to the one
 // defined in the related data member.
-// If the method is not recognized, returns kFALSE and 
+// If the method is not recognized, returns kFALSE and
 // gives an alert. Otherwise, returns kTRUE.
-//=========================================================
+//
 
     switch (fMethod) {
         case kNone:
@@ -328,17 +381,40 @@ Bool_t AliRsnPID::Identify(AliRsnDaughter *daughter)
     }
 }
 
+//_____________________________________________________________________________
+Bool_t AliRsnPID::IdentifiedAs(AliRsnDaughter *d, EType type, Short_t charge)
+{
+//
+// Tells if a particle has been identified to be of a given tipe and charge.
+// If the charge is zero, the check is done only on the PID type, otherwise
+// both charge and PID type are required to match
+//
+    if (charge == 0) {
+        return (d->PIDType() == type);
+    }
+    else if (charge > 0) {
+        return (d->PIDType() == type && d->Charge() > 0);
+    }
+    else {
+        return (d->PIDType() == type && d->Charge() < 0);
+    }
+}
+
 //_____________________________________________________________________________
 Bool_t AliRsnPID::Identify(AliRsnEvent *event)
 {
-//=========================================================
+//
 // Performs identification for all tracks in a given event.
 // Returns the logical AND of all PID operations.
-//=========================================================
+//
 
     Bool_t check = kTRUE;
+    if (!event) return check;
+    if (!event->GetTracks()) return check;
+    if (event->GetTracks()->IsEmpty()) return check;
+
     AliRsnDaughter *daughter = 0;
-    TObjArrayIter iter(event->GetAllTracks());
+    TObjArrayIter iter(event->GetTracks());
     while ( (daughter = (AliRsnDaughter*)iter.Next()) ) {
         check = check && Identify(daughter);
     }
@@ -351,11 +427,11 @@ Bool_t AliRsnPID::Identify(AliRsnEvent *event)
 //_____________________________________________________________________________
 void AliRsnPID::SetPriorProbability(EType type, Double_t p)
 {
-//=========================================================
+//
 // Sets the prior probability for Realistic PID, for a
 // given particle species.
-//=========================================================
-    
+//
+
     if (type >= kElectron && type < kSpecies) {
         fPrior[type] = p;
     }
index b0cddca71032d9d06a068f5456bb5930b2a37904..8d24d51a02bdfb5c93d244242a664d0274f76f37 100644 (file)
@@ -8,78 +8,84 @@
 //-------------------------------------------------------------------------
 //                      Class AliRsnPID
 //  Simple collection of reconstructed tracks, selected from an ESD event
-// 
+//
 // author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
 //-------------------------------------------------------------------------
 
 #ifndef ALIRSNPID_H
 #define ALIRSNPID_H
 
+class AliRsnPIDProb;
 class AliRsnDaughter;
 class AliRsnEvent;
 
 class AliRsnPID : public TObject
 {
 public:
-       
+
     AliRsnPID();
     AliRsnPID(const AliRsnPID& copy);
     AliRsnPID& operator=(const AliRsnPID& copy);
     virtual ~AliRsnPID() {}
-    
+
     // types enum
-    enum EType { 
-        kElectron = 0, 
-        kMuon, 
-        kPion, 
-        kKaon, 
-        kProton, 
-        kUnknown, 
-        kSpecies = 5 
+    enum EType {
+        kElectron = 0,
+        kMuon,
+        kPion,
+        kKaon,
+        kProton,
+        kUnknown,
+        kSpecies = 5
     };
-    
+
     // identification method enum
     enum EMethod {
         kNone = 0,
         kRealistic,
-        kPerfect
+        kPerfect,
+        kMethods
     };
-    
-    // conversions from PDG code to local type 
+
+    // conversions from PDG code to local type
     static EType         InternalType(Int_t pdgCode);
-    
+
     // retrieve particle informations from internal type
     static Int_t         PDGCode(EType pid);
-    static const char *  ParticleName(EType pid);
+    static const char *  ParticleName(EType pid, Bool_t shortName = kTRUE);
+    static const char *  ParticleNameLatex(EType pid);
     static Double_t      ParticleMass(EType pid);
-    
+
     // identification routines
-    Bool_t  Identify(AliRsnDaughter *d);
-    Bool_t  Identify(AliRsnEvent *e);
-    
+    Bool_t        Identify(AliRsnDaughter *d);
+    Bool_t        Identify(AliRsnEvent *e);
+    Bool_t        IdentifiedAs(AliRsnDaughter *d, EType type, Short_t charge = 0);
+
     // setters
     void SetMethod(EMethod method) {fMethod = method;}
        void SetPriorProbability(EType type, Double_t p);
        void SetMinProb(Double_t p) {fMinProb = p;}
        void SetMaxPt(Double_t p) {fMaxPt = p;}
-       
+
        // getters
        EMethod  GetMethod() {return fMethod;}
-    
+
 private:
 
     // identification routines
     Bool_t  IdentifyPerfect(AliRsnDaughter *d);
     Bool_t  IdentifyRealistic(AliRsnDaughter *d);
-    Bool_t  Unidentify(AliRsnDaughter *d);
+    Bool_t  Unidentify(AliRsnDaughter *d, Double_t value = 1.0);
 
     EMethod    fMethod;          // PID method
-    
-    Double_t   fPrior[kSpecies]; // prior probabilities 
+
+    Double_t   fPrior[kSpecies]; // prior probabilities
     Double_t   fMaxPt;           // realistic PID is done for Pt < this parameter
     Double_t   fMinProb;         // threshold on acceptable largest probability
-    
-    static const char* fgkParticleName[kSpecies+1];
+
+    static const char* fgkParticleNameShort[kSpecies+1];
+    static const char* fgkParticleNameLong[kSpecies+1];
+    static const char* fgkParticleNameLatex[kSpecies+1];
     static const Int_t fgkParticlePDG[kSpecies+1];
 
     ClassDef(AliRsnPID,1);
diff --git a/PWG2/RESONANCES/AliRsnPIDIndex.cxx b/PWG2/RESONANCES/AliRsnPIDIndex.cxx
new file mode 100644 (file)
index 0000000..bb66cd1
--- /dev/null
@@ -0,0 +1,221 @@
+/**************************************************************************
+ * 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 AliRsnPIDIndex ***
+//
+// It sorts the indexes of all tracks in an AliRsnEvent
+// for a fast retrieval of them according to charge and PID.
+//
+// author: M. Vala (email: martin.vala@cern.ch)
+//
+
+#include <TObject.h>
+
+#include "AliLog.h"
+
+#include "AliRsnPIDIndex.h"
+
+ClassImp (AliRsnPIDIndex)
+
+//_____________________________________________________________________________
+AliRsnPIDIndex::AliRsnPIDIndex (Int_t num)
+{
+//
+// Default constructor
+//
+    Int_t i, j, k;
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < AliRsnPID::kSpecies+1; j++) {
+            fNumOfIndex[i][j] = 0;
+            fIndex[i][j].Set(num);
+            for (k = 0; k < num; k++) fIndex[i][j].AddAt(-1, k);
+        }
+    }
+}
+
+//_____________________________________________________________________________
+AliRsnPIDIndex::AliRsnPIDIndex (const AliRsnPIDIndex & copy)
+    : TObject (copy)
+{
+//
+// Copy constructor.
+// Creates new instances of all collections
+// to store a copy of all objects.
+//
+
+    Int_t i, j, k, size;
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < AliRsnPID::kSpecies+1; j++) {
+            fNumOfIndex[i][j] = copy.fNumOfIndex[i][j];
+            size = copy.fIndex[i][j].GetSize();
+            fIndex[i][j].Set(size);
+            for (k = 0; k < size; k++) {
+                fIndex[i][j].AddAt(copy.fIndex[i][j].At(k), k);
+            }
+        }
+    }
+}
+
+//_____________________________________________________________________________
+AliRsnPIDIndex& AliRsnPIDIndex::operator= (const AliRsnPIDIndex & copy)
+{
+//
+// Assignment operator.
+// Creates new instances of all collections
+// to store a copy of all objects.
+//
+
+    Int_t i, j, k, size;
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < AliRsnPID::kSpecies+1; j++) {
+            fNumOfIndex[i][j] = copy.fNumOfIndex[i][j];
+            size = copy.fIndex[i][j].GetSize();
+            fIndex[i][j].Set(size);
+            for (k = 0; k < size; k++) {
+                fIndex[i][j].AddAt(copy.fIndex[i][j].At(k), k);
+            }
+        }
+    }
+
+    // return this object
+    return (*this);
+}
+
+AliRsnPIDIndex::~AliRsnPIDIndex()
+{
+//
+// Destructor.
+// Does nothing.
+//
+}
+
+//_____________________________________________________________________________
+void AliRsnPIDIndex::Print (Option_t * option) const
+{
+//
+// Prints AliRsnPIDIndex info
+//
+    Int_t i, j;
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < AliRsnPID::kSpecies + 1; j++) {
+            AliInfo (Form (" [%d][%d] %d %d", i, j, fIndex[i][j].GetSize(), fNumOfIndex[i][j]));
+        }
+    }
+}
+
+//_____________________________________________________________________________
+void AliRsnPIDIndex::AddIndex (const Int_t index, Char_t sign, AliRsnPID::EType type)
+{
+//
+// Adds index to corresponding TArrayI
+//
+    Int_t iCharge = ChargeIndex(sign);
+    Int_t iType = (Int_t)type;
+    fIndex[iCharge][iType].AddAt(index, fNumOfIndex[iCharge][iType]);
+    fNumOfIndex[iCharge][iType]++;
+}
+
+//_____________________________________________________________________________
+void AliRsnPIDIndex::AddIndex(const Int_t index, Short_t sign, Int_t type)
+{
+//
+// Adds index to corresponding TArrayI
+//
+
+    fIndex[sign][type].AddAt (index, fNumOfIndex[sign][type]);
+    fNumOfIndex[sign][type]++;
+}
+
+//_____________________________________________________________________________
+void AliRsnPIDIndex::SetCorrectIndexSize()
+{
+//
+// Sets Correct sizes to all TArrayI
+//
+
+    Int_t i, j;
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < AliRsnPID::kSpecies + 1; j++) {
+            fIndex[i][j].Set(fNumOfIndex[i][j]);
+        }
+    }
+}
+
+//_____________________________________________________________________________
+TArrayI* AliRsnPIDIndex::GetTracksArray (Char_t sign, AliRsnPID::EType type)
+{
+//
+// Returns the array of indexes of tracks whose charge
+// and PID correspond to the passed arguments:
+//   1) sign of particle ('+' or '-')
+//   2) PID of particle (from AliRsnPID::EType)
+// Otherwise returns null pointer.
+//
+
+    Int_t icharge = ChargeIndex (sign);
+    if (icharge < 0) return (TArrayI *) 0x0;
+    if (type < AliRsnPID::kElectron || type > AliRsnPID::kSpecies) {
+        AliError (Form ("Index %d out of range", type));
+        return (TArrayI *) 0x0;
+    }
+
+    return &fIndex[icharge][type];
+}
+
+//_____________________________________________________________________________
+TArrayI* AliRsnPIDIndex::GetCharged (Char_t sign)
+{
+//
+// Returns the array of indexes of tracks whose charge
+// corresponds to the passed argument
+// Otherwise returns a null pointer.
+//
+
+    // check that argument is meaningful
+    Int_t icharge = ChargeIndex (sign);
+    if (icharge < 0) return (TArrayI *)0x0;
+
+    // count total number of tracks with that charge
+    // and create output object of appropriate size
+    Int_t i, total = 0;
+    for (i = 0; i <= AliRsnPID::kSpecies; i++) total += fIndex[icharge][i].GetSize();
+    TArrayI *output = new TArrayI(total);
+
+    // add all indexes
+    Int_t j, counter = 0;
+    for (i = 0; i <= AliRsnPID::kSpecies; i++) {
+        for (j = 0; j < fIndex[icharge][i].GetSize(); j++) {
+            output->AddAt (fIndex[icharge][i].At(j), counter++);
+        }
+    }
+
+    return output;
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnPIDIndex::ChargeIndex (Char_t sign) const
+{
+//
+// Returns the array index corresponding to charge
+//
+
+    if (sign == '+') return 0;
+    else if (sign == '-') return 1;
+    else {
+        AliError (Form ("Character '%c' not recognized as charge sign", sign));
+        return -1;
+    }
+}
diff --git a/PWG2/RESONANCES/AliRsnPIDIndex.h b/PWG2/RESONANCES/AliRsnPIDIndex.h
new file mode 100644 (file)
index 0000000..488494d
--- /dev/null
@@ -0,0 +1,50 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+
+//
+// *** Class AliRsnPIDIndex ***
+//
+// It sorts the indexes of all tracks in an AliRsnEvent
+// for a fast retrieval of them according to charge and PID.
+//
+// author: M. Vala (email: martin.vala@cern.ch)
+//
+
+#ifndef AliRsnPIDIndex_h
+#define AliRsnPIDIndex_h
+
+#include <TArrayI.h>
+#include "AliRsnPID.h"
+
+class AliRsnPIDIndex : public TObject
+{
+public:
+
+    AliRsnPIDIndex (Int_t num = 1000);
+    AliRsnPIDIndex (const AliRsnPIDIndex &copy);
+    AliRsnPIDIndex& operator= (const AliRsnPIDIndex& copy);
+
+    virtual ~AliRsnPIDIndex();
+
+    void     Print(Option_t *option = "") const;
+
+    void     AddIndex(const Int_t index, Char_t sign, AliRsnPID::EType type);
+    void     AddIndex(const Int_t index, Short_t sign, Int_t type);
+    void     SetCorrectIndexSize();
+
+    TArrayI* GetTracksArray (Char_t sign, AliRsnPID::EType type);
+    TArrayI* GetCharged (Char_t sign);
+
+private:
+
+    Int_t    ChargeIndex (Char_t sign) const;
+
+    TArrayI  fIndex[2][AliRsnPID::kSpecies+1];       // index arrays of pos/neg particles of each PID
+    Int_t    fNumOfIndex[2][AliRsnPID::kSpecies+1];  //! array size
+
+    ClassDef (AliRsnPIDIndex, 1);
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx b/PWG2/RESONANCES/AliRsnPIDWeightsMgr.cxx
new file mode 100644 (file)
index 0000000..7d0778e
--- /dev/null
@@ -0,0 +1,123 @@
+/**************************************************************************
+ * 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 AliRsnPIDWeightsMgr
+//                     -------------------
+//           Simple collection of reconstructed tracks
+//           selected from an ESD event
+//           to be used for analysis.
+//           .........................................
+// 
+// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
+//-------------------------------------------------------------------------
+
+#include <TMath.h>
+#include <TString.h>
+#include <TClonesArray.h>
+#include <TDatabasePDG.h>
+
+#include "AliLog.h"
+#include "AliRsnPIDWeightsMgr.h"
+
+ClassImp(AliRsnPIDWeightsMgr)
+
+//_____________________________________________________________________________
+AliRsnPIDWeightsMgr::AliRsnPIDWeightsMgr() 
+{
+//
+// Default and unique constructor which initializes arrays
+//
+    Int_t i, j;
+    for (i = 0; i < kDetectors; i++) {
+        for (j = 0; j < AliRsnPID::kSpecies; j++) fWeights[i][j] = 0.0;
+        fDetPtMin[i] = 0.0;
+        fDetPtMax[i] = 1E25;
+        fUseDet[i] = kTRUE;
+    }
+}
+
+//_____________________________________________________________________________
+void AliRsnPIDWeightsMgr::SetDetectorWeights(EDetector det, Double_t *weights)
+{
+//
+// Copy into the array the PID weights of a detector
+//
+
+    Int_t i;
+    if (!CheckBounds(det)) return;
+    for (i = 0; i < AliRsnPID::kSpecies; i++) fWeights[det][i] = weights[i];
+}
+
+//_____________________________________________________________________________
+void AliRsnPIDWeightsMgr::SetAcceptanceRange(EDetector det, Double_t ptmin, Double_t ptmax)
+{
+//
+// Sets a range in pt for which the PID weights of this detector
+// are accepted in the global computation, in the case that one
+// did not accept to use the global ESD pid.
+//
+
+    if (!CheckBounds(det)) return;
+
+    // swap values if necessary
+    if (ptmin > ptmax) {
+        AliWarning("Values passed in wrong order. Swapping");
+        Double_t temp = ptmin;
+        ptmin = ptmax;
+        ptmax = temp;
+    }
+    fDetPtMin[det] = ptmin;
+    fDetPtMax[det] = ptmax;
+}
+
+//_____________________________________________________________________________
+Double_t AliRsnPIDWeightsMgr::GetWeight(AliRsnPID::EType type, Double_t pt)
+{
+//
+// Computes the global PID weights using the given ranges
+//
+
+    if (type < 0 or type >= AliRsnPID::kSpecies) {
+        AliError("Index out of range");
+        return kFALSE;
+    }
+    
+    Int_t i;
+    Double_t prob = 1.0;
+    for (i = 0; i < kDetectors; i++) {
+        //AliInfo(Form("weights[%d] = %f %f %f %f %f", i, fWeights[i][0], fWeights[i][1], fWeights[i][2], fWeights[i][3], fWeights[i][4], fWeights[i][5]));
+        if (!fUseDet[i]) continue;
+        if (pt < fDetPtMin[i] || pt > fDetPtMax[i]) continue;
+        prob *= fWeights[i][type];
+    }
+
+    return prob;
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnPIDWeightsMgr::CheckBounds(EDetector det)
+{
+//
+// Bounds checker
+//
+    
+    if (det < 0 or det >= kDetectors) {
+        AliError("Index out of range");
+        return kFALSE;
+    }
+    
+    return kTRUE;
+}
diff --git a/PWG2/RESONANCES/AliRsnPIDWeightsMgr.h b/PWG2/RESONANCES/AliRsnPIDWeightsMgr.h
new file mode 100644 (file)
index 0000000..a497e19
--- /dev/null
@@ -0,0 +1,54 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+
+/* $Id: AliRsnPIDWeightsMgr.h,v 1.5 2007/02/21 14:33:25 pulvir Exp $ */
+
+//-------------------------------------------------------------------------
+//                      Class AliRsnPIDWeightsMgr
+//  Simple collection of reconstructed tracks, selected from an ESD event
+// 
+// author: A. Pulvirenti             (email: alberto.pulvirenti@ct.infn.it)
+//-------------------------------------------------------------------------
+
+#ifndef AliRsnPIDWeightsMgr_H
+#define AliRsnPIDWeightsMgr_H
+
+#include "AliRsnPID.h"
+
+class AliRsnPIDWeightsMgr : public TObject
+{
+public:
+    
+    enum EDetector {
+        kITS,
+        kTPC,
+        kTRD,
+        kTOF,
+        kHMPID,
+        kDetectors
+    };
+       
+    AliRsnPIDWeightsMgr();
+    virtual ~AliRsnPIDWeightsMgr() {}
+    
+    void      UseDetector(EDetector det, Bool_t use) {if (CheckBounds(det)) fUseDet[det] = use;}
+    void      SetDetectorWeights(EDetector det, Double_t *weights);
+    void      SetAcceptanceRange(EDetector det, Double_t ptmin, Double_t ptmax);
+    Double_t  GetWeight(AliRsnPID::EType type, Double_t pt);
+    Double_t* GetWeightArray(EDetector det) {if (CheckBounds(det)) return fWeights[det]; else return 0x0;}
+    
+private:
+
+    Bool_t   CheckBounds(EDetector det);
+
+    Bool_t   fUseDet[kDetectors];                        // flag to switch off info from a detector
+    Double_t fDetPtMin[kDetectors];                      // min value for detector weight acceptance
+    Double_t fDetPtMax[kDetectors];                      // max value for detector weight acceptance
+    Double_t fWeights[kDetectors][AliRsnPID::kSpecies];  // PID weights of a single detector
+
+    ClassDef(AliRsnPIDWeightsMgr,1);
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnPairDef.cxx b/PWG2/RESONANCES/AliRsnPairDef.cxx
new file mode 100644 (file)
index 0000000..7048852
--- /dev/null
@@ -0,0 +1,180 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+//
+// ALIRSNPAIRDEF
+//
+// Definition of working parameters for a specific resonance analysis.
+// This object allows to define the particles to be used for computation
+// with respect to charge and PID type (included 'kUnknown'), and
+// the binning of the output histogram.
+// These definitions can then be used by many AliRsnPair objects
+// which can operate on the same track samples under different conditions.
+//
+// author: A. Pulvirenti
+// email : alberto.pulvirenti@ct.infn.it
+//
+
+#include <Riostream.h>
+
+#include "AliLog.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnPairDef.h"
+
+ClassImp(AliRsnPairDef)
+
+//_____________________________________________________________________________
+AliRsnPairDef::AliRsnPairDef() :
+  TObject(),
+  fMotherPDG(0),
+  fNBins(0),
+  fMin(0.0),
+  fMax(0.0)
+{
+//
+// Empty constructor.
+// Initializes the data members to default values:
+//  - no definition of particles in the pair;
+//  - histogram binning 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++) {
+        fCharge[i] = '0';
+        fMass[i] = 0.0;
+        fType[i] = AliRsnPID::kUnknown;
+    }
+}
+
+//_____________________________________________________________________________
+AliRsnPairDef::AliRsnPairDef
+(Char_t sign1, AliRsnPID::EType type1, Char_t sign2, AliRsnPID::EType type2,
+ Int_t nbins, Double_t min, Double_t max) :
+  TObject(),
+  fMotherPDG(0),
+  fNBins(0),
+  fMin(0.0),
+  fMax(0.0)
+{
+//
+// Constructor with arguments.
+// This constructor allows to define all the working parameters.
+//
+
+    SetPair(sign1, type1, sign2, type2);
+    SetBins(nbins, min, max);
+}
+
+//_____________________________________________________________________________
+AliRsnPairDef::AliRsnPairDef(const AliRsnPairDef &copy) :
+  TObject(copy),
+  fMotherPDG(copy.fMotherPDG),
+  fNBins(0),
+  fMin(0.0),
+  fMax(0.0)
+{
+//
+// Copy constructor with standard behavior
+//
+
+    SetPair(copy.fCharge[0], copy.fType[0], copy.fCharge[1], copy.fType[1]);
+    SetBins(copy.fNBins, copy.fMin, copy.fMax);
+}
+
+//_____________________________________________________________________________
+const AliRsnPairDef& AliRsnPairDef::operator=(const AliRsnPairDef &copy)
+{
+//
+// Assignment operator with standard behavior.
+//
+
+    fMotherPDG = copy.fMotherPDG;
+    SetPair(copy.fCharge[0], copy.fType[0], copy.fCharge[1], copy.fType[1]);
+    SetBins(copy.fNBins, copy.fMin, copy.fMax);
+
+    return (*this);
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnPairDef::SetPairElement(Int_t i, Char_t charge, AliRsnPID::EType type)
+{
+//
+// Set one element of the pair
+// and returns warnings if the type is not valid.
+//
+    if (i < 0 || i > 1) {
+        AliError("Index out of range");
+        return kFALSE;
+    }
+    if (charge != '+' && charge != '-') {
+        AliError(Form("Character '%c' not recognized as charge sign"));
+        return kFALSE;
+    }
+    if (type < AliRsnPID::kElectron && type > AliRsnPID::kUnknown) {
+        AliError("Type index out of enumeration range");
+        return kFALSE;
+    }
+    fCharge[i] = charge;
+    fType[i] = type;
+    fMass[i] = AliRsnPID::ParticleMass(type);
+    return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnPairDef::SetPair
+(Char_t charge1, AliRsnPID::EType type1, Char_t charge2, AliRsnPID::EType type2)
+{
+//
+// Set both elements of the pair,
+// returning logical AND of check for each one.
+//
+
+    Bool_t part1 = SetPairElement(0, charge1, type1);
+    Bool_t part2 = SetPairElement(1, charge2, type2);
+    return (part1 && part2);
+}
+
+//_____________________________________________________________________________
+void AliRsnPairDef::CheckEdges()
+{
+//
+// Checks that histogram edges are appropriate,
+// otherwise swaps them.
+//
+    if (fMin > fMax) {
+        AliWarning(Form("min = %f -- max = %f --> swapping", fMin, fMax));
+        Double_t temp = fMin;
+        fMin = fMax;
+        fMax = temp;
+    }
+}
+
+//_____________________________________________________________________________
+Double_t AliRsnPairDef::ComputeWeight(AliRsnDaughter *d0, AliRsnDaughter *d1)
+{
+//
+// Compute a weight for filling the histograms:
+// probability of first track to be identified as 'type[0]' times
+// the probability of second track to be identified as 'type[1]',
+// according to the order of appearance in argument list.
+//
+
+    Double_t prob0 = d0->PIDProb()[fType[0]];
+    Double_t prob1 = d1->PIDProb()[fType[1]];
+
+    return prob0*prob1;
+}
diff --git a/PWG2/RESONANCES/AliRsnPairDef.h b/PWG2/RESONANCES/AliRsnPairDef.h
new file mode 100644 (file)
index 0000000..c3c49d7
--- /dev/null
@@ -0,0 +1,77 @@
+/**************************************************************************
+ * 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 ALIRSNPAIRDEF_H
+#define ALIRSNPAIRDEF_H
+
+class AliRsnDaughter;
+#include "AliRsnPID.h"
+
+class AliRsnPairDef : public TObject
+{
+public:
+
+    AliRsnPairDef();
+    AliRsnPairDef(Char_t sign1, AliRsnPID::EType type1, Char_t sign2, AliRsnPID::EType type2,
+                  Int_t nbins, Double_t min, Double_t max);
+    AliRsnPairDef(const AliRsnPairDef &copy);
+    const AliRsnPairDef& operator=(const AliRsnPairDef &copy);
+    virtual ~AliRsnPairDef() { }
+
+    // getters
+    Char_t           GetCharge(Int_t i) const {if (i>=0&&i<2) return fCharge[i]; else return 0;}
+    AliRsnPID::EType GetType(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;}
+    Int_t            GetNBins() const {return fNBins;}
+    Double_t         GetMin() const {return fMin;}
+    Double_t         GetMax() const {return fMax;}
+    Int_t            GetMotherPDG() const {return fMotherPDG;}
+
+    // setters
+    Bool_t SetPairElement(Int_t i, Char_t charge, AliRsnPID::EType pid);
+    Bool_t SetPair(Char_t charge1, AliRsnPID::EType pid1, Char_t charge2, AliRsnPID::EType pid2);
+    void   SetMotherPDG(Int_t pdg) {fMotherPDG = pdg;}
+    void   SetNBins(Int_t value) {fNBins = value;}
+    void   SetMin(Double_t value) {fMin = value; CheckEdges();}
+    void   SetMax(Double_t value) {fMax = value; CheckEdges();}
+    void   SetBins(Int_t nbins, Double_t min, Double_t max) {fNBins=nbins; fMin=min; fMax=max; CheckEdges();}
+
+    // pair information methods
+    Bool_t IsLikeSign() {return (fCharge[0] == fCharge[1]);}
+    Bool_t HasEqualTypes() {return (fType[0] == fType[1]);}
+
+    // working routines
+    void     CheckEdges();
+    Double_t ComputeWeight(AliRsnDaughter *d0, AliRsnDaughter *d1);
+
+private:
+
+    // pair parameters
+    Int_t             fMotherPDG;  // PDG code of true mother (if known)
+    Double_t          fMass[2];    // mass of particles
+    Char_t            fCharge[2];  // charge of particles
+    AliRsnPID::EType  fType[2];    // PID of particles
+
+    // histogram parameters
+    Int_t             fNBins;      // number of histogram bins
+    Double_t          fMin;        // lower edge
+    Double_t          fMax;        // upper edge
+
+    // ROOT dictionary
+    ClassDef(AliRsnPairDef, 1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnPairParticle.cxx b/PWG2/RESONANCES/AliRsnPairParticle.cxx
new file mode 100644 (file)
index 0000000..040c3b0
--- /dev/null
@@ -0,0 +1,313 @@
+/**************************************************************************
+ * 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 AliRsnPairParticle
+//
+// Implementation of a pair of tracks, for several purposes
+// - computing the total 4-momentum & inv. mass for output histos filling
+// - evaluating cut checks on the pair of particles
+//
+// author: Martin Vala (martin.vala@cern.ch)
+// revised by: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#include "AliLog.h"
+
+#include "AliRsnPairParticle.h"
+
+ClassImp (AliRsnPairParticle)
+
+//_____________________________________________________________________________
+AliRsnPairParticle::AliRsnPairParticle() :
+  fMass(0.0)
+{
+//
+// Constructor.
+// Initializes all variables to meaningless values.
+//
+    Int_t i, j;
+    for (i = 0; i < 3; i++) {
+        fPTot[i] = 0.0;
+        fPTotMC[i] = 0.0;
+        if (i < 2) {
+            fMotherLabel[i] = -1;
+            fMotherPDG[i] = 0;
+            fDaughter[i] = 0x0;
+        }
+        for (j = 0; j < 2; j++) {
+            fPTrack[j][i] = 0.0;
+            fPTrackMC[j][i] = 0.0;
+        }
+    }
+}
+
+//_____________________________________________________________________________
+AliRsnPairParticle::AliRsnPairParticle(const AliRsnPairParticle &obj) :
+  TObject(obj),
+  fMass(obj.fMass)
+{
+//
+// Copy constructor.
+// Initializes all variables to copy values.
+// Does not duplicate pointers.
+//
+    Int_t i, j;
+    for (i = 0; i < 3; i++) {
+        fPTot[i] = obj.fPTot[i];
+        fPTotMC[i] = obj.fPTotMC[i];
+        if (i < 2) {
+            fMotherLabel[i] = obj.fMotherLabel[i];
+            fMotherPDG[i] = obj.fMotherPDG[i];
+            fDaughter[i] = obj.fDaughter[i];
+        }
+        for (j = 0; j < 2; j++) {
+            fPTrack[j][i] = obj.fPTrack[j][i];
+            fPTrackMC[j][i] = obj.fPTrackMC[j][i];
+        }
+    }
+}
+
+//_____________________________________________________________________________
+AliRsnPairParticle& AliRsnPairParticle::operator=(const AliRsnPairParticle &obj)
+{
+//
+// Assignment operator.
+// Initializes all variables to copy values.
+// Does not duplicate pointers.
+//
+
+    fMass = obj.fMass;
+
+    Int_t i, j;
+    for (i = 0; i < 3; i++) {
+        fPTot[i] = obj.fPTot[i];
+        fPTotMC[i] = obj.fPTotMC[i];
+        if (i < 2) {
+            fMotherLabel[i] = obj.fMotherLabel[i];
+            fMotherPDG[i] = obj.fMotherPDG[i];
+            fDaughter[i] = obj.fDaughter[i];
+        }
+        for (j = 0; j < 2; j++) {
+            fPTrack[j][i] = obj.fPTrack[j][i];
+            fPTrackMC[j][i] = obj.fPTrackMC[j][i];
+        }
+    }
+
+    return (*this);
+}
+
+//_____________________________________________________________________________
+AliRsnPairParticle::~AliRsnPairParticle()
+{
+//
+// Desctructor.
+// Does nothing.
+//
+}
+
+//_____________________________________________________________________________
+Double_t AliRsnPairParticle::GetInvMass(Double_t m1, Double_t m2)
+{
+//
+// Compute invariant mass using REC values.
+// The masses in argument have default value = -1.0;
+// when this is used, the mass for computation is taken from daughter object.
+// Otherwise, the passed values are used.
+//
+    Double_t etot = 0.0;
+
+    // energy of particle 1
+    if (m1 > 0.0) etot = GetDaughterEnergy(0, m1);
+    else etot = fDaughter[0]->E();
+
+    // energy of particle 2
+    if (m2 > 0.0) etot += GetDaughterEnergy(1, m2);
+    else etot += fDaughter[1]->E();
+
+    // total momentum square module
+    Double_t p2Tot = fPTot[0]*fPTot[0] + fPTot[1]*fPTot[1] + fPTot[2]*fPTot[2];
+
+    // invariant mass returned
+    return  TMath::Sqrt (etot * etot - p2Tot);
+}
+
+//_____________________________________________________________________________
+Double_t AliRsnPairParticle::GetInvMassMC(Double_t m1, Double_t m2)
+{
+//
+// Compute invariant mass using MC values.
+// The masses in argument have default value = -1.0;
+// when a negative mass value is passed as one of the arguments,
+// the energy of tracks for computation is taken from daughter object.
+// Otherwise, the passed mass values are used to re-compute the track energy.
+//
+    Double_t etot = 0.0;
+
+    // energy of particle 1
+    if (m1 > 0.0) etot = GetDaughterEnergyMC(0, m1);
+    else etot = fDaughter[0]->GetMCInfo()->E();
+
+    // energy of particle 2
+    if (m2 > 0.0) etot += GetDaughterEnergyMC(1, m2);
+    else etot += fDaughter[1]->GetMCInfo()->E();
+
+    // total momentum square module
+    Double_t p2Tot = fPTotMC[0]*fPTotMC[0] + fPTotMC[1]*fPTotMC[1] +fPTotMC[2]*fPTotMC[2];
+
+    // invariant mass returned
+    return  TMath::Sqrt (etot * etot - p2Tot);
+}
+
+//_____________________________________________________________________________
+Double_t AliRsnPairParticle::GetDaughterEnergy(const Int_t &index, const Double_t &mass)
+{
+//
+// Compute track energy from REC momentum using a passed mass value.
+// The index argument refers to the used track among the two of the pair.
+//
+
+    Int_t i;
+    Double_t p2Tot = 0.0;
+    if (mass > 0 && index >= 0 && index < 2) {
+        AliRsnDaughter temp(*fDaughter[index]);
+        temp.SetM(mass);
+        return temp.E();
+    }
+
+    AliWarning("Negative mass or wrong index passed. Returning 0");
+    return 0.0;
+}
+
+//_____________________________________________________________________________
+Double_t AliRsnPairParticle::GetDaughterEnergyMC(const Int_t &index, const Double_t &mass)
+{
+//
+// Compute track energy from MC momentum using a passed mass value.
+// The index argument refers to the used track among the two of the pair.
+//
+    Int_t i;
+    Double_t p2Tot = 0.0;
+    if (mass > 0 && index >= 0 && index < 2) {
+        for (i = 0; i < 3; i++) p2Tot += fPTrackMC[index][i] * fPTrackMC[index][i];
+        return TMath::Sqrt(mass*mass + p2Tot);
+    }
+
+    AliWarning("Negative mass or wrong index passed. Returning 0");
+    return 0.0;
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnPairParticle::GetPDG(const Int_t &index)
+{
+//
+// Return PDG code of one track in the pair
+//
+
+    if (index < 0 || index > 1) {
+        AliError("Index out of range");
+        return 0;
+    }
+    if (!fDaughter[index]->GetMCInfo()) {
+        AliError(Form("MCInfo not initialized for track %d", index));
+        return 0;
+    }
+    return fDaughter[index]->GetMCInfo()->PDG();
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnPairParticle::IsTruePair(Int_t refPDG)
+{
+//
+// Checks if the tweo tracks in the pair come from the same resonance.
+// This can be known if MC info is present, looking at the GEANT label of mother
+// (which should be the same).
+// If the argument is 0, the answer is kTRUE whenever the labels of mothers of the
+// two tracks is the same. When the argument is not zero, the answer is kTRUE only
+// if the mother is the same and its PDG code is equal to the argument.
+
+    // if MC info is not available, the pairs is not true by default
+    if (!fDaughter[0]->GetMCInfo() || !fDaughter[1]->GetMCInfo()) {
+        return kFALSE;
+    }
+
+    // check that labels are the same
+    if (fDaughter[0]->GetMCInfo()->Mother() != fDaughter[1]->GetMCInfo()->Mother()) {
+        return kFALSE;
+    }
+
+    // if we reach this point, the two tracks have the same mother
+    // let's check now the PDG code of this common mother
+    Int_t motherPDG = TMath::Abs(fDaughter[0]->GetMCInfo()->MotherPDG());
+    if (refPDG == 0) return kTRUE;
+    else return (motherPDG == refPDG);
+}
+
+//_____________________________________________________________________________
+void AliRsnPairParticle::SetPair(AliRsnDaughter *daughter1, AliRsnDaughter *daughter2)
+{
+//
+// Main object filling method.
+// Accepts two AliRsnDaughter's which are the two tracks in the pair,
+// fills all data-members which contain their momenta & info,
+// and computes the total momentum for REC data and MC if available
+//
+
+    Int_t i;
+
+    fDaughter[0] = daughter1;
+    fDaughter[1] = daughter2;
+
+    // copy MC info (if available)
+    if (fDaughter[0]->GetMCInfo() && fDaughter[1]->GetMCInfo()) {
+        for (i = 0; i < 2; i++) {
+            fPTrackMC[i][0] = fDaughter[i]->GetMCInfo()->Px();
+            fPTrackMC[i][1] = fDaughter[i]->GetMCInfo()->Py();
+            fPTrackMC[i][2] = fDaughter[i]->GetMCInfo()->Pz();
+            fMotherPDG[i] = fDaughter[i]->GetMCInfo()->MotherPDG();
+        }
+        for (i = 0; i < 3; i++) fPTotMC[i] = fPTrackMC[0][i] + fPTrackMC[1][i];
+    }
+
+    // copy reconstructed info (always available)
+    for (i = 0; i < 2; i++) {
+        fPTrack[i][0] = fDaughter[i]->Px();
+        fPTrack[i][1] = fDaughter[i]->Py();
+        fPTrack[i][2] = fDaughter[i]->Pz();
+    }
+    for (i = 0; i < 3; i++) fPTot[i] = fPTrack[0][i] + fPTrack[1][i];
+}
+
+//_____________________________________________________________________________
+void AliRsnPairParticle::PrintInfo (const Option_t *option)
+{
+//
+// Print some info of the pair
+//
+
+    TString s(option);
+
+    AliInfo ( "======== BEGIN PAIR INFO ===========" );
+    if (s.Contains("p")) {
+        AliInfo (Form("Px1 = %.6f --- Py1 = %.6f --- Pz1 = %.6f", fPTrack[0][0], fPTrack[0][1], fPTrack[0][2]));
+        AliInfo (Form("Px2 = %.6f --- Py2 = %.6f --- Pz2 = %.6f", fPTrack[1][0], fPTrack[1][1], fPTrack[1][2]));
+    }
+    if (s.Contains("t")) {
+        AliInfo (Form("PDG1 = %d --- PDG2 = %d", GetPDG(0), GetPDG(1)));
+        AliInfo (Form("type1 = %d --- type2 = %d", GetType(0), GetType(1)));
+        AliInfo (Form("label1 = %d --- label2 = %d", GetLabel(0), GetLabel(1)));
+    }
+    AliInfo ( "====== END PAIR INFO =========" );
+}
diff --git a/PWG2/RESONANCES/AliRsnPairParticle.h b/PWG2/RESONANCES/AliRsnPairParticle.h
new file mode 100644 (file)
index 0000000..102fac5
--- /dev/null
@@ -0,0 +1,85 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               *
+ **************************************************************************/
+
+//
+// Class AliRsnPairParticle
+//
+// Implementation of a pair of tracks, for several purposes
+// - computing the total 4-momentum & inv. mass for output histos filling
+// - evaluating cut checks on the pair of particles
+//
+// author: Martin Vala (martin.vala@cern.ch)
+// revised by: Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNPAIRPARTICLE_H
+#define ALIRSNPAIRPARTICLE_H
+
+#include <TMath.h>
+
+#include "AliRsnDaughter.h"
+#include "AliRsnMCInfo.h"
+
+class AliRsnPairParticle : public TObject
+{
+public:
+
+    AliRsnPairParticle();
+    AliRsnPairParticle(const AliRsnPairParticle &obj);
+    AliRsnPairParticle& operator=(const AliRsnPairParticle &obj);
+    virtual ~AliRsnPairParticle();
+
+    Double_t   GetInvMass (Double_t m1 = -1.0, Double_t m2 = -1.0);
+    Double_t   GetInvMassMC (Double_t m1 = -1.0, Double_t m2 = -1.0);
+    Double_t   GetDaughterEnergy(const Int_t &index, const Double_t &mass);
+    Double_t   GetDaughterEnergyMC(const Int_t &index, const Double_t &mass);
+
+    Double_t   GetP2() const {return (fPTot[0]*fPTot[0] + fPTot[1]*fPTot[1] + fPTot[2]*fPTot[2]);}
+    Double_t   GetPt2() const {return (fPTot[0]*fPTot[0] + fPTot[1]*fPTot[1]);}
+    Double_t   GetP() const {return TMath::Sqrt(GetP2());}
+    Double_t   GetP(Int_t index) const {return fPTot[index];}
+    Double_t   GetPt() const {return TMath::Sqrt(GetPt2());}
+
+    Double_t   GetP2MC() const {return (fPTotMC[0]*fPTotMC[0] + fPTotMC[1]*fPTotMC[1] + fPTotMC[2]*fPTotMC[2]);}
+    Double_t   GetPt2MC() const {return (fPTotMC[0]*fPTotMC[0] + fPTotMC[1]*fPTotMC[1]);}
+    Double_t   GetPMC() const {return TMath::Sqrt(GetP2MC());}
+    Double_t   GetPMC(Int_t index) const {return fPTotMC[index];}
+    Double_t   GetPtMC() const {return TMath::Sqrt(GetPt2MC());}
+
+    Int_t      GetPDG(const Int_t &index);
+    Int_t      GetType(const Int_t &index) const {return (Int_t) fDaughter[index]->PIDType();}
+    Int_t      GetLabel(const Int_t &index) const {return (Int_t) fDaughter[index]->Label();}
+    Int_t      GetIndex(const Int_t &index) const {return (Int_t) fDaughter[index]->Index();}
+    Double_t   GetMass() const {return fMass;}
+    AliRsnDaughter* GetDaughter(const Int_t &index) const {return fDaughter[index];}
+
+    Bool_t     IsPDGEqual() {return abs(GetPDG(0)) == abs(GetPDG(1));}
+    Bool_t     IsTypeEqual() {return GetType(0) == GetType(1);}
+    Bool_t     IsLabelEqual() {return abs(GetLabel(0)) == abs(GetLabel(1));}
+    Bool_t     IsIndexEqual() {return GetIndex(0) == GetIndex(1);}
+    Bool_t     IsTruePair(Int_t refPDG = 0);
+
+    void       SetMass(Double_t mass) {fMass = mass;}
+    void       SetPair(AliRsnDaughter *daughter1, AliRsnDaughter *daughter2);
+    void       PrintInfo (const Option_t *option = "");
+
+private:
+
+    Double_t         fPTot[3];          // total momentum computed with rec. values
+    Double_t         fPTotMC[3];        // total momentum computed with MC values
+    Double_t         fPTrack[2][3];     // rec. momentum of single tracks
+    Double_t         fPTrackMC[2][3];   // MC momentum of single tracks
+
+    Double_t         fMass;             // mass hypothesis for resonance
+
+    Int_t            fMotherLabel[2];   // GEANT label of tracks
+    Int_t            fMotherPDG[2];     // PDG code of mother of tracks
+
+    AliRsnDaughter  *fDaughter[2];      // elements of the pair
+
+    ClassDef (AliRsnPairParticle,1)
+};
+
+#endif
diff --git a/PWG2/RESONANCES/AliRsnPairSimple.cxx b/PWG2/RESONANCES/AliRsnPairSimple.cxx
new file mode 100644 (file)
index 0000000..3cc5fae
--- /dev/null
@@ -0,0 +1,361 @@
+/**************************************************************************
+ * 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 AliRsnPairSimple
+//-------------------------------------------------------------------------
+// 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 AliRsnPairSimple'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 <TArrayI.h>
+#include <TClonesArray.h>
+
+#include "AliLog.h"
+#include "AliRsnMCInfo.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnEvent.h"
+#include "AliRsnCut.h"
+#include "AliRsnCutMgr.h"
+#include "AliRsnPairDef.h"
+#include "AliRsnPID.h"
+
+#include "AliRsnPairSimple.h"
+
+ClassImp(AliRsnPairSimple)
+
+//--------------------------------------------------------------------------------------------------------
+AliRsnPairSimple::AliRsnPairSimple(AliRsnPairDef *pd, const char *name, const char *title) :
+  TNamed(name, title),
+  fPIDMethod(AliRsnPID::kNone),
+  fForMixing(kFALSE),
+  fStoreOnlyTrue(kFALSE),
+  fCuts(0x0),
+  fPair(),
+  fPairDef(pd),
+  fHistogram(0x0),
+  fHistogramMC(0x0)
+{
+//
+// Constructor.
+// 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.
+//
+}
+//--------------------------------------------------------------------------------------------------------
+AliRsnPairSimple::AliRsnPairSimple(const AliRsnPairSimple &copy) :
+  TNamed(copy),
+  fPIDMethod(copy.fPIDMethod),
+  fForMixing(copy.fForMixing),
+  fStoreOnlyTrue(copy.fStoreOnlyTrue),
+  fCuts(0x0),
+  fPair(),
+  fPairDef(copy.fPairDef),
+  fHistogram(0x0),
+  fHistogramMC(0x0)
+{
+//
+// Copy constructor.
+// Default behavior as a copy constructor for what concerns non-array data-members.
+// The arrays are cloned if they are not NULL.
+//
+}
+//--------------------------------------------------------------------------------------------------------
+const AliRsnPairSimple& AliRsnPairSimple::operator=(const AliRsnPairSimple &copy)
+{
+//
+// Assignment operator.
+// Default behavior like copy constructor.
+//
+    SetName(copy.GetName());
+    SetTitle(copy.GetTitle());
+
+    fHistogram = 0x0;
+    fHistogramMC = 0x0;
+    fPairDef = copy.fPairDef;
+
+    fPIDMethod = copy.fPIDMethod;
+    fForMixing = copy.fForMixing;
+    fStoreOnlyTrue = copy.fStoreOnlyTrue;
+    if (copy.fHistogram) fHistogram = (TH1D*)(copy.fHistogram->Clone());
+
+    fCuts = 0x0;
+
+    return (*this);
+}
+//--------------------------------------------------------------------------------------------------------
+void AliRsnPairSimple::Clear(Option_t* /*option*/)
+{
+//
+// Clear arrays and histogram.
+// For the sake of security, all pointers are also set explicitly to NULL.
+//
+    delete fHistogram;
+    fHistogram = 0x0;
+    delete fHistogramMC;
+    fHistogramMC = 0x0;
+}
+
+//--------------------------------------------------------------------------------------------------------
+void AliRsnPairSimple::InitHistograms()
+{
+//
+// Initialize histograms
+//
+
+    Int_t nbins = fPairDef->GetNBins();
+    Double_t min = fPairDef->GetMin(), max = fPairDef->GetMax();
+
+    if (strlen(GetName()) > 0) {
+        fHistogram = new TH1D(GetName(), GetTitle(), nbins, min, max);
+        fHistogramMC = new TH1D(Form("MC_%s", GetName()), Form("%s (MC)", GetTitle()), nbins, min, max);
+    }
+    else {
+        Char_t name[200], title[200];
+        strcpy(name, GetHistName());
+        strcpy(title, GetHistTitle());
+        fHistogram = new TH1D(name, title, nbins, min, max);
+        fHistogramMC = new TH1D(Form("MC_%s", name), Form("%s (MC)", title), nbins, min, max);
+    }
+    fHistogram->Sumw2();
+    fHistogramMC->Sumw2();
+}
+
+const char* AliRsnPairSimple::GetHistName ()
+{
+//
+// Creates the histogram name, given a cut manager
+//
+
+    TString strName("");
+    strName.Append(AliRsnPID::ParticleName(fPairDef->GetType(0)));
+    strName += '(';
+    strName += fPairDef->GetCharge(0);
+    strName += ')';
+    strName += '_';
+    strName.Append(AliRsnPID::ParticleName(fPairDef->GetType(1)));
+    strName += '(';
+    strName += fPairDef->GetCharge(1);
+    strName += ')';
+    strName += '_';
+    if (fCuts) {
+        strName.Append("cuts:");
+        strName.Append(fCuts->GetName());
+    }
+    else {
+        strName.Append("NoCuts");
+    }
+    if (fStoreOnlyTrue) strName.Append("_true");
+    if (fForMixing) strName.Append("_mix");
+
+    return strName.Data();
+}
+
+const char* AliRsnPairSimple::GetHistTitle()
+{
+//
+// Creates the histogram title, given a cut manager
+//
+
+    TString strName("Inv. mass of ");
+    strName.Append(AliRsnPID::ParticleName(fPairDef->GetType(0), kFALSE));
+    strName += 's';
+    strName += ' ';
+    strName += '(';
+    strName += fPairDef->GetCharge(0);
+    strName += ')';
+    strName.Append(" and ");
+    strName.Append(AliRsnPID::ParticleName(fPairDef->GetType(1), kFALSE));
+    strName += 's';
+    strName += ' ';
+    strName += '(';
+    strName += fPairDef->GetCharge(1);
+    strName += ')';
+    if (fCuts) {
+        strName.Append(" [cuts: ");
+        strName.Append(fCuts->GetTitle());
+        strName.Append("] ");
+    }
+    else {
+        strName.Append(" [No cuts] ");
+    }
+    if (fStoreOnlyTrue) strName.Append(" [true pairs]");
+    if (fForMixing) strName.Append(" [event mixing]");
+
+    return strName.Data();
+}
+
+//--------------------------------------------------------------------------------------------------------
+Stat_t AliRsnPairSimple::Process(AliRsnEvent *event1, AliRsnEvent *event2)
+{
+//
+// Scans the two events specified in argument to fill the histogram.
+// This method essentially calls the AliRsnPairSimple::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 AliRsnPairSimple 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.
+//
+
+    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;
+    }
+    if (!fPairDef) {
+        AliError("No pairdef defined");
+        return 0.0;
+    }
+    if (!fHistogram) {
+        AliError("Histograms not initialized");
+        return 0.0;
+    }
+
+    // assign pointers to the list of indexes to be used
+    TArrayI *listCharged1 = 0x0, *listCharged2 = 0x0;
+    //if (pidMethod == AliRsnPID::kNone) {
+        listCharged1 = event1->GetCharged(fPairDef->GetCharge(0));
+        listCharged2 = event2->GetCharged(fPairDef->GetCharge(1));
+    //}
+    //else {
+        //listCharged1 = event1->GetTracksArray(pidMethod, fPairDef->GetCharge(0), fPairDef->GetType(0));
+        //listCharged2 = event2->GetTracksArray(pidMethod, fPairDef->GetCharge(1), fPairDef->GetType(1));
+    //}
+    if (!listCharged1 || !listCharged2) return 0.0;
+    TArrayI &list1 = *listCharged1;
+    TArrayI &list2 = *listCharged2;
+
+    Int_t   i1, i2, start2;
+    Stat_t  nPairs = 0;
+    AliRsnDaughter *track1 = 0x0, *track2 = 0x0;
+
+    // loop on particle of type 1 (in first event)
+    for (i1 = 0; i1 < list1.GetSize(); i1++) {
+        track1 = event1->GetTrack(list1[i1]);
+        //if (!track1) continue;
+        if (!fCuts->IsSelected(AliRsnCut::kParticle, track1)) continue;
+        // loop on particle of type 2 (in second event)
+        // in case we are building a like-sign histogram with particles
+        // of the same type in the same event, we must avoid that
+        // each pair is computed twice
+        start2 = 0;
+        if (listCharged1 == listCharged2) start2 = i1 + 1;
+        for (i2 = start2; i2 < list2.GetSize(); i2++) {
+            track2 = event2->GetTrack(list2[i2]);
+            //if (!track2) continue;
+            if (!fCuts->IsSelected(AliRsnCut::kParticle, track2)) continue;
+            nPairs += Process(track1, track2);
+        }
+    }
+
+    return nPairs;
+}
+
+//_____________________________________________________________________________
+Stat_t AliRsnPairSimple::Process
+(AliRsnDaughter *track1, AliRsnDaughter *track2)
+{
+//
+// Checks the single tracks and the pair against track cuts and,
+// if the cuts are passed, fill the histograms with a weight
+// given by the product of the appropriate PID probabilities of both.
+// The method returns a boolean success value for eventually counting.
+//
+
+    // setup pair and check pair cuts
+    fPair.SetPair(track1, track2);
+    if (!fCuts->IsSelected(AliRsnCut::kPair, &fPair)) return 0.0;
+
+    // if there is a request to process only the pairs born from a true resonance
+    // this is checked here
+    if (fStoreOnlyTrue && !fPair.IsTruePair(fPairDef->GetMotherPDG())) return 0.0;
+
+    // computation variables
+    Double_t mass1 = fPairDef->GetMass(0);
+    Double_t mass2 = fPairDef->GetMass(1);
+    Double_t invmass, invmassMC, weight;
+
+    // assign nominal masses to daughters
+    track1->SetM(mass1);
+    track2->SetM(mass2);
+
+    // if we are here, all cuts are passed - fill histograms
+    invmass = fPair.GetInvMass(mass1, mass2);
+    invmassMC = fPair.GetInvMassMC(mass1, mass2);
+    if (fPIDMethod == AliRsnPID::kNone) {
+        fHistogram->Fill(invmass);
+        fHistogramMC->Fill(invmassMC);
+        if (fPairDef->IsLikeSign() && !fPairDef->HasEqualTypes()) {
+            track1->SetM(mass1);
+            track2->SetM(mass2);
+            if (fCuts->IsSelected(AliRsnCut::kPair, &fPair)) {
+                invmass = fPair.GetInvMass(mass2, mass1);
+                invmassMC = fPair.GetInvMassMC(mass2, mass1);
+                fHistogram->Fill(invmass);
+                fHistogramMC->Fill(invmassMC);
+            }
+        }
+    }
+    else {
+        weight = fPairDef->ComputeWeight(track1, track2);
+        if (weight > 0.0) {
+            fHistogram->Fill(invmass, weight);
+            fHistogramMC->Fill(invmassMC, weight);
+        }
+        // if we are treating a like-sign pair with different types for track #1 and #2,
+        // we must also exchange the tracks and fill again the histogram
+        if (fPairDef->IsLikeSign() && !fPairDef->HasEqualTypes()) {
+            track1->SetM(mass1);
+            track2->SetM(mass2);
+            if (fCuts->IsSelected(AliRsnCut::kPair, &fPair)) {
+                weight = fPairDef->ComputeWeight(track2, track1);
+                invmass = fPair.GetInvMass(mass2, mass1);
+                invmassMC = fPair.GetInvMassMC(mass2, mass1);
+                if (weight > 0.0) {
+                    fHistogram->Fill(invmass, weight);
+                    fHistogramMC->Fill(invmassMC, weight);
+                }
+            }
+        }
+    }
+
+    return 1.0;
+}
diff --git a/PWG2/RESONANCES/AliRsnPairSimple.h b/PWG2/RESONANCES/AliRsnPairSimple.h
new file mode 100644 (file)
index 0000000..0dbf0e6
--- /dev/null
@@ -0,0 +1,85 @@
+/*************************************************************************
+ * 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 AliRsnPairSimple_H
+#define AliRsnPairSimple_H
+
+#include <TNamed.h>
+#include "AliRsnPID.h"
+#include "AliRsnPairParticle.h"
+
+class TH1D;
+class AliRsnEvent;
+class AliRsnPairDef;
+class AliRsnCutMgr;
+class AliRsnPID;
+
+class AliRsnPairSimple : public TNamed
+{
+
+public:
+
+    AliRsnPairSimple(AliRsnPairDef *pd = 0x0, const char *name  = "", const char *title = "");
+    virtual ~AliRsnPairSimple() {Clear();}
+    virtual void Clear(Option_t *option = "");
+
+    // getters
+    TH1D*               GetHistogram() {return fHistogram;}
+    TH1D*               GetHistogramMC() {return fHistogramMC;}
+    AliRsnPairDef*      GetPairDef() {return fPairDef;}
+    AliRsnPairParticle* GetPair() {return &fPair;}
+    Bool_t              StoreOnlyTruePairs() const {return fStoreOnlyTrue;}
+    Bool_t              IsForMixing() const {return fForMixing;}
+
+    // setters
+    void   SetPIDMethod(AliRsnPID::EMethod method) {fPIDMethod = method;}
+    void   SetPairDef(AliRsnPairDef *def) {fPairDef = def;}
+    void   SetStoreOnlyTrue(Bool_t doit = kTRUE) {fStoreOnlyTrue = doit;}
+    void   SetForMixing(Bool_t doit = kTRUE) {fForMixing = doit;}
+    void   SetCutManager(AliRsnCutMgr *cutMgr) {fCuts = cutMgr;}
+
+    // working parameters
+    void   InitHistograms();
+    Stat_t Process(AliRsnEvent *event1, AliRsnEvent *event2 = 0);
+    Stat_t Process(AliRsnDaughter *t1, AliRsnDaughter *t2);
+
+private:
+
+    // private functions
+    AliRsnPairSimple(const AliRsnPairSimple &copy);
+    const AliRsnPairSimple& operator=(const AliRsnPairSimple &copy);
+    const char* GetHistName();
+    const char* GetHistTitle();
+
+    // flags
+    AliRsnPID::EMethod   fPIDMethod;       // flag to know PID method used
+    Bool_t               fForMixing;       // flag is true for objects created for event mixing
+    Bool_t               fStoreOnlyTrue;   // output = only spectra of true pairs
+
+    // cut manager
+    AliRsnCutMgr        *fCuts;            // cut manager for single particle
+
+    // objects
+    AliRsnPairParticle   fPair;            // utility class for pair
+    AliRsnPairDef       *fPairDef;         // definitions for pair
+    TH1D                *fHistogram;       // invariant mass distribution
+    TH1D                *fHistogramMC;     // invariant mass distribution (MC)
+
+    // ROOT dictionary
+    ClassDef(AliRsnPairSimple, 1)
+};
+
+#endif
index b735643fc1d535ef08b92e4e3618796e3897645c..8f9dcc80e612c5262a13d889bb84dabc0ed0dbd4 100644 (file)
 // email : alberto.pulvirenti@ct.infn.it
 //
 
+#include <TString.h>
+
 #include "AliLog.h"
 
+#include "AliVEvent.h"
+
 #include "AliESDEvent.h"
 #include "AliESDtrack.h"
 #include "AliESDVertex.h"
 #include "AliMCParticle.h"
 #include "AliGenEventHeader.h"
 
-#include "AliRsnParticle.h"
+#include "AliRsnMCInfo.h"
 #include "AliRsnDaughter.h"
 #include "AliRsnEvent.h"
+#include "AliRsnPIDWeightsMgr.h"
 #include "AliRsnReader.h"
 
 ClassImp(AliRsnReader)
-               
+
 //_____________________________________________________________________________
-AliRsnReader::AliRsnReader(Bool_t checkSplit, Bool_t rejectFakes) :
+AliRsnReader::AliRsnReader(ESource source, AliRsnPIDWeightsMgr *mgr) :
   TObject(),
-  fCheckSplit(checkSplit),
-  fRejectFakes(rejectFakes)
+  fSource(source),
+  fCheckSplit(kFALSE),
+  fRejectFakes(kFALSE),
+  fWeightsMgr(mgr)
 {
-//=========================================================
+//
 // Constructor.
 // Initializes the base-type data members:
 //   - management of fake tracks
-//=========================================================
+//
 }
 
 //_____________________________________________________________________________
 AliRsnReader::AliRsnReader(const AliRsnReader &copy) : 
   TObject(copy),
+  fSource(copy.fSource),
   fCheckSplit(copy.fCheckSplit),
-  fRejectFakes(copy.fRejectFakes)
+  fRejectFakes(copy.fRejectFakes),
+  fWeightsMgr(copy.fWeightsMgr)
 {
-//=========================================================
+//
 // Copy constructor.
-//=========================================================
+//
 }
 
 //_____________________________________________________________________________
 AliRsnReader& AliRsnReader::operator=(const AliRsnReader &copy)
 {
-//=========================================================
+//
 // Assignment operator.
-//=========================================================
-       
-       fCheckSplit = copy.fCheckSplit;
-       fRejectFakes = copy.fRejectFakes;
-       return (*this);
+//
+
+    fSource = copy.fSource;
+    fCheckSplit = copy.fCheckSplit;
+    fRejectFakes = copy.fRejectFakes;
+    fWeightsMgr = copy.fWeightsMgr;
+    return (*this);
+}
+
+//_____________________________________________________________________________
+Bool_t AliRsnReader::Fill(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *mc)
+{
+//
+// According to the class type of event and the selected source
+// recalls one of the private reading methods to fill the RsnEvent
+// passed by reference as first argument.
+//
+
+    TString str(event->ClassName());
+
+    switch (fSource) {
+        case kESD:
+            if (!str.Contains("AliESDEvent")) {
+                AliError("A reader set to 'kESD' or 'kESDTPC' can read only ESD events");
+                return kFALSE;
+            }
+            return FillFromESD(rsn, (AliESDEvent*)event, mc);
+        case kESDTPC:
+            if (!str.Contains("AliESDEvent")) {
+                AliError("A reader set to 'kESD' or 'kESDTPC' can read only ESD events");
+                return kFALSE;
+            }
+            return FillFromESD(rsn, (AliESDEvent*)event, mc, kTRUE);
+        case kAOD:
+            if (!str.Contains("AliAODEvent")) {
+                AliError("A reader set to 'kAOD' can read only AOD events");
+                return kFALSE;
+            }
+            return FillFromAOD(rsn, (AliAODEvent*)event, mc);
+        case kMC:
+            if (!str.Contains("AliMCEvent")) {
+                AliError("A reader set to 'kMC' can read only MC events");
+                return kFALSE;
+            }
+            return FillFromMC(rsn, (AliMCEvent*)event);
+        default:
+            return kFALSE;
+    }
 }
 
 //_____________________________________________________________________________
-Bool_t AliRsnReader::FillFromESD(AliRsnEvent *rsn, AliESDEvent *esd, AliMCEvent *mc)
+Bool_t AliRsnReader::FillFromESD
+(AliRsnEvent *rsn, AliESDEvent *esd, AliMCEvent *mc, Bool_t useTPCOnly)
 {
-//=========================================================
+//
 // Filler from an ESD event.
 // Stores all tracks (if a filter is defined, it will store
 // only the ones which survive the cuts).
@@ -103,21 +156,20 @@ Bool_t AliRsnReader::FillFromESD(AliRsnEvent *rsn, AliESDEvent *esd, AliMCEvent
 // GEANT label of mother, PDG code of mother, if any).
 // When this is used, the 'source' flag of the output
 // AliRsnEvent object will be set to 'kESD'.
-//=========================================================
-       
-       // set source flag
-       rsn->SetSource(AliRsnEvent::kESD);
-       
-       // retrieve stack (if possible)
-       AliStack *stack = 0x0;
-       if (mc) stack = mc->Stack();
-       
-       // get number of tracks
-       Int_t ntracks = esd->GetNumberOfTracks();
-       if (!ntracks) {
-          AliWarning("No tracks in this event");
-          return kFALSE;
+//
+    
+    // retrieve stack (if possible)
+    AliStack *stack = 0x0;
+    if (mc) stack = mc->Stack();
+    
+    // get number of tracks
+    Int_t ntracks = esd->GetNumberOfTracks();
+    /*
+    if (!ntracks) {
+       AliWarning("No tracks in this event");
+       return kFALSE;
     }
+    */
     
     // if required with the flag, scans the event
     // and searches all split tracks (= 2 tracks with the same label);
@@ -135,7 +187,7 @@ Bool_t AliRsnReader::FillFromESD(AliRsnEvent *rsn, AliESDEvent *esd, AliMCEvent
                 lab2 = TMath::Abs(trk2->GetLabel());
                 // check if labels are equal
                 if (lab1 == lab2) {
-                    if (trk1->GetConstrainedChi2() > trk2->GetConstrainedChi2()) {
+                    if (trk1->GetConstrainedChi2() < trk2->GetConstrainedChi2()) {
                         accept[i1] = kTRUE;
                         accept[i2] = kFALSE;
                     }
@@ -147,16 +199,23 @@ Bool_t AliRsnReader::FillFromESD(AliRsnEvent *rsn, AliESDEvent *esd, AliMCEvent
             }
         }
     }
-       
-       // get primary vertex
-       Double_t vertex[3];
-       vertex[0] = esd->GetVertex()->GetXv();
-       vertex[1] = esd->GetVertex()->GetYv();
-       vertex[2] = esd->GetVertex()->GetZv();
-       rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]);
-       
-       // store tracks from ESD
-    Int_t  index, label, labmum;
+    
+    // get primary vertex
+    Double_t vertex[3];
+    if (!useTPCOnly) {
+        vertex[0] = esd->GetVertex()->GetXv();
+        vertex[1] = esd->GetVertex()->GetYv();
+        vertex[2] = esd->GetVertex()->GetZv();
+    }
+    else {
+        vertex[0] = esd->GetPrimaryVertexTPC()->GetXv();
+        vertex[1] = esd->GetPrimaryVertexTPC()->GetYv();
+        vertex[2] = esd->GetPrimaryVertexTPC()->GetZv();
+    }
+    rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]);
+    
+    // store tracks from ESD
+    Int_t  i, index, label, labmum;
     Bool_t check;
     AliRsnDaughter temp;
     for (index = 0; index < ntracks; index++) {
@@ -171,17 +230,37 @@ Bool_t AliRsnReader::FillFromESD(AliRsnEvent *rsn, AliESDEvent *esd, AliMCEvent
         if (fRejectFakes && (label < 0)) continue;
         // copy ESD track data into RsnDaughter
         // if unsuccessful, this track is skipped
-        check = temp.Adopt(esdTrack);
+        check = temp.Adopt(esdTrack, useTPCOnly);
         if (!check) continue;
+        // if the AliRsnWeightsMgr object is initialized
+        // this means that ESD PID weights are not used
+        // and they are computed according to the Weight manager
+        if (fWeightsMgr) {
+            //AliInfo("Using customized weights");
+            //AliInfo(Form("ESD weights = %f %f %f %f %f", temp.PID()[0], temp.PID()[1], temp.PID()[2], temp.PID()[3], temp.PID()[4], temp.PID()[5]));
+            esdTrack->GetITSpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kITS));
+            esdTrack->GetTPCpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kTPC));
+            esdTrack->GetTRDpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kTRD));
+            esdTrack->GetTOFpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kTOF));
+            esdTrack->GetHMPIDpid(fWeightsMgr->GetWeightArray(AliRsnPIDWeightsMgr::kHMPID));
+            for (i = 0; i < AliRsnPID::kSpecies; i++) {
+                temp.SetPIDWeight(i, fWeightsMgr->GetWeight((AliRsnPID::EType)i, temp.Pt()));
+            }
+            //AliInfo(Form("Used weights = %f %f %f %f %f", temp.PID()[0], temp.PID()[1], temp.PID()[2], temp.PID()[3], temp.PID()[4], temp.PID()[5]));
+        }
+        else {
+            //AliInfo("Using standard ESD weights");
+        }
+        
         // if stack is present, copy MC info
         if (stack) {
             TParticle *part = stack->Particle(TMath::Abs(label));
             if (part) {
-                temp.InitParticle(part);
+                temp.InitMCInfo(part);
                 labmum = part->GetFirstMother();
                 if (labmum >= 0) {
                     TParticle *mum = stack->Particle(labmum);
-                    temp.GetParticle()->SetMotherPDG(mum->GetPdgCode());
+                    temp.GetMCInfo()->SetMotherPDG(mum->GetPdgCode());
                 }
             }
         }
@@ -205,7 +284,7 @@ Bool_t AliRsnReader::FillFromESD(AliRsnEvent *rsn, AliESDEvent *esd, AliMCEvent
 //_____________________________________________________________________________
 Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent *mc)
 {
-//=========================================================
+//
 // Filler from an AOD event.
 // Stores all tracks (if a filter is defined, it will store
 // only the ones which survive the cuts).
@@ -214,30 +293,27 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent
 // GEANT label of mother, PDG code of mother, if any).
 // When this is used, the 'source' flag of the output
 // AliRsnEvent object will be set to 'kAOD'.
-//=========================================================
-       
-    // set source flag
-       rsn->SetSource(AliRsnEvent::kAOD);
+//
     
     // retrieve stack (if possible)
-       AliStack *stack = 0x0;
-       if (mc) stack = mc->Stack();
+    AliStack *stack = 0x0;
+    if (mc) stack = mc->Stack();
     
     // get number of tracks
-       Int_t ntracks = aod->GetNTracks();
-       if (!ntracks) {
-          AliWarning("No tracks in this event");
-          return kFALSE;
+    Int_t ntracks = aod->GetNTracks();
+    if (!ntracks) {
+       AliWarning("No tracks in this event");
+       return kFALSE;
     }
-       
-       // get primary vertex
-       Double_t vertex[3];
-       vertex[0] = aod->GetPrimaryVertex()->GetX();
-       vertex[1] = aod->GetPrimaryVertex()->GetY();
-       vertex[2] = aod->GetPrimaryVertex()->GetZ();
-       rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]);
-       
-       // store tracks from ESD
+    
+    // get primary vertex
+    Double_t vertex[3];
+    vertex[0] = aod->GetPrimaryVertex()->GetX();
+    vertex[1] = aod->GetPrimaryVertex()->GetY();
+    vertex[2] = aod->GetPrimaryVertex()->GetZ();
+    rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]);
+    
+    // store tracks from ESD
     Int_t  index, label, labmum;
     Bool_t check;
     AliAODTrack *aodTrack = 0;
@@ -256,11 +332,11 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent
         if (stack) {
             TParticle *part = stack->Particle(TMath::Abs(label));
             if (part) {
-                temp.InitParticle(part);
+                temp.InitMCInfo(part);
                 labmum = part->GetFirstMother();
                 if (labmum >= 0) {
                     TParticle *mum = stack->Particle(labmum);
-                    temp.GetParticle()->SetMotherPDG(mum->GetPdgCode());
+                    temp.GetMCInfo()->SetMotherPDG(mum->GetPdgCode());
                 }
             }
         }
@@ -284,7 +360,7 @@ Bool_t AliRsnReader::FillFromAOD(AliRsnEvent *rsn, AliAODEvent *aod, AliMCEvent
 //_____________________________________________________________________________
 Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc)
 {
-//=========================================================
+//
 // Filler from an ESD event.
 // Stores all tracks which generate at least one 
 // TrackReference (a point in a sensitive volume).
@@ -292,30 +368,27 @@ Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc)
 // perfect particle identification is the unique available.
 // When this is used, the 'source' flag of the output
 // AliRsnEvent object will be set to 'kMC'.
-//=========================================================
-       
-       // set source flag
-       rsn->SetSource(AliRsnEvent::kMC);
-       
-       // get number of tracks
-       Int_t ntracks = mc->GetNumberOfTracks();
-       if (!ntracks) {
-          AliWarning("No tracks in this event");
-          return kFALSE;
+//
+    
+    // get number of tracks
+    Int_t ntracks = mc->GetNumberOfTracks();
+    if (!ntracks) {
+       AliWarning("No tracks in this event");
+       return kFALSE;
     }
     
     AliStack *stack = mc->Stack();
-       
-       // get primary vertex
-       TArrayF fvertex(3);
-       Double_t vertex[3];
-       mc->GenEventHeader()->PrimaryVertex(fvertex);
-       vertex[0] = (Double_t)fvertex[0];
-       vertex[1] = (Double_t)fvertex[1];
-       vertex[2] = (Double_t)fvertex[2];
-       rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]);
-       
-       // store tracks from MC
+    
+    // get primary vertex
+    TArrayF fvertex(3);
+    Double_t vertex[3];
+    mc->GenEventHeader()->PrimaryVertex(fvertex);
+    vertex[0] = (Double_t)fvertex[0];
+    vertex[1] = (Double_t)fvertex[1];
+    vertex[2] = (Double_t)fvertex[2];
+    rsn->SetPrimaryVertex(vertex[0], vertex[1], vertex[2]);
+    
+    // store tracks from MC
     Int_t  index, labmum;
     Bool_t check;
     AliRsnDaughter temp;
@@ -327,10 +400,10 @@ Bool_t AliRsnReader::FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc)
         // try to insert in the RsnDaughter its data
         check = temp.Adopt(mcTrack);
         if (!check) continue;
-        labmum = temp.GetParticle()->Mother();
+        labmum = temp.GetMCInfo()->Mother();
         if (labmum >= 0) {
             TParticle *mum = stack->Particle(labmum);
-            temp.GetParticle()->SetMotherPDG(mum->GetPdgCode());
+            temp.GetMCInfo()->SetMotherPDG(mum->GetPdgCode());
         }
         // if successful, set other data and stores it
         temp.SetIndex(index);
index 1a4ba2f53698a178ad1b9478c0713f77871a3599..ab7d233615b7e70240722c6a5f9e21caea7ec734 100644 (file)
 #ifndef ALIRSNREADER_H
 #define ALIRSNREADER_H
 
+class AliVEvent;
 class AliESDEvent;
 class AliAODEvent;
 class AliMCEvent;
 class AliRsnEvent;
+class AliRsnPIDWeightsMgr;
 
 class AliRsnReader : public TObject
 {
 public:
+
+    enum ESource {
+        kESD = 0,
+        kESDTPC,
+        kAOD,
+        kMC,
+        kSources
+    };
+
+    AliRsnReader(ESource source = kESD, AliRsnPIDWeightsMgr *mgr = 0x0);
+    AliRsnReader(const AliRsnReader& copy);
+    AliRsnReader& operator=(const AliRsnReader& copy);
+    virtual ~AliRsnReader() {}
     
-       AliRsnReader(Bool_t checkSplit = kTRUE, Bool_t rejectFakes = kFALSE);
-       AliRsnReader(const AliRsnReader& copy);
-       AliRsnReader& operator=(const AliRsnReader& copy);
-       virtual ~AliRsnReader() {}
-       
-       void    SetCheckSplit(Bool_t doit = kTRUE) {fCheckSplit = doit;}
-       void    SetRejectFakes(Bool_t doit = kTRUE) {fRejectFakes = doit;}
-       Bool_t  FillFromESD(AliRsnEvent *rsn, AliESDEvent *event, AliMCEvent *refMC = 0);
-    Bool_t  FillFromAOD(AliRsnEvent *rsn, AliAODEvent *event, AliMCEvent *refMC = 0);
-    Bool_t  FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc);
+    void    SetWeightsMgr(AliRsnPIDWeightsMgr *mgr) {fWeightsMgr = mgr;}
+    void    SetCheckSplit(Bool_t doit = kTRUE) {fCheckSplit = doit;}
+    void    SetRejectFakes(Bool_t doit = kTRUE) {fRejectFakes = doit;}
+    
+    Bool_t  Fill(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *refMC = 0);
     
 protected:
 
-    Bool_t  fCheckSplit;  // flag to check and remove split tracks
-    Bool_t  fRejectFakes; // flag to reject fake tracks (negative label)
+    Bool_t  FillFromESD(AliRsnEvent *rsn, AliESDEvent *event, AliMCEvent *refMC = 0, Bool_t useTPCOnly = kFALSE);
+    Bool_t  FillFromAOD(AliRsnEvent *rsn, AliAODEvent *event, AliMCEvent *refMC = 0);
+    Bool_t  FillFromMC(AliRsnEvent *rsn, AliMCEvent *mc);
+
+    ESource              fSource;        // flag to choose what kind of data to be read
+    Bool_t               fCheckSplit;    // flag to check and remove split tracks
+    Bool_t               fRejectFakes;   // flag to reject fake tracks (negative label)
+    AliRsnPIDWeightsMgr *fWeightsMgr;    // manager for alternative PID weights
 
 private:
     
-       ClassDef(AliRsnReader, 1);
+    ClassDef(AliRsnReader, 1);
 };
 
 #endif
similarity index 53%
rename from PWG2/RESONANCES/AliRsnReaderTask.cxx
rename to PWG2/RESONANCES/AliRsnReaderTaskSE.cxx
index 3bfe02325660ee8c1aaa650584fc755700782581..a1b186ec132c0b7d3c9ecbec8542ebc23e66a4dc 100644 (file)
@@ -14,7 +14,7 @@
  **************************************************************************/
 
 //----------------------------------------------------------------------------------
-//  Class AliRsnReaderTask
+//  Class AliRsnReaderTaskSE
 // ------------------------
 // Reader for conversion of ESD output into the internal format
 // used for resonance study.
 #include "AliAODHandler.h"
 
 #include "AliRsnEvent.h"
-#include "AliRsnReaderTask.h"
+#include "AliRsnReader.h"
+#include "AliRsnPID.h"
+#include "AliRsnReaderTaskSE.h"
 
-ClassImp(AliRsnReaderTask)
+ClassImp(AliRsnReaderTaskSE)
 
 //_____________________________________________________________________________
-AliRsnReaderTask::AliRsnReaderTask(ESource source) :
+AliRsnReaderTaskSE::AliRsnReaderTaskSE() :
   AliAnalysisTaskSE(),
-  fSource(source),
   fReader(0x0),
   fPID(0x0),
-  fRsnEvents(0x0)
+  fRsnEvent(0x0)
 {
 //=========================================================
 // Default constructor (not recommended)
@@ -55,25 +56,27 @@ AliRsnReaderTask::AliRsnReaderTask(ESource source) :
 }
 
 //_____________________________________________________________________________
-AliRsnReaderTask::AliRsnReaderTask(const char *name, ESource source) : 
+AliRsnReaderTaskSE::AliRsnReaderTaskSE(const char *name) :
   AliAnalysisTaskSE(name),
-  fSource(source),
   fReader(0x0),
   fPID(0x0),
-  fRsnEvents(0x0)
+  fRsnEvent(0x0)
 {
 //=========================================================
 // Working constructor (recommended)
+// Initializes the reader and PID objects.
 //=========================================================
+
+    fReader = new AliRsnReader;
+    fPID = new AliRsnPID;
 }
 
 //_____________________________________________________________________________
-AliRsnReaderTask::AliRsnReaderTask(const AliRsnReaderTask& obj) :
+AliRsnReaderTaskSE::AliRsnReaderTaskSE(const AliRsnReaderTaskSE& obj) :
   AliAnalysisTaskSE(obj),
-  fSource(obj.fSource),
   fReader(obj.fReader),
   fPID(obj.fPID),
-  fRsnEvents(0x0)
+  fRsnEvent(0x0)
 {
 //=========================================================
 // Copy constructor (not recommended)
@@ -81,7 +84,7 @@ AliRsnReaderTask::AliRsnReaderTask(const AliRsnReaderTask& obj) :
 }
 
 //_____________________________________________________________________________
-AliRsnReaderTask& AliRsnReaderTask::operator=(const AliRsnReaderTask& /*obj*/) 
+AliRsnReaderTaskSE& AliRsnReaderTaskSE::operator=(const AliRsnReaderTaskSE& /*obj*/)
 {
 //=========================================================
 // Assignment operator (not recommended)
@@ -92,20 +95,37 @@ AliRsnReaderTask& AliRsnReaderTask::operator=(const AliRsnReaderTask& /*obj*/)
 }
 
 //_____________________________________________________________________________
-void AliRsnReaderTask::UserCreateOutputObjects()
+void AliRsnReaderTaskSE::UserCreateOutputObjects()
 {
 //=========================================================
 // Create the output container
 //=========================================================
 
     AliDebug(1, "Creating USER output objects");
-    fRsnEvents = new TClonesArray("AliRsnEvent", 0);
-    fRsnEvents->SetName("AliRsnEvents");
-    AddAODBranch("TClonesArray", fRsnEvents);
+
+    // check for existence of reader, otherwise abort
+    if (!fReader) {
+        AliFatal("Event reader not initialized. Impossible to continue");
+        return;
+    }
+    if (!fPID) {
+        AliFatal("PID manager not initialized. Impossible to continue");
+        return;
+    }
+    else {
+        // the PID object is always used in realistic mode here
+        // to fill the "realistic" index array in AliRsnEvent
+        fPID->SetMethod(AliRsnPID::kRealistic);
+    }
+
+    fRsnEvent = new AliRsnEvent();
+    fRsnEvent->SetName("rsnEvents");
+    fRsnEvent->Init();
+    AddAODBranch("AliRsnEvent", &fRsnEvent);
 }
 
 //_____________________________________________________________________________
-void AliRsnReaderTask::Init()
+void AliRsnReaderTaskSE::Init()
 {
 //=========================================================
 // Initialization
@@ -115,7 +135,7 @@ void AliRsnReaderTask::Init()
 }
 
 //_____________________________________________________________________________
-void AliRsnReaderTask::UserExec(Option_t */*option*/)
+void AliRsnReaderTaskSE::UserExec(Option_t */*option*/)
 {
 //=========================================================
 // Loops on input container to store data of all tracks.
@@ -123,96 +143,19 @@ void AliRsnReaderTask::UserExec(Option_t */*option*/)
 //=========================================================
 
     // static counter
-    static Int_t ientry = 0;
-    AliInfo(Form("Reading event %d", ++ientry));
-    
+    AliInfo(Form("Reading event %d", ++fEntry));
+
     // clear previous sample
-    fRsnEvents->Clear();
-    
-    // check for existence of reader, otherwise abort
-    if (!fReader) {
-        AliError("Event reader not initialized. Impossible to continue");
-        return;
-    }
-    if (!fPID) {
-        AliError("PID manager not initialized. Impossible to continue");
-        return;
-    }
-    
-
-       // get MC reference event
-       AliMCEventHandler* mcHandler = (AliMCEventHandler*)((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
-       AliMCEvent *mcEvent = 0x0;
-       if (mcHandler) mcEvent = mcHandler->MCEvent();
-       
-       // work-flow variables
-       Bool_t successRead;
-       Int_t  nextIndex = fRsnEvents->GetEntries();
-       TClonesArray &array = *fRsnEvents;
-    AliRsnEvent *event = new(array[nextIndex]) AliRsnEvent;
-    if (!event) {
-        AliError("Problem occurred while creating new AliRsnEvent object. Aborting");
-        return;
-    }
-    event->Init();
-    AliESDInputHandler *handlerESD;
-    AliAODInputHandler *handlerAOD;
-    AliESDEvent *esd;
-    AliAODEvent *aod;
-       
-       // read source event according to reader settings
-       switch (fSource) {
-        case kESD:  // read from ESD event
-            handlerESD = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-            if (!handlerESD) {
-                AliError("Source set to 'ESD' but ESD handler not initialized");
-                return;
-            }
-            esd = handlerESD->GetEvent();
-            if (!esd) {
-                AliError("Source set to 'ESD' but ESD event not found in handler");
-                return;
-            }
-            if (!mcEvent) AliWarning("MC info not present");
-            successRead = fReader->FillFromESD(event, esd, mcEvent);
-            break;
-        case kAOD:  // read from AOD event
-            handlerAOD = dynamic_cast<AliAODInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-            if (!handlerAOD) {
-                AliError("Source set to 'AOD' but AOD handler not initialized");
-                return;
-            }
-            aod = handlerAOD->GetEvent();
-            if (!aod) {
-                AliError("Source set to 'AOD' but AOD event not found in handler");
-                return;
-            }
-            if (!mcEvent) AliWarning("MC info not present");
-            successRead = fReader->FillFromAOD(event, aod, mcEvent);
-            break;
-        case kMC: // read from MC truth only
-            if (!mcEvent) {
-                AliError("Required usage of MC event for reading. Not possible without MC info. Impossible to continue");
-                return;
-            }
-            successRead = fReader->FillFromMC(event, mcEvent);
-            break;
-        default: // unrecognized option
-            AliError("Source flag not properly set");
-            return;
-    }
-    if (!successRead) {
-        array.RemoveAt(nextIndex);
-        return;
-    }
-    
-    // if the event reading is successful, perform particle identification
-    if (!fPID->Identify(event)) AliWarning(Form("Failed PID for event %d", ientry));
-    AliInfo(Form("Event %d: collected %d tracks", ientry, event->GetMultiplicity()));
+    fRsnEvent->Clear();
+
+    // read event, identify
+    if (!fReader->Fill(fRsnEvent, fInputEvent, fMCEvent)) AliWarning("Failed reading");
+    if (!fPID->Identify(fRsnEvent)) AliWarning("Failed PID");
+    AliInfo(Form("Collected %d tracks", fRsnEvent->GetMultiplicity()));
 }
 
 //_____________________________________________________________________________
-void AliRsnReaderTask::Terminate(Option_t */*option*/)
+void AliRsnReaderTaskSE::Terminate(Option_t */*option*/)
 {
 //=========================================================
 // Terminate analysis
similarity index 60%
rename from PWG2/RESONANCES/AliRsnReaderTask.h
rename to PWG2/RESONANCES/AliRsnReaderTaskSE.h
index 7d8fb8f5f519fb887be1a3228af71267f58cd0ff..3821fe160cae324d8ca4690c546a8e46f2d169ba 100644 (file)
@@ -4,7 +4,7 @@
  **************************************************************************/
 
 //----------------------------------------------------------------------------------
-//  Class AliRsnReaderTask
+//  Class AliRsnReaderTaskSE
 // ------------------------
 // Reader for conversion of ESD output into the internal format
 // used for resonance study.
 // by    : R. Vernet                          (email: renaud.vernet@cern.ch)
 //----------------------------------------------------------------------------------
 
-#ifndef ALIRSNREADERTASK_H
-#define ALIRSNREADERTASK_H
+#ifndef AliRsnReaderTaskSE_H
+#define AliRsnReaderTaskSE_H
 
 #include "AliAnalysisTaskSE.h"
-#include "AliRsnReader.h"
-#include "AliRsnPID.h"
+//#include "AliRsnReader.h"
+//#include "AliRsnPID.h"
 
-class TTree;
-class TBranch;
 class AliESDEvent;
+class AliRsnPID;
+class AliRsnReader;
 
-class AliRsnReaderTask : public AliAnalysisTaskSE
+class AliRsnReaderTaskSE : public AliAnalysisTaskSE
 {
 public:
 
-    enum ESource {
-        kESD = 0,
-        kAOD,
-        kMC
-    };
-
-    AliRsnReaderTask(ESource source = kESD);
-       AliRsnReaderTask(const char *name, ESource source = kESD);
-       virtual ~AliRsnReaderTask() {Clear();}
+    AliRsnReaderTaskSE();
+       AliRsnReaderTaskSE(const char *name);
+       virtual ~AliRsnReaderTaskSE() {Clear();}
 
     // Implementation of interface methods
     virtual void UserCreateOutputObjects();
@@ -46,28 +40,25 @@ public:
     virtual void LocalInit() {Init();}
     virtual void UserExec(Option_t *option);
     virtual void Terminate(Option_t *option);
-       
+
        // setters
        void SetReader(AliRsnReader *reader) {fReader = reader;}
        void SetPID(AliRsnPID *pid) {fPID = pid;}
-       void SetSource(ESource source) {fSource = source;}
-       
+
        // getters
        AliRsnReader* GetReader() {return fReader;}
        AliRsnPID*    GetPID() {return fPID;}
 
 private:
 
-    AliRsnReaderTask(const AliRsnReaderTask&);
-       AliRsnReaderTask& operator=(const AliRsnReaderTask&);
-       
-       ESource fSource;   // source of data
-       
-       AliRsnReader* fReader;     // read manager
-       AliRsnPID*    fPID;        // particle identification manager
-       TClonesArray* fRsnEvents;  // output events in the AliRsnEvent format
-       
-       ClassDef(AliRsnReaderTask, 0); // implementation of RsnReader as AnalysisTaskSE
+    AliRsnReaderTaskSE(const AliRsnReaderTaskSE&);
+       AliRsnReaderTaskSE& operator=(const AliRsnReaderTaskSE&);
+
+       AliRsnReader *fReader;     // read manager
+       AliRsnPID    *fPID;        // particle identification manager
+       AliRsnEvent  *fRsnEvent;   // output events in the AliRsnEvent format
+
+       ClassDef(AliRsnReaderTaskSE, 0); // implementation of RsnReader as AnalysisTaskSE
 };
 
 #endif