+++ /dev/null
-/**************************************************************************
- * 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();
-}
+++ /dev/null
-/**************************************************************************
- * 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 ©) :
- 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
+++ /dev/null
-/**************************************************************************
- * 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();
-}
+++ /dev/null
-/**************************************************************************
- * 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
+++ /dev/null
-/**************************************************************************
- * 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;
-}
+++ /dev/null
-/**************************************************************************
- * 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 ©) :
- 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
-/**************************************************************************
- * 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 [--> MatchesValue() ]
+// - a value contained in a given interval [--> IsBetween() ]
+// - a value equal to a given reference [--> MatchesValue()]
+//
// 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
//
// authors: Martin Vala (martin.vala@cern.ch)
// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//=========================================================================
+//
#include "AliLog.h"
#include "AliRsnMCInfo.h"
#include "AliRsnPairParticle.h"
#include "AliRsnPairDef.h"
+#include "AliRsnEvent.h"
#include "AliRsnCut.h"
const Double_t AliRsnCut::fgkDSmallNumber = 1e-100;
fIMax( fgkIBigNumber),
fUIMin(0),
fUIMax(2 * (UInt_t)fgkIBigNumber),
- fRsnCutType (kLastCutType),
- fRsnCutVarType (kDouble_t)
+ fType (kLastCutType),
+ fVarType (kDouble_t)
{
//
// Constructor
}
//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char *name, const char *title, ERsnCutType type) :
+AliRsnCut::AliRsnCut (const char *name, const char *title, EType type) :
TNamed (name,title),
fDMin(-fgkDBigNumber),
fDMax( fgkDBigNumber),
fIMax( fgkIBigNumber),
fUIMin(0),
fUIMax(2 * (UInt_t)fgkIBigNumber),
- fRsnCutType (type),
- fRsnCutVarType (kDouble_t)
+ fType (type),
+ fVarType (kDouble_t)
{
//
// Constructor with arguments but not limits
}
//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char *name, const char *title, ERsnCutType type, Double_t min, Double_t max) :
+AliRsnCut::AliRsnCut (const char *name, const char *title, EType type, Double_t min, Double_t max) :
TNamed (name,title),
fDMin(min),
fDMax(max),
fIMax( fgkIBigNumber),
fUIMin(0),
fUIMax(2 * (UInt_t)fgkIBigNumber),
- fRsnCutType (type),
- fRsnCutVarType (kDouble_t)
+ fType (type),
+ fVarType (kDouble_t)
{
//
// Constructor with arguments and limits
}
//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char * name, const char * title, ERsnCutType type, Int_t min, Int_t max) :
+AliRsnCut::AliRsnCut (const char * name, const char * title, EType type, Int_t min, Int_t max) :
TNamed (name,title),
fDMin(-fgkDBigNumber),
fDMax( fgkDBigNumber),
fIMax(max),
fUIMin(0),
fUIMax(2 * (UInt_t)fgkIBigNumber),
- fRsnCutType (type),
- fRsnCutVarType (kInt_t)
+ fType (type),
+ fVarType (kInt_t)
{
//
// Constructor with arguments and limits
}
//________________________________________________________________________________________________________________
-AliRsnCut::AliRsnCut (const char * name, const char * title, ERsnCutType type, UInt_t min, UInt_t max) :
+AliRsnCut::AliRsnCut (const char * name, const char * title, EType type, UInt_t min, UInt_t max) :
TNamed (name,title),
fDMin(-fgkDBigNumber),
fDMax( fgkDBigNumber),
fIMax( fgkIBigNumber),
fUIMin(min),
fUIMax(max),
- fRsnCutType (type),
- fRsnCutVarType (kUInt_t)
+ fType (type),
+ fVarType (kUInt_t)
{
//
// Constructor with arguments and limits
}
//________________________________________________________________________________________________________________
-AliRsnCut::~ AliRsnCut()
+AliRsnCut::~AliRsnCut()
{
//
// Destructor.
}
//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsBetween (const Double_t & theValue)
+Bool_t AliRsnCut::IsBetween (const Double_t &theValue)
{
//
// Interval check.
return ((theValue >= fDMin) && (theValue <= fDMax));
}
+//________________________________________________________________________________________________________________
+Bool_t AliRsnCut::IsBetween (const Int_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 >= fIMin) && (theValue <= fIMax));
+}
+
//________________________________________________________________________________________________________________
Bool_t AliRsnCut::MatchesValue (const Int_t &theValue)
{
}
//________________________________________________________________________________________________________________
-void AliRsnCut::SetCutValues (ERsnCutType type, const Double_t & theValue, const Double_t & theValue2)
+void AliRsnCut::SetCutValues (EType type, const Double_t &theValue, const Double_t &theValue2)
{
//
// (Re)assignment of cut values
//
- fRsnCutType = type;
+ fType = type;
fDMin = theValue;
fDMax = theValue2;
}
//________________________________________________________________________________________________________________
-void AliRsnCut::SetCutValues (ERsnCutType type, const Int_t& theValue, const Int_t& theValue2)
+void AliRsnCut::SetCutValues (EType type, const Int_t &theValue, const Int_t &theValue2)
{
//
// (Re)assignment of cut values
//
- fRsnCutType = type;
+ fType = type;
fIMin = theValue;
fIMax = theValue2;
}
//________________________________________________________________________________________________________________
-void AliRsnCut::SetCutValues (ERsnCutType type, const UInt_t& theValue, const UInt_t& theValue2)
+void AliRsnCut::SetCutValues (EType type, const UInt_t &theValue, const UInt_t &theValue2)
{
//
// (Re)assignment of cut values
//
- fRsnCutType = type;
+ fType = type;
fUIMin = theValue;
fUIMax = theValue2;
}
//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ECutSetType type, AliRsnDaughter *daughter)
+Bool_t AliRsnCut::IsSelected(ETarget type, AliRsnDaughter *daughter)
{
//
// Core of the whole class.
AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnDaughter)", type, kParticle, daughter->ClassName()));
return kTRUE;
}
+
+ // utility variables
+ AliRsnPID::EType pidType;
+ Double_t prob;
- switch (fRsnCutType) {
+ switch (fType) {
case kMomentum:
return IsBetween (daughter->P());
case kTransMomentum:
case kEta:
return IsBetween (daughter->Eta());
case kRadialImpactParam:
- return IsBetween (daughter->Vt());
+ return IsBetween (daughter->Dr());
case kMomentumMC:
if (mcinfo) return IsBetween (mcinfo->P());
else return kTRUE;
case kChargeNeg:
return (daughter->Charge() < 0);
case kPIDType:
- return MatchesValue((Int_t)daughter->PIDType());
+ case kPIDProb:
+ pidType = daughter->PIDType(prob);
+ if (fType == kPIDType) return MatchesValue((Int_t)pidType);
+ if (fType == kPIDProb) return IsBetween(prob);
/*
case kEtaMC:
if (mcinfo) return IsBetween (mcinfo->Eta());
}
//________________________________________________________________________________________________________________
-Bool_t AliRsnCut::IsSelected(ECutSetType type, AliRsnPairParticle * pair)
+Bool_t AliRsnCut::IsSelected(ETarget type, AliRsnPairParticle * pair)
{
AliDebug (AliLog::kDebug, "<-");
return kTRUE;
}
- switch (fRsnCutType) {
+ switch (fType) {
case kMomentum:
return IsBetween (pair->GetP());
case kTransMomentum:
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:
}
//________________________________________________________________________________________________________________
-void AliRsnCut::PrintAllValues()
+Bool_t AliRsnCut::IsSelected(ETarget type, AliRsnEvent * event)
{
- 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);
+ AliDebug (AliLog::kDebug, "<-");
- p1restP = gamma*p1labP - beta*gamma*pair->GetDaughter(0)->E();
+ // check type
+ if (type != kEvent) {
+ AliWarning(Form("Mismatch: type = %d (expected %d), class type = %s (expected AliRsnEvent)", type, kEvent, event->ClassName()));
+ return kTRUE;
+ }
- p1restTot = TMath::Sqrt(p1restP*p1restP + p1labT*p1labT);
+ switch (fType) {
+ case kMultiplicity:
+ return IsBetween ((Int_t)event->GetMultiplicity());
+ default:
+ AliWarning("Requested a cut which cannot be applied to an event");
+ return kTRUE;
+ }
- return IsBetween(p1restTot);
+ return kTRUE;
}
-
-
+//________________________________________________________________________________________________________________
+void AliRsnCut::PrintAllValues()
+{
+ AliInfo (Form ("fType=%d fVarType=%d",fType,fVarType));
+ AliInfo (Form ("fDMin=%.2e fDMax=%.2e",fDMin,fDMax));
+ AliInfo (Form ("fIMin=%d fIMax=%d",fIMin,fIMax));
+ AliInfo (Form ("fUIMin=%d fUIMax=%d",fUIMin,fUIMax));
+}
-/**************************************************************************
- * 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:
//
// authors: Martin Vala (martin.vala@cern.ch)
// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
-//=========================================================================
+//
#ifndef ALIRSNCUT_H
#define ALIRSNCUT_H
class AliRsnDaughter;
class AliRsnPairParticle;
class AliRsnPairDef;
+class AliRsnEvent;
class AliRsnCut : public TNamed
{
public:
- enum ERsnCutType
+
+ // available cut types
+ // some ones work both for pairs and single tracks
+ enum EType
{
kMomentum = 0,
kTransMomentum,
kMomentumMC,
kTransMomentumMC,
kEtaMC,
- kRestMomentum,
kNSigma,
kNSigmaCalculate,
kStatus,
- kIsPdgEqual,
kIsLabelEqual,
kIsTruePair,
kChargePos,
kChargeNeg,
kPIDType,
+ kPIDProb,
+ kMultiplicity,
kLastCutType
};
- enum ERsnCutVarType
+ // types of cut variables
+ enum EVarType
{
kDouble_t = 0,
kInt_t,
kUInt_t
};
- enum ECutSetType
+ // possible targets for a cut
+ enum ETarget
{
kParticle = 0,
kPair,
+ kEvent,
kMixEventFinderCut,
- kLastCutSetIndex
+ kLastCutTarget
};
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 (const char *name, const char *title, EType type);
+ AliRsnCut (const char *name, const char *title, EType type, Double_t min, Double_t max = 1e-100);
+ AliRsnCut (const char *name, const char *title, EType type, Int_t min, Int_t max = 32767);
+ AliRsnCut (const char *name, const char *title, EType 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);
+ void SetCutValues (EType type, const Double_t& theValue, const Double_t& theValue2);
+ void SetCutValues (EType type, const Int_t& theValue, const Int_t& theValue2);
+ void SetCutValues (EType type, const UInt_t& theValue, const UInt_t& theValue2);
- Bool_t IsSelected (ECutSetType type, AliRsnDaughter *daughter);
- Bool_t IsSelected (ECutSetType type, AliRsnPairParticle *pair);
+ Bool_t IsSelected (ETarget tgt, AliRsnDaughter *daughter);
+ Bool_t IsSelected (ETarget tgt, AliRsnPairParticle *pair);
+ Bool_t IsSelected (ETarget tgt, AliRsnEvent *event);
void PrintAllValues();
Bool_t IsBetween (const Double_t &theValue);
+ Bool_t IsBetween (const Int_t &theValue);
Bool_t MatchesValue (const Int_t &theValue);
Bool_t MatchesValue (const UInt_t &theValue);
Bool_t MatchesValue (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
UInt_t fUIMin; // min. uint value
UInt_t fUIMax; // max. uint value
- ERsnCutType fRsnCutType; // cut type
- ERsnCutVarType fRsnCutVarType; // variable type
+ EType fType; // cut type
+ EVarType fVarType; // variable type
static const Double_t fgkDSmallNumber; // small double value
static const Double_t fgkDBigNumber; // big double value
+//
+// Class AliRsnCutMgr
+//
+// The cut manager: contains a complete set of cut definitions
+// to be applied to all possible targets (one for each target),
+// in order to ease the set-up procedure of cuts and allow to
+// pass them at once to each object which must use them
+//
+// author: Martin Vala (martin.vala@cern.ch)
+//
+
#include "AliLog.h"
#include "AliRsnDaughter.h"
+#include "AliRsnEvent.h"
#include "AliRsnCutSet.h"
#include "AliRsnCutMgr.h"
-ClassImp ( AliRsnCutMgr )
+ClassImp (AliRsnCutMgr)
-AliRsnCutMgr::AliRsnCutMgr()
- : TNamed("defaultName","default Tilte")
+//_____________________________________________________________________________
+AliRsnCutMgr::AliRsnCutMgr() :
+ TNamed("defaultName", "defaultTitle")
{
- for ( Int_t i=0 ;i<AliRsnCut::kLastCutSetIndex ;i++ )
- {
- fCutSets[i] = 0;
- }
+//
+// Constructor without arguments.
+//
+ Int_t i;
+ for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
+ fCutSets[i] = 0;
+ }
}
-AliRsnCutMgr::AliRsnCutMgr ( const char * name, const char * title )
- : TNamed ( name,title )
+//_____________________________________________________________________________
+AliRsnCutMgr::AliRsnCutMgr (const char *name, const char *title) :
+ TNamed (name, title)
{
+//
+// Constructor with name and title.
+//
- for ( Int_t i=0 ;i<AliRsnCut::kLastCutSetIndex ;i++ )
- {
- fCutSets[i] = 0 ;
- }
-
+ Int_t i;
+ for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
+ fCutSets[i] = 0;
+ }
}
+//_____________________________________________________________________________
AliRsnCutMgr::~AliRsnCutMgr()
{
- for ( Int_t i=0 ;i<AliRsnCut::kLastCutSetIndex ;i++ )
- {
- delete fCutSets[i];
- }
+//
+// Destructor.
+// Deletes all cut definitions.
+//
+ Int_t i;
+ for (i = 0; i < AliRsnCut::kLastCutTarget; i++) {
+ delete fCutSets[i];
+ }
}
-void AliRsnCutMgr::SetCutSet ( AliRsnCut::ECutSetType type, AliRsnCutSet* cutset )
+//_____________________________________________________________________________
+void AliRsnCutMgr::SetCutSet (AliRsnCut::ETarget type, AliRsnCutSet* cutset)
{
- if ( !fCutSets[type] )
- fCutSets[type] = ( AliRsnCutSet* ) cutset->Clone() ;
- AliDebug (AliLog::kDebug ,Form ( "DatasetName %s",fCutSets[type]->GetName() ) );
-}
+//
+// Assign a cut set to a given target
+//
+ 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 )
+//_____________________________________________________________________________
+Bool_t AliRsnCutMgr::IsSelected ( AliRsnCut::ETarget 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;
+//
+// Check if a given object passes the cuts defined for it.
+// The target of the check is here a TObject, in order to allo generality
+// but then the kind of cut to be used is defined as first argument, and
+// in the single cut it will be checked if it is appropriate for passed target
+//
- }
- return kTRUE;
+ AliDebug (AliLog::kDebug, "<-");
+ if (!fCutSets[type]) return kTRUE;
+
+ switch (type) {
+ case AliRsnCut::kParticle:
+ return fCutSets[type]->IsSelected (type, (AliRsnDaughter*)obj);
+ break;
+ case AliRsnCut::kPair:
+ return fCutSets[type]->IsSelected (type, (AliRsnPairParticle*)obj);
+ break;
+ case AliRsnCut::kEvent:
+ return fCutSets[type]->IsSelected (type, (AliRsnEvent*)obj);
+ break;
+ default:
+ AliWarning ("Wrong target selected.");
+ return kTRUE;
+ break;
+ }
+
+ return kTRUE;
}
-#ifndef ALIRSNMVCUTMGR_H
-#define ALIRSNMVCUTMGR_H
+//
+// Class AliRsnCutMgr
+//
+// The cut manager: contains a complete set of cut definitions
+// to be applied to all possible targets (one for each target),
+// in order to ease the set-up procedure of cuts and allow to
+// pass them at once to each object which must use them
+//
+// author: Martin Vala (martin.vala@cern.ch)
+//
+
+#ifndef ALIRSNCUTMGR_H
+#define ALIRSNCUTMGR_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);
+ void SetCutSet(AliRsnCut::ETarget type, AliRsnCutSet* cutset);
+ AliRsnCutSet* GetCutSet(AliRsnCut::ETarget type) {return fCutSets[type];}
+ Bool_t IsSelected(AliRsnCut::ETarget type, TObject *obj);
private:
- AliRsnCutMgr(const AliRsnCutMgr &cut):TNamed(cut) {}
+ // dummy constructors
+ AliRsnCutMgr(const AliRsnCutMgr &cut) : TNamed(cut) {}
AliRsnCutMgr& operator=(const AliRsnCutMgr& /*cut*/) {return *this;}
- AliRsnCutSet *fCutSets[AliRsnCut::kLastCutSetIndex];
+ AliRsnCutSet *fCutSets[AliRsnCut::kLastCutTarget]; // cut definitions for all targets
- ClassDef ( AliRsnCutMgr,1 );
+ ClassDef (AliRsnCutMgr, 1); // dictionary
};
#endif
#include "AliRsnCutSet.h"
-ClassImp ( AliRsnCutSet )
-
-AliRsnCutSet::AliRsnCutSet()
- : TNamed(),fCuts(0),fNumOfCuts ( 0 ),
- fCutScheme ( "" ),
- fCutSchemeIndexed ( "" ),
- fBoolValues ( 0 ),fIsScheme ( kFALSE ),fExpression(0)
+ClassImp (AliRsnCutSet)
+
+//_____________________________________________________________________________
+AliRsnCutSet::AliRsnCutSet() :
+ TNamed(),
+ fCuts(0),
+ fNumOfCuts(0),
+ fCutScheme (""),
+ fCutSchemeIndexed (""),
+ fBoolValues (0),
+ fIsScheme (kFALSE),
+ fExpression(0)
{
- fBoolValues = new Bool_t[1];
-// fExpression = new AliRsnExpression ( fCutSchemeIndexed );
- AliRsnExpression::sCutSet = this;
+//
+// Constructor without name (not recommended)
+//
+
+ fBoolValues = new Bool_t[1];
+ AliRsnExpression::sCutSet = this;
}
-AliRsnCutSet::AliRsnCutSet ( TString name )
- : TNamed ( name,name ),fCuts(0),fNumOfCuts ( 0 ),
- fCutScheme ( "" ),
- fCutSchemeIndexed ( "" ),
- fBoolValues ( 0 ),fIsScheme ( kFALSE ),fExpression(0)
+//_____________________________________________________________________________
+AliRsnCutSet::AliRsnCutSet (TString name) :
+ TNamed (name, name),
+ fCuts(0),
+ fNumOfCuts(0),
+ fCutScheme (""),
+ fCutSchemeIndexed (""),
+ fBoolValues (0),
+ fIsScheme (kFALSE),
+ fExpression(0)
{
- fBoolValues = new Bool_t[1];
- fExpression = 0;
- AliRsnExpression::sCutSet = this;
+//
+// Constructor with argument name (recommended)
+//
+
+ 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 ),
- fBoolValues(0),
- fIsScheme ( copy.fIsScheme ),
- fExpression ( copy.fExpression )
+//_____________________________________________________________________________
+AliRsnCutSet::AliRsnCutSet (const AliRsnCutSet & copy) :
+ TNamed ((TNamed) copy),
+ fCuts(copy.fCuts),
+ fNumOfCuts(copy.fNumOfCuts),
+ fCutScheme(copy.fCutScheme),
+ fCutSchemeIndexed (copy.fCutSchemeIndexed),
+ fBoolValues(0),
+ fIsScheme(copy.fIsScheme),
+ fExpression(copy.fExpression)
{
- AliRsnExpression::sCutSet = this;
+//
+// Copy constructor
+//
+
+ AliRsnExpression::sCutSet = this;
}
+//_____________________________________________________________________________
AliRsnCutSet::~AliRsnCutSet()
{
- delete fExpression;
- delete [] fBoolValues;
+//
+// Destructor
+//
+
+ delete fExpression;
+ delete [] fBoolValues;
}
-void AliRsnCutSet::AddCut ( AliRsnCut * cut )
+//_____________________________________________________________________________
+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;
- }
+//
+// Add a new cut.
+// This must be done for all components of the final expression
+//
- AliDebug ( AliLog::kDebug,Form ( "%d",fCuts.GetEntriesFast() ) );
- AliDebug ( AliLog::kDebug,"->" );
+ Int_t i;
+
+ AliDebug (AliLog::kDebug,"<-");
+ fCuts.Add (cut);
+ fNumOfCuts++;
+
+ if (fBoolValues) delete fBoolValues;
+
+ fBoolValues = new Bool_t[fNumOfCuts];
+ for (i = 0; i < fNumOfCuts; i++) {
+ fBoolValues[i] = kTRUE;
+ }
+
+ AliDebug (AliLog::kDebug,Form ("%d",fCuts.GetEntriesFast()));
+ AliDebug (AliLog::kDebug,"->");
}
-void AliRsnCutSet::ShowCuts ( )
+//_____________________________________________________________________________
+void AliRsnCutSet::ShowCuts ()
{
+//
+// Prints all cuts
+//
// AliRsnCut *cut;
-// for ( Int_t i=0; i<fCuts.GetEntriesFast() ;i++ )
+// 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() ) );
+// 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 )
+//_____________________________________________________________________________
+Bool_t AliRsnCutSet::IsSelected (AliRsnCut::ETarget 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();
+//
+// Checks an object according to the cut expression defined here.
+//
- return boolReturn;
+ Int_t i;
+
+ if (!fNumOfCuts) return kTRUE;
+
+ Bool_t boolReturn = kTRUE;
+ AliRsnCut *cut;
+ for (i = 0; i < fNumOfCuts; i++) {
+ cut = (AliRsnCut*)fCuts.At(i);
+ fBoolValues[i] = cut->IsSelected (type,daughter);
+ }
+
+ if (fIsScheme) boolReturn = Passed();
+ return boolReturn;
}
-Bool_t AliRsnCutSet::IsSelected ( AliRsnCut::ECutSetType type, AliRsnPairParticle * pair )
+//_____________________________________________________________________________
+Bool_t AliRsnCutSet::IsSelected (AliRsnCut::ETarget type, AliRsnPairParticle * pair)
{
- if ( !fNumOfCuts )
- return kTRUE;
+//
+// Checks an object according to the cut expression defined here.
+//
- 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]));
- }
+ Int_t i;
+
+ if (!fNumOfCuts) return kTRUE;
+
+ Bool_t boolReturn = kTRUE;
+ AliRsnCut *cut;
+ for (i = 0; i < fNumOfCuts; i++) {
+ cut = (AliRsnCut*) fCuts.At (i);
+ fBoolValues[i] = cut->IsSelected (type,pair);
+ }
+
+ if (fIsScheme) boolReturn = Passed();
+ return boolReturn;
+}
- if ( fIsScheme )
- boolReturn = Passed();
+//_____________________________________________________________________________
+Bool_t AliRsnCutSet::IsSelected (AliRsnCut::ETarget type, AliRsnEvent * event)
+{
+//
+// Checks an object according to the cut expression defined here.
+//
- return boolReturn;
+ Int_t i;
+ if (!fNumOfCuts) return kTRUE;
+
+ Bool_t boolReturn = kTRUE;
+ AliRsnCut *cut;
+ for (i = 0; i < fNumOfCuts; i++) {
+ cut = (AliRsnCut*) fCuts.At (i);
+ fBoolValues[i] = cut->IsSelected (type,event);
+ }
+
+ if (fIsScheme) boolReturn = Passed();
+ return boolReturn;
}
-
-void AliRsnCutSet::SetCutScheme ( const TString & theValue )
+//_____________________________________________________________________________
+void AliRsnCutSet::SetCutScheme (const TString & theValue)
{
- AliDebug ( AliLog::kDebug,"<-" );
- fCutScheme = theValue;
- SetCutSchemeIndexed ( theValue );
- fIsScheme = kTRUE;
- AliDebug ( AliLog::kDebug,"->" );
-}
+//
+// Define the combination of cuts with logical operators
+// and using the names given to all defined cuts.
+//
+ AliDebug (AliLog::kDebug,"<-");
+ fCutScheme = theValue;
+ SetCutSchemeIndexed (theValue);
+ fIsScheme = kTRUE;
+ AliDebug (AliLog::kDebug,"->");
+}
-void AliRsnCutSet::SetCutSchemeIndexed ( TString theValue )
+//_____________________________________________________________________________
+void AliRsnCutSet::SetCutSchemeIndexed (TString theValue)
{
- AliDebug ( AliLog::kDebug,"<-" );
- theValue.Append(" ");
-// fCutSchemeIndexed = theValue;
- fCutSchemeIndexed = GetCutSchemeIndexed();
- AliDebug ( AliLog::kDebug,"->" );
+//
+// Internal method which indexes all cuts to organize their combo
+//
+
+ AliDebug (AliLog::kDebug,"<-");
+ theValue.Append(" ");
+ // fCutSchemeIndexed = theValue;
+ fCutSchemeIndexed = GetCutSchemeIndexed();
+ AliDebug (AliLog::kDebug,"->");
}
-Int_t AliRsnCutSet::GetIndexByCutName ( TString s )
+//_____________________________________________________________________________
+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;
- }
- }
+//
+// Retrieve the cut index from its name
+//
- return -1;
+ Int_t i;
+ AliRsnCut *cut;
+
+ for (i = 0; i < fCuts.GetEntriesFast(); i++) {
+ cut = (AliRsnCut*) fCuts.At (i);
+ 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() );
+//
+// Combines the cuts according to expression
+// and gives a global response to the cut check
+//
+
+ 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" ) ) );
+//
+// Validity check on cut expression specified by user
+//
+
+ return (! (ShowCutScheme().Contains ("Error")));
}
+//_____________________________________________________________________________
TString AliRsnCutSet::ShowCutScheme()
{
- return fExpression->Unparse();
+//
+// Utility method to check validity of expression
+//
+ return fExpression->Unparse();
}
-Int_t AliRsnCutSet::TestExpression ( TString opt )
+//_____________________________________________________________________________
+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 );
+
+// 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 );
+// AliRsnCutSet* set = new AliRsnCutSet ("setOne");
+// set->AddCut (cut1);
+// set->AddCut (cut2);
+// set->AddCut (cut3);
//
-// set->SetCutScheme ( "(aaa&!(ccc))&(bbb&!(ccc))" );
+// set->SetCutScheme ("(aaa&!(ccc))&(bbb&!(ccc))");
//
// set->ShowCuts ();
- AliDebug(1, opt.Data());
- return 0;
+ AliDebug(1, opt.Data());
+ return 0;
}
+//_____________________________________________________________________________
void AliRsnCutSet::PrintSetInfo()
{
+//
+// Show data about the cut set
+//
-
- 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 ==============" );
-
+ Int_t i;
+
+ 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 (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;
-}
+//
+// Internal method to retrieve the list of cuts with their indexes
+// for evaluation of cut expression
+//
+ AliDebug (AliLog::kDebug,"<-");
+ Int_t i;
+ TString str (fCutScheme);
+ AliDebug (AliLog::kDebug,Form ("Num of cuts %d",fCuts.GetEntriesFast()));
+ AliRsnCut *cut;
+ for (i = 0; i < fCuts.GetEntriesFast(); i++) {
+ cut = (AliRsnCut*) fCuts.At (i);
+ str.ReplaceAll (cut->GetName(),Form ("%d",i));
+ }
+ AliDebug (AliLog::kDebug,"->");
+ return str;
+}
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice *
+ **************************************************************************/
+
+//
+// class AliRsnCutSet
+// Combination of simple cuts
+//
+
#ifndef ALIRSNCUTSET_H
#define ALIRSNCUTSET_H
#include <TObjArray.h>
#include "AliRsnCut.h"
-// class AliRsnCut;
-class AliRsnCutMgr;
class AliRsnDaughter;
class AliRsnExpression;
class AliRsnPairParticle;
+class AliRsnEvent;
class AliRsnCutSet : public TNamed
{
+public:
- public:
AliRsnCutSet();
- AliRsnCutSet ( TString name );
- AliRsnCutSet ( const AliRsnCutSet © );
-
+ AliRsnCutSet (TString name);
+ AliRsnCutSet (const AliRsnCutSet ©);
~AliRsnCutSet();
- void AddCut ( AliRsnCut* cut );
-// void SetCutScheme ( TString sheme ) {fCutScheme = sheme;}
+ void AddCut (AliRsnCut* cut);
void ShowCuts();
- Int_t GetIndexByCutName ( TString s );
+ Int_t GetIndexByCutName (TString s);
Bool_t Passed();
Bool_t IsValidScheme();
TString ShowCutScheme();
- Int_t TestExpression ( TString opt="short" );
+ 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);
+ Bool_t IsSelected (AliRsnCut::ETarget type, AliRsnDaughter *daughter);
+ Bool_t IsSelected (AliRsnCut::ETarget type, AliRsnPairParticle *pair);
+ Bool_t IsSelected (AliRsnCut::ETarget type, AliRsnEvent *event);
- void SetBoolValue ( Bool_t theValue,Int_t index ) { fBoolValues[index] = theValue; }
- Bool_t GetBoolValue ( Int_t index ) const { return fBoolValues[index]; }
+ 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 );
+ void SetCutScheme (const TString& theValue);
TString GetCutScheme() const { return fCutScheme; }
- void SetCutSchemeIndexed ( TString theValue );
+ void SetCutSchemeIndexed (TString theValue);
TString GetCutSchemeIndexed();
TObjArray *GetCuts() { return &fCuts; }
-
- private:
+private:
AliRsnCutSet& operator=(const AliRsnCutSet& /*copy*/) {return (*this);}
TString fCutScheme; // cut scheme
TString fCutSchemeIndexed; // cut scheme indexed
- Bool_t *fBoolValues; //[fNumOfCuts]
+ Bool_t *fBoolValues; //[fNumOfCuts]
Bool_t fIsScheme; // is scheme
- AliRsnExpression *fExpression; // pointer to AliRsnExpression
+
+ AliRsnExpression *fExpression; // pointer to AliRsnExpression
- ClassDef ( AliRsnCutSet,1 );
+ ClassDef (AliRsnCutSet,1); // ROOT dictionary
};
#endif
-/**************************************************************************
- * 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 AliRsnDaughter
//
//
// Contains also a facility to compute invariant mass of a pair.
//
// author: A. Pulvirenti --- email: alberto.pulvirenti@ct.infn.it
-//=========================================================================
+//
#include <Riostream.h>
#include "AliAODTrack.h"
#include "AliMCParticle.h"
-#include "AliRsnPID.h"
#include "AliRsnMCInfo.h"
#include "AliRsnDaughter.h"
ClassImp(AliRsnDaughter)
+AliRsnDaughter::EPIDMethod AliRsnDaughter::fgPIDMethod = AliRsnDaughter::kNoPID;
+
//_____________________________________________________________________________
AliRsnDaughter::AliRsnDaughter() :
AliVParticle(),
fLabel(-1),
fCharge(0),
fFlags(0),
- fPIDType(AliRsnPID::kUnknown),
fMass(0.0),
+ fRealisticPID(AliRsnPID::kUnknown),
fMCInfo(0x0)
{
//
fLabel(copy.fLabel),
fCharge(copy.fCharge),
fFlags(copy.fFlags),
- fPIDType(copy.fPIDType),
fMass(copy.fMass),
+ fRealisticPID(copy.fRealisticPID),
fMCInfo(0x0)
{
//
fLabel(-1),
fCharge(0),
fFlags(0),
- fPIDType(AliRsnPID::kUnknown),
fMass(0.0),
+ fRealisticPID(AliRsnPID::kUnknown),
fMCInfo(0x0)
{
//
fLabel(-1),
fCharge(0),
fFlags(0),
- fPIDType(AliRsnPID::kUnknown),
fMass(0.0),
+ fRealisticPID(AliRsnPID::kUnknown),
fMCInfo(0x0)
{
//
fLabel(-1),
fCharge(0),
fFlags(0),
- fPIDType(AliRsnPID::kUnknown),
fMass(0.0),
+ fRealisticPID(AliRsnPID::kUnknown),
fMCInfo(0x0)
{
//
fPIDProb[i] = copy.fPIDProb[i];
}
- fPIDType = copy.fPIDType;
- fMass = copy.fMass;
+ fMass = copy.fMass;
+ fRealisticPID = copy.fRealisticPID;
// initialize particle object
// only if it is present in the template object;
}
//_____________________________________________________________________________
-void AliRsnDaughter::SetPIDProb(Int_t i, Double_t value)
+void AliRsnDaughter::AssignRealisticPID()
{
//
-// I the argument 'i' is in the correct range,
-// sets the i-th PID probability to 'value'
+// Assign realistic PID from largest probability
//
- if (i >= 0 && i < AliRsnPID::kSpecies) fPIDProb[i] = value;
- else {
- AliError(Form("Cannot set a weight related to slot %d", i));
+ Int_t i, imax = 0;
+ Double_t pmax = fPIDProb[0];
+
+ // search for maximum
+ for (i = 1; i < AliRsnPID::kSpecies; i++) {
+ if (fPIDProb[i] > pmax) {
+ imax = i;
+ pmax = fPIDProb[i];
+ }
}
+
+ fRealisticPID = (AliRsnPID::EType)imax;
}
//_____________________________________________________________________________
-void AliRsnDaughter::SetPIDWeights(const Double_t *pid)
+AliRsnPID::EType AliRsnDaughter::PIDType(Double_t &prob)
{
//
-// 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.
+// Return the PID type according to the selected method
+// in the argument passed by reference, the probability is stored.
+// It will be realistic for realistic PID and 1 for perfect PID.
+//
+
+ switch (fgPIDMethod) {
+ case kNoPID:
+ AliWarning("Requested a PIDtype call in NoPID mode");
+ return AliRsnPID::kUnknown;
+ case kPerfect:
+ if (fMCInfo) return AliRsnPID::InternalType(fMCInfo->PDG());
+ else return AliRsnPID::kUnknown;
+ default:
+ if (fRealisticPID > 0 && fRealisticPID < AliRsnPID::kSpecies) {
+ prob = fPIDProb[fRealisticPID];
+ return fRealisticPID;
+ }
+ else {
+ prob = 1.0;
+ return AliRsnPID::kUnknown;
+ }
+ }
+}
+
+//_____________________________________________________________________________
+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'
//
- Int_t i;
- for (i = 0; i < AliRsnPID::kSpecies; i++) fPIDWeight[i] = pid[i];
+ if (i >= 0 && i < AliRsnPID::kSpecies) fPIDProb[i] = value;
+ else {
+ AliError(Form("Cannot set a weight related to slot %d", i));
+ }
}
-
//_____________________________________________________________________________
Bool_t AliRsnDaughter::Adopt(AliESDtrack* esdTrack, Bool_t useTPCInnerParam)
{
// copy PID weights
Int_t i;
for (i = 0; i < 5; i++) fPIDWeight[i] = aodTrack->PID()[i];
+
+ // copy flags
+ fFlags = aodTrack->GetStatus();
// copy sign
fCharge = aodTrack->Charge();
return kFALSE;
}
- // identify track perfectly using PDG code
- fPIDType = AliRsnPID::InternalType(pdg);
- 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;
+ fPIDWeight[AliRsnPID::InternalType(absPDG)] = 1.0;
// copy other MC info (mother PDG code cannot be retrieved here)
InitMCInfo(particle);
// - I --> identification (PID, probability and mass)
// - W --> PID weights
// - M --> Montecarlo (from AliRsnMCInfo)
+// - L --> index & label
// - 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("L") || opt.Contains("ALL")) {
+ 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;
}
if (opt.Contains("F") || opt.Contains("ALL")) {
cout << ".......Flags : " << fFlags << endl;
}
- if (opt.Contains("I") || opt.Contains("ALL")) {
- cout << ".......PID : " << AliRsnPID::ParticleName(fPIDType) << endl;
- if (fPIDType > 0 && fPIDType < AliRsnPID::kSpecies) {
- cout << ".......PID probability : " << fPIDProb[fPIDType] << endl;
- }
- cout << ".......Mass : " << fMass << endl;
- }
if (opt.Contains("W") || opt.Contains("ALL")) {
cout << ".......Weights : ";
Int_t i;
TParticle *particle = mcParticle->Particle();
return InitMCInfo(particle);
}
+
+//_____________________________________________________________________________
+Int_t AliRsnDaughter::Compare(const TObject* obj) const
+{
+//
+// Compare two tracks with respect to their transverse momentum.
+// Citation from ROOT reference:
+// "Must return -1 if this is smaller than obj, 0 if objects are equal
+// and 1 if this is larger than obj".
+//
+
+ AliRsnDaughter *that = (AliRsnDaughter*)obj;
+ if (Pt() < that->Pt()) return 1;
+ else if (Pt() > that->Pt()) return -1;
+ else return 0;
+}
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice *
- **************************************************************************/
-
-//=============================================================================
+//
// Class AliRsnDaughter
//
-// Light-weight 'track' AOD object which contains all required track details
+// Light-weight 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
class AliRsnDaughter : public AliVParticle
{
public:
+
+ enum EPIDMethod {
+ kNoPID = 0,
+ kRealistic,
+ kWeighted,
+ kPerfect,
+ kMethods
+ };
AliRsnDaughter();
AliRsnDaughter (const AliRsnDaughter ©);
// 4-momentum
virtual Double_t E() const {return TMath::Sqrt (fMass*fMass + P2());}
+ virtual Double_t E(Double_t mass) {SetM(mass); return E();}
virtual Double_t M() const {return fMass;}
- virtual Double_t P2() const {return Px() *Px() + Py() *Py() + Pz() *Pz();}
+ 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;}
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 Double_t Dr() 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;}
// PID
virtual const Double_t* PID() const {return fPIDWeight;}
- AliRsnPID::EType PIDType() const {return fPIDType;}
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);
+ static void SetPIDMethod(EPIDMethod method) {fgPIDMethod = method;}
+ void AssignRealisticPID();
+ AliRsnPID::EType PIDType(Double_t &prob);
// check that contains a given ESD flag
Bool_t CheckFlag (ULong_t flag) {return (fFlags & flag);}
// position in stack/array
Int_t Index() const {return fIndex;}
Int_t Label() const {return fLabel;}
+ Int_t GetLabel() const {return -1;}
void SetIndex (Int_t value) {fIndex = value;}
void SetLabel (Int_t value) {fLabel = value;}
Bool_t InitMCInfo (TParticle *particle);
Bool_t InitMCInfo (AliMCParticle *mcParticle);
- // Dummy
- Int_t GetLabel() const {return -1;}
+ // MC info
AliRsnMCInfo* GetMCInfo() const { return fMCInfo; }
+
+ // sorting (with respect to Pt)
+ virtual Bool_t IsSortable() const {return kTRUE;}
+ virtual Int_t Compare(const TObject* obj) const;
private:
Double_t fP[3]; // vector momentum (x, y, z)
Double_t fV[3]; // DCA vertex (x, y, z)
+ Double_t fMass; // mass (assigned externally)
- AliRsnPID::EType fPIDType; // assigned PID
- Double_t fPIDProb[AliRsnPID::kSpecies]; // probability related to assigned PID
+ AliRsnPID::EType fRealisticPID; // PID from Bayesian probs (largest one)
+ Double_t fPIDProb[AliRsnPID::kSpecies]; // PID probabilities (Bayesian comp.)
Double_t fPIDWeight[AliRsnPID::kSpecies]; // PID weights
- Double_t fMass; // mass (defined by PID)
- AliRsnMCInfo *fMCInfo; // reference to particle object (if any)
+ AliRsnMCInfo *fMCInfo; // reference to particle object (if any)
+ static EPIDMethod fgPIDMethod; // flag to define how the PID is computed for this object
- ClassDef (AliRsnDaughter, 3);
+ ClassDef (AliRsnDaughter, 4);
};
#endif
return (AliRsnDaughter*) fTracks->UncheckedAt (index);
}
+//_____________________________________________________________________________
+AliRsnDaughter* AliRsnEvent::GetLeadingParticle
+(Double_t ptMin, AliRsnPID::EType type, Bool_t realistic)
+{
+//
+// Returns the particle in this event with largest transverse momentum,
+// provided that this momentum is larger than the first argument
+// and that the PID type correspond to the second argument.
+// If one specifies "AliRsnPID::kUnknown" as second arguments, the PID check is not done.
+//
+
+ Double_t prob;
+ AliRsnPID::EType trackType;
+ AliRsnDaughter *track, *leading = 0x0;
+ TObjArrayIter iter(fTracks);
+ while ( (track = (AliRsnDaughter*)iter.Next()) ) {
+ if (track->Pt() < ptMin) continue;
+ if (realistic) {
+ AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic);
+ }
+ else {
+ AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kPerfect);
+ }
+ trackType = track->PIDType(prob);
+ if (type != AliRsnPID::kUnknown && trackType != type) continue;
+ ptMin = track->Pt();
+ leading = track;
+ }
+
+ return leading;
+}
+
+//_____________________________________________________________________________
+Int_t AliRsnEvent::GetLastFastTrack
+(Double_t ptMin, AliRsnPID::EType type, Bool_t realistic)
+{
+//
+// Loops on the list of tracks (eventually skipping the ones which do not match
+// the given PID type with the specified PID method) and returns the index of the last
+// one whose transverse momentum is still larger than a specified value.
+// When no tracks are found this way, the value "-1" is returned.
+//
+
+ if (realistic) {
+ AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic);
+ }
+ else {
+ AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kPerfect);
+ }
+
+ Double_t prob;
+ Int_t i, nTracks = fTracks->GetEntries(), lastIndex = -1;
+ for (i = 0; i < nTracks; i++) {
+ AliRsnDaughter *d = (AliRsnDaughter*)fTracks->At(i);
+ AliRsnPID::EType trackType = d->PIDType(prob);
+ if (type != AliRsnPID::kUnknown && trackType != type) continue;
+ if (d->Pt() >= ptMin) lastIndex = i;
+ }
+
+ return lastIndex;
+}
+
//_____________________________________________________________________________
TArrayI* AliRsnEvent::GetCharged (Char_t sign)
{
//_____________________________________________________________________________
TArrayI * AliRsnEvent::GetTracksArray
-(AliRsnPID::EMethod pidtype, Char_t sign, AliRsnPID::EType type)
+(AliRsnDaughter::EPIDMethod pidtype, Char_t sign, AliRsnPID::EType type)
{
//
// Returns an array of indexes of all tracks in this event
//
switch (pidtype) {
- case AliRsnPID::kRealistic:
+ case AliRsnDaughter::kRealistic:
if (fRealisticPID) {
return fRealisticPID->GetTracksArray (sign, type);
}
break;
- case AliRsnPID::kPerfect:
+ case AliRsnDaughter::kPerfect:
if (fPerfectPID) {
return fPerfectPID->GetTracksArray (sign, type);
}
fNoPID = new AliRsnPIDIndex;
fPerfectPID = new AliRsnPIDIndex;
fRealisticPID = new AliRsnPIDIndex;
+
+ // set the default type to Realistic
+ AliRsnDaughter::SetPIDMethod(AliRsnDaughter::kRealistic);
// loop on tracks and create references
+ Double_t prob;
Int_t i, icharge, type;
Short_t charge;
AliRsnMCInfo *mcinfo = 0;
TObjArrayIter iter(fTracks);
while ( (track = (AliRsnDaughter*) iter.Next()) ) {
charge = track->Charge();
- type = (Int_t)track->PIDType();
+ type = (Int_t)track->PIDType(prob);
i = fTracks->IndexOf(track);
mcinfo = track->GetMCInfo();
if (charge > 0) icharge = 0;
#ifndef ALIRSNEVENT_H
#define ALIRSNEVENT_H
-class AliRsnDaughter;
-
#include <TNamed.h>
#include <TArrayI.h>
#include <TClonesArray.h>
+
#include "AliRsnPID.h"
#include "AliRsnPIDIndex.h"
+#include "AliRsnDaughter.h"
class AliRsnEvent : public TNamed
{
void Clear (Option_t *option = "");
AliRsnDaughter* AddTrack (AliRsnDaughter track);
AliRsnDaughter* GetTrack (Int_t index);
+ AliRsnDaughter* GetLeadingParticle(Double_t ptMin = 0.0, AliRsnPID::EType type = AliRsnPID::kUnknown, Bool_t realistic = kTRUE);
+ Int_t GetLastFastTrack(Double_t ptMin, AliRsnPID::EType type = AliRsnPID::kUnknown, Bool_t realistic = kTRUE);
TClonesArray* GetTracks() {return fTracks;}
TArrayI* GetCharged (Char_t sign);
- TArrayI* GetTracksArray (AliRsnPID::EMethod pidtype, Char_t sign, AliRsnPID::EType type);
+ TArrayI* GetTracksArray (AliRsnDaughter::EPIDMethod method, Char_t sign, AliRsnPID::EType type);
void FillPIDArrays();
+ void SortTracks() {fTracks->Sort();}
void Print (Option_t *option = "") const;
// Primary vertex
// These are the valid operators types.
-enum { kOpAND=1, // AND '&'
- kOpOR, // OR '|'
- kOpNOT
- }; // Unary negation '!'
-
class AliRsnExpression : public TObject
{
public:
+
+ // operators for complex cut expressions
+ enum ECutOp
+ {
+ kOpAND=1, // AND '&'
+ kOpOR, // OR '|'
+ kOpNOT // Unary negation '!'
+ };
+
AliRsnExpression() : fVname ( 0 ), fArg1 ( 0 ), fArg2 ( 0 ), fOperator ( 0 ) {}
AliRsnExpression ( TString exp );
virtual ~AliRsnExpression();
#include <AliVParticle.h>
#include <TParticle.h>
+#include <TMath.h>
class AliRsnMCInfo : public TObject
{
// 4-momentum
virtual Double_t E() const {return fEnergy;}
+ virtual Double_t E(Double_t mass) {return TMath::Sqrt(mass*mass + P2());}
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() );}
//-------------------------------------------------------------------------
#include <TMath.h>
-#include <TString.h>
-#include <TClonesArray.h>
-#include <TDatabasePDG.h>
+#include <TDirectory.h>
#include "AliLog.h"
#include "AliRsnMCInfo.h"
ClassImp(AliRsnPID)
+const Double_t AliRsnPID::fgkParticleMass[AliRsnPID::kSpecies + 1] =
+{
+ 0.00051099892, // electron
+ 0.105658369, // muon
+ 0.13957018, // pion
+ 0.493677, // kaon
+ 0.93827203, // proton
+ 0.0 // nothing
+};
+
const char* AliRsnPID::fgkParticleNameLong[AliRsnPID::kSpecies + 1] =
{
"electron",
//_____________________________________________________________________________
AliRsnPID::AliRsnPID() :
- fMethod(kRealistic),
- fMaxPt(10.0),
+ TNamed("RsnPID", ""),
+ fMaxPt(100.0),
fMinProb(0.0)
{
//
-// 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;
- fPrior[kKaon ] = 0.07;
- fPrior[kProton ] = 0.06;
-}
-
-//_____________________________________________________________________________
-AliRsnPID::AliRsnPID(const AliRsnPID &event) :
- TObject((TObject)event),
- fMethod(event.fMethod),
- fMaxPt(event.fMaxPt),
- fMinProb(event.fMinProb)
-{
-//
-// Copy constructor.
-// Implemented to manage the array safely.
+// Constructor.
+// Adds also the object in the default directory of the session.
//
- Int_t i;
- for (i = 0; i < kSpecies; i++) fPrior[i] = event.fPrior[i];
-}
-
-//_____________________________________________________________________________
-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);
+ Int_t i;
+ for (i = 0; i < kSpecies; i++) fPrior[i] = 0.0;
+
+ gDirectory->Append(this, kTRUE);
}
//_____________________________________________________________________________
// 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();
+ */
+ if (type >= kElectron && type < kSpecies) return fgkParticleMass[type];
+ return 0.0;
}
//_____________________________________________________________________________
-Bool_t AliRsnPID::IdentifyRealistic(AliRsnDaughter *daughter)
+Bool_t AliRsnPID::ComputeProbs(AliRsnDaughter *daughter)
{
//
// Uses the Bayesian combination of prior probabilities
//
// 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];
+ Int_t i;
+ for (i = 0; i < kSpecies; i++) daughter->SetPIDProb(i, 1.0 / (Double_t)kSpecies);
- // step 1 - compute the normalization factor
+ // multiply weights and priors
+ Double_t sum = 0.0, prob[kSpecies];
for (i = 0; i < kSpecies; i++) {
- prob[i] = fPrior[i] * weight[i];
+ prob[i] = fPrior[i] * daughter->PID()[i];
sum += prob[i];
}
if (sum <= (Double_t)0.) {
- AliError(Form("Sum of weights = %f < 0", sum));
+ AliError(Form("Sum of weights = %f <= 0", sum));
return kFALSE;
}
- // step 2 - normalize PID weights and update daughter data-member
+ // normalize
for (i = 0; i < kSpecies; i++) {
prob[i] /= sum;
daughter->SetPIDProb(i, prob[i]);
}
-
- // 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] > pmax) {
- imax = i;
- pmax = prob[i];
- }
- }
- EType type = (EType)imax;
- if (pmax >= fMinProb) {
- daughter->SetPIDType(type);
- daughter->SetM(ParticleMass(type));
- }
- else {
- daughter->SetPIDType(kUnknown);
- }
-
+
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliRsnPID::IdentifyPerfect(AliRsnDaughter *daughter)
+Bool_t AliRsnPID::IdentifiedAs(AliRsnDaughter *d, EType type, Short_t charge)
{
//
-// 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
-// PID to 'unknown' and returns kFALSE.
-// Otherwise, returns kTRUE.
+// Tells if a particle has can be 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 the track momentum is larger than the pt threshold passed to this object,
+// or the maximum probability is smaller than the prob thrashold, the return value
+// is kFALSE even when the type and charge are matched.
//
- // reset all PID probabilities to 0.0
- Unidentify(daughter, 0.0);
-
- // 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");
- return kFALSE;
- }
-
- // convert the PDG into the internal enum
- Int_t pdgCode = particle->PDG();
- EType type = InternalType(pdgCode);
-
- // 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(type, 1.0);
- daughter->SetM(ParticleMass(type));
+ EType dType = TrackType(d);
+ if (dType != type) return kFALSE;
+ if (charge == 0) {
return kTRUE;
}
-
- return kFALSE;
-}
-
-//_____________________________________________________________________________
-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;
-}
-
-//_____________________________________________________________________________
-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
-// gives an alert. Otherwise, returns kTRUE.
-//
-
- switch (fMethod) {
- case kNone:
- Unidentify(daughter);
- return kTRUE;
- case kRealistic:
- IdentifyRealistic(daughter);
- return kTRUE;
- case kPerfect:
- IdentifyPerfect(daughter);
- return kTRUE;
- default:
- AliError(Form("PID method '%d' unrecognized. Nothing done.", fMethod));
- return kFALSE;
+ else if (charge > 0) {
+ return (d->Charge() > 0);
+ }
+ else {
+ return (d->Charge() < 0);
}
}
//_____________________________________________________________________________
-Bool_t AliRsnPID::IdentifiedAs(AliRsnDaughter *d, EType type, Short_t charge)
+AliRsnPID::EType AliRsnPID::TrackType(AliRsnDaughter *d)
{
//
-// 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
+// Returns the track type according to the object settings
+// and to the static settings in the AliRsnDaughter object.
//
- 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);
- }
+
+ Double_t prob;
+ EType type = d->PIDType(prob);
+
+ if (d->Pt() > fMaxPt) return kUnknown;
+ if (prob < fMinProb) return kUnknown;
+
+ return type;
}
//_____________________________________________________________________________
-Bool_t AliRsnPID::Identify(AliRsnEvent *event)
+Bool_t AliRsnPID::Process(AliRsnEvent *event)
{
//
// Performs identification for all tracks in a given event.
AliRsnDaughter *daughter = 0;
TObjArrayIter iter(event->GetTracks());
while ( (daughter = (AliRsnDaughter*)iter.Next()) ) {
- check = check && Identify(daughter);
+ check = check && ComputeProbs(daughter);
}
event->FillPIDArrays();
fPrior[type] = p;
}
}
+
+//_____________________________________________________________________________
+void AliRsnPID::DumpPriors()
+{
+//
+// Print all prior probabilities
+//
+
+ Int_t i;
+ Char_t msg[200];
+
+ for (i = 0; i < kSpecies; i++) {
+ sprintf(msg, "Prior probability for '%s' = %3.5f", fgkParticleNameLong[i], fPrior[i]);
+ AliInfo(msg);
+ }
+}
#ifndef ALIRSNPID_H
#define ALIRSNPID_H
-class AliRsnPIDProb;
+#include <TNamed.h>
+
class AliRsnDaughter;
class AliRsnEvent;
-class AliRsnPID : public TObject
+class AliRsnPID : public TNamed
{
public:
- AliRsnPID();
- AliRsnPID(const AliRsnPID& copy);
- AliRsnPID& operator=(const AliRsnPID& copy);
- virtual ~AliRsnPID() {}
-
// types enum
enum EType {
kElectron = 0,
kSpecies = 5
};
- // identification method enum
- enum EMethod {
- kNone = 0,
- kRealistic,
- kPerfect,
- kMethods
- };
+ AliRsnPID();
+ virtual ~AliRsnPID() {}
// conversions from PDG code to local type
- static EType InternalType(Int_t pdgCode);
-
+ static EType InternalType(Int_t pdgCode);
+
// retrieve particle informations from internal type
- static Int_t PDGCode(EType pid);
- static const char * ParticleName(EType pid, Bool_t shortName = kTRUE);
- static const char * ParticleNameLatex(EType pid);
- static Double_t ParticleMass(EType pid);
+ static Int_t PDGCode(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 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;}
+ Bool_t Process(AliRsnEvent *e);
+ Bool_t ComputeProbs(AliRsnDaughter *d);
+ Bool_t IdentifiedAs(AliRsnDaughter *d, EType type, Short_t charge = 0);
+ EType TrackType(AliRsnDaughter *d);
+
+ // data members
+ void SetPriorProbability(EType type, Double_t p);
+ void SetMinProb(Double_t p) {fMinProb = p;}
+ void SetMaxPt(Double_t p) {fMaxPt = p;}
+ Double_t GetPriorProbability(EType type) {return fPrior[(Int_t)type];}
+ Double_t GetMinProb() {return fMinProb;}
+ Double_t GetMaxPt() {return fMaxPt;}
+
+ // other
+ void DumpPriors();
private:
- // identification routines
- Bool_t IdentifyPerfect(AliRsnDaughter *d);
- Bool_t IdentifyRealistic(AliRsnDaughter *d);
- Bool_t Unidentify(AliRsnDaughter *d, Double_t value = 1.0);
-
- EMethod fMethod; // PID method
-
- 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
+ Double_t fPrior[kSpecies]; // prior probabilities
+ Double_t fMaxPt; // pt threshold for realistic PID
+ Double_t fMinProb; // threshold on acceptable largest probability
- 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];
+ static const Double_t fgkParticleMass[kSpecies + 1]; // PDG particle mass
+ static const char* fgkParticleNameShort[kSpecies + 1]; // short particle name
+ static const char* fgkParticleNameLong[kSpecies + 1]; // long particle name
+ static const char* fgkParticleNameLatex[kSpecies + 1]; // latex particle name
+ static const Int_t fgkParticlePDG[kSpecies + 1]; // PDG code of particle
ClassDef(AliRsnPID,1);
};
}
//_____________________________________________________________________________
-void AliRsnPIDIndex::Print (Option_t * option) const
+void AliRsnPIDIndex::Print (Option_t* /*option*/) const
{
//
// Prints AliRsnPIDIndex info
//
Int_t i, j;
- if (!option) return;
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]));
class AliRsnPIDWeightsMgr : public TObject
{
public:
-
+
+ // detectors for customizing PID weights
enum EDetector {
kITS,
kTPC,
-/**************************************************************************
- * 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
+// Class 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.
+// Defines a decay channel for a resonance,
+// resulting in a specified PDG code for the mother,
+// and the particle type for the daughters, defined
+// according to the internal PID format of the package
//
-// author: A. Pulvirenti
-// email : alberto.pulvirenti@ct.infn.it
+// author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
//
-#include <Riostream.h>
-
#include "AliLog.h"
#include "AliRsnDaughter.h"
#include "AliRsnPairDef.h"
//_____________________________________________________________________________
AliRsnPairDef::AliRsnPairDef() :
- TObject(),
- fMotherPDG(0),
- fNBins(0),
- fMin(0.0),
- fMax(0.0)
+ fMotherPDG(0)
{
//
// Empty constructor.
//_____________________________________________________________________________
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)
+(Char_t sign1, AliRsnPID::EType type1, Char_t sign2, AliRsnPID::EType type2, Int_t motherPDG) :
+ fMotherPDG(motherPDG)
{
//
// Constructor with arguments.
//
SetPair(sign1, type1, sign2, type2);
- SetBins(nbins, min, max);
}
//_____________________________________________________________________________
AliRsnPairDef::AliRsnPairDef(const AliRsnPairDef ©) :
TObject(copy),
- fMotherPDG(copy.fMotherPDG),
- fNBins(0),
- fMin(0.0),
- fMax(0.0)
+ fMotherPDG(copy.fMotherPDG)
{
//
// 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);
}
//_____________________________________________________________________________
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);
}
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)
{
-/**************************************************************************
- * 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)
-//-------------------------------------------------------------------------
+// Class AliRsnPairDef
+//
+// Defines a decay channel for a resonance,
+// resulting in a specified PDG code for the mother,
+// and the particle type for the daughters, defined
+// according to the internal PID format of the package
+//
+// author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
#ifndef ALIRSNPAIRDEF_H
#define ALIRSNPAIRDEF_H
-class AliRsnDaughter;
#include "AliRsnPID.h"
+class AliRsnDaughter;
+
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(Char_t ch1, AliRsnPID::EType pid1,
+ Char_t ch2, AliRsnPID::EType pid2, Int_t motherPDG = 0);
AliRsnPairDef(const AliRsnPairDef ©);
const AliRsnPairDef& operator=(const AliRsnPairDef ©);
virtual ~AliRsnPairDef() { }
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);
+ Bool_t SetPair(Char_t ch1, AliRsnPID::EType pid1, Char_t ch2, 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:
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)
};
ClassImp (AliRsnPairParticle)
//_____________________________________________________________________________
-AliRsnPairParticle::AliRsnPairParticle() :
- fMass(0.0)
+AliRsnPairParticle::AliRsnPairParticle()
{
//
// 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;
//_____________________________________________________________________________
AliRsnPairParticle::AliRsnPairParticle(const AliRsnPairParticle &obj) :
- TObject(obj),
- fMass(obj.fMass)
+ TObject(obj)
{
//
// 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];
// Does not duplicate pointers.
//
- fMass = obj.fMass;
-
Int_t i, j;
for (i = 0; i < 3; i++) {
fPTot[i] = obj.fPTot[i];
}
//_____________________________________________________________________________
-Double_t AliRsnPairParticle::GetInvMass(Double_t m1, Double_t m2)
+Double_t AliRsnPairParticle::GetInvMass(Double_t mass0, Double_t mass1)
{
//
-// 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.
+// Compute invariant mass using reconstructed values.
+// Mass in argument #1 is assigned to first track in the pair (fDaughter[0]),
+// mass in argument #2 is assigned to second track in the pair (fDaughter[1])
+// Then, the invariant mass of the pair is computed by using their total momentum
+// and the sum of their energies as they result from assigned masses.
//
- 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);
-}
+ if (!fDaughter[0] || !fDaughter[1]) {
+ AliError("One of the two tracks is NULL in this pair!");
+ return -1000.0;
+ }
-//_____________________________________________________________________________
-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.
-//
+ // compute track energies using the shortcut method defined in AliRsnDaughter
Double_t etot = 0.0;
+ etot += fDaughter[0]->E(mass0);
+ etot += fDaughter[1]->E(mass1);
- // 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);
+ // compute & return invariant mass
+ return TMath::Sqrt (etot * etot - GetP2());
}
//_____________________________________________________________________________
-Double_t AliRsnPairParticle::GetDaughterEnergy(const Int_t &index, const Double_t &mass)
+Double_t AliRsnPairParticle::GetInvMassMC(Double_t mass0, Double_t mass1)
{
//
-// 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.
+// Compute invariant mass using MC values.
+// Mass in argument #1 is assigned to first track in the pair (fDaughter[0]),
+// mass in argument #2 is assigned to second track in the pair (fDaughter[1])
+// Then, the invariant mass of the pair is computed by using their total momentum
+// and the sum of their energies as they result from assigned masses.
//
- if (mass > 0 && index >= 0 && index < 2) {
- AliRsnDaughter temp(*fDaughter[index]);
- temp.SetM(mass);
- return temp.E();
+ if (!fDaughter[0] || !fDaughter[1]) {
+ AliError("One of the two tracks is NULL in this pair!");
+ return -1000.0;
}
-
- 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);
+ if (!fDaughter[0]->GetMCInfo() || !fDaughter[1]->GetMCInfo()) {
+ AliError("One of the two tracks has a NULL MCInfo in this pair!");
+ return -1000.0;
}
- AliWarning("Negative mass or wrong index passed. Returning 0");
- return 0.0;
+ // compute track energies using the shortcut method defined in AliRsnDaughter
+ Double_t etot = 0.0;
+ etot += fDaughter[0]->GetMCInfo()->E(mass0);
+ etot += fDaughter[1]->GetMCInfo()->E(mass1);
+
+ // compute & return invariant mass
+ return TMath::Sqrt (etot * etot - GetP2());
}
//_____________________________________________________________________________
-Int_t AliRsnPairParticle::GetPDG(const Int_t &index)
+Double_t AliRsnPairParticle::GetAngle() const
{
//
-// Return PDG code of one track in the pair
+// Returns the relative angle between the vector momenta of the tracks
+// Return value is in DEGREES.
//
- 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();
+ Double_t dotProd = 0.0;
+ dotProd += fDaughter[0]->Px() * fDaughter[1]->Px();
+ dotProd += fDaughter[0]->Py() * fDaughter[1]->Pz();
+ dotProd += fDaughter[0]->Pz() * fDaughter[1]->Pz();
+
+ Double_t cosAngle = dotProd / (fDaughter[0]->P() * fDaughter[1]->P());
+
+ return TMath::ACos(cosAngle) * TMath::RadToDeg();
}
//_____________________________________________________________________________
Bool_t AliRsnPairParticle::IsTruePair(Int_t refPDG)
{
//
-// Checks if the tweo tracks in the pair come from the same resonance.
+// Checks if the two 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()) {
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
void AliRsnPairParticle::PrintInfo (const Option_t *option)
{
//
-// Print some info of the pair
+// Print some info of the pair.
+// The options are passed to the AliRsnDaughter::Print() method
//
- 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 =========" );
+ AliInfo("======== BEGIN PAIR INFO ===========");
+ AliInfo("Track #1");
+ fDaughter[0]->Print(option);
+ AliInfo("Track #2");
+ fDaughter[1]->Print(option);
+ AliInfo ("========= END PAIR INFO ===========");
}
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 = "");
+ Double_t GetInvMass (Double_t m1, Double_t m2);
+ Double_t GetInvMassMC (Double_t m1 = -1.0, Double_t m2 = -1.0);
+
+ 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 GetPx() const {return fPTot[0];}
+ Double_t GetPy() const {return fPTot[1];}
+ Double_t GetPz() const {return fPTot[2];}
+ 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 GetPxMC() const {return fPTotMC[0];}
+ Double_t GetPyMC() const {return fPTotMC[1];}
+ Double_t GetPzMC() const {return fPTotMC[2];}
+ Double_t GetPtMC() const {return TMath::Sqrt(GetPt2MC());}
+
+ Double_t GetAngle() const;
+
+ AliRsnDaughter* GetDaughter(const Int_t &index) const {return fDaughter[index];}
+
+ Bool_t IsLabelEqual() {return abs(fDaughter[0]->Label()) == abs(fDaughter[1]->Label());}
+ Bool_t IsIndexEqual() {return (fDaughter[0]->Index() == fDaughter[1]->Index());}
+ Bool_t IsTruePair(Int_t refPDG = 0);
+
+ void SetPair(AliRsnDaughter *daughter1, AliRsnDaughter *daughter2);
+ void PrintInfo (const Option_t *option = "");
private:
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
+++ /dev/null
-/**************************************************************************
- * 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 ©) :
- 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 ©)
-{
-//
-// 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;
-}
+++ /dev/null
-/*************************************************************************
- * 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 ©);
- const AliRsnPairSimple& operator=(const AliRsnPairSimple ©);
- 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
-/**************************************************************************
- * 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 AliRsnReader ========
+// Class AliRsnReader
//
-// This object reads a 'standard' event and converts it into the internal
-// format used for resonance analysis (AliRsnEvent).
-// 'Standard' event means ESD, standard AOD and MC event.
+// This is the universal converter from any kind of source event
+// (i.e. ESD, standard AOD, MC) into the internal non-standard
+// AOD format used by RSN package.
+// ---
+// This class reads all tracks in an input event and converts them
+// into AliRsnDaughters, and computes preliminarily the PID probabilities
+// by doing the Bayesian combination of a set of assigned prior probabilities
+// with the PID weights defined in each track.
+// ---
+// When filling the output event (AliRsnEvent), some arrays of indexes
+// are created in order to organize tracks according to their PID and charge,
+// which will then be used in further analysis steps.
//
-// The input-2-AliRsnEvent conversion is done through a class which reads
-// from AliAnalysisTaskSE, which is the standard analysis object.
-// This class creates the AliRsnEvent's before the input event is read,
-// so this class has not to 'create' a new outpu event, but instead it has
-// to 'fill' one which has already been created elsewhere.
-// Then, the methods provided here accept an AliRsnEvent as argument passed
-// by reference, and they 'fill' this object using the data from the inputs
-// passed to them.
-//
-// author: A. Pulvirenti
-// email : alberto.pulvirenti@ct.infn.it
+// author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
//
#include <TString.h>
+#include <TDirectory.h>
#include "AliLog.h"
//_____________________________________________________________________________
AliRsnReader::AliRsnReader(ESource source, AliRsnPIDWeightsMgr *mgr) :
- TObject(),
+ TNamed("RsnReader", ""),
fSource(source),
fCheckSplit(kFALSE),
fRejectFakes(kFALSE),
{
//
// Constructor.
-// Initializes the base-type data members:
-// - management of fake tracks
-//
-}
-
-//_____________________________________________________________________________
-AliRsnReader::AliRsnReader(const AliRsnReader ©) :
- TObject(copy),
- fSource(copy.fSource),
- fCheckSplit(copy.fCheckSplit),
- fRejectFakes(copy.fRejectFakes),
- fWeightsMgr(copy.fWeightsMgr)
-{
-//
-// Copy constructor.
-//
-}
-
-//_____________________________________________________________________________
-AliRsnReader& AliRsnReader::operator=(const AliRsnReader ©)
-{
+// Adds also this object to global directory.
//
-// Assignment operator.
-//
-
- fSource = copy.fSource;
- fCheckSplit = copy.fCheckSplit;
- fRejectFakes = copy.fRejectFakes;
- fWeightsMgr = copy.fWeightsMgr;
- return (*this);
+ gDirectory->Append(this, kTRUE);
}
//_____________________________________________________________________________
// passed by reference as first argument.
//
+ Bool_t success = kFALSE;
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");
+ AliError(Form("Source class mismatch [expected: 'AliESDEvent' -- passed: '%s'", str.Data()));
return kFALSE;
}
- return FillFromESD(rsn, (AliESDEvent*)event, mc);
+ success = FillFromESD(rsn, (AliESDEvent*)event, mc);
+ break;
case kESDTPC:
if (!str.Contains("AliESDEvent")) {
- AliError("A reader set to 'kESD' or 'kESDTPC' can read only ESD events");
+ AliError(Form("Source class mismatch [expected: 'AliESDEvent' -- passed: '%s'", str.Data()));
return kFALSE;
}
- return FillFromESD(rsn, (AliESDEvent*)event, mc, kTRUE);
+ success = FillFromESD(rsn, (AliESDEvent*)event, mc, kTRUE);
+ break;
case kAOD:
if (!str.Contains("AliAODEvent")) {
- AliError("A reader set to 'kAOD' can read only AOD events");
+ AliError(Form("Source class mismatch [expected: 'AliAODEvent' -- passed: '%s'", str.Data()));
return kFALSE;
}
- return FillFromAOD(rsn, (AliAODEvent*)event, mc);
+ success = FillFromAOD(rsn, (AliAODEvent*)event, mc);
+ break;
case kMC:
if (!str.Contains("AliMCEvent")) {
- AliError("A reader set to 'kMC' can read only MC events");
+ AliError(Form("Source class mismatch [expected: 'AliMCEvent' -- passed: '%s'", str.Data()));
return kFALSE;
}
- return FillFromMC(rsn, (AliMCEvent*)event);
+ success = FillFromMC(rsn, (AliMCEvent*)event);
+ break;
default:
return kFALSE;
}
+
+ // sort tracks w.r. to Pt (from largest to smallest)
+ rsn->SortTracks();
+
+ return success;
}
//_____________________________________________________________________________
// When this is used, the 'source' flag of the output
// AliRsnEvent object will be set to '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;
- }
- */
-
+
// if required with the flag, scans the event
// and searches all split tracks (= 2 tracks with the same label);
// for each pair of split tracks, only the better (best chi2) is kept
}
}
}
-
+
// get primary vertex
Double_t vertex[3];
if (!useTPCOnly) {
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;
else {
//AliInfo("Using standard ESD weights");
}
-
+
// if stack is present, copy MC info
if (stack) {
TParticle *part = stack->Particle(TMath::Abs(label));
// if problems occurred while storing, that pointer is NULL
if (!ptr) AliWarning(Form("Failed storing track#%d", index));
}
-
+
// compute total multiplicity
if (rsn->GetMultiplicity() <= 0) {
AliWarning("Zero Multiplicity in this event");
return kFALSE;
}
-
+
return kTRUE;
}
// When this is used, the 'source' flag of the output
// AliRsnEvent object will be set to 'kAOD'.
//
-
+
// retrieve stack (if possible)
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;
}
-
+
// 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;
// if problems occurred while storin, that pointer is NULL
if (!ptr) AliWarning(Form("Failed storing track#%d"));
}
-
+
// compute total multiplicity
if (rsn->GetMultiplicity() <= 0) {
AliWarning("Zero multiplicity in this event");
return kFALSE;
}
-
+
return kTRUE;
}
// When this is used, the 'source' flag of the output
// AliRsnEvent object will be set to 'kMC'.
//
-
+
// 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];
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;
// if problems occurred while storin, that pointer is NULL
if (!ptr) AliWarning(Form("Failed storing track#%d", index));
}
-
+
// compute total multiplicity
if (rsn->GetMultiplicity() <= 0) {
AliWarning("Zero multiplicity in this event");
return kFALSE;
}
-
+
return kTRUE;
}
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice *
- **************************************************************************/
-
//
-// ==== Class AliRsnReader ========
+// Class AliRsnReader
//
-// This object reads a 'standard' event and converts it into the internal
-// format used for resonance analysis (AliRsnEvent).
-// 'Standard' event means ESD, standard AOD and MC event.
+// This is the universal converter from any kind of source event
+// (i.e. ESD, standard AOD, MC) into the internal non-standard
+// AOD format used by RSN package.
+// ---
+// This class reads all tracks in an input event and converts them
+// into AliRsnDaughters, and computes preliminarily the PID probabilities
+// by doing the Bayesian combination of a set of assigned prior probabilities
+// with the PID weights defined in each track.
+// ---
+// When filling the output event (AliRsnEvent), some arrays of indexes
+// are created in order to organize tracks according to their PID and charge,
+// which will then be used in further analysis steps.
//
-// The input-2-AliRsnEvent conversion is done through a class which reads
-// from AliAnalysisTaskSE, which is the standard analysis object.
-// This class creates the AliRsnEvent's before the input event is read,
-// so this class has not to 'create' a new outpu event, but instead it has
-// to 'fill' one which has already been created elsewhere.
-// Then, the methods provided here accept an AliRsnEvent as argument passed
-// by reference, and they 'fill' this object using the data from the inputs
-// passed to them.
-//
-// author: A. Pulvirenti
-// email : alberto.pulvirenti@ct.infn.it
+// author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
//
#ifndef ALIRSNREADER_H
#define ALIRSNREADER_H
+#include <TNamed.h>
+
class AliVEvent;
class AliESDEvent;
class AliAODEvent;
class AliRsnEvent;
class AliRsnPIDWeightsMgr;
-class AliRsnReader : public TObject
+class AliRsnReader : public TNamed
{
public:
};
AliRsnReader(ESource source = kESD, AliRsnPIDWeightsMgr *mgr = 0x0);
- AliRsnReader(const AliRsnReader& copy);
- AliRsnReader& operator=(const AliRsnReader& copy);
virtual ~AliRsnReader() {}
+ void SetSource(ESource source) {fSource = source;}
void SetWeightsMgr(AliRsnPIDWeightsMgr *mgr) {fWeightsMgr = mgr;}
void SetCheckSplit(Bool_t doit = kTRUE) {fCheckSplit = doit;}
void SetRejectFakes(Bool_t doit = kTRUE) {fRejectFakes = doit;}
+ ESource GetSource() {return fSource;}
+ Bool_t CheckSplit() {return fCheckSplit;}
+ Bool_t RejectFakes() {return fRejectFakes;}
Bool_t Fill(AliRsnEvent *rsn, AliVEvent *event, AliMCEvent *refMC = 0);
protected:
+ // dummy copy methods
+ AliRsnReader(const AliRsnReader ©) : TNamed(copy),
+ fSource(kESD),fCheckSplit(0),fRejectFakes(0),fWeightsMgr(0x0) { /*nothing*/ }
+ AliRsnReader& operator=(const AliRsnReader&) {return (*this);}
+
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);
-/**************************************************************************
- * 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 AliRsnReaderTaskSE
-// ------------------------
-// Reader for conversion of ESD output into the internal format
-// used for resonance study.
+//
+// Class AliRsnReaderTaskSE
+//
+// An AnalysisTask object to convert any kind of source event type (ESD/AOD/MC)
+// into the RSN internal format (AliRsnEvent).
+// The output of this task is a TTree with converted events, which is saved in a file
+// and can then be processed as many times as desired, to build invariant mass spectra.
// ---
-// original author: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it)
-// ---
-// adapted for Analysis Framework
-// by : R. Vernet (email: renaud.vernet@cern.ch)
-//----------------------------------------------------------------------------------
-
-#include <Riostream.h>
+// original author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
+// adapted for Analysis Framework by: R. Vernet (renaud.vernet@cern.ch)
+//
#include "AliLog.h"
#include "AliAnalysisManager.h"
-#include "AliMCEventHandler.h"
+
#include "AliMCEvent.h"
+#include "AliMCEventHandler.h"
+
#include "AliESDInputHandler.h"
#include "AliAODInputHandler.h"
#include "AliAODHandler.h"
+#include "AliRsnPID.h"
#include "AliRsnEvent.h"
#include "AliRsnReader.h"
-#include "AliRsnPID.h"
#include "AliRsnReaderTaskSE.h"
ClassImp(AliRsnReaderTaskSE)
fPID(0x0),
fRsnEvent(0x0)
{
-//=========================================================
+//
// Default constructor (not recommended)
-//=========================================================
+//
}
//_____________________________________________________________________________
fPID(0x0),
fRsnEvent(0x0)
{
-//=========================================================
+//
// Working constructor (recommended)
-// Initializes the reader and PID objects.
-//=========================================================
-
- fReader = new AliRsnReader;
- fPID = new AliRsnPID;
-}
-
-//_____________________________________________________________________________
-AliRsnReaderTaskSE::AliRsnReaderTaskSE(const AliRsnReaderTaskSE& obj) :
- AliAnalysisTaskSE(obj),
- fReader(obj.fReader),
- fPID(obj.fPID),
- fRsnEvent(0x0)
-{
-//=========================================================
-// Copy constructor (not recommended)
-//=========================================================
-}
-
-//_____________________________________________________________________________
-AliRsnReaderTaskSE& AliRsnReaderTaskSE::operator=(const AliRsnReaderTaskSE& /*obj*/)
-{
-//=========================================================
-// Assignment operator (not recommended)
-//=========================================================
-
- AliInfo("Not implemented. Avoid using the assignment operator");
- return *this;
+//
}
//_____________________________________________________________________________
void AliRsnReaderTaskSE::UserCreateOutputObjects()
{
-//=========================================================
-// Create the output container
-//=========================================================
+//
+// Instantiates the output object (AliRsnEvent) and adds a branch
+// to the non-standard AOD output TTree to include it.
+// Checks that the necessary data member objects for
+// conversion and PID are allocated. If this is not the case,
+// raises a fatal error which breaks the AliRoot session.
+//
- AliDebug(1, "Creating USER output objects");
-
- // 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");
+ AliFatal("PID 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");
//_____________________________________________________________________________
void AliRsnReaderTaskSE::Init()
{
-//=========================================================
-// Initialization
-//=========================================================
-
- AliDebug(1, "Initializing");
+//
+// Inherited function.
+// Here it does not need to do anything, so it is left dummy.
+//
}
//_____________________________________________________________________________
void AliRsnReaderTaskSE::UserExec(Option_t */*option*/)
{
-//=========================================================
-// Loops on input container to store data of all tracks.
-// Uses the AliRsnReader methods to save them in the output.
-//=========================================================
+//
+// Execution core of the class.
+// Uses the AliRsnReader and AliRsnPID methods to convert input data
+// and store them in the output AOD event, with all required computations.
+//
- // static counter
AliInfo(Form("Reading event %d", ++fEntry));
- // clear previous sample
+ // before adding new data, the ones from previous event
+ // must be cleared explicitly
fRsnEvent->Clear();
- // read event, identify
+ // step 1: conversion
if (!fReader->Fill(fRsnEvent, fInputEvent, fMCEvent)) AliWarning("Failed reading");
- if (!fPID->Identify(fRsnEvent)) AliWarning("Failed PID");
+
+ // step 2: PID probability computation
+ if (!fPID->Process(fRsnEvent)) AliWarning("Failed PID");
+
AliInfo(Form("Collected %d tracks", fRsnEvent->GetMultiplicity()));
}
//_____________________________________________________________________________
void AliRsnReaderTaskSE::Terminate(Option_t */*option*/)
{
-//=========================================================
-// Terminate analysis
-//=========================================================
-
- AliDebug(1, "Terminating");
+//
+// Inherited function.
+// Here it does not need to do anything, so it is left dummy.
+//
}
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice *
- **************************************************************************/
-
-//----------------------------------------------------------------------------------
-// Class AliRsnReaderTaskSE
-// ------------------------
-// Reader for conversion of ESD output into the internal format
-// used for resonance study.
-// ---
-// original author: A. Pulvirenti (email: alberto.pulvirenti@ct.infn.it)
+//
+// Class AliRsnReaderTaskSE
+//
+// An AnalysisTask object to convert any kind of source event type (ESD/AOD/MC)
+// into the RSN internal format (AliRsnEvent).
+// The output of this task is a TTree with converted events, which is saved in a file
+// and can then be processed as many times as desired, to build invariant mass spectra.
// ---
-// adapted for Analysis Framework
-// by : R. Vernet (email: renaud.vernet@cern.ch)
-//----------------------------------------------------------------------------------
+// original author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
+// adapted for Analysis Framework by: R. Vernet (renaud.vernet@cern.ch)
+//
#ifndef AliRsnReaderTaskSE_H
#define AliRsnReaderTaskSE_H
#include "AliAnalysisTaskSE.h"
-//#include "AliRsnReader.h"
-//#include "AliRsnPID.h"
-class AliESDEvent;
class AliRsnPID;
+class AliESDEvent;
class AliRsnReader;
class AliRsnReaderTaskSE : public AliAnalysisTaskSE
public:
AliRsnReaderTaskSE();
- AliRsnReaderTaskSE(const char *name);
- virtual ~AliRsnReaderTaskSE() {Clear();}
+ AliRsnReaderTaskSE(const char *name);
+ virtual ~AliRsnReaderTaskSE() {Clear();}
// Implementation of interface methods
virtual void UserCreateOutputObjects();
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;}
-
- // getters
- AliRsnReader* GetReader() {return fReader;}
- AliRsnPID* GetPID() {return fPID;}
+ void SetReader(AliRsnReader *reader) {fReader = reader;}
+ void SetPID(AliRsnPID *pid) {fPID = pid;}
+ AliRsnReader* GetReader() {return fReader;}
+ AliRsnPID* GetPID() {return fPID;}
+ AliRsnEvent* GetCurrentEvent() {return fRsnEvent;}
private:
- AliRsnReaderTaskSE(const AliRsnReaderTaskSE&);
- AliRsnReaderTaskSE& operator=(const AliRsnReaderTaskSE&);
+ AliRsnReaderTaskSE(const AliRsnReaderTaskSE ©) :
+ AliAnalysisTaskSE(copy),fReader(0x0),fPID(0x0),fRsnEvent(0x0) { /*nothing*/ }
+ AliRsnReaderTaskSE& operator=(const AliRsnReaderTaskSE&)
+ { /*nothing*/ return (*this); }
- AliRsnReader *fReader; // read manager
- AliRsnPID *fPID; // particle identification manager
- AliRsnEvent *fRsnEvent; // output events in the AliRsnEvent format
+ AliRsnReader *fReader; // read manager
+ AliRsnPID *fPID; // PID manager
+ AliRsnEvent *fRsnEvent; // output events in the AliRsnEvent format
- ClassDef(AliRsnReaderTaskSE, 0); // implementation of RsnReader as AnalysisTaskSE
+ ClassDef(AliRsnReaderTaskSE, 1); // implementation of RsnReader as AnalysisTaskSE
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff