//____________________________________________________________________________
void AliPHOS::SetTreeAddress()
{
-
+ // Set tree address to hit array
TBranch *branch;
char branchname[20];
sprintf(branchname,"%s",GetName());
//
//*-- Author: Laurent Aphecetche & Yves Schutz (SUBATECH)
-#include <stdlib.h>
+//#include <stdlib.h>
// --- ROOT system ---
virtual const TString Version() const {return TString(" ") ; }
virtual void WriteQA() ;
AliPHOS & operator = (const AliPHOS & rvalue) {
- // assignement operator requested by coding convention
- // but not needed
- Fatal("operator =", "not implemented") ;
- return *this ;
+ // assignement operator requested by coding convention but not needed
+ Fatal("operator =", "not implemented") ; return *this ;
}
protected:
/*
$Log$
+ Revision 1.2 2001/05/31 22:46:32 schutz
+ Coding rule violation corrected
+
Revision 1.1 2000/11/03 16:27:47 schutz
CPV base geometry class to correct previous name-convetion rule violation
// --- AliRoot header files ---
-#include "AliPHOSCPVBaseGeometry.h"
+class AliPHOSCPVBaseGeometry
ClassImp(AliPHOSCPVBaseGeometry) ;
AliPHOSCPVDigit(Int_t x, Int_t y, Float_t q);
void SetQpad(Float_t q) { fQpad = q; }
- Int_t GetXpad() { return fXpad; }
- Int_t GetYpad() { return fYpad; }
- Float_t GetQpad() { return fQpad; }
+ Int_t GetXpad() const { return fXpad; }
+ Int_t GetYpad() const { return fYpad; }
+ Float_t GetQpad() const { return fQpad; }
private:
Int_t fXpad; // Digit's pad number in Phi
// Author: Yuri Kharlov (IHEP, Protvino)
// 7 November 2000
-#include <assert.h>
+//#include "AliPHOSCPVBaseGeometry.h"
+#include "TObject.h"
-#include "AliPHOSCPVBaseGeometry.h"
-
-class AliPHOSCPVGeometry : public AliPHOSCPVBaseGeometry {
+// class AliPHOSCPVGeometry : public AliPHOSCPVBaseGeometry {
+class AliPHOSCPVGeometry : public TObject {
public:
// CPV functions
- virtual Int_t GetNumberOfCPVLayers(void) { return fNumberOfCPVLayers; }
- virtual Int_t GetNumberOfCPVPadsPhi(void) { return fNumberOfCPVPadsPhi ; }
- virtual Int_t GetNumberOfCPVPadsZ(void) { return fNumberOfCPVPadsZ ; }
- virtual Float_t GetCPVPadSizePhi(void) { return fCPVPadSizePhi; }
- virtual Float_t GetCPVPadSizeZ(void) { return fCPVPadSizeZ; }
- virtual Float_t GetCPVBoxSize(Int_t index) { return fCPVBoxSize[index]; }
- virtual Float_t GetCPVActiveSize(Int_t index) { return fCPVActiveSize[index]; }
- virtual Int_t GetNumberOfCPVChipsPhi(void) { return fNumberOfCPVChipsPhi; }
- virtual Int_t GetNumberOfCPVChipsZ(void) { return fNumberOfCPVChipsZ; }
- virtual Float_t GetGassiplexChipSize(Int_t index) { return fGassiplexChipSize[index]; }
- virtual Float_t GetCPVGasThickness(void) { return fCPVGasThickness; }
- virtual Float_t GetCPVTextoliteThickness(void) { return fCPVTextoliteThickness; }
- virtual Float_t GetCPVCuNiFoilThickness(void) { return fCPVCuNiFoilThickness; }
- virtual Float_t GetFTPosition(Int_t index) { return fFTPosition[index]; }
- virtual Float_t GetCPVFrameSize(Int_t index) { return fCPVFrameSize[index]; }
+ virtual Int_t GetNumberOfCPVLayers(void) const { return fNumberOfCPVLayers; }
+ virtual Int_t GetNumberOfCPVPadsPhi(void) const { return fNumberOfCPVPadsPhi ; }
+ virtual Int_t GetNumberOfCPVPadsZ(void) const { return fNumberOfCPVPadsZ ; }
+ virtual Float_t GetCPVPadSizePhi(void) const { return fCPVPadSizePhi; }
+ virtual Float_t GetCPVPadSizeZ(void) const { return fCPVPadSizeZ; }
+ virtual Float_t GetCPVBoxSize(Int_t index) const { return fCPVBoxSize[index]; }
+ virtual Float_t GetCPVActiveSize(Int_t index) const { return fCPVActiveSize[index]; }
+ virtual Int_t GetNumberOfCPVChipsPhi(void) const { return fNumberOfCPVChipsPhi; }
+ virtual Int_t GetNumberOfCPVChipsZ(void) const { return fNumberOfCPVChipsZ; }
+ virtual Float_t GetGassiplexChipSize(Int_t index) const { return fGassiplexChipSize[index]; }
+ virtual Float_t GetCPVGasThickness(void) const { return fCPVGasThickness; }
+ virtual Float_t GetCPVTextoliteThickness(void) const { return fCPVTextoliteThickness; }
+ virtual Float_t GetCPVCuNiFoilThickness(void) const { return fCPVCuNiFoilThickness; }
+ virtual Float_t GetFTPosition(Int_t index) const { return fFTPosition[index]; }
+ virtual Float_t GetCPVFrameSize(Int_t index) const { return fCPVFrameSize[index]; }
private:
AliPHOSClusterizer() ; // default ctor
AliPHOSClusterizer(const char * headerFile, const char * name, const Bool_t toSplit) ;
+ AliPHOSClusterizer(const AliPHOSClusterizer & clusterizer) {
+ // copy ctor: no implementation yet
+ Fatal("cpy ctor", "not implemented") ;
+ }
virtual ~AliPHOSClusterizer() ; // dtor
virtual Float_t GetEmcClusteringThreshold()const {Warning("GetEmcClusteringThreshold", "Not Defined" ) ; return 0. ; }
virtual void SetEmcClusteringThreshold(Float_t cluth) {Warning("SetEmcClusteringThreshold", "Not Defined" ) ; }
virtual void SetEmcLocalMaxCut(Float_t cut) {Warning("SetEmcLocalMaxCut", "Not Defined" ) ; }
+
virtual void SetEmcLogWeight(Float_t w) {Warning("SetEmcLogWeight", "Not Defined" ) ; }
virtual void SetEmcTimeGate(Float_t gate) {Warning("SetEmcTimeGate", "Not Defined" ) ; }
virtual void SetCpvClusteringThreshold(Float_t cluth) {Warning("SetCpvClusteringThreshold", "Not Defined" ) ; }
virtual void SetDigitsBranch(const char * title) {Warning("SetDigitsBranch", "Not Defined" ) ; }
virtual void SetRecPointsBranch(const char *title) {Warning("SetRecPointsBranch", "Not Defined" ) ; }
virtual void SetUnfolding(Bool_t toUnfold ){Warning("SetUnfolding", "Not Defined" ) ;}
+ AliPHOSClusterizer & operator = (const AliPHOSClusterizer & rvalue) {
+ // assignement operator requested by coding convention but not needed
+ Fatal("operator =", "not implemented") ; return *this ;
+ }
virtual const char * Version() const {Warning("Version", "Not Defined" ) ; return 0 ; }
protected:
//____________________________________________________________________________
AliPHOSClusterizerv1::~AliPHOSClusterizerv1()
{
+ // dtor
+
delete fPedestals ;
delete fGains ;
//____________________________________________________________________________
const TString AliPHOSClusterizerv1::BranchName() const
{
+ // Returns branch name of the AliPHOSClusterizer
+
TString branchName(GetName() ) ;
branchName.Remove(branchName.Index(Version())-1) ;
return branchName ;
//____________________________________________________________________________
Float_t AliPHOSClusterizerv1::Calibrate(Int_t amp, Int_t absId) const
{
+ // Returns energy value in the cell absId with the digit amplitude amp
+
if(fPedestals || fGains ){ //use calibration data
if(!fPedestals || !fGains ){
Error("Calibrate","Either Pedestals of Gains not set!") ;
//____________________________________________________________________________
void AliPHOSClusterizerv1::GetCalibrationParameters()
{
+ // Get calibration parameters from AliPHOSDigitizer
+
AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
const TTask * task = gime->Digitizer(BranchName()) ;
//____________________________________________________________________________
void AliPHOSClusterizerv1::InitParameters()
{
+ // Set initial parameters for clusterization
fNumberOfCpvClusters = 0 ;
fNumberOfEmcClusters = 0 ;
AliPHOSClusterizerv1() ;
AliPHOSClusterizerv1(const char * headerFile, const char * name = "Default", const Bool_t toSplit=kFALSE);
+ AliPHOSClusterizerv1(const AliPHOSClusterizerv1 & clusterizer) {
+ // copy ctor: no implementation yet
+ Fatal("cpy ctor", "not implemented") ;
+ }
virtual ~AliPHOSClusterizerv1() ;
virtual Int_t AreNeighbours(AliPHOSDigit * d1, AliPHOSDigit * d2)const ;
//class member function (not object member function)
static void UnfoldingChiSquare(Int_t & nPar, Double_t * Grad, Double_t & fret, Double_t * x, Int_t iflag) ;
// Chi^2 of the fit. Should be static to be passes to MINUIT
+ AliPHOSClusterizerv1 & operator = (const AliPHOSClusterizerv1 & rvalue) {
+ // assignement operator requested by coding convention but not needed
+ Fatal("operator =", "not implemented") ; return *this ;
+ }
+
virtual const char * Version() const { return "clu-v1" ; }
protected:
AliPHOSCalibrationData * fPedestals ; //!
AliPHOSCalibrationData * fGains ; //!
TArrayS * fPatterns ;// Array of trigger patterns of events to handle
- TString fCalibrVersion ; //Version of calibration Data
- Int_t fCalibrRun ; //Specification of Calibration data
+ TString fCalibrVersion ; // Version of calibration Data
+ Int_t fCalibrRun ; // Specification of Calibration data
Float_t fADCchanelEmc ; // width of one ADC channel in GeV
- Float_t fADCpedestalEmc ; //
+ Float_t fADCpedestalEmc ; // value of the EMC ADC pedestal
Float_t fADCchanelCpv ; // width of one ADC channel in CPV 'popugais'
- Float_t fADCpedestalCpv ; //
+ Float_t fADCpedestalCpv ; // value of the CPV ADC pedestal
Float_t fPurifyThreshold ; // threshold for cell energies after unfolding
Float_t fEmcClusteringThreshold ; // minimum energy to include a EMC digit in a cluster
+/**************************************************************************
+ * 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. *
+ **************************************************************************/
+/* $Id: */
+
+/* $Log:
+ */
+//*-- Author: Boris Polichtchouk, IHEP
+//////////////////////////////////////////////////////////////////////////////
+// Clusterization class for IHEP reconstruction.
+// Performs clusterization (collects neighbouring active cells)
+// It differs from AliPHOSClusterizerv1 in neighbour definition only
+
// --- ROOT system ---
#include "TBenchmark.h"
#include "TROOT.h"
void AliPHOSClusterizerv2::GetNumberOfClustersFound(int* numb) const
{
+ // Returns the number of found EMC and CPV rec.points
AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ;
numb[0] = gime->EmcRecPoints()->GetEntries();
void AliPHOSClusterizerv2::Exec(Option_t* option)
{
+ // Steering method
if(strstr(option,"tim"))
gBenchmark->Start("PHOSClusterizer");
//____________________________________________________________________________
Int_t AliPHOSDigitizer::DigitizeEnergy(Float_t energy, Int_t absId)
{
+ // Returns digitized value of the energy in a cell absId
+
Int_t chanel ;
if(absId <= fEmcCrystals){ //digitize as EMC
chanel = (Int_t) TMath::Ceil((energy - fADCpedestalEmc)/fADCchanelEmc) ;
}
//____________________________________________________________________________
-Float_t AliPHOSDigitizer::FrontEdgeTime(TClonesArray * ticks)
-{ //
+Float_t AliPHOSDigitizer::FrontEdgeTime(TClonesArray * ticks) const
+{
+ // Returns the shortest time among all time ticks
+
ticks->Sort() ; //Sort in accordance with times of ticks
TIter it(ticks) ;
AliPHOSTick * ctick = (AliPHOSTick *) it.Next() ;
//____________________________________________________________________________
void AliPHOSDigitizer::InitParameters()
{
+ // Set initial parameters for Digitizer
+
fPinNoise = 0.004 ;
fEMCDigitThreshold = 0.012 ;
fCPVNoise = 0.01;
message += GetName() ;
message += "-------------\n" ;
- const Int_t nStreams = GetNInputStreams() ;
- if (nStreams) {
+ const Int_t kNStreams = GetNInputStreams() ;
+ if (kNStreams) {
Int_t index = 0 ;
- for (index = 0 ; index < nStreams ; index++) {
+ for (index = 0 ; index < kNStreams ; index++) {
message += "Adding SDigits " ;
message += GetName() ;
message += "from " ;
}
//__________________________________________________________________
-Float_t AliPHOSDigitizer::TimeOfNoise(void)
+Float_t AliPHOSDigitizer::TimeOfNoise(void) const
{ // Calculates the time signal generated by noise
//to be rewritten, now returns just big number
return 1. ;
void InitParameters() ;
void PrintDigits(Option_t * option) ;
void WriteDigits(Int_t evt) ; // Writes Digits for particular event
- Float_t TimeOfNoise(void) ; // Calculate time signal generated by noise
+ Float_t TimeOfNoise(void) const; // Calculate time signal generated by noise
//Calculate the time of crossing of the threshold by front edge
- Float_t FrontEdgeTime(TClonesArray * ticks) ;
+ Float_t FrontEdgeTime(TClonesArray * ticks) const ;
//Calculate digitized signal with gived ADC parameters
Int_t DigitizeEnergy(Float_t energy, Int_t absId) ;
Float_t fTimeSignalLength ; // Length of the timing signal
Float_t fADCchanelEmc ; // width of one ADC channel in GeV
- Float_t fADCpedestalEmc ; //
+ Float_t fADCpedestalEmc ; // value of the EMC ADC pedestal
Int_t fNADCemc ; // number of channels in EMC ADC
- Float_t fADCchanelCpv ; // width of one ADC channel in CPV 'popugais'
- Float_t fADCpedestalCpv ; //
+ Float_t fADCchanelCpv ; // width of one ADC channel in CPV units
+ Float_t fADCpedestalCpv ; // value of the CPV ADC pedestal in CPV units
Int_t fNADCcpv ; // number of channels in CPV ADC
Bool_t fToSplit ; //! Do we work in the split mode
}
Float_t * GetStripHalfSize() {return fStripHalfSize ;}
- Float_t GetStripWallWidthOut() {return fStripWallWidthOut ;}
+ Float_t GetStripWallWidthOut() const {return fStripWallWidthOut ;}
Float_t * GetAirCellHalfSize() {return fAirCellHalfSize ;}
Float_t * GetWrappedHalfSize() {return fWrappedHalfSize ;}
Float_t GetAirGapLed() const {return fAirGapLed ;}
Float_t * GetCrystalHalfSize() {return fCrystalHalfSize ;}
- Float_t * GetSupportPlateHalfSize() { return fSupportPlateHalfSize ;}
+ Float_t * GetSupportPlateHalfSize() {return fSupportPlateHalfSize ;}
Float_t * GetSupportPlateInHalfSize() {return fSupportPlateInHalfSize ;}
- Float_t GetSupportPlateThickness(void) const { return fSupportPlateThickness ; }
+ Float_t GetSupportPlateThickness(void) const { return fSupportPlateThickness ; }
Float_t * GetPreampHalfSize() {return fPreampHalfSize ;}
Float_t * GetAPDHalfSize(void) {return fPinDiodeHalfSize ; }
Float_t * GetTSupport2HalfSize() {return fTSupport2HalfSize ;}
Float_t * GetTCables1HalfSize() {return fTCables1HalfSize ; }
Float_t * GetTCables2HalfSize() {return fTCables2HalfSize ; }
- Float_t GetTSupportDist() {return fTSupportDist ; }
+ Float_t GetTSupportDist() const {return fTSupportDist ; }
Float_t * GetFrameXHalfSize() {return fFrameXHalfSize ;}
Float_t * GetFrameZHalfSize() {return fFrameZHalfSize ;}
Float_t * GetFrameXPosition() {return fFrameXPosition ;}
return iDigitN ;
}
//____________________________________________________________________________
-void AliPHOSEmcRecPoint::EvalTime(TClonesArray * digits){
-
+void AliPHOSEmcRecPoint::EvalTime(TClonesArray * digits)
+{
+ // Define a rec.point time as a time in the cell with the maximum energy
+
Float_t maxE = 0;
Int_t maxAt = 0;
for(Int_t idig=0; idig < fMulDigit; idig++){
Int_t GetMultiplicity(void) const { return fMulDigit ; } // gets the number of digits making this recpoint
Int_t GetMultiplicityAtLevel(const Float_t level) const ; // computes multiplicity of digits with
// energy above relative level
- Short_t GetNExMax(void){return fNExMax ;} //Number of maxima found in cluster in unfolding:
- //0 : was no unfolging
- //-1: unfolding failed
+ Short_t GetNExMax(void) const {return fNExMax ;} // Number of maxima found in cluster in unfolding:
+ // 0: was no unfolging
+ //-1: unfolding failed
void SetNExMax(Int_t nmax){fNExMax = static_cast<Short_t>(nmax) ;}
virtual Int_t GetNumberOfLocalMax(AliPHOSDigit ** maxAt, Float_t * maxAtEnergy,
Float_t locMaxCut,TClonesArray * digits ) const ;
AliPHOSGeometry * AliPHOSGeometry::fgGeom = 0 ;
Bool_t AliPHOSGeometry::fgInit = kFALSE ;
+//____________________________________________________________________________
+AliPHOSGeometry::AliPHOSGeometry(void)
+{
+ // default ctor
+ // must be kept public for root persistency purposes,
+ // but should never be called by the outside world
+ fPHOSAngle = 0 ;
+ fGeometryEMCA = 0;
+ fGeometrySUPP = 0;
+ fGeometryCPV = 0;
+ fgGeom = 0;
+ fRotMatrixArray = 0;
+}
//____________________________________________________________________________
AliPHOSGeometry::~AliPHOSGeometry(void)
{
}
}
+//____________________________________________________________________________
Bool_t AliPHOSGeometry::Impact(const TParticle * particle) const
{
- Bool_t In=kFALSE;
- Int_t ModuleNumber=0;
+ // Check if a particle being propagates from IP along the straight line impacts EMC
+
+ Bool_t in=kFALSE;
+ Int_t moduleNumber=0;
Double_t z,x;
- ImpactOnEmc(particle->Theta(),particle->Phi(),ModuleNumber,z,x);
- if(ModuleNumber) In=kTRUE;
- else In=kFALSE;
- return In;
+ ImpactOnEmc(particle->Theta(),particle->Phi(),moduleNumber,z,x);
+ if(moduleNumber) in=kTRUE;
+ else in=kFALSE;
+ return in;
}
//____________________________________________________________________________
//
//*-- Author: Yves Schutz (SUBATECH)
-#include <assert.h>
-
// --- ROOT system ---
#include "TString.h"
public:
- AliPHOSGeometry() {
- // default ctor
- // must be kept public for root persistency purposes, but should never be called by the outside world
- fPHOSAngle = 0 ;
- fGeometryEMCA = 0;
- fGeometrySUPP = 0;
- fGeometryCPV = 0;
- fgGeom = 0;
- fRotMatrixArray = 0; }
+ AliPHOSGeometry() ;
AliPHOSGeometry(const AliPHOSGeometry & geom) {
// cpy ctor requested by Coding Convention but not yet needed
-
- assert(0==1) ;
+ Fatal("cpy ctor", "not implemented") ;
}
virtual ~AliPHOSGeometry(void) ;
AliPHOSGeometry & operator = (const AliPHOSGeometry & rvalue) const {
// assignement operator requested by coding convention but not needed
- assert(0==1) ;
- return *(GetInstance()) ;
+ Fatal("operator =", "not implemented") ; return *(GetInstance()) ;
}
// General
ClassImp(AliPHOSGetter)
AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
- TFile * AliPHOSGetter::fFile = 0 ;
+ TFile * AliPHOSGetter::fgFile = 0 ;
//____________________________________________________________________________
AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* branchTitle, const Bool_t toSplit )
if ( fHeaderFile != "aliroot" ) { // to call the getter without a file
//open headers file
- fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
+ fgFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
- if(!fFile) { //if file was not opened yet, read gAlice
- fFile = TFile::Open(fHeaderFile.Data(),"update") ;
- if (!fFile->IsOpen()) {
+ if(!fgFile) { //if file was not opened yet, read gAlice
+ fgFile = TFile::Open(fHeaderFile.Data(),"update") ;
+ if (!fgFile->IsOpen()) {
Error("AliPHOSGetter", "Cannot open %s", fHeaderFile.Data() ) ;
fFailed = kTRUE ;
return ;
}
}
- gAlice = dynamic_cast<AliRun *>(fFile->Get("gAlice")) ;
+ gAlice = dynamic_cast<AliRun *>(fgFile->Get("gAlice")) ;
}
if (!gAlice) {
}
//____________________________________________________________________________
-AliPHOSGetter::~AliPHOSGetter(){
-
+AliPHOSGetter::~AliPHOSGetter()
+{
+ // dtor
if (fPrimaries) {
fPrimaries->Delete() ;
delete fPrimaries ;
while ( (folder = static_cast<TFolder*>(next())) )
phosF->Remove(folder) ;
- if (fFile) {
- fFile->Close() ;
- delete fFile ;
- fFile = 0 ;
+ if (fgFile) {
+ fgFile->Close() ;
+ delete fgFile ;
+ fgFile = 0 ;
}
fgObjGetter = 0 ;
//____________________________________________________________________________
void AliPHOSGetter::CloseFile()
{
+ // delete gAlice
+
if(gAlice)
delete gAlice ;
gAlice = 0 ;
}
//First checks, if header file already opened
- if(!fgObjGetter->fFile){
+ if(!fgObjGetter->fgFile){
fgObjGetter = new AliPHOSGetter(headerFile,branchTitle,toSplit) ;
if(fgObjGetter->fFailed)
return 0;
fgObjGetter->fModuleFolder->Remove(fgObjGetter->fModuleFolder->FindObject("PHOS")) ;
delete gAlice ;
}
- if(fgObjGetter->fFile){
- fgObjGetter->fFile->Close() ;
- fgObjGetter->fFile=0;
+ if(fgObjGetter->fgFile){
+ fgObjGetter->fgFile->Close() ;
+ fgObjGetter->fgFile=0;
}
if(fgObjGetter->fToSplit)
fgObjGetter->CloseSplitFiles() ;
file = TFile::Open(fSDigitsFileName.Data(),"update");
}
else
- file = fFile ;
+ file = fgFile ;
tree = (TTree *)file->Get(name.Data()) ;
//____________________________________________________________________________
void AliPHOSGetter::ListBranches(Int_t event) const
{
+ // Iterates over branches in each TreeH, TreeS, TreeD and TreeR and
+ // prints lists of branches to stdout
+ // (I don't know why this method is needed. Yu.Kharlov)
TBranch * branch = 0 ;
if (gAlice->GetEvent(event) == -1)
//____________________________________________________________________________
void AliPHOSGetter::NewBranch(TString name, Int_t event)
{
+ // Set titles for (S)Digits, RecPoints, TSegments and RecParticles branches
+
fBranchTitle = fSDigitsTitle = fDigitsTitle = fRecPointsTitle = fTrackSegmentsTitle = fRecParticlesTitle = name ;
Event(event) ;
}
//____________________________________________________________________________
Bool_t AliPHOSGetter::NewFile(TString name)
{
+ // Open a new file
fHeaderFile = name ;
- fFile->Close() ;
+ fgFile->Close() ;
fFailed = kFALSE;
- fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
- if(!fFile) { //if file was not opened yet, read gAlice
- fFile = TFile::Open(fHeaderFile.Data(),"update") ;
- if (!fFile->IsOpen()) {
+ fgFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
+ if(!fgFile) { //if file was not opened yet, read gAlice
+ fgFile = TFile::Open(fHeaderFile.Data(),"update") ;
+ if (!fgFile->IsOpen()) {
Error("NewFile", "Cannot open %s", fHeaderFile.Data() ) ;
fFailed = kTRUE ;
return fFailed ;
}
- gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
+ gAlice = static_cast<AliRun *>(fgFile->Get("gAlice")) ;
}
if (!gAlice) {
//____________________________________________________________________________
const AliPHOSGeometry * AliPHOSGetter::PHOSGeometry()
{
+ // Returns PHOS geometry
+
AliPHOSGeometry * rv = 0 ;
if (PHOS() )
rv = PHOS()->GetGeometry() ;
//____________________________________________________________________________
const Bool_t AliPHOSGetter::PostSDigitizer(AliPHOSSDigitizer * sdigitizer) const
-{ //---------- SDigitizer -------------------------
-
+{
+ //---------- SDigitizer -------------------------
// the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
//____________________________________________________________________________
TObject** AliPHOSGetter::SDigitizerRef(const char * name) const
{
+ //---------- return task SDigitizer -------------------------
TTask * sd = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
if ( !sd ) {
//____________________________________________________________________________
const Bool_t AliPHOSGetter::PostSDigitizer(const char * name, const char * file) const
-{ //---------- SDigitizer -------------------------
-
- // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
+{
+ //---------- SDigitizer -------------------------
+ // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
TTask * sd = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
if ( !sd ) {
//____________________________________________________________________________
TObject** AliPHOSGetter::DigitsRef(const char * name) const
-{ //------- Digits ----------------------
-
- // the hierarchy is //Folders/Run/Event/Data/PHOS/Digits/name
+{
+ //------- Digits ----------------------
+ // the hierarchy is //Folders/Run/Event/Data/PHOS/Digits/name
if ( !fDigitsFolder ) {
Fatal("DigitsRef", "Folder //%s not found !", fDigitsFolder) ;
//____________________________________________________________________________
const Bool_t AliPHOSGetter::PostDigitizer(AliPHOSDigitizer * digitizer) const
-{ //---------- Digitizer -------------------------
+{
+ //---------- Digitizer -------------------------
TTask * sd = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
//____________________________________________________________________________
const Bool_t AliPHOSGetter::PostDigitizer(const char * name) const
-{ //---------- Digitizer -------------------------
-
- // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
+{
+ //---------- Digitizer -------------------------
+ // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
TTask * d = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
if ( !d ) {
//____________________________________________________________________________
TObject** AliPHOSGetter::DigitizerRef(const char * name) const
{
+ // -------------- Return Digitizer task ------------------------------------
TTask * sd = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
if ( !sd ) {
Fatal("DigitizerRef", "Task //%s/Digitizer not found !", fTasksFolder) ;
//____________________________________________________________________________
TObject** AliPHOSGetter::ClusterizerRef(const char * name) const
-{ // ------------------ AliPHOSClusterizer ------------------------
+{
+ // ------------------ AliPHOSClusterizer ------------------------
TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
}
//____________________________________________________________________________
const Bool_t AliPHOSGetter::PostTrackSegmentMaker(const char * name) const
-{ //------------Track Segment Maker ------------------------------
-
+{
+ //------------Track Segment Maker ------------------------------
// the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
//____________________________________________________________________________
TObject** AliPHOSGetter::TSMakerRef(const char * name) const
-{ //------------Track Segment Maker ------------------------------
+{
+ //------------Track Segment Maker ------------------------------
TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
return phosFolder->GetListOfFolders()->GetObjectRef(tss) ;
}
//____________________________________________________________________________
-const UShort_t AliPHOSGetter::EventPattern(void){
+const UShort_t AliPHOSGetter::EventPattern(void)
+{
+ // Return the pattern (trigger bit register) of the beam-test event
if(fBTE)
return fBTE->GetPattern() ;
else
return 0 ;
}
//____________________________________________________________________________
-const Float_t AliPHOSGetter::BeamEnergy(void){
+const Float_t AliPHOSGetter::BeamEnergy(void)
+{
+ // Return the beam energy of the beam-test event
if(fBTE)
return fBTE->GetBeamEnergy() ;
else
}
//____________________________________________________________________________
const Bool_t AliPHOSGetter::PostPID(AliPHOSPID * pid) const
-{ // ------------AliPHOS PID -----------------------------
+{
+ // ------------AliPHOS PID -----------------------------
TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
//____________________________________________________________________________
TObject** AliPHOSGetter::PIDRef(const char * name) const
-{ //------------PID ------------------------------
+{
+ //------------PID ------------------------------
TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
//____________________________________________________________________________
void AliPHOSGetter::ReadTreeS(TTree * treeS, Int_t input)
-
-{ // Read the summable digits fron treeS()
-
+{
+ // Read the summable digits fron treeS()
TString filename("mergefile") ;
filename+= input ;
//____________________________________________________________________________
void AliPHOSGetter::RemoveSDigits() const
{
+ // Clean SDigit array
+
TFolder * phos= dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
if (!phos)
return ;
}
//____________________________________________________________________________
-void AliPHOSGetter::CleanWhiteBoard(void){
+void AliPHOSGetter::CleanWhiteBoard(void)
+{
+ // Delete all PHOS objects from folders
TFolder * phosmain = 0 ;
TFolder * phos ;
//____________________________________________________________________________
void AliPHOSGetter::SetTitle(const char * branchTitle )
{
+ // Set branch titles and add folders with PHOS data
+
fBranchTitle = branchTitle ;
fSDigitsTitle = branchTitle ;
fDigitsTitle = branchTitle ;
}
//____________________________________________________________________________
-void AliPHOSGetter::CloseSplitFiles(void){
+void AliPHOSGetter::CloseSplitFiles(void)
+{
+ // Close files opened in a split mode
TFile * file ;
file = static_cast<TFile*>(gROOT->GetFile(fSDigitsFileName.Data() ) ) ;
if(file)
//=========== SDigits ==============
TTree * TreeS(TString filename="") ;
- TClonesArray * SDigits(const char * name = 0, const char * file=0) {
+ TClonesArray * SDigits(const char * name = 0, const char * file=0) const {
return dynamic_cast<TClonesArray*>(ReturnO("SDigits", name, file)) ; }
//const AliPHOSDigit * SDigit(Int_t index) { return static_cast<const AliPHOSDigit *>(SDigits()->At(index)) ;} !!! why no such method ?
const AliPHOSSDigitizer * SDigitizer(const char * name =0) const {
private:
- static TFile * fFile; //!
+ static TFile * fgFile; //!
Bool_t fToSplit ; //! Do we work in the split mode
AliPHOSBeamTestEvent * fBTE ; //! Header if BeamTest Event
TString fHeaderFile ; //! File in which gAlice lives
//*-- Author: Maxime Volkov (RRC KI) & Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
// --- ROOT system ---
+#include "TVector3.h"
// --- Standard library ---
-#include <string.h>
-#include <stdlib.h>
// --- AliRoot header files ---
#include "AliPHOSHit.h"
#include "AliRun.h"
-#include "AliConst.h"
-#include "AliPHOSGetter.h"
-#include "AliPHOSGeometry.h"
#include "AliPHOS.h"
+#include "AliPHOSGeometry.h"
ClassImp(AliPHOSHit)
}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
//*-- Author: Maxime Volkov (RRC KI) & Yves Schutz (SUBATECH)
// --- ROOT system ---
-#include <TLorentzVector.h>
// --- AliRoot header files ---
#include "AliHit.h"
// 24 March 2001
- TH1F* hDrij_cpv_r = new TH1F("Drij_cpv_r","Distance between reconstructed hits in CPV",140,0,50);
- TH1F* hDrij_cpv_g = new TH1F("Drij_cpv_g","Distance between generated hits in CPV",140,0,50);
- TH1F* hDrij_cpv_ratio = new TH1F("Drij_cpv_ratio","R_{ij}^{rec}/R_{ij}^{gen} in CPV",140,0,50);
+ TH1F* hDrijCpvR = new TH1F("DrijCpvR","Distance between reconstructed hits in CPV",140,0,50);
+ TH1F* hDrijCpvG = new TH1F("Drij_cpv_g","Distance between generated hits in CPV",140,0,50);
+ TH1F* hDrijCpvRatio = new TH1F("DrijCpvRatio","R_{ij}^{rec}/R_{ij}^{gen} in CPV",140,0,50);
// TH1F* hT0 = new TH1F("hT0","Type of entering particle",20000,-10000,10000);
- hDrij_cpv_r->Sumw2();
- hDrij_cpv_g->Sumw2();
- hDrij_cpv_ratio->Sumw2(); //correct treatment of errors
+ hDrijCpvR->Sumw2();
+ hDrijCpvG->Sumw2();
+ hDrijCpvRatio->Sumw2(); //correct treatment of errors
TList * fCpvImpacts = new TList();
TBranch * branchCPVimpacts;
Int_t ntracks = gAlice->GetEvent(nev);
please->Event(nev);
- Int_t nrec_cpv = 0; // Reconstructed points in event
- Int_t ngen_cpv = 0; // Impacts in event
+ Int_t nrecCPV = 0; // Reconstructed points in event
+ Int_t ngenCPV = 0; // Impacts in event
// Get branch of CPV impacts
if (! (branchCPVimpacts =gAlice->TreeH()->GetBranch("PHOSCpvImpacts")) ) return;
Int_t nsum = hitsPerModule[iModule]->GetEntriesFast();
printf("CPV module %d has %d hits\n",iModule,nsum);
- AliPHOSImpact* GenHit1;
- AliPHOSImpact* GenHit2;
+ AliPHOSImpact* genHit1;
+ AliPHOSImpact* genHit2;
Int_t irp1,irp2;
for(irp1=0; irp1< nsum; irp1++)
{
- GenHit1 = (AliPHOSImpact*)((hitsPerModule[iModule])->At(irp1));
+ genHit1 = (AliPHOSImpact*)((hitsPerModule[iModule])->At(irp1));
for(irp2 = irp1+1; irp2<nsum; irp2++)
{
- GenHit2 = (AliPHOSImpact*)((hitsPerModule[iModule])->At(irp2));
- Float_t dx = GenHit1->X() - GenHit2->X();
- Float_t dz = GenHit1->Z() - GenHit2->Z();
+ genHit2 = (AliPHOSImpact*)((hitsPerModule[iModule])->At(irp2));
+ Float_t dx = genHit1->X() - genHit2->X();
+ Float_t dz = genHit1->Z() - genHit2->Z();
Float_t dr = TMath::Sqrt(dx*dx + dz*dz);
- hDrij_cpv_g->Fill(dr);
+ hDrijCpvG->Fill(dr);
// Info("AnalyzeCPV1", "(dx dz dr): %f %f", dx, dz);
}
}
//--------- Combinatoric distance between rec. hits in CPV
TObjArray* cpvRecPoints = please->CpvRecPoints();
- nrec_cpv = cpvRecPoints->GetEntriesFast();
+ nrecCPV = cpvRecPoints->GetEntriesFast();
- if(nrec_cpv)
+ if(nrecCPV)
{
- AliPHOSCpvRecPoint* RecHit1;
- AliPHOSCpvRecPoint* RecHit2;
- TIter next_cpv_rec1(cpvRecPoints);
- while(TObject* obj1 = next_cpv_rec1() )
+ AliPHOSCpvRecPoint* recHit1;
+ AliPHOSCpvRecPoint* recHit2;
+ TIter nextCPVrec1(cpvRecPoints);
+ while(TObject* obj1 = nextCPVrec1() )
{
- TIter next_cpv_rec2(cpvRecPoints);
- while (TObject* obj2 = next_cpv_rec2())
+ TIter nextCPVrec2(cpvRecPoints);
+ while (TObject* obj2 = nextCPVrec2())
{
if(!obj2->IsEqual(obj1))
{
- RecHit1 = (AliPHOSCpvRecPoint*)obj1;
- RecHit2 = (AliPHOSCpvRecPoint*)obj2;
+ recHit1 = (AliPHOSCpvRecPoint*)obj1;
+ recHit2 = (AliPHOSCpvRecPoint*)obj2;
TVector3 locpos1;
TVector3 locpos2;
- RecHit1->GetLocalPosition(locpos1);
- RecHit2->GetLocalPosition(locpos2);
+ recHit1->GetLocalPosition(locpos1);
+ recHit2->GetLocalPosition(locpos2);
Float_t dx = locpos1.X() - locpos2.X();
Float_t dz = locpos1.Z() - locpos2.Z();
Float_t dr = TMath::Sqrt(dx*dx + dz*dz);
- if(RecHit1->GetPHOSMod() == RecHit2->GetPHOSMod())
- hDrij_cpv_r->Fill(dr);
+ if(recHit1->GetPHOSMod() == recHit2->GetPHOSMod())
+ hDrijCpvR->Fill(dr);
}
}
}
}
Info("AnalyzeCPV1", " Event %d . Total of %d hits, %d rec.points.",
- nev, ngen_cpv, nrec_cpv) ;
+ nev, ngenCPV, nrecCPV) ;
delete [] hitsPerModule;
} // End of loop over events.
-// hDrij_cpv_g->Draw();
-// hDrij_cpv_r->Draw();
- hDrij_cpv_ratio->Divide(hDrij_cpv_r,hDrij_cpv_g);
- hDrij_cpv_ratio->Draw();
+// hDrijCpvG->Draw();
+// hDrijCpvR->Draw();
+ hDrijCpvRatio->Divide(hDrijCpvR,hDrijCpvG);
+ hDrijCpvRatio->Draw();
// hT0->Draw();
Int_t ntracks = gAlice->GetEvent(nev);
please->Event(nev);
-// Int_t nrec_cpv = 0; // Reconstructed points in event // 01.10.2001
-// Int_t ngen_cpv = 0; // Impacts in event
+// Int_t nrecCPV = 0; // Reconstructed points in event // 01.10.2001
+// Int_t ngenCPV = 0; // Impacts in event
// Get branch of CPV impacts
if (! (branchCPVimpacts =gAlice->TreeH()->GetBranch("PHOSCpvImpacts")) ) return;
// Info("AnalyzeCPV1", " PHOS module "<<iModule<<": "<<hits->GetEntries()<<" charged CPV hits.");
// }
-Bool_t AliPHOSIhepAnalyze::IsCharged(Int_t pdg_code)
+Bool_t AliPHOSIhepAnalyze::IsCharged(Int_t pdgCode)
{
// For HIJING
- Info("AnalyzeCPV1", "pdg_code %d", pdg_code);
- if(pdg_code==211 || pdg_code==-211 || pdg_code==321 || pdg_code==-321 || pdg_code==11 || pdg_code==-11 || pdg_code==2212 || pdg_code==-2212) return kTRUE;
+ Info("AnalyzeCPV1", "pdgCode %d", pdgCode);
+ if(pdgCode==211 || pdgCode==-211 || pdgCode==321 || pdgCode==-321 || pdgCode==11 || pdgCode==-11 || pdgCode==2212 || pdgCode==-2212) return kTRUE;
else
return kFALSE;
}
AliPHOSIhepAnalyze() ; // ctor
AliPHOSIhepAnalyze(Text_t * name) ; // ctor
-
+ virtual ~AliPHOSIhepAnalyze(void) ; // dtor
+
void AnalyzeCPV1(Int_t Nevents); // resolutions, mult and cluster lengths for CPV
void AnalyzeEMC1(Int_t Nevents); // resolutions, mult and cluster lengths for EMC
void AnalyzeCPV2(Int_t Nevents); // delta(gen)/delta(rec) between hits
void CpvSingle(Int_t Nevents); // signle particle analysis
virtual void HitsCPV(TClonesArray& hits, Int_t event);
- TString GetFileName() { return fFileName; }
+ const TString GetFileName() const { return fFileName; }
private:
- Bool_t IsCharged(Int_t pdg_code);
+ Bool_t IsCharged(Int_t pdgCode);
private:
- TString fFileName;
+ TString fFileName; //Name of file analyzed
ClassDef(AliPHOSIhepAnalyze,1) // PHOSv1 event analyzis algorithm
//____________________________________________________________________________
void AliPHOSImpact::Print()
{
+ //Print information of the impact
printf("Impact Pid=%4d, p=(%6.2f,%6.2f,%6.2f,%6.2f) GeV, x=(%6.1f,%6.1f,%6.1f) cm\n",
fPid,fMomentum.Px(),fMomentum.Py(),fMomentum.Pz(),fMomentum.E(),
fX,fY,fZ);
}
+
+
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/* $Id$ */
+
//_________________________________________________________________________
// Class to calculate jet chararacteristics
//
+// This class implements for PHOS a jet finder for PHOS. It depends on a
+// energy seed
+// minimum energy, cone radius and movement of the cone.
//*-- Author : D.Peressounko
//////////////////////////////////////////////////////////////////////////////
//____________________________________________________________________________
AliPHOSJet::AliPHOSJet():TObject() {
+ //Inicilize members
fNpart = 0 ;
fList = 0 ;
// fMode = 0 ;
//____________________________________________________________________________
AliPHOSJet::~AliPHOSJet(){
+ //dtor
if(fList){
delete fList ;
fList = 0 ;
}
//____________________________________________________________________________
Bool_t AliPHOSJet::IsInCone(const TParticle * p)const
-{//
+{
+ //Say if particle is inside the defined cone
Double_t dEta ;
Double_t dPhi ;
if(!fEnergy){ //Final values not calculated yet, use intermediate
}
//____________________________________________________________________________
Bool_t AliPHOSJet::IsInCone(const Double_t e,const Double_t eta,const Double_t phi)const
-{//
+{
+ //Says if particle is inside the defined cone
Double_t dEta ;
Double_t dPhi ;
if(!fEnergy){ //Final values not calculated yet, use intermediate
}
//____________________________________________________________________________
void AliPHOSJet::CalculateAll(void){
-
+ //Calculate all jet parameters
if(fSumEnergy==0)
return ; //Nothing to calculate
}
//____________________________________________________________________________
void AliPHOSJet::Print(Option_t * option){
+ //Print jet parameters
printf("-------------- AliPHOSJet ------------\n") ;
printf(" Energy............. %f \n",fEnergy) ;
printf(" Eta................ %f \n",fEta ) ;
printf(" N particles in jet %d \n",fNpart) ;
printf("----------------------------------\n") ;
}
+
+
+
-#ifndef ALIJET_H
-#define ALIJET_H
+#ifndef ALIPHOSJET_H
+#define ALIPHOSJET_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
+/* $Id$ */
+
//_________________________________________________________________________
// Base Class for Jets in ALICE
//
public:
AliPHOSJet() ; // ctor
- AliPHOSJet(const AliPHOSJet & jet){} ; // ctor
+ AliPHOSJet(const AliPHOSJet & jet) {
+ // copy ctor: no implementation yet
+ Fatal("cpy ctor", "not implemented") ;
+ }
virtual ~AliPHOSJet() ;
void AddDigit(const Double_t e,const Double_t eta,const Double_t phi,const Int_t index) ;
Int_t GetNJetParticles(void)const{return fNpart;}
void Print(Option_t * option="") ;
+ AliPHOSJet & operator = (const AliPHOSJet & rvalue) {
+ // assignement operator requested by coding convention but not needed
+ Fatal("operator =", "not implemented") ; return *this ;
+ }
private:
Int_t fNpart ; //Number of particles in jet
TArrayI * fList ; //Indexes of particles in list
- Double_t fConeRad ;
- Double_t fMaxConeMove ;
- Double_t fMinConeMove ;
+ Double_t fConeRad ; // Cone radius
+ Double_t fMaxConeMove ;// Maximum Cone movement
+ Double_t fMinConeMove ;// Minimum Cone movement
Double_t fSumEnergy ; //! Intermediate energy
Double_t fSumEta ; //! Intermediate eta
Double_t fSumPhi ; //! Intermediate phi
};
-#endif // ALIJET_H
+//////////////////////////////////////////////////////
+
+#endif // ALIPHOSJET_H
+
+
+
+
+
//_________________________________________________________________________
// C++ version of UA2 and/or Lund jet finding algorithm
-// UA1 jet algorithm from LUND JETSET (LUCELL)
-//
+// UA1 jet algorithm from LUND JETSET (LUCELL)
+// Find jets at the level of no detector and Digits.
+// Needs modifications.
//*-- Author : D.Peressounko after UA1 coll. etc
//////////////////////////////////////////////////////////////////////////////
//____________________________________________________________________________
AliPHOSJetFinder::AliPHOSJetFinder():TNamed("AliPHOSJetFinder","")
{
- fNJets = 0 ;
+ //Initialize jet parameters
+ fNJets = 0 ;
fMode = 0 ; //No iterations
fStatusCode = -999 ; //no selection
//____________________________________________________________________________
AliPHOSJetFinder::~AliPHOSJetFinder()
{
+ //dtor
if(fParticles){
delete fParticles ;
fParticles = 0 ;
//____________________________________________________________________________
void AliPHOSJetFinder::FindJetsFromParticles(const TClonesArray * plist,TObjArray * jetslist)
{
-
+ //Find jets in the case without detector.
TIter next(plist) ;
TIter nextJet(jetslist) ;
}
//____________________________________________________________________________
void AliPHOSJetFinder::FindJetsFromDigits(const TClonesArray * digits, TObjArray * jets){
-
+ //Find jets in the case witht detector at the level of digits.
if(digits->GetEntries()==0){
Error("JetsFromDigits","No entries in digits list \n") ;
return ;
}
//____________________________________________________________________________
void AliPHOSJetFinder::CalculateEEtaPhi(const AliPHOSDigit * d,Double_t &e, Double_t &eta, Double_t &phi){
+ //Calculate direction of the jet
e=Calibrate(d) ;
AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance("GPS2","") ;
TVector3 pos ;
}
//____________________________________________________________________________
void AliPHOSJetFinder::Print(Option_t * option){
+ //Print parameters of the found jet
printf("\n --------------- AliPHOSJetFinder --------------- \n") ;
printf(" Jets found .........%d \n",fNJets) ;
printf(" Seed energy cut ....%f \n",fEtSeed) ;
public:
AliPHOSJetFinder() ; // ctor
-
+ AliPHOSJetFinder(const AliPHOSJetFinder & jet) {
+ // copy ctor: no implementation yet
+ Fatal("cpy ctor", "not implemented") ;
+ }
virtual ~AliPHOSJetFinder() ; // dtor
void FindJetsFromParticles(const TClonesArray * plist,TObjArray * jetslist) ; //Do the job
void SetMaxConeMove(Double_t move){fMaxConeMove=move ; } ;
void SetMinConeMove(Double_t move){fMinConeMove=move ; } ;
void SetStatusCode(Int_t stc = 1){fStatusCode=stc ;} ;
+ AliPHOSJetFinder & operator = (const AliPHOSJetFinder & rvalue) {
+ // assignement operator requested by coding convention but not needed
+ Fatal("operator =", "not implemented") ; return *this ;
+ }
private:
Double_t Calibrate(const AliPHOSDigit * digit) ;
void CalculateEEtaPhi(const AliPHOSDigit * d,Double_t &e, Double_t &Eta, Double_t &phi);
private:
- Int_t fNJets ;
+ Int_t fNJets ; //Number of jets
Int_t fStatusCode ; //Status code of particles to handle
Int_t fMode ; //Mode for background calculation
Double_t fConeRad ; //Maximal radius of jet
- Double_t fMaxConeMove ;
- Double_t fMinConeMove ;
- Double_t fEtSeed ;
- Double_t fEtMin ;
- Double_t fPrecBg ;
- Double_t fSimGain ;
- Double_t fSimPedestal ;
+ Double_t fMaxConeMove ; //Maximal cone movement
+ Double_t fMinConeMove ; //Minimum cone movement
+ Double_t fEtSeed ; //Transversal energy seed
+ Double_t fEtMin ; //Minimal transversal energy
+ Double_t fPrecBg ; //Precision due to background?
+ Double_t fSimGain ; //Simulated digit gain
+ Double_t fSimPedestal ; //Simulated digit pedestal
- TClonesArray * fParticles ;
- TObjArray * fJets ;
+ TClonesArray * fParticles ; //Particles array
+ TObjArray * fJets ; //Jets array
ClassDef(AliPHOSJetFinder,1) //Class to find Jets
// dtor
}
Int_t Compare(const TObject * obj) const;
- Int_t GetEmc(void) {
+ const Int_t GetEmc(void) const {
// returns the index of EMC
return fEmcN;
}
- Int_t GetPpsd(void) {
+ const Int_t GetPpsd(void) const {
// returns the index of PPSD
return fPpsdN ;
}
- Float_t GetR(void) {
+ const Float_t GetR(void) const {
// returns the distance between EMC and PPSD
return fR ;
}