diff --git a/.travis.yml b/.travis.yml
index 2de858187a848cb1f96509ad0c0c78c383074a21..92821955fdc8b1ce4ccb800944c8a11b676cc98f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -25,9 +25,10 @@ install:
   - python --version
   - scons --version
 script:
-  - make
   - scons
+  - mkdir build; cd build; cmake ..; make
 after_success:
+  - cd $TRAVIS_BUILD_DIR
   - pwd
   - ldd $HCANALYZER/hcana
   - $HCANALYZER/hcana --version
diff --git a/SConscript.py b/SConscript.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8f4ccd2eb1bcf9a15947594684d152be4f15c1c
--- /dev/null
+++ b/SConscript.py
@@ -0,0 +1,120 @@
+###### Hall C Software Main SConscript File #####
+###### Author:	Edward Brash (brash@jlab.org) June 2013
+
+import os
+import re
+import sys
+import subprocess
+import platform
+import time
+import SCons.Util
+Import ('pbaseenv')
+
+######## ROOT Dictionaries #########
+
+roothcdict = pbaseenv.subst('$HC_DIR')+'/HallCDict.C'
+roothcobj = pbaseenv.subst('$HC_SRC')+'/HallCDict.so'
+ 
+hcheadersbase = Glob('src/*.h',exclude=['src/THcGlobals.h','src/HallC_LinkDef.h'])
+
+cmd = "cat src/HallC_LinkDef.h_preamble > src/HallC_LinkDef.h"
+os.system(cmd)
+
+for hcheaderfile in hcheadersbase:
+    filename = '%s' % hcheaderfile
+    basefilename = filename.rsplit('.',1)
+    newbasefilename = basefilename[0].rsplit('/',1)
+    # Assume filenames beginning with Scaler are decoder classes
+    if newbasefilename[1] == 'hc_compiledata':
+        continue
+    if newbasefilename[1][:6] == 'Scaler' or newbasefilename[1] == "TIBlobModule":
+        cmd1 = "echo '#pragma link C++ class Decoder::%s+;' >> src/HallC_LinkDef.h" % newbasefilename[1]
+    else:
+        cmd1 = "echo '#pragma link C++ class %s+;' >> src/HallC_LinkDef.h" % newbasefilename[1]
+    os.system(cmd1)
+
+cmd = "cat src/HallC_LinkDef.h_postamble >> src/HallC_LinkDef.h"
+os.system(cmd)
+
+hcheaders = Glob('src/*.h',exclude=['src/HallC_LinkDef.h','src/hc_compiledata.h'])+Glob('src/HallC_LinkDef.h')
+
+pbaseenv.RootCint(roothcdict,hcheaders)
+pbaseenv.Clean(roothcdict,re.sub(r'\.C\Z','_rdict.pcm',roothcdict))
+pbaseenv.SharedObject(target = roothcobj, source = roothcdict)
+
+#######  write src/hc_compiledata.h header file ######
+
+if sys.version_info >= (2, 7):
+    try:
+        cmd = "git rev-parse HEAD 2>/dev/null"
+        gitrev = subprocess.check_output(cmd, shell=True).rstrip()
+    except:
+        gitrev = ''
+    try:
+        cmd = pbaseenv.subst('$CXX') + " --version 2>/dev/null | head -1"
+        cxxver = subprocess.check_output(cmd, shell=True).rstrip()
+    except:
+        cxxver = ''
+    # subprocess gives us byte string literals in Python 3, but we'd like
+    # Unicode strings
+    if sys.version_info >= (3, 0):
+        gitrev = gitrev.decode()
+        cxxver = cxxver.decode()
+else:
+    FNULL = open(os.devnull, 'w')
+    try:
+        gitrev = subprocess.Popen(['git', 'rev-parse', 'HEAD', '2>dev/null'],\
+                    stdout=subprocess.PIPE, stderr=FNULL).communicate()[0].rstrip()
+    except:
+        gitrev =''
+    try:
+        outp = subprocess.Popen([pbaseenv.subst('$CXX'), '--version'],\
+                                stdout=subprocess.PIPE, stderr=FNULL).communicate()[0]
+        lines = outp.splitlines()
+        cxxver = lines[0]
+    except:
+        cxxver = ''
+
+compiledata = 'src/hc_compiledata.h'
+f=open(compiledata,'w')
+f.write('#ifndef HCANA_COMPILEDATA_H\n')
+f.write('#define HCANA_COMPILEDATA_H\n')
+f.write('\n')
+f.write('#define HC_INCLUDEPATH "%s"\n' % (pbaseenv.subst('$HC_SRC')))
+f.write('#define HC_VERSION "%s"\n' % pbaseenv.subst('$HC_VERSION'))
+f.write('#define HC_DATE "%s"\n' % time.strftime("%b %d %Y"))
+f.write('#define HC_DATETIME "%s"\n' % time.strftime("%a %b %d %Y"))
+#f.write('#define HC_DATETIME "%s"\n' % time.strftime("%a %b %d %H:%M:%S %Z %Y"))
+f.write('#define HC_PLATFORM "%s"\n' % platform.platform())
+f.write('#define HC_BUILDNODE "%s"\n' % platform.node())
+f.write('#define HC_BUILDDIR "%s"\n' % os.getcwd())
+try:
+    builduser = pbaseenv['ENV']['LOGNAME']
+except:
+    builduser = ''
+f.write('#define HC_BUILDUSER "%s"\n' % builduser)
+f.write('#define HC_GITVERS "%s"\n' % gitrev[:7])
+f.write('#define HC_CXXVERS "%s"\n' % cxxver)
+f.write('#define HC_ROOTVERS "%s"\n' % pbaseenv.subst('$ROOTVERS'))
+f.write('#define HCANA_VERSION_CODE %s\n' % pbaseenv.subst('$VERCODE'))
+f.write('#define HCANA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))\n')
+f.write('\n')
+f.write('#endif\n')
+f.close()
+
+#######  Start of main SConscript ###########
+
+print ('LIBS = %s\n' % pbaseenv.subst('$LIBS'))
+
+# SCons seems to ignore $RPATH on macOS... sigh
+if pbaseenv['PLATFORM'] == 'darwin':
+    try:
+        for rp in pbaseenv['RPATH']:
+            pbaseenv.Append(LINKFLAGS = ['-Wl,-rpath,'+rp])
+    except KeyError:
+        pass
+
+analyzer = pbaseenv.Program(target = 'hcana', source = 'src/main.o')
+pbaseenv.Install('./bin',analyzer)
+pbaseenv.Alias('install',['./bin'])
+#pbaseenv.Clean(analyzer,)
diff --git a/SConstruct b/SConstruct
new file mode 100644
index 0000000000000000000000000000000000000000..d5651fe480d86023c153c110bbdeeefa785c5c79
--- /dev/null
+++ b/SConstruct
@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+###### Hall C Software Main SConstruct Build File #####
+###### Author:	Edward Brash (brash@jlab.org) June 2013
+
+import os
+import sys
+#import platform
+#import commands
+import SCons
+import subprocess
+
+####### Check SCons version ##################
+print('!!! Building the Hall C analyzer and libraries with SCons requires')
+print('!!! SCons version 2.5.0 or newer.')
+EnsureSConsVersion(2,5,0)
+
+baseenv = Environment(ENV = os.environ,tools=["default","rootcint"],toolpath=['podd/site_scons'])
+
+####### Hall A Build Environment #############
+#
+baseenv.Append(HEAD_DIR= Dir('.').abspath)
+baseenv.Append(HC_DIR= baseenv.subst('$HEAD_DIR'))
+baseenv.Append(HC_SRC= baseenv.subst('$HC_DIR')+'/src')
+baseenv.Append(HA_DIR= baseenv.subst('$HC_DIR')+'/podd')
+baseenv.Append(MAIN_DIR= baseenv.subst('$HEAD_DIR'))
+baseenv.Append(HA_Podd = os.path.join(baseenv.subst('$HA_DIR'),'Podd'))
+baseenv.Append(HA_DC = os.path.join(baseenv.subst('$HA_DIR'),'hana_decode'))
+baseenv.Append(MAJORVERSION = '0')
+baseenv.Append(MINORVERSION = '90')
+baseenv.Append(PATCH = '0')
+baseenv.Append(SOVERSION = baseenv.subst('$MAJORVERSION')+'.'+baseenv.subst('$MINORVERSION'))
+baseenv.Append(VERSION = baseenv.subst('$SOVERSION')+'.'+baseenv.subst('$PATCH'))
+baseenv.Append(EXTVERS = '')
+baseenv.Append(HC_VERSION = baseenv.subst('$VERSION')+baseenv.subst('$EXTVERS'))
+print ("Hall C Main Directory = %s" % baseenv.subst('$HC_DIR'))
+print ("Hall C Source Directory = %s" % baseenv.subst('$HC_SRC'))
+print ("Hall A Main Directory = %s" % baseenv.subst('$HA_DIR'))
+print ("Software Version = %s" % baseenv.subst('$VERSION'))
+ivercode = 65536*int(float(baseenv.subst('$SOVERSION')))+ 256*int(10*(float(baseenv.subst('$SOVERSION'))-int(float(baseenv.subst('$SOVERSION')))))+ int(float(baseenv.subst('$PATCH')))
+baseenv.Append(VERCODE = ivercode)
+baseenv.Append(CPPPATH = ['$HC_SRC','$HA_Podd','$HA_DC'])
+
+sys.path.insert(1,baseenv.subst('$HA_DIR'+'/site_scons'))
+import configure
+
+configure.FindROOT(baseenv)
+
+######## cppcheck ###########################
+
+proceed = "1" or "y" or "yes" or "Yes" or "Y"
+if baseenv.subst('$CPPCHECK')==proceed:
+    is_cppcheck = which('cppcheck')
+    print ("Path to cppcheck is %s\n" % is_cppcheck)
+
+    if(is_cppcheck == None):
+        print('!!! cppcheck not found on this system.  Check if cppcheck is installed and in your PATH.')
+        Exit(1)
+    else:
+        cppcheck_command = baseenv.Command('cppcheck_report.txt',[],"cppcheck --quiet --enable=all src/ 2> $TARGET")
+        baseenv.AlwaysBuild(cppcheck_command)
+
+######## Configure Section #######
+
+if not (baseenv.GetOption('clean') or baseenv.GetOption('help')):
+
+    configure.config(baseenv,ARGUMENTS)
+
+    conf = Configure(baseenv)
+    if not conf.CheckCXX():
+        print('!!! Your compiler and/or environment is not correctly configured.')
+        Exit(1)
+    # if not conf.CheckFunc('printf'):
+    #         print('!!! Your compiler and/or environment is not correctly configured.')
+    #         Exit(1)
+    if conf.CheckCXXHeader('sstream'):
+        conf.env.Append(CPPDEFINES = 'HAS_SSTREAM')
+    baseenv = conf.Finish()
+
+Export('baseenv')
+
+#print (baseenv.Dump())
+#print ('CXXFLAGS = ', baseenv['CXXFLAGS'])
+#print ('LINKFLAGS = ', baseenv['LINKFLAGS'])
+#print ('SHLINKFLAGS = ', baseenv['SHLINKFLAGS'])
+
+####### Start of main SConstruct ############
+
+hallclib = 'HallC'
+poddlib = 'Podd'
+dclib = 'dc'
+
+baseenv.Append(LIBPATH=['$HC_DIR','$HC_SRC','$HA_Podd','$HA_DC'])
+baseenv.Append(RPATH=['$HC_DIR','$HA_Podd','$HA_DC'])
+baseenv.Replace(SHLIBSUFFIX = '.so')
+baseenv.Replace(SOSUFFIX = baseenv.subst('$SHLIBSUFFIX'))
+#baseenv.Replace(SHLIBSUFFIX = '.so')
+baseenv.Append(SHLIBSUFFIX = '.'+baseenv.subst('$VERSION'))
+
+pbaseenv=baseenv.Clone()
+pbaseenv.Prepend(LIBS=[hallclib,poddlib,dclib])
+baseenv.Prepend(LIBS=[poddlib,dclib])
+Export('pbaseenv')
+
+if pbaseenv['CXX'] == 'g++':
+    gxxVersion = [int(i) for i in pbaseenv['CXXVERSION'].split('.')]
+    if (gxxVersion[0] < 4) or (gxxVersion[0] == 4 and gxxVersion[1] < 4):
+        print('Error: g++ version too old! Need at least g++ 4.4!')
+        Exit(1)
+
+##directorylist = ['./','src','podd','podd/src','podd/hana_decode']
+##SConscript('podd/SConstruct')
+
+if baseenv.GetOption('clean'):
+    subprocess.call(['echo', '!!!!!! Cleaning Podd Directory !!!!!! '])
+    podd_command_scons = "cd %s; scons -c" % baseenv.subst('$HA_DIR')
+else:
+    subprocess.call(['echo', '!!!!!! Building Podd !!!!!! '])
+    podd_command_scons = "cd %s; scons" % baseenv.subst('$HA_DIR')
+    if baseenv.GetOption('num_jobs'):
+        podd_command_scons += " -j%s" % (GetOption('num_jobs')) 
+    if baseenv.GetOption('silent'):
+        podd_command_scons += " -s"
+    for key,value in ARGLIST:
+        podd_command_scons += " %s=%s" % (key,value)
+
+print ("podd_command_scons = %s" % podd_command_scons)
+
+os.system(podd_command_scons)
+
+directorylist = ['./','src']
+SConscript(dirs = directorylist,name='SConscript.py',exports='baseenv')
+
+#######  End of SConstruct #########
+
+# Local Variables:
+# mode: python
+# End:
diff --git a/examples/output.def b/examples/output.def
index 67350e7f5822d8190db6bd866f7a3f1fd0803e99..27fa26669039adfd66108cf8d3542d2db8691628 100644
--- a/examples/output.def
+++ b/examples/output.def
@@ -10,7 +10,7 @@ block S.dc.*
 block S.hod.*
 block S.cal.*
 block g.evtyp
