#include "AliJet.h"
ClassImp(AliJet)
-
-
-AliJet::AliJet()
+
+AliJet::AliJet():
+ fNInput(0),
+ fNJets(0),
+ fEtAvg(0),
+ fInJet(0),
+ fMultiplicities(0),
+ fNCells(0),
+ fPtFromSignal(0),
+ fJets(0),
+ fEtaIn(0),
+ fPhiIn(0),
+ fPtIn(0)
{
- // Constructor
+ // Default constructor
fJets = new TClonesArray("TLorentzVector",1000);
- fNInput=0;
- fNJets=0;
- fEtAvg = 0;
- fInJet=TArrayI();
- fPtIn=TArrayF();
- fEtaIn=TArrayF();
- fPhiIn=TArrayF();
- fPtFromSignal=TArrayF();
- fMultiplicities=TArrayI();
- fNCells=TArrayI();
+ fInJet = TArrayI();
+ fPtIn = TArrayF();
+ fEtaIn = TArrayF();
+ fPhiIn = TArrayF();
+ fPtFromSignal = TArrayF();
+ fMultiplicities = TArrayI();
+ fNCells = TArrayI();
}
////////////////////////////////////////////////////////////////////////
~AliJet();
// Getters
- Int_t GetNinput() const { return fNInput; }
+ Int_t GetNinput() const {return fNInput;}
Int_t GetNJets() const {return fNJets;}
TClonesArray* GetJets() const {return fJets;}
TArrayI GetInJet() const {return fInJet;}
TArrayI GetMultiplicities() const {return fMultiplicities;}
TArrayI GetNCells() const {return fNCells;}
TArrayF GetPtFromSignal() const {return fPtFromSignal;}
- TArrayF GetEtaIn() const { return fEtaIn; }
- TArrayF GetPhiIn() const { return fPhiIn; }
- TArrayF GetPtIn() const { return fPtIn; }
- Double_t GetEtAvg() const { return fEtAvg; }
+ TArrayF GetEtaIn() const {return fEtaIn;}
+ TArrayF GetPhiIn() const {return fPhiIn;}
+ TArrayF GetPtIn() const {return fPtIn;}
+ Double_t GetEtAvg() const {return fEtAvg;}
TLorentzVector* GetJet(Int_t i);
Int_t GetMultiplicity(Int_t i) const;
protected:
+ AliJet(const AliJet& rJet);
+ AliJet& operator = (const AliJet& rhs);
+
Int_t fNInput; // number of input objects
Int_t fNJets; // number of jets found
Double_t fEtAvg; // average background et per cell
#include "AliLeading.h"
-AliJetAnalysis::AliJetAnalysis()
+AliJetAnalysis::AliJetAnalysis():
+ fReaderHeader(0x0),
+ fDirectory(0x0),
+ fBkgdDirectory(0x0),
+ fFile(0x0),
+ fEventMin(0),
+ fEventMax(-1),
+ fRunMin(0),
+ fRunMax(11),
+ fminMult(0),
+ fPercentage(-1.0),
+ fPartPtCut(0.0),
+ fdrJt(1.0),
+ fdrdNdxi(0.7),
+ fdrdEdr(1.0),
+ fEfactor(1.0),
+ fp0(0.0),
+ fPtJ(0.0),
+ fEJ(0.0),
+ fEtaJ(0.0),
+ fPhiJ(0.0),
+ fjv3X(0.0),
+ fjv3Y(0.0),
+ fjv3Z(0.0),
+ fPythia(kFALSE),
+ fDoPart(kTRUE),
+ fDoGenJ(kTRUE),
+ fDoRecJ(kTRUE),
+ fDoKine(kTRUE),
+ fDoCorr(kTRUE),
+ fDoCorr50(kFALSE),
+ fDoShap(kTRUE),
+ fDoFrag(kTRUE),
+ fDoTrig(kTRUE),
+ fDoJt(kTRUE),
+ fDodNdxi(kTRUE),
+ fDoBkgd(kTRUE),
+ fWeight(1.0),
+ fWShapR(0.0),
+ fWFragR(0.0),
+ fWdEdr(0.0),
+ fWJt(0.0),
+ fWdNdxi(0.0),
+ fPart(0),
+ fGenJ(0),
+ fRecJ(0),
+ fRecB(0),
+ fRKineEneH(0),
+ fRKinePtH(0),
+ fRKinePhiH(0),
+ fRKineEtaH(0),
+ fGKineEneH(0),
+ fGKinePtH(0),
+ fGKinePhiH(0),
+ fGKineEtaH(0),
+ fPKineEneH(0),
+ fPKinePtH(0),
+ fPKinePhiH(0),
+ fPKineEtaH(0),
+ fPGCorrEneH(0),
+ fPGCorrPtH(0),
+ fPGCorrEtaH(0),
+ fPGCorrPhiH(0),
+ fPRCorrEneH(0),
+ fPRCorrPtH(0),
+ fPRCorrEtaH(0),
+ fPRCorrPhiH(0),
+ fRGCorrEneH(0),
+ fRGCorrPtH(0),
+ fRGCorrEtaH(0),
+ fRGCorrPhiH(0),
+ fPRCorr50EneH(0),
+ fPRCorr50PtH(0),
+ fPRCorr50EtaH(0),
+ fPRCorr50PhiH(0),
+ fRGCorr50EneH(0),
+ fRGCorr50PtH(0),
+ fRGCorr50EtaH(0),
+ fRGCorr50PhiH(0),
+ fRFragSelH(0),
+ fRFragRejH(0),
+ fRFragAllH(0),
+ fRShapSelH(0),
+ fRShapRejH(0),
+ fRShapAllH(0),
+ fGTriggerEneH(0),
+ fRTriggerEneH(0),
+ fGPTriggerEneH(0),
+ fPTriggerEneH(0),
+ fdEdrH(0),
+ fdEdrB(0),
+ fPtEneH2(0),
+ fdEdrW(0),
+ fJtH(0),
+ fJtB(0),
+ fJtW(0),
+ fdNdxiH(0),
+ fdNdxiB(0),
+ fdNdxiW(0),
+ fPtEneH(0)
{
- // Constructor
- fDirectory = 0x0;
- fBkgdDirectory = 0x0;
- fFile = "anajets.root";
- fEventMin = 0;
- fEventMax = -1;
- fRunMin = 0;
- fRunMax = 11;
- fminMult = 0;
- fPercentage = -1.0;
- fEfactor = 1.0;
- SetReaderHeader();
+ // Default constructor
+ fFile = "anaJets.root";
- // for Analize()
- fPythia = kFALSE;
- fDoPart = kTRUE;
- fDoGenJ = kTRUE;
- fDoRecJ = kTRUE;
- fDoKine = kTRUE;
- fDoCorr = kTRUE;
- fDoCorr50 = kFALSE;
- fDoShap = kTRUE;
- fDoFrag = kTRUE;
- fDoTrig = kTRUE;
- fDoJt = kTRUE;
- fDodNdxi = kTRUE;
- fDoBkgd = kFALSE;
-
- fPart = 0;
- fGenJ = 0;
- fRecJ = 0;
- fRecB = 0;
- fWeight = 1.0;
- fWdEdr = 0.0;
- fPartPtCut = 0.0;
- fWJt = 0.0;
- fWdNdxi = 0.0;
-
- // for bkgd
- fp0 = 0.0;
- fPtJ = 0.0;
- fEJ = 0.0;
- fEtaJ = 0.0;
- fPhiJ = 0.0;
- fjv3X = 0.0;
- fjv3Y = 0.0;
- fjv3Z = 0.0;
-
- // kine histos
- fRKineEneH = 0;
- fRKinePtH = 0;
- fRKinePhiH = 0;
- fRKineEtaH = 0;
- fGKineEneH = 0;
- fGKinePtH = 0;
- fGKinePhiH = 0;
- fGKineEtaH = 0;
- fPKineEneH = 0;
- fPKinePtH = 0;
- fPKinePhiH = 0;
- fPKineEtaH = 0;
-
- // correlation histograms
- fPGCorrEneH = 0;
- fPGCorrPtH = 0;
- fPGCorrEtaH = 0;
- fPGCorrPhiH = 0;
- fPRCorrEneH = 0;
- fPRCorrPtH = 0;
- fPRCorrEtaH = 0;
- fPRCorrPhiH = 0;
- fRGCorrEneH = 0;
- fRGCorrPtH = 0;
- fRGCorrEtaH = 0;
- fRGCorrPhiH = 0;
-
- // correlation histograms when one particle
- // has more than 50% of the energy of the jet
- fPRCorr50EneH = 0;
- fPRCorr50PtH = 0;
- fPRCorr50EtaH = 0;
- fPRCorr50PhiH = 0;
- fRGCorr50EneH = 0;
- fRGCorr50PtH = 0;
- fRGCorr50EtaH = 0;
- fRGCorr50PhiH = 0;
-
- // shape histos
- fWShapR = 0.0;
- fRShapSelH = 0;
- fRShapRejH = 0;
- fRShapAllH = 0;
-
- // fragmentation function histos
- fWFragR = 0.0;
- fRFragSelH = 0;
- fRFragRejH = 0;
- fRFragAllH = 0;
-
- // trigger bias histos
- fGTriggerEneH = 0;
- fRTriggerEneH = 0;
- fGPTriggerEneH = 0;
- fPTriggerEneH = 0;
-
- // dE/dr histo and its dr
- fdEdrH = 0;
- fdEdrB = 0;
- fPtEneH2 = 0;
- fdEdrW = 0;
- fdrdEdr = 1.0;
-
- // jt histo and its dr
- fJtH = 0;
- fJtB = 0;
- fJtW = 0;
- fdrJt = 1.0;
-
- // dN/dxi histo and its dr
- fdNdxiH = 0;
- fdNdxiB = 0;
- fdNdxiW = 0;
- fPtEneH = 0;
- fdrdNdxi = 0.7;
-
// initialize weight for dE/dr histo
SetdEdrWeight();
}
TH2F *fRGCorrEtaH; // Pseudorapidity correlation rec jet-gen jet
TH2F *fRGCorrPhiH; // Azimuthal angle correlation rec jet-gen jet
- // correlation histograms
+ // correlation histogramswhen one particle
+ // has more than 50% of the energy of the jet
TH2F *fPRCorr50EneH; // Energy correlation part-rec jet
TH2F *fPRCorr50PtH; // Pt correlation part-rec jet
TH2F *fPRCorr50EtaH; // Pseudorapidity correlation part-rec jet
TH1F* fdNdxiW; // dN/d#xi weight histo
TH2F* fPtEneH; // fPtEneH
+protected:
+ AliJetAnalysis(const AliJetAnalysis& rJetA);
+ AliJetAnalysis& operator = (const AliJetAnalysis& rhsa);
+
+
ClassDef(AliJetAnalysis,1)
};
////////////////////////////////////////////////////////////////////////
-AliJetControlPlots::AliJetControlPlots()
+AliJetControlPlots::AliJetControlPlots():
+ fNJetsH(0),
+ fMultH(0),
+ fPtH(0),
+ fEtaH(0),
+ fEneH(0),
+ fFragH(0),
+ fFragLnH(0),
+ fFragrH(0),
+ fFragLnrH(0),
+ fShapeH(0),
+ fShaperH(0),
+ fPhiH(0),
+ fInJetH(0),
+ fNJetT(0)
+
{
- // Constructor
- fNJetT=0;
+ // Default constructor
// general properties
fNJetsH = new TH1I("fNJetsH","Number of Jets",12,0,11);
void Normalize();
protected:
+ AliJetControlPlots(const AliJetControlPlots& rControlPlots);
+ AliJetControlPlots& operator = (const AliJetControlPlots& rcp);
+
TH1I *fNJetsH; // distribution of number of jets
TH1I *fMultH; // jet multiplicity
TH1D *fPtH; // pt spectra
////////////////////////////////////////////////////////////////////////
// constructor/destructor
-AliJetDistributions::AliJetDistributions()
+AliJetDistributions::AliJetDistributions():
+ fReaderHeader(0x0),
+ fDirectory(0x0),
+ fFile(0x0),
+ fEventMin(0),
+ fEventMax(-1),
+ fRunMin(0),
+ fRunMax(11),
+ fPercentage(-1.0),
+ fPartPtCut(0.0),
+ fPythia(kFALSE),
+ fDoPart(kTRUE),
+ fDoGenJ(kTRUE),
+ fDoRecJ(kTRUE),
+ fPart(0),
+ fGenJ(0),
+ fRecJ(0),
+ fRetaH(0),
+ fRphiH(0),
+ fRptH(0),
+ fRetaphiH(0),
+ fMultH(0)
{
- // Constructor
- fDirectory = 0x0;
- fFile = "jets.root";
- fEventMin = 0;
- fEventMax = -1;
- fRunMin = 0;
- fRunMax = 11;
- fPercentage = -1.0;
+ // Default constructor
+ fFile = "jets.root";
SetReaderHeader();
- fPart = 0;
- fGenJ = 0;
- fRecJ = 0;
-
- fRetaH = 0;
- fRphiH = 0;
- fRptH = 0;
- fRetaphiH = 0;
-
- fMultH = 0;
-
- // for Analize()
- fPythia = kFALSE;
- fDoPart = kTRUE;
- fDoGenJ = kTRUE;
- fDoRecJ = kTRUE;
-
}
////////////////////////////////////////////////////////////////////////
TH1F* fMultH; // Multiplicity
+ protected:
+ AliJetDistributions(const AliJetDistributions& rJetD);
+ AliJetDistributions& operator = (const AliJetDistributions& rhsd);
+
ClassDef(AliJetDistributions,1)
};
ClassImp(AliJetESDReader)
- AliJetESDReader::AliJetESDReader()
+AliJetESDReader::AliJetESDReader():
+ fMass(0),
+ fSign(0)
{
// Constructor
fReaderHeader = 0x0;
- fMass = 0;
- fSign = 0;
}
//____________________________________________________________________________
//____________________________________________________________________________
void AliJetESDReader::OpenInputFiles()
-
{
// chain for the ESDs
fChain = new TChain("esdTree");
track->GetPxPyPz(mom);
p3.SetXYZ(mom[0],mom[1],mom[2]);
pt = p3.Pt();
- if (((status & AliESDtrack::kITSrefit) == 0) ||
- ((status & AliESDtrack::kTPCrefit) == 0)) continue; // quality check
+ if ((status & AliESDtrack::kTPCrefit) == 0) continue; // quality check
+ //if ((status & AliESDtrack::kITSrefit) == 0) continue; // quality check
if (((AliJetESDReaderHeader*) fReaderHeader)->ReadSignalOnly()
- && TMath::Abs(track->GetLabel()) > 10000) continue; // quality check
+ && TMath::Abs(track->GetLabel()) > 10000) continue; // quality check
if (((AliJetESDReaderHeader*) fReaderHeader)->ReadBkgdOnly()
- && TMath::Abs(track->GetLabel()) < 10000) continue; // quality check
+ && TMath::Abs(track->GetLabel()) < 10000) continue; // quality check
eta = p3.Eta();
if ( (eta > etaMax) || (eta < etaMin)) continue; // checking eta cut
//____________________________________________________________________________
AliJetESDReaderHeader::AliJetESDReaderHeader():
- AliJetReaderHeader("AliJetESDReaderHeader")
+ AliJetReaderHeader("AliJetESDReaderHeader"),
+ fReadSignalOnly(kFALSE),
+ fReadBkgdOnly(kFALSE)
{
- // Constructor
- SetReadSignalOnly(kFALSE);
- SetReadBkgdOnly(kFALSE);
+ // Default constructor
}
ClassImp(AliJetESDmcReader)
-AliJetESDmcReader::AliJetESDmcReader()
+AliJetESDmcReader::AliJetESDmcReader():
+ fMass(0),
+ fSign(0)
{
// Constructor
fReaderHeader = 0x0;
- fMass = 0;
- fSign = 0;
}
//____________________________________________________________________________
ClassImp(AliJetFinder)
-AliJetFinder::AliJetFinder()
+AliJetFinder::AliJetFinder():
+ fPlotMode(kFALSE),
+ fJets(0),
+ fGenJets(0),
+ fLeading(0),
+ fReader(0x0),
+ fPlots(0x0),
+ fOut(0x0)
+
{
// Constructor
- fOut = 0x0;
+ //fOut = 0x0;
fJets = new AliJet();
fGenJets = new AliJet();
fLeading = new AliLeading();
- fReader = 0x0;
- fPlots = 0x0;
- SetPlotMode(kFALSE);
+ //fReader = 0x0;
+ //fPlots = 0x0;
+ //SetPlotMode(kFALSE);
}
////////////////////////////////////////////////////////////////////////
virtual void GetGenJets();
protected:
+ AliJetFinder(const AliJetFinder& rJetFinder);
+ AliJetFinder& operator = (const AliJetFinder& rhsf);
+
Bool_t fPlotMode; // do you want control plots?
AliJet* fJets; // pointer to jet class
AliJet* fGenJets; // pointer to generated jets
AliJetHeader::AliJetHeader():
TNamed("AliJetHeader", "Jet Header"),
- fComment("No comment")
+ fComment("No comment"),
+ fJetEtaMax(0.5),
+ fJetEtaMin(-0.5)
{
//
- // Constructor
+ // Default constructor
//
- fJetEtaMax = 0.5;
- fJetEtaMin = -0.5;
+
}
////////////////////////////////////////////////////////////////////////
AliJetHeader::AliJetHeader(const char * name):
TNamed(name, "Jet Header"),
- fComment("No comment")
+ fComment("No comment"),
+ fJetEtaMax(0.5),
+ fJetEtaMin(-0.5)
{
//
// Constructor
//
- fJetEtaMax = 0.5;
- fJetEtaMin = -0.5;
+
}
////////////////////////////////////////////////////////////////////////
ClassImp(AliJetKineReader)
-AliJetKineReader::AliJetKineReader()
+AliJetKineReader::AliJetKineReader():
+ fRunLoader(0x0),
+ fMass(0),
+ fPdgC(0)
{
- // Constructor
+ // Default constructor
fReaderHeader = 0x0;
- fRunLoader = 0x0;
- fMass = 0;
- fPdgC = 0;
}
//____________________________________________________________________________
Bool_t Efficiency(Float_t pt, Float_t eta, Float_t phi);
protected:
- AliRunLoader *fRunLoader; // Pointer to the run loader
+ AliJetKineReader(const AliJetKineReader& rJetKine);
+ AliJetKineReader& operator = (const AliJetKineReader& rkr);
+
+ AliRunLoader *fRunLoader; // Pointer to the run loader
- Float_t fMass; // Particle mass
- Int_t fPdgC; // Pdg code
+ Float_t fMass; // Particle mass
+ Int_t fPdgC; // Pdg code
ClassDef(AliJetKineReader,1)
};
//____________________________________________________________________________
AliJetKineReaderHeader::AliJetKineReaderHeader():
- AliJetReaderHeader("AliJetKineReaderHeader")
+ AliJetReaderHeader("AliJetKineReaderHeader"),
+ fFastSimTPC(kFALSE),
+ fFastSimEMCAL(kFALSE)
{
- // Constructor
- SetFastSimTPC(kFALSE);
- SetFastSimEMCAL(kFALSE);
+ // Default constructor
+
}
//____________________________________________________________________________
////////////////////////////////////////////////////////////////////////
-AliJetProductionData::AliJetProductionData()
+AliJetProductionData::AliJetProductionData():
+ fNbins(0),
+ fPtHardLimits(0x0),
+ fWeights(0x0),
+ fRunTitles(0x0)
{
- // Constructor
- fNbins = 0;
- fPtHardLimits = 0x0;
- fRunTitles = 0x0;
+ // Default constructor
+
}
////////////////////////////////////////////////////////////////////////
TString* fRunTitles; //[fNbins]
private:
+ AliJetProductionData(const AliJetProductionData& rJetPD);
+ AliJetProductionData& operator = (const AliJetProductionData& rjpd);
+
ClassDef(AliJetProductionData, 1)
};
////////////////////////////////////////////////////////////////////////
-AliJetReader::AliJetReader()
+AliJetReader::AliJetReader():
+ fChain(0),
+ fChainMC(0),
+ fMomentumArray(0),
+ fArrayMC(0),
+ fESD(0),
+ fReaderHeader(0),
+ fAliHeader(0),
+ fSignalFlag(0),
+ fCutFlag(0)
+
{
- // Constructor
- fChain = 0;
- fChainMC = 0;
- fESD = 0;
+ // Default constructor
fMomentumArray = new TClonesArray("TLorentzVector",2000);
- fArrayMC = 0;
- fAliHeader = 0;
fSignalFlag = TArrayI();
fCutFlag = TArrayI();
}
void ClearArray();
protected:
+ AliJetReader(const AliJetReader& rJetReader);
+ AliJetReader& operator = (const AliJetReader& rhsr);
+
TChain *fChain; // chain for reconstructed tracks
TChain *fChainMC; // chain for mc information
TClonesArray *fMomentumArray; // array of particle momenta
AliJetReaderHeader::AliJetReaderHeader():
TNamed("AliJetReaderHeader", "Jet Reader Header"),
- fComment("No comment"),fDir(""),fPattern("")
+ fNesd(0),
+ fFirst(0),
+ fLast(-1),
+ fFiducialEtaMin(-0.9),
+ fFiducialEtaMax(0.9),
+ fPtCut(2.0),
+ fDCA(0.),
+ fTLength(0.),
+ fComment("No comment"),
+ fDir(""),
+ fPattern("")
{
- // Constructor
- fFirst = 0;
- fLast = -1;
- fFiducialEtaMin = -0.9;
- fFiducialEtaMax = 0.9;
- SetPtCut();
+ // Default constructor
}
////////////////////////////////////////////////////////////////////////
AliJetReaderHeader::AliJetReaderHeader(const char * name):
TNamed(name, "Jet Reader Header"),
- fComment("No comment"),fDir(""),fPattern("")
+ fNesd(0),
+ fFirst(0),
+ fLast(-1),
+ fFiducialEtaMin(-0.9),
+ fFiducialEtaMax(0.9),
+ fPtCut(2.0),
+ fDCA(0.),
+ fTLength(0.),
+ fComment("No comment"),
+ fDir(""),
+ fPattern("")
{
// Constructor
- fFirst = 0;
- fLast = -1;
- fFiducialEtaMin = -0.9;
- fFiducialEtaMax = 0.9;
- SetPtCut();
}
////////////////////////////////////////////////////////////////////////
virtual const char* GetPattern() {return fPattern.Data();}
virtual Float_t GetFiducialEtaMin() const {return fFiducialEtaMin;}
virtual Float_t GetFiducialEtaMax() const {return fFiducialEtaMax;}
- virtual Float_t GetPtCut() const {return fPtCut;}
+ virtual Float_t GetPtCut() const {return fPtCut;}
Float_t GetDCA() const {return fDCA;} // not working so far..(always 0)
- Float_t GetTLength() const {return fTLength;} // not working so far.. (always 0)
+ Float_t GetTLength() const {return fTLength;} // not working so far.. (always 0)
Int_t GetNesd() const {return fNesd;}
Int_t GetNEvents() const {return fLast-fFirst;}
Int_t GetFirstEvent() const {return fFirst;}
Int_t GetLastEvent() const {return fLast;}
-
+
// Setters
virtual void SetComment(const char* s) {fComment=TString(s);}
virtual void SetPattern(const char* s) {fPattern=TString(s);}
virtual void SetPtCut(Float_t par = 2.0) {fPtCut = par;}
virtual void SetDCA(Float_t dca = 0.0) {fDCA = dca;}
virtual void SetTLength(Float_t length = 0.0) {fTLength = length;}
-
+
protected:
Int_t fNesd; // Number of ESDs to read
////////////////////////////////////////////////////////////////////////
-AliLeading::AliLeading()
+AliLeading::AliLeading():
+ fNassoc(0),
+ fLeading(0),
+ fCorr(0),
+ fnBin(45),
+ fLow(-TMath::Pi()/2.0),
+ fFound(kFALSE)
{
// Constructor
- fNassoc = 0;
fLeading = new TLorentzVector(0.,0.,0.,0.);
- fLow = -TMath::Pi()/2.0;
- fnBin = 45;
fCorr = TArrayI(fnBin);
- fFound = kFALSE;
}
////////////////////////////////////////////////////////////////////////
protected:
+ AliLeading(const AliLeading& rLeading);
+ AliLeading& operator = (const AliLeading& rl);
+
Int_t fNassoc; // number of associated particles
TLorentzVector* fLeading; // leading particle
TArrayI fCorr; // array to store azimuthal correlation
////////////////////////////////////////////////////////////////////////
-AliPxconeJetFinder::AliPxconeJetFinder()
-
+AliPxconeJetFinder::AliPxconeJetFinder():
+ fHeader(0)
{
//
// Constructor
//
- fHeader = 0;
}
////////////////////////////////////////////////////////////////////////
void WriteJHeaderToFile();
protected:
+ AliPxconeJetFinder(const AliPxconeJetFinder& rPxJet);
+ AliPxconeJetFinder& operator = (const AliPxconeJetFinder& rhsh);
AliPxconeJetHeader* fHeader; // pointer to jet header
////////////////////////////////////////////////////////////////////////
AliPxconeJetHeader::AliPxconeJetHeader():
- AliJetHeader("AliPxconeJetHeader")
+ AliJetHeader("AliPxconeJetHeader"),
+ fMode(2),
+ fRadius(0.3),
+ fMinPt(10),
+ fOverlap(0.75)
{
- // Constructor
+ // Default constructor
SetMode();
SetRadius();
SetMinPt();
// Setters
void SetMode(Int_t m=2) {fMode=m;}
void SetRadius(Double_t r=0.3) {fRadius=r;}
- void SetMinPt(Double_t p=10.0) {fMinPt=p;}
- void SetOverlap(Double_t o=.75) {fOverlap=o;}
+ void SetMinPt(Double_t p=10) {fMinPt=p;}
+ void SetOverlap(Double_t o=0.75) {fOverlap=o;}
// others
void PrintParameters() const;
////////////////////////////////////////////////////////////////////////
-AliUA1JetFinder::AliUA1JetFinder()
-
+AliUA1JetFinder::AliUA1JetFinder():
+ fHeader(0x0),
+ fLego(0x0)
{
- // Constructor
- fHeader = 0x0;
- fLego = 0x0;
+ // Default constructor
}
////////////////////////////////////////////////////////////////////////
protected:
+ AliUA1JetFinder(const AliUA1JetFinder& rUA1Finder);
+ AliUA1JetFinder& operator = (const AliUA1JetFinder& ruaf);
+
AliUA1JetHeader* fHeader; // pointer to jet header
TH2F * fLego; //! Lego Histo
////////////////////////////////////////////////////////////////////////
-AliUA1JetFinderV1::AliUA1JetFinderV1()
-
+AliUA1JetFinderV1::AliUA1JetFinderV1():
+ fHeader(0x0),
+ fLego(0x0)
{
- // Constructor
- fHeader = 0x0;
- fLego = 0x0;
+ // Default constructor
+
}
////////////////////////////////////////////////////////////////////////
void WriteJHeaderToFile();
protected:
+ AliUA1JetFinderV1(const AliUA1JetFinderV1& rJetF1);
+ AliUA1JetFinderV1& operator = (const AliUA1JetFinderV1& rhsf);
AliUA1JetHeaderV1* fHeader; // pointer to jet header
TH2F * fLego; //! Lego Histo
////////////////////////////////////////////////////////////////////////
AliUA1JetHeader::AliUA1JetHeader():
- AliJetHeader("AliUA1JetHeader")
+ AliJetHeader("AliUA1JetHeader"),
+ fConeRadius(0.3),
+ fEtSeed(3.0),
+ fMinJetEt(10.),
+ fMinCellEt(0.),
+ fMode(1),
+ fMinMove(0.05),
+ fMaxMove(0.15),
+ fPrecBg(0.035),
+ fLegoNbinEta(36),
+ fLegoNbinPhi(124),
+ fLegoEtaMin(-0.9),
+ fLegoEtaMax(0.9),
+ fLegoPhiMin(0.),
+ fLegoPhiMax(2.*TMath::Pi()),
+ fOnlySignal(kFALSE),
+ fOnlyBkgd(kFALSE)
{
- // Constructor
- fConeRadius = 0.3;
- fEtSeed = 3.0;
- fMinJetEt = 10.0;
- fMinCellEt = 0.0;
- fMode = 1;
- fMinMove = 0.05;
- fMaxMove = 0.15;
- fPrecBg = 0.035;
- fLegoNbinEta = 36;
- fLegoNbinPhi = 124;
- fLegoPhiMin = 0.;
- fLegoPhiMax = 2. * TMath::Pi();
- fLegoEtaMin = -0.9;
- fLegoEtaMax = 0.9;
- fOnlySignal = kFALSE;
- fOnlyBkgd = kFALSE;
+ // Default constructor
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
AliUA1JetHeaderV1::AliUA1JetHeaderV1():
- AliJetHeader("AliUA1JetHeaderV1")
+
+ AliJetHeader("AliUA1JetHeaderV1"),
+ fConeRadius(0.3),
+ fEtSeed(3.0),
+ fMinJetEt(10.),
+ fMinMove(0.05),
+ fMaxMove(0.15),
+ fBackgMode(1),
+ fPrecBg(0.035),
+ fBackgStat(0.0),
+ fBackgCutRatio(1.0),
+ fNAcceptJets(3),
+ fLegoNbinEta(36),
+ fLegoNbinPhi(124),
+ fLegoEtaMin(-0.9),
+ fLegoEtaMax(0.9),
+ fLegoPhiMin(0.),
+ fLegoPhiMax(2.*TMath::Pi())
{
// Constructor
- fConeRadius = 0.3;
- fEtSeed = 3.0;
- fMinJetEt = 10.0;
- fMinMove = 0.05;
- fMaxMove = 0.15;
- fBackgMode = 1; // subtract backg
- fPrecBg = 0.035; //background prec
- fBackgStat = 0.0; // pre-calculated background used in statistic subtraction method
- fBackgCutRatio = 1.0; // pre-calculated pt-cut ratio used in ratio subtraction method
- fNAcceptJets = 3; // number of accepted jets per events
- fLegoNbinEta = 36;
- fLegoNbinPhi = 124;
- fLegoPhiMin = 0.;
- fLegoPhiMax = 2. * TMath::Pi();
- fLegoEtaMin = -0.9;
- fLegoEtaMax = 0.9;
}
////////////////////////////////////////////////////////////////////////
#pragma link C++ class AliJetProductionDataPDC2004+;
#pragma link C++ class AliJetAnalysis+;
#pragma link C++ class AliJetDistributions+;
+#pragma link C++ class AliFFT;
#pragma link C++ class AliUA1JetFinderV1+;
#pragma link C++ class AliUA1JetHeaderV1+;
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff