Removal of effc++ warnings
authorcoppedis <coppedis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 29 Aug 2006 08:16:17 +0000 (08:16 +0000)
committercoppedis <coppedis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 29 Aug 2006 08:16:17 +0000 (08:16 +0000)
15 files changed:
ZDC/AliZDC.cxx
ZDC/AliZDC.h
ZDC/AliZDCDigit.h
ZDC/AliZDCDigitizer.cxx
ZDC/AliZDCDigitizer.h
ZDC/AliZDCHit.cxx
ZDC/AliZDCHit.h
ZDC/AliZDCRawStream.cxx
ZDC/AliZDCRawStream.h
ZDC/AliZDCReco.cxx
ZDC/AliZDCReco.h
ZDC/AliZDCReconstructor.cxx
ZDC/AliZDCReconstructor.h
ZDC/ZDCsimLinkDef.h
ZDC/libZDCsim.pkg

index 05e75cf..090f0c7 100644 (file)
@@ -54,38 +54,41 @@ ClassImp(AliZDC)
 AliZDC *gAliZDC;
  
 //_____________________________________________________________________________
-AliZDC::AliZDC()
+AliZDC::AliZDC() :
+  AliDetector(),
+  fNoShower  (0),
+  fCalibData (0)
+
 {
   //
   // Default constructor for the Zero Degree Calorimeter base class
   //
   
-  fIshunt     = 1;
-  fNoShower   = 0;
-
-  fHits       = 0;
-  fNhits      = 0;
-
-  fDigits     = 0;
-  fNdigits    = 0;
+  fIshunt = 1;
+  fNhits  = 0;
+  fHits = 0;
+  fDigits = 0;
+  fNdigits = 0;
   
-  fCalibData  = 0;
-
 }
  
 //_____________________________________________________________________________
-AliZDC::AliZDC(const char *name, const char *title)
-  : AliDetector(name,title)
+AliZDC::AliZDC(const char *name, const char *title) : 
+  AliDetector(name,title),
+  fNoShower  (0),
+  fCalibData (0)
+                
 {
   //
   // Standard constructor for the Zero Degree Calorimeter base class
   //
-
-  fIshunt   = 1;
-  fNoShower = 0;
-
-  // Allocate the hits array  
-  fHits   = new TClonesArray("AliZDCHit",1000);
+    
+  fIshunt = 1;
+  fNhits  = 0;
+  fDigits = 0;
+  fNdigits = 0;
+  fHits = new TClonesArray("AliZDCHit",1000);
   gAlice->GetMCApp()->AddHitList(fHits);
   
   char sensname[5],senstitle[25];
@@ -93,14 +96,10 @@ AliZDC::AliZDC(const char *name, const char *title)
   sprintf(senstitle,"ZDC dummy");
   SetName(sensname); SetTitle(senstitle);
 
-  fDigits     = 0;
-  fNdigits    = 0;
-  
-  fCalibData  = 0;
-
-  gAliZDC=this;
+  gAliZDC = this;
 
 }
+
 //____________________________________________________________________________ 
 AliZDC::~AliZDC()
 {
@@ -108,12 +107,34 @@ AliZDC::~AliZDC()
   // ZDC destructor
   //
 
-  fIshunt   = 0;
-  gAliZDC=0;
+  fIshunt = 0;
+  gAliZDC = 0;
 
   delete fCalibData;
 
 }