-block RB.*
+block B.*
 
 # TDC hits per paddle
 TH1F hpostdc1 'HMS s1x+ TDC hits' H.hod.1x.posTdcCounter 16 0.5 16.5
diff --git a/podd b/podd
index e58d6959ef72f188811ba485f53945dde13141bf..1b2c04ad6976a7157f5cba98a5ea26278bca19ed 160000
--- a/podd
+++ b/podd
@@ -1 +1 @@
-Subproject commit e58d6959ef72f188811ba485f53945dde13141bf
+Subproject commit 1b2c04ad6976a7157f5cba98a5ea26278bca19ed
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3233b4bd2c818504dde88da6b0b050d435388951..fd28e59a4ce3c39d12d3135c390bb9941fac3fd9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -75,7 +75,7 @@ endif()
 
 target_link_libraries(${LIBNAME}
   PUBLIC
-    Podd::HallA
+    Podd::Podd
     Podd::Decode
   )
 set_target_properties(${LIBNAME} PROPERTIES
diff --git a/src/THcAerogel.cxx b/src/THcAerogel.cxx
index 5da888e15e4d7dbfdd1c008f2b65d5afd023282c..5fd05c0f6f72b9b1a80cd59add97e267c9e7f6fa 100644
--- a/src/THcAerogel.cxx
+++ b/src/THcAerogel.cxx
@@ -36,51 +36,57 @@ using namespace std;
 //_____________________________________________________________________________
 THcAerogel::THcAerogel( const char* name, const char* description,
                         THaApparatus* apparatus ) :
-  hcana::ConfigLogging<THaNonTrackingDetector>(name,description,apparatus)
+  hcana::ConfigLogging<THaNonTrackingDetector>(name,description,apparatus),
+  fPresentP(0),
+  fAdcPosTimeWindowMin(0), fAdcPosTimeWindowMax(0), fAdcNegTimeWindowMin(0),
+  fAdcNegTimeWindowMax(0), fRegionValue(0), fPosGain(0), fNegGain(0),
+  frPosAdcPedRaw(0), frPosAdcPulseIntRaw(0), frPosAdcPulseAmpRaw(0),
+  frPosAdcPulseTimeRaw(0), frPosAdcPed(0), frPosAdcPulseInt(0),
+  frPosAdcPulseAmp(0), frPosAdcPulseTime(0), frNegAdcPedRaw(0),
+  frNegAdcPulseIntRaw(0), frNegAdcPulseAmpRaw(0), frNegAdcPulseTimeRaw(0),
+  frNegAdcPed(0), frNegAdcPulseInt(0), frNegAdcPulseAmp(0),
+  frNegAdcPulseTime(0), fPosAdcErrorFlag(0),
+  fNegAdcErrorFlag(0), fPosPedSum(0), fPosPedSum2(0), fPosPedLimit(0),
+  fPosPedCount(0), fNegPedSum(0), fNegPedSum2(0), fNegPedLimit(0), fNegPedCount(0),
+  fA_Pos(0), fA_Neg(0), fA_Pos_p(0), fA_Neg_p(0), fT_Pos(0), fT_Neg(0),
+  fPosPed(0), fPosSig(0), fPosThresh(0), fNegPed(0), fNegSig(0),
+  fNegThresh(0), fPosPedMean(0), fNegPedMean(0),
+  fPosTDCHits(0), fNegTDCHits(0), fPosADCHits(0), fNegADCHits(0)
 {
-
-  InitArrays();
-
 }
 
 //_____________________________________________________________________________
 THcAerogel::THcAerogel( ) :
-  hcana::ConfigLogging<THaNonTrackingDetector>()
+  hcana::ConfigLogging<THaNonTrackingDetector>(),
+  fAdcPosTimeWindowMin(0), fAdcPosTimeWindowMax(0), fAdcNegTimeWindowMin(0),
+  fAdcNegTimeWindowMax(0), fRegionValue(0), fPosGain(0), fNegGain(0),
+  frPosAdcPedRaw(0), frPosAdcPulseIntRaw(0), frPosAdcPulseAmpRaw(0),
+  frPosAdcPulseTimeRaw(0), frPosAdcPed(0), frPosAdcPulseInt(0),
+  frPosAdcPulseAmp(0), frPosAdcPulseTime(0), frNegAdcPedRaw(0),
+  frNegAdcPulseIntRaw(0), frNegAdcPulseAmpRaw(0), frNegAdcPulseTimeRaw(0),
+  frNegAdcPed(0), frNegAdcPulseInt(0), frNegAdcPulseAmp(0),
+  frNegAdcPulseTime(0), fPosAdcErrorFlag(0),
+  fNegAdcErrorFlag(0), fPosPedSum(0), fPosPedSum2(0), fPosPedLimit(0),
+  fPosPedCount(0), fNegPedSum(0), fNegPedSum2(0), fNegPedLimit(0), fNegPedCount(0),
+  fA_Pos(0), fA_Neg(0), fA_Pos_p(0), fA_Neg_p(0), fT_Pos(0), fT_Neg(0),
+  fPosPed(0), fPosSig(0), fPosThresh(0), fNegPed(0), fNegSig(0),
+  fNegThresh(0), fPosPedMean(0), fNegPedMean(0),
+  fPosTDCHits(0), fNegTDCHits(0), fPosADCHits(0), fNegADCHits(0)
 {
-  // Constructor
-  frPosAdcPedRaw       = NULL;
-  frPosAdcPulseIntRaw  = NULL;
-  frPosAdcPulseAmpRaw  = NULL;
-  frPosAdcPulseTimeRaw = NULL;
-  frPosAdcPed          = NULL;
-  frPosAdcPulseInt     = NULL;
-  frPosAdcPulseAmp     = NULL;
-  frPosAdcPulseTime    = NULL;
-  frNegAdcPedRaw       = NULL;
-  frNegAdcPulseIntRaw  = NULL;
-  frNegAdcPulseAmpRaw  = NULL;
-  frNegAdcPulseTimeRaw = NULL;
-  frNegAdcPed          = NULL;
-  frNegAdcPulseInt     = NULL;
-  frNegAdcPulseAmp     = NULL;
-  frNegAdcPulseTime    = NULL;
-  fPosAdcErrorFlag     = NULL;
-  fNegAdcErrorFlag     = NULL;
-
-  // 6 GeV variables
-  fPosTDCHits = NULL;
-  fNegTDCHits = NULL;
-  fPosADCHits = NULL;
-  fNegADCHits = NULL;
-
-  InitArrays();
-
 }
 
 //_____________________________________________________________________________
 THcAerogel::~THcAerogel()
 {
   // Destructor
+  DeleteArrays();
+}
+
+//_____________________________________________________________________________
+void THcAerogel::DeleteArrays()
+{
+  // Delete all dynamically allocated memory
+
   delete frPosAdcPedRaw;       frPosAdcPedRaw       = NULL;
   delete frPosAdcPulseIntRaw;  frPosAdcPulseIntRaw  = NULL;
   delete frPosAdcPulseAmpRaw;  frPosAdcPulseAmpRaw  = NULL;
@@ -100,59 +106,37 @@ THcAerogel::~THcAerogel()
   delete fPosAdcErrorFlag;     fPosAdcErrorFlag     = NULL;
   delete fNegAdcErrorFlag;     fNegAdcErrorFlag     = NULL;
 
+  delete [] fRegionValue;         fRegionValue = 0;
+  delete [] fAdcPosTimeWindowMin; fAdcPosTimeWindowMin = 0;
+  delete [] fAdcPosTimeWindowMax; fAdcPosTimeWindowMax = 0;
+  delete [] fAdcNegTimeWindowMin; fAdcNegTimeWindowMin = 0;
+  delete [] fAdcNegTimeWindowMax; fAdcNegTimeWindowMax = 0;
+
   // 6 GeV variables
   delete fPosTDCHits; fPosTDCHits = NULL;
   delete fNegTDCHits; fNegTDCHits = NULL;
   delete fPosADCHits; fPosADCHits = NULL;
   delete fNegADCHits; fNegADCHits = NULL;
 
-  DeleteArrays();
-
-}
-
-//_____________________________________________________________________________
-void THcAerogel::InitArrays()
-{
-  fPosGain = NULL;
-  fNegGain = NULL;
-
-  // 6 GeV variables
-  fA_Pos       = NULL;
-  fA_Neg       = NULL;
-  fA_Pos_p     = NULL;
-  fA_Neg_p     = NULL;
-  fT_Pos       = NULL;
-  fT_Neg       = NULL;
-  fPosPedLimit = NULL;
-  fNegPedLimit = NULL;
-  fPosPedMean  = NULL;
-  fNegPedMean  = NULL;
-  fPosPedSum   = NULL;
-  fPosPedSum2  = NULL;
-  fPosPedCount = NULL;
-  fNegPedSum   = NULL;
-  fNegPedSum2  = NULL;
-  fNegPedCount = NULL;
-  fPosPed      = NULL;
-  fPosSig      = NULL;
-  fPosThresh   = NULL;
-  fNegPed      = NULL;
-  fNegSig      = NULL;
-  fNegThresh   = NULL;
-}
-//_____________________________________________________________________________
-void THcAerogel::DeleteArrays()
-{
   delete [] fPosGain; fPosGain = NULL;
   delete [] fNegGain; fNegGain = NULL;
 
-  // 6 GeV variables
   delete [] fA_Pos;       fA_Pos       = NULL;
   delete [] fA_Neg;       fA_Neg       = NULL;
   delete [] fA_Pos_p;     fA_Pos_p     = NULL;
   delete [] fA_Neg_p;     fA_Neg_p     = NULL;
   delete [] fT_Pos;       fT_Pos       = NULL;
   delete [] fT_Neg;       fT_Neg       = NULL;
+
+  if (fSixGevData)
+    DeletePedestalArrays();
+}
+
+//_____________________________________________________________________________
+void THcAerogel::DeletePedestalArrays()
+{
+  // Delete all dynamically allocated memory for pedestal processing
+
   delete [] fPosPedLimit; fPosPedLimit = NULL;
   delete [] fNegPedLimit; fNegPedLimit = NULL;
   delete [] fPosPedMean;  fPosPedMean  = NULL;
@@ -232,28 +216,26 @@ Int_t THcAerogel::ReadDatabase( const TDatime& date )
 
   gHcParms->LoadParmValues((DBRequest*)&listextra, prefix);
 
-  Bool_t optional = true ;
+  Bool_t optional = true;
 
   _logger->info("Created aerogel detector {}.{} with {} PMT pairs.", GetApparatus()->GetName(),
                 GetName(), fNelem);
   //cout << "Created aerogel detector " << GetApparatus()->GetName() << "."
   //     << GetName() << " with " << fNelem << " PMT pairs" << endl;
 
+  DeleteArrays(); // avoid memory leak when reinitializing
+
   fPosGain = new Double_t[fNelem];
   fNegGain = new Double_t[fNelem];
 
   // 6 GeV variables
   fTdcOffset   = 0; // Offset to make reference time subtracted times positve
-  fPosPedLimit = new Int_t[fNelem];
-  fNegPedLimit = new Int_t[fNelem];
   fA_Pos       = new Float_t[fNelem];
   fA_Neg       = new Float_t[fNelem];
   fA_Pos_p     = new Float_t[fNelem];
   fA_Neg_p     = new Float_t[fNelem];
   fT_Pos       = new Float_t[fNelem];
   fT_Neg       = new Float_t[fNelem];
-  fPosPedMean  = new Double_t[fNelem];
-  fNegPedMean  = new Double_t[fNelem];
 
   // Normal constructor with name and description
   frPosAdcPedRaw       = new TClonesArray("THcSignalHit", fNelem*MaxNumAdcPulse);
@@ -275,28 +257,28 @@ Int_t THcAerogel::ReadDatabase( const TDatime& date )
   fPosAdcErrorFlag     = new TClonesArray("THcSignalHit", fNelem*MaxNumAdcPulse);
   fNegAdcErrorFlag     = new TClonesArray("THcSignalHit", fNelem*MaxNumAdcPulse);
 
-  fNumPosAdcHits         = vector<Int_t>    (fNelem, 0.0);
-  fNumGoodPosAdcHits     = vector<Int_t>    (fNelem, 0.0);
-  fNumNegAdcHits         = vector<Int_t>    (fNelem, 0.0);
-  fNumGoodNegAdcHits     = vector<Int_t>    (fNelem, 0.0);
-  fNumTracksMatched      = vector<Int_t>    (fNelem, 0.0);
-  fNumTracksFired        = vector<Int_t>    (fNelem, 0.0);
-  fPosNpe                = vector<Double_t> (fNelem, 0.0);
-  fNegNpe                = vector<Double_t> (fNelem, 0.0);
-  fGoodPosAdcPed         = vector<Double_t> (fNelem, 0.0);
-  fGoodPosAdcMult         = vector<Double_t> (fNelem, 0.0);
-  fGoodPosAdcPulseInt    = vector<Double_t> (fNelem, 0.0);
-  fGoodPosAdcPulseIntRaw = vector<Double_t> (fNelem, 0.0);
-  fGoodPosAdcPulseAmp    = vector<Double_t> (fNelem, 0.0);
-  fGoodPosAdcPulseTime   = vector<Double_t> (fNelem, 0.0);
-  fGoodPosAdcTdcDiffTime   = vector<Double_t> (fNelem, 0.0);
-  fGoodNegAdcPed         = vector<Double_t> (fNelem, 0.0);
-  fGoodNegAdcMult        = vector<Double_t> (fNelem, 0.0);
-  fGoodNegAdcPulseInt    = vector<Double_t> (fNelem, 0.0);
-  fGoodNegAdcPulseIntRaw = vector<Double_t> (fNelem, 0.0);
-  fGoodNegAdcPulseAmp    = vector<Double_t> (fNelem, 0.0);
-  fGoodNegAdcPulseTime   = vector<Double_t> (fNelem, 0.0);
-  fGoodNegAdcTdcDiffTime   = vector<Double_t> (fNelem, 0.0);
+  fNumPosAdcHits.assign(fNelem, 0);
+  fNumGoodPosAdcHits.assign(fNelem, 0);
+  fNumNegAdcHits.assign(fNelem, 0);
+  fNumGoodNegAdcHits.assign(fNelem, 0);
+  fNumTracksMatched.assign(fNelem, 0);
+  fNumTracksFired.assign(fNelem, 0);
+  fPosNpe.assign(fNelem, 0.0);
+  fNegNpe.assign(fNelem, 0.0);
+  fGoodPosAdcPed.assign(fNelem, 0.0);
+  fGoodPosAdcMult.assign(fNelem, 0.0);
+  fGoodPosAdcPulseInt.assign(fNelem, 0.0);
+  fGoodPosAdcPulseIntRaw.assign(fNelem, 0.0);
+  fGoodPosAdcPulseAmp.assign(fNelem, 0.0);
+  fGoodPosAdcPulseTime.assign(fNelem, 0.0);
+  fGoodPosAdcTdcDiffTime.assign(fNelem, 0.0);
+  fGoodNegAdcPed.assign(fNelem, 0.0);
+  fGoodNegAdcMult.assign(fNelem, 0.0);
+  fGoodNegAdcPulseInt.assign(fNelem, 0.0);
+  fGoodNegAdcPulseIntRaw.assign(fNelem, 0.0);
+  fGoodNegAdcPulseAmp.assign(fNelem, 0.0);
+  fGoodNegAdcPulseTime.assign(fNelem, 0.0);
+  fGoodNegAdcTdcDiffTime.assign(fNelem, 0.0);
 
   // 6 GeV variables
   fPosTDCHits = new TClonesArray("THcSignalHit", fNelem*16);
@@ -304,15 +286,12 @@ Int_t THcAerogel::ReadDatabase( const TDatime& date )
   fPosADCHits = new TClonesArray("THcSignalHit", fNelem*MaxNumAdcPulse);
   fNegADCHits = new TClonesArray("THcSignalHit", fNelem*MaxNumAdcPulse);
 
-  fPosNpeSixGev = vector<Double_t> (fNelem, 0.0);
-  fNegNpeSixGev = vector<Double_t> (fNelem, 0.0);
-
-  // Create arrays to hold pedestal results
-  if (fSixGevData) InitializePedestals();
+  fPosNpeSixGev.assign(fNelem, 0.0);
+  fNegNpeSixGev.assign(fNelem, 0.0);
 
   // Region parameters
   fRegionsValueMax = fNRegions * 8;
-  fRegionValue     = new Double_t[fRegionsValueMax];
+  fRegionValue         = new Double_t[fRegionsValueMax];
 
   fAdcPosTimeWindowMin = new Double_t [fNelem];
   fAdcPosTimeWindowMax = new Double_t [fNelem];
@@ -342,12 +321,7 @@ Int_t THcAerogel::ReadDatabase( const TDatime& date )
     {"aero_six_gev_data",     &fSixGevData,       kInt,    0, 1},
     {"aero_pos_gain",         fPosGain,           kDouble, (UInt_t) fNelem},
     {"aero_neg_gain",         fNegGain,           kDouble, (UInt_t) fNelem},
-    {"aero_pos_ped_limit",    fPosPedLimit,       kInt,    (UInt_t) fNelem, optional},
-    {"aero_neg_ped_limit",    fNegPedLimit,       kInt,    (UInt_t) fNelem, optional},
-    {"aero_pos_ped_mean",     fPosPedMean,        kDouble, (UInt_t) fNelem, optional},
-    {"aero_neg_ped_mean",     fNegPedMean,        kDouble, (UInt_t) fNelem, optional},
     {"aero_tdc_offset",       &fTdcOffset,        kInt,    0,               optional},
-    {"aero_min_peds",         &fMinPeds,          kInt,    0,               optional},
     {"aero_region",           &fRegionValue[0],   kDouble, (UInt_t) fRegionsValueMax},
     {"aero_adcrefcut",        &fADC_RefTimeCut,   kInt,    0, 1},
     {0}
@@ -367,7 +341,22 @@ Int_t THcAerogel::ReadDatabase( const TDatime& date )
 
   gHcParms->LoadParmValues((DBRequest*)&list, prefix);
 
-  if (fSixGevData) cout << "6 GeV Data Analysis Flag Set To TRUE" << endl;
+  if (fSixGevData) {
+    // Create arrays to hold pedestal results
+    InitializePedestals();
+
+    DBRequest list2[]={
+      {"aero_pos_ped_limit",    fPosPedLimit,       kInt,    (UInt_t) fNelem, optional},
+      {"aero_neg_ped_limit",    fNegPedLimit,       kInt,    (UInt_t) fNelem, optional},
+      {"aero_pos_ped_mean",     fPosPedMean,        kDouble, (UInt_t) fNelem, optional},
+      {"aero_neg_ped_mean",     fNegPedMean,        kDouble, (UInt_t) fNelem, optional},
+      {"aero_min_peds",         &fMinPeds,          kInt,    0,               optional},
+      {0}
+    };
+    gHcParms->LoadParmValues((DBRequest*)&list2, prefix);
+
+    cout << "6 GeV Data Analysis Flag Set To TRUE" << endl;
+  }
 
   fIsInit = true;
 
@@ -702,7 +691,7 @@ Int_t THcAerogel::CoarseProcess( TClonesArray&  ) //tracks
 {
   Double_t StartTime = 0.0;
   if( fglHod ) StartTime = fglHod->GetStartTime();
-  //cout << " starttime = " << StartTime << endl ;
+  //cout << " starttime = " << StartTime << endl;
     // Loop over the elements in the TClonesArray
     for(Int_t ielem = 0; ielem < frPosAdcPulseInt->GetEntries(); ielem++) {
 
@@ -948,17 +937,20 @@ void THcAerogel::InitializePedestals()
   fNPedestalEvents = 0;
   fMinPeds         = 0;                    // Do not calculate pedestals by default
 
+  DeletePedestalArrays();
+  fPosPedLimit = new Int_t [fNelem];
+  fNegPedLimit = new Int_t [fNelem];
+  fPosPedMean  = new Double_t[fNelem];
+  fNegPedMean  = new Double_t[fNelem];
   fPosPedSum   = new Int_t [fNelem];
   fPosPedSum2  = new Int_t [fNelem];
-  fPosPedLimit = new Int_t [fNelem];
   fPosPedCount = new Int_t [fNelem];
   fNegPedSum   = new Int_t [fNelem];
   fNegPedSum2  = new Int_t [fNelem];
-  fNegPedLimit = new Int_t [fNelem];
   fNegPedCount = new Int_t [fNelem];
   fPosPed      = new Double_t [fNelem];
-  fNegPed      = new Double_t [fNelem];
   fPosThresh   = new Double_t [fNelem];
+  fNegPed      = new Double_t [fNelem];
   fNegThresh   = new Double_t [fNelem];
 
   for(Int_t i = 0;i < fNelem; i++) {
@@ -1054,14 +1046,16 @@ void THcAerogel::Print(const Option_t* opt) const
   THaNonTrackingDetector::Print(opt);
 
   // Print out the pedestals
-  cout << endl;
-  cout << "Aerogel Pedestals" << endl;
-  cout << "No.   Neg    Pos" << endl;
-  for(Int_t i=0; i<fNelem; i++)
-    cout << " " << i << "\t" << fNegPedMean[i] << "\t" << fPosPedMean[i] << endl;
-  cout << endl;
-  cout << " fMinPeds = " << fMinPeds << endl;
-  cout << endl;
+  if (fSixGevData) {
+    cout << endl;
+    cout << "Aerogel Pedestals" << endl;
+    cout << "No.   Neg    Pos" << endl;
+    for(Int_t i=0; i<fNelem; i++)
+      cout << " " << i << "\t" << fNegPedMean[i] << "\t" << fPosPedMean[i] << endl;
+    cout << endl;
+    cout << " fMinPeds = " << fMinPeds << endl;
+    cout << endl;
+  }
 }
 //_____________________________________________________________________________
 Int_t THcAerogel::End(THaRunBase* run)
diff --git a/src/THcAerogel.h b/src/THcAerogel.h
index 1ac0606252ad1cef088ba0272e888ca0bf690cb6..a92fdd7728a4c40abc7618051acbc7352c33c70f 100644
--- a/src/THcAerogel.h
+++ b/src/THcAerogel.h
@@ -35,8 +35,6 @@ class THcAerogel : public hcana::ConfigLogging<THaNonTrackingDetector>, public T
   virtual EStatus Init(const TDatime& run_time);
   Int_t           End(THaRunBase* run=0);
 
-  void  InitArrays();
-  void  DeleteArrays();
   Int_t GetIndex(Int_t nRegion, Int_t nValue);
 
   THcAerogel();  // for ROOT I/O
@@ -134,7 +132,7 @@ class THcAerogel : public hcana::ConfigLogging<THaNonTrackingDetector>, public T
   vector<Double_t> fGoodNegAdcPulseIntRaw;
   vector<Double_t> fGoodNegAdcPulseAmp;
   vector<Double_t> fGoodNegAdcPulseTime;
- vector<Double_t> fGoodNegAdcTdcDiffTime;
+  vector<Double_t> fGoodNegAdcTdcDiffTime;
 
   // 6 GeV era variables
   Int_t     fAnalyzePedestals;
@@ -182,8 +180,10 @@ class THcAerogel : public hcana::ConfigLogging<THaNonTrackingDetector>, public T
   vector<Double_t> fNegNpeSixGev;
 
   void Setup(const char* name, const char* description);
+  void  DeleteArrays();
+  void  DeletePedestalArrays();
   virtual void  InitializePedestals( );
- THcHodoscope* fglHod;		// Hodoscope to get start time
+  THcHodoscope* fglHod;		// Hodoscope to get start time
 
   ClassDef(THcAerogel,0)   // Generic aerogel class
 }
diff --git a/src/THcAnalyzer.cxx b/src/THcAnalyzer.cxx
index 86fad41ee84af64163f5e6728a0ca66b02a0d0f9..da3832be3fd289af76fe8961c367006031ad357f 100644
--- a/src/THcAnalyzer.cxx
+++ b/src/THcAnalyzer.cxx
@@ -103,6 +103,7 @@ void THcAnalyzer::PrintReport(const char* templatefile, const char* ofile)
       } else {
 	THcFormula* formula = new THcFormula("temp",expression.c_str(),gHcParms,gHaVars,gHaCuts);
 	Double_t value=formula->Eval();
+	delete formula; formula = 0;
 	// If the value is close to integer and no format is defined
 	// use "%.0f" to print out integer
 	if(format.empty()) {
diff --git a/src/THcCherenkov.cxx b/src/THcCherenkov.cxx
index b21a795f92c25203105a638ba52b029ecc1a1348..65c19f1a9cae5be15f0ab19273baf3c5cb2449bd 100644
--- a/src/THcCherenkov.cxx
+++ b/src/THcCherenkov.cxx
@@ -135,6 +135,10 @@ void THcCherenkov::DeleteArrays()
   delete [] fPedCount; fPedCount = NULL;
   delete [] fPed;      fPed      = NULL;
   delete [] fThresh;   fThresh   = NULL;
+
+  delete [] fAdcTimeWindowMin; fAdcTimeWindowMin = 0;
+  delete [] fAdcTimeWindowMax; fAdcTimeWindowMax = 0;
+  delete [] fRegionValue; fRegionValue = 0;
 }
 
 //_____________________________________________________________________________
@@ -166,7 +170,7 @@ THaAnalysisObject::EStatus THcCherenkov::Init( const TDatime& date )
     Warning(Here(here),"Hodoscope \"%s\" not found. ","hod");
   }
 
- fPresentP = 0;
+  fPresentP = 0;
   THaVar* vpresent = gHaVars->Find(Form("%s.present",GetApparatus()->GetName()));
   if(vpresent) {
     fPresentP = (Bool_t *) vpresent->GetValuePointer();
diff --git a/src/THcConfigEvtHandler.cxx b/src/THcConfigEvtHandler.cxx
index afef71090f4b4cd7d8244243429f78e7278c6db5..a3cc6bc144773d7a58aea12ee0d4266fd0f33608 100644
--- a/src/THcConfigEvtHandler.cxx
+++ b/src/THcConfigEvtHandler.cxx
@@ -44,6 +44,9 @@ THcConfigEvtHandler::THcConfigEvtHandler(const char *name, const char* descripti
 
 THcConfigEvtHandler::~THcConfigEvtHandler()
 {
+  // TODO: remove the parameters we've added to gHcParms
+
+  DeleteCrateInfoMap();
 }
 
 //Float_t THcConfigEvtHandler::GetData(const std::string& tag)
@@ -54,6 +57,26 @@ THcConfigEvtHandler::~THcConfigEvtHandler()
 // return theDataMap[tag];
 //}
 
+void THcConfigEvtHandler::DeleteCrateInfoMap()
+{
+  // Clear the CrateInfoMap, deallocating its elements' dynamic memory
+
+  //TODO: don't manage memory manually, contain the object, use STL vectors
+  typedef std::map<Int_t, CrateInfo_t *> cmap_t;
+  typedef std::map<Int_t, Int_t *> imap_t;
+  for( cmap_t::iterator it = CrateInfoMap.begin();
+       it != CrateInfoMap.end(); ++it ) {
+    CrateInfo_t* cinfo = it->second;
+    if( cinfo ) {
+      for( imap_t::iterator jt = cinfo->FADC250.thresholds.begin();
+	   jt != cinfo->FADC250.thresholds.end(); ++jt ) {
+	delete [] jt->second;
+      }
+      delete cinfo;
+    }
+  }
+  CrateInfoMap.clear();
+}
 
 Int_t THcConfigEvtHandler::Analyze(THaEvData *evdata)
 {
@@ -80,6 +103,7 @@ Int_t THcConfigEvtHandler::Analyze(THaEvData *evdata)
   cinfo->FADC250.present=0;
   cinfo->CAEN1190.present=0;
   cinfo->TI.present=0;  
+  // FIXME: check if entry for this roc already present in the map
   CrateInfoMap.insert(std::make_pair(roc, cinfo));
   ip++;
   // Three possible blocks of config data
@@ -214,12 +238,13 @@ void THcConfigEvtHandler::MakeParms(Int_t roc)
       while(itt != cinfo->FADC250.thresholds.end()) {
         Int_t slot = itt->first;
 
-	Int_t *threshp = itt->second;
-	Int_t *thresholds = new Int_t[16];
-	for(Int_t ichan=0;ichan<16;ichan++) {
-	  thresholds[ichan] = threshp[ichan];
-	}
-	gHcParms->Define(Form("g%s_adc_thresholds_%d_%d[16]",fName.Data(),roc,slot),"ADC Thresholds",*thresholds);
+	// this memory would leak
+//	Int_t *thresholds = new Int_t[16];
+//	memcpy(thresholds,itt->second,16*sizeof(Int_t));
+//	gHcParms->Define(Form("g%s_adc_thresholds_%d_%d[16]",fName.Data(),roc,slot),"ADC Thresholds",*thresholds);
+	// Define the variable directly on the CrateInfo_t that resides in CrateInfoMap where it will stay
+	// until the end of the life of this object
+	gHcParms->Define(Form("g%s_adc_thresholds_%d_%d[16]",fName.Data(),roc,slot),"ADC Thresholds",*itt->second);
 
 	Int_t mode = cinfo->FADC250.mode;
 	gHcParms->Define(Form("g%s_adc_mode_%d_%d",fName.Data(),roc,slot),"ADC Mode",mode);
@@ -374,7 +399,7 @@ THaAnalysisObject::EStatus THcConfigEvtHandler::Init(const TDatime& date)
     eventtypes.push_back(125);  // what events to look for
   }
 
-  CrateInfoMap.clear();
+  DeleteCrateInfoMap();
 
   fStatus = kOK;
   return kOK;
diff --git a/src/THcConfigEvtHandler.h b/src/THcConfigEvtHandler.h
index 1f0866b1d4fd4b57d4ea80858c64197314ae6f58..c0cc938becb66fa4b96e92e76bd1a993ef2fc67e 100644
--- a/src/THcConfigEvtHandler.h
+++ b/src/THcConfigEvtHandler.h
@@ -74,6 +74,8 @@ private:
 
   std::map<Int_t, CrateInfo_t *> CrateInfoMap;
 
+  void DeleteCrateInfoMap();
+
   THcConfigEvtHandler(const THcConfigEvtHandler& fh);
   THcConfigEvtHandler& operator=(const THcConfigEvtHandler& fh);
 
diff --git a/src/THcDC.cxx b/src/THcDC.cxx
index d9e082f125c17f2d3c20396f53c1407f472e1cd5..f50e9450c5e72f9c13e2e5d18ca5829c72d73c36 100644
--- a/src/THcDC.cxx
+++ b/src/THcDC.cxx
@@ -318,9 +318,6 @@ Int_t THcDC::ReadDatabase( const TDatime& date )
   delete [] fSigma;  fSigma = new Double_t [fNPlanes];
 
   Bool_t optional = true;
-  fReadoutLR = new Int_t[fNPlanes];
-  fReadoutTB = new Int_t[fNPlanes];
-
 
   DBRequest list[]={
     {"dc_tdc_time_per_channel",&fNSperChan, kDouble},
@@ -505,6 +502,15 @@ void THcDC::DeleteArrays()
   delete [] fNChamHits; fNChamHits = NULL;
   delete [] fPlaneEvents; fPlaneEvents = NULL;
 
+  for( Int_t i = 0; i<fNPlanes; ++i )
+    delete [] fPlaneNames[i];
+  delete [] fPlaneNames;
+
+  delete [] fPlaneCoeffs; fPlaneCoeffs = 0;
+  delete [] fResiduals; fResiduals = 0;
+  delete [] fResidualsExclPlane; fResidualsExclPlane = 0;
+  delete [] fWire_hit_did; fWire_hit_did = 0;
+  delete [] fWire_hit_should; fWire_hit_should = 0;
 }
 
 //_____________________________________________________________________________
diff --git a/src/THcDCLookupTTDConv.cxx b/src/THcDCLookupTTDConv.cxx
index cfedc55685ecd2df41beded7c620ce6b85501113..01c49cd622df83840d71b0f1f56a831a1809a3ab 100644
--- a/src/THcDCLookupTTDConv.cxx
+++ b/src/THcDCLookupTTDConv.cxx
@@ -5,7 +5,8 @@
 
 */
 #include "THcDCLookupTTDConv.h"
-
+#include <cstring>
+#include <cassert>
 ClassImp(THcDCLookupTTDConv)
 
 
@@ -18,18 +19,17 @@ fT0(T0), fMaxDriftDistance(MaxDriftDistance), fBinSize(BinSize),
 {
   //Normal constructor
 
+  assert( fNumBins > 0 );
   fTable = new Double_t[fNumBins];
-  for(Int_t i=0;i<fNumBins;i++) {
-    fTable[i] = Table[i];
-  }
-
+  memcpy( fTable, Table, fNumBins*sizeof(Double_t) );
 }
 
 //______________________________________________________________________________
 THcDCLookupTTDConv::~THcDCLookupTTDConv()
 {
-  // Destructor. Remove variables from global list.
+  // Destructor
 
+  delete [] fTable;
 }
 
 //______________________________________________________________________________
diff --git a/src/THcDriftChamber.cxx b/src/THcDriftChamber.cxx
index a47dea84f6143fb494246dc86190543c1d4167cc..6f2dac9964fdd2e2362f6684e90c53980b6e3c0e 100644
--- a/src/THcDriftChamber.cxx
+++ b/src/THcDriftChamber.cxx
@@ -196,22 +196,23 @@ Int_t THcDriftChamber::ReadDatabase( const TDatime& date )
   for(Int_t ipm1=0;ipm1<fNPlanes+1;ipm1++) { // Loop over missing plane1
     for(Int_t ipm2=ipm1;ipm2<fNPlanes+1;ipm2++) {
       if(ipm1==ipm2 && ipm1<fNPlanes) continue;
-      TMatrixD* AA3 = new TMatrixD(3,3);
+      TMatrixD AA3(3,3);
       for(Int_t i=0;i<3;i++) {
 	for(Int_t j=i;j<3;j++) {
-	  (*AA3)[i][j] = 0.0;
+	  AA3[i][j] = 0.0;
 	  for(Int_t ip=0;ip<fNPlanes;ip++) {
 	    if(ipm1 != ip && ipm2 != ip) {
-	      (*AA3)[i][j] += fStubCoefs[ip][i]*fStubCoefs[ip][j];
+	      AA3[i][j] += fStubCoefs[ip][i]*fStubCoefs[ip][j];
 	    }
 	  }
-	  (*AA3)[j][i] = (*AA3)[i][j];
+	  AA3[j][i] = AA3[i][j];
 	}
       }
       Int_t bitpat = allplanes & ~(1<<ipm1) & ~(1<<ipm2);
       // Should check that it is invertable
       //      if (fhdebugflagpr) cout << bitpat << " Determinant: " << AA3->Determinant() << endl;
-      AA3->Invert();
+      AA3.Invert();
+      fAA3Inv[bitpat].ResizeTo(AA3);
       fAA3Inv[bitpat] = AA3;
     }
   }
@@ -1326,11 +1327,11 @@ Double_t THcDriftChamber::FindStub(Int_t nhits, THcSpacePoint *sp,
 	/fSigma[plane_list[ihit]];
     }
   }
-  //  fAA3Inv[bitpat]->Print();
+  //  fAA3Inv[bitpat].Print();
   //  if (fhdebugflagpr) cout << TT[0] << " " << TT[1] << " " << TT[2] << endl;
-  //  TT->Print();
+  //  TT.Print();
 
-  TT *= *fAA3Inv[bitpat];
+  TT *= fAA3Inv[bitpat];
   // if (fhdebugflagpr) cout << TT[0] << " " << TT[1] << " " << TT[2] << endl;
 
   // Calculate Chi2.  Remember one power of sigma is in fStubCoefs
@@ -1373,14 +1374,12 @@ THcDriftChamber::~THcDriftChamber()
 void THcDriftChamber::DeleteArrays()
 {
   // Delete member arrays. Used by destructor.
-  delete fCosBeta; fCosBeta = NULL;
-  delete fSinBeta; fSinBeta = NULL;
-  delete fTanBeta; fTanBeta = NULL;
-  delete fSigma; fSigma = NULL;
-  delete fPsi0; fPsi0 = NULL;
-  delete fStubCoefs; fStubCoefs = NULL;
-
-  // Need to delete each element of the fAA3Inv map
+  delete [] fCosBeta; fCosBeta = NULL;
+  delete [] fSinBeta; fSinBeta = NULL;
+  delete [] fTanBeta; fTanBeta = NULL;
+  delete [] fSigma; fSigma = NULL;
+  delete [] fPsi0; fPsi0 = NULL;
+  delete [] fStubCoefs; fStubCoefs = NULL;
 
 }
 
diff --git a/src/THcDriftChamber.h b/src/THcDriftChamber.h
index 91f102dbda38f689b861ea00d7d47dae83555b94..f04b024d746588418e95679fd6a45a908e3338f6 100644
--- a/src/THcDriftChamber.h
+++ b/src/THcDriftChamber.h
@@ -135,7 +135,7 @@ protected:
   Int_t fEasySpacePoint;	/* This event is an easy space point */
 
   Double_t* stubcoef[4];
-  std::map<int,TMatrixD*> fAA3Inv;
+  std::map<int,TMatrixD> fAA3Inv;
 
   THaDetectorBase* fParent;
 
diff --git a/src/THcDriftChamberPlane.cxx b/src/THcDriftChamberPlane.cxx
index 8e9ef6f41d56a5b6ed3bbb8ce737fd00f60eb3ab..e6f97ebb86546569cfa06838f0acb678b76e7bff 100644
--- a/src/THcDriftChamberPlane.cxx
+++ b/src/THcDriftChamberPlane.cxx
@@ -33,15 +33,13 @@ THcDriftChamberPlane::THcDriftChamberPlane( const char* name,
 					    const char* description,
 					    const Int_t planenum,
 					    THaDetectorBase* parent )
-  : THaSubDetector(name,description,parent)
+: THaSubDetector(name,description,parent), fTTDConv(0)
 {
   // Normal constructor with name and description
   fHits = new TClonesArray("THcDCHit",100);
   fRawHits = new TClonesArray("THcDCHit",100);
   fWires = new TClonesArray("THcDCWire", 100);
 
-  fTTDConv = NULL;
-
   fPlaneNum = planenum;
 }
 
@@ -59,6 +57,8 @@ THcDriftChamberPlane::THcDriftChamberPlane() :
 THcDriftChamberPlane::~THcDriftChamberPlane()
 {
   // Destructor
+  delete [] fTzeroWire;
+  delete [] fSigmaWire;
   delete fWires;
   delete fHits;
   delete fRawHits;
diff --git a/src/THcHallCSpectrometer.cxx b/src/THcHallCSpectrometer.cxx
index 571a31a1176eba3916d1bac5c7602845ad347d0c..e4dc54a85cc3e9daf16fce33c0484935b5901202 100644
--- a/src/THcHallCSpectrometer.cxx
+++ b/src/THcHallCSpectrometer.cxx
@@ -767,8 +767,8 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
   if ( fNtracks > 0 ) {
     chi2Min   = 10000000000.0;
     fGoodTrack = 0;
-    Bool_t* keep      = new Bool_t [fNtracks];
-    Int_t* reject    = new Int_t  [fNtracks];
+    vector<bool> keep(fNtracks);
+    vector<Int_t> reject(fNtracks);
 
     THaTrack *testTracks[fNtracks];
 
@@ -777,7 +777,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       keep[ptrack] = kTRUE;
       reject[ptrack] = 0;
       testTracks[ptrack] = static_cast<THaTrack*>( fTracks->At(ptrack) );
-      if (!testTracks[ptrack]) {delete[] keep; delete[] reject; return -1;}
+      if (!testTracks[ptrack]) return -1;
     }
 
     // ! Prune on xptar
@@ -791,7 +791,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( TMath::Abs( testTracks[ptrack]->GetTTheta() ) >= fPruneXp ){
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 1;
+	  reject[ptrack] += 1;
 	}
       }
     }
@@ -807,7 +807,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( TMath::Abs( testTracks[ptrack]->GetTPhi() ) >= fPruneYp ){
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 2;
+	  reject[ptrack] += 2;
 
 	}
       }
@@ -824,7 +824,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( TMath::Abs( testTracks[ptrack]->GetTY() ) >= fPruneYtar ){
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 10;
+	  reject[ptrack] += 10;
 	}
       }
     }
