diff --git a/UserTools/EBPMT/EBPMT.cpp b/UserTools/EBPMT/EBPMT.cpp
index cc160819f..99b0b1136 100644
--- a/UserTools/EBPMT/EBPMT.cpp
+++ b/UserTools/EBPMT/EBPMT.cpp
@@ -40,17 +40,17 @@ bool EBPMT::Initialise(std::string configfile, DataModel &data)
 bool EBPMT::Execute()
 {
   m_data->CStore.Get("RunCode", currentRunCode);
+  bool gotTankEvents = m_data->CStore.Get("FinishedTankEvents", FinishedTankEvents);
   bool gotHits = m_data->CStore.Get("InProgressHits", InProgressHits);
   bool gotChkey = m_data->CStore.Get("InProgressChkey", InProgressChkey);
 
-    if (!gotHits || !gotChkey)
+  if (!gotTankEvents || !gotHits || !gotChkey)
   {
-    Log("EBPMT: No InProgressHits or InProgressChkey found", v_message, verbosityEBPMT);
+    Log("EBPMT: No FinishedTankEvents or InProgressHits or InProgressChkey found", v_message, verbosityEBPMT);
     return true;
   }
-  Log("EBPMT: got inprogress hits and chkey with size " + std::to_string(InProgressHits->size()) + " and " + std::to_string(InProgressChkey->size()), v_message, verbosityEBPMT);
-
-
+  Log("EBPMT: got inprogress tank events, hits and chkey with size " + std::to_string(FinishedTankEvents->size()) + ", " + std::to_string(InProgressHits->size()) 
+      + " and " + std::to_string(InProgressChkey->size()), v_message, verbosityEBPMT);
 
   if (exeNum % 80 == 0 && exeNum != 0)
   {
@@ -62,6 +62,7 @@ bool EBPMT::Execute()
     m_data->CStore.Get("InProgressRecoADCHitsAux", InProgressRecoADCHitsAux);
 
     CorrectVMEOffset();
+    m_data->CStore.Set("FinishedTankEvents", FinishedTankEvents);
     m_data->CStore.Set("InProgressHits", InProgressHits);
     m_data->CStore.Set("InProgressChkey", InProgressChkey);
     m_data->CStore.Set("InProgressHitsAux", InProgressHitsAux);
@@ -415,6 +416,12 @@ void EBPMT::CorrectVMEOffset()
   // loop timestamps，对于每一个时间戳，检查它与它之前的时间戳的差值是否是8或者16
   // 如果是，获得InProgressHits在这两个时间戳上的map的size
   // 在timestamps_to_shift中记录pair，第一个时间戳是size较小的那个，第二个是较大的那个
+  
+  // Comment in English using AI
+  // Loop over the timestamps. For each one, check whether its difference from the previous timestamp is 8 or 16 ns.
+  // If so, get the size of the InProgressHits map at both timestamps.
+  // Record the pair in timestamps_to_shift: first the timestamp with the smaller map, then the one with the larger map.
+
   for (int i = 1; i < timestamps.size(); i++)
   {
     uint64_t dt = (timestamps[i] > timestamps[i - 1]) ? (timestamps[i] - timestamps[i - 1]) : (timestamps[i - 1] - timestamps[i]);
@@ -487,6 +494,20 @@ void EBPMT::CorrectVMEOffset()
       (*InProgressRecoADCHitsAux)[LargerMapTS] = SecondRecoADCHitsAux;
       InProgressRecoADCHitsAux->erase(SmallerMapTS);
 
+      if (FinishedTankEvents != nullptr && FinishedTankEvents->count(SmallerMapTS) > 0) {
+              std::map<std::vector<int>, std::vector<uint16_t>> FirstRaw = FinishedTankEvents->at(SmallerMapTS);
+              std::map<std::vector<int>, std::vector<uint16_t>> SecondRaw;
+              
+              if (FinishedTankEvents->count(LargerMapTS) > 0) {
+                  SecondRaw = FinishedTankEvents->at(LargerMapTS);
+              }
+              
+              SecondRaw.insert(FirstRaw.begin(), FirstRaw.end());
+              
+              (*FinishedTankEvents)[LargerMapTS] = SecondRaw;
+              FinishedTankEvents->erase(SmallerMapTS);
+      }
+
       if (saveRWMWaveforms)
       {
         // if found SmallerMapTS in RWMRawWaveforms, then change it to LargerMapTS
diff --git a/UserTools/EBPMT/EBPMT.h b/UserTools/EBPMT/EBPMT.h
index 9065ef439..c43ecd440 100644
--- a/UserTools/EBPMT/EBPMT.h
+++ b/UserTools/EBPMT/EBPMT.h
@@ -15,6 +15,8 @@
  * $Date: 2024/04 $
  * Contact: yuef@iaistate.edu
  *
+ * Updated by: Anuj Gupta (2026.09.25)
+ *
  */
 
 class EBPMT : public Tool
@@ -45,6 +47,7 @@ class EBPMT : public Tool
     std::map<uint64_t, std::vector<unsigned long>> *InProgressChkey;                 // Key: {MTCTime}, value: vector of in progress chankeys
 
     // only used for VME offset correction
+    std::map<uint64_t, std::map<std::vector<int>, std::vector<uint16_t>>>* FinishedTankEvents = nullptr;     // Key: {MTCTime}, value: map of raw, uncalibrated waveforms
     std::map<uint64_t, std::map<unsigned long, std::vector<Hit>> *> *InProgressHitsAux;                        // Key: {MTCTime}, value: map of  Hit distributions
     std::map<uint64_t, std::map<unsigned long, std::vector<std::vector<ADCPulse>>>> *InProgressRecoADCHits;    // Key: {MTCTime}, value: map of found pulses
     std::map<uint64_t, std::map<unsigned long, std::vector<std::vector<ADCPulse>>>> *InProgressRecoADCHitsAux; // Key: {MTCTime}, value: map of found pulses
diff --git a/UserTools/EBSaver/EBSaver.cpp b/UserTools/EBSaver/EBSaver.cpp
index 8621243ac..9e45c40b7 100644
--- a/UserTools/EBSaver/EBSaver.cpp
+++ b/UserTools/EBSaver/EBSaver.cpp
@@ -745,6 +745,29 @@ bool EBSaver::SavePMTData(uint64_t PMTTime)
     Log("EBSaver: Merged PMT data, PMTHits size " + std::to_string(PMTHits->size()), v_debug, verbosityEBSaver);
   }
 
+  if (FinishedTankEvents != nullptr && FinishedTankEvents->count(PMTTime) > 0)
+  {
+    std::map<std::vector<int>, std::vector<uint16_t>> RawMap = FinishedTankEvents->at(PMTTime);
+    std::map<std::vector<int>, std::vector<Waveform<uint16_t>>> RawWaveformMap;
+
+    ANNIEEvent->Get("RawWaveformMap", RawWaveformMap);            // keep waveforms already in this event, otherwise the map will be empty
+
+    for (const auto& apair : RawMap) {
+        Waveform<uint16_t> TheWave(static_cast<double>(PMTTime), apair.second);
+        RawWaveformMap[apair.first].push_back(TheWave);
+    }
+
+    ANNIEEvent->Set("RawWaveformMap", RawWaveformMap);
+    
+    // Erase to prevent memory leaks as we build events
+    FinishedTankEvents->erase(PMTTime);
+    Log("EBSaver: Saved RawWaveformMap of size " + std::to_string(RawMap.size()) + " with PMTTime " + std::to_string(PMTTime), v_message, verbosityEBSaver);
+  }
+  else
+  {
+    Log("EBSaver: Could not find FinishedTankEvents for PMTTime " + std::to_string(PMTTime), v_warning, verbosityEBSaver);
+  }
+
   ANNIEEvent->Set("Hits", PMTHits, true);
   ANNIEEvent->Set("RecoADCData", PMTRecoADCHits);
   ANNIEEvent->Set("AuxHits", PMTHitsAux, true);
@@ -1029,6 +1052,7 @@ bool EBSaver::SaveOrphanLAPPD(int runCode)
 bool EBSaver::GotAllDataFromOriginalBuffer()
 {
   // got PMT data
+  bool gotRawTankEvents = m_data->CStore.Get("FinishedTankEvents", FinishedTankEvents);
   bool gotPMTHits = m_data->CStore.Get("InProgressHits", InProgressHits);
   bool gotPMTChkey = m_data->CStore.Get("InProgressChkey", InProgressChkey);
   bool gotIPRecoADCHits = m_data->CStore.Get("InProgressRecoADCHits", InProgressRecoADCHits);
@@ -1038,10 +1062,12 @@ bool EBSaver::GotAllDataFromOriginalBuffer()
   bool gotRWM = m_data->CStore.Get("RWMRawWaveforms", RWMRawWaveforms);
   bool gotBRF = m_data->CStore.Get("BRFRawWaveforms", BRFRawWaveforms);
 
-  if (!gotPMTHits || !gotPMTChkey || !gotIPRecoADCHits || !gotIPHitsAux || !gotIPRADCH || !gotFRAS)
+  if (!gotRawTankEvents || !gotPMTHits || !gotPMTChkey || !gotIPRecoADCHits || !gotIPHitsAux || !gotIPRADCH || !gotFRAS)
   {
     Log("EBSaver: Failed to get some PMT data from buffer", v_message, verbosityEBSaver);
     // print which one was failed
+    if (!gotRawTankEvents)
+      Log("EBSaver: Failed to get raw PMT Waveforms from buffer", v_message, verbosityEBSaver);
     if (!gotPMTHits)
       Log("EBSaver: Failed to get PMT hits from buffer", v_message, verbosityEBSaver);
     if (!gotPMTChkey)
@@ -1179,6 +1205,7 @@ void EBSaver::SetDataObjects()
 {
   // after erase those data, set them back to CStore
   // set PMT data
+  m_data->CStore.Set("FinishedTankEvents", FinishedTankEvents);
   m_data->CStore.Set("InProgressHits", InProgressHits);
   m_data->CStore.Set("InProgressChkey", InProgressChkey);
   m_data->CStore.Set("InProgressRecoADCHits", InProgressRecoADCHits);
@@ -1229,12 +1256,14 @@ void EBSaver::SetDataObjects()
 
 void EBSaver::BuildEmptyPMTData()
 {
+  std::map<std::vector<int>, std::vector<Waveform<uint16_t>>> RawWaveformMap;
   std::map<unsigned long, std::vector<Hit>> *PMTHits = new std::map<unsigned long, std::vector<Hit>>;
   std::map<unsigned long, std::vector<std::vector<ADCPulse>>> PMTRecoADCHits;
   std::map<unsigned long, std::vector<Hit>> *PMTHitsAux = new std::map<unsigned long, std::vector<Hit>>;
   std::map<unsigned long, std::vector<std::vector<ADCPulse>>> PMTRecoADCHitsAux;
   std::map<unsigned long, std::vector<int>> PMTRawAcqSize;
 
+  ANNIEEvent->Set("RawWaveformMap", RawWaveformMap);
   ANNIEEvent->Set("Hits", PMTHits, true);
   ANNIEEvent->Set("RecoADCData", PMTRecoADCHits);
   ANNIEEvent->Set("AuxHits", PMTHitsAux, true);
diff --git a/UserTools/EBSaver/EBSaver.h b/UserTools/EBSaver/EBSaver.h
index 70dc6a96d..1b779fe83 100644
--- a/UserTools/EBSaver/EBSaver.h
+++ b/UserTools/EBSaver/EBSaver.h
@@ -24,6 +24,8 @@
  * $Date: 2024/04 $
  * Contact: yuef@iaistate.edu
  *
+ * Updated by: Anuj Gupta (2026.09.25)
+ *
  */
 
 class EBSaver : public Tool
@@ -131,6 +133,8 @@ class EBSaver : public Tool
     int PPSMain;
 
     // PMT related data object
+    std::map<uint64_t, std::map<std::vector<int>, std::vector<uint16_t>>>* FinishedTankEvents = nullptr;     // Key: {MTCTime}, value: map of raw, uncalibrated waveforms
+
     std::map<uint64_t, std::map<unsigned long, std::vector<Hit>> *> *InProgressHits;                           // Key: {MTCTime}, value: map of  Hit distributions
     std::map<uint64_t, std::vector<unsigned long>> *InProgressChkey;                                           // Key: {MTCTime}, value: vector of in progress chankeys
     std::map<uint64_t, std::map<unsigned long, std::vector<std::vector<ADCPulse>>>> *InProgressRecoADCHits;    // Key: {MTCTime}, value: map of found pulses
diff --git a/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.cpp b/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.cpp
index bcca11115..0b1a3c0ef 100644
--- a/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.cpp
+++ b/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.cpp
@@ -155,131 +155,166 @@ bool PhaseIIADCCalibrator::Execute() {
   
   Log("PhaseIIADCCalibrator Tool: Executing", v_message, verbosity);
 
-
   //ANNIEEvent mode
   if (eventbuilding_mode == false){
 
-  // Get a pointer to the ANNIEEvent Store
-  auto* annie_event = m_data->Stores["ANNIEEvent"];
+      // Get a pointer to the ANNIEEvent Store
+      auto* annie_event = m_data->Stores["ANNIEEvent"];
 
-  if (!annie_event) {
-    Log("Error: The PhaseIIADCCalibrator tool could not find the ANNIEEvent Store", 0,
-      verbosity);
-    return false;
-  }
+      if (!annie_event) {
+          Log("Error: The PhaseIIADCCalibrator tool could not find the ANNIEEvent Store", v_error, verbosity);
+          return false;
+      }
 
-  // Load the map containing the ADC raw waveform data
-  std::map<unsigned long, std::vector<Waveform<unsigned short> > >
-    raw_waveform_map;
-  // Load the map containing the ADC raw waveform data
-  std::map<unsigned long, std::vector<Waveform<unsigned short> > >
-    raw_auxwaveform_map;
-
-  bool got_raw_data = annie_event->Get("RawADCData", raw_waveform_map);
-  bool got_rawaux_data = annie_event->Get("RawADCAuxData", raw_auxwaveform_map);
-
-  // Check for problems
-  if ( !got_raw_data ) {
-    Log("Error: The PhaseIIADCCalibrator tool could not find the RawADCData entry", 0,
-      verbosity);
-    return false;
-  }
-  else if ( raw_waveform_map.empty() ) {
-    Log("Error: The PhaseIIADCCalibrator tool found an empty RawADCData entry", 0,
-      verbosity);
-    return false;
-  }
+      std::map<unsigned long, std::vector<Waveform<uint16_t>> > RawADCData;
+      std::map<unsigned long, std::vector<Waveform<uint16_t>> > RawADCAuxData;
 
+      std::map<std::vector<int>, std::vector<Waveform<uint16_t>>> RawWaveformMap;
+      bool gotRawWaveformMap = annie_event->Get("RawWaveformMap", RawWaveformMap);
+
+      if (!gotRawWaveformMap) {
+          Log("Error: PhaseIIADCCalibrator could not find 'RawWaveformMap'.", v_error, verbosity);
+          return false;
+      } else if (RawWaveformMap.empty()) {
+          Log("Warning: PhaseIIADCCalibrator found an empty 'RawWaveformMap'.", v_debug, verbosity);
+         
+          annie_event->Set("RawADCData", RawADCData);
+          annie_event->Set("RawADCAuxData", RawADCAuxData);
+ 
+          return true;
+      }
 
+      for (auto& apair : RawWaveformMap) {
+          int CardID = apair.first.at(0);
+          int ChannelID = apair.first.at(1);
+          
+          int CrateNum = -1;
+          int SlotNum = -1;
+          this->CardIDToElectronicsSpace(CardID, CrateNum, SlotNum);
+          std::vector<int> CrateSpace{CrateNum, SlotNum, ChannelID};
+          
+          unsigned long ChannelKey;
+          const std::vector<Waveform<unsigned short>>& WaveVec = apair.second;
+
+          if (TankPMTCrateSpaceToChannelNumMap.count(CrateSpace) > 0) {
+              ChannelKey = TankPMTCrateSpaceToChannelNumMap.at(CrateSpace);
+              RawADCData.emplace(ChannelKey, WaveVec);
+          } 
+          else if (AuxCrateSpaceToChannelNumMap.count(CrateSpace) > 0) {
+              ChannelKey = AuxCrateSpaceToChannelNumMap.at(CrateSpace);
+              RawADCAuxData.emplace(ChannelKey, WaveVec);
+          } 
+          else {
+              Log("PhaseIIADCCalibrator:: Cannot find channel key for Card " + std::to_string(CardID) + 
+                  " Ch " + std::to_string(ChannelID), v_error, verbosity);
+              continue;
+          }
+      }
 
-  // Build the calibrated waveforms
-  std::map<unsigned long, std::vector<CalibratedADCWaveform<double> > >
-    calibrated_waveform_map;
-  // Build the calibrated waveforms
-  std::map<unsigned long, std::vector<CalibratedADCWaveform<double> > >
-    calibrated_auxwaveform_map;
-
-  // Load the map containing the ADC raw waveform data
-  std::map<unsigned long, std::vector<Waveform<unsigned short> > >
-    raw_led_waveform_map;
-
-  std::map<unsigned long, std::vector<CalibratedADCWaveform<double> > >
-    calibrated_led_waveform_map;
-
-  //Calibrate raw detector waveforms
-  for (const auto& temp_pair : raw_waveform_map) {
-    const auto& channel_key = temp_pair.first;
-    //Default running: raw_waveforms only has one entry.  If we go to a
-    //hefty-mode style of running though, this could have multiple minibuffers
-    const auto& raw_waveforms = temp_pair.second;
-    Log("Making calibrated waveforms for ADC channel " +
-      std::to_string(channel_key), 3, verbosity);
-
-    if(BEType == "ze3ra"){
-      calibrated_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra(raw_waveforms);
-    } else if(BEType == "ze3ra_multi"){
-      calibrated_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra_multi(raw_waveforms);
-    } else if(BEType == "rootfit"){
-      calibrated_waveform_map[channel_key] = make_calibrated_waveforms_rootfit(raw_waveforms);
-    } else if (BEType == "simple"){
-      calibrated_waveform_map[channel_key] = make_calibrated_waveforms_simple(raw_waveforms);
-    }
+      /*
+      // Load the map containing the ADC raw waveform data
+      std::map<unsigned long, std::vector<Waveform<unsigned short>>> raw_waveform_map;
+      std::map<unsigned long, std::vector<Waveform<unsigned short>>> raw_auxwaveform_map;
+
+      bool got_raw_data = annie_event->Get("RawADCData", raw_waveform_map);
+      bool got_rawaux_data = annie_event->Get("RawADCAuxData", raw_auxwaveform_map);
 
-    if(make_led_waveforms){
-      Log("Also making LED window waveforms for ADC channel " +
-        std::to_string(channel_key), 3, verbosity);
-      std::vector<Waveform<unsigned short>> LEDWaveforms;
-      this->make_raw_led_waveforms(channel_key,raw_waveforms,LEDWaveforms);
-      raw_led_waveform_map.emplace(channel_key,LEDWaveforms);
-      if(BEType == "ze3ra"){
-        calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra(LEDWaveforms);
-      } else if(BEType == "ze3ra_multi"){
-        calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra_multi(LEDWaveforms);
-      } else if(BEType == "rootfit"){
-        calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_rootfit(LEDWaveforms);
-      } else if(BEType == "simple"){
-        calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_simple(LEDWaveforms);
+      // Check for problems
+      if ( !got_raw_data ) {
+          Log("Error: The PhaseIIADCCalibrator tool could not find the RawADCData entry", v_warning, verbosity);
+          return false;
+      }
+      else if ( raw_waveform_map.empty() ) {
+          Log("Error: The PhaseIIADCCalibrator tool found an empty RawADCData entry", v_warning, verbosity);
+          return false;
+      }
+      */
+
+      // Build the calibrated waveforms
+      std::map<unsigned long, std::vector<CalibratedADCWaveform<double>>> calibrated_waveform_map;
+      std::map<unsigned long, std::vector<CalibratedADCWaveform<double>>> calibrated_auxwaveform_map;
+
+      // Load the map containing the ADC raw waveform data
+      std::map<unsigned long, std::vector<Waveform<unsigned short>>> raw_led_waveform_map;
+      std::map<unsigned long, std::vector<CalibratedADCWaveform<double>>> calibrated_led_waveform_map;
+
+      //Calibrate raw detector waveforms
+      for (const auto& temp_pair : RawADCData) {
+          const auto& channel_key = temp_pair.first;
+          
+          //Default running: raw_waveforms only has one entry.  If we go to a
+          //hefty-mode style of running though, this could have multiple minibuffers
+          const auto& raw_waveforms = temp_pair.second;
+          Log("Making calibrated waveforms for ADC channel " + std::to_string(channel_key), v_debug, verbosity);
+
+          if(BEType == "ze3ra"){
+              calibrated_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra(raw_waveforms);
+          } else if(BEType == "ze3ra_multi"){
+              calibrated_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra_multi(raw_waveforms);
+          } else if(BEType == "rootfit"){
+              calibrated_waveform_map[channel_key] = make_calibrated_waveforms_rootfit(raw_waveforms);
+          } else if (BEType == "simple"){
+              calibrated_waveform_map[channel_key] = make_calibrated_waveforms_simple(raw_waveforms);
+          }
+
+          if(make_led_waveforms){
+            Log("Also making LED window waveforms for ADC channel " + std::to_string(channel_key), v_debug, verbosity);
+            std::vector<Waveform<unsigned short>> LEDWaveforms;
+            this->make_raw_led_waveforms(channel_key,raw_waveforms,LEDWaveforms);
+            raw_led_waveform_map.emplace(channel_key,LEDWaveforms);
+            
+            if(BEType == "ze3ra"){
+                calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra(LEDWaveforms);
+            } else if(BEType == "ze3ra_multi"){
+                calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_ze3ra_multi(LEDWaveforms);
+            } else if(BEType == "rootfit"){
+                calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_rootfit(LEDWaveforms);
+            } else if(BEType == "simple"){
+                calibrated_led_waveform_map[channel_key] = make_calibrated_waveforms_simple(LEDWaveforms);
+            }
+          }
       }
-    }
-  }
   
-  //Calibrate the SIPM waveforms
-  for (const auto& temp_pair : raw_auxwaveform_map) {
-    const auto& channel_key = temp_pair.first;
-    Log("Channel key for Aux channel is " +
-      std::to_string(channel_key), 3, verbosity);
-    //For now, only calibrate the SiPM waveforms
-    Log("Type for Aux channel is " +
-      AuxChannelNumToTypeMap->at(channel_key), 3, verbosity);
-    if(AuxChannelNumToTypeMap->at(channel_key) != "SiPM1" && 
-       AuxChannelNumToTypeMap->at(channel_key) != "SiPM2") continue; 
-    //Default running: raw_waveforms only has one entry.  If we go to a
-    //hefty-mode style of running though, this could have multiple minibuffers
-    const auto& raw_auxwaveforms = temp_pair.second;
-
-    Log("Making calibrated waveforms for Auxiliary channel " +
-      std::to_string(channel_key), 3, verbosity);
-
-    if(BEType == "ze3ra"){
-      calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_ze3ra(raw_auxwaveforms);
-    } else if(BEType == "ze3ra_multi"){
-      calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_ze3ra_multi(raw_auxwaveforms);
-    } else if(BEType == "rootfit"){
-      calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_rootfit(raw_auxwaveforms);
-    } else if (BEType == "simple"){
-      calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_simple(raw_auxwaveforms);
-    }
-  }
+      //Calibrate the SIPM waveforms
+      for (const auto& temp_pair : RawADCAuxData) {
+          const auto& channel_key = temp_pair.first;
+          Log("Channel key for Aux channel is " + std::to_string(channel_key), v_debug, verbosity);
+    
+          //For now, only calibrate the SiPM waveforms
+          Log("Type for Aux channel is " + AuxChannelNumToTypeMap->at(channel_key), v_debug, verbosity);
+          if(AuxChannelNumToTypeMap->at(channel_key) != "SiPM1" && AuxChannelNumToTypeMap->at(channel_key) != "SiPM2") continue; 
+    
+          //Default running: raw_waveforms only has one entry.  If we go to a
+          //hefty-mode style of running though, this could have multiple minibuffers
+          const auto& raw_auxwaveforms = temp_pair.second;
 
-  Log("PhaseIIADCCalibrator Tool: Setting CalibratedADCData",v_debug,verbosity);
-  annie_event->Set("CalibratedADCData", calibrated_waveform_map);
-  annie_event->Set("CalibratedADCAuxData", calibrated_auxwaveform_map);
-  if(make_led_waveforms){
-    std::cout <<"Setting LEDADCData"<<std::endl;
-    annie_event->Set("CalibratedLEDADCData", calibrated_led_waveform_map);
-    annie_event->Set("RawLEDADCData", raw_led_waveform_map);
-  }
-  //std::cout <<"Set CalibratedADCData"<<std::endl;
+          Log("Making calibrated waveforms for Auxiliary channel " + std::to_string(channel_key), v_debug, verbosity);
+
+          if(BEType == "ze3ra"){
+              calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_ze3ra(raw_auxwaveforms);
+          } else if(BEType == "ze3ra_multi"){
+              calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_ze3ra_multi(raw_auxwaveforms);
+          } else if(BEType == "rootfit"){
+              calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_rootfit(raw_auxwaveforms);
+          } else if (BEType == "simple"){
+              calibrated_auxwaveform_map[channel_key] = make_calibrated_waveforms_simple(raw_auxwaveforms);
+          }
+      }
+
+      Log("PhaseIIADCCalibrator Tool: Setting CalibratedADCData",v_debug,verbosity);
+      
+      annie_event->Set("RawADCData", RawADCData);
+      annie_event->Set("RawADCAuxData", RawADCAuxData);
+      annie_event->Set("CalibratedADCData", calibrated_waveform_map);
+      annie_event->Set("CalibratedADCAuxData", calibrated_auxwaveform_map);
+       
+      if(make_led_waveforms){
+          std::cout <<"Setting LEDADCData"<<std::endl;
+          annie_event->Set("CalibratedLEDADCData", calibrated_led_waveform_map);
+          annie_event->Set("RawLEDADCData", raw_led_waveform_map);
+      }
+      //std::cout <<"Set CalibratedADCData"<<std::endl;
+  
   } else {
     //=========================
     //Event Building mode (new)
@@ -490,6 +525,26 @@ bool PhaseIIADCCalibrator::Execute() {
       //std::cout <<"Set CalibratedADCData"<<std::endl;
     }
 
+    m_data->CStore.Get("FinishedTankEvents", FinishedTankEvents);
+    if (FinishedTankEvents == nullptr) {
+        FinishedTankEvents = new std::map<uint64_t, std::map<std::vector<int>, std::vector<uint16_t>>>();
+        m_data->CStore.Set("FinishedTankEvents", FinishedTankEvents);
+    }
+
+    // --- Copy entries about to be erased into the buffer ---
+    for (auto ts : RawTimestampsToDelete) {
+        if (InProgressTankEvents->count(ts) == 0) continue;
+       
+        std::map<std::vector<int>, std::vector<uint16_t>>& raw = (*FinishedTankEvents)[ts];
+        if (!raw.empty()) {
+            Log("PhaseIIADCCalibrator: timestamp " + std::to_string(ts) + " already had raw data, adding " +
+                std::to_string(InProgressTankEvents->at(ts).size()) + " more channels", v_debug, verbosity);
+        }
+
+        for (auto& ch : InProgressTankEvents->at(ts))
+            raw[ch.first] = ch.second;
+    }
+    
     for (int i_del=0; i_del < (int) RawTimestampsToDelete.size(); i_del++){
       //FinishedTankEvents->erase(RawTimestampsToDelete.at(i_del));
       InProgressTankEvents->erase(RawTimestampsToDelete.at(i_del));
diff --git a/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.h b/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.h
index 97483b40f..6fcc13b3f 100644
--- a/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.h
+++ b/UserTools/PhaseIIADCCalibrator/PhaseIIADCCalibrator.h
@@ -102,13 +102,13 @@ class PhaseIIADCCalibrator : public Tool {
  
     //Variables specifically intended for Event Building
     bool eventbuilding_mode = false;
-    //std::map<uint64_t, std::map<std::vector<int>, std::vector<uint16_t> > > *FinishedTankEvents;  //Key: {MTCTime}, value: map of fully-built waveforms from WaveBank
-    std::map<uint64_t, std::map<std::vector<int>, std::vector<uint16_t> > > *InProgressTankEvents;  //Key: {MTCTime}, value: map of fully-built waveforms from WaveBank
-    std::map<uint64_t, std::map<unsigned long,std::vector<Waveform<unsigned short>>>> *FinishedRawWaveforms;	//Key: {MTCTime}, value: map of raw waveforms
+    std::map<uint64_t, std::map<std::vector<int>, std::vector<uint16_t>>> *FinishedTankEvents = nullptr;    //Key: {MTCTime}, value: map of fully-built waveforms from WaveBank
+    std::map<uint64_t, std::map<std::vector<int>, std::vector<uint16_t>>> *InProgressTankEvents = nullptr;  //Key: {MTCTime}, value: map of fully-built waveforms from WaveBank
+    std::map<uint64_t, std::map<unsigned long,std::vector<Waveform<unsigned short>>>> *FinishedRawWaveforms;	 //Key: {MTCTime}, value: map of raw waveforms
     std::map<uint64_t, std::map<unsigned long,std::vector<Waveform<unsigned short>>>> *FinishedRawWaveformsAux;  //Key: {MTCTime}, value: map of raw waveforms (aux channels)
-    std::map<uint64_t, std::map<unsigned long,std::vector<CalibratedADCWaveform<double>>>> *FinishedCalibratedWaveforms;	//Key: {MTCTime}, value: map of calibrated waveforms
+    std::map<uint64_t, std::map<unsigned long,std::vector<CalibratedADCWaveform<double>>>> *FinishedCalibratedWaveforms;     //Key: {MTCTime}, value: map of calibrated waveforms
     std::map<uint64_t, std::map<unsigned long,std::vector<CalibratedADCWaveform<double>>>> *FinishedCalibratedWaveformsAux;  //Key: {MTCTime}, value: map of calibrated waveforms (aux channels)
-    std::map<uint64_t, std::map<unsigned long,std::vector<CalibratedADCWaveform<double>>>> *FinishedCalibratedLEDADCData;  //Key: {MTCTime}, value: map of calibrated waveforms (LED channels)
+    std::map<uint64_t, std::map<unsigned long,std::vector<CalibratedADCWaveform<double>>>> *FinishedCalibratedLEDADCData;    //Key: {MTCTime}, value: map of calibrated waveforms (LED channels)
     std::map<uint64_t, std::map<unsigned long,std::vector<Waveform<unsigned short>>>> *FinishedRawLEDADCData;	//Key: {MTCTime}, value: map of raw LED waveforms
     std::map<uint64_t, std::map<unsigned long,std::vector<int>>> *FinishedRawAcqSize;   // Key: {MTCTime}, value: map 
 
diff --git a/UserTools/PhaseIIADCHitFinder/PhaseIIADCHitFinder.cpp b/UserTools/PhaseIIADCHitFinder/PhaseIIADCHitFinder.cpp
index c77ee2543..2af11fe00 100755
--- a/UserTools/PhaseIIADCHitFinder/PhaseIIADCHitFinder.cpp
+++ b/UserTools/PhaseIIADCHitFinder/PhaseIIADCHitFinder.cpp
@@ -155,9 +155,14 @@ bool PhaseIIADCHitFinder::Execute() {
       return false;
     }
     else if ( raw_waveform_map.empty() && !mc_waveforms ) {
-      Log("Error: The PhaseIIADCHitFinder tool found an empty RawADCData entry", v_error,
-        verbosity);
-      return false;
+      Log("PhaseIIADCHitFinder: empty RawADCData (no tank data in this event)", v_debug, verbosity);
+
+      annie_event->Set("RecoADCHits", pulse_map);
+      annie_event->Set("Hits", hit_map, true);
+      annie_event->Set("RecoADCAuxHits", aux_pulse_map);
+      annie_event->Set("AuxHits", aux_hit_map, true);
+
+      return true;
     }
     
     // Load the maps containing the ADC calibrated waveform data
diff --git a/configfiles/BeamClusterAnalysis/PhaseIIADCCalibratorConfig b/configfiles/BeamClusterAnalysis/PhaseIIADCCalibratorConfig
index a825ba0b1..53187e4b1 100644
--- a/configfiles/BeamClusterAnalysis/PhaseIIADCCalibratorConfig
+++ b/configfiles/BeamClusterAnalysis/PhaseIIADCCalibratorConfig
@@ -1,4 +1,3 @@
-# Dummy config file
 verbosity 0
 
 BaselineEstimationType ze3ra_multi
@@ -9,3 +8,5 @@ SamplesPerBaselineEstimate 2000
 BaselineUncertaintyTolerance 2
 PCritical 0.01
 MakeCalLEDWaveforms 0
+
+EventBuilding 0
diff --git a/configfiles/BeamClusterAnalysis/PhaseIIADCHitFinderConfig b/configfiles/BeamClusterAnalysis/PhaseIIADCHitFinderConfig
index a895c452e..bd127ff08 100644
--- a/configfiles/BeamClusterAnalysis/PhaseIIADCHitFinderConfig
+++ b/configfiles/BeamClusterAnalysis/PhaseIIADCHitFinderConfig
@@ -3,7 +3,8 @@ verbosity 0
 UseLEDWaveforms 0
 
 PulseFindingApproach threshold
-PulseWindowType dynamic
+PulseWindowType NoDoubleHits
 DefaultADCThreshold 7
 DefaultThresholdType relative
 
+EventBuilding 0