+
+//_____________________________________________________________________________
+AliZDC::AliZDC(const AliZDC& ZDC) :
+  AliDetector("ZDC","ZDC")
+{
+  // copy constructor
+    fNoShower = ZDC.fNoShower;
+    fCalibData = ZDC.fCalibData;
+    fZDCCalibFName = ZDC.fZDCCalibFName;
+}
+
+//_____________________________________________________________________________
+AliZDC& AliZDC::operator=(const AliZDC& ZDC)
+{
+  // assignement operator
+  if(this!=&ZDC){
+    fNoShower = ZDC.fNoShower;
+    fCalibData = ZDC.fCalibData;
+    fZDCCalibFName = ZDC.fZDCCalibFName;
+  } return *this;
+}
+
 //_____________________________________________________________________________
 void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits)
 {
@@ -158,15 +179,31 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits)
      curprimquad = (AliZDCHit*) lhits[j];
      if(*curprimquad == *newquad){
         *curprimquad = *curprimquad+*newquad;
+        // CH. debug
+        /*if(newquad->GetEnergy() != 0. || newquad->GetLightPMC() != 0. || 
+          newquad->GetLightPMQ() != 0.){
+         printf("\n\t --- Equal hits found\n");
+         curprimquad->Print("");
+         newquad->Print("");
+          printf("\t --- Det. %d, Quad. %d: X = %f, E = %f, LightPMC = %f, LightPMQ = %f\n",
+          curprimquad->GetVolume(0),curprimquad->GetVolume(1),curprimquad->GetXImpact(),
+          curprimquad->GetEnergy(), curprimquad->GetLightPMC(), curprimquad->GetLightPMQ());
+       }*/
+       //
        delete newquad;
        return;
      } 
   }
 
     //Otherwise create a new hit
-    new(lhits[fNhits]) AliZDCHit(newquad);
+    new(lhits[fNhits]) AliZDCHit(*newquad);
     fNhits++;
-    
+    // CH. debug
+    /*printf("\n\t New ZDC hit added! fNhits = %d\n", fNhits);
+    printf("\t Det. %d, Quad.t %d: X = %f, E = %f, LightPMC = %f, LightPMQ = %f\n",
+    newquad->GetVolume(0),newquad->GetVolume(1),newquad->GetXImpact(),
+    newquad->GetEnergy(), newquad->GetLightPMC(), newquad->GetLightPMQ());
+    */
     delete newquad;
 }
 
index 8e0b2a2..f279c31 100644 (file)
@@ -22,6 +22,8 @@ public:
   AliZDC();
   AliZDC(const char *name, const char *title);
   virtual       ~AliZDC();
+  AliZDC(const AliZDC&);
+  //
   virtual void  AddHit(Int_t track, Int_t *vol, Float_t *hits);
   virtual void  BuildGeometry();
   virtual void  CreateGeometry() {}
@@ -55,6 +57,10 @@ public:
   virtual AliTriggerDetector* CreateTriggerDetector() const
        {return new AliZDCTrigger();}
 
+private:
+
+  AliZDC& operator = (const AliZDC&);
+
 protected:
 
   Int_t        fNoShower;              // Flag to switch off the shower        
