{
// Default ctor
fName = "EMCAL" ;
+ Init();
+
}
//____________________________________________________________________________
AliEMCAL::AliEMCAL(const char* name, const char* title): AliDetector(name,title)
{
// ctor : title is used to identify the layout
+ Init();
+
+}
+
+//____________________________________________________________________________
+AliEMCAL::AliEMCAL(const AliEMCAL& emcal) : AliDetector(emcal)
+{
+ //copy ctor
+ Init();
- fHighCharge = 8.2 ; // adjusted for a high gain range of 5.12 GeV (10 bits)
- fHighGain = 6.64 ;
- fHighLowGainFactor = 16. ; // adjusted for a low gain range of 82 GeV (10 bits)
- fLowGainOffset = 1 ; // offset added to the module id to distinguish high and low gain data
}
//____________________________________________________________________________
//dtor
}
+//____________________________________________________________________________
+void AliEMCAL::Init(void)
+{
+ //initialize EMCAL values
+ fBirkC0 = 1;
+ fBirkC1 = 0.013/1.032;
+ fBirkC2 = 9.6e-6/(1.032 * 1.032);
+
+ fHighCharge = 8.2 ; // adjusted for a high gain range of 5.12 GeV (10 bits)
+ fHighGain = 6.64 ;
+ fHighLowGainFactor = 16. ; // adjusted for a low gain range of 82 GeV (10 bits)
+ fLowGainOffset = 1 ; // offset added to the module id to distinguish high and low gain data
+}
+
//____________________________________________________________________________
void AliEMCAL::Copy(AliEMCAL & emcal) const
{
AliEMCAL();
AliEMCAL(const char* name, const char* title="");
- AliEMCAL(const AliEMCAL& emcal) : AliDetector(emcal) {
- // cpy ctor: no implementation yet
- // requested by the Coding Convention
- Fatal("cpy ctor", "not implemented") ;
- }
+ AliEMCAL(const AliEMCAL& emcal);
+
virtual ~AliEMCAL() ;
virtual void AddHit(Int_t, Int_t*, Float_t *) {
Fatal("AddHit(Int_t, Int_t*, Float_t *", "not to be used: use AddHit( Int_t shunt, Int_t primary, Int_t track,Int_t id, Float_t *hits )") ;
virtual AliTriggerDetector* CreateTriggerDetector() const
{ return new AliEMCALTrigger(); }
-
+
// Raw Read Out
Double_t GetRawFormatCapa() const { return fgCapa ; }
Double_t GetRawFormatHighCharge() const { return fHighCharge ; }
static Double_t RawResponseFunction(Double_t *x, Double_t *par) ;
void FitRaw(Bool_t lowGainFlag, TGraph * gLowGain, TGraph * gHighGain, TF1* signalF, Double_t & energy, Double_t & time) ;
+ void Init(void); //initializes some params
+
Int_t fBirkC0; // constants for Birk's Law implementation
Double_t fBirkC1; // constants for Birk's Law implementation
Double_t fBirkC2; // constants for Birk's Law implementation
fDefaultInit = kFALSE ;
}
+//____________________________________________________________________________
+AliEMCALClusterizerv1::AliEMCALClusterizerv1(const AliEMCALClusterizerv1& clus):AliEMCALClusterizer(clus)
+{
+ //copy ctor
+ fHists = clus.fHists;
+ fPointE = clus.fPointE;
+ fPointL1 = clus.fPointL1;
+ fPointL2 = clus.fPointL2;
+ fPointDis = clus.fPointDis;
+ fPointMult = clus.fPointMult;
+ fDigitAmp = clus.fDigitAmp;
+ fMaxE = clus.fMaxE;
+ fMaxL1 = clus.fMaxL1;
+ fMaxL2 = clus.fMaxL2;
+ fMaxDis = clus.fMaxDis;
+
+ fGeom = clus.fGeom;
+ fDefaultInit = clus.fDefaultInit;
+ fToUnfold = clus.fToUnfold;
+ fNumberOfECAClusters = clus.fNumberOfECAClusters;
+ fNTowerInGroup = clus.fNTowerInGroup;
+ fCalibData = clus.fCalibData;
+ fADCchannelECA = clus.fADCchannelECA;
+ fADCpedestalECA = clus.fADCpedestalECA;
+ fECAClusteringThreshold = clus.fECAClusteringThreshold;
+ fECALocMaxCut = clus.fECALocMaxCut;
+ fECAW0 = clus.fECAW0;
+ fRecPointsInRun = clus.fRecPointsInRun;
+ fTimeGate = clus.fTimeGate;
+ fMinECut = clus.fMinECut;
+
+}
+
//____________________________________________________________________________
AliEMCALClusterizerv1::~AliEMCALClusterizerv1()
{
AliEMCALClusterizerv1() ;
//cpy ctor required by coding convention
- AliEMCALClusterizerv1(const AliEMCALClusterizerv1& clus):AliEMCALClusterizer(clus){};
+ AliEMCALClusterizerv1(const AliEMCALClusterizerv1& clus);
AliEMCALClusterizerv1(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::GetDefaultEventFolderName());
virtual ~AliEMCALClusterizerv1() ;
}
//____________________________________________________________________________
-AliEMCALDigit& AliEMCALDigit::operator+(AliEMCALDigit const & digit)
+AliEMCALDigit AliEMCALDigit::operator+(const AliEMCALDigit &digit)
{
// Adds the amplitude of digits and completes the list of primary particles
// if amplitude is larger than
}
//____________________________________________________________________________
-AliEMCALDigit& AliEMCALDigit::operator*(Float_t factor)
+AliEMCALDigit AliEMCALDigit::operator*(Float_t factor)
{
// Multiplies the amplitude by a factor
virtual ~AliEMCALDigit() ;
Bool_t operator==(const AliEMCALDigit &rValue) const;
- AliEMCALDigit& operator+(AliEMCALDigit const &rValue) ;
- AliEMCALDigit& operator*(Float_t factor) ;
+ AliEMCALDigit operator+(const AliEMCALDigit &rValue) ;
+ AliEMCALDigit operator*(Float_t factor) ;
const AliEMCALDigit& operator = (const AliEMCALDigit &) {return *this;}
Int_t Compare(const TObject * obj) const ;
Init();
CreateListOfTrd1Modules();
}
+//______________________________________________________________________
+AliEMCALGeometry::AliEMCALGeometry(const Text_t* name, const Text_t* title, AliEMCALAlignData* alignData) :
+ AliGeometry(name, title) {// Align data in action
+ fgAlignData = alignData;
+ Init();
+ CreateListOfTrd1Modules();
+};
+//______________________________________________________________________
+AliEMCALGeometry::AliEMCALGeometry(const AliEMCALGeometry& geom):AliGeometry(geom) {
+ //copy ctor
+ fGeoName = geom.fGeoName;
+
+ fArrayOpts = geom.fArrayOpts;
+
+ fAlFrontThick = geom.fAlFrontThick;
+ fECPbRadThickness = geom.fECPbRadThickness;
+ fECScintThick = geom.fECScintThick;
+ fNECLayers = geom.fNECLayers;
+ fArm1PhiMin = geom.fArm1PhiMin;
+ fArm1PhiMax = geom.fArm1PhiMax;
+ fArm1EtaMin = geom.fArm1EtaMin;
+ fArm1EtaMax = geom.fArm1EtaMax;
+
+ fIPDistance = geom.fIPDistance;
+ fShellThickness = geom.fShellThickness;
+ fZLength = geom.fZLength;
+ fGap2Active = geom.fGap2Active;
+ fNZ = geom.fNZ;
+ fNPhi = geom.fNPhi;
+ fSampling = geom.fSampling;
+
+ fNumberOfSuperModules = geom.fNumberOfSuperModules;
+ fSteelFrontThick = geom.fSteelFrontThick;
+ fFrontSteelStrip = geom.fFrontSteelStrip;
+ fLateralSteelStrip = geom.fLateralSteelStrip;
+ fPassiveScintThick = geom.fPassiveScintThick;
+ fPhiModuleSize = geom.fPhiModuleSize;
+ fEtaModuleSize = geom.fEtaModuleSize;
+ fPhiTileSize = geom.fPhiTileSize;
+ fEtaTileSize = geom.fEtaTileSize;
+ fLongModuleSize = geom.fLongModuleSize;
+ fNPhiSuperModule = geom.fNPhiSuperModule;
+ fNPHIdiv = geom.fNPHIdiv;
+ fNETAdiv = geom.fNETAdiv;
+
+ fNCells = geom.fNCells;
+ fNCellsInSupMod = geom.fNCellsInSupMod;
+ fNCellsInTower = geom.fNCellsInTower;
+ fNTRU = geom.fNTRU;
+ fNTRUEta = geom.fNTRUEta;
+ fNTRUPhi = geom.fNTRUPhi;
+ fTrd1Angle = geom.fTrd1Angle;
+ f2Trd1Dx2 = geom.f2Trd1Dx2;
+ fPhiGapForSM = geom.fPhiGapForSM;
+ fKey110DEG = geom.fKey110DEG;
+ fTrd2AngleY = geom.fTrd2AngleY;
+ f2Trd2Dy2 = geom.f2Trd2Dy2;
+ fEmptySpace = geom.fEmptySpace;
+ fTubsR = geom.fTubsR;
+ fTubsTurnAngle = geom.fTubsTurnAngle;
+ fEtaCentersOfCells = geom.fEtaCentersOfCells;
+ fXCentersOfCells = geom.fXCentersOfCells;
+ fPhiCentersOfCells = geom.fPhiCentersOfCells;
+
+ fShishKebabTrd1Modules = geom.fShishKebabTrd1Modules;
+
+ fNAdditionalOpts = geom.fNAdditionalOpts;
+}
+
//______________________________________________________________________
AliEMCALGeometry::~AliEMCALGeometry(void){
// dtor
class AliEMCALGeometry : public AliGeometry {
public:
- AliEMCALGeometry(const AliEMCALGeometry& geom):AliGeometry(geom) {
- // cpy ctor requested by Coding Convention but not yet needed
- Fatal("Cpy ctor", "Not implemented");
- };
+ AliEMCALGeometry(const AliEMCALGeometry& geom);
virtual ~AliEMCALGeometry(void);
static AliEMCALGeometry * GetInstance(const Text_t* name,
protected:
AliEMCALGeometry(const Text_t* name, const Text_t* title);// ctor only for internal usage (singleton)
- AliEMCALGeometry(const Text_t* name, const Text_t* title, AliEMCALAlignData* alignData) :
- AliGeometry(name, title) {// Align data in action
- fgAlignData = alignData;
- Init();
- CreateListOfTrd1Modules();
- };
+ AliEMCALGeometry(const Text_t* name, const Text_t* title, AliEMCALAlignData* alignData);
void Init(void); // initializes the parameters of EMCAL
void CheckAdditionalOptions(); //
AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::fgGeomOfflineTrd1=0;
+//___________________________________________________________________________
AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::GetInstance()
{
//retrurn instance of the geometry
return fgGeomOfflineTrd1;
}
+//___________________________________________________________________________
AliEMCALGeometryOfflineTrd1::AliEMCALGeometryOfflineTrd1() : TNamed("geomTRD1","")
{
// this private constarctor
Init();
}
+//___________________________________________________________________________
+AliEMCALGeometryOfflineTrd1::AliEMCALGeometryOfflineTrd1(const AliEMCALGeometryOfflineTrd1& geom):TNamed(geom.GetName(),geom.GetTitle())
+{
+ //copy ctor
+ fGeometry = geom.fGeometry;
+ fMaxInEta = geom.fMaxInEta;
+
+ for(Int_t mod = 0; mod < 26; mod++) fTrd1Modules[mod] = geom.fTrd1Modules[mod];
+
+ fSMMaxEta = geom.fSMMaxEta;
+ for(Int_t i = 0; i < fSMMaxEta; i++) fSMPositionEta[i] = geom.fSMPositionEta[i];
+
+ fSMPositionPhi = geom.fSMPositionPhi;
+ fShiftOnPhi = geom.fShiftOnPhi;
+ fNPhiSuperModule = geom.fNPhiSuperModule;
+ for(Int_t rot = 0; rot < 6; rot++) {
+ fSuperModuleRotationZ[rot] = geom.fSuperModuleRotationZ[rot];
+ fNameSuperModuleRotationZ[rot] = geom.fNameSuperModuleRotationZ[rot];
+ }
+ fSuperModuleRotationX = geom.fSuperModuleRotationX;
+ for(Int_t rot = 0; rot < 12; rot++) fSuperModuleRotation[rot] = geom.fSuperModuleRotation[rot];
+ fXYZofCells = geom.fXYZofCells;
+
+}
+
+//___________________________________________________________________________
void AliEMCALGeometryOfflineTrd1::Init()
{
// Super module
}
}
+//___________________________________________________________________________
TVector3& AliEMCALGeometryOfflineTrd1::PosInSuperModule(int nSupMod, Int_t nTower, Int_t nIphi, Int_t nIeta)
{
//return location of position within supermodule
return v;
}
+//___________________________________________________________________________
void AliEMCALGeometryOfflineTrd1::PositionInSuperModule(Int_t iphi, Int_t ieta,
double &lphi, double &leta)
{
leta = fSMPositionEta[ie].X();
}
+//___________________________________________________________________________
void AliEMCALGeometryOfflineTrd1::PositionInSuperModule(int nSupMod, Int_t nTower, Int_t nIphi, Int_t nIeta,
double &lphi, double &leta)
{
PositionInSuperModule(iphi,ieta, lphi,leta);
}
+//___________________________________________________________________________
TRotation* AliEMCALGeometryOfflineTrd1::Rotation(Int_t module)
{
//return rotation matrix for module
return &fSuperModuleRotation[module];
}
+//___________________________________________________________________________
TVector3* AliEMCALGeometryOfflineTrd1::CellPosition(int absId)
{
//return cell position given absoluted cell id
return (TVector3*)fXYZofCells->At(absId-1);
}
+//___________________________________________________________________________
void AliEMCALGeometryOfflineTrd1::PrintSuperModule()
{
//utility method for printing supermodule info
}
}
+//___________________________________________________________________________
void AliEMCALGeometryOfflineTrd1::PrintCell(Int_t absId)
{
//utility method for printing cell info
}
}
+//___________________________________________________________________________
void AliEMCALGeometryOfflineTrd1::Browse(TBrowser* b)
{
//Browse the geometry
b->Add(fXYZofCells);
}
+//___________________________________________________________________________
Bool_t AliEMCALGeometryOfflineTrd1::IsFolder() const
{
//folder check
class AliEMCALGeometryOfflineTrd1 : public TNamed {
public:
- AliEMCALGeometryOfflineTrd1(const AliEMCALGeometryOfflineTrd1& geom):TNamed(geom.GetName(),geom.GetTitle()) {
- // cpy ctor requested by Coding Convention but not yet needed
- Fatal("Cpy ctor", "Not implemented");
- }
+ AliEMCALGeometryOfflineTrd1(const AliEMCALGeometryOfflineTrd1& geom);
//assignment operator for coding convention
const AliEMCALGeometryOfflineTrd1 & operator = (const AliEMCALGeometryOfflineTrd1 &) {return *this;}
fRecPoints = new TObjArray();
}
+//____________________________________________________________________________
+AliEMCALLoader::AliEMCALLoader(const AliEMCALLoader & obj):AliLoader(obj)
+{
+ //copy ctor
+
+ fDebug = obj.fDebug;
+ fHits = obj.fHits;
+ fDigits = obj.fDigits;
+ fSDigits = obj.fSDigits;
+ fRecPoints = obj.fRecPoints;
+
+}
+
//____________________________________________________________________________
AliEMCALLoader::~AliEMCALLoader()
{
public:
AliEMCALLoader();
- AliEMCALLoader(const AliEMCALLoader & obj):AliLoader(obj){}
+ AliEMCALLoader(const AliEMCALLoader & obj);
AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername);
virtual ~AliEMCALLoader() ;
fGeomPtr->GetTransformationForSM(); // Global <-> Local
}
//____________________________________________________________________________
+AliEMCALRecPoint::AliEMCALRecPoint(const AliEMCALRecPoint & rp) : AliRecPoint(rp)
+{
+ //copy ctor
+ fGeomPtr = rp.fGeomPtr;
+ fClusterType = rp.fClusterType;
+ fCoreEnergy = rp.fCoreEnergy;
+ fLambda[0] = rp.fLambda[0];
+ fLambda[1] = rp.fLambda[1];
+ fDispersion = rp.fDispersion;
+ fEnergyList = new Float_t[rp.fMulDigit];
+ fTimeList = new Float_t[rp.fMulDigit];
+ fAbsIdList = new Int_t[rp.fMulDigit];
+ for(Int_t i = 0; i < rp.fMulDigit; i++) {
+ fEnergyList[i] = rp.fEnergyList[i];
+ fTimeList[i] = rp.fTimeList[i];
+ fAbsIdList[i] = rp.fAbsIdList[i];
+ }
+ fTime = rp.fTime;
+ fCoreRadius = rp.fCoreRadius;
+ fMulParent = rp.fMulParent;
+ fMaxParent = rp.fMaxParent;
+ fParentsList = new Int_t[rp.fMulParent];
+ for(Int_t i = 0; i < rp.fMulParent; i++) fParentsList[i] = rp.fParentsList[i];
+ fSuperModuleNumber = rp.fSuperModuleNumber;
+
+}
+//____________________________________________________________________________
AliEMCALRecPoint::~AliEMCALRecPoint()
{
// dtor
AliEMCALRecPoint() ; // ctor
AliEMCALRecPoint(const char * opt) ; // ctor
- AliEMCALRecPoint(const AliEMCALRecPoint & rp):AliRecPoint(rp) { Fatal("cpy ctor", "not implemented") ; }
+ AliEMCALRecPoint(const AliEMCALRecPoint & rp);
virtual ~AliEMCALRecPoint();
virtual void AddDigit(AliDigitNew &){ Fatal("AddDigit", "use AddDigit(AliEMCALDigit & digit, Float_t Energy )") ; }
}
+//____________________________________________________________________________
+AliEMCALReconstructor::AliEMCALReconstructor(const AliEMCALReconstructor & rec): AliReconstructor(rec)
+{
+ //copy ctor
+ fDebug = rec.fDebug;
+
+}
//____________________________________________________________________________
AliEMCALReconstructor::~AliEMCALReconstructor()
public:
AliEMCALReconstructor() ; //ctor
- AliEMCALReconstructor(const AliEMCALReconstructor & rec) : AliReconstructor(rec) {
- // cpy ctor:
- // requested by the Coding Convention
- Fatal("cpy ctor", "not implemented") ;
- }
+ AliEMCALReconstructor(const AliEMCALReconstructor & rec);
virtual ~AliEMCALReconstructor() ; //dtor
{
// ctor
fFirstEvent = fLastEvent = fControlHists = 0;
+ InitParameters();
fDefaultInit = kTRUE ;
fHists = 0;
}
Double_t AliEMCALShishKebabModule::fgb=0.;
Double_t AliEMCALShishKebabModule::fgr=0.;
+//_________________________________________________________________________
AliEMCALShishKebabModule::AliEMCALShishKebabModule() : TNamed()
{
// theta in radians ; first object shold be with theta=pi/2.
}
}
+//_________________________________________________________________________
AliEMCALShishKebabModule::AliEMCALShishKebabModule(AliEMCALShishKebabModule &leftNeighbor) : TNamed()
{
// 22-sep-04
Init(leftNeighbor.GetA(),leftNeighbor.GetB());
}
+//_________________________________________________________________________
+AliEMCALShishKebabModule::AliEMCALShishKebabModule(const AliEMCALShishKebabModule& mod) : TNamed(mod.GetName(),mod.GetTitle())
+{
+ //copy ctor
+ fOK = mod.fOK;
+ fA = mod.fA;
+ fB = mod.fB;
+ fTheta = mod.fTheta;
+
+}
+
+//_________________________________________________________________________
void AliEMCALShishKebabModule::Init(Double_t A, Double_t B)
{
//
DefineName(fTheta);
}
+//_________________________________________________________________________
void AliEMCALShishKebabModule::DefineFirstModule()
{
// Define first module
TObject::SetUniqueID(1); //
}
+//_________________________________________________________________________
void AliEMCALShishKebabModule::DefineSecondModuleFirstAssumption()
{ // Keep for testing and checking
// cos(theta) << 1, theta ~ pi/2.; a/r = 11.4/462.54 = 0.0246465 << 1;
*/
}
+//_________________________________________________________________________
Double_t AliEMCALShishKebabModule::Solve(Double_t (*fcn)(Double_t*,Double_t*),
Double_t xmin, Double_t xmax, Int_t npar, Double_t *par, Double_t eps, Int_t maxIter)
{
return x;
}
+//_________________________________________________________________________
Double_t AliEMCALShishKebabModule::Y2(Double_t *x, Double_t *par)
{
// For position calulation of second module
return y;
}
+//_________________________________________________________________________
Double_t AliEMCALShishKebabModule::YALL(Double_t *x, Double_t *par)
{
// For position calulation of 3th, 4th to 30th modules
return y;
}
+//_________________________________________________________________________
void AliEMCALShishKebabModule::DefineName(Double_t theta)
{
// Define name of object
SetName(Form("%2i(%5.2f)", TObject::GetUniqueID(), theta*TMath::RadToDeg()));
}
+//_________________________________________________________________________
Bool_t AliEMCALShishKebabModule::GetParameters()
{
// Get needing module parameters from EMCAL geometry
return kTRUE;
}
+//_________________________________________________________________________
void AliEMCALShishKebabModule::PrintShish(Int_t pri) const
{
// service method
}
}
+//_________________________________________________________________________
Double_t AliEMCALShishKebabModule::GetThetaInDegree() const
{
return fTheta*TMath::RadToDeg();
AliEMCALShishKebabModule();
AliEMCALShishKebabModule(AliEMCALShishKebabModule &leftNeighbor);
void Init(Double_t A, Double_t B);
- AliEMCALShishKebabModule(const AliEMCALShishKebabModule& mod) : TNamed(mod.GetName(),mod.GetTitle()){
- // cpy ctor: no implementation yet; requested by the Coding Convention
- Fatal("cpy ctor", "not implemented") ;
- }
+ AliEMCALShishKebabModule(const AliEMCALShishKebabModule& mod);
+
AliEMCALShishKebabModule & operator = (const AliEMCALShishKebabModule& /*rvalue*/) {
Fatal("operator =", "not implemented") ;
return *this ;
Double_t AliEMCALShishKebabTrd1Module::fgangle=0.; // around one degree
Double_t AliEMCALShishKebabTrd1Module::fgtanBetta=0; //
+//_____________________________________________________________________________
AliEMCALShishKebabTrd1Module::AliEMCALShishKebabTrd1Module(Double_t theta, AliEMCALGeometry *g) : TNamed()
{
// theta in radians ; first object shold be with theta=pi/2.
cout<< "AliEMCALShishKebabTrd1Module - first module: theta " << fTheta << " geometry " << g << endl;
}
+//_____________________________________________________________________________
AliEMCALShishKebabTrd1Module::AliEMCALShishKebabTrd1Module(AliEMCALShishKebabTrd1Module &leftNeighbor) : TNamed()
{
// printf("** Left Neighbor : %s **\n", leftNeighbor.GetName());
Init(leftNeighbor.GetA(),leftNeighbor.GetB());
}
+//________________________________________________________________
+AliEMCALShishKebabTrd1Module::AliEMCALShishKebabTrd1Module(const AliEMCALShishKebabTrd1Module& mod) : TNamed(mod.GetName(),mod.GetTitle())
+{
+ //copy ctor
+ fOK = mod.fOK;
+ fA = mod.fA;
+ fB = mod.fB;
+ fThetaA = mod.fThetaA;
+ fTheta = mod.fTheta;
+ fOK1 = mod.fOK1;
+ fOK2 = mod.fOK2;
+ fOB = mod.fOB;
+ fOB1 = mod.fOB1;
+ fOB2 = mod.fOB2;
+
+}
+
+//________________________________________________________________
void AliEMCALShishKebabTrd1Module::Init(Double_t A, Double_t B)
{
// Define parameter module from parameters A,B from previos.
fOB2.Set(fOB.X()+fga/4.*TMath::Sin(fTheta), fOB.Y()-fga/4.*TMath::Cos(fTheta));
}
+//_____________________________________________________________________________
void AliEMCALShishKebabTrd1Module::DefineFirstModule()
{
// Define first module
TObject::SetUniqueID(1); //
}
+//_____________________________________________________________________________
void AliEMCALShishKebabTrd1Module::DefineName(Double_t theta)
{
// Define name of object
SetName(Form("%2i(%5.2f)", TObject::GetUniqueID(), theta*TMath::RadToDeg()));
}
+//_____________________________________________________________________________
Bool_t AliEMCALShishKebabTrd1Module::GetParameters()
{
// Get needing module parameters from EMCAL geometry
}
// service methods
+//_____________________________________________________________________________
void AliEMCALShishKebabTrd1Module::PrintShish(int pri) const
{
// service method
}
}
+//_____________________________________________________________________________
Double_t AliEMCALShishKebabTrd1Module::GetThetaInDegree() const
{
return fTheta*TMath::RadToDeg();
}
+//_____________________________________________________________________________
Double_t AliEMCALShishKebabTrd1Module::GetEtaOfCenterOfModule() const
{
return -TMath::Log(TMath::Tan(fOK.Phi()/2.));
AliEMCALShishKebabTrd1Module(Double_t theta=0.0, AliEMCALGeometry *g=0);
AliEMCALShishKebabTrd1Module(AliEMCALShishKebabTrd1Module &leftNeighbor);
void Init(Double_t A, Double_t B);
- AliEMCALShishKebabTrd1Module(const AliEMCALShishKebabTrd1Module& mod) : TNamed(mod.GetName(),mod.GetTitle()){
- // cpy ctor: no implementation yet; requested by the Coding Convention
- Fatal("cpy ctor", "not implemented") ;
- }
+ AliEMCALShishKebabTrd1Module(const AliEMCALShishKebabTrd1Module& mod);
+
AliEMCALShishKebabTrd1Module & operator = (const AliEMCALShishKebabTrd1Module& /*rvalue*/) {
Fatal("operator =", "not implemented") ;
return *this ;
fA = a;
fB = slope ;
}
+
+
+
//____________________________________________________________________________
Int_t AliEMCALTick::Compare(const TObject * obj) const
{
fShishKebabModules = geom->GetShishKebabTrd1Modules();
}
+//______________________________________________________________________
+AliEMCALv0::AliEMCALv0(const AliEMCALv0 & emcal):AliEMCAL(emcal)
+{
+ //copy ctor
+ fShishKebabModules = emcal.fShishKebabModules;
+ fEnvelop1 = emcal.fEnvelop1;
+ fIdRotm = emcal.fIdRotm;
+ fIdTmedArr = emcal.fIdTmedArr;
+ fSampleWidth = emcal.fSampleWidth;
+ fSmodPar0 = emcal.fSmodPar0;
+ fSmodPar1 = emcal.fSmodPar1;
+ fSmodPar2 = emcal.fSmodPar2;
+ for(Int_t i = 0; i < 5; i++) fParEMOD[i] = emcal.fParEMOD[i];
+
+}
//______________________________________________________________________
void AliEMCALv0::BuildGeometry()
{
AliEMCALv0(const char *name, const char *title="") ;
virtual ~AliEMCALv0(){}
- AliEMCALv0(const AliEMCALv0 & emcal):AliEMCAL(emcal) {
- Fatal("cpy ctor", "not implemented") ; }
+ AliEMCALv0(const AliEMCALv0 & emcal);
+
AliEMCALv0 & operator = (const AliEMCALv0 & /*rvalue*/) {
// assignement operator requested by coding convention but not needed
Fatal("operator =", "not implemented");
fTimeCut = 30e-09;
}
+//______________________________________________________________________
+AliEMCALv1::AliEMCALv1(const AliEMCALv1 & emcal):AliEMCALv0(emcal)
+{
+ //copy ctor
+ fCurPrimary = emcal.fCurPrimary;
+ fCurParent = emcal.fCurParent;
+ fCurTrack = emcal.fCurTrack;
+ fTimeCut = emcal.fTimeCut;
+
+}
+
//______________________________________________________________________
AliEMCALv1::~AliEMCALv1(){
// dtor
AliEMCALv1(const char *name, const char *title="") ;
virtual ~AliEMCALv1(void) ;
- AliEMCALv1(const AliEMCALv1 & emcal):AliEMCALv0(emcal) {
- Fatal("cpy ctor", "not implemented") ; }
+ AliEMCALv1(const AliEMCALv1 & emcal);
+
AliEMCALv1 & operator = (const AliEMCALv1 & /*rvalue*/) {
// assignement operator requested by coding convention but not needed
Fatal("operator =", "not implemented");
}
}
+//______________________________________________________________________
+AliEMCALv2::AliEMCALv2(const AliEMCALv2 & emcal):AliEMCALv1(emcal)
+{
+ //copy ctor
+ fGeometry = emcal.fGeometry;
+ fHDe = emcal.fHDe;
+ fHNhits = emcal.fHNhits;
+
+}
+
//______________________________________________________________________
AliEMCALv2::~AliEMCALv2(){
// dtor
AliEMCALv2(const char *name, const char *title="") ;
virtual ~AliEMCALv2(void) ;
- AliEMCALv2(const AliEMCALv2 & emcal):AliEMCALv1(emcal) {
- Fatal("cpy ctor", "not implemented") ; }
+ AliEMCALv2(const AliEMCALv2 & emcal);
+
AliEMCALv2 & operator = (const AliEMCALv2 & /*rvalue*/) {
// assignement operator requested by coding convention but not needed
Fatal("operator =", "not implemented");
}
}
+//______________________________________________________________________
+AliEMCALv3::AliEMCALv3(const AliEMCALv3 & emcal):AliEMCALv1(emcal)
+{
+ fGeometry = emcal.fGeometry;
+ fHDe = emcal.fHDe;
+ fHNhits = emcal.fHNhits;
+ fHDeDz = emcal.fHDeDz;
+
+}
+
//______________________________________________________________________
AliEMCALv3::~AliEMCALv3(){
// dtor
AliEMCALv3(void) ;
AliEMCALv3(const char *name, const char *title="") ;
- // cpy ctor: no implementation yet
- // requested by the Coding Convention
- AliEMCALv3(const AliEMCALv3 & emcal):AliEMCALv1(emcal) {
- Fatal("cpy ctor", "not implemented") ; }
+ AliEMCALv3(const AliEMCALv3 & emcal); //copy ctor
+
virtual ~AliEMCALv3(void) ;
using AliEMCALv1::AddHit;
AliEMCALFastRecParticle() ;
- AliEMCALFastRecParticle(const AliEMCALFastRecParticle & rp) ; // ctor
+ AliEMCALFastRecParticle(const AliEMCALFastRecParticle & rp) ; // copy ctor
AliEMCALFastRecParticle(const TParticle & p) ; // ctor
virtual ~AliEMCALFastRecParticle(){
// dtor
AliEMCALHadronCorrectionv1* AliEMCALHadronCorrectionv1::fgHadrCorr = 0;
+//______________________________________________________________________
void AliEMCALHadronCorrectionv1::SetGeometry(AliEMCALGeometry *geometry)
{
// Initialise EMCAL geometry
return;
}
+//______________________________________________________________________
void AliEMCALHadronCorrectionv1::SetGeometry(TString name,Double_t fs)
{
// Initialise EMCAL geometry
}
-
+//______________________________________________________________________
AliEMCALHadronCorrectionv1::AliEMCALHadronCorrectionv1(const char *name,const char *title)
:AliEMCALHadronCorrection(name, title)
{
fgHadrCorr = this;
+ fSamplingFraction = 1.0;
+ for(Int_t i = 0; i < 6; i++) fPar[i] = 0.;
+
}
/*
}
*/
-AliEMCALHadronCorrectionv1*
-AliEMCALHadronCorrectionv1::Instance()
+//______________________________________________________________________
+AliEMCALHadronCorrectionv1* AliEMCALHadronCorrectionv1::Instance()
{
// return pointer to global instance. Instantiate if needed
if (! fgHadrCorr) new AliEMCALHadronCorrectionv1();
return fgHadrCorr;
}
-Double_t
-AliEMCALHadronCorrectionv1::GetEnergy(Double_t pmom, Double_t eta, Int_t /*gid*/)
+//______________________________________________________________________
+Double_t AliEMCALHadronCorrectionv1::GetEnergy(Double_t pmom, Double_t eta, Int_t /*gid*/)
{
// Return parametrised energy response
Double_t etai = TMath::Abs(eta);
AliEMCALJet::AliEMCALJet()
{
// Default constructor
+ fEnergy = 0.;
+ fEMCALEnergy = 0.;
+ fEMCALEnergyBGSub = 0;
+ fTrackEnergy = 0.;
+ fTrackEnergyPtCut = 0.;
+ fHCEnergy = 0.;
+ fIsWeightedEnergy = kFALSE;
+ fEta = 0.;
+ fPhi = 0.;
+ fNt = 0;
+ fPtT = 0;
+ fEtaT = 0;
+ fPhiT = 0;
+ fPdgT = 0;
}
AliEMCALJet::AliEMCALJet(Float_t energy, Float_t phi, Float_t eta)
Float_t fEta; // Jet Eta
Float_t fPhi; // Jet Phi
Int_t fNt; // Number of associated tracks
- Float_t fPtT [1000]; // Track pt
- Float_t fEtaT[1000]; // Track eta
- Float_t fPhiT[1000]; // Track phi
- Int_t fPdgT[1000]; // Track pdg code
+ Float_t *fPtT; //[fNt] Track pt
+ Float_t *fEtaT; //[fNt] Track eta
+ Float_t *fPhiT; //[fNt] Track phi
+ Int_t *fPdgT; //[fNt] Track pdg code
ClassDef(AliEMCALJet,8) // Jet for EMCAL
} ;