add some missing copy ctors and progress toward code convention compliance
authorjklay <jklay@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Aug 2006 01:37:25 +0000 (01:37 +0000)
committerjklay <jklay@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Aug 2006 01:37:25 +0000 (01:37 +0000)
34 files changed:
EMCAL/AliEMCAL.cxx
EMCAL/AliEMCAL.h
EMCAL/AliEMCALClusterizerv1.cxx
EMCAL/AliEMCALClusterizerv1.h
EMCAL/AliEMCALDigit.cxx
EMCAL/AliEMCALDigit.h
EMCAL/AliEMCALGeometry.cxx
EMCAL/AliEMCALGeometry.h
EMCAL/AliEMCALGeometryOfflineTrd1.cxx
EMCAL/AliEMCALGeometryOfflineTrd1.h
EMCAL/AliEMCALLoader.cxx
EMCAL/AliEMCALLoader.h
EMCAL/AliEMCALRecPoint.cxx
EMCAL/AliEMCALRecPoint.h
EMCAL/AliEMCALReconstructor.cxx
EMCAL/AliEMCALReconstructor.h
EMCAL/AliEMCALSDigitizer.cxx
EMCAL/AliEMCALShishKebabModule.cxx
EMCAL/AliEMCALShishKebabModule.h
EMCAL/AliEMCALShishKebabTrd1Module.cxx
EMCAL/AliEMCALShishKebabTrd1Module.h
EMCAL/AliEMCALTick.cxx
EMCAL/AliEMCALv0.cxx
EMCAL/AliEMCALv0.h
EMCAL/AliEMCALv1.cxx
EMCAL/AliEMCALv1.h
EMCAL/AliEMCALv2.cxx
EMCAL/AliEMCALv2.h
EMCAL/AliEMCALv3.cxx
EMCAL/AliEMCALv3.h
EMCAL/jetfinder/AliEMCALFastRecParticle.h
EMCAL/jetfinder/AliEMCALHadronCorrectionv1.cxx
EMCAL/jetfinder/AliEMCALJet.cxx
EMCAL/jetfinder/AliEMCALJet.h

index 6f95bb9..d00b2d2 100644 (file)
@@ -67,17 +67,24 @@ AliEMCAL::AliEMCAL():AliDetector()
 {
   // 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
 }
 
 //____________________________________________________________________________
@@ -87,6 +94,20 @@ AliEMCAL::~AliEMCAL()
 }
 
 //____________________________________________________________________________