@@ -840,7 +840,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( TMath::Abs( testTracks[ptrack]->GetDp() ) >= fPruneDelta ){
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 20;
+	  reject[ptrack] += 20;
 	}
       }
     }
@@ -860,7 +860,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
 	Double_t betaP = p / TMath::Sqrt( p * p + fPartMass * fPartMass );
 	if ( TMath::Abs( testTracks[ptrack]->GetBeta() - betaP ) >= fPruneBeta ) {
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 100;
+	  reject[ptrack] += 100;
 	}
       }
     }
@@ -876,7 +876,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( testTracks[ptrack]->GetNDoF() < fPruneDf ){
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 200;
+	  reject[ptrack] += 200;
 	}
       }
     }
@@ -892,7 +892,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( testTracks[ptrack]->GetNPMT() < fPruneNPMT ){
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 100000;
+	  reject[ptrack] += 100000;
 	}
       }
     }
@@ -910,7 +910,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
 	if ( ( testTracks[ptrack]->GetBetaChi2() >= fPruneChiBeta ) ||
 	     ( testTracks[ptrack]->GetBetaChi2() <= 0.01          ) ){
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 1000;
+	  reject[ptrack] += 1000;
 	}
       }
     }
@@ -927,7 +927,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( TMath::Abs( testTracks[ptrack]->GetFPTime() - fHodo->GetStartTimeCenter() ) >= fPruneFpTime ) {
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 2000;
+	  reject[ptrack] += 2000;
 	}
       }
     }
