From: gconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Date: Sun, 20 Nov 2011 16:45:06 +0000 (+0000)
Subject: coverity
X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=0bd264d520369187da0dfe07db00007d2265c332

coverity
---

diff --git a/EMCAL/AliEMCALDigit.cxx b/EMCAL/AliEMCALDigit.cxx
index 55723d157da..43be36c00ea 100644
--- a/EMCAL/AliEMCALDigit.cxx
+++ b/EMCAL/AliEMCALDigit.cxx
@@ -401,6 +401,74 @@ void AliEMCALDigit::ShiftPrimary(Int_t shift){
   for(index =0; index <fNiparent; index++){
     fIparent[index] = fIparent[index] + shift * 10000000 ;}
 }
+
+
+//____________________________________________________________________________
+AliEMCALDigit& AliEMCALDigit::operator= (const AliEMCALDigit &digit)
+{
+  // assignment operator
+  
+  if(&digit == this) return *this;
+  
+  fAmpFloat    = digit.fAmpFloat;	
+  fNSamples    = digit.fNSamples;
+  fNSamplesHG  = digit.fNSamplesHG;
+  fNprimary    = digit.fNprimary;
+  fNMaxPrimary = digit.fNMaxPrimary;
+  fNiparent    = digit.fNiparent;
+  fNMaxiparent = digit.fNMaxiparent;
+  fMaxIter     = digit.fMaxIter;
+  fTime        = digit.fTime;
+  fTimeR       = digit.fTimeR; 
+  fChi2        = digit.fChi2; 
+  fNDF         = digit.fNDF;
+  fDigitType   = digit.fDigitType;
+  fAmpCalib    = digit.fAmpCalib;
+  fAmp         = digit.fAmp ;
+  fId          = digit.fId;
+  fIndexInList = digit.fIndexInList ; 
+  
+  // data members  
+  if (fSamples )   delete [] fSamples ;   fSamples   = NULL ;
+  if (fSamplesHG ) delete [] fSamplesHG ; fSamplesHG = NULL ;
+  if (fPrimary  )  delete [] fPrimary ;   fPrimary   = NULL ;
+  if (fDEPrimary)  delete [] fDEPrimary ; fDEPrimary = NULL ;
+  if (fIparent )   delete [] fIparent ;   fIparent   = NULL ;
+  if (fDEParent)   delete [] fDEParent ;  fDEParent  = NULL ;
+  
+  if (fNSamples){
+    fSamples     = new Int_t[fNSamples]; 
+    for (Int_t i=0; i < digit.fNSamples; i++) fSamples[i] = digit.fSamples[i];
+  }
+  
+  if (fNSamplesHG){
+    fSamplesHG   = new Int_t[fNSamplesHG]; 
+    for (Int_t i=0; i < digit.fNSamplesHG; i++) fSamplesHG[i] = digit.fSamplesHG[i];
+  }
+  
+  
+  if (fNMaxPrimary){
+    fPrimary   = new Int_t  [fNMaxPrimary] ;  
+    fDEPrimary = new Float_t[fNMaxPrimary] ;
+    for ( Int_t i = 0; i < fNMaxPrimary ; i++) {
+      fPrimary[i]   = digit.fPrimary[i] ;
+      fDEPrimary[i] = digit.fDEPrimary[i] ;
+    }
+  }
+  
+  if (fNMaxiparent){
+    fIparent  = new Int_t  [fNMaxiparent] ;
+    fDEParent = new Float_t[fNMaxiparent] ;
+    for (Int_t j = 0; j< fNMaxiparent ; j++) {
+      fIparent[j]  = digit.fIparent[j] ;
+      fDEParent[j] = digit.fDEParent[j] ;
+    }
+  }  
+  
+  return *this;
+  
+}  
+
 //____________________________________________________________________________
 Bool_t AliEMCALDigit::operator==(AliEMCALDigit const & digit) const 
 {
diff --git a/EMCAL/AliEMCALDigit.h b/EMCAL/AliEMCALDigit.h
index 918d54c08f5..10289ddb3a0 100644
--- a/EMCAL/AliEMCALDigit.h
+++ b/EMCAL/AliEMCALDigit.h
@@ -38,7 +38,8 @@ class AliEMCALDigit : public AliDigitNew {
   Bool_t operator==(const AliEMCALDigit &rValue) const;
   AliEMCALDigit operator+(const AliEMCALDigit &rValue) ;
   AliEMCALDigit operator*(Float_t factor) ; 
-  const AliEMCALDigit& operator = (const AliEMCALDigit &) {return *this;}
+  AliEMCALDigit& operator = (const AliEMCALDigit & digit) ;
+  
   enum  digitType{kUnknown=-1, kHG=0, kLG=1, kLGnoHG=2, kTrigger=3, kEmbedded = 4};
 
   void     Clear(const Option_t*) ;	
diff --git a/EMCAL/AliEMCALDigitizer.cxx b/EMCAL/AliEMCALDigitizer.cxx
index 86a775a009f..f0eca4c281b 100644
--- a/EMCAL/AliEMCALDigitizer.cxx
+++ b/EMCAL/AliEMCALDigitizer.cxx
@@ -779,8 +779,10 @@ void AliEMCALDigitizer::Digitize(Option_t *option)
   
   if(strstr(option,"tim")){
     gBenchmark->Stop("EMCALDigitizer");
-    AliInfo(Form("Digitize: took %f seconds for Digitizing %f seconds per event", 
-	 gBenchmark->GetCpuTime("EMCALDigitizer"), gBenchmark->GetCpuTime("EMCALDigitizer")/nEvents )) ;
+    Float_t cputime   = gBenchmark->GetCpuTime("EMCALDigitizer");
+    Float_t avcputime = cputime;
+    if(nEvents==0) avcputime = 0 ;
+    AliInfo(Form("Digitize: took %f seconds for Digitizing %f seconds per event", cputime, avcputime)) ;
   } 
 }
 
diff --git a/EMCAL/AliEMCALRecPoint.cxx b/EMCAL/AliEMCALRecPoint.cxx
index aff07003d58..351be08435c 100644
--- a/EMCAL/AliEMCALRecPoint.cxx
+++ b/EMCAL/AliEMCALRecPoint.cxx
@@ -161,36 +161,59 @@ AliEMCALRecPoint& AliEMCALRecPoint::operator= (const AliEMCALRecPoint &rp)
 
   if(&rp == this) return *this;
 
-  fGeomPtr = rp.fGeomPtr;
-  fAmp = rp.fAmp;
+  fGeomPtr     = rp.fGeomPtr;
+  fAmp         = rp.fAmp;
   fIndexInList = rp.fIndexInList;
-  fGlobPos = rp.fGlobPos;
-  fLocPos  = rp.fLocPos;
-  fMaxDigit = rp.fMaxDigit;
-  fMulDigit = rp.fMulDigit;
-  fMaxTrack = rp.fMaxTrack;
-  fMulTrack = rp.fMaxTrack;
+  fGlobPos     = rp.fGlobPos;
+  fLocPos      = rp.fLocPos;
+  fMaxDigit    = rp.fMaxDigit;
+  fMulDigit    = rp.fMulDigit;
+  fMaxTrack    = rp.fMaxTrack;
+  fMulTrack    = rp.fMulTrack;
+  
+  if(fDigitsList) delete [] fDigitsList;
+  fDigitsList = new Int_t[rp.fMaxDigit];
+  if(fTracksList) delete [] fTracksList;
+  fTracksList = new Int_t[rp.fMaxTrack];
   for(Int_t i = 0; i<fMaxDigit; i++) fDigitsList[i] = rp.fDigitsList[i];
   for(Int_t i = 0; i<fMaxTrack; i++) fTracksList[i] = rp.fTracksList[i];
+  
   fClusterType = rp.fClusterType;
   fCoreEnergy  = rp.fCoreEnergy; 
   fDispersion  = rp.fDispersion;
+  
+  
+  if(fEnergyList) delete [] fEnergyList;
+  fEnergyList = new Float_t[rp.fMaxDigit];
+  if(fAbsIdList) delete [] fAbsIdList;
+  fAbsIdList = new Int_t[rp.fMaxDigit];  
   for(Int_t i = 0; i<fMaxDigit; i++) {
     fEnergyList[i] = rp.fEnergyList[i];
     fAbsIdList[i]  = rp.fAbsIdList[i];
   }
-  fTime = rp.fTime;
-  fNExMax = rp.fNExMax;
+  
+  fTime       = rp.fTime;
+  fNExMax     = rp.fNExMax;
   fCoreRadius = rp.fCoreRadius;
+  
+  if(fDETracksList) delete [] fDETracksList;
+  fDETracksList = new Float_t[rp.fMaxTrack];
   for(Int_t i = 0; i < fMaxTrack; i++) fDETracksList[i] = rp.fDETracksList[i];
+
   fMulParent = rp.fMulParent;
   fMaxParent = rp.fMaxParent;
+  
+  if(fParentsList) delete [] fParentsList;
+  fParentsList = new Int_t[rp.fMaxParent];
+  if(fDEParentsList) delete [] fDEParentsList;
+  fDEParentsList = new Float_t[rp.fMaxParent];
   for(Int_t i = 0; i < fMaxParent; i++) {
-    fParentsList[i] = rp.fParentsList[i]; 
+    fParentsList[i]   = rp.fParentsList[i]; 
     fDEParentsList[i] = rp.fDEParentsList[i];
   }
+  
   fSuperModuleNumber = rp.fSuperModuleNumber;
-  fDigitIndMax = rp.fDigitIndMax;
+  fDigitIndMax       = rp.fDigitIndMax;
 
   fLambda[0] = rp.fLambda[0];
   fLambda[1] = rp.fLambda[1];
diff --git a/EMCAL/AliEMCALTrigger.cxx b/EMCAL/AliEMCALTrigger.cxx
index 78da6ac95fe..68bd95b2bb6 100644
--- a/EMCAL/AliEMCALTrigger.cxx
+++ b/EMCAL/AliEMCALTrigger.cxx
@@ -127,58 +127,6 @@ AliEMCALTrigger::AliEMCALTrigger()
    //Print("") ; 
 }
 