+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
 {
   //copy
index 2dba2f1..34d87d6 100644 (file)
@@ -33,11 +33,8 @@ class AliEMCAL : public AliDetector {
   
   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 )") ;  
@@ -61,7 +58,7 @@ class AliEMCAL : public AliDetector {
   
   virtual AliTriggerDetector* CreateTriggerDetector() const 
     { return new AliEMCALTrigger(); }
-  
+
   // Raw Read Out
   Double_t GetRawFormatCapa() const { return fgCapa ; }   
   Double_t GetRawFormatHighCharge() const { return fHighCharge ; }  
@@ -90,6 +87,8 @@ protected:
   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
index 044b6b3..9114f8f 100644 (file)
@@ -102,6 +102,39 @@ AliEMCALClusterizerv1::AliEMCALClusterizerv1(const TString alirunFileName, const
 }
 
 //____________________________________________________________________________
+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()
 {
   // dtor
index 59b0ca1..f83936e 100644 (file)
@@ -37,7 +37,7 @@ public:
   
   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()  ;
index 40eab12..968f445 100644 (file)
@@ -226,7 +226,7 @@ Bool_t AliEMCALDigit::operator==(AliEMCALDigit const & digit) const
 }
  
 //____________________________________________________________________________
-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 
@@ -287,7 +287,7 @@ AliEMCALDigit& AliEMCALDigit::operator+(AliEMCALDigit const & digit)
 }
 
 //____________________________________________________________________________
-AliEMCALDigit& AliEMCALDigit::operator*(Float_t factor) 
+AliEMCALDigit AliEMCALDigit::operator*(Float_t factor) 
 {
   // Multiplies the amplitude by a factor
   
index 4801b31..dc80f89 100644 (file)
@@ -36,8 +36,8 @@ class AliEMCALDigit : public AliDigitNew {
   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 ;  
index ed114c6..1b05489 100644 (file)
@@ -80,6 +80,75 @@ AliGeometry(name, title) {// ctor only for internal usage (singleton)
   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
 }
index 1b598d7..c148cfc 100644 (file)
@@ -31,10 +31,7 @@ class TClonesArray ;
 
 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,
@@ -177,12 +174,7 @@ public:
 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();        //
index 804d6b5..0e51e04 100644 (file)
@@ -35,6 +35,7 @@ ClassImp(AliEMCALGeometryOfflineTrd1)
 
 AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::fgGeomOfflineTrd1=0;
 
+//___________________________________________________________________________
 AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::GetInstance()
 {
   //retrurn instance of the geometry
@@ -44,6 +45,7 @@ AliEMCALGeometryOfflineTrd1* AliEMCALGeometryOfflineTrd1::GetInstance()
   return fgGeomOfflineTrd1;
 }
 
+//___________________________________________________________________________
 AliEMCALGeometryOfflineTrd1::AliEMCALGeometryOfflineTrd1() : TNamed("geomTRD1","")
 { 
   // this private constarctor
@@ -51,6 +53,32 @@ AliEMCALGeometryOfflineTrd1::AliEMCALGeometryOfflineTrd1() : TNamed("geomTRD1","
   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
@@ -109,6 +137,7 @@ void AliEMCALGeometryOfflineTrd1::Init()
   }
 }
 
+//___________________________________________________________________________
 TVector3& AliEMCALGeometryOfflineTrd1::PosInSuperModule(int nSupMod, Int_t nTower, Int_t nIphi, Int_t nIeta)
 { 
   //return location of position within supermodule
@@ -122,6 +151,7 @@ TVector3& AliEMCALGeometryOfflineTrd1::PosInSuperModule(int nSupMod, Int_t nTowe
   return v;
 } 
 
+//___________________________________________________________________________
 void AliEMCALGeometryOfflineTrd1::PositionInSuperModule(Int_t iphi, Int_t ieta, 
 double &lphi, double &leta)
 { 
@@ -135,6 +165,7 @@ 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)
 {
@@ -145,6 +176,7 @@ double &lphi, double &leta)
   PositionInSuperModule(iphi,ieta, lphi,leta);
 }
 
+//___________________________________________________________________________
 TRotation* AliEMCALGeometryOfflineTrd1::Rotation(Int_t module)
 { 
   //return rotation matrix for module
@@ -154,6 +186,7 @@ TRotation* AliEMCALGeometryOfflineTrd1::Rotation(Int_t module)
   return &fSuperModuleRotation[module];
 }
 
+//___________________________________________________________________________
 TVector3* AliEMCALGeometryOfflineTrd1::CellPosition(int absId)
 { 
   //return cell position given absoluted cell id
@@ -162,6 +195,7 @@ TVector3* AliEMCALGeometryOfflineTrd1::CellPosition(int absId)
   return (TVector3*)fXYZofCells->At(absId-1);
 }
 
+//___________________________________________________________________________
 void AliEMCALGeometryOfflineTrd1::PrintSuperModule()
 {
   //utility method for printing supermodule info
@@ -177,6 +211,7 @@ void AliEMCALGeometryOfflineTrd1::PrintSuperModule()
   }
 }
 
+//___________________________________________________________________________
 void AliEMCALGeometryOfflineTrd1::PrintCell(Int_t absId)
 {
   //utility method for printing cell info
@@ -191,6 +226,7 @@ void AliEMCALGeometryOfflineTrd1::PrintCell(Int_t absId)
   }
 }
 
+//___________________________________________________________________________
 void AliEMCALGeometryOfflineTrd1::Browse(TBrowser* b)
 {
   //Browse the geometry
@@ -211,6 +247,7 @@ void AliEMCALGeometryOfflineTrd1::Browse(TBrowser* b)
   b->Add(fXYZofCells);
 }
 
+//___________________________________________________________________________
 Bool_t AliEMCALGeometryOfflineTrd1::IsFolder() const
 {
   //folder check
index 038cf79..df42d83 100644 (file)
@@ -25,10 +25,7 @@ class AliEMCALShishKebabTrd1Module;
 
 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;}
index 3abdb44..64dd38d 100644 (file)
@@ -83,6 +83,19 @@ AliEMCALLoader::AliEMCALLoader(const Char_t *detname,const Char_t *eventfolderna
   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()
 {
index dcd4bce..067b5d0 100644 (file)
@@ -41,7 +41,7 @@ class AliEMCALLoader : public AliLoader {
  public:
 
   AliEMCALLoader();
-  AliEMCALLoader(const AliEMCALLoader & obj):AliLoader(obj){}
+  AliEMCALLoader(const AliEMCALLoader & obj);
   AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername); 
   
   virtual ~AliEMCALLoader() ; 
index ac5cec3..8d3d8f2 100644 (file)
@@ -94,6 +94,33 @@ AliEMCALRecPoint::AliEMCALRecPoint(const char * opt) : AliRecPoint(opt)
   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
index ca7164a..64955d8 100644 (file)
@@ -28,7 +28,7 @@ class AliEMCALRecPoint : public AliRecPoint {
 
   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 )") ; }
index ab56090..b2df8c9 100644 (file)
@@ -45,6 +45,13 @@ ClassImp(AliEMCALReconstructor)
 
 } 
 
+//____________________________________________________________________________
+AliEMCALReconstructor::AliEMCALReconstructor(const AliEMCALReconstructor & rec): AliReconstructor(rec)
+{
+  //copy ctor
+  fDebug = rec.fDebug;
+
+}
 
 //____________________________________________________________________________
 AliEMCALReconstructor::~AliEMCALReconstructor()
index aa98d97..f852f1e 100644 (file)
@@ -30,11 +30,7 @@ class AliEMCALReconstructor : public AliReconstructor {
 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
 
index ee8c007..ed23b9f 100644 (file)
@@ -76,6 +76,7 @@ ClassImp(AliEMCALSDigitizer)
 {
   // ctor
   fFirstEvent = fLastEvent  = fControlHists = 0;  
+  InitParameters();
   fDefaultInit = kTRUE ; 
   fHists = 0;
 }
index bb2b2ee..172f948 100644 (file)
@@ -35,6 +35,7 @@ ClassImp(AliEMCALShishKebabModule)
   Double_t AliEMCALShishKebabModule::fgb=0.; 
   Double_t AliEMCALShishKebabModule::fgr=0.; 
 
+//_________________________________________________________________________
 AliEMCALShishKebabModule::AliEMCALShishKebabModule() : TNamed()
 { 
   // theta in radians ; first object shold be with theta=pi/2.
@@ -49,6 +50,7 @@ AliEMCALShishKebabModule::AliEMCALShishKebabModule() : TNamed()
   }
 }
 
+//_________________________________________________________________________
 AliEMCALShishKebabModule::AliEMCALShishKebabModule(AliEMCALShishKebabModule &leftNeighbor) : TNamed()
 { 
   // 22-sep-04
@@ -56,6 +58,18 @@ AliEMCALShishKebabModule::AliEMCALShishKebabModule(AliEMCALShishKebabModule &lef
   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)
 { 
   //
@@ -88,6 +102,7 @@ void AliEMCALShishKebabModule::Init(Double_t A, Double_t B)
   DefineName(fTheta);
 }
 
+//_________________________________________________________________________
 void AliEMCALShishKebabModule::DefineFirstModule()
 {
   // Define first module
@@ -98,6 +113,7 @@ void AliEMCALShishKebabModule::DefineFirstModule()
   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; 
@@ -114,6 +130,7 @@ void AliEMCALShishKebabModule::DefineSecondModuleFirstAssumption()
   */
 }
 
+//_________________________________________________________________________
 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)
 {
@@ -130,6 +147,7 @@ Double_t xmin, Double_t xmax, Int_t npar, Double_t *par, Double_t eps, Int_t max
   return x;
 }
 
+//_________________________________________________________________________
 Double_t AliEMCALShishKebabModule::Y2(Double_t *x, Double_t *par)
 { 
   // For position calulation of second module
@@ -143,6 +161,7 @@ Double_t AliEMCALShishKebabModule::Y2(Double_t *x, Double_t *par)
   return y;
 }
 
+//_________________________________________________________________________
 Double_t AliEMCALShishKebabModule::YALL(Double_t *x, Double_t *par)
 { 
   // For position calulation of 3th, 4th to 30th modules
@@ -158,12 +177,14 @@ Double_t AliEMCALShishKebabModule::YALL(Double_t *x, Double_t *par)
   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
@@ -180,6 +201,7 @@ Bool_t AliEMCALShishKebabModule::GetParameters()
   return kTRUE;
 }
 
+//_________________________________________________________________________
 void AliEMCALShishKebabModule::PrintShish(Int_t pri) const
 {
   // service method
@@ -195,6 +217,7 @@ void AliEMCALShishKebabModule::PrintShish(Int_t pri) const
   }
 }
 
+//_________________________________________________________________________
 Double_t AliEMCALShishKebabModule::GetThetaInDegree() const 
 {
   return fTheta*TMath::RadToDeg();
index f2f663c..ffcd8a8 100644 (file)
@@ -22,10 +22,8 @@ class AliEMCALShishKebabModule : public TNamed {
   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 ; 
index a569536..8aa8335 100644 (file)
@@ -40,6 +40,7 @@ ClassImp(AliEMCALShishKebabTrd1Module)
   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.
@@ -55,6 +56,7 @@ AliEMCALShishKebabTrd1Module::AliEMCALShishKebabTrd1Module(Double_t theta, AliEM
   cout<< "AliEMCALShishKebabTrd1Module - first module:  theta " << fTheta << " geometry " << g << endl;  
 }
 
+//_____________________________________________________________________________
 AliEMCALShishKebabTrd1Module::AliEMCALShishKebabTrd1Module(AliEMCALShishKebabTrd1Module &leftNeighbor) : TNamed()
 { 
   //  printf("** Left Neighbor : %s **\n", leftNeighbor.GetName());
@@ -63,6 +65,24 @@ AliEMCALShishKebabTrd1Module::AliEMCALShishKebabTrd1Module(AliEMCALShishKebabTrd
   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.
@@ -106,6 +126,7 @@ void AliEMCALShishKebabTrd1Module::Init(Double_t A, Double_t B)
   fOB2.Set(fOB.X()+fga/4.*TMath::Sin(fTheta), fOB.Y()-fga/4.*TMath::Cos(fTheta));
 }
 
+//_____________________________________________________________________________
 void AliEMCALShishKebabTrd1Module::DefineFirstModule()
 {
   // Define first module
@@ -128,12 +149,14 @@ void AliEMCALShishKebabTrd1Module::DefineFirstModule()
   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
@@ -157,6 +180,7 @@ Bool_t AliEMCALShishKebabTrd1Module::GetParameters()
 }
 
 // service methods
+//_____________________________________________________________________________
 void AliEMCALShishKebabTrd1Module::PrintShish(int pri) const
 {
   // service method
@@ -180,11 +204,13 @@ void AliEMCALShishKebabTrd1Module::PrintShish(int pri) const
   }
 }
 
+//_____________________________________________________________________________
 Double_t  AliEMCALShishKebabTrd1Module::GetThetaInDegree() const 
 {
   return fTheta*TMath::RadToDeg();
 }
 
+//_____________________________________________________________________________
 Double_t  AliEMCALShishKebabTrd1Module::GetEtaOfCenterOfModule() const 
 { 
   return -TMath::Log(TMath::Tan(fOK.Phi()/2.));
index cc727b8..8ee884c 100644 (file)
@@ -20,10 +20,8 @@ class AliEMCALShishKebabTrd1Module : public TNamed {
   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 ; 
index 5db9090..af2169e 100644 (file)
@@ -53,6 +53,9 @@ AliEMCALTick::AliEMCALTick(Float_t time, Float_t a, Float_t slope):TObject()
   fA = a;
   fB = slope ;  
 }
+
+
+
 //____________________________________________________________________________ 
 Int_t AliEMCALTick::Compare(const TObject * obj) const 
 {
index 725b7fa..1683160 100644 (file)
@@ -82,6 +82,21 @@ AliEMCALv0::AliEMCALv0(const char *name, const char *title):
 }
 
 //______________________________________________________________________
+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()
 {
     // Display Geometry for display.C
index 085e9c8..b4d765f 100644 (file)
@@ -32,8 +32,8 @@ class AliEMCALv0 : public AliEMCAL {
   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");
index 1f71607..2b7dd7c 100644 (file)
@@ -64,6 +64,17 @@ AliEMCALv1::AliEMCALv1(const char *name, const char *title):
 }
 
 //______________________________________________________________________
+AliEMCALv1::AliEMCALv1(const AliEMCALv1 & emcal):AliEMCALv0(emcal)
+{
+  //copy ctor
+  fCurPrimary = emcal.fCurPrimary;
+  fCurParent = emcal.fCurParent;
+  fCurTrack = emcal.fCurTrack;
+  fTimeCut = emcal.fTimeCut;
+
+}
+
+//______________________________________________________________________
 AliEMCALv1::~AliEMCALv1(){
     // dtor
 
index 6fba374..fa61a60 100644 (file)
@@ -28,8 +28,8 @@ public:
   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");
index fe7d858..18bddbb 100644 (file)
@@ -76,6 +76,16 @@ AliEMCALv2::AliEMCALv2(const char *name, const char *title): AliEMCALv1(name,tit
 }
 
 //______________________________________________________________________
+AliEMCALv2::AliEMCALv2(const AliEMCALv2 & emcal):AliEMCALv1(emcal)
+{
+  //copy ctor
+  fGeometry = emcal.fGeometry;
+  fHDe = emcal.fHDe;
+  fHNhits = emcal.fHNhits;
+
+}
+
+//______________________________________________________________________
 AliEMCALv2::~AliEMCALv2(){
     // dtor
 
index 54dc462..9467b62 100644 (file)
@@ -33,8 +33,8 @@ public:
   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");
index 183088d..8a20c55 100644 (file)
@@ -85,6 +85,16 @@ AliEMCALv3::AliEMCALv3(const char *name, const char *title): AliEMCALv1(name,tit
 }
 
 //______________________________________________________________________
+AliEMCALv3::AliEMCALv3(const AliEMCALv3 & emcal):AliEMCALv1(emcal)
+{
+  fGeometry = emcal.fGeometry;
+  fHDe = emcal.fHDe;
+  fHNhits = emcal.fHNhits;
+  fHDeDz = emcal.fHDeDz;
+
+}
+
+//______________________________________________________________________
 AliEMCALv3::~AliEMCALv3(){
     // dtor
 
index c79a463..a4a6fce 100644 (file)
@@ -27,10 +27,8 @@ public:
 
   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;
index 7faa0dd..183cda1 100644 (file)
@@ -26,7 +26,7 @@ class AliEMCALFastRecParticle : public TParticle {
   
   AliEMCALFastRecParticle() ;
   
-  AliEMCALFastRecParticle(const AliEMCALFastRecParticle & rp) ;  // ctor
+  AliEMCALFastRecParticle(const AliEMCALFastRecParticle & rp) ;  // copy ctor
   AliEMCALFastRecParticle(const TParticle & p) ;  // ctor
   virtual ~AliEMCALFastRecParticle(){
     // dtor
index 26b763e..e4599b4 100644 (file)
@@ -35,6 +35,7 @@ Double_t AliEMCALHadronCorrectionv1::fgParLookup[HCPARAMETERS][HCPARAMETERSETS]
 
 AliEMCALHadronCorrectionv1* AliEMCALHadronCorrectionv1::fgHadrCorr = 0;
 
+//______________________________________________________________________
 void AliEMCALHadronCorrectionv1::SetGeometry(AliEMCALGeometry *geometry)
 {
   // Initialise EMCAL geometry
@@ -52,6 +53,7 @@ void AliEMCALHadronCorrectionv1::SetGeometry(AliEMCALGeometry *geometry)
     return;    
 }      
        
+//______________________________________________________________________
 void AliEMCALHadronCorrectionv1::SetGeometry(TString name,Double_t fs)
 {
   // Initialise EMCAL geometry
@@ -86,11 +88,14 @@ void AliEMCALHadronCorrectionv1::SetGeometry(TString name,Double_t fs)
        
 }      
 
-       
+//______________________________________________________________________       
 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.;
+
 }
 
 /*
@@ -103,16 +108,16 @@ AliEMCALHadronCorrectionv1::AliEMCALHadronCorrectionv1(const char *name,const ch
 }      
 */
 
-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); 
index dedf693..c58e501 100644 (file)
@@ -27,6 +27,20 @@ ClassImp(AliEMCALJet)
 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)
index d43cef6..1f90f43 100644 (file)
@@ -46,10 +46,10 @@ protected:
   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
 
 } ;