@@ -943,7 +943,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( testTracks[ptrack]->GetGoodPlane4() != 1 ) {
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 10000;
+	  reject[ptrack] += 10000;
 	}
       }
     }
@@ -959,7 +959,7 @@ Int_t THcHallCSpectrometer::BestTrackUsingPrune()
       for (Int_t ptrack = 0; ptrack < fNtracks; ptrack++ ){
 	if ( testTracks[ptrack]->GetGoodPlane3() != 1 ) {
 	  keep[ptrack] = kFALSE;
-	  reject[ptrack] = reject[ptrack] + 20000;
+	  reject[ptrack] += 20000;
 	}
       }
     }
diff --git a/src/THcHitList.cxx b/src/THcHitList.cxx
index 777fcc064e3b4ade5d44cb0f655c91e21d3e175c..2b0b09d0b160f0b2f5d7c08ff3defce63a26519e 100644
--- a/src/THcHitList.cxx
+++ b/src/THcHitList.cxx
@@ -39,7 +39,8 @@ THcHitList::THcHitList() : fMap(0), fTISlot(0), fDisableSlipCorrection(kFALSE)
 
 THcHitList::~THcHitList() {
   /// Destructor
-  delete fSignalTypes;
+  delete fRawHitList;
+  delete [] fSignalTypes;
 }
 /**
 
diff --git a/src/THcHodoEff.cxx b/src/THcHodoEff.cxx
index 5e2caafe51d52bf5af1702386ac95f57e24ef307..941b89f85915dc4c6c9e535a71c34765baec1d6e 100644
--- a/src/THcHodoEff.cxx
+++ b/src/THcHodoEff.cxx
@@ -36,6 +36,24 @@ THcHodoEff::~THcHodoEff()
 {
   // Destructor
 
+  delete [] fPlanes; fPlanes = 0;
+  delete [] fPosZ; fPosZ = 0;
+  delete [] fSpacing; fSpacing = 0;
+  delete [] fCenterFirst; fCenterFirst = 0;
+  delete [] fNCounters; fNCounters = 0;
+  delete [] fHodoSlop; fHodoSlop = 0;
+  delete [] fStatTrkSum; fStatTrkSum = 0;
+  delete [] fStatAndSum; fStatAndSum = 0;
+  delete [] fStatAndEff; fStatAndEff = 0;
+
+  delete [] fHodoPosEffi; fHodoPosEffi = 0;
+  delete [] fHodoNegEffi; fHodoNegEffi = 0;
+  delete [] fHodoOrEffi; fHodoOrEffi = 0;
+  delete [] fHodoAndEffi; fHodoAndEffi = 0;
+  delete [] fStatTrk; fStatTrk = 0;
+
+  delete [] fHitPlane; fHitPlane = 0;
+
   RemoveVariables();
 }
 
diff --git a/src/THcHodoscope.cxx b/src/THcHodoscope.cxx
index 577239c89d34d05ecc34af56850ea3be0455183b..6beaa08eccca4f9ec315f8aec835c0a685652099 100644
--- a/src/THcHodoscope.cxx
+++ b/src/THcHodoscope.cxx
@@ -46,6 +46,7 @@ hodoscope array, not just one plane.
 #include <array>
 
 #include "hcana/helpers.hxx"
+#include <cassert>
 
 using namespace std;
 using std::vector;
@@ -422,6 +423,11 @@ Int_t THcHodoscope::ReadDatabase( const TDatime& date )
   //      << " number of photo electrons = " << fNCerNPE
   //      << endl;
 
+  //Set scin Velocity/Cable to default
+  for (UInt_t i=0; i<fMaxHodoScin; i++) {
+    fHodoVelLight[i] = 15.0;
+  }
+
   if (fTofUsingInvAdc) {
     DBRequest list2[]={
       {"hodo_vel_light",                   &fHodoVelLight[0],       kDouble,  fMaxHodoScin, 1},
@@ -434,13 +440,6 @@ Int_t THcHodoscope::ReadDatabase( const TDatime& date )
       {0}
     };
     
-       for (UInt_t i=0; i<fMaxHodoScin; i++)                                                                    
-       {  
-	 //Set scin Velocity/Cable to default
-	 fHodoVelLight[i] = 15.0;
-	 
-       }
-    
     gHcParms->LoadParmValues((DBRequest*)&list2,prefix);
   };
   /* if (!fTofUsingInvAdc) {
@@ -577,10 +576,13 @@ THcHodoscope::~THcHodoscope()
     RemoveVariables();
   if( fIsInit )
     DeleteArrays();
-  if (fTrackProj) {
-    fTrackProj->Clear();
-    delete fTrackProj; fTrackProj = 0;
+
+  for( int i = 0; i < fNPlanes; ++i ) {
+    delete fPlanes[i];
+    delete [] fPlaneNames[i];
   }
+  delete [] fPlanes;
+  delete [] fPlaneNames;
 }
 
 //_____________________________________________________________________________
@@ -595,6 +597,8 @@ void THcHodoscope::DeleteArrays()
 
   delete [] fxLoScin;             fxLoScin = NULL;
   delete [] fxHiScin;             fxHiScin = NULL;
+  delete [] fyLoScin;             fyLoScin = NULL;
+  delete [] fyHiScin;             fyHiScin = NULL;
   delete [] fHodoSlop;            fHodoSlop = NULL;
 
   delete [] fNPaddle;             fNPaddle = NULL;
@@ -614,11 +618,13 @@ void THcHodoscope::DeleteArrays()
   delete [] fHodoPosInvAdcLinear; fHodoPosInvAdcLinear = NULL;
   delete [] fHodoNegInvAdcLinear; fHodoNegInvAdcLinear = NULL;
   delete [] fHodoPosInvAdcAdc;    fHodoPosInvAdcAdc = NULL;
+  delete [] fHodoNegInvAdcAdc;    fHodoNegInvAdcAdc = NULL;
   delete [] fGoodPlaneTime;       fGoodPlaneTime = NULL;
   delete [] fNPlaneTime;          fNPlaneTime = NULL;
   delete [] fSumPlaneTime;        fSumPlaneTime = NULL;
   delete [] fNScinHits;           fNScinHits = NULL;
   delete [] fTdcOffset;           fTdcOffset = NULL;
+  delete [] fAdcTdcOffset;        fAdcTdcOffset = NULL;
   delete [] fHodoNegAdcTimeWindowMin;    fHodoNegAdcTimeWindowMin = NULL;
   delete [] fHodoNegAdcTimeWindowMax;    fHodoNegAdcTimeWindowMax = NULL;
   delete [] fHodoPosAdcTimeWindowMin;    fHodoPosAdcTimeWindowMin = NULL;
@@ -636,8 +642,7 @@ void THcHodoscope::DeleteArrays()
 }
 
 //_____________________________________________________________________________
-inline
-void THcHodoscope::ClearEvent()
+void THcHodoscope::Clear( Option_t* opt )
 {
   /*! \brief Clears variables
    *
@@ -656,13 +661,15 @@ void THcHodoscope::ClearEvent()
   fGoodStartTime = kFALSE;
   fGoodScinHits = 0;
  
-  for(Int_t ip=0;ip<fNPlanes;ip++) {
-    fPlanes[ip]->Clear();
-    fFPTime[ip]=0.;
-    fPlaneCenter[ip]=0.;
-    fPlaneSpacing[ip]=0.;
-    for(UInt_t iPaddle=0;iPaddle<fNPaddle[ip]; ++iPaddle) {
-      fScinHitPaddle[ip][iPaddle]=0;
+  if( *opt != 'I' ) {
+    for(Int_t ip=0;ip<fNPlanes;ip++) {
+      fPlanes[ip]->Clear();
+      fFPTime[ip]=0.;
+      fPlaneCenter[ip]=0.;
+      fPlaneSpacing[ip]=0.;
+      for(UInt_t iPaddle=0;iPaddle<fNPaddle[ip]; ++iPaddle) {
+	fScinHitPaddle[ip][iPaddle]=0;
+      }
     }
   }
   fdEdX.clear();
@@ -672,6 +679,7 @@ void THcHodoscope::ClearEvent()
   fClustPos.clear();
   fThreeScin.clear();
   fGoodScinHitsX.clear();
+  fGoodFlags.clear();
 }
 
 //_____________________________________________________________________________
@@ -679,7 +687,6 @@ Int_t THcHodoscope::Decode( const THaEvData& evdata )
 {
   /*! \brief Decodes raw data and processes raw data into hits for each instance of  THcScintillatorPlane
    *
-   *  - Calls THcHodoscope::ClearEvent
    *  - Reads raw data using THcHitList::DecodeToHitList
    *  - If one wants to subtract pedestals (assumed to be a set of data at beginning of run)
    *    + Must define "Pedestal_event" cut in the cuts definition file
@@ -690,7 +697,6 @@ Int_t THcHodoscope::Decode( const THaEvData& evdata )
    *
    *
    */