index 17c297c..606bc96 100644 (file)
@@ -29,15 +29,15 @@ class AliZDCDigit : public TObject {
   // Operators
   // Two digits are equal if they refers to the detector
   // in the same sub-volume (same procedure as for hits)
-  Int_t operator == (AliZDCDigit &digit) {
+  Int_t operator == (AliZDCDigit &digit){
     Int_t i;
     for(i=0; i<2; i++) if(fSector[i]!=digit.GetSector(i)) return 0;
     return 1;
   }
   // Adds the amplitude of digits 
-  virtual AliZDCDigit& operator + (AliZDCDigit &digit) {
+  virtual AliZDCDigit operator + (AliZDCDigit &digit){
     for(Int_t i = 0; i < 2; i++) fADCValue[i] += digit.fADCValue[i];
-    return *this ;
+    return *this;
   }
 
   // Print method
index c34706a..a7ce519 100644 (file)
@@ -76,6 +76,23 @@ AliZDCDigitizer::~AliZDCDigitizer()
 
 
 //____________________________________________________________________________
+AliZDCDigitizer::AliZDCDigitizer(const AliZDCDigitizer &digitizer):
+  AliDigitizer()
+{
+  // Copy constructor
+
+  for(Int_t i=0; i<6; i++){
+     for(Int_t j=0; j<5; j++){
+        fPMGain[i][j]   = digitizer.fPMGain[i][j];           
+     }
+  }
+  for(Int_t i=0; i<2; i++) fADCRes[i] = digitizer.fADCRes[i];
+  fIsCalibration = digitizer.fIsCalibration;
+  fCalibData = digitizer.fCalibData;
+
+}
+
+//____________________________________________________________________________
 Bool_t AliZDCDigitizer::Init()
 {
   // Initialize the digitizer
index 31ff644..f2ddddb 100644 (file)
@@ -47,6 +47,10 @@ public:
   AliZDCCalibData *GetCalibData() const; 
 
 private:
+
+  AliZDCDigitizer(const AliZDCDigitizer&);
+  AliZDCDigitizer& operator=(const AliZDCDigitizer&);
+
   void    Fragmentation(Float_t impPar, Int_t specN, Int_t specP,
                         Int_t &freeSpecN, Int_t &freeSpecP) const;
   void    SpectatorSignal(Int_t SpecType, Int_t numEvents, 
index 009e4ee..bf1257e 100644 (file)
 ClassImp(AliZDCHit)
   
 //_____________________________________________________________________________
-AliZDCHit::AliZDCHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
-  AliHit(shunt, track)
+AliZDCHit::AliZDCHit() :
+//  AliHit(shunt, track),
+  fPrimKinEn(00),
+  fXImpact(0.),
+  fYImpact(0.),
+  fSFlag(0),
+  fLightPMQ(0.),
+  fLightPMC(0.),
+  fEnergy(0.) 
+
+{
+  //
+  // Default constructor
+  //
+}
+
+//_____________________________________________________________________________
+AliZDCHit::AliZDCHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits) :
+  AliHit(shunt, track),
+  fPrimKinEn(hits[3]),
+  fXImpact(hits[4]),
+  fYImpact(hits[5]),
+  fSFlag(hits[6]),
+  fLightPMQ(hits[7]),
+  fLightPMC(hits[8]),
+  fEnergy(hits[9]) 
+
 {
   //
-  // Add a ZDC hit
+  // Standard constructor
   //
   Int_t i;
-  for(i=0; i<2; i++) {
-     fVolume[i] = vol[i];
-  }
+  for(i=0; i<2; i++) fVolume[i] = vol[i];
   fX           = hits[0];
   fY           = hits[1];
   fZ           = hits[2];
-  fPrimKinEn   = hits[3];
-  fXImpact     = hits[4];
-  fYImpact     = hits[5];
-  fSFlag       = hits[6];
-  fLightPMQ    = hits[7];
-  fLightPMC    = hits[8];
-  fEnergy      = hits[9]; 
+}
   
+//_____________________________________________________________________________
+AliZDCHit::AliZDCHit(const AliZDCHit &oldhit) :
+  AliHit(0,oldhit.GetTrack())
+{
+  // Copy constructor
+  fX = oldhit.X();
+  fY = oldhit.Y();
+  fZ = oldhit.Z();
+  for(Int_t i=0; i<2; i++) fVolume[i] = oldhit.GetVolume(i);
+  fPrimKinEn = oldhit.GetPrimKinEn();
+  fXImpact = oldhit.GetXImpact();  
+  fYImpact = oldhit.GetYImpact();  
+  fSFlag = oldhit.GetSFlag();    
+  fLightPMQ = oldhit.GetLightPMQ(); 
+  fLightPMC = oldhit.GetLightPMC(); 
+  fEnergy = oldhit.GetEnergy();   
 }
   
+  
 //_____________________________________________________________________________
 void AliZDCHit::Print(Option_t *) const 
 {
index 247cc3b..4964f54 100644 (file)
 class AliZDCHit : public AliHit {
 
 public:
-  AliZDCHit() {}
+  AliZDCHit();
   AliZDCHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
-  AliZDCHit(AliZDCHit* oldhit) {*this=*oldhit;}
+  //AliZDCHit(const AliZDCHit* oldhit) {*this=*oldhit;}
+  AliZDCHit(const AliZDCHit &oldhit);
   virtual ~AliZDCHit() {}
 
   // Getters 
@@ -36,17 +37,17 @@ public:
   virtual void SetYImpact(Float_t value)  {fYImpact=value;}
 
   // Operators
-  Int_t operator == (AliZDCHit &quad) {
+  Int_t operator == (AliZDCHit &quad){
      Int_t i;
      if(fTrack!=quad.GetTrack()) return 0;
      for(i=0; i<2; i++) if(fVolume[i]!=quad.GetVolume(i)) return 0;
      return 1;
   }
   
-  virtual AliZDCHit& operator + (AliZDCHit &quad) {
-     fLightPMQ+=quad.GetLightPMQ();
-     fLightPMC+=quad.GetLightPMC();
-     fEnergy+=quad.GetEnergy();
+  virtual AliZDCHit operator + (AliZDCHit &quad){
+     fLightPMQ += quad.GetLightPMQ();
+     fLightPMC += quad.GetLightPMC();
+     fEnergy += quad.GetEnergy();
      return *this;
   }
 
index 3e84f79..3fbcd54 100644 (file)
@@ -28,6 +28,7 @@
 
 #include "AliZDCRawStream.h"
 #include "AliRawReader.h"
+#include "AliLog.h"
 
 ClassImp(AliZDCRawStream)
 
@@ -35,13 +36,13 @@ ClassImp(AliZDCRawStream)
 //_____________________________________________________________________________
 AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
   fRawReader(rawReader),
-  fADCValue(-1)
+  fRawADC(0),   
+  fADCModule(-1),
+  fADCValue(-1),        
+  fADCGain(0)
 {
   // Create an object to read ZDC raw digits
 
-  fSector[0] = 0;
-  fSector[1] = -1;
-  fADCModule = 0;
   fRawReader->Select("ZDC");
 }
 
@@ -97,9 +98,9 @@ Bool_t AliZDCRawStream::Next()
   } 
   //ADC Data Words
   else{
-    //printf("This is an ADC Data Word -> channel %d range %d\n",(fRawADC & 0x1e0000) >> 17, (fRawADC & 0x10000) >> 16);
+    /*printf("This is an ADC Data Word -> channel %d range %d\n",(fRawADC & 0x1e0000) >> 17, (fRawADC & 0x10000) >> 16);
     if(fRawADC & 0x1000) printf("ZDCRawStream -> ADC overflow\n");
-    if(fRawADC & 0x2000) printf("ZDCRawStream -> ADC underflow\n");
+    if(fRawADC & 0x2000) printf("ZDCRawStream -> ADC underflow\n");*/
     //
     fADCGain = (fRawADC & 0x10000) >> 16;
     fADCValue = (fRawADC & 0xfff);   
@@ -130,7 +131,7 @@ Bool_t AliZDCRawStream::Next()
         fSector[1] = vADCChannel-8;
       } 
     }
-    else printf("\t AliZDCRawStreamer -> ERROR! No valid ADC module!\n");
+    else Warning("AliZDCRawStream","\t No valid ADC module!\n");
     
   }
   return kTRUE;
index 257a21e..b2304f7 100644 (file)
@@ -18,9 +18,8 @@ class AliRawReader;
 
 class AliZDCRawStream: public TObject {
   public :
-    AliZDCRawStream(AliRawReader* rawReader);
+    AliZDCRawStream(AliRawReader* rawReader); 
     virtual ~AliZDCRawStream();
-
     virtual Bool_t   Next();
 
     Int_t            GetSector(Int_t i) const {return fSector[i];};
@@ -34,13 +33,13 @@ class AliZDCRawStream: public TObject {
     AliZDCRawStream(const AliZDCRawStream& stream);
     AliZDCRawStream& operator = (const AliZDCRawStream& stream);
 
-    AliRawReader*    fRawReader;    // object for reading the raw data
+    AliRawReader*    fRawReader;     // object for reading the raw data
 
-    UInt_t           fRawADC;       // raw ADC
-    Int_t            fSector[2];    // index of current sector
-    Int_t            fADCModule;    // ADC module;
-    Int_t            fADCValue;     // ADC value;
-    Int_t            fADCGain;      // ADC gain (0=high range; 1=low range)
+    UInt_t           fRawADC;        // raw ADC
+    Int_t            fSector[2];     // index of current sector
+    Int_t            fADCModule;     // ADC module;
+    Int_t            fADCValue;      // ADC value;
+    Int_t            fADCGain;       // ADC gain (0=high range; 1=low range)
     Bool_t           fIsADCDataWord; //True when data word
 
     ClassDef(AliZDCRawStream, 2)    // class for reading ZDC raw digits
index 431d980..7cb8c27 100644 (file)
 
 ClassImp(AliZDCReco)
   
+
+//_____________________________________________________________________________
+AliZDCReco::AliZDCReco() :
+       
+  TObject(),
+  fZN1energy(0),
+  fZP1energy(0),
+  fZDC1energy(0),
+  fZN2energy(0),
+  fZP2energy(0),
+  fZDC2energy(0),
+  fZEMenergy(0),
+  fNDetSpecNLeft(0),
+  fNDetSpecPLeft(0),
+  fNDetSpecNRight(0),
+  fNDetSpecPRight(0),
+  fNTrueSpecN(0),
+  fNTrueSpecP(0),
+  fNTrueSpec(0),
+  fNPart(0),
+  fImpPar(0)
+
+{ 
+  //
+  // Default constructor
+  //
+}
+  
+
 //_____________________________________________________________________________
 AliZDCReco::AliZDCReco(Float_t ezn1, Float_t ezp1, Float_t ezdc1, Float_t ezem,
        Float_t ezn2, Float_t ezp2, Float_t ezdc2,
        Int_t detspnLeft, Int_t detsppLeft, Int_t detspnRight, Int_t detsppRight,
-       Int_t trspn, Int_t trspp, Int_t trsp, Int_t part, Float_t b)
+       Int_t trspn, Int_t trspp, Int_t trsp, Int_t part,
+       Float_t b) :
+       
+  TObject(),
+  fZN1energy(ezn1),
+  fZP1energy(ezp1),
+  fZDC1energy(ezdc1),
+  fZN2energy(ezn2),
+  fZP2energy(ezp2),
+  fZDC2energy(ezdc2),
+  fZEMenergy(ezem),
+  fNDetSpecNLeft(detspnLeft),
+  fNDetSpecPLeft(detsppLeft),
+  fNDetSpecNRight(detspnRight),
+  fNDetSpecPRight(detsppRight),
+  fNTrueSpecN(trspn),
+  fNTrueSpecP(trspp),
+  fNTrueSpec(trsp),
+  fNPart(part),
+  fImpPar(b)
+
 { 
   //
-  // Standard constructor
+  // Constructor
   //
-  fZN1energy  = ezn1;
-  fZP1energy  = ezp1;
-  fZDC1energy = ezdc1;
-  fZN2energy  = ezn2;
-  fZP2energy  = ezp2;
-  fZDC2energy = ezdc2;
-  fZEMenergy = ezem;
-  fNDetSpecNLeft = detspnLeft;
-  fNDetSpecPLeft = detsppLeft;
-  fNDetSpecNRight = detspnRight;
-  fNDetSpecPRight = detsppRight;
-  fNTrueSpecN = trspn;
-  fNTrueSpecP = trspp;
-  fNTrueSpec = trsp;
-  fNPart     = part;
-  fImpPar    = b;
   
 }
 
 //______________________________________________________________________________
+AliZDCReco::AliZDCReco(const AliZDCReco &oldreco) :
+
+  TObject()
+{
+  // Copy constructor
+
+  fZN1energy = oldreco.GetZN1energy();
+  fZP1energy = oldreco.GetZP1energy();            
+  fZDC1energy = oldreco.GetZDC1energy();         
+  fZN2energy = oldreco.GetZN2energy();    
+  fZP2energy = oldreco.GetZP2energy();            
+  fZDC2energy = oldreco.GetZDC2energy();         
+  fZEMenergy = oldreco.GetZEMenergy();    
+  fNDetSpecNLeft = oldreco.GetNDetSpecNLeft(); 
+  fNDetSpecPLeft = oldreco.GetNDetSpecPLeft(); 
+  fNDetSpecNRight = oldreco.GetNDetSpecNRight();       
+  fNDetSpecPRight = oldreco.GetNDetSpecPRight();       
+  fNTrueSpecN = oldreco.GetNTrueSpecN();         
+  fNTrueSpecP = oldreco.GetNTrueSpecP();         
+  fNTrueSpec = oldreco.GetNTrueSpec();   
+  fNPart = oldreco.GetNPart();                  
+  fImpPar = oldreco.GetImpPar();                        
+}
+
+//______________________________________________________________________________
 void AliZDCReco::Print(Option_t *) const {
   //
   // Printing Reconstruction Parameters
index 59978d2..a258aff 100644 (file)
 class AliZDCReco : public TObject {
 
 public:
-  AliZDCReco() {}
+  AliZDCReco();
   AliZDCReco(Float_t ezn1, Float_t ezp1, Float_t ezdc1, Float_t ezem, 
             Float_t ezn2, Float_t ezp2, Float_t ezdc2, Int_t detspnLeft, 
              Int_t detsppLeft, Int_t detspnRight, Int_t detsppRight, 
             Int_t trspn, Int_t trspp, Int_t trsp, Int_t part, Float_t b);
-  AliZDCReco(AliZDCReco* oldreco) {*this=*oldreco;}
+  AliZDCReco(const AliZDCReco &oldreco);
   virtual ~AliZDCReco() {}
 
   // Getters 
index 5c0c578..86a4a52 100644 (file)
@@ -38,64 +38,34 @@ ClassImp(AliZDCReconstructor)
 
 
 //_____________________________________________________________________________
-AliZDCReconstructor:: AliZDCReconstructor()
-{
-  // **** Default constructor
-  
-  //  ---      Number of generated spectator nucleons and impact parameter
-  // --------------------------------------------------------------------------------------------------
-  // [1] ### Results from a new production  -> 0<b<18 fm (Apr 2002)
-  // Fit results for neutrons (Nspectator n true vs. EZN)
-  fZNCen = new TF1("fZNCen",
-      "(-2.287920+sqrt(2.287920*2.287920-4*(-0.007629)*(11.921710-x)))/(2*(-0.007629))",0.,164.);
-  fZNPer = new TF1("fZNPer",
-      "(-37.812280-sqrt(37.812280*37.812280-4*(-0.190932)*(-1709.249672-x)))/(2*(-0.190932))",0.,164.);
-  // Fit results for protons (Nspectator p true vs. EZP)
-  fZPCen = new TF1("fZPCen",
-       "(-1.321353+sqrt(1.321353*1.321353-4*(-0.007283)*(3.550697-x)))/(2*(-0.007283))",0.,60.);
-  fZPPer = new TF1("fZPPer",
-      "(-42.643308-sqrt(42.643308*42.643308-4*(-0.310786)*(-1402.945615-x)))/(2*(-0.310786))",0.,60.);
-  // Fit results for total number of spectators (Nspectators true vs. EZDC)
-  fZDCCen = new TF1("fZDCCen",
-      "(-1.934991+sqrt(1.934991*1.934991-4*(-0.004080)*(15.111124-x)))/(2*(-0.004080))",0.,225.);
-  fZDCPer = new TF1("fZDCPer",
-      "(-34.380639-sqrt(34.380639*34.380639-4*(-0.104251)*(-2612.189017-x)))/(2*(-0.104251))",0.,225.);
-  // --------------------------------------------------------------------------------------------------
-  // Fit results for b (b vs. EZDC)
-  // [2] ### Results from a new production  -> 0<b<18 fm (Apr 2002)
-  fbCen = new TF1("fbCen","-0.056923+0.079703*x-0.0004301*x*x+0.000001366*x*x*x",0.,220.);
-  fbPer = new TF1("fbPer","17.943998-0.046846*x+0.000074*x*x",0.,220.);
-  // --------------------------------------------------------------------------------------------------
-  // Evaluating Nspectators and b from ZEM energy
-  // [2] ### Results from a new production  -> 0<b<18 fm (Apr 2002)
-  fZEMn  = new TF1("fZEMn","126.2-0.05399*x+0.000005679*x*x",0.,4000.);
-  fZEMp  = new TF1("fZEMp","82.49-0.03611*x+0.00000385*x*x",0.,4000.);
-  fZEMsp = new TF1("fZEMsp","208.7-0.09006*x+0.000009526*x*x",0.,4000.);
-  fZEMb  = new TF1("fZEMb","16.06-0.01633*x+1.44e-5*x*x-6.778e-9*x*x*x+1.438e-12*x*x*x*x-1.112e-16*x*x*x*x*x",0.,4000.);
-  
-  // Get calibration data
-  fCalibData = GetCalibData(); 
-}
+AliZDCReconstructor:: AliZDCReconstructor() :
+
+  fZNCen (new TF1("fZNCen", 
+       "(-2.287920+sqrt(2.287920*2.287920-4*(-0.007629)*(11.921710-x)))/(2*(-0.007629))",0.,164.)),
+  fZNPer (new TF1("fZNPer",
+      "(-37.812280-sqrt(37.812280*37.812280-4*(-0.190932)*(-1709.249672-x)))/(2*(-0.190932))",0.,164.)),
+  fZPCen (new TF1("fZPCen",
+       "(-1.321353+sqrt(1.321353*1.321353-4*(-0.007283)*(3.550697-x)))/(2*(-0.007283))",0.,60.)),
+  fZPPer (new TF1("fZPPer",
+      "(-42.643308-sqrt(42.643308*42.643308-4*(-0.310786)*(-1402.945615-x)))/(2*(-0.310786))",0.,60.)),
+  fZDCCen (new TF1("fZDCCen",
+      "(-1.934991+sqrt(1.934991*1.934991-4*(-0.004080)*(15.111124-x)))/(2*(-0.004080))",0.,225.)),
+  fZDCPer (new TF1("fZDCPer",
+      "(-34.380639-sqrt(34.380639*34.380639-4*(-0.104251)*(-2612.189017-x)))/(2*(-0.104251))",0.,225.)),
+  fbCen (new TF1("fbCen","-0.056923+0.079703*x-0.0004301*x*x+0.000001366*x*x*x",0.,220.)),
+  fbPer (new TF1("fbPer","17.943998-0.046846*x+0.000074*x*x",0.,220.)),
+  fZEMn (new TF1("fZEMn","126.2-0.05399*x+0.000005679*x*x",0.,4000.)),
+  fZEMp (new TF1("fZEMp","82.49-0.03611*x+0.00000385*x*x",0.,4000.)),
+  fZEMsp (new TF1("fZEMsp","208.7-0.09006*x+0.000009526*x*x",0.,4000.)),
+  fZEMb (new TF1("fZEMb",
+       "16.06-0.01633*x+1.44e-5*x*x-6.778e-9*x*x*x+1.438e-12*x*x*x*x-1.112e-16*x*x*x*x*x",0.,4000.)),
+  fCalibData(GetCalibData())
 
-//_____________________________________________________________________________
-AliZDCReconstructor::AliZDCReconstructor(const AliZDCReconstructor& 
-                                         reconstructor):
-  AliReconstructor(reconstructor)
 {
-// copy constructor
+  // **** Default constructor
 
-  Fatal("AliZDCReconstructor", "copy constructor not implemented");
 }
 
-//_____________________________________________________________________________
-AliZDCReconstructor& AliZDCReconstructor::operator = 
-  (const AliZDCReconstructor& /*reconstructor*/)
-{
-// assignment operator
-
-  Fatal("operator =", "assignment operator not implemented");
-  return *this;
-}
 
 //_____________________________________________________________________________
 AliZDCReconstructor::~AliZDCReconstructor()
@@ -370,7 +340,7 @@ void AliZDCReconstructor::FillESD(AliRunLoader* runLoader,
 //_____________________________________________________________________________
 AliCDBStorage* AliZDCReconstructor::SetStorage(const char *uri) 
 {
-  //printf("\n\t AliZDCReconstructor::SetStorage \n");
+  // Setting the storage
 
   Bool_t deleteManager = kFALSE;
   
index 026ac88..8f478a9 100644 (file)
@@ -24,27 +24,27 @@ public:
   AliZDCReconstructor();
   virtual ~AliZDCReconstructor();
 
-  virtual void   Reconstruct(AliRunLoader* runLoader) const;
-  virtual void   Reconstruct(AliRunLoader* runLoader,
-                 AliRawReader* rawReader) const;
-  virtual void   Reconstruct(TTree* digitsTree, TTree* clustersTree) const 
-                 {AliReconstructor::Reconstruct(digitsTree,clustersTree);}
-  virtual void   Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const 
-                 {AliReconstructor::Reconstruct(rawReader,clustersTree);}
-  virtual void   FillESD(AliRunLoader* runLoader, AliESD* esd) const;
-  virtual void   FillESD(TTree* digitsTree, TTree* clustersTree, AliESD* esd) const 
-                 {AliReconstructor::FillESD(digitsTree,clustersTree,esd);}
-  virtual void   FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESD* esd) const 
-                 {AliReconstructor::FillESD(rawReader,clustersTree,esd);}
-  virtual void   FillESD(AliRunLoader* runLoader, AliRawReader* rawReader, AliESD* esd) const 
+  virtual void Reconstruct(AliRunLoader* runLoader) const;
+  virtual void Reconstruct(AliRunLoader* runLoader,
+               AliRawReader* rawReader) const;
+  virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const 
+               {AliReconstructor::Reconstruct(digitsTree,clustersTree);}
+  virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const 
+               {AliReconstructor::Reconstruct(rawReader,clustersTree);}
+  virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
+  virtual void FillESD(TTree* digitsTree, TTree* clustersTree, AliESD* esd) const 
+               {AliReconstructor::FillESD(digitsTree,clustersTree,esd);}
+  virtual void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESD* esd) const 
+               {AliReconstructor::FillESD(rawReader,clustersTree,esd);}
+  virtual void FillESD(AliRunLoader* runLoader, AliRawReader* rawReader, AliESD* esd) const 
                  {AliReconstructor::FillESD(runLoader,rawReader,esd);}
   
   AliCDBStorage   *SetStorage(const char* uri);
   AliZDCCalibData *GetCalibData() const; 
 
 private:
-  AliZDCReconstructor(const AliZDCReconstructor& reconstructor);
-  AliZDCReconstructor& operator = (const AliZDCReconstructor& reconstructor);
+  AliZDCReconstructor(const AliZDCReconstructor&);
+  AliZDCReconstructor& operator =(const AliZDCReconstructor&);
 
   void   ReconstructEvent(AliLoader* loader, Float_t zn1corr, Float_t zp1corr, Float_t zemcorr,
                Float_t zn2corr, Float_t zp2corr) const;
index a556c24..204bc1b 100644 (file)
@@ -9,7 +9,7 @@
 #pragma link off all functions;
  
 #pragma link C++ class  AliZDC+;
-#pragma link C++ class  AliZDCv1+;
+//#pragma link C++ class  AliZDCv1+;
 #pragma link C++ class  AliZDCv2+;
 
 #pragma link C++ class  AliZDCHit+;
index b2a8356..771352e 100644 (file)
@@ -1,7 +1,7 @@
 #-*- Mode: Makefile -*-
 # $Id$
 
-SRCS= AliZDC.cxx AliZDCv1.cxx AliZDCv2.cxx \
+SRCS= AliZDC.cxx AliZDCv2.cxx \
       AliZDCHit.cxx AliZDCSDigit.cxx AliZDCFragment.cxx AliZDCDigitizer.cxx \
       AliGenZDC.cxx AliZDCTrigger.cxx 
 #AliZDCMergedHit.cxx AliZDCMerger.cxx