#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliAODHandler.h"
+#include "AliAODExtension.h"
#include "AliAODTrack.h"
#include "AliAODJet.h"
#include "AliAODMCParticle.h"
#include "AliAODEvent.h"
#include "AliAODJetEventBackground.h"
#include "AliAODHandler.h"
+#include "AliAODExtension.h"
#include "AliMCEventHandler.h"
#include "AliESDInputHandler.h"
#include "AliMCEvent.h"
}
//-----------------------------------------------------------------------------------
-void AliDAJetFinder::DoubleClusters(Int_t nc,Int_t &nk, TVectorD *vPy, TMatrixD *mY) const
+void AliDAJetFinder::DoubleClusters(Int_t nc,Int_t &nk, TVectorD *vPy, TMatrixD *mY) const
{
+// Return double clusters
for(Int_t iClust=0; iClust<nc; iClust++){
(*vPy)(iClust)=(*vPy)(iClust)/2;
(*vPy)(nc+iClust)=(*vPy)(iClust);
//-----------------------------------------------------------------------------------
void AliDAJetFinder::NumCl(Int_t &nc,Int_t &nk,TVectorD *vPy, TMatrixD *mPyx,TMatrixD *mY)
{
+ // Number of clusters
static Bool_t growcl=true;
if (nk==2) growcl=true;
//-----------------------------------------------------------------------------------
void AliDAJetFinder::ReduceClusters(Int_t **iSame,Int_t nc,Int_t &ncout,Int_t **cont,Int_t *nSameOut) const
{
+// Reduction step
Int_t *nSame = new Int_t[nc];
Int_t *iperm = new Int_t[nc];
Int_t *go = new Int_t[nc];
void Annealing (Int_t nk, Double_t **xData, TVectorD *vPx, TVectorD *vPy, TMatrixD *mPyx, TMatrixD *mY);
void NumCl (Int_t &nc, Int_t &nk, TVectorD *vPy, TMatrixD *mPyx, TMatrixD *mY);
void ReduceClusters(Int_t **iSame, Int_t nc, Int_t &ncout, Int_t **cont, Int_t *nSameOut) const;
- void DoubleClusters(Int_t nc, Int_t &nk, TVectorD *vPy, TMatrixD *mY) const;
+ void DoubleClusters(Int_t nc, Int_t &nk, TVectorD *vPy, TMatrixD *mY) const;
void EndDetAnn (Int_t &nk, Double_t **xData, Int_t *xx, Double_t etx, TVectorD *px, TVectorD *py, TMatrixD *pyx, TMatrixD *y);
void StoreJets (Int_t nk, Double_t **xData, Int_t *xx, TMatrixD *mY);
if (nmctracks < nstudymin) {
- Printf("Too few particles, abort");
+ Printf("Too few particles, stopping");
return -2;
}
fastjet::RecombinationScheme fRecombScheme; // = fastjet::BIpt_scheme;
//fastjet::GhostedAreaSpec parameters
- Double_t fGhostEtaMax;
- Double_t fGhostArea;
- Int_t fActiveAreaRepeats;
+ Double_t fGhostEtaMax; // max area of ghosts
+ Double_t fGhostArea; // ghost area
+ Int_t fActiveAreaRepeats; // number of repetitions of active area
//fastjet::AreaDefinition parameters
- fastjet::AreaType fAreaType;
+ fastjet::AreaType fAreaType; // the are type
//fastjet::ClusterSequenceArea options parameters
Double_t fPtMin; //jets with pt > ptmin
protected:
//fastjet::JetDefinition parameters
- Double_t fRparam;
+ Double_t fRparam; // R param
Double_t fRparamBkg;//R param for bkg calculation
fastjet::JetAlgorithm fAlgorithm; //fastjet::kt_algorithm
fastjet::Strategy fStrategy; //= fastjet::Best;
fastjet::RecombinationScheme fRecombScheme; // = fastjet::BIpt_scheme;
//fastjet::GhostedAreaSpec parameters
- Double_t fGhostEtaMax;
- Double_t fGhostArea;
- Int_t fActiveAreaRepeats;
+ Double_t fGhostEtaMax; // Max eta for ghosts
+ Double_t fGhostArea; // Ghost area
+ Int_t fActiveAreaRepeats; // Active are repetitions
//fastjet::AreaDefinition parameters
- fastjet::AreaType fAreaType;
+ fastjet::AreaType fAreaType; // area types
//fastjet::ClusterSequenceArea options parameters
Double_t fPtMin; //jets with pt > ptmin
}
-Double_t AliFastJetInput::Thermalspectrum(Double_t *x, Double_t *par){
+Double_t AliFastJetInput::Thermalspectrum(const Double_t *x, const Double_t *par){
return x[0]*TMath::Exp(-x[0]/par[0]);
void FillInput();
vector<fastjet::PseudoJet> GetInputParticles() const {return fInputParticles;}
vector<fastjet::PseudoJet> GetInputParticlesCh() const {return fInputParticlesCh;}
-
Float_t EtaToTheta(Float_t arg);
- static Double_t Thermalspectrum(Double_t *x, Double_t *par);
+ static Double_t Thermalspectrum(const Double_t *x, const Double_t *par);
private:
AliJetReader *fReader; //! reader
//____________________________________________________________________________
void AliJetAODFillUnitArrayEMCalDigits::GetTracksPointingToCell(TArrayS* array,Double_t eta, Double_t phi, Double_t cut)
{
-
+// Get all tracks pointing to cell
int size=0;
for (Int_t itrk = 0; itrk < fAOD->GetNumberOfTracks() ; itrk++) { //track loop
// Getters
Int_t GetNaod() const {return fNaod;}
- UInt_t GetTestFilterMask(){return fTestFilterMask;}
+ UInt_t GetTestFilterMask() const {return fTestFilterMask;}
TString GetNonStdBranch() const { return fNonStdBranch; }
Bool_t GetReadStdBranch() const { return (fReadBranches & kReadStdBranch); }
Bool_t GetReadNonStdBranch() const { return (fReadBranches & kReadNonStdBranch); }
//___________________________________________________________________
Float_t AliJetBkg::BkgFastJet(){
-
+// Return background
AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
Bool_t debug = header->GetDebug(); // debug option
}
//___________________________________________________________________
Float_t AliJetBkg::BkgChargedFastJet(){
-
+// Background for charged jets
AliFastJetHeaderV1 *header = (AliFastJetHeaderV1*)fHeader;
Bool_t debug = header->GetDebug(); // debug option
}
-Bool_t AliJetBkg::EmcalAcceptance(const Float_t eta, const Float_t phi, const Float_t radius){
-
+Bool_t AliJetBkg::EmcalAcceptance(const Float_t eta, const Float_t phi, const Float_t radius) const{
+// Apply emcal acceptance cuts
Float_t meanPhi=190./180.*TMath::Pi()-110./180.*TMath::Pi()/2;
Float_t deltaphi=110./180.*TMath::Pi();
Float_t phicut=deltaphi/2.-radius;
// Float_t BkgRemoveJetLeading(TClonesArray* fAODJets);
Float_t BkgRemoveJetLeadingFromUArray(TClonesArray* fAODJets);
Float_t EtaToTheta(Float_t arg);
- Bool_t EmcalAcceptance(const Float_t eta, const Float_t phi, const Float_t radius);
+ Bool_t EmcalAcceptance(const Float_t eta, const Float_t phi, const Float_t radius) const;
static Double_t BkgFunction(Double_t *x,Double_t *par);
private:
}
//------------------------------------------------------------------------------------
-void AliJetDummyGeo::EtaPhiFromIndex(Int_t absId, Float_t& eta, Float_t& phi)
+void AliJetDummyGeo::EtaPhiFromIndex(Int_t absId, Float_t& eta, Float_t& phi) const
{
// Nov 16, 2006- float to double
// version for TRD1 only
Float_t GetArm1PhiMin() const {return fArm1PhiMin;}
Float_t GetArm1PhiMax() const {return fArm1PhiMax;}
Float_t GetIPDistance() const {return fIPDistance;}
- void EtaPhiFromIndex(Int_t id, Float_t& eta, Float_t& phi);
+ void EtaPhiFromIndex(Int_t id, Float_t& eta, Float_t& phi) const;
void GetGlobal(const Double_t *loc, Double_t *glob, Int_t ind) const;
void GetGlobal(Int_t absId, Double_t glob[3]) const;
void GetGlobal(Int_t absId, TVector3 &vglob) const;
} else {xr = fOK1.Y(); zr = fOK1.X();
}
}
- void GetCenterOfCellInLocalCoordinateofSM3X3(Int_t ieta, Double_t &xr, Double_t &zr) const
- {
- // Center of cell
- // 3X3 case - Nov 9,2006
- ieta = ieta<0? 0 : ieta; // check index
- ieta = ieta>2? 2 : ieta;
- xr = fOK3X3[2-ieta].Y();
- zr = fOK3X3[2-ieta].X();
- }
- void GetCenterOfCellInLocalCoordinateofSM1X1(Double_t &xr, Double_t &zr) const
- {
- // 1X1 case - Nov 27,2006
- // Center of cell is center of module
- xr = fOK.Y() - fgr;
- zr = fOK.X();
- }
+ void GetCenterOfCellInLocalCoordinateofSM3X3(Int_t ieta, Double_t &xr, Double_t &zr) const;
+ void GetCenterOfCellInLocalCoordinateofSM1X1(Double_t &xr, Double_t &zr) const;
// 15-may-06
TVector2& GetCenterOfModuleFace() {return fOB;}
TVector2& GetCenterOfModuleFace(Int_t ieta) {
Int_t fDebug; // debug flag
ClassDef(AliJetDummyShishKebabTrd1Module,1) // TRD1 Shish-Kebab module
};
+inline
+ void AliJetDummyShishKebabTrd1Module::GetCenterOfCellInLocalCoordinateofSM3X3(Int_t ieta, Double_t &xr, Double_t &zr) const
+ {
+ // Center of cell
+ // 3X3 case - Nov 9,2006
+ ieta = ieta<0? 0 : ieta; // check index
+ ieta = ieta>2? 2 : ieta;
+ xr = fOK3X3[2-ieta].Y();
+ zr = fOK3X3[2-ieta].X();
+ }
+inline
+ void AliJetDummyShishKebabTrd1Module::GetCenterOfCellInLocalCoordinateofSM1X1(Double_t &xr, Double_t &zr) const
+ {
+ // 1X1 case - Nov 27,2006
+ // Center of cell is center of module
+ xr = fOK.Y() - fgr;
+ zr = fOK.X();
+ }
#endif
new ((*fAODjets)[fNAODjets++]) AliAODJet(p);
}
-void AliJetFinder::ConnectAOD(AliAODEvent* aod)
+void AliJetFinder::ConnectAOD(const AliAODEvent* aod)
{
// Connect to the AOD
fAODjets = aod->GetJets();
virtual Bool_t ProcessEvent();
virtual Bool_t ProcessEvent2();
virtual void ConnectTree(TTree* tree, TObject* data);
- virtual void ConnectAOD(AliAODEvent* aod);
+ virtual void ConnectAOD(const AliAODEvent* aod);
virtual void ConnectAODNonStd(AliAODEvent* aod,const char* bname);
virtual void WriteHeaders();
Double_t
AliJetHadronCorrectionv0::GetEnergy(Double_t pmom, Double_t eta, Int_t /*gid*/)
{
+// Get energy for momentum pmom and pseudorapidity eta
Int_t iEta=0; // index
Double_t etaw = TMath::Abs(eta);
if(etaw > etaGrid[maxVariant-1]) etaw = etaGrid[maxVariant-1];
class AliJetHadronCorrectionv0: public AliJetHadronCorrection {
- private:
- static AliJetHadronCorrectionv0* fHadrCorr;
+ public:
+ static AliJetHadronCorrectionv0* Instance();
+ virtual Double_t GetEnergy(Double_t pmom, Double_t eta, Int_t gid);
+ Double_t GetEnergy(Double_t pmom, Double_t eta){return GetEnergy(pmom,eta,7);}
+ virtual ~AliJetHadronCorrectionv0() {}
protected:
AliJetHadronCorrectionv0() {;}
AliJetHadronCorrectionv0(const char *name, const char *title);
- public:
- static AliJetHadronCorrectionv0* Instance();
- virtual Double_t GetEnergy(Double_t pmom, Double_t eta, Int_t gid);
- Double_t GetEnergy(Double_t pmom, Double_t eta){return GetEnergy(pmom,eta,7);}
- virtual ~AliJetHadronCorrectionv0() {}
+ private:
+ static AliJetHadronCorrectionv0* fHadrCorr; // pointer to instance
ClassDef(AliJetHadronCorrectionv0,1) // Hadron correction for EMC (version for MDC)
};
return fgHadrCorr;
}
-void AliJetHadronCorrectionv1::SetGeometry2(AliJetDummyGeo *geometry)
+void AliJetHadronCorrectionv1::SetGeometry2(const AliJetDummyGeo *geometry)
{
// Initialise EMCAL geometry
if (!geometry)
}
-void AliJetHadronCorrectionv1::TrackPositionEMCal(AliAODTrack* track,Double_t &eta, Double_t &phi)
+void AliJetHadronCorrectionv1::TrackPositionEMCal(const AliAODTrack* track,Double_t &eta, Double_t &phi)
{
+// Return track position on EMCal
AliAODPid* pid = (AliAODPid*) track->GetDetPid();
if(pid) {
Double_t GetEnergy(Double_t pmom, Double_t eta){return GetEnergy(pmom,eta,7);}
void SetGeometry(TString name, Double_t fs = 1.);
- void SetGeometry2(AliJetDummyGeo *geometry);
- void TrackPositionEMCal(AliAODTrack* track,Double_t &eta, Double_t &phi);
+ void SetGeometry2(const AliJetDummyGeo *geometry);
+ void TrackPositionEMCal(const AliAODTrack* track,Double_t &eta, Double_t &phi);
protected:
AliJetHadronCorrectionv1():fSamplingFraction(0) {for (Int_t i = 0; i < 8; i++) fPar[i] = 0.;}
static AliJetHadronCorrectionv1* fgHadrCorr; // Pointer to global instance (singleton)
static Double_t fgParLookup[HCPARAMETERS][HCPARAMETERSETS]; // Global array with parameters for hadronic response
- Double_t fPar[8];
+ Double_t fPar[8]; // Parameters
Float_t fSamplingFraction; // Sampling fraction
ClassDef(AliJetHadronCorrectionv1,2) // Hadron correction for EMC (version for MDC)
AliJetHistos::~AliJetHistos()
{
+// Destructor
delete fNJetsH;
delete fPtH;
delete fEtaH;
void AliJetHistos::AddHistosToList(TList *list)
{
+// Add histos to the list
list->Add(fNJetsH);
list->Add(fPtH);
list->Add(fEtaH);
void AliJetHistos::FillHistos(TClonesArray *jets)
{
-
+// Fill histograms
if(!jets)return;
Int_t nj = jets->GetEntries();
fNJetsH->Fill(nj,1);
protected:
//parameters set by user
- Bool_t fFastSimTPC;
- Bool_t fFastSimEMCAL;
- Bool_t fChargedOnly;
+ Bool_t fFastSimTPC; // TPC fast simulation flag
+ Bool_t fFastSimEMCAL; // EMCAL fast simulation flag
+ Bool_t fChargedOnly; // Charged particle only flag
ClassDef(AliJetKineReaderHeader,2);
};
void GetPtHardLimits(Int_t bin, Float_t& ptmin, Float_t& ptmax);
TString GetRunTitle(Int_t bin);
Float_t GetWeight(Int_t bin);
-
+ protected:
Int_t fNbins; // Number of pt_hard bins used in the production
Float_t* fPtHardLimits; //[fNbins+1]
Float_t* fWeights; //[fNbins]
Int_t fCluster; // cluster type
Int_t fDebug; // debug option
Bool_t fDZ; // include dead zones or not
- Int_t fSignalPerBg;
+ Int_t fSignalPerBg; // Signal per Background
Float_t fFiducialEtaMin; // Fiducial minimum eta
Float_t fFiducialEtaMax; // Fiducial maximum eta
Float_t fFiducialPhiMin; // Fiducial minimum phi
virtual void Terminate();
protected:
- AliJetFinder* fJetFinder;
+ AliJetFinder* fJetFinder; // Pointer to jet finder
ClassDef(AliJetSelector, 1)
};
}
//------------------------------------------------------------------------
-Bool_t AliJetUnitArray::operator>(AliJetUnitArray* unit) const
+Bool_t AliJetUnitArray::operator>(const AliJetUnitArray* unit) const
{
// Greater than operator used by sort
if( fUnitEnergy > unit->GetUnitEnergy())
}
//------------------------------------------------------------------------
-Bool_t AliJetUnitArray::operator<( AliJetUnitArray* unit) const
+Bool_t AliJetUnitArray::operator<(const AliJetUnitArray* unit) const
{
// Less than operator used by sort
if( fUnitEnergy < unit->GetUnitEnergy())
}
//------------------------------------------------------------------------
-Bool_t AliJetUnitArray::operator==( AliJetUnitArray* unit) const
+Bool_t AliJetUnitArray::operator==(const AliJetUnitArray* unit) const
{
// equality operator used by sort
if( fUnitEnergy == unit->GetUnitEnergy())
protected:
AliJetUnitArray(const AliJetUnitArray& rUnit);
AliJetUnitArray& operator = (const AliJetUnitArray& rhs);
- Bool_t operator> ( AliJetUnitArray* unit1) const;
- Bool_t operator< ( AliJetUnitArray* unit1) const;
- Bool_t operator== ( AliJetUnitArray* unit1) const;
+ Bool_t operator> (const AliJetUnitArray* unit1) const;
+ Bool_t operator< (const AliJetUnitArray* unit1) const;
+ Bool_t operator== (const AliJetUnitArray* unit1) const;
Float_t fUnitEnergy; // Energy (Pt,et) of the unit
Float_t fUnitEta; // Eta of the unit
Double_t AliKMeansClustering::fBeta = 10.;
-Int_t AliKMeansClustering::SoftKMeans(Int_t k, Int_t n, Double_t* x, Double_t* y, Double_t* mx, Double_t* my , Double_t* rk )
+Int_t AliKMeansClustering::SoftKMeans(Int_t k, Int_t n, const Double_t* x, const Double_t* y, Double_t* mx, Double_t* my , Double_t* rk )
{
//
// The soft K-means algorithm
-void AliKMeansClustering::OptimalInit(Int_t k, Int_t n, Double_t* x, Double_t* y, Double_t* mx, Double_t* my)
+void AliKMeansClustering::OptimalInit(Int_t k, Int_t n, const Double_t* x, const Double_t* y, Double_t* mx, Double_t* my)
{
//
// Optimal initialisation using the k-means++ algorithm
TMath::Sort(fK, fTarget, fInd);
}
-void AliKMeansResult::Sort(Int_t n, Double_t* x, Double_t* y)
+void AliKMeansResult::Sort(Int_t n, const Double_t* x, const Double_t* y)
{
// Build target array and sort
for (Int_t i = 0; i < fK; i++)
TMath::Sort(fK, fTarget, fInd);
}
-void AliKMeansResult::CopyResults(AliKMeansResult* res)
+void AliKMeansResult::CopyResults(const AliKMeansResult* res)
{
fK = res->GetK();
for (Int_t i = 0; i <fK; i++) {
AliKMeansClustering() {}
virtual ~AliKMeansClustering() {}
- static Int_t SoftKMeans (Int_t k, Int_t n, Double_t* x, Double_t* y, Double_t* mx, Double_t* my , Double_t* rk );
+ static Int_t SoftKMeans (Int_t k, Int_t n, const Double_t* x, const Double_t* y, Double_t* mx, Double_t* my , Double_t* rk );
static Int_t SoftKMeans2(Int_t k, Int_t n, Double_t* x, Double_t* y, Double_t* mx, Double_t* my , Double_t* sigma2,
Double_t* rk );
static Int_t SoftKMeans3(Int_t k, Int_t n, Double_t* x, Double_t* y, Double_t* mx, Double_t* my ,
Double_t* sigmax2, Double_t* sigmay2, Double_t* rk );
- static void OptimalInit(Int_t k, Int_t n, Double_t* x, Double_t* y, Double_t* mx, Double_t* my);
+ static void OptimalInit(Int_t k, Int_t n, const Double_t* x, const Double_t* y, Double_t* mx, Double_t* my);
static void SetBeta(Double_t beta) {fBeta = beta;}
static Double_t d(Double_t mx, Double_t my, Double_t x, Double_t y);
protected:
- static Double_t fBeta;
+ static Double_t fBeta; // beta parameter
ClassDef(AliKMeansClustering, 1)
};
Double_t* GetRk() const {return fRk;}
Int_t* GetInd() const {return fInd;}
Double_t* GetTarget() const {return fTarget;}
- void CopyResults(AliKMeansResult* res);
+ void CopyResults(const AliKMeansResult* res);
void Sort();
- void Sort(Int_t n, Double_t* x, Double_t* y);
+ void Sort(Int_t n, const Double_t* x, const Double_t* y);
protected:
Int_t fK; //! Number of clusters
Double_t* fMx; //! Position x
////////////////////////////////////////////////////////////////////////
void AliUA1JetFinderV2::SubtractBackgCone(const Int_t& nIn, const Int_t&nJ,Float_t& etbgTotalN,
- Float_t* ptT, Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
+ const Float_t* ptT, const Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
Float_t* const etJet, const Float_t* etaJet, const Float_t* phiJet,
Float_t* const etsigJet, Int_t* const multJet, Int_t* const injet)
{
////////////////////////////////////////////////////////////////////////
void AliUA1JetFinderV2::SubtractBackgRatio(const Int_t& nIn, const Int_t&nJ,Float_t& etbgTotalN,
- Float_t* ptT, Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
+ const Float_t* ptT, const Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
Float_t* const etJet, const Float_t* etaJet, const Float_t* phiJet,
Float_t* const etsigJet, Int_t* const multJet, Int_t* const injet)
{
Float_t* const etsigJet, Int_t* const multJet, Int_t* const injet);
void SubtractBackgCone(const Int_t& nIn, const Int_t&nJ,Float_t& EtbgTotalN,
- Float_t* ptT, Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
+ const Float_t* ptT, const Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
Float_t* const etJet, const Float_t* etaJet, const Float_t* phiJet,
Float_t* const etsigJet, Int_t* const multJet, Int_t* const injet);
void SubtractBackgRatio(const Int_t& nIn, const Int_t&nJ,Float_t& EtbgTotalN,
- Float_t* ptT, Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
+ const Float_t* ptT, const Float_t* etaT, const Float_t* phiT, const Int_t* cFlagT, const Int_t* sFlagT,
Float_t* const etJet, const Float_t* etaJet, const Float_t* phiJet,
Float_t* const etsigJet, Int_t* const multJet, Int_t* const injet);