Use vectors in THcHelicityScaler to avoid memory leaks

src/THcHelicityScaler.cxx

@@ -51,11 +51,10 @@ static const UInt_t MAXCHAN   = 32;
 static const UInt_t defaultDT = 4;
 
 THcHelicityScaler::THcHelicityScaler(const char *name, const char* description)
-  : THaEvtTypeHandler(name,description),
+  : THaEvtTypeHandler(name, description),
     fBankID(9801),
     fUseFirstEvent(kTRUE),
-    fDelayedType(-1),
-    fBCM_Gain(0), fBCM_Offset(0)
+    fDelayedType(-1)
 {
   fROC=-1;
   fNScalerChannels = 32;
@@ -72,9 +71,6 @@ THcHelicityScaler::THcHelicityScaler(const char *name, const char* description)
 
 THcHelicityScaler::~THcHelicityScaler()
 {
-  delete [] fBCM_Gain;
-  delete [] fBCM_Offset;
-
   for( vector<UInt_t*>::iterator it = fDelayedEvents.begin();
        it != fDelayedEvents.end(); ++it )
     delete [] *it;
@@ -180,11 +176,11 @@ Int_t THcHelicityScaler::ReadDatabase(const TDatime& date )
   };
   gHcParms->LoadParmValues((DBRequest*)&list, prefix);
   if(fNumBCMs > 0) {
-    fBCM_Gain = new Double_t[fNumBCMs];
-    fBCM_Offset = new Double_t[fNumBCMs];
+    fBCM_Gain.resize(fNumBCMs);
+    fBCM_Offset.resize(fNumBCMs);
     DBRequest list2[]={
-      {"BCM_Gain",      fBCM_Gain,         kDouble, (UInt_t) fNumBCMs},
-      {"BCM_Offset",     fBCM_Offset,       kDouble,(UInt_t) fNumBCMs},
+      {"BCM_Gain",       &fBCM_Gain[0],		kDouble, 	(UInt_t) fNumBCMs},
+      {"BCM_Offset",     &fBCM_Offset[0],       kDouble,	(UInt_t) fNumBCMs},
       {0}
     };
     gHcParms->LoadParmValues((DBRequest*)&list2, prefix);
@@ -470,11 +466,11 @@ THaAnalysisObject::EStatus THcHelicityScaler::Init(const TDatime& date)
   fRingSeed_actual = 0;
   fNBits = 0;
   fNTriggersPlus = fNTriggersMinus = 0;
-  fHScalers[0] = new Double_t[fNScalerChannels];
-  fHScalers[1] = new Double_t[fNScalerChannels];
-  fScalerSums = new Double_t[fNScalerChannels];
-  fAsymmetry = new Double_t[fNScalerChannels];
-  fAsymmetryError = new Double_t[fNScalerChannels];
+  fHScalers[0].resize(fNScalerChannels);
+  fHScalers[1].resize(fNScalerChannels);
+  fScalerSums.resize(fNScalerChannels);
+  fAsymmetry.resize(fNScalerChannels);
+  fAsymmetryError.resize(fNScalerChannels);
   for(Int_t i=0;i<fNScalerChannels;i++) {
     fHScalers[0][i] = 0.0;
     fHScalers[1][i] = 0.0;
@@ -483,8 +479,8 @@ THaAnalysisObject::EStatus THcHelicityScaler::Init(const TDatime& date)
     fAsymmetryError[0] = 0.0;
   }
 
-  fCharge = new Double_t[fNumBCMs];
-  fChargeAsymmetry = new Double_t[fNumBCMs];
+  fCharge.resize(fNumBCMs);
+  fChargeAsymmetry.resize(fNumBCMs);
 
   fTime = fTimeAsymmetry = 0;
   fTriggerAsymmetry = 0.0;
@@ -500,15 +496,15 @@ void THcHelicityScaler::MakeParms()
      Put Various helicity scaler results in gHcParms so they can be included in results.
   */
   gHcParms->Define(Form("g%s_hscaler_plus[%d]",fName.Data(),fNScalerChannels),
-                   "Plus Helcity Scalers",*(fHScalers[0]));
+                   "Plus Helcity Scalers", fHScalers[0][0]);
   gHcParms->Define(Form("g%s_hscaler_minus[%d]",fName.Data(),fNScalerChannels),
-                   "Minus Helcity Scalers",*(fHScalers[1]));
+                   "Minus Helcity Scalers", fHScalers[1][0]);
   gHcParms->Define(Form("g%s_hscaler_sum[%d]",fName.Data(),fNScalerChannels),
-                   "Helcity Scalers Sum",*fScalerSums);
+                   "Helcity Scalers Sum", fScalerSums[0]);
   gHcParms->Define(Form("g%s_hscaler_asy[%d]",fName.Data(),fNScalerChannels),
-                   "Helicity Scaler Asymmetry[%d]",*fAsymmetry);
+                   "Helicity Scaler Asymmetry[%d]", fAsymmetry[0]);
   gHcParms->Define(Form("g%s_hscaler_asyerr[%d]",fName.Data(),fNScalerChannels),
-                   "Helicity Scaler Asymmetry Error[%d]",*fAsymmetryError);
+                   "Helicity Scaler Asymmetry Error[%d]", fAsymmetryError[0]);
   gHcParms->Define(Form("g%s_hscaler_triggers",fName.Data()),
                    "Total Helicity Scaler Triggers",fNTriggers);
   gHcParms->Define(Form("g%s_hscaler_triggers_plus",fName.Data()),
@@ -516,9 +512,9 @@ void THcHelicityScaler::MakeParms()
   gHcParms->Define(Form("g%s_hscaler_triggers_minus",fName.Data()),
                    "Negative Helicity Scaler Triggers",fNTriggersMinus);
   gHcParms->Define(Form("g%s_hscaler_charge[%d]",fName.Data(),fNumBCMs),
-                   "Helicity Gated Charge",*fCharge);
+                   "Helicity Gated Charge", fCharge[0]);
   gHcParms->Define(Form("g%s_hscaler_charge_asy[%d]",fName.Data(),fNumBCMs),
-                   "Helicity Gated Charge Asymmetry",*fChargeAsymmetry);
+                   "Helicity Gated Charge Asymmetry", fChargeAsymmetry[0]);
   gHcParms->Define(Form("g%s_hscaler_time",fName.Data()),
                    "Helicity Gated Time (sec)",fTime);
   gHcParms->Define(Form("g%s_hscaler_time_asy",fName.Data()),

src/THcHelicityScaler.h

@@ -69,13 +69,10 @@ private:
 
   Int_t fNTriggersPlus;
   Int_t fNTriggersMinus;
-  Double_t* fHScalers[2];
+  std::vector<Double_t> fHScalers[2];
   Int_t fGateCount[2];
-  Double_t *fScalerSums;
-  Double_t *fAsymmetry;
-  Double_t *fAsymmetryError;
-  Double_t *fCharge;
-  Double_t *fChargeAsymmetry;
+  std::vector<Double_t> fScalerSums, fAsymmetry, fAsymmetryError;
+  std::vector<Double_t> fCharge, fChargeAsymmetry;
   Double_t fTime;
   Double_t fTimeAsymmetry;
   Double_t fTriggerAsymmetry;
@@ -85,8 +82,7 @@ private:
   Int_t fNScalerChannels;	// Number of scaler channels/event
 
   Int_t fNumBCMs;
-  Double_t *fBCM_Gain;
-  Double_t *fBCM_Offset;
+  std::vector<Double_t> fBCM_Gain, fBCM_Offset;
   std::vector <std::string> fBCM_Name;
 
   THcHelicityScaler(const THcHelicityScaler& fh);