-  ClearEvent();
   // Get the Hall C style hitlist (fRawHitList) for this event
   Bool_t present = kTRUE;	// Suppress reference time warnings
   if(fPresentP) {		// if this spectrometer not part of trigger
@@ -981,11 +987,13 @@ Int_t THcHodoscope::CoarseProcess( TClonesArray& tracks )
 
   //  fDumpOut << " ntrack =  " << ntracks  << endl;
 
-  if (tracks.GetLast()+1 > 0 ) {
+  if (ntracks > 0 ) {
 
     // **MAIN LOOP: Loop over all tracks and get corrected time, tof, beta...
-    Double_t* nPmtHit = new Double_t [ntracks];
-    Double_t* timeAtFP = new Double_t [ntracks];
+    vector<Double_t> nPmtHit(ntracks);
+    vector<Double_t> timeAtFP(ntracks);
+    fdEdX.reserve(ntracks);
+    fGoodFlags.reserve(ntracks);
     for ( Int_t itrack = 0; itrack < ntracks; itrack++ ) { // Line 133
       nPmtHit[itrack]=0;
       timeAtFP[itrack]=0;
@@ -1000,10 +1008,15 @@ Int_t THcHodoscope::CoarseProcess( TClonesArray& tracks )
 	fSumPlaneTime[ip] = 0.;
       }
       std::vector<Double_t> dedx_temp;
-      fdEdX.push_back(dedx_temp); // Create array of dedx per hit
       std::vector<std::vector<GoodFlags> > goodflagstmp1;
+      goodflagstmp1.reserve(fNumPlanesBetaCalc);
+#if __cplusplus >= 201103L
+      fdEdX.push_back(std::move(dedx_temp)); // Create array of dedx per hit
+      fGoodFlags.push_back(std::move(goodflagstmp1));
+#else
+      fdEdX.push_back(dedx_temp); // Create array of dedx per hit
       fGoodFlags.push_back(goodflagstmp1);
-
+#endif
       Int_t nFPTime = 0;
       Double_t betaChiSq = -3;
       Double_t beta = 0;
@@ -1034,8 +1047,12 @@ Int_t THcHodoscope::CoarseProcess( TClonesArray& tracks )
       for(Int_t ip = 0; ip < fNumPlanesBetaCalc; ip++ ) {
 
 	std::vector<GoodFlags> goodflagstmp2;
+	goodflagstmp2.reserve(fNScinHits[ip]);
+#if __cplusplus >= 201103L
+	fGoodFlags[itrack].push_back(std::move(goodflagstmp2));
+#else
 	fGoodFlags[itrack].push_back(goodflagstmp2);
-
+#endif
 	fNScinHits[ip] = fPlanes[ip]->GetNScinHits();
 	TClonesArray* hodoHits = fPlanes[ip]->GetHits();
 
@@ -1174,16 +1191,20 @@ Int_t THcHodoscope::CoarseProcess( TClonesArray& tracks )
       }
 
       //---------------------------------------------------------------------------------------------
-      // ---------------------- Scond loop over scint. hits in a plane ------------------------------
+      // ---------------------- Second loop over scint. hits in a plane -----------------------------
       //---------------------------------------------------------------------------------------------
+ 
+      fdEdX[itrack].reserve(nhits);
+      fTOFCalc.reserve(nhits);
       for(Int_t ih=0; ih < nhits; ih++) {
 	THcHodoHit *hit = fTOFPInfo[ih].hit;
 	Int_t iphit = fTOFPInfo[ih].hitNumInPlane;
 	Int_t ip = fTOFPInfo[ih].planeIndex;
 	//         fDumpOut << " looping over hits = " << ih << " plane = " << ip+1 << endl;
-	GoodFlags flags;
 	// Flags are used by THcHodoEff
-	fGoodFlags[itrack][ip].push_back(flags);
+	fGoodFlags[itrack][ip].reserve(nhits);
+	fGoodFlags[itrack][ip].push_back(GoodFlags());
+	assert( iphit >= 0 && (size_t)iphit < fGoodFlags[itrack][ip].size() );
 	fGoodFlags[itrack][ip][iphit].onTrack = kFALSE;
 	fGoodFlags[itrack][ip][iphit].goodScinTime = kFALSE;
 	fGoodFlags[itrack][ip][iphit].goodTdcNeg = kFALSE;
@@ -1191,6 +1212,7 @@ Int_t THcHodoscope::CoarseProcess( TClonesArray& tracks )
 
 	fTOFCalc.push_back(TOFCalc());
 	// Do we set back to false for each track, or just once per event?
+	assert( ih >= 0 && (size_t)ih < fTOFCalc.size() );
 	fTOFCalc[ih].good_scin_time = kFALSE;
 	// These need a track index too to calculate efficiencies
 	fTOFCalc[ih].good_tdc_pos = kFALSE;
@@ -1289,6 +1311,7 @@ Int_t THcHodoscope::CoarseProcess( TClonesArray& tracks )
 	    }
 
 	    fdEdX[itrack].push_back(0.0);
+	    assert( fNScinHit[itrack] > 0 && (size_t)fNScinHit[itrack] < fdEdX[itrack].size()+1 );
 
 	    // --------------------------------------------------------------------------------------------
 	    if ( fTOFCalc[ih].good_tdc_pos ){
diff --git a/src/THcHodoscope.h b/src/THcHodoscope.h
index af69735f31aefc615043adac1fe2f1f6c207c837..db255e3396e1eb1b707a91a19e0f5267363a76f6 100644
--- a/src/THcHodoscope.h
+++ b/src/THcHodoscope.h
@@ -44,6 +44,7 @@ public:
 
   virtual Int_t      Decode( const THaEvData& );
   virtual EStatus    Init( const TDatime& run_time );
+  virtual void       Clear( Option_t* opt="" );
 
   virtual Int_t      CoarseProcess( TClonesArray& tracks );
   virtual Int_t      FineProcess( TClonesArray& tracks );
@@ -346,9 +347,8 @@ protected:
     Int_t hitNumInPlane;
     THcHodoHit *hit;
     TOFPInfo () : onTrack(kFALSE), keep_pos(kFALSE), keep_neg(kFALSE),
-      time_pos(-99.0), time_neg(-99.0),
-
-scin_pos_time(0.0), scin_neg_time(0.0) {}
+		  time_pos(-99.0), time_neg(-99.0), scin_pos_time(0.0),
+		  scin_neg_time(0.0) {}
   };
   std::vector<TOFPInfo> fTOFPInfo;
 
@@ -386,11 +386,12 @@ scin_pos_time(0.0), scin_neg_time(0.0) {}
     Bool_t goodScinTime;
     Bool_t goodTdcNeg;
     Bool_t goodTdcPos;
+    GoodFlags() : onTrack(false), goodScinTime(false),
+		  goodTdcNeg(false), goodTdcPos(false) {}
   };
   std::vector<std::vector<std::vector<GoodFlags> > > fGoodFlags;
   //
 
-  void           ClearEvent();
   void           DeleteArrays();
   virtual Int_t  ReadDatabase( const TDatime& date );
   virtual Int_t  DefineVariables( EMode mode = kDefine );
diff --git a/src/THcParmList.cxx b/src/THcParmList.cxx
index 6fdada9b2bba7571e1c7badb4a61c5ae9d88ba61..7cdbe1e0588f92cf974acd90c900c5b03a1aa601 100644
--- a/src/THcParmList.cxx
+++ b/src/THcParmList.cxx
@@ -60,10 +60,17 @@ An instance of THaTextvars is created to hold the string parameters.
 #include <cassert>
 #include <cstdlib>
 #include <stdexcept>
+#include <memory>
 
 using namespace std;
 Int_t  fDebug   = 1;  // Keep this at one while we're working on the code
 
+#if __cplusplus < 201103L
+# define SMART_PTR auto_ptr
+#else
+# define SMART_PTR unique_ptr
+#endif
+
 ClassImp(THcParmList)
 
 /// Create empty numerical and string parameter lists
@@ -266,7 +273,7 @@ The ENGINE CTP support parameter "blocks" which were marked with
       if(line.find_first_not_of("0123456789-,")==string::npos) { // Interpret as runnum range
 	// Interpret line as a list of comma separated run numbers or ranges
 	TString runnums(line.c_str());
-	TObjArray *runnumarr = runnums.Tokenize(",");
+	SMART_PTR<TObjArray> runnumarr( runnums.Tokenize(",") );
 	Int_t nranges=runnumarr->GetLast()+1;
 
 	InRunRange = 0;
diff --git a/src/THcScalerEvtHandler.cxx b/src/THcScalerEvtHandler.cxx
index 5b2ff5c09a00968c3d97ef0d526e16ba02d32e10..a785b704a1516ac4699c3f039a9900aa273de3cd 100644
--- a/src/THcScalerEvtHandler.cxx
+++ b/src/THcScalerEvtHandler.cxx
@@ -50,6 +50,7 @@ To enable debugging you may try this in the setup script
 #include "TNamed.h"
 #include "TMath.h"
 #include "TString.h"
+#include "TROOT.h"
 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
@@ -59,6 +60,7 @@ To enable debugging you may try this in the setup script
 #include <iterator>
 #include "THaVarList.h"
 #include "VarDef.h"
+#include "Helper.h"
 
 using namespace std;
 using namespace Decoder;
@@ -88,9 +90,24 @@ THcScalerEvtHandler::THcScalerEvtHandler(const char *name, const char* descripti
 
 THcScalerEvtHandler::~THcScalerEvtHandler()
 {
-  if (fScalerTree) {
+  // The tree object is owned by ROOT since it gets associated wth the output
+  // file, so DO NOT delete it here. 
+  if (!TROOT::Initialized()) {
     delete fScalerTree;
   }
+  Podd::DeleteContainer(scalers);
+  Podd::DeleteContainer(scalerloc);
+  delete [] dvars_prev_read;
+  delete [] dvars;
+  delete [] dvarsFirst;
+  delete [] fBCM_Gain;
+  delete [] fBCM_Offset;
+  delete [] fBCM_delta_charge;
+
+  for( vector<UInt_t*>::iterator it = fDelayedEvents.begin();
+       it != fDelayedEvents.end(); ++it )
+    delete [] *it;
+  fDelayedEvents.clear();
 }
 
 Int_t THcScalerEvtHandler::End( THaRunBase* )
@@ -107,7 +124,10 @@ Int_t THcScalerEvtHandler::End( THaRunBase* )
     evNumberR = -1;
   if (fScalerTree) fScalerTree->Fill();
 
-  fDelayedEvents.clear();	// Does this free the arrays?
+  for( vector<UInt_t*>::iterator it = fDelayedEvents.begin();
+       it != fDelayedEvents.end(); ++it )
+    delete [] *it;
+  fDelayedEvents.clear();
 
   if (fScalerTree) fScalerTree->Write();
   return 0;
@@ -222,9 +242,7 @@ Int_t THcScalerEvtHandler::Analyze(THaEvData *evdata)
     
     UInt_t *datacopy = new UInt_t[evlen];
     fDelayedEvents.push_back(datacopy);
-    for(Int_t i=0;i<evlen;i++) {
-      datacopy[i] = rdata[i];
-    }
+    memcpy(datacopy,rdata,evlen*sizeof(UInt_t));
     return 1;
   } else { 			// A normal event
     if (fDebugFile) *fDebugFile<<"\n\nTHcScalerEvtHandler :: Debugging event type "<<dec<<evdata->GetEvType()<< " event num = " << evdata->GetEvNum() << endl<<endl;
@@ -536,7 +554,7 @@ Int_t THcScalerEvtHandler::AnalyzeBuffer(UInt_t* rdata, Bool_t onlysync)
       UInt_t scaldata = scalers[idx]->GetData(ichan);
       if ( scal_current > fbcm_Current_Threshold) {
 	UInt_t diff;
-	if(scaldata < scal_prev_read[nscal-1]) {
+	if(scaldata < dvars_prev_read[ivar]) {
 	  diff = (kMaxUInt-(dvars_prev_read[ivar] - 1)) + scaldata;
 	} else {
 	  diff = scaldata - dvars_prev_read[ivar];
@@ -587,6 +605,9 @@ THaAnalysisObject::EStatus THcScalerEvtHandler::Init(const TDatime& date)
   fStatus = kOK;
   fNormIdx = -1;
 
+  for( vector<UInt_t*>::iterator it = fDelayedEvents.begin();
+       it != fDelayedEvents.end(); ++it )
+    delete [] *it;
   fDelayedEvents.clear();
 
   //cout << "Howdy !  We are initializing THcScalerEvtHandler !!   name =   "
diff --git a/src/THcScalerEvtHandler.h b/src/THcScalerEvtHandler.h
index a2bb4da130a321f1c7936ebf3895744896499699..78dd315afbc98dbe6c7ac22063f41df96ae3ed0a 100644
--- a/src/THcScalerEvtHandler.h
+++ b/src/THcScalerEvtHandler.h
@@ -27,7 +27,7 @@ class HCScalerLoc { // Utility class used by THcScalerEvtHandler
 	      UInt_t iki, Int_t iv) :
    name(nm), description(desc), index(idx), islot(s1), ichan(ich),
    ikind(iki), ivar(iv) { };
-  ~HCScalerLoc();
+  ~HCScalerLoc() {}
   TString name, description;
   UInt_t index, islot, ichan, ikind, ivar;
 };
diff --git a/src/THcScintillatorPlane.cxx b/src/THcScintillatorPlane.cxx
index 38033103faf6282a290bc04b300eea391a3faa2b..175ab79d04d556d24da87c1591bf99a7572abff4 100644
--- a/src/THcScintillatorPlane.cxx
+++ b/src/THcScintillatorPlane.cxx
@@ -33,7 +33,30 @@ THcScintillatorPlane::THcScintillatorPlane( const char* name,
 					    const char* description,
 					    const Int_t planenum,
 					    THaDetectorBase* parent )
-: THaSubDetector(name,description,parent)
+: THaSubDetector(name,description,parent),
+  fParentHitList(0), frPosAdcErrorFlag(0), frNegAdcErrorFlag(0),
+  frPosTDCHits(0), frNegTDCHits(0), frPosADCHits(0), frNegADCHits(0),
+  frPosADCSums(0), frNegADCSums(0), frPosADCPeds(0), frNegADCPeds(0),
+  fHodoHits(0), frPosTdcTimeRaw(0), frPosAdcPedRaw(0),
+  frPosAdcPulseIntRaw(0), frPosAdcPulseAmpRaw(0),
+  frPosAdcPulseTimeRaw(0), frPosTdcTime(0), frPosAdcPed(0),
+  frPosAdcPulseInt(0), frPosAdcPulseAmp(0), frPosAdcPulseTime(0),
+  frNegTdcTimeRaw(0), frNegAdcPedRaw(0), frNegAdcPulseIntRaw(0),
+  frNegAdcPulseAmpRaw(0), frNegAdcPulseTimeRaw(0), frNegTdcTime(0),
+  frNegAdcPed(0), frNegAdcPulseInt(0), frNegAdcPulseAmp(0),
+  frNegAdcPulseTime(0), fPosCenter(0), fHodoPosMinPh(0),
+  fHodoNegMinPh(0), fHodoPosPhcCoeff(0), fHodoNegPhcCoeff(0),
+  fHodoPosTimeOffset(0), fHodoNegTimeOffset(0), fHodoVelLight(0),
+  fHodoPosInvAdcOffset(0), fHodoNegInvAdcOffset(0),
+  fHodoPosAdcTimeWindowMin(0), fHodoPosAdcTimeWindowMax(0),
+  fHodoNegAdcTimeWindowMin(0), fHodoNegAdcTimeWindowMax(0),
+  fHodoPosInvAdcLinear(0), fHodoNegInvAdcLinear(0),
+  fHodoPosInvAdcAdc(0), fHodoNegInvAdcAdc(0), fHodoVelFit(0),
+  fHodoCableFit(0), fHodo_LCoeff(0), fHodoPos_c1(0), fHodoNeg_c1(0),
+  fHodoPos_c2(0), fHodoNeg_c2(0), fHodoSigma(0), fPosPedSum(0),
+  fPosPedSum2(0), fPosPedLimit(0), fPosPedCount(0), fNegPedSum(0),
+  fNegPedSum2(0), fNegPedLimit(0), fNegPedCount(0), fPosPed(0),
+  fPosSig(0), fPosThresh(0), fNegPed(0), fNegSig(0), fNegThresh(0)
 {
   // Normal constructor with name and description
   fHodoHits = new TClonesArray("THcHodoHit",16);
@@ -77,14 +100,14 @@ THcScintillatorPlane::THcScintillatorPlane( const char* name,
   fPlaneNum = planenum;
   fTotPlanes = planenum;
   fNScinHits = 0;
-
-  fPosCenter = NULL;
 }
 
 //______________________________________________________________________________
 THcScintillatorPlane::~THcScintillatorPlane()
 {
   // Destructor
+  if( fIsSetup )
+    RemoveVariables();
   delete  frPosAdcErrorFlag; frPosAdcErrorFlag = NULL;
   delete  frNegAdcErrorFlag; frNegAdcErrorFlag = NULL;
 
@@ -122,7 +145,7 @@ THcScintillatorPlane::~THcScintillatorPlane()
   delete frNegAdcPulseAmp;
   delete frNegAdcPulseTime;
 
-  delete [] fPosCenter;
+  delete [] fPosCenter; fPosCenter = 0;
 
   delete [] fHodoPosMinPh; fHodoPosMinPh = NULL;
   delete [] fHodoNegMinPh; fHodoNegMinPh = NULL;
@@ -153,6 +176,18 @@ THcScintillatorPlane::~THcScintillatorPlane()
   delete [] fHodoVelLight; fHodoVelLight = NULL;
   delete [] fHodoSigma; fHodoSigma = NULL;
 
+  delete [] fPosPedSum; fPosPedSum = 0;
+  delete [] fPosPedSum2; fPosPedSum2 = 0;
+  delete [] fPosPedLimit; fPosPedLimit = 0;
+  delete [] fPosPedCount; fPosPedCount = 0;
+  delete [] fNegPedSum; fNegPedSum = 0;
+  delete [] fNegPedSum2; fNegPedSum2 = 0;
+  delete [] fNegPedLimit; fNegPedLimit = 0;
+  delete [] fNegPedCount; fNegPedCount = 0;
+  delete [] fPosPed; fPosPed = 0;
+  delete [] fNegPed; fNegPed = 0;
+  delete [] fPosThresh; fPosThresh = 0;
+  delete [] fNegThresh; fNegThresh = 0;
 }
 
 //______________________________________________________________________________
diff --git a/src/THcShower.cxx b/src/THcShower.cxx
index fd5fd0195348e9fa365b098f9794b85a9341ae48..b7d6590ed4b4dc9eaba61261f0c8ed1e95a829fd 100644
--- a/src/THcShower.cxx
+++ b/src/THcShower.cxx
@@ -19,19 +19,26 @@
 #include "TClonesArray.h"
 #include "THaTrackProj.h"
 #include "TMath.h"
+#include "Helper.h"
 
 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include <numeric>
+#include <cassert>
 
 using namespace std;
 
 //_____________________________________________________________________________
 THcShower::THcShower( const char* name, const char* description,
 				  THaApparatus* apparatus ) :
-  hcana::ConfigLogging<THaNonTrackingDetector>(name,description,apparatus)
+  hcana::ConfigLogging<THaNonTrackingDetector>(name,description,apparatus),
+  fPosAdcTimeWindowMin(0), fNegAdcTimeWindowMin(0),
+  fPosAdcTimeWindowMax(0), fNegAdcTimeWindowMax(0),
+  fShPosPedLimit(0), fShNegPedLimit(0), fPosGain(0), fNegGain(0),
+  fClusterList(0), fLayerNames(0), fLayerZPos(0), BlockThick(0),
+  fNBlocks(0), fXPos(0), fYPos(0), fZPos(0), fPlanes(0), fArray(0)
 {
   // Constructor
   fNLayers = 0;			// No layers until we make them
@@ -43,7 +50,12 @@ THcShower::THcShower( const char* name, const char* description,
 
 //_____________________________________________________________________________
 THcShower::THcShower( ) :
-  hcana::ConfigLogging<THaNonTrackingDetector>()
+  hcana::ConfigLogging<THaNonTrackingDetector>(),
+  fPosAdcTimeWindowMin(0), fNegAdcTimeWindowMin(0),
+  fPosAdcTimeWindowMax(0), fNegAdcTimeWindowMax(0),
+  fShPosPedLimit(0), fShNegPedLimit(0), fPosGain(0), fNegGain(0),
+  fClusterList(0), fLayerNames(0), fLayerZPos(0), BlockThick(0),
+  fNBlocks(0), fXPos(0), fYPos(0), fZPos(0), fPlanes(0), fArray(0)
 {
   // Constructor
 }
@@ -572,14 +584,24 @@ THcShower::~THcShower()
 {
   // Destructor. Remove variables from global list.
 
+  Clear();
   if( fIsSetup )
     RemoveVariables();
   if( fIsInit )
     DeleteArrays();
-  if (fTrackProj) {
-    fTrackProj->Clear();
-    delete fTrackProj; fTrackProj = 0;
+
+  for (THcShowerClusterListIt i=fClusterList->begin(); i!=fClusterList->end();
+       ++i) {
+    Podd::DeleteContainer(**i);
+    delete *i;
+  }
+  delete fClusterList; fClusterList = 0;
+
+  for( UInt_t i = 0; i<fNLayers; ++i) {
+    delete fPlanes[i];
   }
+  delete [] fPlanes; fPlanes = 0;
+  delete fArray; fArray = 0;
 }
 
 //_____________________________________________________________________________
@@ -587,10 +609,25 @@ void THcShower::DeleteArrays()
 {
   // Delete member arrays. Used by destructor.
 
+  for (UInt_t i = 0; i<fNTotLayers; ++i)
+    delete [] fLayerNames[i];
+  delete [] fLayerNames; fLayerNames = 0;
+
+  delete [] fPosAdcTimeWindowMin; fPosAdcTimeWindowMin = 0;
+  delete [] fNegAdcTimeWindowMin; fNegAdcTimeWindowMin = 0;
+  delete [] fPosAdcTimeWindowMax; fPosAdcTimeWindowMax = 0;
+  delete [] fNegAdcTimeWindowMax; fNegAdcTimeWindowMax = 0;
+  delete [] fShPosPedLimit; fShPosPedLimit = 0;
+  delete [] fShNegPedLimit; fShNegPedLimit = 0;
+  delete [] fPosGain; fPosGain = 0;
+  delete [] fNegGain; fNegGain = 0;
   delete [] BlockThick;  BlockThick = NULL;
   delete [] fNBlocks;  fNBlocks = NULL;
   delete [] fLayerZPos;  fLayerZPos = NULL;
+  for (UInt_t i = 0; i<fNLayers; ++i)
+    delete [] fXPos[i];
   delete [] fXPos;  fXPos = NULL;
+  delete [] fYPos;  fYPos = NULL;
   delete [] fZPos;  fZPos = NULL;
 }
 
@@ -635,11 +672,10 @@ void THcShower::Clear(Option_t* opt)
 
   for (THcShowerClusterListIt i=fClusterList->begin(); i!=fClusterList->end();
        ++i) {
+    Podd::DeleteContainer(**i);
     delete *i;
-    *i = 0;
   }
   fClusterList->clear();
-
 }
 
 //_____________________________________________________________________________
@@ -766,6 +802,7 @@ Int_t THcShower::CoarseProcess( TClonesArray& tracks)
   // Fill list of clusters.
 
   ClusterHits(HitSet, fClusterList);
+  assert( HitSet.empty() );  // else bug in ClusterHits()
 
   fNclust = (*fClusterList).size();   //number of clusters
 
diff --git a/src/THcShower.h b/src/THcShower.h
index 5c102fc23f0d3c0ff50175736557e26e246f753c..7bbab5f8e911646bd9cc953190f302336651054b 100644
--- a/src/THcShower.h
+++ b/src/THcShower.h
@@ -270,8 +270,6 @@ protected:
   THcShowerPlane** fPlanes;     // [fNLayers] Shower Plane objects
   THcShowerArray* fArray;
 
-  TClonesArray*  fTrackProj;    // projection of track onto plane
-
   void           ClearEvent();
   void           DeleteArrays();
   virtual Int_t  ReadDatabase( const TDatime& date );
diff --git a/src/THcShowerArray.cxx b/src/THcShowerArray.cxx
index 2efd325caaeca442f5dd1e0019de1cada25971a7..4c5fedf5269b6161f65705e9640ff507613a35a1 100644
--- a/src/THcShowerArray.cxx
+++ b/src/THcShowerArray.cxx
@@ -20,12 +20,13 @@
 #include "THaTrackProj.h"
 #include "THcCherenkov.h"         //for efficiency calculations
 #include "THcHallCSpectrometer.h"
+#include "Helper.h"
 
 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
-
+#include <cassert>
 #include <fstream>
 
 using namespace std;
@@ -61,11 +62,15 @@ THcShowerArray::~THcShowerArray()
 {
   // Destructor
 
+  Clear(); // deletes allocations in fClusterList
   for (UInt_t i=0; i<fNRows; i++) {
     delete [] fXPos[i];
     delete [] fYPos[i];
     delete [] fZPos[i];
   }
+  delete [] fXPos; fXPos = 0;
+  delete [] fYPos; fYPos = 0;
+  delete [] fZPos; fZPos = 0;
 
   delete [] fPedLimit;
   delete [] fGain;
@@ -95,6 +100,11 @@ THcShowerArray::~THcShowerArray()
 
   //delete [] fE;
   delete [] fBlock_ClusterID;
+
+  delete fClusterList; fClusterList = 0;
+
+  delete [] fAdcTimeWindowMin; fAdcTimeWindowMin = 0;
+  delete [] fAdcTimeWindowMax; fAdcTimeWindowMax = 0;
 }
 
 //_____________________________________________________________________________
@@ -479,8 +489,8 @@ void THcShowerArray::Clear( Option_t* )
 
   for (THcShowerClusterListIt i=fClusterList->begin(); i!=fClusterList->end();
        ++i) {
+    Podd::DeleteContainer(**i);
     delete *i;
-    *i = 0;
   }
   fClusterList->clear();
 
@@ -570,6 +580,7 @@ Int_t THcShowerArray::CoarseProcess( TClonesArray& tracks )
   // Cluster hits and fill list of clusters.
 
   static_cast<THcShower*>(fParent)->ClusterHits(HitSet, fClusterList);
+  assert( HitSet.empty() );  // else bug in ClusterHits()
 
   fNclust = (*fClusterList).size();         //number of clusters
 
diff --git a/src/main.C b/src/main.C
index 329c92e6c5066977e162dfd300a008c82cb88009..a82bae7381c05cb81a5d4309ca550e8c0c16f23f 100644
--- a/src/main.C
+++ b/src/main.C
@@ -17,15 +17,13 @@ int main(int argc, char **argv)
   // Create a ROOT-style interactive interface
   //
 
-  if (const char* env_p = std::getenv("DB_DIR")) {
-    std::cout << "Your DB_DIR is: " << env_p << '\n';
-  } else {
+  if (!std::getenv("DB_DIR")) {
     std::string db_dir_env = "DBASE";
     if (setenv("DB_DIR", db_dir_env.c_str(), 1)) {
       std::cout << "Failed to set env var DB_DIR\n";
-      std::exit(EXIT_FAILURE);
+    } else {
+      std::cout << "DB_DIR set to DBASE\n";
     }
-    std::cout << "DB_DIR set to DBASE\n";
   }
 
   // Handle convenience command line options