-
-
-//____________________________________________________________________________
-AliEMCALTrigger::AliEMCALTrigger(const AliEMCALTrigger & trig) 
-  : AliTriggerDetector(trig),
-    fGeom(trig.fGeom),
-    f2x2MaxAmp(trig.f2x2MaxAmp), 
-    f2x2ModulePhi(trig.f2x2ModulePhi),  
-    f2x2ModuleEta(trig.f2x2ModuleEta),
-    f2x2SM(trig.f2x2SM),
-    fnxnMaxAmp(trig.fnxnMaxAmp), 
-    fnxnModulePhi(trig.fnxnModulePhi),  
-    fnxnModuleEta(trig.fnxnModuleEta),
-    fnxnSM(trig.fnxnSM),
-    fADCValuesHighnxn(trig.fADCValuesHighnxn),
-    fADCValuesLownxn(trig.fADCValuesLownxn),
-    fADCValuesHigh2x2(trig.fADCValuesHigh2x2),
-    fADCValuesLow2x2(trig.fADCValuesLow2x2),
-    fDigitsList(trig.fDigitsList),
-    fL0Threshold(trig.fL0Threshold),
-    fL1GammaLowPtThreshold(trig.fL1GammaLowPtThreshold),
-    fL1GammaMediumPtThreshold(trig.fL1GammaMediumPtThreshold), 
-    fL1GammaHighPtThreshold(trig.fL1GammaHighPtThreshold),
-    fPatchSize(trig.fPatchSize),
-    fIsolPatchSize(trig.fIsolPatchSize), 
-    f2x2AmpOutOfPatch(trig.f2x2AmpOutOfPatch), 
-    fnxnAmpOutOfPatch(trig.fnxnAmpOutOfPatch), 
-    f2x2AmpOutOfPatchThres(trig.f2x2AmpOutOfPatchThres),  
-    fnxnAmpOutOfPatchThres(trig.fnxnAmpOutOfPatchThres), 
-    fIs2x2Isol(trig.fIs2x2Isol),
-    fIsnxnIsol(trig.fIsnxnIsol),  
-    fSimulation(trig.fSimulation),
-    fIsolateInSuperModule(trig.fIsolateInSuperModule),
-    fTimeKey(trig.fTimeKey),
-    fAmpTrus(trig.fAmpTrus),
-    fTimeRtrus(trig.fTimeRtrus),
-    fAmpSMods(trig.fAmpSMods),
-    fTriggerPosition(trig.fTriggerPosition),
-    fTriggerAmplitudes(trig.fTriggerAmplitudes),
-    fNJetPatchPhi(trig.fNJetPatchPhi), 
-    fNJetPatchEta(trig.fNJetPatchEta), 
-    fNJetThreshold(trig.fNJetThreshold),
-    fL1JetThreshold(trig.fL1JetThreshold), 
-    fJetMaxAmp(trig.fJetMaxAmp),
-    fAmpJetMatrix(trig.fAmpJetMatrix),
-    fJetMatrixE(trig.fJetMatrixE),
-    fAmpJetMax(trig.fAmpJetMax),
-    fVZER0Mult(trig.fVZER0Mult)
-{
-  // cpy ctor
-}
-
 //____________________________________________________________________________
 AliEMCALTrigger::~AliEMCALTrigger() {
 	
diff --git a/EMCAL/AliEMCALTrigger.h b/EMCAL/AliEMCALTrigger.h
index 760e649081f..5bd7a37e52a 100644
--- a/EMCAL/AliEMCALTrigger.h
+++ b/EMCAL/AliEMCALTrigger.h
@@ -59,15 +59,12 @@ class AliEMCALTrigger : public AliTriggerDetector {
  public:   
 
   AliEMCALTrigger() ; //  ctor
-  AliEMCALTrigger(const AliEMCALTrigger & trig) ; // cpy ctor
   virtual ~AliEMCALTrigger(); //virtual dtor
 
 
   virtual void    CreateInputs(); //Define trigger inputs for Central Trigger Processor
   void            Print(const Option_t * opt ="") const ;  
   virtual void    Trigger();  //Make EMCAL trigger
-  //assignment operator for coding convention
-  const AliEMCALTrigger & operator = (const AliEMCALTrigger & ) {return *this;}
 
   //Getters
   Float_t  Get2x2MaxAmplitude()  const { return f2x2MaxAmp ; }
@@ -237,6 +234,9 @@ class AliEMCALTrigger : public AliTriggerDetector {
   // VZER0 
   Double_t  fVZER0Mult;              // multiplicity (V0A+V0c)
   
+  const AliEMCALTrigger & operator = (const AliEMCALTrigger & ) ;
+  AliEMCALTrigger(const AliEMCALTrigger & trig) ; // cpy ctor
+  
   ClassDef(AliEMCALTrigger, 2)
 } ;