diff --git a/CustomGUIv2/controller/MyNewMain.controller.js b/CustomGUIv2/controller/MyNewMain.controller.js
index 10719ca..1b8a910 100644
--- a/CustomGUIv2/controller/MyNewMain.controller.js
+++ b/CustomGUIv2/controller/MyNewMain.controller.js
@@ -108,7 +108,7 @@ sap.ui.define(['rootui5/eve7/controller/Main.controller',
       },
 
       showEventInfo : function() {
-         let tinfo = "Event : " + this.fw2gui.eventid + " Sub Run :" + this.fw2gui.subrunid + " Run :" + this.fw2gui.runid;
+         let tinfo =  " Run :" + this.fw2gui.runid + " Sub Run :" + this.fw2gui.subrunid + "Event : " + this.fw2gui.eventid;
          document.title = tinfo;
          //this.byId("runInput").setValue(this.fw2gui.runid);
          //this.byId("eventInput").setValue(this.fw2gui.eventid);
diff --git a/CustomGUIv2/view/MyMain.view.xml b/CustomGUIv2/view/MyMain.view.xml
index cf2f279..e800d0d 100644
--- a/CustomGUIv2/view/MyMain.view.xml
+++ b/CustomGUIv2/view/MyMain.view.xml
@@ -63,7 +63,7 @@
             <Input id="dateInput" width="100px" />   
               </OverflowToolbar>
         <OverflowToolbar id="otb3">
-            <Label text="test:">
+            <Label text="AutoPlay (plcaeholder):">
                <layoutData>
                   <OverflowToolbarLayoutData priority="Disappear" shrinkable="true" minWidth="40px" />
                </layoutData>
diff --git a/README.md b/README.md
index cd57038..a088f0e 100644
--- a/README.md
+++ b/README.md
@@ -4,53 +4,12 @@ This repo contains the current EventDisplay source code, example fcls, tutorials
 
 The EventDisplay is based on REve which is an updated version of the well-known and widely used TEve ROOT based Event Visualization Software. REve uses modernized infrastcutrue and allows Web Access for remote use.
 
-For more information about REve and the implementation for Mu2e see: https://mu2ewiki.fnal.gov/wiki/Eve7EventDisplay#Examples_of_the_Eve-7_Mu2e_Display.
-
-# Useage
-
-## Sequential on known file
-To use the display to scroll through events sequentially utilize either the ```nominal_example``` for nominal Mu2e geometry or ```extracted_example``` for the extracted geometry and run as you would any other .fcl:
-
-```
-mu2e -c <chosen_geom.fcl> <filename.art>
-```
-
-The current available options for the .fcl are located in the ```examples``` directory. There are four main examples:
-
-* nominal_MDC2020.fcl: with the original CRV geometry, to be used the MDC2020 samples
-* nominal_MDC2025.fcl: with the MDC2025 CRV geometry assuming the common GDML
-* extracted_MDC2020.fcl: for those still using MDC2020 extracted samples, to be retired
-* extracted_MDC2025.fcl: for those doing extracted studies with MDC2025 samples
-* nominal_Run1A.fcl: Run1A CRV geometry MDC2025
-* nominal_Run2.fcl: full CRV geometry, MDC2025
-
-These .fcl can be edited as you wish (adding or removing certain features), they should provide good starting points for any study.
-
-## Go to an given event
-
-There are a number of ways to go from your analysis to a visualized event. Utilities are provided in both rooutils [cite] and pyutils [https://github.com/Mu2e/pyutils/blob/main/pyutils/pydisplay.py]. There is also a custom script in this repo ```config/EventDisplay.sh``` the usage is as follows:
-
-```
-./EventDisplay.sh --run 1201 --subrun 34 --event 15028 --dataset mcs.mu2e.ensembleMDS2cMix1BBTriggered.MDC2020ba_best_v1_3.art
-```
-
-if you know the name of the dataset.
-
-If you are working with an ntuple, you may not know all the commands to figure out its parent mcs. In this case run:
-
-```
-./EventDisplay.sh  --run 1201 --subrun 476 --event 1  --dataset nts.mu2e.ensembleMDS2cMix1BBTriggered.MDC2020ba_best_v1_3_v06_06_00.001201_00000476.root
-```
-
-where the run, subrun and event numbers are identified from your analysis to be an event of interest in that root file.
-
-
-
-# Tutorial
-
-We are in the process of updating our Analysis Tools Tutorial material. In the meantime, please see: https://mu2ewiki.fnal.gov/wiki/EventDisplayTutorial
-
-# Development
-
-This code is still under development by the Mu2e Analysis Tools Group. The development team current consists of Sophie Middleton, Andy Edmonds and Namitha Chithiraseemadam. Please contact us to contribute.
+## Documentation
+
+* [Getting Started](./documentation/GettingStarted.md)
+* [Examples](./documentation/examples.md).
+* [Fcl Options](./documentation/FclOptions.md).
+* [GUI Options](./documentation/GUIOptions.md).
+* [EventNavigation](./documentation/EventNavigation.md).
+* [Data Product Visualizaton](./documentation/DataProductVisualization.md).
 
diff --git a/config/drawutils.txt b/config/drawutils.txt
index ab569ec..9728f82 100644
--- a/config/drawutils.txt
+++ b/config/drawutils.txt
@@ -3,7 +3,7 @@
 int TRKtrans  = 98;
 int CALtrans  = 100;
 int CRYtrans  = 90;
-int CRVtrans  = 98;
+int Crvtrans  = 98;
 int BLtrans  = 90;//BL = beamline elements
 
 int maxlevel = 8; //8=calocrystals, moved to 10 for PA
@@ -15,10 +15,10 @@ int GeomLineWidth = 1;
 int TRKColor = 432; //kCyan = 432
 int CALColor = 432; //kCyan = 432
 int BLColor = 432; //kCyan = 432
-int CRVColor = 432; //kCyan = 432
+int CrvColor = 432; //kCyan = 432
 
-int CRVBarColor = 632;
+int CrvBarColor = 632;
 int RecoTrackColor = 600; //kGreen
-int CRVHitColor = 600; //kBlue
+int CrvHitColor = 600; //kBlue
 int TrkHitColor = 632; //kBlue
 int TrkNoHitColor = 600; //kBlue
diff --git a/config/start_RemoteDisplay.sh b/config/start_RemoteDisplay.sh
new file mode 100644
index 0000000..c8ed57b
--- /dev/null
+++ b/config/start_RemoteDisplay.sh
@@ -0,0 +1,79 @@
+#!/bin/bash
+
+# Initialize variables
+PORT_NUM=""
+MACHINE_ID=""
+USERNAME=""
+
+# --- Function to open browser based on OS ---
+open_browser() {
+    local url=$1
+    case "$(uname -s)" in
+        Darwin)
+            # macOS
+            echo "Detected macOS. Opening Google Chrome..."
+            open -a "Google Chrome" "$url"
+            ;;
+        Linux)
+            # Linux variants
+            echo "Detected Linux. Attempting to open browser..."
+            # Try specific commands for Chrome/Chromium, fall back to xdg-open
+            if command -v google-chrome >/dev/null; then
+                google-chrome "$url"
+            elif command -v chromium-browser >/dev/null; then
+                chromium-browser "$url"
+            else
+                xdg-open "$url"
+            fi
+            ;;
+        CYGWIN*|MINGW*|MSYS*)
+            # Windows (Git Bash/Cygwin)
+            echo "Detected Windows. Opening browser..."
+            cmd.exe /c start "$url"
+            ;;
+        *)
+            echo "Unsupported OS. Please open the URL manually: $url"
+            ;;
+    esac
+}
+
+# --- Parse command-line arguments ---
+while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+        --port)
+            PORT_NUM="$2"
+            shift; shift
+            ;;
+        --machine)
+            MACHINE_ID="$2"
+            shift; shift
+            ;;
+        --user)
+            USERNAME="$2"
+            shift; shift
+            ;;
+        *)
+            echo "Unknown parameter passed: $1"
+            echo "Usage: $0 --port <number> --machine <id> --user <name>"
+            exit 1
+            ;;
+    esac
+done
+
+# --- Validation ---
+if [ -z "$PORT_NUM" ] || [ -z "$MACHINE_ID" ] || [ -z "$USERNAME" ]; then
+    echo "Error: Missing required arguments."
+    echo "Usage: $0 --port <number> --machine <id> --user <name>"
+    echo "Example: $0 --port 1234 --machine 05 --user sophie"
+    exit 1
+fi
+
+# --- Execution ---
+HOSTNAME="mu2egpvm${MACHINE_ID}.fnal.gov"
+URL="http://localhost:${PORT_NUM}/win1/"
+
+open_browser "$URL"
+
+echo "Establishing SSH tunnel for ${USERNAME}@${HOSTNAME} on port ${PORT_NUM}"
+ssh -KXY -L "${PORT_NUM}:localhost:${PORT_NUM}" "${USERNAME}@${HOSTNAME}"
+
diff --git a/documentation/DataProductVisualization.md b/documentation/DataProductVisualization.md
new file mode 100644
index 0000000..541464e
--- /dev/null
+++ b/documentation/DataProductVisualization.md
@@ -0,0 +1,113 @@
+# Data Product Visualization in Mu2e Event Display
+
+This document outlines the purpose and key features of the core C++ functions used in the Mu2e event display to visualize **Monte Carlo (MC)** and **Reconstructed (Reco)** data products. These functions convert abstract data objects into graphical elements using the **ROOT REve** framework, enabling detailed event inspection.
+
+---
+
+## MC Data Visualization
+
+The following function displays simulated particle trajectories.
+
+### $\text{MCInterface::AddMCTrajectoryCollection}$
+
+This function processes collections of $\text{MCTrajectory}$ objects and renders them as colored lines in the detector scene. 
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{MCTrajectoryCollection}$ |
+| **Visualization** | **$\text{REveLine}$** for each trajectory. |
+| **Color Coding** | Line color is assigned based on the **particle's PDG ID** (e.g., electron is red, muon is black). |
+| **Filtering** | Draws only particles whose PDG ID is included in the user-defined $\text{particleIds}$ list. |
+| **Title Info** | Includes **Particle Name**, **SimParticle ID**, **Parent ID**, **Kinetic Energy**, and **Creation/Stopping Codes** for traceability. |
+
+### $\text{MCInterface::AddSurfaceStepCollection}$
+
+This function visualizes points where a $\text{SimParticle}$ crosses a defined detector or virtual surface.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{SurfaceStepCollection}$ |
+| **Visualization** | **$\text{REvePointSet}$** marker at the step's $\text{midPosition}$. |
+| **Color Coding** | Fixed to **kBlack** (in the current implementation) to distinguish them clearly from track lines. |
+| **Filtering** | Draws only steps made by particles whose PDG ID is in the user-defined $\text{particleIds}$ list. |
+| **Title Info** | Includes the **Surface ID name**, step **Position**, **Time**, **Momentum**, and **Energy Deposit** ($\text{edep}$). |
+
+---
+
+## Reconstructed (Reco) Data Visualization
+
+These functions visualize the output of track fitting and hit clustering algorithms.
+
+### $\text{DataInterface::FillKinKalTrajectory}$
+
+This is the main orchestration function for visualizing reconstructed tracks ($\text{KalSeed}$) and their associated products.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{KalSeedPtrCollection}$ |
+| **Action** | Identifies the successful fit type ($\text{LoopHelix}$, $\text{CentralHelix}$, $\text{KinematicLine}$) and calls specialized functions to draw the trajectory and products. |
+| **Output** | Adds a **$\text{REveCompound}$** (**trackproducts**) to the scene, grouping all elements related to a single track. |
+| **Trajectory** | Uses $\text{AddKinKalTrajectory}$ to draw the path based on the chosen fit type. |
+| **Products** | Calls $\text{AddTrkStrawHit}$ (for hits) and $\text{AddKalIntersection}$ (for material/surface crossings). |
+
+### $\text{DataInterface::AddKinKalTrajectory}$
+
+Renders the smooth, mathematical path of a **$\text{KinKal}$ track fit**.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{KinKal}$ Trajectory ($\text{LoopHelix}$, $\text{CentralHelix}$, or $\text{KinematicLine}$) |
+| **Visualization** | **$\text{REveLine}$** generated by sampling the trajectory's equation across its time range at discrete steps ($\text{0.1}$ time units). |
+| **Title Info** | Includes **Particle Name**, **Momentum**, **Fit Parameters** ($\text{lam}$, $\text{rad}$, $\text{omega}$, $\text{d0}$, $\text{z0}$), and **Fit Consistency**. |
+
+### $\text{DataInterface::AddTrkStrawHit}$
+
+Visualizes the individual $\text{Tracker}$ hits that contributed to a track fit.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{TrkStrawHitSeed}$s from a $\text{KalSeed}$ |
+| **Visualization** | A **$\text{REveCompound}$** containing a **$\text{REvePointSet}$** (the hit position) and a **$\text{REveLine}$** (the $2\sigma$ error bar perpendicular to the track/wire). |
+| **Color Coding** | Uses **$\text{TrkHitColor}$** but switches to a **$\text{TrkNoHitColor}$** if the full drift constraint was *not* used in the fit. |
+
+### $\text{DataInterface::AddKalIntersection}$
+
+Marks where the track crosses significant surfaces within the detector geometry.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{KalIntersection}$ objects from a $\text{KalSeed}$ |
+| **Visualization** | **$\text{REvePointSet}$** marker. |
+| **Color Coding** | **kViolet** for intersections with material (where $\text{dMom} > 0.0$) and **kYellow** for intersections with virtual surfaces. |
+| **Title Info** | **Position**, **Time**, **Momentum/dMomentum**, and the name of the **Surface** intersected. |
+
+### $\text{DataInterface::AddTrkHits}$
+
+Visually links reconstructed tracks to the original hit collections.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{ComboHitCollection}$ and $\text{KalSeedPtrCollection}$ |
+| **Visualization** | **$\text{REvePointSet}$** at the position of each $\text{ComboHit}$. |
+| **Functionality** | **Filters** the $\text{ComboHits}$ by comparing their $\text{StrawId}$ against a set of $\text{StrawId}$s used in all $\text{KalSeeds}$. This highlights *only* the hits used for tracking. |
+| **Efficiency** | Uses a **$\text{std::set}$** to efficiently check $\text{StrawId}$ membership, preventing slow triple-nested loop searches. |
+
+### $\text{DataInterface::AddTimeClusters}$
+
+Visually displays clusters of hits used to determine the initial time ($\text{t0}$) for track seeds.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{TimeClusterCollection}$ |
+| **Visualization** | **$\text{REvePointSet}$** marker at the cluster's central position. |
+| **Title Info** | Cluster $\text{t0}$ and error. |
+
+### $\text{DataInterface::AddCosmicTrackFit}$
+
+Draws the simple straight-line fit for cosmic ray data.
+
+| Feature | Description |
+| :--- | :--- |
+| **Input** | $\text{CosmicTrackSeedCollection}$ |
+| **Visualization** | **$\text{REveLine}$** segment. |
+| **Functionality** | Draws a line segment between the calculated track positions corresponding to the **first and last Y-coordinates** of the hits used in the fit. |
diff --git a/documentation/EventNavigation.md b/documentation/EventNavigation.md
new file mode 100644
index 0000000..6f3d441
--- /dev/null
+++ b/documentation/EventNavigation.md
@@ -0,0 +1,57 @@
+## 🗺️ Event Navigation
+
+During analysis, there are several methods available to navigate to a specific event within the Event Display.
+
+---
+
+### 1. Default Sequential Mode
+
+The **default navigation mode** is sequential.
+
+* By default, the setting `seqMode` is set to `true`.
+* The display begins at the **first event**.
+* Users can navigate to the next event in the sequence using the **GUI's navigation controls**. 
+
+---
+
+### 2. Autoplay
+
+The **Autoplay** option overrides the standard GUI navigation.
+
+* When the "**autoplay**" checkbox is selected, the display will **stream all events sequentially** until it reaches the end of the file.
+
+---
+
+### 3. Go to an Event: GUI
+
+The Event Display GUI includes **text entry boxes** that allow a user to jump directly to an event by specifying its **run** and **event number**.
+
+* **Steps to Use (Currently a Placeholder):**
+    1.  Ensure the display is loaded in `seqMode`.
+    2.  Navigate to the **second event** using the `NextEvent()` function.
+    3.  Enter the desired run and event number into the text boxes.
+    4.  Select the **`Go()`** button, followed immediately by **`NextEvent()`**.
+
+> **Note:** This is **not the recommended method** for navigation and is considered a placeholder feature.
+
+---
+
+### 4. Go to an Event: Scripts (Recommended Method)
+
+The most robust way to navigate to a specific event is by using the custom script located in this repository: `config/EventDisplay.sh`.
+
+#### A. Navigating with the Dataset Name
+
+If you know the name of the **dataset** containing the event, use the following syntax:
+
+```
+./EventDisplay.sh --run 1201 --subrun 34 --event 15028 --dataset mcs.mu2e.ensembleMDS2cMix1BBTriggered.MDC2020ba_best_v1_3.art```
+```
+
+If you are working with an ntuple, you may not know all the commands to figure out its parent mcs. In this case run:
+
+```
+./EventDisplay.sh  --run 1201 --subrun 476 --event 1  --dataset nts.mu2e.ensembleMDS2cMix1BBTriggered.MDC2020ba_best_v1_3_v06_06_00.001201_00000476.root
+```
+
+where the run, subrun and event numbers are identified from your analysis to be an event of interest in that root file.
diff --git a/documentation/FclOptions.md b/documentation/FclOptions.md
new file mode 100644
index 0000000..43a0044
--- /dev/null
+++ b/documentation/FclOptions.md
@@ -0,0 +1,102 @@
+# Mu2eEventDisplay Configuration Documentation
+
+There are many parameters defined within the Mu2e/EventDisplay Framework. Here we list and define all of them.
+
+### 💡 Note on Parameter Placement (Module vs. Filler)
+
+ In this type of framework:
+
+1. **`filler` Block:** Is responsible for **data ingestion**. It specifies *which* collections (e.g., `ComboHitCollection`, `KalSeedPtrCollection`) should be read from the event record and *where* to find them (the module tags, like `makeSH` or `MergeKK`).
+
+2. **Module-Level Flags:** Control the **rendering/visualization logic** of the main module. Flags like `addTrkStrawHits` or `addErrBar` tell the `Mu2eEventDisplay` module *how* to draw the data that the `filler` has already prepared. They affect display features (error bars, drawing style, etc.) rather than the data source.
+
+
+## General Module Parameters
+
+These parameters control the core behavior of the module, including logging, geometry loading, and global display switches for major detector components.
+
+| Parameter | Type | Default (from config) | Description | 
+| :--- | :--- | :--- | :--- | 
+| `module_type` | String | `Mu2eEventDisplay` | **Mandatory.** Specifies the class name of the module to load. | 
+| `diagLevel` | Integer | `1` | Controls the verbosity of the internal module logging. `0` is typically minimal, higher values (`1`, `2`, etc.) increase diagnostic output. | 
+| `gdmlname` | String | `"Offline/gen/gdml/mu2e.gdml"` | Specifies the path to the GDML (Geometry Description Markup Language) file used to load the detector geometry for visualization. | 
+| `extracted` | Boolean | `false` | flag to control if the display should use an *extracted* geometry | 
+| `particles` | Array (Int) | `[11,13,2212,2112,211,22,212]` | A list of particle IDs (PDG codes) to focus the display on or track. Common IDs include electron (`11`), muon (`13`), proton (`2212`), neutron (`2112`), pion (`211`), photon (`22`), and others. | 
+| `specifyTag` | Boolean | `false` | **IMPORTANT.** When set to `true`, it overrides default behavior and forces the module to use the collection tags specified explicitly within the `filler` block. | 
+| `seqMode` | Boolean | `true` | **IMPORTANT.** This will allow you to navigate from the first to the last using the NextEvent() button | 
+
+
+## Detector Visibility Flags
+
+These boolean flags enable or disable the display of the major sub-detector components (geometry and related elements).
+
+| Parameter | Type | Default (from config) | Description | 
+| :--- | :--- | :--- | :--- | 
+| `showCrv` | Boolean | `true` | Show the Cosmic Ray Veto (CRV) detector components. | 
+| `showPS` | Boolean | `false` | Show the Production Solenoid (PS) components. | 
+| `showTS` | Boolean | `false` | Show the Transport Solenoid (TS) components. | 
+| `showDS` | Boolean | `false` | Show the Detector Solenoid (DS) components. | 
+| `showST` | Boolean | `true` | Show the Stopping Target (ST). | 
+| `showSTM` | Boolean | `false` | Show the Stopping Target Monitor (STM) components. | 
+| `showCalo` | Boolean | `true` | Show the Calorimeter volume. | 
+| `showCaloCrystals` | Boolean | `true` | Show the individual calorimeter crystals. | 
+| `showTracker` | Boolean | `true` | Show the Tracker detector components (straw tubes). | 
+
+## Display Functionality and Rendering Flags
+
+These flags modify how data is rendered or what auxiliary information is included.
+
+| Parameter | Type | Default (from config) | Description | 
+| :--- | :--- | :--- | :--- | 
+| `show2D` | Boolean | `true` | Enables or disables a two-dimensional projection display mode. | 
+| `caloVST` | Boolean | `false` | A visualization mode intended to view the Calorimeter alone. | 
+| `addErrBar` | Boolean | `true` | Add error bars to visualized hit/cluster points. | 
+| `addCrystalHits` | Boolean | `false` | Display individual hits within the calorimeter crystals. | 
+| `addCrvBars` | Boolean | `false` | Display the physical CRV bars/scintillators. | 
+| `addKalInter` | Boolean | `false` | Add Kalmar (KalSeed) trajectory intersection points. | 
+| `addTrkStrawHits` | Boolean | `false` | Add individual tracker straw hits to the display. | 
+| `addTrkCaloHits` | Boolean | `false` | Add tracker hits extrapolated to the calorimeter face. | 
+| `strawdisplay` | Boolean | `false` | Specific flag to control the display of individual straw tubes (often only enabled for debug/close-up views). | 
+
+
+## `filler` Block Parameters
+
+The `filler` block is responsible for configuring the **data collections** that the event display will ingest and draw. The keys are the data types, and the values are the **producer tags** specifying which module created the collection.
+
+### Input Data Collections
+
+| Parameter | Type | Default (from config) | Description | 
+| :--- | :--- | :--- | :--- | 
+| `ComboHitCollection` | Array (String) | `["makeSH"]` | Tag(s) for the combined straw hits used for tracking. | 
+| `CrvRecoPulseCollection` | Array (String) | `["SelectRecoMC"]` | Tag(s) for the reconstructed pulses from the CRV. | 
+| `CrvCoincidenceClusterCollection`| Array (String) | `["SelectRecoMC:CrvCoincidenceClusterFinder"]` | Tag(s) for the CRV coincidence clusters (higher-level CRV data). | 
+| `TimeClusterCollection` | Array (String) | `["MHDeM"]` | Tag(s) for the primary time clusters found in the event. | 
+| `CaloDigiCollection` | Array (String) | `["CaloDigiMaker"]` | Tag(s) for the digitized/raw calorimeter data (digis). | 
+| `CaloClusterCollection` | Array (String) | `["CaloClusterMaker"]` | Tag(s) for the reconstructed calorimeter clusters. | 
+| `KalSeedPtrCollection` | Array (String) | `["MergeKK"]` | Tag(s) for the final, merged Kalman Filter (KalSeed) tracks. | 
+| `HelixSeedCollection` | Array (String) | `["MHFinderDe"]` | Tag(s) for the initial helix seeds used for tracking. | 
+| `CosmicTrackSeedCollection`| String | `"CosmicTrackFinderTimeFit"` | Tag for cosmic ray tracks (if available). | 
+| `MCTrajectoryCollection` | Array (String) | `["compressRecoMCs"]` | Tag(s) for the Monte Carlo (MC) generated trajectories (the truth data). | 
+| `SurfaceStepCollection` | Array (String) | `[]` | Tag(s) for MC steps on detector surfaces (currently empty). | 
+| `SimParticleCollection` | Array (String) | `["compressSTMDet"]` | Tag(s) for the MC simulated particles. | 
+
+### Filler Display Control Flags
+
+These flags control whether the data collections identified above are actually *added* to the event display's drawing list.
+
+| Parameter | Type | Default (from config) | Description | 
+| :--- | :--- | :--- | :--- | 
+| `diagLevel` | Integer | `0` | Logging level specific to the `filler` block (data reading). | 
+| `FillAll` | Boolean | `false` | If true, likely overrides individual `add...` flags and attempts to add all known data types. | 
+| `addHits` | Boolean | `false` | Add `ComboHitCollection` (combined tracker hits). | 
+| `addCrvRecoPulse` | Boolean | `false` | Add `CrvRecoPulseCollection`. | 
+| `addCrvClusters` | Boolean | `false` | Add `CrvCoincidenceClusterCollection`. | 
+| `addTimeClusters` | Boolean | `false` | Add `TimeClusterCollection`. | 
+| `addTrkHits` | Boolean | `false` | Add tracker hits (often synonymous with `addHits` or a specialized hit collection). | 
+| `addCaloDigis` | Boolean | `false` | Add `CaloDigiCollection`. | 
+| `addClusters` | Boolean | `false` | Add `CaloClusterCollection`. | 
+| `addKalSeeds` | Boolean | `false` | Add `KalSeedPtrCollection` (reconstructed tracks). | 
+| `addCosmicTrackSeeds` | Boolean | `false` | Add `CosmicTrackSeedCollection` (cosmic tracks). | 
+| `addMCTraj` | Boolean | `true` | Add `MCTrajectoryCollection` (MC truth particle trajectories). | 
+| `addSurfSteps` | Boolean | `true` | Add `SurfaceStepCollection` (MC steps on surfaces). | 
+| `addSimParts` | Boolean | `true` | Add `SimParticleCollection` (MC truth particles). |
diff --git a/documentation/GUIOptions.md b/documentation/GUIOptions.md
new file mode 100644
index 0000000..b40fd6a
--- /dev/null
+++ b/documentation/GUIOptions.md
@@ -0,0 +1,48 @@
+# 💡 Mu2e Event Display GUI
+
+The Mu2e Event Display provides an interactive visualization environment based on the ROOT REve framework. The GUI allows users to control what data is displayed, how it is viewed, and how detailed information is retrieved.
+
+## Toggle Menu
+
+The Toggle Menu typically appears as a side panel in the browser, providing quick access to visibility controls and event-specific filtering options. The entire visualization is structurally divided into two primary $\text{REve}$ Scenes to manage the fixed detector elements separately from the changing event data.
+
+The toggle menu includes everything that is displayed in the browser. Our custom products are divided into two primary Scenes:
+
+* $\text{GeomScene}$ (Geometry Scene): This scene contains static, time-independent elements of the detector. This includes the large, unmoving structures of the Mu2e detector, such as the Solenoids, the Target, and the fixed components of the Tracker and Calorimeter. These elements are loaded once and rarely change for a specific data set. Remember to ensure the data-set and the geometry match i.e. MDC2020 data requires MDC2020 geometry.
+
+* $\text{EventScene}$ (Event Data Scene): This scene holds all dynamic, event-dependent data products. This is where the visualization of particle trajectories, reconstructed tracks, hits, and clusters resides. Every time a new event is loaded, the contents of the $\text{EventScene}$ are cleared and redrawn based on the new data products.
+
+* Visibility: You can toggle the overall visibility of major detector components (e.g., turn off the CRV to focus on the Tracker). The same can be done for the event information using the check markers.
+
+
+## Zooming and Keyboard shortcuts
+
+The visualization scene supports full 3D interaction for detailed inspection of events.
+
+### Mouse Interaction (3D Viewer):
+
+* Left Mouse Drag: Rotates the 3D scene view around the current center point.
+
+* Right Mouse Drag: Pans the scene (moves the camera laterally).
+
+* Scroll Wheel: The mouse can be used to zoom in and out by changing the camera's distance from the scene.
+
+* Keyboard $\text{'Shift'}$ + Left Click: The shift key can be used to recenter the view on the point you click, setting a new pivot point for rotations.
+
+* Keyboard Shortcuts: While many advanced shortcuts exist within the ROOT REve framework, the most commonly used shortcuts are for navigation and resetting the view. Hitting the 'Home' key typically resets the scene back to its predefined initial orientation (often looking down the Z-axis).
+
+## Text Entry
+
+Text entry fields provide critical, powerful filtering capabilities, although the current implementation may be limited in quantity. We are working to advance the options.
+
+Please reach out if you have use-cases.
+
+## MouseOvers
+
+All products have useful "mouseover" labels (tooltips) that link the visual representation directly back to the underlying data.
+
+* Function: Place your mouse on a track, hit, or cluster, and a tooltip will appear, showing information relating to the features of that product.
+
+* Data Provided: The tooltip displays the element's descriptive $\text{Title}$ string, which is custom-built for each data type.
+
+This feature is essential for debugging, event checking, and quantitative analysis within the display.
diff --git a/documentation/GettingStarted.md b/documentation/GettingStarted.md
new file mode 100644
index 0000000..865b19f
--- /dev/null
+++ b/documentation/GettingStarted.md
@@ -0,0 +1,94 @@
+## 🚀 Getting Started with the Event Display
+
+This guide covers the essential setup and troubleshooting steps required before launching the Event Display to ensure a smooth and error-free operation.
+
+---
+
+### 🛠️ Initial Setup and Troubleshooting
+
+Before running the Event Display, complete the following steps to prevent common errors and system hangs.
+
+#### 1. Building GDML Geometry
+
+The Event Display requires the detector geometry to be compiled into a **GDML** (Geometry Description Markup Language) file. Skipping this step will result in a fatal ROOT error, as the application cannot initialize its environment without the geometry data. 
+
+* **Command to Build GDML:**
+    ```
+    muse build GDML
+    ```
+
+* **Common Error if Skipped:**
+    ```
+     what(): ---- FatalRootError BEGIN
+     Fatal Root Error: TFile::Write
+     file /dev/null not opened in write mode
+     ROOT severity: 2000
+    ---- FatalRootError END
+    ```
+    This error indicates a critical failure to load the necessary geometry components.
+
+---
+
+#### 2. Setting up the $\text{.rootrc}$ File
+
+The **$\text{.rootrc}$ configuration file** is crucial for the correct functioning of the **ROOT environment** and the Event Display, especially for graphical and startup behavior.
+
+* **Command to Create $\text{.rootrc}$:**
+    This script generates a properly configured $\text{.rootrc}$ file in your current working directory.
+    ```
+    EventDisplay/config/makerootrc.sh
+    ```
+
+---
+
+#### 3. Launching the Remote Browser
+
+Once you've run the display on the local **Mu2e machines** (refer to the documentation on EventNavigation for local instructions), you can access the remote display using a browser.
+
+* **Sign that the Display is Accessible:**
+    The local (mu2e) machine will print a log that includes the **EVE URL** and streaming details, indicating that the geometry and event scenes have loaded successfully.
+
+    ```
+    Info in <THttpEngine::Create>: Starting HTTP server on port 1234
+    EVE URL http://localhost:1234/win1/
+    ...
+    EVEMNG ............. streaming the world scene.
+    ...
+    EVEMNG ............. streaming scene [Geometry scene]
+    ...
+    EVEMNG ............. streaming scene [Event scene]
+    ...
+    Geometry file: /exp/mu2e/app/users/sophie/...
+    ...
+    ```
+    The presence of the `EVE URL` and logs for streaming the `[Geometry scene]` and `[Event scene]` confirms it's safe to attempt remote access.
+
+* **Accessing the Remote Display:**
+    Use the provided script on your remote machine to set up the connection.
+
+    ```
+    start_RemoteDisplay.sh --port <WXYZ> --user <your_name> --machine <mu2e gpvm number e.g. 04>
+    ```
+
+    > **Note:** **Google Chrome** is the recommended browser.
+
+* **Manual Setup for Other Browsers:**
+    If you prefer another browser, you can manually set up an **SSH tunnel**:
+    ```
+    ssh -KXY -L 0<port>:localhost:0<port> <user>@mu2egpvm0<machine>.fnal.gov
+    ```
+    Then, copy the displayed URL (e.g., `http://localhost:<port>/win1/`) into your chosen browser.
+
+---
+
+#### 4. Correcting Stale Browser Sessions (Correcting hangs)
+
+If the event display **hangs** or fails to start correctly, it is often caused by leftover processes or stale browser calls from a previous session.
+
+* **Troubleshooting Command:**
+    Executing this script attempts to forcefully terminate any persistent browser connections that could interfere with the new display session.
+    ```
+    EventDisplay/config/kill.sh
+    ```
+
+
diff --git a/documentation/examples.md b/documentation/examples.md
new file mode 100644
index 0000000..e618e30
--- /dev/null
+++ b/documentation/examples.md
@@ -0,0 +1,44 @@
+# ✨ Examples and Configuration
+
+This section provides details on using example files and configuring the Event Display for different geometry settings.
+
+---
+
+## 1. The `prolog.fcl` File
+
+The **`prolog.fcl`** file defines the **default settings** for the Event Display, covering both the geometry and event scene information (refer to the FclOption documentation for specifics).
+
+* **Override Nominal Settings:** To use a non-default geometry or configuration, you must **update your driver `.fcl` file**. This is done in the same way you would configure any Mu2e/Offline analyzer module.
+
+---
+
+## 2. The `EventDisplay/examples1` Directory
+
+This directory contains several starter `.fcl` files to help you quickly set up the Event Display for various sample types and geometry configurations.
+
+| Example File | Description | Usage |
+| :--- | :--- | :--- |
+| `nominal_MDC2020.fcl` | Uses the original CRV geometry. | Recommended for **MDC2020** nominal samples. |
+| `nominal_MDC2025.fcl` | Uses the updated MDC2025 CRV geometry. | Recommended for **MDC2025** nominal samples, assuming the common GDML. |
+| `extracted_MDC2020.fcl` | Used for running against MDC2020 extracted samples. | **Note:** This example will be retired soon. |
+| `extracted_MDC2025.fcl` | Used for extracted physics studies with MDC2025 samples. | Recommended for **MDC2025** extracted samples. |
+
+> **Tip:** These `.fcl` files are intended as starting points and can be **edited** to add or remove specific features as needed for your study.
+
+---
+
+## 3. Other Geometry Configurations
+
+If you need to run the Event Display against a geometry configuration that is **not** one of the standard examples (e.g., a custom geometry tag), you must explicitly update the paths in your driver `.fcl` file.
+
+To configure the display for a new geometry, update the following parameters:
+
+```
+physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/<new>.gdml"
+services.GeometryService.inputFile: "Offline/Mu2eG4/geom/<new-geom_common.txt>"
+```
+
+* Replace `<new>.gdml` with the name of the GDML file for your configuration.
+
+* Replace `<new-geom_common.txt>` with the name of the corresponding geometry input file.
+
diff --git a/examples/nominal_Run1a.fcl b/examples/calibcalo_MDC2020.fcl
similarity index 79%
rename from examples/nominal_Run1a.fcl
rename to examples/calibcalo_MDC2020.fcl
index f8d7f45..bec042a 100644
--- a/examples/nominal_Run1a.fcl
+++ b/examples/calibcalo_MDC2020.fcl
@@ -24,18 +24,21 @@ physics.analyzers.Mu2eEventDisplay.showPS : false
 physics.analyzers.Mu2eEventDisplay.showTS : false
 physics.analyzers.Mu2eEventDisplay.showDS : false
 physics.analyzers.Mu2eEventDisplay.addCRVBars : false
-
-physics.analyzers.Mu2eEventDisplay.addKalInter : true
+physics.analyzers.Mu2eEventDisplay.showTracker : false
+physics.analyzers.Mu2eEventDisplay.showST : false
+physics.analyzers.Mu2eEventDisplay.showCRV : false
+physics.analyzers.Mu2eEventDisplay.addKalInter : false
 physics.analyzers.Mu2eEventDisplay.addCrystalHits : true
 physics.analyzers.Mu2eEventDisplay.filler.addHelixSeeds : false
-physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : true
+physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : false
 physics.analyzers.Mu2eEventDisplay.filler.addClusters : true
 physics.analyzers.Mu2eEventDisplay.filler.addHits : false #  adds ComboHits
 physics.analyzers.Mu2eEventDisplay.filler.addCrvClusters : true
 physics.analyzers.Mu2eEventDisplay.filler.addCrvHits : true
 physics.analyzers.Mu2eEventDisplay.filler.addTimeClusters : false
-physics.analyzers.Mu2eEventDisplay.filler.addSimParts : false
-physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : true
+physics.analyzers.Mu2eEventDisplay.filler.addSimParts : true
+physics.analyzers.Mu2eEventDisplay.filler.addCaloDigis : true
+physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : false
 physics.analyzers.Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
 physics.analyzers.Mu2eEventDisplay.filler.addMCTraj : true
 physics.analyzers.Mu2eEventDisplay.specifyTag : false
@@ -64,10 +67,11 @@ services.TFileService.fileName: "/dev/null"
 #  "1202:636:337031",
 #  "1202:648:370322" ]
 #
-physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_run1_a.gdml"
-
+physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_MDC2020.gdml"
 
 source.inputCommands: ["keep *",
     "drop mu2e::CaloClusters_CaloClusterFast_*_*"
     ]
 
+services.TFileService.fileName: "/dev/null"
+services.GeometryService.inputFile: "Offline/Mu2eG4/geom/geom_common_MDC2020.txt"
diff --git a/examples/extracted_MDC2020.fcl b/examples/extracted_MDC2020.fcl
index f1f4874..6ceaac3 100644
--- a/examples/extracted_MDC2020.fcl
+++ b/examples/extracted_MDC2020.fcl
@@ -3,53 +3,14 @@
 #include "Offline/fcl/minimalMessageService.fcl"
 #include "Offline/fcl/standardProducers.fcl"
 #include "Offline/fcl/standardServices.fcl"
-#include "EventDisplay/fcl/prolog.fcl"
-services : @local::Services.Reco
-process_name : HelixED
-source : { module_type : RootInput }
-physics :
-{
- analyzers : { @table::REveDis.analyzers}
-  producers : { @table::REveDis.producers }
-  filters : { @table::REveDis.filters }
-}
-//geometry options
-physics.analyzers.Mu2eEventDisplay.showCRV : true
-physics.analyzers.Mu2eEventDisplay.showPS : false
-physics.analyzers.Mu2eEventDisplay.showTS : false
-physics.analyzers.Mu2eEventDisplay.showST : false
-//highlight CRV bars which are "hit"
-physics.analyzers.Mu2eEventDisplay.addCRVBars : true
-physics.analyzers.Mu2eEventDisplay.filler.addCrvHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addCrvClusters : true
-//for KinKal development
-physics.analyzers.Mu2eEventDisplay.addCrystalHits : true
-physics.analyzers.Mu2eEventDisplay.addKalInter : true
-physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : true
-physics.analyzers.Mu2eEventDisplay.filler.addTrkHits : false
-//turn these off for now
-physics.analyzers.Mu2eEventDisplay.filler.addClusters : false //CaloClusters
-physics.analyzers.Mu2eEventDisplay.filler.addHits : false //ComboHits
-physics.analyzers.Mu2eEventDisplay.filler.addTimeClusters : false
-//pat rec CosmicTrackSeed
-physics.analyzers.Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
+#include "EventDisplay/fcl/extracted.fcl"
 
-// MC Trajectory:
-physics.analyzers.Mu2eEventDisplay.filler.addMCTraj : true
 
-//setup extracted geometry
-physics.analyzers.Mu2eEventDisplay.extracted : true
 physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_extracted_MDC2020.gdml"
+services.TFileService.fileName: "/dev/null"
+services.GeometryService.inputFile: "Offline/Mu2eG4/geom/geom_common_extracted_MDC2020.txt"
 
-physics.analyzers.Mu2eEventDisplay.seqMode : true
-//for print statements
-physics.analyzers.Mu2eEventDisplay.diagLevel : 1
-//the path
 physics.EndPath  : [ @sequence::REveDis.seqBase]
 physics.REvePath : @local::REvePath
 physics.trigger_paths :  ["REvePath" ]
 physics.analyzers.Mu2eEventDisplay.SelectEvents : ["REvePath" ]
-
-services.TFileService.fileName: "/dev/null"
-services.GeometryService.inputFile: "Offline/Mu2eG4/geom/geom_common_extracted_MDC2020.txt"
diff --git a/examples/extracted_MDC2025.fcl b/examples/extracted_MDC2025.fcl
index 09bd12f..c507d45 100644
--- a/examples/extracted_MDC2025.fcl
+++ b/examples/extracted_MDC2025.fcl
@@ -3,53 +3,10 @@
 #include "Offline/fcl/minimalMessageService.fcl"
 #include "Offline/fcl/standardProducers.fcl"
 #include "Offline/fcl/standardServices.fcl"
-#include "EventDisplay/fcl/prolog.fcl"
-services : @local::Services.Reco
-process_name : HelixED
-source : { module_type : RootInput }
-physics :
-{
- analyzers : { @table::REveDis.analyzers}
-  producers : { @table::REveDis.producers }
-  filters : { @table::REveDis.filters }
-}
-//geometry options
-physics.analyzers.Mu2eEventDisplay.showCRV : true
-physics.analyzers.Mu2eEventDisplay.showPS : false
-physics.analyzers.Mu2eEventDisplay.showTS : false
-physics.analyzers.Mu2eEventDisplay.showST : false
-//highlight CRV bars which are "hit"
-physics.analyzers.Mu2eEventDisplay.addCRVBars : true
-physics.analyzers.Mu2eEventDisplay.filler.addCrvHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addCrvClusters : true
-//for KinKal development
-physics.analyzers.Mu2eEventDisplay.addCrystalHits : true
-physics.analyzers.Mu2eEventDisplay.addKalInter : true
-physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : true
-physics.analyzers.Mu2eEventDisplay.filler.addTrkHits : false
-//turn these off for now
-physics.analyzers.Mu2eEventDisplay.filler.addClusters : false //CaloClusters
-physics.analyzers.Mu2eEventDisplay.filler.addHits : false //ComboHits
-physics.analyzers.Mu2eEventDisplay.filler.addTimeClusters : false
-//pat rec CosmicTrackSeed
-physics.analyzers.Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
+#include "EventDisplay/fcl/extracted.fcl"
 
-// MC Trajectory:
-physics.analyzers.Mu2eEventDisplay.filler.addMCTraj : true
 
-//setup extracted geometry
-physics.analyzers.Mu2eEventDisplay.extracted : true
 physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_extracted.gdml"
 
-physics.analyzers.Mu2eEventDisplay.seqMode : true
-//for print statements
-physics.analyzers.Mu2eEventDisplay.diagLevel : 1
-//the path
-physics.EndPath  : [ @sequence::REveDis.seqBase]
-physics.REvePath : @local::REvePath
-physics.trigger_paths :  ["REvePath" ]
-physics.analyzers.Mu2eEventDisplay.SelectEvents : ["REvePath" ]
-
 services.TFileService.fileName: "/dev/null"
 services.GeometryService.inputFile: "Offline/Mu2eG4/geom/geom_common_extracted.txt"
diff --git a/examples/nominal_MDC2020.fcl b/examples/nominal_MDC2020.fcl
index a2129bb..e57b7c3 100644
--- a/examples/nominal_MDC2020.fcl
+++ b/examples/nominal_MDC2020.fcl
@@ -1,5 +1,5 @@
 # author : Sophie Middleton
-# purpose : example for helix tracks
+# purpose : MDC2020
 #include "Offline/fcl/minimalMessageService.fcl"
 #include "Offline/fcl/standardProducers.fcl"
 #include "Offline/fcl/standardServices.fcl"
@@ -7,7 +7,7 @@
 
 services : @local::Services.Reco
 
-process_name : HelixED
+process_name : Nominal
 
 source : { module_type : RootInput }
 
@@ -17,32 +17,6 @@ physics :
   producers : { @table::REveDis.producers }
   filters : { @table::REveDis.filters }
 }
-# geometry options
-physics.analyzers.Mu2eEventDisplay.showCRV : true
-
-physics.analyzers.Mu2eEventDisplay.showPS : false
-physics.analyzers.Mu2eEventDisplay.showTS : false
-physics.analyzers.Mu2eEventDisplay.showDS : false
-physics.analyzers.Mu2eEventDisplay.addCRVBars : true
-
-physics.analyzers.Mu2eEventDisplay.addKalInter : true
-physics.analyzers.Mu2eEventDisplay.addCrystalHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addHelixSeeds : false
-physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : true
-physics.analyzers.Mu2eEventDisplay.filler.addClusters : true
-physics.analyzers.Mu2eEventDisplay.filler.addHits : false #  adds ComboHits
-physics.analyzers.Mu2eEventDisplay.filler.addCrvClusters : true
-physics.analyzers.Mu2eEventDisplay.filler.addCrvHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addTimeClusters : false
-physics.analyzers.Mu2eEventDisplay.filler.addSimParts : false
-physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
-physics.analyzers.Mu2eEventDisplay.filler.addMCTraj : true
-physics.analyzers.Mu2eEventDisplay.specifyTag : false
-
-# allows movement through events in sequential order
-physics.analyzers.Mu2eEventDisplay.seqMode : true
-physics.analyzers.Mu2eEventDisplay.strawdisplay : false
 
 # print statements
 physics.analyzers.Mu2eEventDisplay.diagLevel : 10
@@ -53,22 +27,12 @@ physics.REvePath : @local::REvePath
 physics.trigger_paths :  ["REvePath" ]
 physics.analyzers.Mu2eEventDisplay.SelectEvents : ["REvePath" ]
 
-# useless file name
-services.TFileService.fileName: "/dev/null"
-
-#
-# to display a selected set of events, #include this file with a list of eventid triplets: ie:
-#
-##include "Mu2eEventDisplay/examples/nominal_example.fcl"
-#physics.filters.eidsel.idsToMatch : [
-#  "1202:636:337031",
-#  "1202:648:370322" ]
-#
-physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_MDC2020.gdml"
 
 source.inputCommands: ["keep *",
     "drop mu2e::CaloClusters_CaloClusterFast_*_*"
     ]
 
+# useless file name
 services.TFileService.fileName: "/dev/null"
+physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_MDC2020.gdml"
 services.GeometryService.inputFile: "Offline/Mu2eG4/geom/geom_common_MDC2020.txt"
diff --git a/examples/nominal_MDC2025.fcl b/examples/nominal_MDC2025.fcl
index 8a28478..388d456 100644
--- a/examples/nominal_MDC2025.fcl
+++ b/examples/nominal_MDC2025.fcl
@@ -1,5 +1,5 @@
 # author : Sophie Middleton
-# purpose : example for helix tracks
+# purpose : MDC2025
 #include "Offline/fcl/minimalMessageService.fcl"
 #include "Offline/fcl/standardProducers.fcl"
 #include "Offline/fcl/standardServices.fcl"
@@ -7,7 +7,7 @@
 
 services : @local::Services.Reco
 
-process_name : HelixED
+process_name : Nominal
 
 source : { module_type : RootInput }
 
@@ -17,32 +17,6 @@ physics :
   producers : { @table::REveDis.producers }
   filters : { @table::REveDis.filters }
 }
-# geometry options
-physics.analyzers.Mu2eEventDisplay.showCRV : true
-
-physics.analyzers.Mu2eEventDisplay.showPS : false
-physics.analyzers.Mu2eEventDisplay.showTS : false
-physics.analyzers.Mu2eEventDisplay.showDS : false
-physics.analyzers.Mu2eEventDisplay.addCRVBars : false
-
-physics.analyzers.Mu2eEventDisplay.addKalInter : true
-physics.analyzers.Mu2eEventDisplay.addCrystalHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addHelixSeeds : false
-physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : true
-physics.analyzers.Mu2eEventDisplay.filler.addClusters : true
-physics.analyzers.Mu2eEventDisplay.filler.addHits : false #  adds ComboHits
-physics.analyzers.Mu2eEventDisplay.filler.addCrvClusters : true
-physics.analyzers.Mu2eEventDisplay.filler.addCrvHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addTimeClusters : false
-physics.analyzers.Mu2eEventDisplay.filler.addSimParts : false
-physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
-physics.analyzers.Mu2eEventDisplay.filler.addMCTraj : true
-physics.analyzers.Mu2eEventDisplay.specifyTag : false
-
-# allows movement through events in sequential order
-physics.analyzers.Mu2eEventDisplay.seqMode : true
-physics.analyzers.Mu2eEventDisplay.strawdisplay : false
 
 # print statements
 physics.analyzers.Mu2eEventDisplay.diagLevel : 10
@@ -53,21 +27,12 @@ physics.REvePath : @local::REvePath
 physics.trigger_paths :  ["REvePath" ]
 physics.analyzers.Mu2eEventDisplay.SelectEvents : ["REvePath" ]
 
-# useless file name
-services.TFileService.fileName: "/dev/null"
-
-#
-# to display a selected set of events, #include this file with a list of eventid triplets: ie:
-#
-##include "Mu2eEventDisplay/examples/nominal_example.fcl"
-#physics.filters.eidsel.idsToMatch : [
-#  "1202:636:337031",
-#  "1202:648:370322" ]
-#
-physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_common.gdml"
-
 
 source.inputCommands: ["keep *",
     "drop mu2e::CaloClusters_CaloClusterFast_*_*"
     ]
 
+# useless file name
+services.TFileService.fileName: "/dev/null"
+physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_common.gdml"
+services.GeometryService.inputFile: "Offline/Mu2eG4/geom/geom_common.txt"
diff --git a/examples/nominal_Run2.fcl b/examples/nominal_Run2.fcl
deleted file mode 100644
index f4e0405..0000000
--- a/examples/nominal_Run2.fcl
+++ /dev/null
@@ -1,73 +0,0 @@
-# author : Sophie Middleton
-# purpose : example for helix tracks
-#include "Offline/fcl/minimalMessageService.fcl"
-#include "Offline/fcl/standardProducers.fcl"
-#include "Offline/fcl/standardServices.fcl"
-#include "EventDisplay/fcl/prolog.fcl"
-
-services : @local::Services.Reco
-
-process_name : HelixED
-
-source : { module_type : RootInput }
-
-physics :
-{
-  analyzers : { @table::REveDis.analyzers}
-  producers : { @table::REveDis.producers }
-  filters : { @table::REveDis.filters }
-}
-# geometry options
-physics.analyzers.Mu2eEventDisplay.showCRV : true
-
-physics.analyzers.Mu2eEventDisplay.showPS : false
-physics.analyzers.Mu2eEventDisplay.showTS : false
-physics.analyzers.Mu2eEventDisplay.showDS : false
-physics.analyzers.Mu2eEventDisplay.addCRVBars : false
-
-physics.analyzers.Mu2eEventDisplay.addKalInter : true
-physics.analyzers.Mu2eEventDisplay.addCrystalHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addHelixSeeds : false
-physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : true
-physics.analyzers.Mu2eEventDisplay.filler.addClusters : true
-physics.analyzers.Mu2eEventDisplay.filler.addHits : false #  adds ComboHits
-physics.analyzers.Mu2eEventDisplay.filler.addCrvClusters : true
-physics.analyzers.Mu2eEventDisplay.filler.addCrvHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addTimeClusters : false
-physics.analyzers.Mu2eEventDisplay.filler.addSimParts : false
-physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : true
-physics.analyzers.Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
-physics.analyzers.Mu2eEventDisplay.filler.addMCTraj : true
-physics.analyzers.Mu2eEventDisplay.specifyTag : false
-
-# allows movement through events in sequential order
-physics.analyzers.Mu2eEventDisplay.seqMode : true
-physics.analyzers.Mu2eEventDisplay.strawdisplay : false
-
-# print statements
-physics.analyzers.Mu2eEventDisplay.diagLevel : 10
-
-# the path
-physics.EndPath  : [ @sequence::REveDis.seqBase]
-physics.REvePath : @local::REvePath
-physics.trigger_paths :  ["REvePath" ]
-physics.analyzers.Mu2eEventDisplay.SelectEvents : ["REvePath" ]
-
-# useless file name
-services.TFileService.fileName: "/dev/null"
-
-#
-# to display a selected set of events, #include this file with a list of eventid triplets: ie:
-#
-##include "Mu2eEventDisplay/examples/nominal_example.fcl"
-#physics.filters.eidsel.idsToMatch : [
-#  "1202:636:337031",
-#  "1202:648:370322" ]
-#
-physics.analyzers.Mu2eEventDisplay.gdmlname :"Offline/gen/gdml/mu2e_run2.gdml"
-
-
-source.inputCommands: ["keep *",
-    "drop mu2e::CaloClusters_CaloClusterFast_*_*"
-    ]
-
diff --git a/fcl/extracted.fcl b/fcl/extracted.fcl
new file mode 100644
index 0000000..58f6c34
--- /dev/null
+++ b/fcl/extracted.fcl
@@ -0,0 +1,29 @@
+#include "EventDisplay/fcl/prolog.fcl"
+
+services : @local::Services.Reco
+process_name : Extracted
+source : { module_type : RootInput }
+physics :
+{
+ analyzers : { @table::REveDis.analyzers}
+  producers : { @table::REveDis.producers }
+  filters : { @table::REveDis.filters }
+}
+
+physics.analyzers.Mu2eEventDisplay.showCrv : true
+physics.analyzers.Mu2eEventDisplay.showST: false
+physics.analyzers.Mu2eEventDisplay.addCrvBars : true
+physics.analyzers.Mu2eEventDisplay.filler.addCrvRecoPulse: true
+physics.analyzers.Mu2eEventDisplay.filler.addCrvClusters : false
+physics.analyzers.Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
+physics.analyzers.Mu2eEventDisplay.addCrystalHits : true
+physics.analyzers.Mu2eEventDisplay.addKalInter : true
+physics.analyzers.Mu2eEventDisplay.addTrkStrawHits : true
+physics.analyzers.Mu2eEventDisplay.filler.addKalSeeds : true
+physics.analyzers.Mu2eEventDisplay.filler.addTrkHits : false
+physics.analyzers.Mu2eEventDisplay.filler.addClusters : false //CaloClusters
+physics.analyzers.Mu2eEventDisplay.filler.addHits : false //ComboHits
+physics.analyzers.Mu2eEventDisplay.filler.addSimParts : true
+
+physics.analyzers.Mu2eEventDisplay.extracted : true
+physics.analyzers.Mu2eEventDisplay.seqMode : true
diff --git a/fcl/nominal.fcl b/fcl/nominal.fcl
new file mode 100644
index 0000000..4e766c2
--- /dev/null
+++ b/fcl/nominal.fcl
@@ -0,0 +1,39 @@
+# author : Sophie Middleton
+# purpose : example fo nominal geometry i.e. not extracted
+
+# geometry options
+Mu2eEventDisplay.showCrv : true
+Mu2eEventDisplay.showPS : false
+Mu2eEventDisplay.showTS : false
+Mu2eEventDisplay.showDS : false
+Mu2eEventDisplay.addCrvBars : true
+Mu2eEventDisplay.addKalInter : true
+Mu2eEventDisplay.addCrystalHits : true
+Mu2eEventDisplay.filler.addHelixSeeds : false
+Mu2eEventDisplay.filler.addKalSeeds : true
+Mu2eEventDisplay.filler.addClusters : true
+Mu2eEventDisplay.filler.addHits : false #  adds ComboHits
+Mu2eEventDisplay.filler.addCrvClusters : true
+Mu2eEventDisplay.filler.addCrvRecoPulse : false
+Mu2eEventDisplay.filler.addTimeClusters : false
+Mu2eEventDisplay.filler.addSimParts : false
+Mu2eEventDisplay.addTrkStrawHits : true
+Mu2eEventDisplay.addTrkCaloHits : true
+Mu2eEventDisplay.filler.addCosmicTrackSeeds : false
+Mu2eEventDisplay.filler.addMCTraj : true
+Mu2eEventDisplay.filler.addHelixSeeds : false
+Mu2eEventDisplay.specifyTag : false
+
+Mu2eEventDisplay.seqMode : true
+Mu2eEventDisplay.strawdisplay : false
+
+Mu2eEventDisplay.diagLevel : 10
+
+# the path
+physics.EndPath  : [ @sequence::REveDis.seqBase]
+physics.REvePath : @local::REvePath
+physics.trigger_paths :  ["REvePath" ]
+Mu2eEventDisplay.SelectEvents : ["REvePath" ]
+
+# useless file name
+services.TFileService.fileName: "/dev/null"
diff --git a/fcl/prolog.fcl b/fcl/prolog.fcl
index 50bfffa..3af9eb0 100644
--- a/fcl/prolog.fcl
+++ b/fcl/prolog.fcl
@@ -3,7 +3,7 @@ BEGIN_PROLOG
 Mu2eEventDisplay : {
     module_type : Mu2eEventDisplay
     diagLevel : 1
-    showCRV : false
+    showCrv : true
     showPS : false
     showTS : false
     showDS : false
@@ -15,9 +15,13 @@ Mu2eEventDisplay : {
     showTracker : true
     showCaloCrystals : true
     addErrBar : true
-    addCrystalHits : false
-    addCRVBars : false
-    addKalInter : false
+    addCrystalHits : true
+    addCrvBars : true
+    addKalInter : true
+    addTrkStrawHits : true //why are these at module level and not "filler" - presumably because the dont need to access any collections from the event
+    addTrkCaloHits: true
+    seqMode : true
+    strawdisplay : false
     specifyTag : false // IMPORTANT: override to make the following selections!!!
     filler : {
       diagLevel : 0
@@ -32,24 +36,25 @@ Mu2eEventDisplay : {
       HelixSeedCollection : ["MHFinderDe"]
       CosmicTrackSeedCollection : "CosmicTrackFinderTimeFit"
       MCTrajectoryCollection :  ["compressRecoMCs"]
-#      SurfaceStepCollection :  ["compressRecoMCs"]
-      SurfaceStepCollection :  []
+      SurfaceStepCollection :  ["compressRecoMCs"]
       SimParticleCollection :  ["compressSTMDet"]
       addHits : false
       addBkgClusters : false
       addCrvHits : false
       addCrvClusters : false
       addTimeClusters : false
-      addTrkHits : false
+      addTrkHits : false //Combo hits?
       addCaloDigis : false
-      addClusters : false
-      addKalSeeds : false
+      addClusters : true
+      addKalSeeds : true
       addCosmicTrackSeeds : false
       addMCTraj : true
       addSurfSteps : true
-      addSimParts : true
+      addSimParts : false
+      addHelixSeeds : false
       FillAll : false
     }
+
     particles :   [11,13,2212,2112,211,22,212]
     strawdisplay : false
     extracted : false
diff --git a/inc/CollectionFiller.hh b/inc/CollectionFiller.hh
index 9e8fb0a..37665d9 100644
--- a/inc/CollectionFiller.hh
+++ b/inc/CollectionFiller.hh
@@ -14,80 +14,147 @@
 #include <TGListBox.h>
 
 #include "EventDisplay/inc/DataCollections.hh"
-
 namespace mu2e{
 
-  enum RecoDataProductName {ComboHits,  BkgClusters, CrvRecoPulses, TimeClusters, CaloClusters, HelixSeeds, KalSeeds, CosmicTrackSeeds, TrkHits, CrvCoincidenceCluster, CaloDigis};
-  enum MCDataProductName {MCTrajectories, SurfaceSteps, SimParticles};
-  class CollectionFiller
-  {
+    // --- Enumerations for Data Product Selection ---
+    
+    /**
+     * @brief Enum listing all reconstructed data products supported by the display.
+     * Used as a code in FillRecoCollections to retrieve a specific product type.
+     */
+    enum RecoDataProductName {
+        ComboHits, CrvRecoPulses, TimeClusters, CaloClusters, HelixSeeds, 
+        KalSeeds, CosmicTrackSeeds, TrkHits, CrvCoincidenceCluster, CaloDigis
+    };
+    
+    /**
+     * @brief Enum listing all Monte Carlo data products supported by the display.
+     * Used as a code in FillMCCollections.
+     */
+    enum MCDataProductName {
+        MCTrajectories, SurfaceSteps, SimParticles
+    };
+    
+    /**
+     * @brief Class responsible for configuring data product retrieval from the Art event.
+     */
+    class CollectionFiller
+    {
     public:
-      struct Config{
-        using Name=fhicl::Name;
-        using Comment=fhicl::Comment;
-        fhicl::Atom<int> diagLevel{Name("diagLevel"), Comment("for info"),0};
-        fhicl::Sequence<art::InputTag>chTag{Name("ComboHitCollection"),Comment("chTag")};
-        fhicl::Sequence<art::InputTag>bcTag{Name("BkgClusterCollection"),Comment("bcTag")};
-        fhicl::Sequence<art::InputTag>tcTag{Name("TimeClusterCollection"),Comment("ttcTag")};
-        fhicl::Sequence<art::InputTag>crvrecoTag{Name("CrvRecoPulseCollection"),Comment("crvTag")};
-        fhicl::Sequence<art::InputTag>crvcoinTag{Name("CrvCoincidenceClusterCollection"),Comment("crvcoinTag")};
-        fhicl::Sequence<art::InputTag>calodigTag{Name("CaloDigiCollection"),Comment("calodigTag")};
-        fhicl::Sequence<art::InputTag>cluTag{Name("CaloClusterCollection"),Comment("cluTag")};
-        fhicl::Sequence<art::InputTag>helixSeedTag{Name("HelixSeedCollection"),Comment("helixseedTag")};
-        fhicl::Sequence<art::InputTag>kalSeedTag{Name("KalSeedPtrCollection"),Comment("kalseedTag")};
-        fhicl::Atom<art::InputTag>cosmicTrackSeedTag{Name("CosmicTrackSeedCollection"),Comment("cosmicTrackSeedTag")};
-        fhicl::Sequence<art::InputTag>MCTrajTag{Name("MCTrajectoryCollection"),Comment("MCTrajTag")};
-        fhicl::Sequence<art::InputTag>SurfStepsTag{Name("SurfaceStepCollection"),Comment("SurfaceSteps Collection Tag")};
-        fhicl::Sequence<art::InputTag>SimTag{Name("SimParticleCollection"),Comment("SimTag")};
-        fhicl::Atom<bool> addHits{Name("addHits"), Comment("set to add the hits"),false};
-        fhicl::Atom<bool> addBkgClusters{Name("addBkgClusters"), Comment("set to add the bkg clusters"),false};
-        fhicl::Atom<bool> addCrvHits{Name("addCrvHits"), Comment("set to add crv hits"),false};
-        fhicl::Atom<bool> addCrvClusters{Name("addCrvClusters"), Comment("set to add crv clusters"),false};
-        fhicl::Atom<bool> addTimeClusters{Name("addTimeClusters"), Comment("set to add the Crv hits"),false};
-        fhicl::Atom<bool> addTrkHits{Name("addTrkHits"), Comment("set to add the Trk hits"),false};
-        fhicl::Atom<bool> addCaloDigis{Name("addCaloDigis"), Comment("set to add calodigis"),false};
-        fhicl::Atom<bool> addClusters{Name("addClusters"), Comment("set to add caloclusters"),false};
-        fhicl::Atom<bool> addHelixSeeds{Name("addHelixSeeds"), Comment("set to add helixseeds"),false};
-        fhicl::Atom<bool> addKalSeeds{Name("addKalSeeds"), Comment("set to add kalseeds"),false};
-        fhicl::Atom<bool> addCosmicTrackSeeds{Name("addCosmicTrackSeeds"), Comment("set to add cosmic track seeds"),false};
-        fhicl::Atom<bool> addMCTraj{Name("addMCTraj"), Comment("set to add MCTrajectories"),false};
-        fhicl::Atom<bool> addSurfSteps{Name("addSurfSteps"), Comment("set to add SurfaceStep MC"),false};
-        fhicl::Atom<bool> addSimParts{Name("addSimParts"), Comment("set to add SimParticles MC"),false};
-        fhicl::Atom<bool> FillAll{Name("FillAll"), Comment("to see all available products"), false};
-      };
+        // --- FHiCL Configuration Struct ---
+        /**
+         * @brief Defines the structure of the configuration parameters for CollectionFiller
+         * as read from the FHiCL file.
+         */
+        struct Config{
+            using Name=fhicl::Name;
+            using Comment=fhicl::Comment;
+            
+            // Debugging level
+            fhicl::Atom<int> diagLevel{Name("diagLevel"), Comment("for info"),0};
+            
+            // FHiCL Sequences for product tags (Art InputTags) - multiple instances allowed
+            fhicl::Sequence<art::InputTag>chTag{Name("ComboHitCollection"),Comment("chTag")};
+            fhicl::Sequence<art::InputTag>bcTag{Name("BkgClusterCollection"),Comment("bcTag")};
+            fhicl::Sequence<art::InputTag>tcTag{Name("TimeClusterCollection"),Comment("ttcTag")};
+            fhicl::Sequence<art::InputTag>crvrecoTag{Name("CrvRecoPulseCollection"),Comment("crvTag")};
+            fhicl::Sequence<art::InputTag>crvcoinTag{Name("CrvCoincidenceClusterCollection"),Comment("crvcoinTag")};
+            fhicl::Sequence<art::InputTag>calodigTag{Name("CaloDigiCollection"),Comment("calodigTag")};
+            fhicl::Sequence<art::InputTag>cluTag{Name("CaloClusterCollection"),Comment("cluTag")};
+            fhicl::Sequence<art::InputTag>helixSeedTag{Name("HelixSeedCollection"),Comment("helixseedTag")};
+            fhicl::Sequence<art::InputTag>kalSeedTag{Name("KalSeedPtrCollection"),Comment("kalseedTag")};
+            
+            // FHiCL Atom for a single product tag (one instance expected)
+            fhicl::Atom<art::InputTag>cosmicTrackSeedTag{Name("CosmicTrackSeedCollection"),Comment("cosmicTrackSeedTag")};
+            
+            // MC product tags
+            fhicl::Sequence<art::InputTag>MCTrajTag{Name("MCTrajectoryCollection"),Comment("MCTrajTag")};
+            fhicl::Sequence<art::InputTag>SurfStepsTag{Name("SurfaceStepCollection"),Comment("SurfaceSteps Collection Tag")};
+            fhicl::Sequence<art::InputTag>SimTag{Name("SimParticleCollection"),Comment("SimTag")};
+            
+            // Boolean flags to enable/disable loading of specific collection types
+            fhicl::Atom<bool> addHits{Name("addHits"), Comment("set to add the hits"),false}; // Corresponds to ComboHits
+            fhicl::Atom<bool> addBkgClusters{Name("addBkgClusters"), Comment("set to add the bkg clusters"),false}; // Corresponds to bkg clusters
+            fhicl::Atom<bool> addCrvRecoPulse{Name("addCrvRecoPulse"), Comment("set to add crv hits"),false}; // Corresponds to CrvRecoPulses
+            fhicl::Atom<bool> addCrvClusters{Name("addCrvClusters"), Comment("set to add crv clusters"),false}; // Corresponds to CrvCoincidenceCluster
+            fhicl::Atom<bool> addTimeClusters{Name("addTimeClusters"), Comment("set to add the Crv hits"),false};
+            fhicl::Atom<bool> addTrkHits{Name("addTrkHits"), Comment("set to add the Trk hits"),false}; // Alias for ComboHits/TrkHits
+            fhicl::Atom<bool> addCaloDigis{Name("addCaloDigis"), Comment("set to add calodigis"),false};
+            fhicl::Atom<bool> addClusters{Name("addClusters"), Comment("set to add caloclusters"),false};
+            fhicl::Atom<bool> addHelixSeeds{Name("addHelixSeeds"), Comment("set to add helixseeds"),false};
+            fhicl::Atom<bool> addKalSeeds{Name("addKalSeeds"), Comment("set to add kalseeds"),false};
+            fhicl::Atom<bool> addCosmicTrackSeeds{Name("addCosmicTrackSeeds"), Comment("set to add cosmic track seeds"),false};
+            fhicl::Atom<bool> addMCTraj{Name("addMCTraj"), Comment("set to add MCTrajectories"),false};
+            fhicl::Atom<bool> addSurfSteps{Name("addSurfSteps"), Comment("set to add SurfaceStep MC"),false};
+            fhicl::Atom<bool> addSimParts{Name("addSimParts"), Comment("set to add SimParticles MC"),false};
+            
+            // Global flag to attempt retrieval of all collections found in the event
+            fhicl::Atom<bool> FillAll{Name("FillAll"), Comment("to see all available products"), false};
+        };
 
-      explicit CollectionFiller(const Config& conf);
-      CollectionFiller(const CollectionFiller &);
-      CollectionFiller& operator=(const CollectionFiller &);
+        // --- Constructors and Operators ---
+        
+        /**
+         * @brief Primary constructor; accepts and initializes member variables from the FHiCL Config struct.
+         * @param conf The FHiCL configuration object.
+         */
+        explicit CollectionFiller(const Config& conf);
+        
+        // Disable copy constructor and assignment operator to prevent issues with Art pointers/handles
+        CollectionFiller(const CollectionFiller &);
+        CollectionFiller& operator=(const CollectionFiller &);
 
-      std::vector<art::InputTag> chTag_;
-      std::vector<art::InputTag> bcTag_;
-      std::vector<art::InputTag> tcTag_;
-      std::vector<art::InputTag> crvrecoTag_;
-      std::vector<art::InputTag> crvcoinTag_;
-      std::vector<art::InputTag> calodigTag_;
-      std::vector<art::InputTag> cluTag_;
-      std::vector<art::InputTag> helixSeedTag_;
-      std::vector<art::InputTag> kalSeedTag_;
-      art::InputTag cosmicTrackSeedTag_;
-      std::vector<art::InputTag> MCTrajTag_;
-      std::vector<art::InputTag> SurfStepsTag_;
-      std::vector<art::InputTag> SimTag_;
-      art::Event *_event;
-      art::Run *_run;
-      bool addHits_,  addBkgClusters_, addCrvHits_, addCrvClusters_, addTimeClusters_, addTrkHits_, addCaloDigis_, addClusters_, addHelixSeeds_, addKalSeeds_, addCosmicTrackSeeds_, addMCTraj_,
-           addSurfSteps_, addSimParts_, FillAll_;
-      void FillRecoCollections(const art::Event& evt, DataCollections &data, RecoDataProductName code);
-      void FillMCCollections(const art::Event& evt, DataCollections &data, MCDataProductName code);
-      //template <class L> void test(const L& item);
-      //template <class T, class V> int FillAllCollections(const art::Event& evt, std::vector<std::shared_ptr<V>>& list);
-      virtual ~CollectionFiller(){};
+        // --- Input Tag Members (Filled from FHiCL config) ---
+        // These store the actual InputTags used by art::Event::getValidHandle().
+        std::vector<art::InputTag> chTag_;
+        std::vector<art::InputTag> bcTag_;
+        std::vector<art::InputTag> tcTag_;
+        std::vector<art::InputTag> crvrecoTag_;
+        std::vector<art::InputTag> crvcoinTag_;
+        std::vector<art::InputTag> calodigTag_;
+        std::vector<art::InputTag> cluTag_;
+        std::vector<art::InputTag> helixSeedTag_;
+        std::vector<art::InputTag> kalSeedTag_;
+        art::InputTag cosmicTrackSeedTag_;
+        std::vector<art::InputTag> MCTrajTag_;
+        std::vector<art::InputTag> SurfStepsTag_;
+        std::vector<art::InputTag> SimTag_;
+        
+        // --- Event/Run Pointers (Optional: may be set externally for easy access) ---
+        art::Event *_event;
+        art::Run *_run;
+        
+        // --- Boolean Control Flags (Copied from FHiCL Config) ---
+        bool addHits_, addBkgClusters_, addCrvRecoPulse_, addCrvClusters_, addTimeClusters_, addTrkHits_, addCaloDigis_, 
+             addClusters_, addHelixSeeds_, addKalSeeds_, addCosmicTrackSeeds_, addMCTraj_,
+             addSurfSteps_, addSimParts_, FillAll_;
+             
+        // --- Collection Retrieval Methods ---
+        
+        /**
+         * @brief Fills the DataCollections structure with requested reconstructed data products.
+         * @param evt The current Art event.
+         * @param data The structure to populate with product pointers and labels.
+         * @param code The specific RecoDataProductName to retrieve (if FillAll_ is false).
+         */
+        void FillRecoCollections(const art::Event& evt, DataCollections &data, RecoDataProductName code);
+        
+        /**
+         * @brief Fills the DataCollections structure with requested Monte Carlo data products.
+         * @param evt The current Art event.
+         * @param data The structure to populate with product pointers and labels.
+         * @param code The specific MCDataProductName to retrieve (if FillAll_ is false).
+         */
+        void FillMCCollections(const art::Event& evt, DataCollections &data, MCDataProductName code);
+        
+        // Default virtual destructor
+        virtual ~CollectionFiller(){};
 
     private:
-      Config _conf;
-
-  };
+        // Copy of the FHiCL configuration object (if needed internally after construction)
+        Config _conf;
 
+    };
 }
 
 #endif
diff --git a/inc/DataInterface.hh b/inc/DataInterface.hh
index 2c48111..65655a3 100644
--- a/inc/DataInterface.hh
+++ b/inc/DataInterface.hh
@@ -8,8 +8,10 @@
 #include <ROOT/REveBox.hxx>
 #include <ROOT/REveScene.hxx>
 #include <ROOT/REveCompound.hxx>
+
 #include <TGeoBBox.h>
 #include <TGeoMatrix.h>
+#include <TStyle.h>
 #include <ROOT/REveTrackPropagator.hxx>
 #include <ROOT/REveTrans.hxx>
 #include "Offline/RecoDataProducts/inc/CrvCoincidenceCluster.hh"
@@ -40,6 +42,7 @@
 #include <vector>
 #include <tuple>
 #include <algorithm>
+#include <stdexcept>
 
 using namespace mu2e;
 namespace REX = ROOT::Experimental;
@@ -58,17 +61,17 @@ namespace mu2e{
           void AddBkgClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const BkgClusterCollection*>> bkgcluster_tuple, REX::REveElement* &scene);
           void AddComboHits(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const ComboHitCollection*>> combohit_tuple, REX::REveElement* &scene, bool strawdisplay, bool AddErrBar);
           void AddTimeClusters(REX::REveManager *&eveMng, bool firstloop, std::tuple<std::vector<std::string>, std::vector<const TimeClusterCollection*>> timecluster_tuple, REX::REveElement* &scene);
-          void AddTrkHits(REX::REveManager *&eveMng, bool firstLoop_,  std::tuple<std::vector<std::string>, std::vector<const ComboHitCollection*>> combohit_tuple, std::tuple<std::vector<std::string>, std::vector<const KalSeedPtrCollection*>> track_tuple, REX::REveElement* &scene);
           void AddCaloDigis(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CaloDigiCollection*>> calodigi_tuple, REX::REveElement* &scene);
-          void AddCaloClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CaloClusterCollection*>> calocluster_tuple, REX::REveElement* &scene, bool addCrystalDraw, double t1, double t2);
-          void AddCRVInfo(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CrvRecoPulseCollection*>> crvpulse_tuple, REX::REveElement* &scene, bool extracted, bool addCRVBars);
-          void AddCRVClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CrvCoincidenceClusterCollection*>>  crvpulse_tuple, REX::REveElement* &scene, bool extracted, bool addCRVBars);
+          void AddCaloClusterLegend(REX::REveElement* scene, double t_ref);
+          void AddCaloClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CaloClusterCollection*>> calocluster_tuple, REX::REveElement* &scene, bool addCrystalDraw);
+          void AddCrvInfo(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CrvRecoPulseCollection*>> crvpulse_tuple, REX::REveElement* &scene, bool extracted, bool addCrvBars);
+          void AddCrvClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CrvCoincidenceClusterCollection*>>  crvpulse_tuple, REX::REveElement* &scene, bool extracted, bool addCrvBars);
           void AddHelixSeedCollection(REX::REveManager *&eveMng,bool firstloop,  std::tuple<std::vector<std::string>, std::vector<const HelixSeedCollection*>> helix_tuple, REX::REveElement* &scene);
-          void AddKalIntersection(KalSeed const& kalseed, REX::REveElement* &scene, REX::REveCompound *products);
+          void AddKalIntersection(KalSeed const& kalseed, REX::REveElement* &scene, REX::REveCompound *products, std::string track_tag);
           template<class KTRAJc> void AddTrkStrawHit(KalSeed const& kalseed, REX::REveElement* &scene, std::unique_ptr<KTRAJc> &trajectory, REX::REveCompound *products);
           void AddTrkCaloHit(KalSeed const& kalseed, REX::REveElement* &scene);
           template<class KTRAJ> void AddKinKalTrajectory( std::unique_ptr<KTRAJ> &trajectory, REX::REveElement* &scene, unsigned int j, std::string kaltitle, double& t1, double& t2);
-          void FillKinKalTrajectory(REX::REveManager *&eveMng, bool firstloop, REX::REveElement* &scene, std::tuple<std::vector<std::string>, std::vector<const KalSeedPtrCollection*>> track_tuple, bool kalinter, bool hits, double& t1, double& t2);
+          void FillKinKalTrajectory(REX::REveManager *&eveMng, bool firstloop, REX::REveElement* &scene, std::tuple<std::vector<std::string>, std::vector<const KalSeedPtrCollection*>> track_tuple, bool kalinter, bool hits, bool calohits, double& t1, double& t2);
           void AddCosmicTrackFit(REX::REveManager *&eveMng, bool firstLoop_, const mu2e::CosmicTrackSeedCollection *cosmiccol, REX::REveElement* &scene);
 
           #endif
diff --git a/inc/DataProduct.hh b/inc/DataProduct.hh
index 8346a0f..ba611fa 100644
--- a/inc/DataProduct.hh
+++ b/inc/DataProduct.hh
@@ -2,19 +2,42 @@
 #define DataProduct_HH_
 
 #include <string>
-
 namespace mu2e {
 
-  class DataProduct {
-   public:
-    DataProduct(std::string name) : _name(name) {};
-    DataProduct(){};
-    std::string& name() { return _name; }
+    /**
+     * @brief A simple utility class to hold a string name for a data product.
+     * * In the context of a large experiment like Mu2e, this class might be used
+     * to consistently track the human-readable label (e.g., the Art InputTag)
+     * of a collection being visualized.
+     */
+    class DataProduct {
+    public:
+        
+        /**
+         * @brief Constructor that initializes the name member.
+         * @param name The string name to assign to this data product.
+         */
+        DataProduct(std::string name) : _name(name) {};
+        
+        /**
+         * @brief Default constructor. Initializes name to an empty string.
+         */
+        DataProduct(){}; 
+        
+        /**
+         * @brief Accessor method for the private name member.
+         * Returns a reference, allowing the name to be modified (read/write access).
+         * @return std::string& A reference to the internal name string.
+         */
+        std::string& name() { 
+            return _name; 
+        }
 
-   private:
-    std::string _name;
+    private:
+        // The private member storing the product's identifying name/label.
+        std::string _name; 
 
-  };
+    };
 }  // namespace mu2e
 
 #endif
diff --git a/inc/EventDisplayManager.hh b/inc/EventDisplayManager.hh
index 16b5802..144bf71 100644
--- a/inc/EventDisplayManager.hh
+++ b/inc/EventDisplayManager.hh
@@ -11,6 +11,7 @@
 #include "EventDisplay/inc/GUI.hh"
 #include "EventDisplay/inc/TextSelect.hh"
 #include "nlohmann/json.hpp"
+#include <ROOT/REveManager.hxx>
 
 namespace ROOT::Experimental {
   class REveManager;
@@ -18,32 +19,82 @@ namespace ROOT::Experimental {
 
 namespace mu2e {
 
-  constexpr auto invalid_event = std::numeric_limits<unsigned>::max();
-
-  class EventDisplayManager : public ROOT::Experimental::REveElement {
+    /**
+     * @brief Manages event flow, commands, and synchronization between the Art analysis thread
+     * and the dedicated ROOT/REve display thread.
+     * Inherits from ROOT::Experimental::REveElement to receive browser commands.
+     */
+    class EventDisplayManager : public ROOT::Experimental::REveElement {
     public:
-      EventDisplayManager() = default; // ROOT needs a dictionary
-
-      explicit EventDisplayManager(ROOT::Experimental::REveManager* eveMgr,
-                                       std::condition_variable& cv,
-                                       std::mutex& m,
-                                       GUI *fGui,
-                                       TextSelect *fText);
-
-    void NextEvent();
-    void QuitRoot();
-    void autoplay(int x);
-    int getR();
-    void setR(int runId);
-    void goToRunEvent(int runId, int eventId);
-    int run{0};
+        // Default constructor required by ROOT's dictionary generation mechanism.
+        EventDisplayManager() = default; 
+
+        /**
+         * @brief Primary constructor for initializing thread synchronization and manager pointers.
+         * @param eveMgr The global REveManager instance.
+         * @param cv The condition variable for inter-thread signaling (notify/wait).
+         * @param m The mutex for protecting access and for condition variable use.
+         * @param fGui Pointer to the custom GUI element instance.
+         */
+        explicit EventDisplayManager(ROOT::Experimental::REveManager* eveMgr,
+                                    std::condition_variable& cv,
+                                    std::mutex& m,
+                                    GUI *fGui);
+
+        // --- REve Command Methods (Invoked by browser buttons) ---
+
+        /**
+         * @brief Command to signal the Art analysis thread to load the next event.
+         */
+        void NextEvent(); 
+        
+        /**
+         * @brief Command to terminate the ROOT application and the job gracefully.
+         */
+        void QuitRoot();
+
+        void autoplay(int x);
+
+        /**
+         * @brief Command to handle user input and trigger loading a specific Run and Event ID.
+         * * This function runs in the REve thread and uses fTextId_ to look up the TextSelect object.
+         */
+        void goToRunEvent(int runId, int eventId);
+
+        // --- Public Members ---
+
+        // Stores the current Run ID, often used by commands or display logic.
+        int run{0}; 
+
+        // Stores the unique REve Element ID (EId_t) of the TextSelect object.
+        // This is the robust mechanism for looking up the TextSelect element.
+        std::uint32_t fTextId_{0}; 
+        
+        /**
+         * @brief Setter to store the unique REve Element ID after the object is added to the World.
+         * @param textId The assigned REve Element ID.
+         */
+        void setTextSelectId(std::uint32_t textId);
+        int id_;
+        void setid(int id){ id_ = id;}
     private:
-      ROOT::Experimental::REveManager* eveMng_{nullptr};
-      std::condition_variable* cv_{nullptr};
-      std::mutex* m_{nullptr};
-      bool doneProcessingEvents_{false};
-      GUI *fGui_{nullptr};
-      TextSelect *fText_{nullptr};
+
+        // Pointer to the global REve manager, controlling all visualization.
+        ROOT::Experimental::REveManager* eveMng_{nullptr}; 
+        
+        // Pointer to the condition variable, used to unblock the Art thread (e.g., in analyze()).
+        std::condition_variable* cv_{nullptr};             
+        
+        // Pointer to the mutex, used for thread synchronization (locking data access and cv_ usage).
+        std::mutex* m_{nullptr};                           
+        
+        // Pointer to the custom GUI element instance.
+        GUI *fGui_{nullptr};                               
+        
+        // Raw pointer to the TextSelect element. While fTextId_ is preferred for lookup, 
+        // this is kept for direct access if necessary (but is less robust).
+        TextSelect *fText_{nullptr};
+        
     };
 }
 
diff --git a/inc/GUI.hh b/inc/GUI.hh
index dac9699..462336b 100644
--- a/inc/GUI.hh
+++ b/inc/GUI.hh
@@ -7,21 +7,38 @@ namespace REX = ROOT::Experimental;
 using namespace ROOT::Experimental;
 
 namespace mu2e {
+/**
+ * @brief Represents the custom Graphical User Interface component within the REve visualization.
+ * * This class holds the event metadata and overrides methods to push that data to the web client.
+ * Inherits from REveElement so it can be added to the REve scene and participate in state updates.
+ */
 class GUI : public ROOT::Experimental::REveElement
 {
   public:
+     // --- Event Display Variables (Set by the Art thread) ---
+     
+     // Current Event ID being displayed. Used when writing to JSON.
      int feventid{0};
+     // Current Subrun ID being displayed.
      int fsubrunid{0};
+     // Current Run ID being displayed.
      int frunid{0};
+
+     // --- REve Overrides and Communication ---
+
+     /**
+      * @brief Overrides the base method to serialize custom class data into a JSON stream.
+      * * This is the crucial function that sends feventid/frunid to the web browser client.
+      * @param j The nlohmann::json object to populate.
+      * @param rnr_offset The rendering offset (typically 0).
+      * @return int Status code from the base class.
+      */
      int WriteCoreJson(nlohmann::json &j, int rnr_offset) override;
-     void setRun(int run);
-     void setEvent(int event);
-     void getRunEvent();
-     void PrintEventInfo();
+
+     // Storage for the Run number requested by the user.
      int runNumber{0};
+     // Storage for the Event number requested by the user.
      int eventNumber{0};
-
 };
 }
-
 #endif
diff --git a/inc/GeomUtil.hh b/inc/GeomUtil.hh
deleted file mode 100644
index d5248b7..0000000
--- a/inc/GeomUtil.hh
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _GeomUtil_hh
-#define _GeomUtil_hh
-
-#include <ROOT/REveElement.hxx>
-#include <ROOT/REveManager.hxx>
-
-#include "Offline/StoppingTargetGeom/inc/StoppingTarget.hh"
-#include "Offline/GeometryService/inc/DetectorSystem.hh"
-
-namespace REX = ROOT::Experimental;
-
-namespace mu2e {
-    class GeomUtil  : public REX::REveElement {
-
-        public :
-            explicit GeomUtil() { SetErrorHandler(DefaultErrorHandler); }
-            virtual ~GeomUtil() {}
-            #ifndef __CINT__
-            double FindStoppingTarget_z();
-            double GetStoppingTarget_z(){ return StoppingTarget_z; }
-            double StoppingTarget_z;
-
-            #endif
-            ClassDef(GeomUtil, 0);
-
-
-
-      };
-
-}
-#endif
diff --git a/inc/MCInterface.hh b/inc/MCInterface.hh
index 1a25705..11c23b3 100644
--- a/inc/MCInterface.hh
+++ b/inc/MCInterface.hh
@@ -14,6 +14,7 @@
 #include "Offline/MCDataProducts/inc/SurfaceStep.hh"
 #include "Offline/MCDataProducts/inc/SimParticle.hh"
 #include "Offline/MCDataProducts/inc/MCRelationship.hh"
+#include "Offline/MCDataProducts/inc/ProcessCode.hh"
 #include <TApplication.h>
 #include <TEvePad.h>
 #include <TObject.h>
diff --git a/inc/MainWindow.hh b/inc/MainWindow.hh
index 56ee55a..4c4733b 100644
--- a/inc/MainWindow.hh
+++ b/inc/MainWindow.hh
@@ -43,7 +43,6 @@
 #include "EventDisplay/inc/DataCollections.hh"
 #include "EventDisplay/inc/DataInterface.hh"
 #include "EventDisplay/inc/MCInterface.hh"
-#include "EventDisplay/inc/GeomUtil.hh"
 #include "Offline/StoppingTargetGeom/inc/StoppingTarget.hh"
 
 #include <utility>
@@ -54,7 +53,7 @@ namespace mu2e {
 
   struct GeomOptions{
       // geom options
-      bool showCRV = false;
+      bool showCrv = false;
       bool showPS = false;
       bool showTS = false;
       bool showDS = false;
@@ -69,9 +68,9 @@ namespace mu2e {
       bool showEM = false;
       GeomOptions(){};
       GeomOptions(bool crv, bool ps, bool ts, bool ds, bool twodim, bool cVST, bool st, bool ext, bool stm, bool calo, bool trk, bool crys, bool em)
-      : showCRV(crv), showPS(ps), showTS(ts), showDS(ds), show2D(twodim), caloVST(cVST), showST(st), extracted(ext), showSTM(stm), showCalo(calo), showTracker(trk), showCaloCrystals(crys), showEM(em) {};
+      : showCrv(crv), showPS(ps), showTS(ts), showDS(ds), show2D(twodim), caloVST(cVST), showST(st), extracted(ext), showSTM(stm), showCalo(calo), showTracker(trk), showCaloCrystals(crys), showEM(em) {};
       void fill(bool crv, bool ps, bool ts, bool ds, bool twodim, bool cVST, bool st, bool ext, bool stm, bool cal, bool trk, bool crys, bool em) {
-        showCRV = (crv);
+        showCrv = (crv);
         showPS = (ps);
         showTS = (ts);
         showDS = (ds);
@@ -87,7 +86,7 @@ namespace mu2e {
       }
       void print(){
         std::cout<<"***** Geom Options ****** "<<'\n'
-        <<" show CRV : "<<showCRV <<'\n'
+        <<" show Crv : "<<showCrv <<'\n'
         <<" show PS : "<<showPS <<'\n'
         <<" show TS : "<<showTS <<'\n'
         <<" show DS : "<<showDS <<'\n'
@@ -122,9 +121,11 @@ namespace mu2e {
       bool addCaloDigis = false;
       bool addClusters = false;
       bool addComboHits = false;
+
       bool addBkgClusters = false;
-      bool addCRVInfo = false;
-      bool addCRVClusters = false;
+      bool addCrvRecoPulse = false;
+      bool addCrvClusters = false;
+
       bool addTimeClusters = false;
       bool addTrkHits = false; // legacy
       bool addMCTrajectories = false;
@@ -132,10 +133,12 @@ namespace mu2e {
       bool addSimParts = false;
       bool addTrkErrBar = true;
       bool addCrystalDraw = false;
-      bool addCRVBars = true;
+      bool addCrvBars = true;
       DrawOptions(){};
+
       DrawOptions(bool cosmictracks, bool helices, bool tracks, bool calodigis, bool clusters, bool combohits, bool bkgclusters, bool crv, bool crvclu, bool timeclusters, bool trkhits, bool mctraj, bool surfsteps, bool simparts, bool errbar, bool crys, bool crvbars)
-        : addCosmicTracks(cosmictracks), addHelices(helices), addTracks(tracks), addCaloDigis(calodigis), addClusters(clusters), addComboHits(combohits), addBkgClusters(bkgclusters), addCRVInfo(crv), addCRVClusters(crvclu), addTimeClusters(timeclusters), addTrkHits(trkhits), addMCTrajectories(mctraj), addSurfaceSteps(surfsteps), addSimParts(simparts), addTrkErrBar(errbar), addCrystalDraw(crys), addCRVBars(crvbars) {};
+      : addCosmicTracks(cosmictracks), addHelices(helices), addTracks(tracks), addCaloDigis(calodigis), addClusters(clusters), addComboHits(combohits), addCrvRecoPulse(crv), addCrvClusters(crvclu), addTimeClusters(timeclusters), addTrkHits(trkhits), addMCTrajectories(mctraj), addSurfaceSteps(surfsteps), addSimParts(simparts), addTrkErrBar(errbar), addCrystalDraw(crys), addCrvBars(crvbars) {};
+
      };
 
     class MainWindow  : public REX::REveElement {
diff --git a/inc/PrintInfo.hh b/inc/PrintInfo.hh
index f71b7e3..58fa12f 100644
--- a/inc/PrintInfo.hh
+++ b/inc/PrintInfo.hh
@@ -16,44 +16,75 @@
 
 namespace REX = ROOT::Experimental;
 using namespace ROOT::Experimental;
-
 namespace mu2e {
+
+/**
+ * @brief REve element responsible for holding event data pointers and printing diagnostic information.
+ * * This element is added to the REve World and is the target for print commands issued from the browser.
+ * * The member variables (tuples) are populated by the Mu2eEventDisplay::analyze() method.
+ */
 class PrintInfo : public ROOT::Experimental::REveElement
 {
   public:
-     PrintInfo() = default;
-     const mu2e::CaloClusterCollection* clustercol = 0;
-     std::vector<const mu2e::CaloClusterCollection*> calocluster_list;
-     std::vector<std::string> calocluster_labels;
-     std::tuple<std::vector<std::string>, std::vector<const mu2e::CaloClusterCollection*>> fcalocluster_tuple;
-
-     const mu2e::MCTrajectoryCollection *mctrajcol = 0;
-     std::vector<const mu2e::MCTrajectoryCollection*> mctrack_list;
-     std::vector<std::string> mctrack_labels;
-     std::tuple<std::vector<std::string>, std::vector<const mu2e::MCTrajectoryCollection*>> fmctrack_tuple;
-     
-     const mu2e::SimParticleCollection *simcol = 0;
-     std::vector<const mu2e::SimParticleCollection*> sim_list;
-     std::vector<std::string> sim_labels;
-     std::tuple<std::vector<std::string>, std::vector<const mu2e::SimParticleCollection*>> fsim_tuple;
-
-     const mu2e::KalSeedPtrCollection* kalSeedcol = 0;
-     std::vector<const mu2e::KalSeedPtrCollection*> track_list;
-     std::vector<std::string> track_labels;
-     std::tuple<std::vector<std::string>, std::vector<const mu2e::KalSeedPtrCollection*>> ftrack_tuple;
-
-     const mu2e::CrvCoincidenceClusterCollection* crvcoincol = 0;
-     std::vector<const mu2e::CrvCoincidenceClusterCollection*> crvcoin_list;
-     std::vector<std::string> crvcoin_labels;
-     std::tuple<std::vector<std::string>, std::vector<const mu2e::CrvCoincidenceClusterCollection*>> fcrvcoin_tuple;
-
-     void PrintRecoInfo(); //prints everything which is there (tracks, clusters, CRV coin, not hits)
-     void PrintMCInfo(); // print MCs and SimParticles
-     void PrintSimInfo();
-     void PrintKalInfo();
-     void PrintCaloInfo();
-     void PrintCRVInfo();
-};
+    PrintInfo() : REveElement{"PrintInfo"} {} 
+
+    // --- Data Storage for CaloClusterCollection ---
+    const mu2e::CaloClusterCollection* clustercol = 0; // Single raw pointer (often for legacy use)
+    std::vector<const mu2e::CaloClusterCollection*> calocluster_list; // List of collection pointers
+    std::vector<std::string> calocluster_labels; // Labels corresponding to the collections
+    // Primary storage: Tuple of (Labels, Collection Pointers) for all CaloCluster products in the event
+    std::tuple<std::vector<std::string>, std::vector<const mu2e::CaloClusterCollection*>> fcalocluster_tuple;
+
+    // --- Data Storage for MCTrajectoryCollection ---
+    const mu2e::MCTrajectoryCollection *mctrajcol = 0; 
+    std::vector<const mu2e::MCTrajectoryCollection*> mctrack_list; 
+    std::vector<std::string> mctrack_labels;
+    // Primary storage: Tuple for all Monte Carlo Trajectory collections
+    std::tuple<std::vector<std::string>, std::vector<const mu2e::MCTrajectoryCollection*>> fmctrack_tuple;
+
+    // --- Data Storage for SimParticleCollection (Monte Carlo) ---
+    const mu2e::SimParticleCollection *simcol = 0; 
+    std::vector<const mu2e::SimParticleCollection*> sim_list; 
+    std::vector<std::string> sim_labels;
+    // Primary storage: Tuple for all SimParticle collections
+    std::tuple<std::vector<std::string>, std::vector<const mu2e::SimParticleCollection*>> fsim_tuple;
+
+    // --- Data Storage for KalSeedPtrCollection (Reconstruction) ---
+    const mu2e::KalSeedPtrCollection* kalSeedcol = 0; 
+    std::vector<const mu2e::KalSeedPtrCollection*> track_list; 
+    std::vector<std::string> track_labels;
+    // Primary storage: Tuple for all Kalman Seed collections (reconstructed tracks)
+    std::tuple<std::vector<std::string>, std::vector<const mu2e::KalSeedPtrCollection*>> ftrack_tuple;
+
+    // --- Data Storage for CrvCoincidenceClusterCollection (Reconstruction) ---
+    const mu2e::CrvCoincidenceClusterCollection* crvcoincol = 0; 
+    std::vector<const mu2e::CrvCoincidenceClusterCollection*> crvcoin_list; 
+    std::vector<std::string> crvcoin_labels;
+    // Primary storage: Tuple for all CRV Coincidence Cluster collections
+    std::tuple<std::vector<std::string>, std::vector<const mu2e::CrvCoincidenceClusterCollection*>> fcrvcoin_tuple;
+
+    // --- Print Command Methods (Invoked by REve commands) ---
+
+    /**
+     * @brief Prints summary information for reconstructed data products 
+     * (Tracks, CaloClusters, CRV Coincidence Clusters).
+     */
+    void PrintRecoInfo(); 
+
+    /**
+     * @brief Prints summary information for Monte Carlo data products 
+     * (MCTrajectories and SimParticles).
+     */
+    void PrintMCInfo(); 
+
+    // The following are more specialized print methods, likely called internally 
+    // by PrintRecoInfo/PrintMCInfo or bound to separate commands.
+    void PrintMCTrajInfo();
+    void PrintSimPartInfo();
+    void PrintKalInfo();
+    void PrintCaloInfo();
+    void PrintCRVInfo();
+    };
 }
 
 #endif
diff --git a/inc/TextSelect.hh b/inc/TextSelect.hh
index 43b3ab1..be950f5 100644
--- a/inc/TextSelect.hh
+++ b/inc/TextSelect.hh
@@ -2,6 +2,7 @@
 #define _TextSelect_hh
 
 #include <ROOT/REveElement.hxx>
+#include <mutex>
 
 namespace REX = ROOT::Experimental;
 using namespace ROOT::Experimental;
@@ -10,26 +11,24 @@ namespace mu2e {
 class TextSelect : public ROOT::Experimental::REveElement
 {
   public:
-    //TextSelect(int &test_) : test(test_){};
-    /*TextSelect() = default; // ROOT needs a dictionary
-    TextSelect(){};
-
-    explicit TextSelect(
-        int runn,
-        int eventn)
-        : REveElement{"TextSelect"}, runN(runn), eventN(eventn)
-      {}*/
+    // Constructor remains implicit or default
+    TextSelect() : REveElement{"TextSelect"} {} 
       
-       void set(int run, int event);
-       int get();
-       int setRun(int run);
-       //int test{0};
-   private:
+    // Setter (Called by the GUI thread/EventDisplayManager)
+    void set(int run, int event);
+
+    // Getter (Called by the art module thread)
+    // We now retrieve both run and event in one call for atomic safety
+    std::pair<int, int> getRunEvent(); // <<< Modified getter signature
+
+    // setAutoplay
+    void setAutoplay(int x);
+    int getAutoplay();
+    private:
      int runN = 0;
      int eventN = 0;
-     
-     
-     
+     int autoplay_=0;
+     std::mutex _mutex; // <<< The synchronization tool
 };
 }
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index aeb209f..c7363e0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -13,7 +13,6 @@ cet_make_library(
       DataInterface.cc
       EventDisplayManager.cc
       GUI.cc
-      GeomUtil.cc
       MCInterface.cc
       MainWindow.cc
       PrintInfo.cc
diff --git a/src/CollectionFiller.cc b/src/CollectionFiller.cc
index fced478..d20b926 100644
--- a/src/CollectionFiller.cc
+++ b/src/CollectionFiller.cc
@@ -23,7 +23,7 @@ namespace mu2e{
     SimTag_(conf.SimTag()),
     addHits_(conf.addHits()),
     addBkgClusters_(conf.addBkgClusters()),
-    addCrvHits_(conf.addCrvHits()),
+    addCrvRecoPulse_(conf.addCrvRecoPulse()),
     addCrvClusters_(conf.addCrvClusters()),
     addTimeClusters_(conf.addTimeClusters()),
     addTrkHits_(conf.addTrkHits()),
@@ -38,25 +38,55 @@ namespace mu2e{
     FillAll_(conf.FillAll())
   {}
 
-  template <typename T> std::string TurnNameToString( const T& value )
+  /**
+ * @brief Converts any object or variable that can be streamed (via operator<<) 
+ * into a standard C++ string.
+ *
+ * This function uses a std::ostringstream to perform the conversion in a type-safe 
+ * and generic manner, relying on the type T's definition of operator<<.
+ *
+ * @tparam T The type of the value to be converted (e.g., int, double, a custom class).
+ * @param value The value of type T to convert.
+ * @return std::string The string representation of the input value.
+ */
+  template <typename T> 
+  std::string TurnNameToString( const T& value )
   {
-    std::ostringstream ss;
-    ss << value;
-    return ss.str();
+      // Create a std::ostringstream object. 
+      std::ostringstream ss;
+
+      // Insert the input 'value' into the string stream.
+      ss << value;
+
+      // Extract the final string from the string stream buffer and return it.
+      return ss.str();
   }
 
-  void CollectionFiller::FillRecoCollections(const art::Event& evt, DataCollections &data, RecoDataProductName CollectionName)  {
-    if(FillAll_  or (CollectionName == ComboHits)){
-      for(const auto &tag : chTag_){
-        auto chH = evt.getValidHandle<mu2e::ComboHitCollection>(tag);
-        data.chcol = chH.product();
-        data.combohit_list.push_back(data.chcol);
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting ComboHit Instance: "<<name<<std::endl;
-        data.combohit_labels.push_back(name);
-      }
-      data.combohit_tuple = std::make_tuple(data.combohit_labels,data.combohit_list);
+  /**
+ * @brief Retrieves specified reconstructed data products from the Art event.
+ * * It iterates over a list of Art tags (labels) for each product type to handle multiple
+ * instances of the same collection produced by different modules in the job.
+ * * @param evt The current art::Event object.
+ * @param data The DataCollections structure where pointers and labels are stored.
+ * @param CollectionName An enum value used to selectively fill one type of collection.
+ */
+void CollectionFiller::FillRecoCollections(const art::Event& evt, DataCollections &data, RecoDataProductName CollectionName) {
+    
+    // --- 1. ComboHits (Reconstructed Straw Tracker Hits) ---
+    if(FillAll_ or (CollectionName == ComboHits)){
+        for(const auto &tag : chTag_){
+            auto chH = evt.getValidHandle<mu2e::ComboHitCollection>(tag);
+            
+            data.chcol = chH.product();
+            data.combohit_list.push_back(data.chcol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting ComboHit Instance: "<<name<<std::endl;
+            data.combohit_labels.push_back(name);
+        }
+        data.combohit_tuple = std::make_tuple(data.combohit_labels,data.combohit_list);
     }
+
+    // --- 2. BkgClusters (Background hit clusters) ---
     if(FillAll_  or (CollectionName == BkgClusters)){
       for(const auto &tag : bcTag_){
         auto bcH = evt.getValidHandle<mu2e::BkgClusterCollection>(tag);
@@ -68,160 +98,178 @@ namespace mu2e{
       }
       data.bkgcluster_tuple = std::make_tuple(data.bkgcluster_labels,data.bkgcluster_list);
     }
-    if(FillAll_ or (addCrvHits_ and CollectionName==CrvRecoPulses)){
-      for(const auto &tag : crvrecoTag_){
-        auto chH = evt.getValidHandle<mu2e::CrvRecoPulseCollection>(tag);
-        data.crvrecocol = chH.product();
-        data.crvpulse_list.push_back(data.crvrecocol);
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting Crv Instance: "<<name<<"  "<<data.crvpulse_list.size()<<std::endl;
-        data.crvpulse_labels.push_back(name);
-      }
-      data.crvpulse_tuple = std::make_tuple(data.crvpulse_labels,data.crvpulse_list);
+
+    // --- 3. CrvRecoPulses (Crv Raw Reconstructed Hits) ---
+    if(FillAll_ or (addCrvRecoPulse_ and CollectionName==CrvRecoPulses)){
+        for(const auto &tag : crvrecoTag_){
+            auto chH = evt.getValidHandle<mu2e::CrvRecoPulseCollection>(tag);
+            data.crvrecocol = chH.product();
+            data.crvpulse_list.push_back(data.crvrecocol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting Crv Instance: "<<name<<"  "<<data.crvpulse_list.size()<<std::endl;
+            data.crvpulse_labels.push_back(name);
+        }
+        data.crvpulse_tuple = std::make_tuple(data.crvpulse_labels,data.crvpulse_list);
     }
+
+    
+    // --- 4. CrvCoincidenceClusters (Crv Coincidence Clusters) ---
     if(FillAll_ or (addCrvClusters_ and CollectionName==CrvCoincidenceCluster)){
-      std::cout << "Fill CrvClusters " << std::endl;
-      for(const auto &tag : crvcoinTag_){
-        std::cout << "Searching for tag " << tag << std::endl;
-        auto chH = evt.getValidHandle<mu2e::CrvCoincidenceClusterCollection>(tag);
-        data.crvcoincol = chH.product();
-        data.crvcoin_list.push_back(data.crvcoincol);
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting Crv Instance: "<<name<<"  "<<data.crvcoin_list.size()<<std::endl;
-        data.crvcoin_labels.push_back(name);
-      }
-      data.crvcoin_tuple = std::make_tuple(data.crvcoin_labels,data.crvcoin_list);
+        std::cout << "Fill CrvClusters " << std::endl;
+        for(const auto &tag : crvcoinTag_){
+            std::cout << "Searching for tag " << tag << std::endl;
+            auto chH = evt.getValidHandle<mu2e::CrvCoincidenceClusterCollection>(tag);
+            data.crvcoincol = chH.product();
+            data.crvcoin_list.push_back(data.crvcoincol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting Crv Instance: "<<name<<"  "<<data.crvcoin_list.size()<<std::endl;
+            data.crvcoin_labels.push_back(name);
+        }
+        data.crvcoin_tuple = std::make_tuple(data.crvcoin_labels,data.crvcoin_list);
     }
-    if(FillAll_  or (CollectionName == TimeClusters)){
-      for(const auto &tag : tcTag_){
-        auto chH = evt.getValidHandle<mu2e::TimeClusterCollection>(tag);
-        data.tccol = chH.product();
-        data.timecluster_list.push_back(data.tccol);
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting TimeCluster Instance: "<<name<<std::endl;
-        data.timecluster_labels.push_back(name);
-      }
-      data.timecluster_tuple = std::make_tuple(data.timecluster_labels,data.timecluster_list);
+    
+    // --- 5. TimeClusters (Seed Time Clusters) ---
+    if(FillAll_ or (CollectionName == TimeClusters)){
+        for(const auto &tag : tcTag_){
+            auto chH = evt.getValidHandle<mu2e::TimeClusterCollection>(tag);
+            data.tccol = chH.product();
+            data.timecluster_list.push_back(data.tccol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting TimeCluster Instance: "<<name<<std::endl;
+            data.timecluster_labels.push_back(name);
+        }
+        data.timecluster_tuple = std::make_tuple(data.timecluster_labels,data.timecluster_list);
     }
+    
+    // --- 6. TrkHits (ComboHits treated as Tracking Hits) ---
+    //FIXME - is this the same as the ComboHits version?
     if(FillAll_ or (addTrkHits_ and CollectionName == TrkHits)){
-      for(const auto &tag : chTag_){
-        auto chH = evt.getValidHandle<mu2e::ComboHitCollection>(tag);
-        data.chcol = chH.product();
-        data.combohit_list.push_back(data.chcol);
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting TrkHit Instance: "<<name<<std::endl;
-        data.combohit_labels.push_back(name);
-      }
-      data.combohit_tuple = std::make_tuple(data.combohit_labels,data.combohit_list);
+        for(const auto &tag : chTag_){
+            auto chH = evt.getValidHandle<mu2e::ComboHitCollection>(tag);
+            data.chcol = chH.product();
+            data.combohit_list.push_back(data.chcol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting TrkHit Instance: "<<name<<std::endl;
+            data.combohit_labels.push_back(name);
+        }
+        data.combohit_tuple = std::make_tuple(data.combohit_labels,data.combohit_list);
     }
-    if(FillAll_  or (CollectionName == CaloDigis)){
-      for(const auto &tag : calodigTag_){
-        auto chH = evt.getValidHandle<mu2e::CaloDigiCollection>(tag);
-        data.calodigicol = chH.product();
-        data.calodigi_list.push_back(data.calodigicol);
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting CaloDigi Instance: "<<name<<std::endl;
-        data.calodigi_labels.push_back(name);
-      }
-      data.calocluster_tuple = std::make_tuple(data.calocluster_labels,data.calocluster_list);
+    
+    // --- 7. CaloDigis (Raw Calorimeter Signal Samples) ---
+    if(FillAll_ or (CollectionName == CaloDigis)){
+        for(const auto &tag : calodigTag_){
+            auto chH = evt.getValidHandle<mu2e::CaloDigiCollection>(tag);
+            data.calodigicol = chH.product();
+            data.calodigi_list.push_back(data.calodigicol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting CaloDigi Instance: "<<name<<std::endl;
+            data.calodigi_labels.push_back(name);
+        }
+        data.calocluster_tuple = std::make_tuple(data.calocluster_labels,data.calocluster_list);
     }
-    if(FillAll_  or (CollectionName == CaloClusters)){
-      for(const auto &tag : cluTag_){
-        auto chH = evt.getValidHandle<mu2e::CaloClusterCollection>(tag);
-        data.clustercol = chH.product();
-        data.calocluster_list.push_back(data.clustercol);
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting CaloCluster Instance: "<<name<<std::endl;
-        data.calocluster_labels.push_back(name);
-      }
-      data.calocluster_tuple = std::make_tuple(data.calocluster_labels,data.calocluster_list);
+    
+    // --- 8. CaloClusters (Reconstructed Calorimeter Energy Clusters) ---
+    if(FillAll_ or (CollectionName == CaloClusters)){
+        for(const auto &tag : cluTag_){
+            auto chH = evt.getValidHandle<mu2e::CaloClusterCollection>(tag);
+            data.clustercol = chH.product();
+            data.calocluster_list.push_back(data.clustercol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting CaloCluster Instance: "<<name<<std::endl;
+            data.calocluster_labels.push_back(name);
+        }
+        data.calocluster_tuple = std::make_tuple(data.calocluster_labels,data.calocluster_list);
     }
+    
+    // --- 9. HelixSeeds (Pre-tracking Helix Fits) ---
     if(FillAll_ or (CollectionName==HelixSeeds)){
-
-      for(const auto &tag : helixSeedTag_){
-        auto chH = evt.getValidHandle<mu2e::HelixSeedCollection>(tag);
-        data.helixSeedcol = chH.product();
-        data.helix_list.push_back(data.helixSeedcol);
-
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting HelixSeed Instance: "<<name<<std::endl;
-        data.helix_labels.push_back(name);
-
-      }
-      data.helix_tuple = std::make_tuple(data.helix_labels,data.helix_list);
-
+        for(const auto &tag : helixSeedTag_){
+            auto chH = evt.getValidHandle<mu2e::HelixSeedCollection>(tag);
+            data.helixSeedcol = chH.product();
+            data.helix_list.push_back(data.helixSeedcol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting HelixSeed Instance: "<<name<<std::endl;
+            data.helix_labels.push_back(name);
+        }
+        data.helix_tuple = std::make_tuple(data.helix_labels,data.helix_list);
     }
+    
+    // --- 10. KalSeeds (Final Kalman Filter Tracks) ---
     if(FillAll_ or (CollectionName==KalSeeds)){
-
-      for(const auto &tag : kalSeedTag_){
-        auto chH = evt.getValidHandle<mu2e::KalSeedPtrCollection>(tag);
-        data.kalSeedcol = chH.product();
-        data.track_list.push_back(data.kalSeedcol);
-
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting KalSeed Instance: "<<name<<std::endl;
-        data.track_labels.push_back(name);
-
-      }
-      data.track_tuple = std::make_tuple(data.track_labels,data.track_list);
-
+        for(const auto &tag : kalSeedTag_){
+            auto chH = evt.getValidHandle<mu2e::KalSeedPtrCollection>(tag); 
+            data.kalSeedcol = chH.product();
+            data.track_list.push_back(data.kalSeedcol);
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting KalSeed Instance: "<<name<<std::endl;
+            data.track_labels.push_back(name);
+        }
+        data.track_tuple = std::make_tuple(data.track_labels,data.track_list);
     }
-    if(FillAll_  or (CollectionName == CosmicTrackSeeds)){
-      auto chH = evt.getValidHandle<mu2e::CosmicTrackSeedCollection>(cosmicTrackSeedTag_);
-      data.CosmicTrackSeedcol = chH.product();
+    
+    // --- 11. CosmicTrackSeeds (Cosmic Ray Track Candidates) --- // FIXME - is this needed?
+    if(FillAll_ or (CollectionName == CosmicTrackSeeds)){
+        auto chH = evt.getValidHandle<mu2e::CosmicTrackSeedCollection>(cosmicTrackSeedTag_);
+        data.CosmicTrackSeedcol = chH.product();
     }
-  }
+}
 
-  void CollectionFiller::FillMCCollections(const art::Event& evt, DataCollections &data, MCDataProductName CollectionName){
+/**
+ * @brief Retrieves specified Monte Carlo data products from the Art event.
+ * * It supports retrieving multiple instances of the same collection produced by
+ * different simulation stages or modules by iterating over Art tags.
+ * @param evt The current art::Event object.
+ * @param data The DataCollections structure where pointers and labels are stored.
+ * @param CollectionName An enum value used to selectively fill one type of MC collection.
+ */
+void CollectionFiller::FillMCCollections(const art::Event& evt, DataCollections &data, MCDataProductName CollectionName){
 
+    // --- 1. MCTrajectories (Full Monte Carlo Particle Paths) ---
     if(FillAll_ or (CollectionName==MCTrajectories)){
 
-      for(const auto &tag : MCTrajTag_){
-        auto chH = evt.getValidHandle<mu2e::MCTrajectoryCollection>(tag);
-        data.mctrajcol = chH.product();
-        data.mctrack_list.push_back(data.mctrajcol);
-
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting MCTrajectory Instance: "<<name<<std::endl;
-        data.mctrack_labels.push_back(name);
-
-      }
-      data.mctrack_tuple = std::make_tuple(data.mctrack_labels,data.mctrack_list);
+        for(const auto &tag : MCTrajTag_){
+            auto chH = evt.getValidHandle<mu2e::MCTrajectoryCollection>(tag);
+            
+            data.mctrajcol = chH.product();
+            data.mctrack_list.push_back(data.mctrajcol);
 
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting MCTrajectory Instance: "<<name<<std::endl;
+            data.mctrack_labels.push_back(name);
+        }
+        data.mctrack_tuple = std::make_tuple(data.mctrack_labels,data.mctrack_list);
     }
 
+    // --- 2. SurfaceSteps (Steps taken by particles near critical surfaces/boundaries) ---
     if(FillAll_ or (CollectionName==SurfaceSteps)){
 
-      for(const auto &tag : SurfStepsTag_){
-        auto chH = evt.getValidHandle<mu2e::SurfaceStepCollection>(tag);
-        data.surfstepcol = chH.product();
-        data.surfstep_list.push_back(data.surfstepcol);
-
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting SurfaceStep Instance: "<<name<<std::endl;
-        data.surfstep_labels.push_back(name);
-
-      }
-      data.surfstep_tuple = std::make_tuple(data.surfstep_labels,data.surfstep_list);
+        for(const auto &tag : SurfStepsTag_){
+            auto chH = evt.getValidHandle<mu2e::SurfaceStepCollection>(tag);
+            
+            data.surfstepcol = chH.product();
+            data.surfstep_list.push_back(data.surfstepcol);
 
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting SurfaceStep Instance: "<<name<<std::endl;
+            data.surfstep_labels.push_back(name);
+        }
+        data.surfstep_tuple = std::make_tuple(data.surfstep_labels,data.surfstep_list);
     }
     
+    // --- 3. SimParticles (Primary information about each simulated particle) ---
     if(FillAll_ or (CollectionName==SimParticles)){
+        for(const auto &tag : SimTag_){
+            auto chH = evt.getValidHandle<mu2e::SimParticleCollection>(tag);
+            
+            data.simcol = chH.product();
+            data.sim_list.push_back(data.simcol);
 
-      for(const auto &tag : SimTag_){
-        auto chH = evt.getValidHandle<mu2e::SimParticleCollection>(tag);
-        data.simcol = chH.product();
-        data.sim_list.push_back(data.simcol);
-
-        std::string name = TurnNameToString(tag);
-        std::cout<<"Plotting SimParticle Instance: "<<name<<std::endl;
-        data.sim_labels.push_back(name);
-
-      }
-      data.sim_tuple = std::make_tuple(data.sim_labels,data.sim_list);
-
+            std::string name = TurnNameToString(tag);
+            std::cout<<"Plotting SimParticle Instance: "<<name<<std::endl;
+            data.sim_labels.push_back(name);
+        }
+        data.sim_tuple = std::make_tuple(data.sim_labels,data.sim_list);
     }
-
-  }
+}
 
 }
diff --git a/src/DataInterface.cc b/src/DataInterface.cc
index 0a57ca7..6aa4ef5 100644
--- a/src/DataInterface.cc
+++ b/src/DataInterface.cc
@@ -16,276 +16,364 @@ std::string drawfilename("EventDisplay/config/drawutils.txt");
 SimpleConfig drawconfig(drawfilename);
 
 
-void DataInterface::AddCaloDigis(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CaloDigiCollection*>> calodigi_tuple, REX::REveElement* &scene){
-
-  std::cout<<"[DataInterface] AddCaloDigi "<<std::endl;
-  std::vector<const CaloDigiCollection*> calodigi_list = std::get<1>(calodigi_tuple);
-  std::vector<std::string> names = std::get<0>(calodigi_tuple);
-  std::cout<<"calo digi size = "<<calodigi_list.size()<<std::endl;
-  for(unsigned int j = 0; j< calodigi_list.size(); j++){
-
-    const CaloDigiCollection* calodigicol = calodigi_list[j];
-    if(calodigicol->size() != 0){
-      if(!firstLoop_){
+/*
+ * Adds reconstructed CaloDigi data products to the REve visualization scene.
+ * Digis are visualized as points (crystal center) and 3D boxes.
+ * Elements are colored based on the t0 time of the digitization pulse.
+*/
+void DataInterface::AddCaloDigis(REX::REveManager *&eveMng, bool firstLoop_, 
+                                 std::tuple<std::vector<std::string>, 
+                                 std::vector<const CaloDigiCollection*>> calodigi_tuple, 
+                                 REX::REveElement* &scene){
+    /*if(!firstLoop_){
         scene->DestroyElements();;
-      }
-      mu2e::Calorimeter const &cal = *(mu2e::GeomHandle<mu2e::Calorimeter>());
-      std::cout<<"calodigi col size = "<<calodigicol->size()<<std::endl;
-      auto allcryhits = new REX::REveCompound("CrystalHits for Cluster "+std::to_string(j),"CrystalHits for Cluster "+std::to_string(j),1);
-      for(unsigned int i = 0; i < calodigicol->size(); i++){
-        mu2e::CaloDigi const  &digi= (*calodigicol)[i];
-        int sipmID = digi.SiPMID();
-        //bool isEven = sipmID % 2;
-        int cryID = sipmID/2;
-        std::cout<<"crystal ID "<<cryID<<" "<<digi.t0()<<std::endl;
-        Crystal const &crystal = cal.crystal(cryID);
-        double crystalXLen = pointmmTocm(crystal.size().x());
-        double crystalYLen = pointmmTocm(crystal.size().y());
-        double crystalZLen = pointmmTocm(crystal.size().z());
-
-
-        GeomHandle<DetectorSystem> det;
-        double zpos = 0;
-        double diskID = 0;
-        if(cryID < 674) {
-          zpos = 186.53;
-          diskID = 0;
-        }
-        if(cryID >= 674) {
-          zpos = 256.53;
-          diskID = 1;
+    }*/
+    std::cout << "[DataInterface] AddCaloDigi: Restoring Original Z-Position Logic" << std::endl;
+    std::vector<const CaloDigiCollection*> calodigi_list = std::get<1>(calodigi_tuple);
+    std::vector<std::string> names = std::get<0>(calodigi_tuple);
+
+    // Find the Global Time Range (min/max t0)
+    double max_t0 = -1e6;
+    double min_t0 = 1e6;
+    bool found_digis = false;
+
+    for(const auto* calodigicol : calodigi_list){
+        if(calodigicol && !calodigicol->empty()){
+            found_digis = true;
+            for(const auto& digi : *calodigicol){
+                double t0 = digi.t0();
+                if(t0 > max_t0) max_t0 = t0;
+                if(t0 < min_t0) min_t0 = t0;
+            }
         }
-        CLHEP::Hep3Vector crystalPos = cal.geomUtil().mu2eToDisk(diskID,crystal.position()) ;
-        CLHEP::Hep3Vector pointInMu2e = det->toMu2e(crystalPos);
-
-        std::string crytitle =  "Crystal ID = " + std::to_string(cryID) +  '\n'
-          + " Time = " + std::to_string(digi.t0())+" ns ";
-        char const *crytitle_c = crytitle.c_str();
-
-        std::string name = "disk" + std::to_string(diskID);
-        auto ps1 = new REX::REvePointSet(name, "CaloClusters Disk 1: ",0);
-        auto ps2 = new REX::REvePointSet(name, "CaloClusters Disk 2: ",0);
-
-
-        // Set positions of clusters
-        if(diskID == 0)
-          ps1->SetNextPoint(pointmmTocm(crystal.position().x()), pointmmTocm(crystal.position().y()) , zpos );
-        if(diskID == 1) 
-          ps2->SetNextPoint(pointmmTocm(crystalPos.x()), pointmmTocm(crystalPos.y()) , zpos );
-
-        Color_t color = kRed;
+    }
 
-        ps1->SetMarkerColor(color);
-        ps1->SetMarkerStyle(DataInterface::mstyle);
-        ps1->SetMarkerSize(DataInterface::msize);
+    if (!found_digis) {
+        std::cout << "[DataInterface] No valid CaloDigis found." << std::endl;
+        return;
+    }
+    
+    if (max_t0 == min_t0) {
+        max_t0 += 1.0; 
+    }
 
-        ps2->SetMarkerColor(color);
-        ps2->SetMarkerStyle(DataInterface::mstyle);
-        ps2->SetMarkerSize(DataInterface::msize);
-
-        // Add to REve world
-        scene->AddElement(ps1);
-        scene->AddElement(ps2);
-
-        // plot the crystals which are present in this event:
-        auto b = new REX::REveBox("crystal",crytitle_c);
-        b->SetMainColor(color);
-        double width = crystalXLen/2;
-        double height = crystalYLen/2;
-        double thickness = crystalZLen/2;
-        b->SetVertex(0, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())- height ,pointmmTocm(crystalPos.z())- thickness + 2*thickness + zpos);//---
-        b->SetVertex(1, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())+ height, pointmmTocm(crystalPos.z())- thickness + 2*thickness  +zpos);//-+-
-        b->SetVertex(2, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())+ height ,pointmmTocm(crystalPos.z())- thickness + 2*thickness  + zpos);//++-
-        b->SetVertex(3, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())- height, pointmmTocm(crystalPos.z())-thickness  + 2*thickness + zpos);//+--
-        b->SetVertex(4, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())- height ,pointmmTocm(crystalPos.z())+ thickness + 2*thickness + zpos);//--+
-        b->SetVertex(5, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())+ height , pointmmTocm(crystalPos.z())+ thickness  + 2*thickness + zpos);//-++
-        b->SetVertex(6, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())+ height , pointmmTocm(crystalPos.z()) + thickness + 2*thickness+zpos); //+++
-        b->SetVertex(7, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())- height, pointmmTocm(crystalPos.z())+ thickness + 2*thickness + zpos);//+-+
-        allcryhits->AddElement(b);
-        //scene->AddElement(b);
-      }
-      scene->AddElement(allcryhits);
+    // Define the Color Gradient (Palette)
+    const Int_t NRGBs = 5;
+    const Int_t NCont = 255; 
+    Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 }; 
+    Double_t red[NRGBs]   = { 0.00, 0.00, 0.87, 1.00, 0.51 }; 
+    Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 }; 
+    Double_t blue[NRGBs]  = { 0.51, 1.00, 0.12, 0.00, 0.00 }; 
+    
+    TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
+    gStyle->SetNumberContours(NCont);
+
+    // Visualization Loop
+    for(unsigned int j = 0; j < calodigi_list.size(); j++){
+
+        const CaloDigiCollection* calodigicol = calodigi_list[j];
+        
+        if(calodigicol->size() != 0){
+            if(!firstLoop_){
+                scene->DestroyElements();;
+            }
+            
+            mu2e::Calorimeter const &cal = *(mu2e::GeomHandle<mu2e::Calorimeter>());
+            GeomHandle<DetectorSystem> det;
+            
+            auto allcryhits = new REX::REveCompound(("CaloDigiCollection_" + names[j]).c_str(), 
+                                                   ("CaloDigi Collection: " + names[j]).c_str(), 1);
+
+            for(unsigned int i = 0; i < calodigicol->size(); i++){
+                mu2e::CaloDigi const &digi = (*calodigicol)[i];
+                int sipmID = digi.SiPMID();
+                int cryID = sipmID / 2;
+
+                Crystal const &crystal = cal.crystal(cryID);
+                
+                // Calculate Color based on t0
+                Color_t color;
+                double normalized_t0 = (digi.t0() - min_t0) / (max_t0 - min_t0);
+                int colorIdx = static_cast<int>(normalized_t0 * (NCont - 1));
+                color = gStyle->GetColorPalette(colorIdx); 
+
+                // Geometry and Position (Matching Original Logic)
+                double crystalXLen = pointmmTocm(crystal.size().x());
+                double crystalYLen = pointmmTocm(crystal.size().y());
+                double crystalZLen = pointmmTocm(crystal.size().z());
+
+                double zpos = 0;
+                double diskID = 0;
+                if(cryID < 674) {
+                    zpos = 186.53;
+                    diskID = 0;
+                }
+                if(cryID >= 674) {
+                    zpos = 256.53;
+                    diskID = 1;
+                }
+                // Convert fixed zpos to cm for REve
+                double fixed_zpos_cm = zpos;//pointmmTocm(zpos); 
+
+                // Get crystal position in its local Mu2e disk frame (still in mm in Hep3Vector)
+                CLHEP::Hep3Vector crystalPos_local_mm = cal.geomUtil().mu2eToDisk(diskID, crystal.position());
+                
+                // Label
+                std::string label = " CaloDigi Instance = " + names[j] + '\n'
+                                  + " Crystal ID = " + std::to_string(cryID) + '\n'
+                                  + " SiPM. = "+std::to_string(sipmID)+ '\n'
+                                  + " t0 = "+std::to_string(digi.t0())+" ns " + '\n'
+                                  + " peakPos = "+std::to_string(digi.peakpos());
+                
+                // A. Draw Crystal Center (Point Set)
+                auto ps1 = new REX::REvePointSet(label.c_str(), label.c_str(), 0);
+                auto ps2 = new REX::REvePointSet(label.c_str(), label.c_str(), 0);
+                
+                // The point sets use the fixed global Z position.
+                if(diskID == 0)
+                    ps1->SetNextPoint(pointmmTocm(crystalPos_local_mm.x()), pointmmTocm(crystalPos_local_mm.y()), fixed_zpos_cm );
+                if(diskID == 1) 
+                    ps2->SetNextPoint(pointmmTocm(crystalPos_local_mm.x()), pointmmTocm(crystalPos_local_mm.y()), fixed_zpos_cm );
+
+                ps1->SetMarkerColor(color);
+                ps1->SetMarkerStyle(DataInterface::mstyle);
+                ps1->SetMarkerSize(DataInterface::msize);
+
+                ps2->SetMarkerColor(color);
+                ps2->SetMarkerStyle(DataInterface::mstyle);
+                ps2->SetMarkerSize(DataInterface::msize);
+
+                scene->AddElement(ps1);
+                scene->AddElement(ps2);
+
+                // B. Draw Crystal Volume (REveBox)
+                std::string crytitle = "Crystal ID = " + std::to_string(cryID) + '\n'
+                                     + " Time = " + std::to_string(digi.t0()) + " ns ";
+                
+                auto b = new REX::REveBox(crytitle.c_str(), crytitle.c_str());
+                b->SetMainColor(color);
+                
+                double width = crystalXLen / 2.0;
+                double height = crystalYLen / 2.0;
+                double thickness = crystalZLen / 2.0;
+                
+                // Z-Terms (All in cm):
+                double Z_local_cm = pointmmTocm(crystalPos_local_mm.z());
+                
+                // The full Z offset term from your original logic: 2*thickness + fixed_zpos_cm
+                double Z_offset = 2.0 * thickness + fixed_zpos_cm;
+
+                // Front Face
+                b->SetVertex(0, pointmmTocm(crystalPos_local_mm.x()) - width, pointmmTocm(crystalPos_local_mm.y()) - height, Z_local_cm - thickness + Z_offset);
+                b->SetVertex(1, pointmmTocm(crystalPos_local_mm.x()) - width, pointmmTocm(crystalPos_local_mm.y()) + height, Z_local_cm - thickness + Z_offset);
+                b->SetVertex(2, pointmmTocm(crystalPos_local_mm.x()) + width, pointmmTocm(crystalPos_local_mm.y()) + height, Z_local_cm - thickness + Z_offset);
+                b->SetVertex(3, pointmmTocm(crystalPos_local_mm.x()) + width, pointmmTocm(crystalPos_local_mm.y()) - height, Z_local_cm - thickness + Z_offset);
+                
+                // Back Face (Z_local_cm + thickness + Z_offset)
+                b->SetVertex(4, pointmmTocm(crystalPos_local_mm.x()) - width, pointmmTocm(crystalPos_local_mm.y()) - height, Z_local_cm + thickness + Z_offset);
+                b->SetVertex(5, pointmmTocm(crystalPos_local_mm.x()) - width, pointmmTocm(crystalPos_local_mm.y()) + height, Z_local_cm + thickness + Z_offset);
+                b->SetVertex(6, pointmmTocm(crystalPos_local_mm.x()) + width, pointmmTocm(crystalPos_local_mm.y()) + height, Z_local_cm + thickness + Z_offset);
+                b->SetVertex(7, pointmmTocm(crystalPos_local_mm.x()) + width, pointmmTocm(crystalPos_local_mm.y()) - height, Z_local_cm + thickness + Z_offset);
+
+                allcryhits->AddElement(b);
+            }
+            scene->AddElement(allcryhits);
+        }
     }
-  }
 }
-void DataInterface::AddCaloClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CaloClusterCollection*>> calocluster_tuple, REX::REveElement* &scene, bool addCrystalDraw, double t1, double t2){
 
-  std::cout<<"[DataInterface] AddCaloClusters "<<std::endl;
-  std::vector<const CaloClusterCollection*> calocluster_list = std::get<1>(calocluster_tuple);
-  std::vector<std::string> names = std::get<0>(calocluster_tuple);
-  for(unsigned int j = 0; j< calocluster_list.size(); j++){
 
-    // Extract cluster list
-    const CaloClusterCollection* clustercol = calocluster_list[j];
-    if(clustercol->size() != 0){
-      if(!firstLoop_){
-        scene->DestroyElements();;
-      }
-      Color_t color = kWhite;
-      mu2e::Calorimeter const &cal = *(mu2e::GeomHandle<mu2e::Calorimeter>());
-      GeomHandle<DetectorSystem> det;
-      // Add crystals
-      double maxE = 1e-6;
-      double minE = 1000;
-      using CCCPtr = const CaloCluster*;
-      std::list<CCCPtr> cluList;
-      //std::array<Color_t, 10> colorList {kViolet, kBlue, kBlue, kGreen, kGreen, kYellow, kYellow, kOrange, kOrange, kRed};
-      //std::vector<Color_t> colors;
-
-      for(unsigned int i = 0; i < clustercol->size(); i++){
-        auto const& cluster= (*clustercol)[i];
-        cluList.push_back(&cluster);
-        if(cluster.energyDep() > maxE) maxE = cluster.energyDep();
-        if(cluster.energyDep() < minE) minE = cluster.energyDep();
-
-        // sort in energy
-        cluList.sort([] (const CaloCluster* lhs, const CaloCluster* rhs) {return lhs->energyDep() > rhs->energyDep();} );
-      }
+/*
+ * Adds reconstructed CaloCluster data products to the REve visualization scene.
+ * Crystals in the cluster are visualized as points (crystal center) and 3D boxes.
+ * Elements are colored based on the t0 time of the digitization pulse.
+ * Crystal lego plot uses energy proportional to length
+*/
+void DataInterface::AddCaloClusters(REX::REveManager *&eveMng, bool firstLoop_, 
+                                    std::tuple<std::vector<std::string>, 
+                                    std::vector<const CaloClusterCollection*>> calocluster_tuple, 
+                                    REX::REveElement* &scene, bool addCrystalDraw){ // t1 and t2 are now ignored
 
-      /*if(cluList.size() <= 2){
-        Color_t color;
-        for(auto const& cluster : cluList){
-        if(cluster.energyDep() == minE){
-        color = kViolet;
-        colors.push_back(color);
-        }
-        if(cluster.energyDep() == maxE){
-        color = kRed;
-        colors.push_back(color);
-        }
-        }
-        }
-        unsigned int c = -1;
-        if(cluList.size() > 2){
-        for(auto const& cluster : cluList){
-        c+=1;
-        Color_t color;
-        if(cluster.energyDep() == minE){
-        color = kViolet;
-        colors.push_back(color);
-        }
-        if(cluster.energyDep() == maxE){
-        color = kRed;
-        colors.push_back(color);
-        }
-        if (c > 1 and c < colorList.size()-1){
-        color = colorList.at(c);
-        colors.push_back(color);
-        }
-        if (c > 1 and c >= colorList.size()-1){
-        color = kRed;
-        colors.push_back(color);
-        }
+    /*if(!firstLoop_){
+        scene->DestroyElements();;
+    }*/
+    std::cout << "[DataInterface] AddCaloClusters: Coloring by Proximity to Max-Energy Cluster Time" << std::endl;
+    std::vector<const CaloClusterCollection*> calocluster_list = std::get<1>(calocluster_tuple);
+    std::vector<std::string> names = std::get<0>(calocluster_tuple);
+
+    // Time Difference Color Palette
+    // This defines how clusters are colored based on their time separation from t_ref.
+    // Near: Red (Prompt) -> Mid: Orange/Yellow -> Far: Green/Blue/Violet (Late/Background)
+
+    // Find the Global Reference Time (t_ref)
+    double maxE = 1e-6;
+    double t_ref = -1.0; 
+    const mu2e::CaloCluster* refCluster = nullptr; // Pointer to the cluster that sets t_ref
+    
+    // First, iterate over ALL clusters in all collections to find the single most energetic one.
+    for(const auto* clustercol : calocluster_list){
+        if(clustercol && !clustercol->empty()){
+            for(const auto& cluster : *clustercol){
+                if(cluster.energyDep() > maxE){
+                    maxE = cluster.energyDep();
+                    t_ref = cluster.time();
+                    refCluster = &cluster;
+                }
+            }
         }
-        } */
-
-      unsigned int i = 0;
-      for(auto cptr : cluList){
-        auto const& cluster = *cptr;
-        //mu2e::CaloCluster const  &cluster= cluList.at(i);
-        i += 1;
-
-        // Info for label:
-        std::string cluster_energy = std::to_string(cluster.energyDep());
-        std::string cluster_time = std::to_string(cluster.time());
-        std::string cluster_x = std::to_string(cluster.cog3Vector().x());
-        std::string cluster_y = std::to_string(cluster.cog3Vector().y());
-        // Extract center of gravity, convert to coord sys
-        CLHEP::Hep3Vector COG(cluster.cog3Vector().x(),cluster.cog3Vector().y(), cluster.cog3Vector().z());
-        CLHEP::Hep3Vector crystalPos   = cal.geomUtil().mu2eToDisk(cluster.diskID(),COG);
-        CLHEP::Hep3Vector pointInMu2e = det->toMu2e(crystalPos);
-        // Info for label
-        std::string cluster_z = std::to_string(abs(pointInMu2e.z()));
-        // Make label and REve objects
-        std::string label =   " Instance = " + names[0] +  '\n'
-          + " Energy Dep. = "+cluster_energy+" MeV "+   '\n'
-          + " Time = "+cluster_time+" ns " +  '\n'
-          + " Pos =  ("+cluster_x+","+cluster_y+","+cluster_z+") mm";
-        std::string name = "disk" + std::to_string(cluster.diskID()) + label;
-        auto ps1 = new REX::REvePointSet(name, "CaloClusters Disk 1: "+label,0);
-        auto ps2 = new REX::REvePointSet(name, "CaloClusters Disk 2: "+label,0);
-
-
-        // Set positions of clusters
-        if(cluster.diskID() == 0) 
-          ps1->SetNextPoint(pointmmTocm(COG.x()), pointmmTocm(COG.y()) , abs(pointmmTocm(pointInMu2e.z())));
-        if(cluster.diskID() == 1)
-          ps2->SetNextPoint(pointmmTocm(COG.x()), pointmmTocm(COG.y()) , abs(pointmmTocm(pointInMu2e.z())));
-        
-        // Set draw options
-        /*TColor color1;
-          color1.SetPalette(1,0);
-          Color_t color = color1.GetNumber();// colors[i];*/
-
-        if(abs(cluster.time() - t2) < 20) color = kRed;
-        if(abs(cluster.time() - t2) >=  20 and abs(cluster.time() - t2) < 100) color = kOrange;
-        if(abs(cluster.time() - t2) >= 100 and abs(cluster.time() - t2) < 200) color = kYellow;
-        if(abs(cluster.time() - t2) >= 200 and abs(cluster.time() - t2) < 400) color = kGreen;
-        if(abs(cluster.time() - t2) >= 400 and abs(cluster.time() - t2) < 600) color = kBlue;
-        if(abs(cluster.time() - t2) >= 600 ) color = kViolet;
-
-        ps1->SetMarkerColor(color);
-        ps1->SetMarkerStyle(DataInterface::mstyle);
-        ps1->SetMarkerSize(DataInterface::msize);
-
-        ps2->SetMarkerColor(color);
-        ps2->SetMarkerStyle(DataInterface::mstyle);
-        ps2->SetMarkerSize(DataInterface::msize);
-
-        // Add to REve world
-        scene->AddElement(ps1);
-        scene->AddElement(ps2);
-
-        // Add crystals
-        if(addCrystalDraw){
-          auto allcryhits = new REX::REveCompound("CrystalHits for Cluster "+std::to_string(i),"CrystalHits for Cluster "+std::to_string(i),1);
-          for(unsigned h =0 ; h < cluster.caloHitsPtrVector().size();h++)     {
-            art::Ptr<CaloHit>  crystalhit = cluster.caloHitsPtrVector()[h];
-            int cryID = crystalhit->crystalID();
+    }
 
-            //int diskID = cal.crystal(crystalhit->crystalID()).diskID();
-            Crystal const &crystal = cal.crystal(cryID);
-            double crystalXLen = pointmmTocm(crystal.size().x());
-            double crystalYLen = pointmmTocm(crystal.size().y());
-            double crystalZLen = pointmmTocm(crystal.size().z());
+    // Check if a reference time was found (i.e., at least one cluster exists)
+    if(t_ref < 0.0){
+        std::cout << "[DataInterface] No valid CaloClusters found to set a reference time." << std::endl;
+        return;
+    }
+    //AddCaloClusterLegend(scene, t_ref); TODO - issue with header file
+    // Visualization Loop
+    for(unsigned int j = 0; j< calocluster_list.size(); j++){
 
+        const CaloClusterCollection* clustercol = calocluster_list[j];
+        
+        if(clustercol->size() != 0){
+            if(!firstLoop_){
+                scene->DestroyElements();;
+            }
+            
+            // Get Geometry Handles
+            mu2e::Calorimeter const &cal = *(mu2e::GeomHandle<mu2e::Calorimeter>());
             GeomHandle<DetectorSystem> det;
-            CLHEP::Hep3Vector crystalPos = cal.geomUtil().mu2eToDisk(cluster.diskID(),crystal.position()) ;
-
-            //  make title
-            std::string crytitle =   "disk"+std::to_string(cal.crystal(crystalhit->crystalID()).diskID()) + " Crystal Hit = " + std::to_string(cryID) +  '\n'
-              + " Energy Dep. = "+std::to_string(crystalhit->energyDep())+" MeV "+   '\n'
-              + " Time = "+std::to_string(crystalhit->time())+" ns ";
-            char const *crytitle_c = crytitle.c_str();
-            auto b = new REX::REveBox(crytitle_c,crytitle_c);
-
-            // plot the crystals which are present in this event in lego:
-            b->SetMainColor(color);//s[i]);
-
-
-            double width = crystalXLen/2;
-            double height = crystalYLen/2;
-            double thickness = crystalhit->energyDep()/maxE * crystalZLen/2; //length proportional to energy
-
-            b->SetVertex(0, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())- height ,pointmmTocm(crystalPos.z())- thickness  + abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2);//---
-            b->SetVertex(1, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())+ height, pointmmTocm(crystalPos.z())- thickness   +abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2);//-+-
-            b->SetVertex(2, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())+ height ,pointmmTocm(crystalPos.z())- thickness   + abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2);//++-
-            b->SetVertex(3, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())- height, pointmmTocm(crystalPos.z())-thickness   + abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2);//+--
-            b->SetVertex(4, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())- height ,pointmmTocm(crystalPos.z())+ thickness  + abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2);//--+
-            b->SetVertex(5, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())+ height , pointmmTocm(crystalPos.z())+ thickness   + abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2);//-++
-            b->SetVertex(6, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())+ height , pointmmTocm(crystalPos.z()) + thickness +abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2); //+++
-            b->SetVertex(7,pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())- height, pointmmTocm(crystalPos.z())+ thickness + abs(pointmmTocm(pointInMu2e.z()))+crystalZLen/2);//+-+
-            allcryhits->AddElement(b);
-          }
-          scene->AddElement(allcryhits);
-        }
+            
+            // maxE is used here to normalize the crystal box height for the optional Lego plot
+            int i = 0;
+            // Iterate over the clusters in the current collection
+            for(const auto& cluster : *clustercol){
+                i++;
+                Color_t color = kWhite; // Default
+                double markerSize = DataInterface::msize;
+
+                // Calculate time difference
+                double time_diff = abs(cluster.time() - t_ref); 
+
+                // Set Color based on Time Proximity to t_ref
+                if(&cluster == refCluster){
+                    // This is the cluster that set t_ref. Mark it clearly.
+                    color = kWhite; 
+                    markerSize = DataInterface::msize + 1.0; // Make it larger
+                }
+                // Clusters close in time to the reference (likely prompt)
+                else if(time_diff < 100.0) { // e.g., within +/- 15 ns
+                    color = kRed;
+                    markerSize = DataInterface::msize;
+                }
+                else if(time_diff < 250.0) { // e.g., 15-50 ns
+                    color = kOrange;
+                    markerSize = DataInterface::msize;
+                }
+                // Clusters far in time (likely background or secondary activity)
+                else if(time_diff < 500.0) { // e.g., 50-200 ns
+                    color = kYellow;
+                    markerSize = DataInterface::msize - 0.5;
+                }
+                else { // > 200 ns
+                    color = kGreen + 2;
+                    markerSize = DataInterface::msize - 1.0;
+                }
 
-      }
+                std::string cluster_energy = std::to_string(cluster.energyDep());
+                std::string cluster_time = std::to_string(cluster.time());
+                std::string cluster_x = std::to_string(cluster.cog3Vector().x());
+                std::string cluster_y = std::to_string(cluster.cog3Vector().y());
+                
+                CLHEP::Hep3Vector COG(cluster.cog3Vector().x(),cluster.cog3Vector().y(), cluster.cog3Vector().z());
+                
+                CLHEP::Hep3Vector crystalPos = cal.geomUtil().mu2eToDisk(cluster.diskID(),COG);
+                CLHEP::Hep3Vector pointInMu2e = det->toMu2e(crystalPos);
+                
+                std::string cluster_z = std::to_string(abs(pointInMu2e.z()));
+                
+                std::string label = " Instance = " + names[0] + '\n'
+                                  + " E = "+cluster_energy+" MeV " + '\n'
+                                  + " Time = "+cluster_time+" ns " + '\n'
+                                  + " |dt| from Emax = " + std::to_string(time_diff) + " ns " + '\n'
+                                  + " Pos = ("+cluster_x+","+cluster_y+","+cluster_z+") mm";
+                
+                std::string name = "disk" + std::to_string(cluster.diskID()) + label;
+                auto ps1 = new REX::REvePointSet(name, "CaloClusters Disk 1: "+label,0);
+                auto ps2 = new REX::REvePointSet(name, "CaloClusters Disk 2: "+label,0);
+
+
+                // Set Positions, Color, and Size
+                if(cluster.diskID() == 0)    
+                    ps1->SetNextPoint(pointmmTocm(COG.x()), pointmmTocm(COG.y()) , abs(pointmmTocm(pointInMu2e.z())));
+                if(cluster.diskID() == 1)
+                    ps2->SetNextPoint(pointmmTocm(COG.x()), pointmmTocm(COG.y()) , abs(pointmmTocm(pointInMu2e.z())));
+                
+                ps1->SetMarkerColor(color);
+                ps1->SetMarkerStyle(DataInterface::mstyle);
+                ps1->SetMarkerSize(markerSize);
+
+                ps2->SetMarkerColor(color);
+                ps2->SetMarkerStyle(DataInterface::mstyle);
+                ps2->SetMarkerSize(markerSize);
+
+                scene->AddElement(ps1);
+                scene->AddElement(ps2);
+
+                // Optional: Draw Contributing Crystals (Lego Plot)
+                if(addCrystalDraw){
+                    auto allcryhits = new REX::REveCompound("CrystalHits for Cluster "+std::to_string(cluster.diskID())+"_"+std::to_string(i),"CrystalHits for Cluster "+std::to_string(cluster.diskID())+"_"+std::to_string(i),1);
+                    
+                    for(unsigned h =0 ; h < cluster.caloHitsPtrVector().size();h++)    {
+                        art::Ptr<CaloHit> crystalhit = cluster.caloHitsPtrVector()[h];
+                        int cryID = crystalhit->crystalID();
+
+                        Crystal const &crystal = cal.crystal(cryID);
+                        double crystalXLen = pointmmTocm(crystal.size().x());
+                        double crystalYLen = pointmmTocm(crystal.size().y());
+                        double crystalZLen = pointmmTocm(crystal.size().z());
+
+                        CLHEP::Hep3Vector crystalPos = cal.geomUtil().mu2eToDisk(cluster.diskID(),crystal.position()) ;
+
+                        std::string crytitle = "disk"+std::to_string(cal.crystal(crystalhit->crystalID()).diskID()) + " Crystal Hit = " + std::to_string(cryID) + '\n'
+                                             + " Energy Dep. = "+std::to_string(crystalhit->energyDep())+" MeV " + '\n'
+                                             + " Time = "+std::to_string(crystalhit->time())+" ns ";
+                        
+                        char const *crytitle_c = crytitle.c_str();
+                        auto b = new REX::REveBox(crytitle_c,crytitle_c); 
+
+                        b->SetMainColor(color); // Use the time-proximity color
+
+                        double width = crystalXLen/2;
+                        double height = crystalYLen/2;
+                        
+                        // Z proportional to energy (normalized by the global max E found earlier)
+                        double thickness = crystalhit->energyDep()/maxE * crystalZLen/2; 
+                        
+                        // Calculate Z offset
+                        double crystalZOffset = pointmmTocm(crystalPos.z()) + abs(pointmmTocm(pointInMu2e.z())) + crystalZLen/2;
+                        
+                        // Set the 8 vertices of the REveBox object
+                        b->SetVertex(0, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())- height , crystalZOffset - thickness); 
+                        b->SetVertex(1, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())+ height, crystalZOffset - thickness); 
+                        b->SetVertex(2, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())+ height ,crystalZOffset - thickness); 
+                        b->SetVertex(3, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())- height, crystalZOffset - thickness); 
+                        b->SetVertex(4, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())- height ,crystalZOffset + thickness); 
+                        b->SetVertex(5, pointmmTocm(crystalPos.x()) - width, pointmmTocm(crystalPos.y())+ height , crystalZOffset + thickness); 
+                        b->SetVertex(6, pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())+ height , crystalZOffset + thickness); 
+                        b->SetVertex(7,pointmmTocm(crystalPos.x()) + width, pointmmTocm(crystalPos.y())- height, crystalZOffset + thickness); 
+                        
+                        allcryhits->AddElement(b);
+                    }
+                    scene->AddElement(allcryhits);
+                }
+            }
+        }
     }
-  }
 }
 
-//Enables the visualization of cluster of hits flagged as background by the FlagBkgHits module. This is work in progress. More features coming soon.
+/*
+Enables the visualization of cluster of hits flagged as background by the FlagBkgHits module. This is work in progress. More features coming soon.
+*/
 void DataInterface::AddBkgClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const BkgClusterCollection*>> bkgcluster_tuple, REX::REveElement* &scene){
   std::cout<<"BkgClusterCollection "<<std::endl;
   std::vector<const BkgClusterCollection*> bkgcluster_list = std::get<1>(bkgcluster_tuple);
@@ -312,757 +400,1283 @@ void DataInterface::AddBkgClusters(REX::REveManager *&eveMng, bool firstLoop_, s
   }
 }
 
-void DataInterface::AddComboHits(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const ComboHitCollection*>> combohit_tuple, REX::REveElement* &scene, bool strawdisplay, bool AddErrorBar_){
-
-  std::vector<const ComboHitCollection*> combohit_list = std::get<1>(combohit_tuple);
-  std::vector<std::string> names = std::get<0>(combohit_tuple);
-
-  // Loop over hit lists
-  for(unsigned int j = 0; j < combohit_list.size(); j++){
-    const ComboHitCollection* chcol = combohit_list[j];
-    int colour = (j+3);
-    if(chcol->size() !=0 ){
-      // Loop over hits
-      for(unsigned int i=0; i< chcol->size(); i++){
-        mu2e::ComboHit const  &hit= (*chcol)[i];
-        // Display hit straws if selected too in FCL file
-        if(strawdisplay){
-          mu2e::GeomHandle<mu2e::Tracker> tracker;
-          const auto& allStraws = tracker->getStraws();
-          int sid = hit._sid.asUint16();
-          CLHEP::Hep3Vector sposi(0.0,0.0,0.0), sposf(0.0,0.0,0.0);
-          const mu2e::Straw& s = allStraws[sid];
-          const CLHEP::Hep3Vector& p = s.getMidPoint();
-          const CLHEP::Hep3Vector& d = s.getDirection();
-          double x = p.x();
-          double y = p.y();
-          double z = p.z();
-          double l = s.halfLength();
-          double st=sin(d.theta());
-          double ct=cos(d.theta());
-          double sp=sin(d.phi()+TMath::Pi()/2.0);
-          double cp=cos(d.phi()+TMath::Pi()/2.0);
-          if(sid < drawconfig.getInt("maxSID")){
-            double x1=x+l*st*sp;
-            double y1=y-l*st*cp;
-            double z1=z+l*ct;
-            double x2=x-l*st*sp;
-            double y2=y+l*st*cp;
-            double z2=z-l*ct;
-            std::string strawtitle;
-            int idStraw =  s.id().getStraw();
-            int idPanel =  s.id().getPanel();
-            int idPlane =  s.id().getPlane();
-            int colorid = idPlane + idPanel;
-            strawtitle =Form("Straw %i Panel %i  Plane %i",idStraw,idPanel,idPlane);
-            sposi.set(x1, y1, z1);
-            sposf.set(x2, y2, z2);
-            if(sposi.x()!=0){
-              auto strawline = new REX::REveLine("StrawHit ",strawtitle,2);
-              strawline->SetPoint(0,pointmmTocm(sposi.x()),pointmmTocm(sposi.y()),pointmmTocm(sposi.z()));
-              strawline->SetNextPoint(pointmmTocm(sposf.x()),pointmmTocm(sposf.y()),pointmmTocm(sposf.z()));
-              strawline->SetLineWidth(1);
-              strawline->SetLineColor(colorid);
-              if(strawline->GetSize() !=0 ) scene->AddElement(strawline);
+/*
+ * Adds reconstructed ComboHits data products to the REve visualization scene.
+ * Hits are visualized as points with optional error bars
+ * Elements are colored based on the t0 time of the digitization pulse.
+*/
+
+//FIXME if firstloop never used remove it
+void DataInterface::AddComboHits(REX::REveManager *&eveMng, bool firstLoop_, 
+                                 std::tuple<std::vector<std::string>, 
+                                 std::vector<const ComboHitCollection*>> combohit_tuple, 
+                                 REX::REveElement* &scene, 
+                                 bool strawdisplay, bool AddErrorBar_) {
+    /*if(!firstLoop_){
+        scene->DestroyElements();;
+    }*/
+    std::vector<const ComboHitCollection*> combohit_list = std::get<1>(combohit_tuple);
+    std::vector<std::string> names = std::get<0>(combohit_tuple);
+
+    // Find the Global Time Range (min/max time)
+    double max_time = -1e6;
+    double min_time = 1e6;
+    bool found_hits = false;
+
+    for(const auto* chcol : combohit_list){
+        if(chcol && !chcol->empty()){
+            found_hits = true;
+            for(const auto& hit : *chcol){
+                double time = hit.time();
+                if(time > max_time) max_time = time;
+                if(time < min_time) min_time = time;
             }
-          }
         }
+    }
 
-        if(AddErrorBar_){
-          //XY
-          auto const& p = hit.pos();
-          auto w = hit.uDir();
-          auto const& s = hit.wireRes();
-          double x1 = (p.x()+s*w.x());
-          double x2 = (p.x()-s*w.x());
-          double z1 = (p.z()+s*w.z());
-          double z2 = (p.z()-s*w.z());
-          double y1 = (p.y()+s*w.y());
-          double y2 = (p.y()-s*w.y());
-
-          std::string errorbar = Form("ErrorBar Length: %f, %f, %f, %f, %f, %f",x1,y1,z1,x2,y2,z2);
-          auto error = new REX::REveLine("errors",errorbar.c_str(),2);
-          error->SetPoint(0, pointmmTocm(x1),pointmmTocm(y1),pointmmTocm(z1));
-          error->SetNextPoint(pointmmTocm(x2),pointmmTocm(y2),pointmmTocm(z2));
-          //std::cout<<"points "<<p.x()<<" "<<p.y()<<" "<<p.z()<<std::endl;
-          //std::cout<<"errors "<<x1<<" "<<y1<<" "<<z1<<std::endl;
-          error->SetLineColor(kRed);
-          error->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
-          scene->AddElement(error);
-        }
-        CLHEP::Hep3Vector HitPos(pointmmTocm(hit.pos().x()), pointmmTocm(hit.pos().y()), pointmmTocm(hit.pos().z()));
-        std::string chtitle = "ComboHits tag = "
-          + (names[j])  +  '\n'
-          + " position : x "  + std::to_string(hit.pos().x())  +  '\n'
-          + " y " + std::to_string(hit.pos().y())  +  '\n'
-          + " z " + std::to_string(hit.pos().z())  +  '\n'
-          + " time :" + std::to_string(hit.time()) +  '\n'
-          + " energy dep : "
-          + std::to_string(hit.energyDep())  +
-          + "MeV";
-        auto ps1 = new REX::REvePointSet(chtitle, chtitle,0);
-        ps1->SetNextPoint(HitPos.x(), HitPos.y() , HitPos.z());
-        ps1->SetMarkerColor(colour);
-        ps1->SetMarkerStyle(DataInterface::mstyle);
-        ps1->SetMarkerSize(DataInterface::msize);
-        if(ps1->GetSize() !=0 ) scene->AddElement(ps1);
-      }
+    if (!found_hits) {
+        std::cout << "[DataInterface] No valid ComboHits found." << std::endl;
+        return;
+    }
+    if (max_time == min_time) {
+        max_time += 1.0; 
     }
-  }
-}
 
-/*------------Function to add CRV information to the display:-------------*/
-void DataInterface::AddCRVInfo(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CrvRecoPulseCollection*>>  crvpulse_tuple, REX::REveElement* &scene, bool extracted, bool addCRVBars){
-  std::cout<<"[ REveDataInterface::AddCRVInfo() ]"<<std::endl;
-  std::vector<const CrvRecoPulseCollection*> crvpulse_list = std::get<1>(crvpulse_tuple);
-  std::vector<std::string> names = std::get<0>(crvpulse_tuple);
-  GeomHandle<CosmicRayShield> CRS;
-  GeomHandle<DetectorSystem> det;
-  if(crvpulse_list.size() !=0){
-    for(unsigned int i=0; i < crvpulse_list.size(); i++){
-      const CrvRecoPulseCollection* crvRecoPulse = crvpulse_list[i];
-      if(crvRecoPulse->size() !=0){
-        std::string crvtitle = " CRV Bar Hit tag : " + names[i];
-        auto ps1 = new REX::REvePointSet(crvtitle, crvtitle,0);
-        auto allcrvbars = new REX::REveCompound("allcrvbars"+std::to_string(i),"allcrvbars"+std::to_string(i),1);
-        for(unsigned int j=0; j< crvRecoPulse->size(); j++){
-
-          mu2e::CrvRecoPulse const &crvpulse = (*crvRecoPulse)[j];
-
-          const CRSScintillatorBarIndex &crvBarIndex = crvpulse.GetScintillatorBarIndex();
-          const CRSScintillatorBar &crvCounter = CRS->getBar(crvBarIndex);
-          const CRSScintillatorBarDetail &barDetail = crvCounter.getBarDetail();
-          CLHEP::Hep3Vector crvCounterPos = crvCounter.getPosition();
-          CLHEP::Hep3Vector HitPos(crvCounterPos.x(), crvCounterPos.y(), crvCounterPos.z());
-
-          CLHEP::Hep3Vector pointInMu2e = det-> toDetector(crvCounterPos);
-          CLHEP::Hep3Vector sibardetails(barDetail.getHalfLengths()[0],barDetail.getHalfLengths()[1],barDetail.getHalfLengths()[2]);
-          std::string pulsetitle = " CRV Bar Hit tag : "
-          + names[i] +  '\n'
-          + "CRVRecoPulse in Bar ID" +  '\n'
-          + std::to_string(crvBarIndex.asInt());
-          char const *pulsetitle_c = pulsetitle.c_str();
-          if(addCRVBars){
-            if(!extracted){
-              auto b = new REX::REveBox(pulsetitle_c,pulsetitle_c);
-              b->SetMainColor(drawconfig.getInt("CRVBarColor"));
-              b-> SetMainTransparency(drawconfig.getInt("CRVtrans"));
-              b->SetLineWidth(drawconfig.getInt("GeomLineWidth"));
-              double  length = pointmmTocm(crvCounter.getHalfLength());
-              double  width = pointmmTocm(crvCounter.getHalfWidth());
-              double  height = pointmmTocm(crvCounter.getHalfThickness());
-
-              if(barDetail.getWidthDirection() == 1 and barDetail.getThicknessDirection() == 2 and barDetail.getLengthDirection() == 0){ //CRV D, CRV U -- WORKS
-                b->SetVertex(0,  -1*length, pointmmTocm(pointInMu2e.y()) - width, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height); //---
-                b->SetVertex(1,  -1*length, pointmmTocm(pointInMu2e.y()) - width, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height);//-+-
-                b->SetVertex(2,  -1*length, pointmmTocm(pointInMu2e.y()) + width , pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height );//++-
-                b->SetVertex(3,  -1*length, pointmmTocm(pointInMu2e.y()) + width  ,pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height);//+--
-                b->SetVertex(4, length, pointmmTocm(pointInMu2e.y()) - width,   pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height  );//--+
-                b->SetVertex(5,  length, pointmmTocm(pointInMu2e.y()) - width,  pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height );//-++
-                b->SetVertex(6, length, pointmmTocm(pointInMu2e.y()) + width,  pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height );//+++
-                b->SetVertex(7, length,pointmmTocm(pointInMu2e.y()) + width,  pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height );//+-+
-
-              }
-
-              if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){ //CRV TS -- WORKS
-                b->SetVertex(0, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + -1*length ); //---
-                b->SetVertex(1, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + -1*length);//-+-
-                b->SetVertex(2, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + -1*length);//++-
-                b->SetVertex(3, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + -1*length);//+--
-                b->SetVertex(4, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + length);//--+
-                b->SetVertex(5, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + length);//-++
-                b->SetVertex(6, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + length);//+++
-                b->SetVertex(7, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + length);//+-+
-              }
-
-              if(barDetail.getWidthDirection() == 2 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 0){ //CRV T -- orientation DONE
-                b->SetVertex(0, -1*length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width); //---
-                b->SetVertex(1, -1*length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width);//-+-
-                b->SetVertex(2, -1*length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width);//++-
-                b->SetVertex(3, -1*length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width);//+--
-                b->SetVertex(4, length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width );//--+
-                b->SetVertex(5, length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width );//-++
-                b->SetVertex(6, length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width );//+++
-                b->SetVertex(7, length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width );//+-+
-              }
-
-              if(barDetail.getWidthDirection() == 1 and barDetail.getThicknessDirection() == 0 and barDetail.getLengthDirection() == 2){ //CRV R, CRV L -- orientation DONE
-                b->SetVertex(0, pointmmTocm(pointInMu2e.y()) - height, -1*length, pointmmTocm(pointInMu2e.x()) - width );//---
-                b->SetVertex(1, pointmmTocm(pointInMu2e.y()) + height, -1*length,pointmmTocm(pointInMu2e.x()) - width);//-+-
-                b->SetVertex(2, pointmmTocm(pointInMu2e.y()) + height, -1*length,pointmmTocm(pointInMu2e.x()) + width);//++-
-                b->SetVertex(3, pointmmTocm(pointInMu2e.y()) - height, -1*length,pointmmTocm(pointInMu2e.x()) + width);//+--
-                b->SetVertex(4, pointmmTocm(pointInMu2e.y()) - height, length, pointmmTocm(pointInMu2e.x()) - width);//--+
-                b->SetVertex(5, pointmmTocm(pointInMu2e.y()) + height, length, pointmmTocm(pointInMu2e.x()) - width );//-++
-                b->SetVertex(6, pointmmTocm(pointInMu2e.y()) + height, length,pointmmTocm(pointInMu2e.x()) + width );//+++
-                b->SetVertex(7, pointmmTocm(pointInMu2e.y()) - height, length,pointmmTocm(pointInMu2e.x()) + width );//+-+
-              }
-              allcrvbars->AddElement(b);
-            }
-            if(extracted){ //TODO same for nominal geom
-
-              // CRV hit scintillation bars highlighted
-              // std::string const& base;
-              // std::string bartitle = crvCounter.name( base );
-              // char const *bartitle_c = base.c_str(); //TODO title
-
-              // Draw "bars hit" in red:
-              auto b = new REX::REveBox(pulsetitle_c,pulsetitle_c);
-              b->SetMainColor(drawconfig.getInt("CRVBarColor"));
-              b-> SetMainTransparency(drawconfig.getInt("CRVtrans"));
-              b->SetLineWidth(drawconfig.getInt("GeomLineWidth"));
-              double  length = pointmmTocm(crvCounter.getHalfLength());
-              double  width = pointmmTocm(crvCounter.getHalfWidth());
-              double  height = pointmmTocm(crvCounter.getHalfThickness());
-
-              if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){ //T1
-
-                b->SetVertex(0, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height, -1*length+ pointmmTocm(pointInMu2e.z())); //---
-                b->SetVertex(1, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y())  + height, -1*length+ pointmmTocm(pointInMu2e.z()));//-+-
-                b->SetVertex(2, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height, -1*length+ pointmmTocm(pointInMu2e.z()));//++-
-                b->SetVertex(3, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, -1*length+ pointmmTocm(pointInMu2e.z()));//+--
-                b->SetVertex(4, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height,  length + pointmmTocm(pointInMu2e.z()));//--+
-                b->SetVertex(5, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) + height, length + pointmmTocm(pointInMu2e.z()));//-++
-                b->SetVertex(6, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height,length + pointmmTocm(pointInMu2e.z()));//+++
-                b->SetVertex(7, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, length+ pointmmTocm(pointInMu2e.z()) );//+-+
-              } else { //EX, T2
-                b->SetVertex(0, -1*length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.x()) - width + pointmmTocm(pointInMu2e.z()));//---
-                b->SetVertex(1,-1*length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.x()) - width + pointmmTocm(pointInMu2e.z()));//-+-
-                b->SetVertex(2, length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.x()) - width  + pointmmTocm(pointInMu2e.z()));//++-
-                b->SetVertex(3, length, pointmmTocm(pointInMu2e.y()) - height , pointmmTocm(pointInMu2e.x()) - width + pointmmTocm(pointInMu2e.z()) );//+--
-                b->SetVertex(4, -1*length , pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z())); //--+
-                b->SetVertex(5,-1*length, pointmmTocm(pointInMu2e.y()) + height , pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z()) ); // -++
-                b->SetVertex(6, length, pointmmTocm(pointInMu2e.y()) + height , pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z()));//+++
-                b->SetVertex(7,  length , pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z()));//+-+
-
-              }
-              scene->AddElement(b);
-            }
-          }
-          // Add Reco Pulse to collection
-          ps1->SetNextPoint(pointmmTocm(pointInMu2e.x()), pointmmTocm(pointInMu2e.y()) , pointmmTocm(pointInMu2e.z()));
+    // Define the Color Gradient (Palette)
+    const Int_t NRGBs = 5;
+    const Int_t NCont = 255; 
+    Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 }; 
+    Double_t red[NRGBs]   = { 0.00, 0.00, 0.87, 1.00, 0.51 }; 
+    Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 }; 
+    Double_t blue[NRGBs]  = { 0.51, 1.00, 0.12, 0.00, 0.00 }; 
+    
+    TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
+    gStyle->SetNumberContours(NCont);
+
+    // Visualization Loop
+    for(unsigned int j = 0; j < combohit_list.size(); j++){
+        const ComboHitCollection* chcol = combohit_list[j];
+        
+        if(chcol->size() != 0){
+            
+            // MASTER COMPOUND for the entire collection
+            std::string master_name = "ComboHits_" + names[j];
+            auto master_compound = new REX::REveCompound(master_name.c_str(), master_name.c_str(), true);
+            master_compound->SetRnrSelf(false); // Only render children (hits/errors)
+            
+            mu2e::GeomHandle<mu2e::Tracker> tracker;
+            const auto& allStraws = tracker->getStraws();
+            
+            // Loop over hits
+            for(unsigned int i = 0; i < chcol->size(); i++){
+                mu2e::ComboHit const &hit = (*chcol)[i];
+                
+                // Calculate Time-Based Color
+                Color_t hit_color;
+                double normalized_time = (hit.time() - min_time) / (max_time - min_time);
+                int colorIdx = static_cast<int>(normalized_time * (NCont - 1));
+                hit_color = gStyle->GetColorPalette(colorIdx); 
+
+                // A. Display Hit Straws (Separate element, added directly to scene for broad context)
+                if(strawdisplay){
+                    int sid = hit._sid.asUint16();
+                    
+                    if(static_cast<std::size_t>(sid) < allStraws.size() && sid < drawconfig.getInt("maxSID")){
+                        CLHEP::Hep3Vector sposi(0.0,0.0,0.0), sposf(0.0,0.0,0.0);
+                        const mu2e::Straw& s = allStraws[sid];
+                        const CLHEP::Hep3Vector& p = s.getMidPoint();
+                        const CLHEP::Hep3Vector& d = s.getDirection();
+                        double x = p.x();
+                        double y = p.y();
+                        double z = p.z();
+                        double l = s.halfLength();
+                        
+                        double st = sin(d.theta());
+                        double ct = cos(d.theta());
+                        double sp = sin(d.phi()+TMath::Pi()/2.0);
+                        double cp = cos(d.phi()+TMath::Pi()/2.0);
+
+                        double x1=x+l*st*sp;
+                        double y1=y-l*st*cp;
+                        double z1=z+l*ct;
+                        double x2=x-l*st*sp;
+                        double y2=y+l*st*cp;
+                        double z2=z-l*ct;
+
+                        std::string strawtitle;
+                        int idPlane = s.id().getPlane();
+                        int colorid = s.id().getPanel() + idPlane + 1;
+                        strawtitle =Form("Straw %i Panel %i Plane %i",s.id().getStraw(), s.id().getPanel(), idPlane);
+                        
+                        sposi.set(x1, y1, z1);
+                        sposf.set(x2, y2, z2);
+                        
+                        if(sposi.x() != 0){
+                            auto strawline = new REX::REveLine("StrawHit", strawtitle, 2);
+                            strawline->SetPoint(0, pointmmTocm(sposi.x()), pointmmTocm(sposi.y()), pointmmTocm(sposi.z()));
+                            strawline->SetNextPoint(pointmmTocm(sposf.x()), pointmmTocm(sposf.y()), pointmmTocm(sposf.z()));
+                            strawline->SetLineWidth(1);
+                            strawline->SetLineColor(colorid); 
+                            if(strawline->GetSize() != 0) scene->AddElement(strawline);
+                        }
+                    }
+                }
 
+                // B. Add Error Bar (REveLine) Optional
+                if(AddErrorBar_){
+                    auto const& p = hit.pos();
+                    auto w = hit.uDir();
+                    auto const& s = hit.wireRes(); // Wire resolution (length of error bar half-segment)
+                    
+                    // Calculate endpoints of the error bar along the perpendicular direction (w = uDir)
+                    double x1 = (p.x()+s*w.x());
+                    double x2 = (p.x()-s*w.x());
+                    double z1 = (p.z()+s*w.z());
+                    double z2 = (p.z()-s*w.z());
+                    double y1 = (p.y()+s*w.y());
+                    double y2 = (p.y()-s*w.y());
+
+                    // Add a detailed error bar label
+                    std::string errorbar_label = std::string("ComboHit Error Bar") + '\n' 
+                                               + "Hit Time: " + std::to_string(hit.time()) + " ns" + '\n'
+                                               + "Wire Res (half-length): " + std::to_string(s) + " mm" + '\n'
+                                               + "Error Bar Endpoints (mm):" + '\n'
+                                               + " P1 (" + std::to_string(x1) + ", " + std::to_string(y1) + ", " + std::to_string(z1) + ")" + '\n'
+                                               + " P2 (" + std::to_string(x2) + ", " + std::to_string(y2) + ", " + std::to_string(z2) + ")";
+                    auto error = new REX::REveLine(errorbar_label.c_str(), errorbar_label.c_str(), 2);
+                    error->SetPoint(0, pointmmTocm(x1), pointmmTocm(y1), pointmmTocm(z1));
+                    error->SetNextPoint(pointmmTocm(x2), pointmmTocm(y2), pointmmTocm(z2));
+                    
+                    error->SetLineColor(hit_color); 
+                    error->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
+                    
+                    master_compound->AddElement(error);
+                }
+                
+                // C. Draw ComboHit Position (REvePointSet)
+                CLHEP::Hep3Vector HitPos(pointmmTocm(hit.pos().x()), pointmmTocm(hit.pos().y()), pointmmTocm(hit.pos().z()));
+                std::string chtitle = "ComboHits tag = "
+                    + (names[j]) + '\n'
+                    + " position : x " + std::to_string(hit.pos().x()) + '\n'
+                    + " y " + std::to_string(hit.pos().y()) + '\n'
+                    + " z " + std::to_string(hit.pos().z()) + '\n'
+                    + " time :" + std::to_string(hit.time()) + '\n'
+                    + " energy dep : " + std::to_string(hit.energyDep()) + "MeV";
+                    
+                auto ps1 = new REX::REvePointSet(chtitle.c_str(), chtitle.c_str(), 0);
+                ps1->SetNextPoint(HitPos.x(), HitPos.y() , HitPos.z());
+                
+                ps1->SetMarkerColor(hit_color); // Time-based color
+                ps1->SetMarkerStyle(DataInterface::mstyle);
+                ps1->SetMarkerSize(DataInterface::msize);
+                
+                master_compound->AddElement(ps1);
+            } 
+            
+            // Add the Master Compound to the Scene
+            scene->AddElement(master_compound);
         }
-        scene->AddElement(allcrvbars);
-        // Draw reco pulse collection
-        ps1->SetMarkerColor(i+3);
-        ps1->SetMarkerStyle(DataInterface::mstyle);
-        ps1->SetMarkerSize(DataInterface::msize);
-        if(ps1->GetSize() !=0 ) scene->AddElement(ps1);
-      }
     }
-  }
-
 }
 
 
-/*------------Function to add CRV information to the display:-------------*/
-void DataInterface::AddCRVClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const CrvCoincidenceClusterCollection*>>  crvpulse_tuple, REX::REveElement* &scene, bool extracted, bool addCRVBars){
-
-  std::vector<const CrvCoincidenceClusterCollection*> crvpulse_list = std::get<1>(crvpulse_tuple);
-  std::vector<std::string> names = std::get<0>(crvpulse_tuple);
-  GeomHandle<CosmicRayShield> CRS;
-  GeomHandle<DetectorSystem> det;
-  if(crvpulse_list.size() !=0){
-    for(unsigned int i=0; i < crvpulse_list.size(); i++){
-      const CrvCoincidenceClusterCollection* crvClusters = crvpulse_list[i];
-      if(crvClusters->size() !=0){
-
-        for(unsigned int j=0; j< crvClusters->size(); j++){
-          auto allcrvbars = new REX::REveCompound("Bars for CRVConicidenceCluster"+std::to_string(j),"Bars for CRVConicidenceCluster"+std::to_string(j),1);
-          mu2e::CrvCoincidenceCluster const &crvclu = (*crvClusters)[j];
-          std::string crvtitle = "CRVCoincidenceCluster" + std::to_string(j) + " tag : " + names[i] + '\n'
-          + " averge hit time = " + std::to_string(crvclu.GetAvgHitTime())+" ns " + '\n'
-          + " PEs = " + std::to_string(crvclu.GetPEs());
-          auto ps1 = new REX::REvePointSet(crvtitle, crvtitle,0);
-          CLHEP::Hep3Vector pointInMu2e = det-> toDetector(crvclu.GetAvgHitPos());
-          ps1->SetNextPoint(pointmmTocm(pointInMu2e.x()), pointmmTocm(pointInMu2e.y()) , pointmmTocm(pointInMu2e.z()));
-          for(unsigned h =0 ; h < crvclu.GetCrvRecoPulses().size();h++)     {
-
-            art::Ptr<CrvRecoPulse>  crvpulse = crvclu.GetCrvRecoPulses()[h];
-            const mu2e::CRSScintillatorBarIndex &crvBarIndex = crvpulse->GetScintillatorBarIndex();
-            const mu2e::CRSScintillatorBar &crvCounter = CRS->getBar(crvBarIndex);
-            const mu2e::CRSScintillatorBarDetail &barDetail = crvCounter.getBarDetail();
-            CLHEP::Hep3Vector crvCounterPos = crvCounter.getPosition();
-            CLHEP::Hep3Vector HitPos(crvCounterPos.x(), crvCounterPos.y(), crvCounterPos.z());
-
-            CLHEP::Hep3Vector pointInMu2e = det-> toDetector(crvCounterPos);
-            CLHEP::Hep3Vector sibardetails(barDetail.getHalfLengths()[0],barDetail.getHalfLengths()[1],barDetail.getHalfLengths()[2]);
-            std::string pulsetitle = " CRV Bar Hit for  tag : "
-            + names[i] +  '\n'
-            + "Bar ID"
-            + std::to_string(crvBarIndex.asInt())+  '\n'
-            + "Coincidence start time " + std::to_string(crvclu.GetStartTime())+  '\n'
-            + "Coincidence end time " + std::to_string(crvclu.GetEndTime());
-            char const *pulsetitle_c = pulsetitle.c_str();
-            if(addCRVBars){
-              if(!extracted){
-                auto b = new REX::REveBox(pulsetitle_c,pulsetitle_c);
-                b->SetMainColor(drawconfig.getInt("CRVBarColor"));
-                b-> SetMainTransparency(drawconfig.getInt("CRVtrans"));
-                b->SetLineWidth(drawconfig.getInt("GeomLineWidth"));
-                double  length = pointmmTocm(crvCounter.getHalfLength());
-                double  width = pointmmTocm(crvCounter.getHalfWidth());
-                double  height = pointmmTocm(crvCounter.getHalfThickness());
-
-                if(barDetail.getWidthDirection() == 1 and barDetail.getThicknessDirection() == 2 and barDetail.getLengthDirection() == 0){ //CRV D, CRV U -- WORKS
-                  b->SetVertex(0,  -1*length, pointmmTocm(pointInMu2e.y()) - width, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height); //---
-                  b->SetVertex(1,  -1*length, pointmmTocm(pointInMu2e.y()) - width, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height);//-+-
-                  b->SetVertex(2,  -1*length, pointmmTocm(pointInMu2e.y()) + width , pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height );//++-
-                  b->SetVertex(3,  -1*length, pointmmTocm(pointInMu2e.y()) + width  ,pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height);//+--
-                  b->SetVertex(4, length, pointmmTocm(pointInMu2e.y()) - width,   pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height  );//--+
-                  b->SetVertex(5,  length, pointmmTocm(pointInMu2e.y()) - width,  pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height );//-++
-                  b->SetVertex(6, length, pointmmTocm(pointInMu2e.y()) + width,  pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + height );//+++
-                  b->SetVertex(7, length,pointmmTocm(pointInMu2e.y()) + width,  pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - height );//+-+
-
-                }
-
-                if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){ //CRV TS -- WORKS
-                  b->SetVertex(0, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + -1*length ); //---
-                  b->SetVertex(1, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + -1*length);//-+-
-                  b->SetVertex(2, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + -1*length);//++-
-                  b->SetVertex(3, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + -1*length);//+--
-                  b->SetVertex(4, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + length);//--+
-                  b->SetVertex(5, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + length);//-++
-                  b->SetVertex(6, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + length);//+++
-                  b->SetVertex(7, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + length);//+-+
-
-                }
-
-                if(barDetail.getWidthDirection() == 2 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 0){ //CRV T -- WORKS
-                  b->SetVertex(0, -1*length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width); //---
-                  b->SetVertex(1, -1*length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width);//-+-
-                  b->SetVertex(2, -1*length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width);//++-
-                  b->SetVertex(3, -1*length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width);//+--
-                  b->SetVertex(4, length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width );//--+
-                  b->SetVertex(5, length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) - width );//-++
-                  b->SetVertex(6, length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width );//+++
-                  b->SetVertex(7, length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.z()) + pointmmTocm(pointInMu2e.x()) + width );//+-+
+/*
+ * Adds reconstructed CaloRecoPulse data products to the REve visualization scene.
+ * RecoPules are visualized as points bars are visualized as 3D boxes
+ * Elements are colored based on the height of the digitization pulse.
+*/
+void DataInterface::AddCrvInfo(REX::REveManager *&eveMng, bool firstLoop_, 
+                               std::tuple<std::vector<std::string>, 
+                               std::vector<const CrvRecoPulseCollection*>> crvpulse_tuple, 
+                               REX::REveElement* &scene, bool extracted, bool addCrvBars){
 
+    /*if(!firstLoop_){
+        scene->DestroyElements();;
+    }*/
+    std::cout << "[DataInterface::AddCrvInfo() ] - Coloring by Pulse Height (White Start, More Variation)" << std::endl;
+    std::vector<const CrvRecoPulseCollection*> crvpulse_list = std::get<1>(crvpulse_tuple);
+    std::vector<std::string> names = std::get<0>(crvpulse_tuple);
+    
+    // Geometry Handles
+    mu2e::GeomHandle<mu2e::CosmicRayShield> CRS;
+    mu2e::GeomHandle<mu2e::DetectorSystem> det;
+    
+    // Find the Global Pulse Height Range (min/max)
+    double max_height = 0.0;
+    double min_height = 1e6;
+    bool found_pulses = false;
+
+    if(crvpulse_list.size() != 0){
+        for(const auto* crvRecoPulse : crvpulse_list){
+            if(crvRecoPulse && !crvRecoPulse->empty()){
+                found_pulses = true;
+                for(const auto& crvpulse : *crvRecoPulse){
+                    double height = crvpulse.GetPulseHeight();
+                    if(height > max_height) max_height = height;
+                    if(height < min_height) min_height = height;
                 }
+            }
+        }
+    }
 
-                if(barDetail.getWidthDirection() == 1 and barDetail.getThicknessDirection() == 0 and barDetail.getLengthDirection() == 2){ //CRV R, CRV L -- orientation DONE
-                  b->SetVertex(0, pointmmTocm(pointInMu2e.y()) - height, -1*length, pointmmTocm(pointInMu2e.x()) - width ); //---
-                  b->SetVertex(1, pointmmTocm(pointInMu2e.y()) + height, -1*length,pointmmTocm(pointInMu2e.x()) - width);//-+-
-                  b->SetVertex(2, pointmmTocm(pointInMu2e.y()) + height, -1*length,pointmmTocm(pointInMu2e.x()) + width);//++-
-                  b->SetVertex(3, pointmmTocm(pointInMu2e.y()) - height, -1*length,pointmmTocm(pointInMu2e.x()) + width);//+--
-                  b->SetVertex(4, pointmmTocm(pointInMu2e.y()) - height, length, pointmmTocm(pointInMu2e.x()) - width);//--+
-                  b->SetVertex(5, pointmmTocm(pointInMu2e.y()) + height, length, pointmmTocm(pointInMu2e.x()) - width );//-++
-                  b->SetVertex(6, pointmmTocm(pointInMu2e.y()) + height, length,pointmmTocm(pointInMu2e.x()) + width );//+++
-                  b->SetVertex(7, pointmmTocm(pointInMu2e.y()) - height, length,pointmmTocm(pointInMu2e.x()) + width );//+-+
+    if (!found_pulses) {
+        std::cout << "[ REveDataInterface::AddCrvInfo() ] No valid Crv Reco Pulses found." << std::endl;
+        return;
+    }
+    
+    // Handle cases where all pulses have the same height
+    if (max_height == min_height) {
+        max_height += 1.0; 
+    }
 
+    // Define the Color Gradient (Palette)
+    const Int_t NRGBs = 7; 
+    const Int_t NCont = 255; 
+
+    Double_t stops[NRGBs] = { 0.00, 0.15, 0.30, 0.50, 0.70, 0.85, 1.00 }; 
+    Double_t red[NRGBs]   = { 1.00, 0.90, 0.60, 0.00, 0.00, 0.50, 0.80 }; 
+    Double_t green[NRGBs] = { 1.00, 0.90, 0.80, 0.60, 0.00, 0.00, 0.10 }; 
+    Double_t blue[NRGBs]  = { 1.00, 0.90, 0.80, 0.80, 1.00, 0.80, 0.00 }; 
+    
+    Int_t palette_start_index = TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
+    
+    // Visualization Loop
+    for(unsigned int i=0; i < crvpulse_list.size(); i++){
+        const CrvRecoPulseCollection* crvRecoPulse = crvpulse_list[i];
+        
+        if(crvRecoPulse->size() != 0){
+            
+            std::string temp_title = "Crv Reco Pulses: " + names[i];
+            auto ps1 = new REX::REvePointSet(temp_title.c_str(), temp_title.c_str(), 0); 
+            auto allcrvbars = new REX::REveCompound(("CrvHitBars_" + std::to_string(i)).c_str(), 
+                                                   ("Crv Hit Bars: " + names[i]).c_str(), 1);
+
+            std::string final_ps1_title = temp_title;
+            
+            for(unsigned int j=0; j< crvRecoPulse->size(); j++){
+
+                mu2e::CrvRecoPulse const &crvpulse = (*crvRecoPulse)[j];
+                
+                // Calculate Pulse Height Based Color
+                Color_t hit_color;
+                
+                // Define a minimum range (e.g., 1.0 ADC count) to prevent color collapse
+                const double kMinRange = 1.0; 
+
+                double pulse_height = crvpulse.GetPulseHeight();
+                double actual_range = max_height - min_height;
+
+                // Use the larger of the actual range or the minimum required range (kMinRange)
+                double range = (actual_range < kMinRange) ? kMinRange : actual_range;
+
+                // Calculate the normalized height (0.0 to 1.0) using the adjusted range
+                double normalized_height = (pulse_height - min_height) / range;
+
+                // Clamp the normalized height between 0 and 1
+                if (normalized_height < 0) normalized_height = 0;
+                if (normalized_height > 1) normalized_height = 1;
+
+                // Map normalized height (0 to 1) to the color index (0 to NCont-1)
+                int colorIdx = palette_start_index + static_cast<int>(normalized_height * (NCont - 1));
+
+                hit_color = TColor::GetColor(colorIdx);
+
+
+                // Geometry Setup
+                const mu2e::CRSScintillatorBarIndex &crvBarIndex = crvpulse.GetScintillatorBarIndex();
+                const mu2e::CRSScintillatorBar &crvCounter = CRS->getBar(crvBarIndex);
+                const mu2e::CRSScintillatorBarDetail &barDetail = crvCounter.getBarDetail();
+                
+                CLHEP::Hep3Vector crvCounterPos = crvCounter.getPosition(); 
+                CLHEP::Hep3Vector pointInMu2e = det->toDetector(crvCounterPos); 
+
+                // DETAILED PULSE TITLE (Used for REveBox mouseover)
+                std::string pulsetitle = " Crv Pulse Collection: " + names[i] + '\n'
+                                       + " SiPM Channel ID: " + std::to_string(crvpulse.GetSiPMNumber()) + '\n'
+                                       + " Crv Bar ID: " + std::to_string(crvBarIndex.asInt()) + '\n'
+                                       + " Pulse Time: " + std::to_string(crvpulse.GetPulseTime()) + " ns" + '\n'
+                                       + " Pulse Height: " + std::to_string(crvpulse.GetPulseHeight()) + " ADC (Color)" + '\n'
+                                       + " Pedestal: " + std::to_string(crvpulse.GetPedestal()) + " ADC";
+                char const *pulsetitle_c = pulsetitle.c_str();
+
+                final_ps1_title = "Crv Pulses: " + names[i] + " (Last Pulse Details: " + '\n' + pulsetitle;
+                
+                // A. Draw Crv Bar (REveBox)
+                if(addCrvBars){
+                   
+                    double length = pointmmTocm(crvCounter.getHalfLength());
+                    double width = pointmmTocm(crvCounter.getHalfWidth());
+                    double height = pointmmTocm(crvCounter.getHalfThickness());
+                    
+                    double X_cm = pointmmTocm(pointInMu2e.x());
+                    double Y_cm = pointmmTocm(pointInMu2e.y());
+                    double Z_cm = pointmmTocm(pointInMu2e.z());
+                    
+                    // Handle geometry errors that cause Seg Faults
+                    try {
+                        // Check for degenerate dimensions (re-added for robustness)
+                        const double kMinDimension = 1e-4; // 1 micrometer (in cm)
+                        if (length < kMinDimension || width < kMinDimension || height < kMinDimension) {
+                             throw std::runtime_error("Degenerate dimensions detected.");
+                        }
+
+                        // Only create and configure the REveBox if the dimensions are safe
+                        auto b = new REX::REveBox(pulsetitle_c, pulsetitle_c);
+                        b->SetMainColor(hit_color); 
+                        b->SetMainTransparency(drawconfig.getInt("Crvtrans"));
+                        b->SetLineWidth(drawconfig.getInt("GeomLineWidth"));
+                        if(!extracted){
+                          // Crv D, Crv U orientation (Length along X)
+                          if(barDetail.getWidthDirection() == 1 and barDetail.getThicknessDirection() == 2 and barDetail.getLengthDirection() == 0){ 
+                              b->SetVertex(0, X_cm - length, Y_cm - width, Z_cm - height);
+                              b->SetVertex(1, X_cm - length, Y_cm - width, Z_cm + height);
+                              b->SetVertex(2, X_cm - length, Y_cm + width, Z_cm + height);
+                              b->SetVertex(3, X_cm - length, Y_cm + width, Z_cm - height);
+                              b->SetVertex(4, X_cm + length, Y_cm - width, Z_cm - height);
+                              b->SetVertex(5, X_cm + length, Y_cm - width, Z_cm + height);
+                              b->SetVertex(6, X_cm + length, Y_cm + width, Z_cm + height);
+                              b->SetVertex(7, X_cm + length, Y_cm + width, Z_cm - height);
+                          }
+                          // Crv TS orientation (Length along Z)
+                          else if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){
+                              b->SetVertex(0, X_cm - width, Y_cm - height, Z_cm - length);
+                              b->SetVertex(1, X_cm - width, Y_cm + height, Z_cm - length);
+                              b->SetVertex(2, X_cm + width, Y_cm + height, Z_cm - length);
+                              b->SetVertex(3, X_cm + width, Y_cm - height, Z_cm - length);
+                              b->SetVertex(4, X_cm - width, Y_cm - height, Z_cm + length);
+                              b->SetVertex(5, X_cm - width, Y_cm + height, Z_cm + length);
+                              b->SetVertex(6, X_cm + width, Y_cm + height, Z_cm + length);
+                              b->SetVertex(7, X_cm + width, Y_cm - height, Z_cm + length);
+                          }
+                          // Crv T orientation (Length along X)
+                          else if(barDetail.getWidthDirection() == 2 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 0){ 
+                              b->SetVertex(0, X_cm - length, Y_cm - height, Z_cm - width);
+                              b->SetVertex(1, X_cm - length, Y_cm + height, Z_cm - width);
+                              b->SetVertex(2, X_cm - length, Y_cm + height, Z_cm + width);
+                              b->SetVertex(3, X_cm - length, Y_cm - height, Z_cm + width);
+                              b->SetVertex(4, X_cm + length, Y_cm - height, Z_cm - width);
+                              b->SetVertex(5, X_cm + length, Y_cm + height, Z_cm - width);
+                              b->SetVertex(6, X_cm + length, Y_cm + height, Z_cm + width);
+                              b->SetVertex(7, X_cm + length, Y_cm - height, Z_cm + width);
+                          }
+                          // Crv R, Crv L orientation (Length along Y) 
+                          else if(barDetail.getWidthDirection() == 2 and barDetail.getThicknessDirection() == 0 and barDetail.getLengthDirection() == 1){
+                              b->SetVertex(0, X_cm - height, Y_cm - length, Z_cm - width);
+                              b->SetVertex(1, X_cm - height, Y_cm + length, Z_cm - width);
+                              b->SetVertex(2, X_cm + height, Y_cm + length, Z_cm - width);
+                              b->SetVertex(3, X_cm + height, Y_cm - length, Z_cm - width); 
+                              
+                              b->SetVertex(4, X_cm - height, Y_cm - length, Z_cm + width);
+                              b->SetVertex(5, X_cm - height, Y_cm + length, Z_cm + width);
+                              b->SetVertex(6, X_cm + height, Y_cm + length, Z_cm + width);
+                              b->SetVertex(7, X_cm + height, Y_cm - length, Z_cm + width);
+                          }
+                        }
+                        if(extracted){
+                            if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){ //T1 (Length along Z)
+                                b->SetVertex(0, X_cm - width, Y_cm - height, -1*length + Z_cm);
+                                b->SetVertex(1, X_cm - width, Y_cm + height, -1*length + Z_cm);
+                                b->SetVertex(2, X_cm + width, Y_cm + height, -1*length + Z_cm);
+                                b->SetVertex(3, X_cm + width, Y_cm - height, -1*length + Z_cm);
+                                b->SetVertex(4, X_cm - width, Y_cm - height, length + Z_cm);
+                                b->SetVertex(5, X_cm - width, Y_cm + height, length + Z_cm);
+                                b->SetVertex(6, X_cm + width, Y_cm + height, length + Z_cm);
+                                b->SetVertex(7, X_cm + width, Y_cm - height, length + Z_cm);
+                            } else { //EX, T2 (Length along X)
+                                b->SetVertex(0, X_cm - length, Y_cm - height, Z_cm - width);
+                                b->SetVertex(1, X_cm - length, Y_cm + height, Z_cm - width);
+                                b->SetVertex(2, X_cm + length, Y_cm + height, Z_cm - width);
+                                b->SetVertex(3, X_cm + length, Y_cm - height , Z_cm - width);
+                                b->SetVertex(4, X_cm - length , Y_cm - height, Z_cm + width);
+                                b->SetVertex(5, X_cm - length, Y_cm + height , Z_cm + width);
+                                b->SetVertex(6, X_cm + length, Y_cm + height , Z_cm + width);
+                                b->SetVertex(7, X_cm + length , Y_cm - height, Z_cm + width);
+                            }
+                            scene->AddElement(b); 
+                        } else {
+                             allcrvbars->AddElement(b); 
+                        }
+                    } catch (const std::exception& e) {
+                        // Print a warning but continue the loop
+                        std::cerr << "Crv Geometry Error (Bar ID: " << crvBarIndex.asInt() 
+                                  << "). Skipping REveBox creation. Reason: " << e.what() 
+                                  << " L=" << length << ", W=" << width << ", H=" << height << std::endl;
+                    } catch (...) {
+                        // Catch any unknown exception type (e.g., if REve throws a non-standard error)
+                        std::cerr << "Crv Geometry Critical Error (Bar ID: " << crvBarIndex.asInt() 
+                                  << "). Skipping REveBox creation due to unknown geometry failure." << std::endl;
+                    }
                 }
-                allcrvbars->AddElement(b);
-
-              }
-              if(extracted){
-
-                // Draw "bars hit" in red:
-                auto b = new REX::REveBox(pulsetitle_c,pulsetitle_c);
-                b->SetMainColor(drawconfig.getInt("CRVBarColor"));
-                b-> SetMainTransparency(drawconfig.getInt("CRVtrans"));
-                b->SetLineWidth(drawconfig.getInt("GeomLineWidth"));
-                double  length = pointmmTocm(crvCounter.getHalfLength());
-                double  width = pointmmTocm(crvCounter.getHalfWidth());
-                double  height = pointmmTocm(crvCounter.getHalfThickness());
-
-                if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){ //T1
-
-                  b->SetVertex(0, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height, -1*length + pointmmTocm(pointInMu2e.z())); //---
-                  b->SetVertex(1, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y())  + height, -1*length + pointmmTocm(pointInMu2e.z()));//-+-
-                  b->SetVertex(2, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height, -1*length + pointmmTocm(pointInMu2e.z()));//++-
-                  b->SetVertex(3, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, -1*length + pointmmTocm(pointInMu2e.z()));//+--
-                  b->SetVertex(4, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) - height,  length + pointmmTocm(pointInMu2e.z()));//--+
-                  b->SetVertex(5, pointmmTocm(pointInMu2e.x()) - width, pointmmTocm(pointInMu2e.y()) + height, length + pointmmTocm(pointInMu2e.z()));//-++
-                  b->SetVertex(6, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) + height ,length + pointmmTocm(pointInMu2e.z()) );//+++
-                  b->SetVertex(7, pointmmTocm(pointInMu2e.x()) + width, pointmmTocm(pointInMu2e.y()) - height, length + pointmmTocm(pointInMu2e.z()));//+-+
-                } else { //EX, T2
-                  b->SetVertex(0, -1*length, pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.x()) - width + pointmmTocm(pointInMu2e.z()));//---
-                  b->SetVertex(1,-1*length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.x()) - width + pointmmTocm(pointInMu2e.z()));//-+-
-                  b->SetVertex(2, length, pointmmTocm(pointInMu2e.y()) + height, pointmmTocm(pointInMu2e.x()) - width  + pointmmTocm(pointInMu2e.z()));//++-
-                  b->SetVertex(3, length, pointmmTocm(pointInMu2e.y()) - height , pointmmTocm(pointInMu2e.x()) - width + pointmmTocm(pointInMu2e.z()) );//+--
-                  b->SetVertex(4, -1*length , pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z())); //--+
-                  b->SetVertex(5,-1*length, pointmmTocm(pointInMu2e.y()) + height , pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z()) ); // -++
-                  b->SetVertex(6, length, pointmmTocm(pointInMu2e.y()) + height , pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z()));//+++
-                  b->SetVertex(7,  length , pointmmTocm(pointInMu2e.y()) - height, pointmmTocm(pointInMu2e.x()) + width + pointmmTocm(pointInMu2e.z()));//+-+
+                
+                // B. Add Reco Pulse Marker (Point Set)
+                ps1->SetNextPoint(pointmmTocm(pointInMu2e.x()), pointmmTocm(pointInMu2e.y()), pointmmTocm(pointInMu2e.z()));
+                
+            } // End of individual pulse loop
+            
+            // Post-Loop: Set the final, detailed title on the PointSet
+            ps1->SetTitle(final_ps1_title.c_str());
+            
+            // Add Compounds/Collections to Scene
+            if (!extracted && addCrvBars) {
+                scene->AddElement(allcrvbars);
+            }
+            
+            // Draw reco pulse collection (markers)
+            ps1->SetMarkerColor(i + 3); 
+            ps1->SetMarkerStyle(DataInterface::mstyle);
+            ps1->SetMarkerSize(DataInterface::msize);
+            
+            if(ps1->GetSize() != 0) scene->AddElement(ps1);
+        }
+    }
+}
 
+/*
+ * Adds reconstructed CrvCluster data products to the REve visualization scene.
+ * Clusters are visualized as points, RecoPulses used to access bar info, bars visualized as boxes in 3D
+ * Elements are colored based on the pulse height of the digitization pulse.
+*/
+void DataInterface::AddCrvClusters(REX::REveManager *&eveMng, bool firstLoop_, 
+                                 std::tuple<std::vector<std::string>, 
+                                 std::vector<const CrvCoincidenceClusterCollection*>> crvpulse_tuple, 
+                                 REX::REveElement* &scene, bool extracted, bool addCrvBars)
+{
+
+    std::vector<const CrvCoincidenceClusterCollection*> crvpulse_list = std::get<1>(crvpulse_tuple);
+    std::vector<std::string> names = std::get<0>(crvpulse_tuple);
+    mu2e::GeomHandle<mu2e::CosmicRayShield> CRS;
+    mu2e::GeomHandle<mu2e::DetectorSystem> det;
+    
+    if (crvpulse_list.size() == 0) return;
+
+    // Find the Global Pulse Height Range (min/max) for ALL pulses in ALL clusters
+    double max_height = 0.0;
+    double min_height = 1e6;
+    bool found_pulses = false;
+
+    for (const auto* crvClusters : crvpulse_list) {
+        if (crvClusters) {
+            for (const auto& crvclu : *crvClusters) {
+                for (const auto& crvpulsePtr : crvclu.GetCrvRecoPulses()) {
+                    if (crvpulsePtr) {
+                        found_pulses = true;
+                        double height = crvpulsePtr->GetPulseHeight();
+                        if(height > max_height) max_height = height;
+                        if(height < min_height) min_height = height;
+                    }
                 }
-                scene->AddElement(b);
-              }
             }
-          }
-        ps1->SetMarkerColor(drawconfig.getInt("CRVHitColor"));
-        ps1->SetMarkerStyle(DataInterface::mstyle);
-        ps1->SetMarkerSize(DataInterface::msize);
-        if(ps1->GetSize() !=0 ) scene->AddElement(ps1);
-        scene->AddElement(allcrvbars);
         }
-      }
     }
-  }
 
-}
+    if (!found_pulses) {
+        std::cout << "[DataInterface::AddCrvClusters() ] No valid Crv Reco Pulses found in clusters." << std::endl;
+        return;
+    }
 
-/*------------Function to add TimeCluster Collection in 3D and 2D displays:-------------*/
-void DataInterface::AddTimeClusters(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const TimeClusterCollection*>>  timecluster_tuple, REX::REveElement* &scene){
+    // Handle cases where all pulses have the same height
+    if (max_height == min_height) {
+        max_height += 1.0; 
+    }
+    
+    // Define the Color Gradient (Palette)
+    const Int_t NRGBs = 7;
+    const Int_t NCont = 255;
+    Double_t stops[NRGBs] = { 0.00, 0.15, 0.30, 0.50, 0.70, 0.85, 1.00 };
+    Double_t red[NRGBs]   = { 1.00, 0.90, 0.60, 0.00, 0.00, 0.50, 0.80 };
+    Double_t green[NRGBs] = { 1.00, 0.90, 0.80, 0.60, 0.00, 0.00, 0.10 };
+    Double_t blue[NRGBs]  = { 1.00, 0.90, 0.80, 0.80, 1.00, 0.80, 0.00 };
+    Int_t palette_start_index = TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
+    const double kMinRange = 1.0; // Define a minimum range to prevent color collapse
+
+    // Visualization Loop
+    for(unsigned int i=0; i < crvpulse_list.size(); i++){
+        const CrvCoincidenceClusterCollection* crvClusters = crvpulse_list[i];
+        
+        if (crvClusters->size() == 0) continue;
 
-  std::vector<const TimeClusterCollection*> timecluster_list = std::get<1>(timecluster_tuple);
-  std::vector<std::string> names = std::get<0>(timecluster_tuple);
+        std::string bars_title = "Crv Cluster Bars: " + names[i];
+        auto allcrvbars_collection = new REX::REveCompound(bars_title.c_str(), bars_title.c_str(), 1); 
 
-  if(timecluster_list.size() !=0){
+        for(unsigned int j=0; j< crvClusters->size(); j++){
+            
+            mu2e::CrvCoincidenceCluster const &crvclu = (*crvClusters)[j];
+            
+            // Make title
+            std::string crvtitle = "CrvCoincidenceCluster" + std::to_string(j) + " tag : " + names[i] + '\n'
+            + " averge hit time = " + std::to_string(crvclu.GetAvgHitTime())+" ns " + '\n'
+            + " PEs = " + std::to_string(crvclu.GetPEs());
+            auto ps1 = new REX::REvePointSet(crvtitle.c_str(), crvtitle.c_str(), 0);
+            
+            CLHEP::Hep3Vector pointInMu2e = det->toDetector(crvclu.GetAvgHitPos());
+            ps1->SetNextPoint(pointmmTocm(pointInMu2e.x()), pointmmTocm(pointInMu2e.y()) , pointmmTocm(pointInMu2e.z()));
+            
+            std::set<mu2e::CRSScintillatorBarIndex> drawn_bars; 
+
+            for(unsigned h =0 ; h < crvclu.GetCrvRecoPulses().size();h++) {
+                
+                art::Ptr<mu2e::CrvRecoPulse> crvpulse = crvclu.GetCrvRecoPulses()[h];
+                const mu2e::CRSScintillatorBarIndex &crvBarIndex = crvpulse->GetScintillatorBarIndex();
+
+                if (addCrvBars && crvpulse && drawn_bars.count(crvBarIndex) == 0) {
+                    
+                    drawn_bars.insert(crvBarIndex);
+                    
+                    const mu2e::CRSScintillatorBar &crvCounter = CRS->getBar(crvBarIndex);
+                    const mu2e::CRSScintillatorBarDetail &barDetail = crvCounter.getBarDetail();
+                    CLHEP::Hep3Vector crvCounterPos = crvCounter.getPosition();
+                    
+                    // Calculate Pulse Height Based Color
+                    double pulse_height = crvpulse->GetPulseHeight();
+                    double actual_range = max_height - min_height;
+                    double range = (actual_range < kMinRange) ? kMinRange : actual_range;
+
+                    double normalized_height = (pulse_height - min_height) / range;
+                    if (normalized_height < 0) normalized_height = 0;
+                    if (normalized_height > 1) normalized_height = 1;
+
+                    int colorIdx = palette_start_index + static_cast<int>(normalized_height * (NCont - 1));
+                    Color_t hit_color = TColor::GetColor(colorIdx);
+
+
+                    // Base Geometry Setup
+                    CLHEP::Hep3Vector bar_center_mu2e = det->toDetector(crvCounterPos);
+                    
+                    double X_cm = pointmmTocm(bar_center_mu2e.x());
+                    double Y_cm = pointmmTocm(bar_center_mu2e.y());
+                    double Z_cm = pointmmTocm(bar_center_mu2e.z());
+
+                    double length = pointmmTocm(crvCounter.getHalfLength());
+                    double width = pointmmTocm(crvCounter.getHalfWidth());
+                    double height = pointmmTocm(crvCounter.getHalfThickness());
+
+                    std::string pulsetitle = " Crv Bar Hit for tag : "
+                                            + names[i] +  '\n'
+                                            + "Bar ID: " + std::to_string(crvBarIndex.asInt()) +  '\n'
+                                            + "Pulse Height: " + std::to_string(pulse_height) + " ADC (Color)" + '\n'
+                                            + "Coincidence start time: " + std::to_string(crvclu.GetStartTime()) +  '\n'
+                                            + "Coincidence end time: " + std::to_string(crvclu.GetEndTime());
+                    char const *pulsetitle_c = pulsetitle.c_str();
+
+                    auto b = new REX::REveBox(pulsetitle_c, pulsetitle_c);
+                    b->SetMainColor(hit_color);
+                    b->SetMainTransparency(drawconfig.getInt("Crvtrans"));
+                    b->SetLineWidth(drawconfig.getInt("GeomLineWidth"));
+                    
+                    // Geometry Setting
+                    if(!extracted){
+                        // Crv D, Crv U orientation (Length along X)
+                        if(barDetail.getWidthDirection() == 1 and barDetail.getThicknessDirection() == 2 and barDetail.getLengthDirection() == 0){
+                            b->SetVertex(0, X_cm - length, Y_cm - width, Z_cm - height);
+                            b->SetVertex(1, X_cm - length, Y_cm - width, Z_cm + height);
+                            b->SetVertex(2, X_cm - length, Y_cm + width, Z_cm + height);
+                            b->SetVertex(3, X_cm - length, Y_cm + width, Z_cm - height);
+                            b->SetVertex(4, X_cm + length, Y_cm - width, Z_cm - height);
+                            b->SetVertex(5, X_cm + length, Y_cm - width, Z_cm + height);
+                            b->SetVertex(6, X_cm + length, Y_cm + width, Z_cm + height);
+                            b->SetVertex(7, X_cm + length, Y_cm + width, Z_cm - height);
+                        }
+                        // Crv TS orientation (Length along Z)
+                        else if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){
+                            b->SetVertex(0, X_cm - width, Y_cm - height, Z_cm - length);
+                            b->SetVertex(1, X_cm - width, Y_cm + height, Z_cm - length);
+                            b->SetVertex(2, X_cm + width, Y_cm + height, Z_cm - length);
+                            b->SetVertex(3, X_cm + width, Y_cm - height, Z_cm - length);
+                            b->SetVertex(4, X_cm - width, Y_cm - height, Z_cm + length);
+                            b->SetVertex(5, X_cm - width, Y_cm + height, Z_cm + length);
+                            b->SetVertex(6, X_cm + width, Y_cm + height, Z_cm + length);
+                            b->SetVertex(7, X_cm + width, Y_cm - height, Z_cm + length);
+                        }
+                        // Crv T orientation (Length along X)
+                        else if(barDetail.getWidthDirection() == 2 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 0){
+                            b->SetVertex(0, X_cm - length, Y_cm - height, Z_cm - width);
+                            b->SetVertex(1, X_cm - length, Y_cm + height, Z_cm - width);
+                            b->SetVertex(2, X_cm - length, Y_cm + height, Z_cm + width);
+                            b->SetVertex(3, X_cm - length, Y_cm - height, Z_cm + width);
+                            b->SetVertex(4, X_cm + length, Y_cm - height, Z_cm - width);
+                            b->SetVertex(5, X_cm + length, Y_cm + height, Z_cm - width);
+                            b->SetVertex(6, X_cm + length, Y_cm + height, Z_cm + width);
+                            b->SetVertex(7, X_cm + length, Y_cm - height, Z_cm + width);
+                        }
+                        // Crv R, Crv L orientation (Length along Y)
+                        else if(barDetail.getWidthDirection() == 2 and barDetail.getThicknessDirection() == 0 and barDetail.getLengthDirection() == 1){
+                            b->SetVertex(0, X_cm - height, Y_cm - length, Z_cm - width);
+                            b->SetVertex(1, X_cm - height, Y_cm + length, Z_cm - width);
+                            b->SetVertex(2, X_cm + height, Y_cm + length, Z_cm - width);
+                            b->SetVertex(3, X_cm + height, Y_cm - length, Z_cm - width);
+                            b->SetVertex(4, X_cm - height, Y_cm - length, Z_cm + width);
+                            b->SetVertex(5, X_cm - height, Y_cm + length, Z_cm + width);
+                            b->SetVertex(6, X_cm + height, Y_cm + length, Z_cm + width);
+                            b->SetVertex(7, X_cm + height, Y_cm - length, Z_cm + width);
+                        }
+                        allcrvbars_collection->AddElement(b); 
+
+                    } else if(extracted){
+                        // T1 (Length along Z)
+                        if(barDetail.getWidthDirection() == 0 and barDetail.getThicknessDirection() == 1 and barDetail.getLengthDirection() == 2){ 
+                            b->SetVertex(0, X_cm - width, Y_cm - height, Z_cm - length);
+                            b->SetVertex(1, X_cm - width, Y_cm + height, Z_cm - length);
+                            b->SetVertex(2, X_cm + width, Y_cm + height, Z_cm - length);
+                            b->SetVertex(3, X_cm + width, Y_cm - height, Z_cm - length);
+                            b->SetVertex(4, X_cm - width, Y_cm - height, Z_cm + length);
+                            b->SetVertex(5, X_cm - width, Y_cm + height, Z_cm + length);
+                            b->SetVertex(6, X_cm + width, Y_cm + height, Z_cm + length);
+                            b->SetVertex(7, X_cm + width, Y_cm - height, Z_cm + length);
+                        } 
+                        // EX, T2 (Length along X)
+                        else { 
+                            b->SetVertex(0, X_cm - length, Y_cm - height, Z_cm - width);
+                            b->SetVertex(1, X_cm - length, Y_cm + height, Z_cm - width);
+                            b->SetVertex(2, X_cm + length, Y_cm + height, Z_cm - width);
+                            b->SetVertex(3, X_cm + length, Y_cm - height, Z_cm - width);
+                            b->SetVertex(4, X_cm - length, Y_cm - height, Z_cm + width);
+                            b->SetVertex(5, X_cm - length, Y_cm + height, Z_cm + width);
+                            b->SetVertex(6, X_cm + length, Y_cm + height, Z_cm + width);
+                            b->SetVertex(7, X_cm + length, Y_cm - height, Z_cm + width);
+                        }
+                        scene->AddElement(b); 
+                    }
+                }
+            } // End of inner h loop (pulses)
+            
+            // Cluster Point Set Configuration
+            ps1->SetMarkerColor(drawconfig.getInt("CrvHitColor")); // Marker color based on configuration
+            ps1->SetMarkerStyle(DataInterface::mstyle);
+            ps1->SetMarkerSize(DataInterface::msize);
+            
+            if(ps1->GetSize() !=0 ) scene->AddElement(ps1); 
+            
+        } // End of j loop (clusters)
+
+        // Final Additions to Scene
+        if(!extracted && addCrvBars) {
+            scene->AddElement(allcrvbars_collection); 
+        } 
+    }
+}
+
+/*
+ * Adds reconstructed TimeClusers data products to the REve visualization scene.
+ * visualized as points
+*/
+// FIXME - do we ever use this? What is the purpose?
+void DataInterface::AddTimeClusters(REX::REveManager *&eveMng, bool firstLoop_, 
+                                 std::tuple<std::vector<std::string>, 
+                                 std::vector<const TimeClusterCollection*>> timecluster_tuple, 
+                                 REX::REveElement* &scene){
+
+    
+    std::vector<const TimeClusterCollection*> timecluster_list = std::get<1>(timecluster_tuple);
+    std::vector<std::string> names = std::get<0>(timecluster_tuple);
+
+    if(timecluster_list.empty()){
+        return; 
+    } else {
+      std::cout << "[DataInterface::AddTimeClusters()]" << std::endl;
+    }
+    
+    // Loop over TimeCluster Collections (i-loop)
     for(unsigned int i = 0; i < timecluster_list.size(); i++){
-      const TimeClusterCollection* tccol = timecluster_list[i];
-      if(tccol->size() != 0){
-        if(!firstLoop_){
-          scene->DestroyElements();;
+        const TimeClusterCollection* tccol = timecluster_list[i];
+        
+        if(tccol && tccol->size() != 0){
+            
+            // Create a compound for this entire collection for better organization in the REve tree
+            std::string collection_title = "Time Cluster Collection: " + names[i];
+            auto collection_compound = new REX::REveCompound(collection_title.c_str(), collection_title.c_str(), true);
+            
+            // Loop over individual TimeClusters (j-loop)
+            for(size_t j=0; j<tccol->size();j++){
+                mu2e::TimeCluster const &tclust= (*tccol)[j];
+                
+                // Detailed title for mouseover
+                std::string tctitle = "Time Cluster tag: " + names[i] + '\n'
+                + "t0: " + std::to_string(tclust.t0().t0()) + " +/- " + std::to_string(tclust.t0().t0Err()) + " ns " + '\n' 
+                + "Hits: " + std::to_string(tclust.hits().size()) + '\n'
+                + "Position (X, Y, Z): (" + std::to_string(tclust._pos.x()) + ", " + std::to_string(tclust._pos.y()) + ", " + std::to_string(tclust._pos.z()) + ") mm";
+                
+                // Create a point set for the single cluster. Naming convention improved.
+                std::string ps_name = "Cluster_" + std::to_string(j) + "_" + names[i];
+                auto ps1 = new REX::REvePointSet(ps_name.c_str(), tctitle.c_str(), 1); 
+                
+                // Get position and convert to cm
+                CLHEP::Hep3Vector clusterPos(tclust._pos.x(), tclust._pos.y(), tclust._pos.z());
+                ps1->SetNextPoint(pointmmTocm(clusterPos.x()), pointmmTocm(clusterPos.y()) , pointmmTocm(clusterPos.z()));
+                
+                // Marker style configuration
+                ps1->SetMarkerColor(i + 6); // Use a color based on collection index (i)
+                ps1->SetMarkerStyle(kOpenCircle);
+                ps1->SetMarkerSize(DataInterface::msize * 1.5); // Slightly larger marker for clarity
+
+                if(ps1->GetSize() !=0 ) {
+                    // Add the individual cluster point set to the collection compound
+                    collection_compound->AddElement(ps1);
+                }
+            } // End of j-loop (clusters)
+            
+            // Add the entire collection compound to the main scene
+            scene->AddElement(collection_compound);
         }
+    } // End of i-loop (collections)
+}
 
-
-        for(size_t j=0; j<tccol->size();j++){
-          mu2e::TimeCluster const  &tclust= (*tccol)[j];
-          std::string tctitle = "Time Cluster tag: " + names[i] + '\n'
-            + "t0 " + std::to_string(tclust.t0().t0()) + " +/- " + std::to_string(tclust.t0().t0Err()) + " ns " + '\n' ;
-          auto ps1 = new REX::REvePointSet("TimeClusters", tctitle, 0);
-          CLHEP::Hep3Vector HitPos(tclust._pos.x(), tclust._pos.y(), tclust._pos.z());
-          ps1->SetNextPoint(pointmmTocm(HitPos.x()), pointmmTocm(HitPos.y()) , pointmmTocm(HitPos.z()));
-          ps1->SetMarkerColor(i+6);
-          ps1->SetMarkerStyle(kOpenCircle);
-          ps1->SetMarkerSize(DataInterface::msize);
-          if(ps1->GetSize() !=0 ) scene->AddElement(ps1);
+/*
+ * Adds reconstructed HelixSeed data products to the REve visualization scene.
+ * Visualized as series of lines
+*/
+//FIXME - establish a use case, if none, remove!
+void DataInterface::AddHelixSeedCollection(REX::REveManager *&eveMng, bool firstloop, 
+                                         std::tuple<std::vector<std::string>, 
+                                         std::vector<const HelixSeedCollection*>> helix_tuple, 
+                                         REX::REveElement* &scene)
+{
+    std::cout << "[DataInterface::AddHelixSeedCollection]" << std::endl;
+
+    //FIXME - remove hardcoded (OK, it is the size of the tracker)
+    const int Z_START_MM = -1500;
+    const int Z_END_MM   = 1500;
+    const int Z_STEP_MM  = 100;
+    const int NUM_POINTS = (Z_END_MM - Z_START_MM) / Z_STEP_MM + 1; 
+
+    const auto& helix_list = std::get<1>(helix_tuple);
+    const auto& names = std::get<0>(helix_tuple);
+    
+    if (helix_list.empty()) return;
+
+    for(unsigned int j=0; j < helix_list.size(); j++){
+        const HelixSeedCollection* seedcol = helix_list[j];
+        
+        if(seedcol != nullptr){
+            std::string collection_title = "HelixSeed Collection: " + names[j];
+            auto collection_compound = new REX::REveCompound(collection_title.c_str(), collection_title.c_str(), true);
+
+            for(unsigned int k = 0; k < seedcol->size(); k++){
+                const mu2e::HelixSeed& hseed = (*seedcol)[k];
+                const mu2e::RobustHelix& rhelix = hseed.helix();
+                
+                // Calculate/Extract Useful Parameters for the Title
+                double momentum = rhelix.momentum(); // Momentum magnitude
+                double lambda_pitch = rhelix._lambda; // Pitch parameter: dZ/dPhi
+                double r_center = rhelix._rcent; // Radius of center vector
+                
+                // Create Detailed Title String
+                std::string helix_title = "HelixSeed " + std::to_string(k) + " tag: " + names[j] + '\n'
+                    + " Momentum (p): " + std::to_string(momentum) + " MeV/c" + '\n'
+                    + " Pitch (lambda): " + std::to_string(lambda_pitch) + '\n'
+                    + " Center Radius (R_cent): " + std::to_string(r_center) + " mm";
+                
+                
+                // Use the calculated number of points for the REveLine constructor
+                auto line = new REX::REveLine(helix_title.c_str(), helix_title.c_str(), NUM_POINTS);
+                
+                // Get Helix Parameters for Drawing
+                float helrad  = rhelix._radius;
+                float xc      = rhelix._rcent * cos(rhelix._fcent);
+                float yc      = rhelix._rcent * sin(rhelix._fcent);
+                float lambda  = rhelix._lambda;
+                float fz0     = rhelix._fz0;
+                
+                // Draw Synthetic Helix Points
+                for(int i = Z_START_MM; i <= Z_END_MM; i += Z_STEP_MM){
+                    float z = static_cast<float>(i);
+                    float circphi = 0.0;
+                    
+                    if(lambda != 0.0f) {
+                        circphi = fz0 + z / lambda;
+                    } else {
+                        circphi = fz0; 
+                    }
+
+                    float x = xc + helrad * cos(circphi);
+                    float y = yc + helrad * sin(circphi);
+                    
+                    CLHEP::Hep3Vector HelPos(x, y, z);
+                    
+                    line->SetNextPoint(pointmmTocm(HelPos.x()), pointmmTocm(HelPos.y()), pointmmTocm(HelPos.z()));
+                }
+                
+                // Update styles
+                line->SetLineColor(drawconfig.getInt("RecoTrackColor"));
+                line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
+                
+                collection_compound->AddElement(line);
+            } // End of k-loop (HelixSeeds)
+            
+            scene->AddElement(collection_compound);
         }
-      }
     }
-  }
 }
 
+/*
+ * Adds reconstructed KalIntersections data products to the REve visualization scene.
+ * Visualizedas points
+*/
+void DataInterface::AddKalIntersection(mu2e::KalSeed const& kalseed, REX::REveElement* &scene, REX::REveCompound *products, std::string track_tag)
+{
+    // Retrieve the vector of intersections from the KalSeed
+    std::vector<mu2e::KalIntersection> const& inters = kalseed.intersections();
+
+    // Iterate over all intersections
+    for(mu2e::KalIntersection const& inter : inters){
+        
+        const KinKal::VEC3& posKI = inter.position3();
+        
+        // Create Detailed Title String
+        std::string title = std::string("KalIntersection for track: ") + track_tag + '\n'
+            + "Surface: " + inter.surfaceId().name() + '\n'
+            + "Position (x, y, z): (" 
+                + std::to_string(posKI.x()) + ", " 
+                + std::to_string(posKI.y()) + ", " 
+                + std::to_string(posKI.z()) + ") mm" + '\n'
+            + "Time: " + std::to_string(inter.time()) + " ns" + '\n'
+            + "Momentum (p, dp): " 
+                + std::to_string(inter.mom()) + " +/- " 
+                + std::to_string(inter.dMom()) + " MeV/c";
+        
+        // Create and Style REve Point Set
+        auto interpoint = new REX::REvePointSet(title.c_str(), title.c_str(), 1);
 
-void DataInterface::AddHelixSeedCollection(REX::REveManager *&eveMng,bool firstloop,  std::tuple<std::vector<std::string>, std::vector<const HelixSeedCollection*>> helix_tuple, REX::REveElement* &scene){
-  std::cout<<"[DataInterface] AddHelices "<<std::endl;
-  std::vector<const HelixSeedCollection*> helix_list = std::get<1>(helix_tuple);
-  std::vector<std::string> names = std::get<0>(helix_tuple);
-  for(unsigned int j=0; j< helix_list.size(); j++){
-    const HelixSeedCollection* seedcol = helix_list[j];
-    if(seedcol!=0){
-      for(unsigned int k = 0; k < seedcol->size(); k++){
-        mu2e::HelixSeed hseed = (*seedcol)[k];
-        const ComboHitCollection& hhits = hseed.hits();
-        unsigned int nhhits = hhits.size();
-        auto line = new REX::REveLine(names[j], names[j],nhhits);
-        // std::cout<<"Helix hits = "<<nhhits<<" radius = "<<hseed.helix()._radius<<" x0 = "<<hseed.helix()._rcent*cos(hseed.helix()._fcent)<<std::endl;
-        float helrad = hseed.helix()._radius;
-        float circphi = 0.0;
-        float xc = hseed.helix()._rcent*cos(hseed.helix()._fcent);
-        float yc = hseed.helix()._rcent*sin(hseed.helix()._fcent);
-        if(hhits.size() !=0 ){
-          for(int i=-1500; i < 1500; i +=100){ //TODO Remove hard-coded numbers
-            float z = i;
-            if(hseed.helix()._lambda !=0.0) circphi = hseed.helix()._fz0 + z/hseed.helix()._lambda;
-            float x= xc + helrad*cos(circphi);
-            float y = yc + helrad*sin(circphi);
-            //std::cout<<"x = "<<x<<" y = "<<y<<" z = "<<z<<std::endl;
-            CLHEP::Hep3Vector HelPos(x, y, z);
-            if(circphi !=0.0)line->SetNextPoint(pointmmTocm(HelPos.x()),pointmmTocm(HelPos.y()) ,pointmmTocm(HelPos.z()));
-          }
+        // Assign color based on momentum uncertainty (dMom > 0 for material intersections)
+        Color_t marker_color = (fabs(inter.dMom()) > 0.0) ? kViolet : kYellow;
+        
+        interpoint->SetMarkerStyle(DataInterface::mstyle);
+        interpoint->SetMarkerSize(DataInterface::msize);
+        interpoint->SetMarkerColor(marker_color);
+
+        // Set Point Position
+        interpoint->SetNextPoint(pointmmTocm(posKI.x()), 
+                                 pointmmTocm(posKI.y()), 
+                                 pointmmTocm(posKI.z()));
+        
+        // Add to Products Compound
+        if (interpoint->GetSize() != 0) {
+            products->AddElement(interpoint);
         }
-        line->SetLineColor(drawconfig.getInt("RecoTrackColor"));
-        line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
-        scene->AddElement(line);
-      }
     }
-  }
 }
 
-void DataInterface::AddKalIntersection(KalSeed const& kalseed, REX::REveElement* &scene, REX::REveCompound *products){
-  //Plot intersecitons:
-  std::vector<mu2e::KalIntersection> const& inters = kalseed.intersections();
-
-  for(auto const& inter : inters){
-    KinKal::VEC3 posKI = inter.position3();
-    std::string title = "KalIntersection position : x "  + std::to_string(posKI.x())  +  '\n'
-      + " y " + std::to_string(posKI.y())  +  '\n'
-      + " z " + std::to_string(posKI.z())  +  '\n'
-      + " time :" + std::to_string(inter.time()) +  '\n'
-      + " mom , dmom : "
-      + std::to_string(inter.mom()) + " , " + std::to_string(inter.dMom())  +
-      + "MeV/c " + '\n'
-      + "Surface " +  inter.surfaceId().name();
-    auto interpoint = new REX::REvePointSet(title, title,1);
-
-    interpoint->SetMarkerStyle(DataInterface::mstyle);
-    interpoint->SetMarkerSize(DataInterface::msize);
-    if(fabs(inter.dMom()) > 0.0){
-      interpoint->SetMarkerColor(kViolet);// color material intersections differently from virtual surface intersections
-    } else {
-      interpoint->SetMarkerColor(kYellow);
+/*
+ * Adds reconstructed TrkStrawHits associated with KalSeed data products to the REve visualization scene.
+ * Visualized as points
+*/
+template<class KTRAJc> 
+void DataInterface::AddTrkStrawHit(mu2e::KalSeed const& kalseed, 
+                                 REX::REveElement* &scene,  
+                                 std::unique_ptr<KTRAJc> &lhptr, 
+                                 REX::REveCompound *trackproducts)
+{
+    std::cout << "[DataInterface::AddTrkStrawHit]" << std::endl;
+    
+    // Setup and Data Extraction
+    mu2e::GeomHandle<mu2e::Tracker> tracker;
+    std::vector<mu2e::TrkStrawHitSeed> const& hits = kalseed.hits();
+
+    // Configuration Constants
+    const double N_SIGMA = 2.0; // Length of the error line in sigma
+    const std::string SIGMA_TITLE = "+/-" + std::to_string(N_SIGMA) + " sigma";
+    
+    // Loop Over Track-Straw Hits
+    for(mu2e::TrkStrawHitSeed const& tshs : hits){
+        
+        // Get Geometry and State
+        const mu2e::Straw& straw = tracker->straw(tshs.strawId());
+        
+        // Setup the hit state based on parameters in the seed
+        mu2e::WireHitState whs(mu2e::WireHitState::State(tshs._ambig),
+                               mu2e::StrawHitUpdaters::algorithm(tshs._algo),
+                               tshs._kkshflag);
+        
+        bool active = whs.active();
+        bool usedrift = whs.driftConstraint();
+
+        // Calculate Position and Error Vectors
+        if(active){ 
+            
+            // Start position: position on the wire at the reference POCA (RUpOS)
+            auto tshspos = XYZVectorF(straw.wirePosition(tshs._rupos));
+            double hit_error(0.0);
+            
+            // Find direction perpendicular to the wire and the track direction (drift direction)
+            // track direction at POCA
+            auto tdir = lhptr->direction(tshs._ptoca); 
+            // wire direction
+            auto wdir = XYZVectorF(straw.wireDirection(tshs._rupos)); 
+            // drift direction is perpendicular to the plane formed by wire and track
+            auto ddir = wdir.Cross(tdir).Unit() * whs.lrSign(); 
+
+            if(usedrift){
+                // Move position out by the drift distance along the signed drift direction
+                tshspos += tshs._rdrift * ddir;
+                hit_error = tshs._sderr; // Use signed drift error
+            } else {
+                hit_error = tshs._uderr; // Use unsigned drift error
+            }
+            
+            // Calculate the endpoints for the error line segment
+            auto end1 = tshspos + N_SIGMA * hit_error * ddir;
+            auto end2 = tshspos - N_SIGMA * hit_error * ddir;
+            
+            // Create Title and Compound
+            std::string title = std::string("TrkStrawHitSeed:") + '\n'
+                + " Position (x,y,z): (" 
+                    + std::to_string(tshspos.x()) + ", " 
+                    + std::to_string(tshspos.y()) + ", " 
+                    + std::to_string(tshspos.z()) + ") mm" + '\n'
+                + " Time: " + std::to_string(tshs.time()) + " ns" + '\n'
+                + " EnergyDep: " + std::to_string(tshs.energyDep()) + " MeV" + '\n'
+                + " Error: " + SIGMA_TITLE;
+
+            // Compound holds the point and the error line together
+            auto point_with_error = new REX::REveCompound(title.c_str(), "TrkStrawHitSeed", 1);
+            
+            // Create Point Marker
+            auto trkstrawpoint = new REX::REvePointSet(title.c_str(), title.c_str(), 1);
+            
+            // Marker configuration
+            trkstrawpoint->SetMarkerStyle(DataInterface::mstyle);
+            trkstrawpoint->SetMarkerSize(DataInterface::msize);
+            
+            // Color logic: Redraw color if drift constraint wasn't used
+            Color_t base_color = drawconfig.getInt("TrkHitColor");
+            if (!usedrift) {
+                base_color = drawconfig.getInt("TrkNoHitColor");
+            }
+            trkstrawpoint->SetMarkerColor(base_color);
+            
+            // Set the position of the hit marker
+            trkstrawpoint->SetNextPoint(pointmmTocm(tshspos.x()), 
+                                       pointmmTocm(tshspos.y()), 
+                                       pointmmTocm(tshspos.z()));
+                                       
+            //  Error Line
+            auto line = new REX::REveLine(("TrkStrawHit Error " + SIGMA_TITLE).c_str(), SIGMA_TITLE.c_str(), 2);
+            
+            // Set line endpoints (converted to cm)
+            line->SetNextPoint(pointmmTocm(end1.x()), pointmmTocm(end1.y()), pointmmTocm(end1.z()));
+            line->SetNextPoint(pointmmTocm(end2.x()), pointmmTocm(end2.y()), pointmmTocm(end2.z()));
+            
+            // Line color is the same as the base hit color
+            line->SetLineColor(base_color); 
+
+            // Add Elements to Compound and Compound to Products
+            point_with_error->AddElement(trkstrawpoint);
+            point_with_error->AddElement(line);
+            
+            trackproducts->AddElement(point_with_error);
+        }
     }
-    interpoint->SetNextPoint(pointmmTocm(posKI.x()),pointmmTocm(posKI.y()) ,pointmmTocm(posKI.z()));
-    if(interpoint->GetSize() !=0 ) products->AddElement(interpoint);
-  }
-
 }
 
-template<class KTRAJc> void DataInterface::AddTrkStrawHit(KalSeed const& kalseed, REX::REveElement* &scene,  std::unique_ptr<KTRAJc> &lhptr, REX::REveCompound *trackproducts){
-  std::cout<<"[DataInterface::AddTrkStrawHit]"<<std::endl;
-  //Plot trk straw hits
-  mu2e::GeomHandle<mu2e::Tracker> tracker;
-  std::vector<mu2e::TrkStrawHitSeed> const& hits = kalseed.hits();
-
-  for(unsigned int i = 0; i < hits.size(); i++){
-    const mu2e::TrkStrawHitSeed &tshs = hits.at(i);
-    auto const& straw = tracker->straw(tshs.strawId());
-    mu2e::WireHitState whs(mu2e::WireHitState::State(tshs._ambig),
-        mu2e::StrawHitUpdaters::algorithm(tshs._algo),
-        tshs._kkshflag);
-    bool active = whs.active();
-    bool usedrift = whs.driftConstraint();
-    if(active){ // maybe draw inactive hits but with a different color? TODO
-      // then find the position at the reference POCA: start with the position on the wire
-      auto tshspos = XYZVectorF(straw.wirePosition(tshs._rupos));
-      double herr(0.0);
-      //find the direction along DOCA
-      auto tdir = lhptr->direction(tshs._ptoca);
-      auto wdir = XYZVectorF(straw.wireDirection(tshs._rupos));
-      auto ddir = wdir.Cross(tdir).Unit()*whs.lrSign();
-      if(usedrift){
-        // move the position out on the signed drift direction.
-        tshspos += tshs._rdrift*ddir;
-        herr = tshs._sderr;
-      } else {
-        herr = tshs._uderr;
-      }
-      // set the line length to be N sigma.  1 may be too short to see, TODO
-      double nsigma(2.0);
-      auto end1 = tshspos + nsigma*herr*ddir;
-      auto end2 = tshspos - nsigma*herr*ddir;
-      std::string err_title = "+/-"+std::to_string(nsigma) +"sigma";
-
-      //goes along that same line (ddir)
-      std::string title = "TrkStrawHitSeed : x "  + std::to_string(tshspos.x())  +  '\n'
-        + " y " + std::to_string(tshspos.y())  +  '\n'
-        + " z " + std::to_string(tshspos.z())  +  '\n'
-        + " time :" + std::to_string(tshs.time())+  '\n'
-        + " energyDep :" + std::to_string(tshs.energyDep())+ "MeV" + '\n'
-        + " error : " + err_title;
-      auto point_with_error = new REX::REveCompound("TrkStrawHitSeed "+std::to_string(i), "TrkStrawHitSeed",1);
-      auto trkstrawpoint = new REX::REvePointSet(title, title,1);
-      trkstrawpoint->SetMarkerStyle(DataInterface::mstyle);
-      trkstrawpoint->SetMarkerSize(DataInterface::msize);
-      trkstrawpoint->SetMarkerColor(drawconfig.getInt("TrkHitColor"));
-      auto line = new REX::REveLine("TrkStrawHit Error"+err_title,err_title, 1);
-      line->SetNextPoint(pointmmTocm(end1.x()),pointmmTocm(end1.y()) ,pointmmTocm(end1.z()));
-      line->SetNextPoint(pointmmTocm(end2.x()),pointmmTocm(end2.y()) ,pointmmTocm(end2.z()));
-      line->SetLineColor(drawconfig.getInt("TrkHitColor"));
-      if(!usedrift)trkstrawpoint->SetMarkerColor(drawconfig.getInt("TrkNoHitColor"));
-      trkstrawpoint->SetNextPoint(pointmmTocm(tshspos.x()),pointmmTocm(tshspos.y()) ,pointmmTocm(tshspos.z()));
-      point_with_error->AddElement(trkstrawpoint);
-      point_with_error->AddElement(line);
-      trackproducts->AddElement(point_with_error);
-    }
-  }
-}
+/*
+ * Adds reconstructed TrkCaloHitSeed products, visualized as points
+*/
+void DataInterface::AddTrkCaloHit(mu2e::KalSeed const& kalseed, REX::REveElement* &scene)
+{
+    std::cout<<"[DataInterface::AddTrkCaloHit]"<<std::endl;
+    // The TrkCaloHitSeed is a member of the KalSeed
+    const mu2e::TrkCaloHitSeed& caloseed = kalseed.caloHit();
+    
+    // The caloseed contains an art::Ptr to the CaloCluster
+    art::Ptr<mu2e::CaloCluster> cluster = caloseed.caloCluster(); 
+
+    // Check if a valid CaloCluster is associated with the track
+    if (cluster) {
+        // Extract Cluster Information
+        CLHEP::Hep3Vector clusterPos = cluster->cog3Vector();
+        double energy = cluster->energyDep();
+        double time = cluster->time();
+        // Get Geometry Handles
+        mu2e::Calorimeter const &cal = *(mu2e::GeomHandle<mu2e::Calorimeter>());
+        GeomHandle<DetectorSystem> det;
+        // Create Title String
+        std::string cluster_title = std::string("TrkCaloHit CaloCluster") + '\n'
+                                  + " Position (x,y,z): (" 
+                                  + std::to_string(clusterPos.x()) + ", " 
+                                  + std::to_string(clusterPos.y()) + ", " 
+                                  + std::to_string(clusterPos.z()) + ") mm" + '\n'
+                                  + " Energy: " + std::to_string(energy) + " MeV" + '\n'
+                                  + " Time: " + std::to_string(time) + " ns";
+
+        CLHEP::Hep3Vector crystalPos = cal.geomUtil().mu2eToDisk(cluster->diskID(),clusterPos);
+        CLHEP::Hep3Vector pointInMu2e = det->toMu2e(crystalPos);
 
-void DataInterface::AddTrkCaloHit(KalSeed const& kalseed, REX::REveElement* &scene){
-  /*mu2e::TrkCaloHitSeed caloseed = kalseed.caloHit();
-    art::Ptr<mu2e::CaloCluster> cluster = caloseed.caloCluster(); // TODO - use this to access x,y,z,t
-    */
-}
+        // Create REve Point Set
+        auto ps1 = new REX::REvePointSet(cluster_title.c_str(), cluster_title.c_str(), 1); 
 
-/*------------Function to color code the Tracker hits -------------*/
-void DataInterface::AddTrkHits(REX::REveManager *&eveMng, bool firstLoop_, std::tuple<std::vector<std::string>, std::vector<const ComboHitCollection*>> combohit_tuple,std::tuple<std::vector<std::string>, std::vector<const KalSeedPtrCollection*>> track_tuple, REX::REveElement* &scene){
-  std::cout<<"[DataInterface] AddTrkHits  "<<std::endl;
-  std::vector<const ComboHitCollection*> combohit_list = std::get<1>(combohit_tuple);
-  std::vector<const KalSeedPtrCollection*> track_list = std::get<1>(track_tuple);
-
-  GeomHandle<DetectorSystem> det;
-  std::vector<StrawId> trksid(drawconfig.getInt("maxStrawID"));
-  unsigned int trkhitsize=0;
-  //Save the hit straw IDs of the KalSeed hits
-  for(unsigned int j = 0; j< track_list.size(); j++){
-    const KalSeedPtrCollection* seedcol = track_list[j];
-    if(seedcol!=0){
-      for(unsigned int k = 0; k < seedcol->size(); k++){
-        auto const& kseed = *(*seedcol)[k];
-        const std::vector<mu2e::TrkStrawHitSeed> &hits = kseed.hits();
-        trkhitsize = hits.size();
-        for(unsigned int i = 0; i <trkhitsize; i++){
-          const mu2e::TrkStrawHitSeed &hit = hits.at(i);
-          trksid[i] = hit._sid;
-        }
-        std::vector<StrawId> usedtrksid(trkhitsize);
-        std::vector<unsigned int> usedid(trkhitsize);
-        //Compare the straw IDs of the Kal seed hits with the hits in the ComboHit Collection
-        for(unsigned int j=0; j< combohit_list.size(); j++){
-          const ComboHitCollection* chcol = combohit_list[j]; //TODO shouldnt rely on ComboHits
-          if(chcol!=0){
-            for(unsigned int i=0; i<chcol->size();i++){
-              ComboHit hit = (*chcol)[i];
-              for(unsigned int q=0; q<trkhitsize; q++){
-                if(hit._sid == trksid[q]){
-                  usedtrksid[q]=hit._sid;//Save the Straw ID if the KalSeed and Combo hit ID matches
-                  usedid[q]=q;
-                  CLHEP::Hep3Vector HitPos(hit.pos().x(), hit.pos().y(), hit.pos().z());
-                  std::string chtitle = "TrkSeedHit position : x "  + std::to_string(hit.pos().x())  +  '\n'
-                    + " y " + std::to_string(hit.pos().y())  +  '\n'
-                    + " z " + std::to_string(hit.pos().z())  +  '\n'
-                    + " time :" + std::to_string(hit.time()) +  '\n'
-                    + " energy dep : "
-                    + std::to_string(hit.energyDep())  +
-                    + "MeV";
-
-                  auto trkhit = new REX::REvePointSet(chtitle, chtitle,0);
-                  trkhit ->SetMarkerStyle(DataInterface::mstyle);
-                  trkhit ->SetMarkerSize(DataInterface::msize);
-                  // trkhit ->SetMarkerColor(drawconfig.getInt("RecoTrackColor")-4);
-                  trkhit ->SetMarkerColor(drawconfig.getInt("TrkHitColor"));
-                  trkhit ->SetNextPoint(pointmmTocm(HitPos.x()),pointmmTocm(HitPos.y()) ,pointmmTocm(HitPos.z()));
-                  if(trkhit->GetSize() !=0 ) scene->AddElement(trkhit);
-                  // std::cout<<"TrkHit = "<<HitPos.x()<<"  "<<HitPos.y()<<" "<<HitPos.z()<<std::endl;
-                }
-              }
-            }
-          }
+        // Set Positions, Color, and Size
+        if(cluster->diskID() == 0)    
+            ps1->SetNextPoint(pointmmTocm(clusterPos.x()), pointmmTocm(clusterPos.y()) , abs(pointmmTocm(pointInMu2e.z())));
+        if(cluster->diskID() == 1)
+            ps1->SetNextPoint(pointmmTocm(clusterPos.x()), pointmmTocm(clusterPos.y()) , abs(pointmmTocm(pointInMu2e.z())));
+
+
+        // Styling
+        ps1->SetMarkerColor(drawconfig.getInt("TrkHitColor")); 
+        ps1->SetMarkerStyle(kFullDiamond);
+        ps1->SetMarkerSize(DataInterface::msize * 3.0);
+
+        // Add to Scene
+        if (ps1->GetSize() != 0) {
+            scene->AddElement(ps1);
         }
-      }
     }
-  }
 }
 
+/*
+ * Adds reconstructed KTRAJ data products to the REve visualization scene.
+ * Visualized as line set
+*/
 using LHPT = KalSeed::LHPT;
 using CHPT = KalSeed::CHPT;
 using KLPT = KalSeed::KLPT;
-template<class KTRAJ> void DataInterface::AddKinKalTrajectory( std::unique_ptr<KTRAJ> &trajectory, REX::REveElement* &scene, unsigned int j, std::string kaltitle, double& t1, double& t2){
-  t1=trajectory->range().begin();
-  t2=trajectory->range().end();
-
-  double x1=trajectory->position3(t1).x();
-  double y1=trajectory->position3(t1).y();
-  double z1=trajectory->position3(t1).z();
-
-  auto line = new REX::REveLine(kaltitle,kaltitle, 100);
-  line->SetPoint(0,pointmmTocm(x1), pointmmTocm(y1) , pointmmTocm(z1));
-  for(double t=t1; t<=t2; t+=0.1)
-  {
-    const auto &p = trajectory->position3(t);
-    double xt=p.x();
-    double yt=p.y();
-    double zt=p.z();
-    line->SetNextPoint(pointmmTocm(xt), pointmmTocm(yt) , pointmmTocm(zt));
-  }
-  line->SetLineColor(j+6);
-  line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
-  scene->AddElement(line);
+template<class KTRAJ> 
+void DataInterface::AddKinKalTrajectory(std::unique_ptr<KTRAJ> &trajectory, 
+                                        REX::REveElement* &scene, 
+                                        unsigned int j, 
+                                        std::string kaltitle, 
+                                        double& t1, // event range will be updated
+                                        double& t2)
+{
+    // Extract Time Range
+    // The range object is returned by value/reference, so we access its limits once.
+    t1 = trajectory->range().begin();
+    t2 = trajectory->range().end();
+
+    // Calculate Number of Points and Setup Line Object
+    // Calculate required number of points for the loop: (t2 - t1) / 0.1 + 1 (for the starting point)
+    double time_step = 0.1;
+    size_t num_steps = static_cast<size_t>((t2 - t1) / time_step) + 1;
+
+    // Create the REveLine with the pre-calculated title and required size
+    auto line = new REX::REveLine(kaltitle.c_str(), kaltitle.c_str(), num_steps);
+
+    // Iterate Through Time and Plot Points 
+    
+    // Set the first point explicitly (t = t1)
+    const auto &p_start = trajectory->position3(t1);
+    line->SetPoint(0, pointmmTocm(p_start.x()), pointmmTocm(p_start.y()), pointmmTocm(p_start.z()));
+    
+    // Loop from t1 + step up to t2
+    for(double t = t1 + time_step; t <= t2; t += time_step)
+    {
+        // Get the position vector once
+        const auto &p = trajectory->position3(t);
+        
+        // Add the point, converting units
+        line->SetNextPoint(pointmmTocm(p.x()), 
+                           pointmmTocm(p.y()), 
+                           pointmmTocm(p.z()));
+    }
+
+    // Styling and Scene Addition
+    line->SetLineColor(j + 6); // Use a color based on the collection index (j)
+    line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
+    scene->AddElement(line);
 }
 
-void DataInterface::FillKinKalTrajectory(REX::REveManager *&eveMng, bool firstloop, REX::REveElement* &scene, std::tuple<std::vector<std::string>, std::vector<const KalSeedPtrCollection*>> track_tuple, bool plotKalIntersection, bool addTrkHits, double& t1, double& t2){
-  std::cout<<"[DataInterface::FillKinKalTrajectory()]"<<std::endl;
-  auto const& ptable = GlobalConstantsHandle<ParticleDataList>();
-  std::vector<const KalSeedPtrCollection*> track_list = std::get<1>(track_tuple);
-  std::vector<std::string> names = std::get<0>(track_tuple);
-  for(unsigned int j=0; j< track_list.size(); j++){
-    const KalSeedPtrCollection* seedcol = track_list[j];
-    if(seedcol!=0){
-      for(auto const& kseedptr : *seedcol){
-        auto const& kseed = *kseedptr;
-//        unsigned nhits = kseed.hits().size();
-        unsigned nactive =0;
-        for (auto const& hit : kseed.hits()){ if (hit.strawHitState() > WireHitState::inactive) ++nactive; }
-        // use t0 to define the reference segment
-        double t0;
-        kseed.t0Segment(t0);
-        std::stringstream ksstream;
-        REX::REveCompound *trackproducts = new REX::REveCompound("Track Products for KalSeed "+ ptable->particle(kseed.particle()).name() + " LoopHelix ","Track Products for KalSeed "+ ptable->particle(kseed.particle()).name() + " LoopHelix " ,1);
-        if(kseed.loopHelixFit())
-        {
-          auto trajectory=kseed.loopHelixFitTrajectory();
-          auto const& lh = trajectory->nearestPiece(t0);
-          auto momvec = lh.momentum3(t0);
-          ksstream << ptable->particle(kseed.particle()).name() <<  " LoopHelix "
-            << std::setw(6) << std::setprecision(3)
-            <<  momvec.R() << " MeV/c, cos(Theta) " << cos(momvec.Theta()) << std::endl
-            << "t0 " << lh.t0() << " ns "
-            << "lam "  << lh.lam() << " mm "
-            << "rad "  << lh.rad() << " mm " << std::endl
-            << "cx "  << lh.cx() << " mm "
-            << "cy "  << lh.cy() << " mm "
-            << "phi0 "  << lh.phi0() << " rad " << std::endl
-            << "N hits " <<  nactive << " fit cons. " << kseed.fitConsistency() << std::endl
-            << "Instance " << names[j] << std::endl;
-          AddKinKalTrajectory<LHPT>(trajectory,scene,j, ksstream.str(), t1, t2);
-          if(addTrkHits) {
-            AddTrkStrawHit<LHPT>(kseed, scene, trajectory,trackproducts);
-          }
-        }
-        else if(kseed.centralHelixFit())
-        {
-          auto trajectory=kseed.centralHelixFitTrajectory();
-          auto const& ch = trajectory->nearestPiece(t0);
-          auto momvec = ch.momentum3(t0);
-          ksstream << ptable->particle(kseed.particle()).name() << " CentralHelix "
-            << std::setw(6) << std::setprecision(3)
-            <<  momvec.R() << " MeV/c, cos(Theta) " << cos(momvec.Theta()) << std::endl
-            << "t0 " << ch.t0() << " ns "
-            << "tandip " << ch.tanDip( )
-            << "d0 " << ch.d0( ) << " mm " << std::endl
-            << "z0 " << ch.z0( ) << " mm "
-            << "phi0 " << ch.phi0( ) << " rad "
-            << "omega " << ch.omega( )<< " mm^-1 " << std::endl
-            << "track arrival time " << t1 << std::endl
-            << "Instance " << names[j] << std::endl;
-          AddKinKalTrajectory<CHPT>(trajectory,scene,j, ksstream.str(), t1, t2);
-          if(addTrkHits) {
-            AddTrkStrawHit<CHPT>(kseed, scene, trajectory,trackproducts);
-            }
-        }
-        else if(kseed.kinematicLineFit())
-        {
-          auto trajectory=kseed.kinematicLineFitTrajectory();
-          auto const& kl = trajectory->nearestPiece(t0);
-          auto momvec = kl.momentum3(t0);
-          ksstream << ptable->particle(kseed.particle()).name() << " KinematicLine "
-            << std::setw(6) << std::setprecision(3)
-            <<  momvec.R() << " MeV/c, cos(Theta) " << cos(momvec.Theta()) << std::endl
-            << " t0 " << kl.t0() << " ns "
-            << " d0 " << kl.d0( ) << " mm "
-            << " z0 " << kl.z0( ) << " mm " << std::endl
-            << " phi0 " << kl.phi0( )<< " rad "
-            << " theta " << kl.theta( ) << " rad " <<  std::endl
-            << " track arrival time " << t1 << std::endl
-            << " Instance " << names[j] << std::endl;
-          AddKinKalTrajectory<KLPT>(trajectory,scene,j, ksstream.str(), t1, t2);
-          if(addTrkHits) {
-            AddTrkStrawHit<KLPT>(kseed, scene, trajectory, trackproducts );
-          }
-        }
-        if(plotKalIntersection) AddKalIntersection(kseed, scene,trackproducts );
-        if(addTrkHits or plotKalIntersection) {
-        scene->AddElement(trackproducts);
-        }
-      }
+/*
+ * Adds reconstructed KTRAJ
+*/
+void DataInterface::FillKinKalTrajectory(REX::REveManager *&eveMng, bool firstloop, REX::REveElement* &scene, 
+                                         std::tuple<std::vector<std::string>, 
+                                         std::vector<const KalSeedPtrCollection*>> track_tuple, 
+                                         bool plotKalIntersection, bool addTrkHits, bool addTrkCaloHits, 
+                                         double& t1, double& t2)
+{
+    std::cout << "[DataInterface::FillKinKalTrajectory()]" << std::endl;
+    
+    // Critical Logic: Scene Cleanup 
+    if (!firstloop) {
+        scene->DestroyElements();
     }
-  }
+
+    // Setup and Data Extraction 
+    const auto& ptable = GlobalConstantsHandle<ParticleDataList>();
+    const auto& track_list = std::get<1>(track_tuple);
+    const auto& names = std::get<0>(track_tuple);
+    
+    if (track_list.empty()) return;
+
+    // Loop over KalSeed Collections 
+    for(unsigned int j = 0; j < track_list.size(); j++){
+        const mu2e::KalSeedPtrCollection* seedcol = track_list[j];
+        
+        if(seedcol == nullptr) continue;
+        
+        // Loop over individual KalSeeds 
+        for(const auto& kseedptr : *seedcol){
+            if (!kseedptr) continue;
+            
+            const mu2e::KalSeed& kseed = *kseedptr;
+            std::string particle_name = ptable->particle(kseed.particle()).name();
+
+            // Determine active hits for display info 
+            unsigned nactive = 0;
+            for (auto const& hit : kseed.hits()){ 
+                if (hit.strawHitState() > mu2e::WireHitState::inactive) {
+                    ++nactive; 
+                }
+            }
+            
+            // Find t0 and Setup Output Container
+            double t0;
+            kseed.t0Segment(t0);
+
+            // Container for all points, hits, and intersections for THIS track
+            std::string compound_name = "Track Products for KalSeed " + particle_name;
+            REX::REveCompound *trackproducts = new REX::REveCompound(compound_name.c_str(), compound_name.c_str(), 1);
+            
+            std::stringstream ksstream;
+            std::string tag = particle_name;
+
+            // Loop Helix Fit 
+            if(kseed.loopHelixFit()) {
+                tag += " Loop Helix";
+                auto trajectory = kseed.loopHelixFitTrajectory();
+                const auto& lh = trajectory->nearestPiece(t0);
+                auto momvec = lh.momentum3(t0);
+                
+                ksstream << particle_name << " LoopHelix "
+                    << std::setw(6) << std::setprecision(3) << momvec.R() << " MeV/c, cos(Theta) " << cos(momvec.Theta()) << '\n'
+                    << "t0 " << lh.t0() << " ns, "
+                    << "lam " << lh.lam() << " mm, "
+                    << "rad " << lh.rad() << " mm" << '\n'
+                    << "cx " << lh.cx() << " mm, "
+                    << "cy " << lh.cy() << " mm, "
+                    << "phi0 " << lh.phi0() << " rad" << '\n'
+                    << "N active hits: " << nactive << ", Fit cons: " << kseed.fitConsistency() << '\n'
+                    << "Instance: " << names[j];
+                
+                AddKinKalTrajectory<LHPT>(trajectory, scene, j, ksstream.str(), t1, t2);
+                if(addTrkHits) {
+                    AddTrkStrawHit<LHPT>(kseed, scene, trajectory, trackproducts);
+                    if(addTrkCaloHits) AddTrkCaloHit(kseed, scene);
+                }
+            }
+            
+            // Central Helix Fit 
+            else if(kseed.centralHelixFit()) {
+                tag += " Central Helix";
+                auto trajectory = kseed.centralHelixFitTrajectory();
+                const auto& ch = trajectory->nearestPiece(t0);
+                auto momvec = ch.momentum3(t0);
+                
+                ksstream << particle_name << " CentralHelix "
+                    << std::setw(6) << std::setprecision(3) << momvec.R() << " MeV/c, cos(Theta) " << cos(momvec.Theta()) << '\n'
+                    << "t0 " << ch.t0() << " ns, "
+                    << "tandip " << ch.tanDip() << '\n'
+                    << "d0 " << ch.d0() << " mm, "
+                    << "z0 " << ch.z0() << " mm, "
+                    << "phi0 " << ch.phi0() << " rad" << '\n'
+                    << "omega " << ch.omega() << " mm^-1" << '\n'
+                    << "Track arrival time " << t1 << '\n'
+                    << "Instance: " << names[j];
+                
+                AddKinKalTrajectory<CHPT>(trajectory, scene, j, ksstream.str(), t1, t2);
+                if(addTrkHits) {
+                    AddTrkStrawHit<CHPT>(kseed, scene, trajectory, trackproducts);
+                    if(addTrkCaloHits) AddTrkCaloHit(kseed, scene);
+                }
+            }
+            
+            // Kinematic Line Fit 
+            else if(kseed.kinematicLineFit()) {
+                tag += " Kinematic Line";
+                auto trajectory = kseed.kinematicLineFitTrajectory();
+                const auto& kl = trajectory->nearestPiece(t0);
+                auto momvec = kl.momentum3(t0);
+                
+                ksstream << particle_name << " KinematicLine "
+                    << std::setw(6) << std::setprecision(3) << momvec.R() << " MeV/c, cos(Theta) " << cos(momvec.Theta()) << '\n'
+                    << "t0 " << kl.t0() << " ns, "
+                    << "d0 " << kl.d0() << " mm, "
+                    << "z0 " << kl.z0() << " mm" << '\n'
+                    << "phi0 " << kl.phi0() << " rad, "
+                    << "theta " << kl.theta() << " rad" << '\n'
+                    << "Track arrival time " << t1 << '\n'
+                    << "Instance: " << names[j];
+                
+                AddKinKalTrajectory<KLPT>(trajectory, scene, j, ksstream.str(), t1, t2);
+                if(addTrkHits) {
+                    AddTrkStrawHit<KLPT>(kseed, scene, trajectory, trackproducts);
+                    if(addTrkCaloHits) AddTrkCaloHit(kseed, scene);
+                }
+            }
+            
+            // Final Additions for the Current KalSeed 
+            if(plotKalIntersection) {
+                AddKalIntersection(kseed, scene, trackproducts, tag);
+            }
+            
+            // Add the compound of all hits/intersections if we added anything to it
+            // The logic implies we add it if hits OR intersections were requested.
+            if(addTrkHits || plotKalIntersection) {
+                scene->AddElement(trackproducts);
+            }
+
+        } // End of inner loop (KalSeeds)
+    } // End of outer loop (Collections)
 }
 
-void DataInterface::AddCosmicTrackFit(REX::REveManager *&eveMng, bool firstLoop_, const mu2e::CosmicTrackSeedCollection *cosmiccol, REX::REveElement* &scene){
-
-  std::cout<<"[DataInterface] AddCosmicTrackSeed "<<std::endl;
-  if(cosmiccol!=0){
-    auto line = new REX::REveLine("Cosmic","Cosmic",2);
-    for(unsigned int i=0; i< cosmiccol->size(); i++){
-      mu2e::CosmicTrackSeed const  &sts= (*cosmiccol)[i];
-      mu2e::CosmicTrack st = sts._track;
-      double ty1 = sts._straw_chits[0].pos().y();
-      double ty2 = sts._straw_chits[sts._straw_chits.size()-1].pos().y();
-      double tx1 = st.MinuitParams.A0  - st.MinuitParams.A1*ty1;
-      double tx2 = st.MinuitParams.A0  - st.MinuitParams.A1*ty2;
-      double tz1 = st.MinuitParams.B0  - st.MinuitParams.B1*ty1;
-      double tz2 = st.MinuitParams.B0  - st.MinuitParams.B1*ty2;
-      line->SetNextPoint(pointmmTocm(tx1), pointmmTocm(ty1) , pointmmTocm(tz1));
-      line->SetNextPoint(pointmmTocm(tx2), pointmmTocm(ty2) , pointmmTocm(tz2));
-    }
+/*
+ * Adds reconstructed CosmicTrackSeed product, visualized as line
+*/
+/*Function to visualize CosmicTrackSeed fits (straight lines)-*/
+void DataInterface::AddCosmicTrackFit(REX::REveManager *&eveMng, bool firstLoop_, 
+                                      const mu2e::CosmicTrackSeedCollection *cosmiccol, 
+                                      REX::REveElement* &scene)
+{
+    std::cout << "[DataInterface] AddCosmicTrackSeed" << std::endl;
+
+    
+    if (cosmiccol == nullptr) return;
+    
+    // Create a compound to hold all individual cosmic tracks for organization
+    auto all_tracks_compound = new REX::REveCompound("Cosmic Tracks", "Cosmic Tracks", true);
+    
+    // Loop over individual CosmicTrackSeeds 
+    for(size_t i = 0; i < cosmiccol->size(); i++){
+        const mu2e::CosmicTrackSeed& sts = (*cosmiccol)[i];
+        const mu2e::CosmicTrack& st = sts._track;
+        
+        // Ensure there are enough hits to define a track segment
+        if (sts._straw_chits.size() < 2) continue;
 
-    line->SetLineColor(drawconfig.getInt("RecoTrackColor"));
-    line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
-    scene->AddElement(line);
-  }
+        // Define Track Segment Endpoints 
+        // The track is parameterized as: X(y) = A0 - A1*y, Z(y) = B0 - B1*y.
+        // We plot the line segment between the Y-positions of the first and last hits.
+        
+        const mu2e::ComboHit& first_hit = sts._straw_chits.front();
+        const mu2e::ComboHit& last_hit = sts._straw_chits.back();
+        
+        double ty1 = first_hit.pos().y();
+        double ty2 = last_hit.pos().y();
+        
+        // Calculate the (X, Z) coordinates at Y1 and Y2 using the fit parameters
+        double tx1 = st.MinuitParams.A0 - st.MinuitParams.A1 * ty1;
+        double tx2 = st.MinuitParams.A0 - st.MinuitParams.A1 * ty2;
+        double tz1 = st.MinuitParams.B0 - st.MinuitParams.B1 * ty1;
+        double tz2 = st.MinuitParams.B0 - st.MinuitParams.B1 * ty2;
+        
+        // Create and Populate REveLine for the Current Track 
+        std::string track_title = "Cosmic Track " + std::to_string(i) 
+                                + " N_Hits: " + std::to_string(sts._straw_chits.size());
+        auto line = new REX::REveLine(track_title.c_str(), track_title.c_str(), 2);
+        
+        // Set Point 1 (Start)
+        line->SetNextPoint(pointmmTocm(tx1), pointmmTocm(ty1), pointmmTocm(tz1));
+        
+        // Set Point 2 (End)
+        line->SetNextPoint(pointmmTocm(tx2), pointmmTocm(ty2), pointmmTocm(tz2));
 
+        // 3. Styling and Addition 
+        line->SetLineColor(drawconfig.getInt("RecoTrackColor"));
+        line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
+        
+        all_tracks_compound->AddElement(line);
+    }
+    
+    // Add the compound of all tracks to the scene
+    scene->AddElement(all_tracks_compound);
 }
 
diff --git a/src/EventDisplayManager.cc b/src/EventDisplayManager.cc
index 7774670..f0ad526 100644
--- a/src/EventDisplayManager.cc
+++ b/src/EventDisplayManager.cc
@@ -1,49 +1,130 @@
 #include "EventDisplay/inc/EventDisplayManager.hh"
-
-
 namespace mu2e {
 
-  EventDisplayManager::EventDisplayManager(
+// --- Constructor Implementation ---
+/**
+ * @brief Constructs the EventDisplayManager singleton instance.
+ * * It stores pointers to the global REve manager and the synchronization primitives (mutex/cv).
+ * The TextSelect pointer is now passed via the setTextSelectId method instead of the constructor.
+ * @param eveMgr The global REveManager instance.
+ * @param cv The condition variable for thread signaling.
+ * @param m The mutex for thread synchronization.
+ * @param fGui The pointer to the custom GUI element.
+ */
+EventDisplayManager::EventDisplayManager(
     ROOT::Experimental::REveManager* eveMgr,
     std::condition_variable& cv,
     std::mutex& m,
-    GUI *fGui,
-    TextSelect *fText)
-    : REveElement{"EventManager"}, eveMng_{eveMgr}, cv_{&cv}, m_{&m}, fGui_(fGui), fText_(fText)
-  {}
-
-  void
-  EventDisplayManager::NextEvent()
-  {
-    std::unique_lock lock{*m_};
-    cv_->notify_all();
-  }
-
-  void
-  EventDisplayManager::QuitRoot()
-  {
+    GUI *fGui)
+    : 
+    REveElement{"EventManager"}, 
+    eveMng_{eveMgr}, 
+    cv_{&cv}, 
+    m_{&m}, 
+    fGui_(fGui)
+{
+}
+
+// --- Thread Synchronization & Commands ---
+
+/*Signals the waiting Art thread to load the next event.
+ This function is invoked by the "NextEvent" REve command button.
+*/
+void EventDisplayManager::NextEvent()
+{
+    std::unique_lock lock{*m_}; // Acquire lock on the mutex
+    cv_->notify_all();          // Notify the waiting Art thread (in analyze())
+}
+
+/*Terminates the application and exits the process.
+ Invoked by the "QuitRoot" REve command button.
+ */
+void EventDisplayManager::QuitRoot()
+{
     std::cout<<"Exit Signal 15, leaving REve Display "<<std::endl;
     exit(15);
-  }
-  void EventDisplayManager::autoplay(int  x)
-   {
-      std::cout << "EventManger autoplay() ....... " << x << std::endl;
-   }
-   int EventDisplayManager::getR(){
-    return this->run;
-  }
-   void EventDisplayManager::setR(int runId){
-    std::cout<<"[EventDisplayManager::setR] taking run number"<<this->run<<" and passing in "<<runId<<std::endl;
-    this->run = runId;
-    std::cout<<"[EventDisplayManager::setR] run number now "<<this->run<<std::endl;
-  }
-  
-   void EventDisplayManager::goToRunEvent(int runId, int eventId)
-   {
-      std::cout << "[EventDisplayManager::goToRunEvent] received: " << runId<<" "<<eventId << std::endl;
-      setR(runId);
-      std::cout<<"[EventDisplayManager::goToRunEvent] value is now"<<this->run<<std::endl;
-      fText_->set(runId,eventId);
-   }
+}
+
+/*Place holder, it will be used for online running - streaming events
+ */
+void EventDisplayManager::autoplay(int x)
+{
+    std::cout << "EventManger autoplay() ....... " << x << std::endl;
+    
+    TextSelect* fText_obj = nullptr;
+    
+    // Check if the global REveManager instance is available.
+    if (ROOT::Experimental::gEve != nullptr) {
+        
+        // 1. Retrieve the generic REveElement using the global manager (gEve) and the Element ID.
+        // The function name should be FindElementWithId(fTextId_)but I found that this does not work so I hardcoded FIXME
+        ROOT::Experimental::REveElement* element = ROOT::Experimental::gEve->FindElementById(4336); 
+        
+        if (element != nullptr) {
+            // 2. Safely cast the generic element to the specific TextSelect type.
+            fText_obj = dynamic_cast<TextSelect*>(element);
+        }
+    }
+    
+    if (fText_obj == nullptr) {
+        // CRITICAL ERROR if the object wasn't found or the cast failed.
+        std::cerr << "CRITICAL ERROR: TextSelect object not found via gEve->FindElementWithId(" 
+                  << fTextId_ << "). Cannot set Run/Event." << std::endl; 
+        return; 
+    }
+
+    // 3. Command executed: Set the Run/Event numbers in the TextSelect object.
+    fText_obj->setAutoplay(x); 
+}
+
+
+
+// --- Element ID Management ---
+
+/**
+ * @brief Stores the unique REve Element ID (EId_t) for the TextSelect object.
+ * * This ID is used for robust, thread-safe lookup of the object via gEve.
+ * @param textId The assigned REve Element ID (e.g., 4285).
+ */
+void EventDisplayManager::setTextSelectId(std::uint32_t textId) {
+    fTextId_ = textId;
+    std::cout << "[EventDisplayManager::setTextSelectId] fTextId_ set to: " << fTextId_ << std::endl;
+}
+
+// --- Core Lookup and Command Execution ---
+
+/**
+ * @brief Executes the command to set the user-requested Run/Event ID.
+ * * This runs in the REve thread and communicates the command to the TextSelect object.
+ */
+void mu2e::EventDisplayManager::goToRunEvent(int runId, int eventId)
+{
+    std::cout << "[EventDisplayManager::goToRunEvent] received: " << runId<<" "<<eventId << std::endl;
+    
+    TextSelect* fText_obj = nullptr;
+    
+    // Check if the global REveManager instance is available.
+    if (ROOT::Experimental::gEve != nullptr) {
+        
+        // 1. Retrieve the generic REveElement using the global manager (gEve) and the Element ID.
+        // The function name should be FindElementWithId(fTextId_)but I found that this does not work so I hardcoded FIXME
+        ROOT::Experimental::REveElement* element = ROOT::Experimental::gEve->FindElementById(4336); 
+        
+        if (element != nullptr) {
+            // 2. Safely cast the generic element to the specific TextSelect type.
+            fText_obj = dynamic_cast<TextSelect*>(element);
+        }
+    }
+    
+    if (fText_obj == nullptr) {
+        // CRITICAL ERROR if the object wasn't found or the cast failed.
+        std::cerr << "CRITICAL ERROR: TextSelect object not found via gEve->FindElementWithId(" 
+                  << fTextId_ << "). Cannot set Run/Event." << std::endl; 
+        return; 
+    }
+
+    // 3. Command executed: Set the Run/Event numbers in the TextSelect object.
+    fText_obj->set(runId, eventId); 
+}
 
 }
diff --git a/src/GUI.cc b/src/GUI.cc
index ea8bc46..e7d8ade 100644
--- a/src/GUI.cc
+++ b/src/GUI.cc
@@ -3,18 +3,31 @@
 using namespace mu2e;
 
 
+/**
+ * @brief Writes core event metadata to the JSON structure for the REve browser interface.
+ * * This method overrides the base REveElement method to ensure custom event information 
+ * is included in the state update sent to the client (browser).
+ * * @param j The nlohmann::json object being populated with element properties.
+ * @param rnr_offset The offset used for rendering elements (typically 0).
+ * @return int The status code returned by the base class method (0 on success).
+ */
 int GUI::WriteCoreJson(nlohmann::json &j, int rnr_offset)
 {
-  j["path"] = "Event/SubRun/Run"; 
-  j["eventid"] = feventid;
-  j["subrunid"] = fsubrunid;
-  j["runid"] = frunid;
-  j["UT_PostStream"] = "UT_refresh_event_info";
-  return ROOT::Experimental::REveElement::WriteCoreJson(j, 0);
-}
-void GUI::setEvent(int event){ eventNumber = event; }
-void GUI::setRun(int run){ runNumber = run; }
-void GUI::getRunEvent(){ std::cout<<"GUI SETTTTT"<<runNumber<<" "<<eventNumber<<std::endl;}
+    // Sets the path displayed in the browser's REve status bar or structure view.
+    j["path"] = "Event/SubRun/Run"; 
+
+    // Embed the current event identification numbers into the JSON object.
+    // These members (feventid, fsubrunid, frunid) should be updated by the analyze() thread.
+    j["eventid"] = feventid;
+    j["subrunid"] = fsubrunid;
+    j["runid"] = frunid;
 
+    // This is a REve-specific instruction. It tells the browser client to execute 
+    // the JavaScript function 'UT_refresh_event_info' after processing the stream 
+    // update. This function is likely implemented in your custom HTML/JS (eventDisplay.html) 
+    // to update displayed text fields with the new Run/Event IDs.
+    j["UT_PostStream"] = "UT_refresh_event_info"; 
 
-  
+    // Call the base class method to ensure all standard REve properties are included.
+    return ROOT::Experimental::REveElement::WriteCoreJson(j, 0);
+}
diff --git a/src/GeomUtil.cc b/src/GeomUtil.cc
deleted file mode 100644
index e63928c..0000000
--- a/src/GeomUtil.cc
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "Offline/GeometryService/inc/GeomHandle.hh"
-#include "EventDisplay/inc/GeomUtil.hh"
-
-namespace REX = ROOT::Experimental;
-using namespace std;
-using namespace mu2e;
-
-double GeomUtil::FindStoppingTarget_z(){
-  CLHEP::Hep3Vector _detSysOrigin = mu2e::GeomHandle<mu2e::DetectorSystem>()->getOrigin();
-  GeomHandle<StoppingTarget> target;
-  std::cout<<"Target "<<target->centerInMu2e().z()<<" "<<_detSysOrigin.z()<<std::endl;
-  StoppingTarget_z = target->centerInMu2e().z() - _detSysOrigin.z();
-  return StoppingTarget_z;
-}
diff --git a/src/MCInterface.cc b/src/MCInterface.cc
index 244c2be..6138846 100644
--- a/src/MCInterface.cc
+++ b/src/MCInterface.cc
@@ -1,6 +1,7 @@
 #include "Offline/ConfigTools/inc/SimpleConfig.hh"
 #include "Offline/GeometryService/inc/GeomHandle.hh"
 #include "EventDisplay/inc/MCInterface.hh"
+
 using namespace mu2e;
 namespace REX = ROOT::Experimental;
 
@@ -9,210 +10,272 @@ int MCInterface::Contains(std::vector<int> v, int x)
   return std::count(v.begin(), v.end(), abs(x));
 }
 
-const char* MCInterface::GetParticleName(int PDGCode){
-  const char* pid = "pid";
-  switch(PDGCode) {
-    case PDGCode::e_minus:
-      pid = "electron -";
-      break;
-    case PDGCode::e_plus:
-      pid = "positron +";
-      break;
-    case PDGCode::mu_minus:
-      pid = "muon - ";
-      break;
-    case PDGCode::mu_plus:
-      pid = "muon + ";
-      break;
-    case PDGCode::pi_minus:
-      pid = "pion -";
-      break;
-    case PDGCode::pi_plus:
-      pid = "pion +";
-      break;
-    case PDGCode::pi0:
-      pid = "pion 0";
-      break;
-    case PDGCode::proton:
-      pid = "proton";
-      break;
-    case PDGCode::n0:
-      pid = "neutron";
-      break;
-    case PDGCode::gamma:
-      pid = "gamma";
-      break;
-    default:
-      pid = "other";
-      break;
-  }
-  return pid;
+/*------------Function to look up the particle name from its PDG Code----------*/
+const char* MCInterface::GetParticleName(int PDGCode)
+{
+    // Initialize the pointer to the default (fallback) name.
+    const char* pid = "other";
+    
+    // Check against common PDG codes and update the name.
+    switch(PDGCode) {
+        case PDGCode::e_minus:
+            pid = "electron-";
+            break;
+        case PDGCode::e_plus:
+            pid = "positron+";
+            break;
+        case PDGCode::mu_minus:
+            pid = "muon-";
+            break;
+        case PDGCode::mu_plus:
+            pid = "muon+";
+            break;
+        case PDGCode::pi_minus:
+            pid = "pion-";
+            break;
+        case PDGCode::pi_plus:
+            pid = "pion+";
+            break;
+        case PDGCode::pi0:
+            pid = "pion0";
+            break;
+        case PDGCode::proton:
+            pid = "proton";
+            break;
+        case PDGCode::n0:
+            pid = "neutron";
+            break;
+        case PDGCode::gamma:
+            pid = "gamma";
+            break;
+        // default is handled by the initial 'pid = "other";'
+    }
+    
+    return pid;
 }
 
-void MCInterface::SetLineColorPID(int PDGCode,REX::REveLine *line){
-  Color_t color;
-  switch(PDGCode) {
-    case PDGCode::e_minus:
-      color = kRed;
-      break;
-    case PDGCode::e_plus:
-      color = kGreen;
-      break;
-    case PDGCode::mu_minus:
-      color = kBlack;
-      break;
-    case PDGCode::mu_plus:
-      color = kViolet;
-      break;
-    case PDGCode::pi_minus:
-      color = kMagenta;
-      break;
-    case PDGCode::pi_plus:
-      color = kRed-7;
-      break;
-    case PDGCode::pi0:
-      color = kGreen-7;
-      break;
-    case PDGCode::proton:
-      color = kBlue;
-      break;
-    case PDGCode::n0:
-      color = kViolet-2;
-      break;
-    case PDGCode::gamma:
-      color = kOrange;
-      break;
-    default:
-      color = kCyan-4;
-      break;
-  }
-  line->SetLineColor(color);
+/*------------Function to  set line color based on PDG ID ---------*/
+void MCInterface::SetLineColorPID(int PDGCode, REX::REveLine *line)
+{
+    // Initialize color to the default/catch-all case ("other")
+    Color_t color = kCyan - 4;
+
+    // Assign color based on PDG Code
+    switch(PDGCode) {
+        case PDGCode::e_minus:
+            color = kRed;
+            break;
+        case PDGCode::e_plus:
+            color = kGreen;
+            break;
+        case PDGCode::mu_minus:
+            color = kBlack;
+            break;
+        case PDGCode::mu_plus:
+            color = kViolet;
+            break;
+        case PDGCode::pi_minus:
+            color = kMagenta;
+            break;
+        case PDGCode::pi_plus:
+            color = kRed - 7;
+            break;
+        case PDGCode::pi0:
+            color = kGreen - 7;
+            break;
+        case PDGCode::proton:
+            color = kBlue;
+            break;
+        case PDGCode::n0:
+            color = kViolet - 2;
+            break;
+        case PDGCode::gamma:
+            color = kOrange;
+            break;
+        // default case is handled by the initial assignment: color = kCyan - 4;
+    }
+
+    // Apply the determined color to the line
+    line->SetLineColor(color);
 }
 
 
-void MCInterface::AddMCTrajectoryCollection(REX::REveManager *&eveMng, bool firstloop,  std::tuple<std::vector<std::string>, std::vector<const MCTrajectoryCollection *>> mctrack_tuple, REX::REveElement* &scene, std::vector<int> particleIds, bool extracted){
-  std::cout<<"[ REveMCInterface::AddMCTrajectoryCollection() ]"<<std::endl;
-  std::string drawfilename("EventDisplay/config/drawutils.txt");
-  SimpleConfig drawconfig(drawfilename);
+void MCInterface::AddMCTrajectoryCollection(REX::REveManager *&eveMng, bool firstloop, 
+                                         std::tuple<std::vector<std::string>, 
+                                         std::vector<const MCTrajectoryCollection *>> mctrack_tuple, 
+                                         REX::REveElement* &scene, 
+                                         std::vector<int> particleIds, 
+                                         bool extracted)
+{
+    std::cout << "[MCInterface::AddMCTrajectoryCollection()]" << std::endl;
+
+    std::string drawfilename("EventDisplay/config/drawutils.txt");
+    SimpleConfig drawconfig(drawfilename);
+
+    const auto& track_list = std::get<1>(mctrack_tuple);
 
-  // eEtract the track and input tag:
-  std::vector<const MCTrajectoryCollection*> track_list = std::get<1>(mctrack_tuple);
-  std::vector<std::string> names = std::get<0>(mctrack_tuple);
+    mu2e::GeomHandle<mu2e::DetectorSystem> det;
+    std::set<art::Ptr<mu2e::SimParticle>> drawn_particles;
+    bool particle_type_found = false;
 
-  // Loop over tracks:
-  for(unsigned int j=0; j< track_list.size(); j++){
-    // extract trajectory
-    const MCTrajectoryCollection* trajcol = track_list[j];
+    // Loop over MCTrajectory Collections (J-loop)
+    for(unsigned int j = 0; j < track_list.size(); j++){
+        const mu2e::MCTrajectoryCollection* trajcol = track_list[j];
 
-    if(trajcol!=0){
-      std::map<art::Ptr<mu2e::SimParticle>,mu2e::MCTrajectory>::const_iterator trajectoryIter;
-      bool isSame = false;
-      //create vector of art Ptr to particles:
-      std::vector<art::Ptr<SimParticle> > allParts;
-      for(unsigned int k = 0; k < trajcol->size(); k++){
-        for(trajectoryIter=trajcol->begin(); trajectoryIter!=trajcol->end(); trajectoryIter++)
+        if(trajcol == nullptr) continue;
+        
+        // Loop over Trajectories in the Collection (Map Iteration)
+        // Iterate directly over the map elements (SimParticle Ptr -> MCTrajectory)
+        for(const auto& pair : *trajcol)
         {
-          // Check user defined list of particles to plot
-          int x = Contains(particleIds,trajectoryIter->first->pdgId());
-          // get particle name
-          const char* particlename = GetParticleName(trajectoryIter->first->pdgId());
-          if(x == 1){
-            const std::vector<MCTrajectoryPoint> &points = trajectoryIter->second.points();
-
-            std::string energy = std::to_string(points[0].kineticEnergy());
-            // check for duplicates
-            for(unsigned int ipart = 0; ipart < allParts.size() ; ipart++){
-              MCRelationship checkrel(trajectoryIter->first,allParts.at(ipart));
-              if(checkrel==MCRelationship::same) {
-                  isSame = true;
+            const art::Ptr<mu2e::SimParticle>& sim_particle = pair.first;
+            const mu2e::MCTrajectory& trajectory = pair.second;
+            
+            int pdg_id = sim_particle->pdgId();
+
+            // Check if the SimParticle is in the user-defined list to plot
+            if(Contains(particleIds, pdg_id) == 1){
+                particle_type_found = true;
+                
+                // Duplicate Check
+                if (drawn_particles.count(sim_particle)) {
+                    continue; 
                 }
-            }
-            if(!isSame) { allParts.push_back(trajectoryIter->first); }
-
-            std::string mctitle = " MCTrajectory tag : particle = " + std::string(particlename)  +  '\n'
-              + " energy = " + energy + "MeV" +  '\n'
-              + " creation code = " + std::to_string(trajectoryIter->first->creationCode()) +  '\n'
-              + " stopping code = " + std::to_string(trajectoryIter->first->stoppingCode())  +  '\n'
-              + " end global time = " + std::to_string(trajectoryIter->first->endGlobalTime())
-              + " ns";
-            // create line with the above label
-            auto line = new REX::REveLine(mctitle,mctitle,1);
-            // add points
-            for(unsigned int i=0; i < points.size();i++){
-              CLHEP::Hep3Vector Pos(points[i].x(), points[i].y(), points[i].z());
-              GeomHandle<DetectorSystem> det;
-              CLHEP::Hep3Vector HitPos = det->toDetector(Pos);
-              if(pointmmTocm(HitPos.y()) < 800){ // a reasonable height above the CRV
-                line->SetNextPoint(pointmmTocm((HitPos.x())),pointmmTocm((HitPos.y())),pointmmTocm(HitPos.z()));
-              }
-            }
-            // set line colour
-            SetLineColorPID(trajectoryIter->first->pdgId(),line);
-            line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
-            if(!isSame) scene->AddElement(line);
-          } else std::cout<<"Warning: No Particles of User-Specified Type In File "<<std::endl;
-        }
-      }
+                drawn_particles.insert(sim_particle);
+                
+                const std::vector<mu2e::MCTrajectoryPoint>& points = trajectory.points();
+                if (points.empty()) continue;
+
+                // Create Title String
+                const char* particlename = GetParticleName(pdg_id);
+                std::string energy = std::to_string(points[0].kineticEnergy());
+
+                // Extract and convert Process Codes
+                ProcessCode creationCode = sim_particle->creationCode();
+                ProcessCode stoppingCode = sim_particle->stoppingCode();
+
+                // Get the string names
+                std::string creationName = creationCode.name();
+                std::string stoppingName = stoppingCode.name();
+
+
+                std::string mctitle = "MCTrajectory: " + std::string(particlename) + '\n'
+                    + "Sim ID: " + std::to_string(sim_particle->id().asInt()) + '\n'
+                    + "Parent ID: " + std::to_string(sim_particle->parentId().asInt()) + '\n'
+                    + "Kinetic Energy: " + energy + " MeV" + '\n'
+                    + "Creation Process: " + creationName + " (" + std::to_string(creationCode) + ")" + '\n'
+                    + "Stopping Process: " + stoppingName + " (" + std::to_string(stoppingCode) + ")" + '\n'
+                    + "End Global Time: " + std::to_string(sim_particle->endGlobalTime()) + " ns";
+                // Create and Populate REveLine
+                auto line = new REX::REveLine(mctitle.c_str(), mctitle.c_str(), points.size()); 
+                
+                // Add points to the line
+                for(const auto& point : points){
+                    // Positions are typically in Mu2e coordinates (mm)
+                    CLHEP::Hep3Vector Pos(point.x(), point.y(), point.z());
+                    // Convert to detector coordinates (if needed)
+                    CLHEP::Hep3Vector HitPos = det->toDetector(Pos); 
+                    
+                    // Apply Z-range cut (CRV cut)
+                    if(pointmmTocm(HitPos.y()) < 800.0){ 
+                        line->SetNextPoint(pointmmTocm(HitPos.x()), 
+                                           pointmmTocm(HitPos.y()), 
+                                           pointmmTocm(HitPos.z()));
+                    }
+                }
+                
+                // Styling and Scene Addition
+                if (line->GetSize() > 0) {
+                    SetLineColorPID(pdg_id, line);
+                    line->SetLineWidth(drawconfig.getInt("TrackLineWidth"));
+                    scene->AddElement(line);
+                }
+            } 
+        } // End of map iteration
+    } // End of collection loop
+    
+    if (!particle_type_found && !particleIds.empty()) {
+        std::cout << "Warning: No Particles of User-Specified Type In File." << std::endl;
     }
-  }
 }
 
-void MCInterface::AddSurfaceStepCollection(REX::REveManager *&eveMng, bool firstloop,  std::tuple<std::vector<std::string>, std::vector<const SurfaceStepCollection *>> surfstep_tuple, REX::REveElement* &scene, std::vector<int> particleIds, bool extracted){
-  std::cout<<"[ REveMCInterface::AddSurfaceStepCollection() ]"<<std::endl;
-  std::vector<const SurfaceStepCollection*> ssteps_list = std::get<1>(surfstep_tuple);
-  std::vector<std::string> names = std::get<0>(surfstep_tuple);
-  
-  if(ssteps_list.size() !=0){
-    for(unsigned int i=0; i < ssteps_list.size(); i++){
-      std::string comptitle = "SurfaceStepCollection" + names[i];
-      
-      // make compund object to store hits
-      auto allpoints = new REX::REveCompound(comptitle,comptitle,1);
-      std::string drawfilename("EventDisplay/config/drawutils.txt");
-      SimpleConfig drawconfig(drawfilename);
+void MCInterface::AddSurfaceStepCollection(REX::REveManager *&eveMng, bool firstloop,
+                                         std::tuple<std::vector<std::string>, 
+                                         std::vector<const SurfaceStepCollection *>> surfstep_tuple, 
+                                         REX::REveElement* &scene, 
+                                         std::vector<int> particleIds, 
+                                         bool extracted)
+{
+    std::cout << "[MCInterface::AddSurfaceStepCollection() ]" << std::endl;
+    
+    // Extract the list of SurfaceStep collections and their associated names/tags from the tuple.
+    const std::vector<const mu2e::SurfaceStepCollection*>& ssteps_list = std::get<1>(surfstep_tuple);
+    const std::vector<std::string>& names = std::get<0>(surfstep_tuple);
+    
+    // Load drawing configuration (assuming this is used for marker size/style).
+    std::string drawfilename("EventDisplay/config/drawutils.txt");
+    mu2e::SimpleConfig drawconfig(drawfilename);
 
-      // eXtract the track and input tag:
-      std::vector<const SurfaceStepCollection*> surfstep_list = std::get<1>(surfstep_tuple);
-      std::vector<std::string> names = std::get<0>(surfstep_tuple);
-
-      // Loop over surface steps
-      for(unsigned int j=0; j< surfstep_list.size(); j++){
-        const SurfaceStepCollection* surfstepcol = surfstep_list[j];
-        if(surfstepcol!=0){
-          for( auto const& surfstep : *surfstepcol) {
-            // Check user defined list of particles to plot
+    // --- Main Loop: Iterate over all SurfaceStep collections ---
+    for(unsigned int j = 0; j < ssteps_list.size(); j++){
+        const mu2e::SurfaceStepCollection* surfstepcol = ssteps_list[j];
+        
+        if(surfstepcol == nullptr) continue; // Skip if collection pointer is null
+
+        // Make a compound object to store all SurfaceStep hits from this collection, 
+        // ensuring they are grouped logically in the REve display tree.
+        std::string comptitle = "SurfaceStepCollection: " + names[j];
+        auto allpoints = new REX::REveCompound(comptitle.c_str(), comptitle.c_str(), 1);
+
+        // Inner Loop: Iterate over individual SurfaceStep objects
+        for(const auto& surfstep : *surfstepcol) {
+            
+            // Get the PDG ID of the SimParticle associated with this step.
             auto pdgid = surfstep.simParticle()->pdgId();
-            int x = Contains(particleIds,pdgid);
+            
+            // Check if the SimParticle's PDG ID is in the user-defined list to plot.
+            int plot_this_particle = Contains(particleIds, pdgid);
+            
+            // Get the midpoint position of the step (in Mu2e coordinates, mm).
             auto midpos = surfstep.midPosition();
-            if(x == 1){
-              // Make label
-              std::string momentum = std::to_string(surfstep.momentum().R());
-              std::string edep = std::to_string(surfstep.energyDeposit());
-              std::string mctitle = " SurfaceStep on " +  surfstep.surfaceId().name() + '\n'
-                + " x "  + std::to_string(midpos.X())
-                + " y " + std::to_string(midpos.Y())
-                + " z " + std::to_string(midpos.Z())
-                + " time :" + std::to_string(surfstep.time())+  '\n'
-                + " momentum " + momentum + " MeV/c, energy loss = " + edep + "MeV";
-              // add point
-              auto surfpoint = new REX::REvePointSet(mctitle,mctitle,1);
-              surfpoint->SetMarkerStyle(MCInterface::mstyle);
-              surfpoint->SetMarkerSize(MCInterface::msize);
-              surfpoint->SetMarkerColor(kBlack);
-              surfpoint->SetNextPoint(pointmmTocm(midpos.X()),pointmmTocm(midpos.Y()) ,pointmmTocm(midpos.Z()));
-              //scene->AddElement(surfpoint);
-              allpoints->AddElement(surfpoint);
+            
+            if(plot_this_particle == 1){
+                // Make a descriptive label for the mouseover tooltip.
+                std::string momentum = std::to_string(surfstep.momentum().R());
+                std::string edep = std::to_string(surfstep.energyDeposit());
+                
+                std::string mctitle = "SurfaceStep on " + surfstep.surfaceId().name() + '\n'
+                    + " x " + std::to_string(midpos.X()) + '\n'
+                    + " y " + std::to_string(midpos.Y()) + '\n'
+                    + " z " + std::to_string(midpos.Z()) + '\n'
+                    + " time: " + std::to_string(surfstep.time()) + '\n'
+                    + " momentum " + momentum + " MeV/c, energy loss = " + edep + " MeV";
+                
+                // Create the REve marker point for this step.
+                auto surfpoint = new REX::REvePointSet(mctitle.c_str(), mctitle.c_str(), 1);
+                
+                // Configure marker appearance.
+                surfpoint->SetMarkerStyle(MCInterface::mstyle);
+                surfpoint->SetMarkerSize(MCInterface::msize);
+                surfpoint->SetMarkerColor(kBlack);
+                
+                // Set the point position, converting coordinates from mm to cm.
+                surfpoint->SetNextPoint(pointmmTocm(midpos.X()), 
+                                        pointmmTocm(midpos.Y()), 
+                                        pointmmTocm(midpos.Z()));
+                
+                // Add the individual point to the compound group.
+                allpoints->AddElement(surfpoint);
             }
-          }
-        }
-      }
-      scene->AddElement(allpoints);
-    }
-  }
+        } // End of inner loop (individual SurfaceSteps)
+
+        // Only add the compound group to the scene if it contains any plotted points.
+        scene->AddElement(allpoints);
+    } // End of main loop (SurfaceStep collections)
 }
 
 void MCInterface::AddSimParticleCollection(REX::REveManager *&eveMng, bool firstloop,  std::tuple<std::vector<std::string>, std::vector<const SimParticleCollection *>> sim_tuple, REX::REveElement* &scene, std::vector<int> particleIds, bool extracted){
-  std::cout<<"[ REveMCInterface::AddSimParticleCollection() ]"<<std::endl;
+  std::cout<<"[MCInterface::AddSimParticleCollection() ]"<<std::endl;
   std::vector<const SimParticleCollection*> sim_list = std::get<1>(sim_tuple);
   std::vector<std::string> names = std::get<0>(sim_tuple);
 
@@ -251,6 +314,7 @@ void MCInterface::AddSimParticleCollection(REX::REveManager *&eveMng, bool first
               CLHEP::Hep3Vector StartPos = det->toDetector(simpart.startPosition());
               CLHEP::Hep3Vector EndPos = det->toDetector(simpart.endPosition());
               double momentum = sqrt(simpart.startMomentum().x()*simpart.startMomentum().x()+simpart.startMomentum().y()*simpart.startMomentum().y() + simpart.startMomentum().z()*simpart.startMomentum().z());
+              double endmomentum = sqrt(simpart.endMomentum().x()*simpart.endMomentum().x()+simpart.endMomentum().y()*simpart.endMomentum().y() + simpart.endMomentum().z()*simpart.endMomentum().z());
               std::string mctitle_start = " SimParticle PDGid " + std::to_string(simpart.pdgId()) + '\n'
                 + " Creation code " + (startCode) + " Stopping code " + (stopCode) + '\n'
                 + " Start Position: " + '\n'
@@ -263,11 +327,10 @@ void MCInterface::AddSimParticleCollection(REX::REveManager *&eveMng, bool first
                 + " x "  + std::to_string( EndPos.x())
                 + " y " + std::to_string( EndPos.y())
                 + " z " + std::to_string( EndPos.z())
-                + " time :" + std::to_string(simpart.endGlobalTime()  );
+                + " time :" + std::to_string(simpart.endGlobalTime()  )+ '\n'
+                + " End Momentum " + std::to_string(endmomentum) + " End Energy " + std::to_string(simpart.endMomentum().e()) ;
 
-              // add point
               
-              // add point
               //auto simpoint_start = new REX::REvePointSet(mctitle_start,mctitle_start,1);
               // create line with the above label
               auto simpart_line = new REX::REveLine(mctitle_start,mctitle_start,1);
diff --git a/src/MainWindow.cc b/src/MainWindow.cc
index 3baf2f0..e4d920e 100644
--- a/src/MainWindow.cc
+++ b/src/MainWindow.cc
@@ -29,7 +29,7 @@ void MainWindow::makeEveGeoShape(TGeoNode* n, REX::REveTrans& trans, REX::REveEl
   b1s->SetShape(gss);
 
   int transpar = drawconfigf.getInt("BLtrans");
-  if(name.find("CRS") != string::npos) transpar = drawconfigf.getInt("CRVtrans");
+  if(name.find("CRS") != string::npos) transpar = drawconfigf.getInt("Crvtrans");
   if(name.find("Tracker") != string::npos) transpar = drawconfigf.getInt("TRKtrans") ;
   if(name.find("CaloDisk") != string::npos) transpar = drawconfigf.getInt("CALtrans") ;
   if(name.find("CaloWrapper") != string::npos ) transpar = drawconfigf.getInt("CRYtrans") ;
@@ -52,9 +52,9 @@ void MainWindow::makeEveGeoShape(TGeoNode* n, REX::REveTrans& trans, REX::REveEl
     mngTrackerXY->ImportElements(b1s, TrackerXYGeomScene); //shows only one plane for 2D view for simplicity
   }
 
-  bool isCRV = name.find("CRS") != string::npos;
-  // remove CRV from the YZ view as it blocks tracker/calo view (will have its own view)
-  if(!isCRV) { mngRhoZ->ImportElements(b1s, rhoZGeomScene); }
+  bool isCrv = name.find("CRS") != string::npos;
+  // remove Crv from the YZ view as it blocks tracker/calo view (will have its own view)
+  if(!isCrv) { mngRhoZ->ImportElements(b1s, rhoZGeomScene); }
 }
 
 int j = 0;
@@ -67,6 +67,7 @@ void MainWindow::showNodesByName(TGeoNode* n, const std::string& str, bool onOff
   }
   std::string name(n->GetName());
   j++;
+  //std::cout<<j<<" "<<name<<std::endl;
   //if(print) std::cout<<j<<" "<<name<<std::endl;
   bool cry1 = false; // these help us know which disk and to draw crystals
   bool cry2 = false;
@@ -103,7 +104,7 @@ void MainWindow::showNodesByName(TGeoNode* n, const std::string& str, bool onOff
         t(2,1) = rm[3]; t(2,2) = rm[4]; t(2,3) = rm[5];
         t(3,1) = rm[6]; t(3,2) = rm[7]; t(3,3) = rm[8];
         t(1,4) = tv[0] + shift[0]; t(2,4) = tv[1]  + shift[1]; t(3,4) = tv[2] + shift[2];
-       // std::cout<<name<<"  "<<tv[0] + shift[0]<<" "<<tv[1]  + shift[1] << " "<< tv[2] + shift[2]<<std::endl;
+        //std::cout<<name<<"  "<<tv[0] + shift[0]<<" "<<tv[1]  + shift[1] << " "<< tv[2] + shift[2]<<std::endl;
 
         if(name.find("TrackerPlaneEnvelope_00") != string::npos) {
           FrontTracker_gdmltag = j;
@@ -147,7 +148,7 @@ void MainWindow::getOffsets(TGeoNode* n,const std::string& str, REX::REveTrans&
   t(1,4) = tv[0]  ; t(2,4) = tv[1]  ; t(3,4) = tv[2] ;
 
   ctrans *= t;
- // std::cout<<j<<" "<<name<<" located at "<<tv[0]<<" "<< tv[1]<<" "<<tv[2]<<std::endl;
+  //std::cout<<j<<" "<<name<<" located at "<<tv[0]<<" "<< tv[1]<<" "<<tv[2]<<std::endl;
   std::vector<float> pos;
   std::pair<std::string, std::vector<float>> offset;
   pos.push_back(tv[0]);
@@ -399,8 +400,10 @@ void MainWindow::GeomDrawerNominal(TGeoNode* node, REX::REveTrans& trans, REX::R
     double z_hall = 0;double z_world = 0;
     double x_crv = 0 ; double y_crv = 0 ; double z_crv = 0; // double z_crv_u = 0;  double z_crv_d = 0;
     x_trk = 0;y_trk = 0;z_trk = 0;
-
+    double x_fp0 = 0; double y_fp0 = 0; double z_fp0 = 0;
+    double x_fp1 = 0; double y_fp1 = 0; double z_fp1 = 0;
     for(unsigned int i = 0; i < offsets.size(); i++){
+      
       if(offsets[i].first.find("World") != string::npos){
         x_world = offsets[i].second[0];
         y_world = offsets[i].second[1];
@@ -455,6 +458,16 @@ void MainWindow::GeomDrawerNominal(TGeoNode* node, REX::REveTrans& trans, REX::R
         y_ipa = y_st + offsets[i].second[1];
         z_ipa = z_st + offsets[i].second[2];
       }
+       if(offsets[i].first.find("CaloFP") != string::npos){
+        x_fp0 = x_d0+ offsets[i].second[0];
+        y_fp0 = y_d0 + offsets[i].second[1];
+        z_fp0 = z_d0 + offsets[i].second[2];
+      }
+      if(offsets[i].first.find("CaloFP") != string::npos){
+        x_fp1 = x_d1 + offsets[i].second[0];
+        y_fp1 = y_d1 + offsets[i].second[1];
+        z_fp1 = z_d1 + offsets[i].second[2];
+      }
     }
     std::vector<double> shift;
 
@@ -471,7 +484,7 @@ void MainWindow::GeomDrawerNominal(TGeoNode* node, REX::REveTrans& trans, REX::R
         showNodesByName(node,i,kFALSE, 0, trans, trackerholder, maxlevel, level, false, false, shift, false, true, drawconfigf.getInt("TRKColor"));
       }
     }
-    // everything else needs to be shifted such that its relative to the tracker center at 0,0,0
+    
     if(geomOpt.showST and !geomOpt.extracted){
       static std::vector <std::string> substrings_stoppingtarget  {"TargetFoil"};
       shift.at(0) = x_st - x_trk;
@@ -498,6 +511,24 @@ void MainWindow::GeomDrawerNominal(TGeoNode* node, REX::REveTrans& trans, REX::R
           showNodesByName(node,i,kFALSE, 0, trans, crystalsholder, maxlevel, level, true, true, shift, true, false, drawconfigf.getInt("CALColor"));
         }
       }
+      bool showPipes = false;
+      if(showPipes){
+        static std::vector <std::string> substrings_pipes1  {"CaloFP_pipe","CaloFP_pipe1","CaloFP_pipe2","CaloFP_pipe3","CaloFP_pipe4","CaloFP_pipe5"};
+          for(auto& i: substrings_pipes1){
+            shift.at(0) = x_fp1 - x_trk;
+            shift.at(1) = y_fp1 - y_trk;
+            shift.at(2) = z_fp1 - z_trk;
+            showNodesByName(node,i,kFALSE, 0, trans, crystalsholder, maxlevel, level, false,false, shift, true, false, drawconfigf.getInt("CALColor"));
+            
+          }
+          static std::vector <std::string> substrings_pipes0  {"CaloFP_pipe","CaloFP_pipe1","CaloFP_pipe2","CaloFP_pipe3","CaloFP_pipe4","CaloFP_pipe5"};
+          for(auto& i: substrings_pipes0){
+            shift.at(0) = x_fp0 - x_trk; 
+            shift.at(1) = y_fp0 - y_trk;
+            shift.at(2) = z_fp0 - z_trk - 20/2; //crystal len/2
+            showNodesByName(node,i,kFALSE, 0, trans, crystalsholder, maxlevel, level, true, true, shift, false, true, drawconfigf.getInt("CALColor"));
+          }
+      }
     }
     if(geomOpt.showST and !geomOpt.extracted){
       static std::vector <std::string> substrings_pa  {"protonabs1","protonabs3","protonabs4"};
@@ -508,13 +539,13 @@ void MainWindow::GeomDrawerNominal(TGeoNode* node, REX::REveTrans& trans, REX::R
         showNodesByName(node,i,kFALSE, 0, trans, beamlineholder, maxlevel, level, false, false, shift, false, true, drawconfigf.getInt("BLColor"));
       }
   }
-  if(geomOpt.showCRV and !geomOpt.extracted){
+  if(geomOpt.showCrv and !geomOpt.extracted){
     static std::vector <std::string> substrings_crv {"CRSmother_CRV"};
     shift.at(0) = x_crv;
     shift.at(1) = y_crv;
     shift.at(2) = z_crv - z_trk;
     for(auto& i: substrings_crv){
-      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, false, drawconfigf.getInt("CRVColor"));
+      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, false, drawconfigf.getInt("CrvColor"));
     }
   }
 }
@@ -615,7 +646,7 @@ void MainWindow::GeomDrawerExtracted(TGeoNode* node, REX::REveTrans& trans, REX:
         }
       }
     }
-  if(geomOpt.showCRV and geomOpt.extracted){
+  if(geomOpt.showCrv and geomOpt.extracted){
 
     static std::vector <std::string> substrings_ex {"CRSmotherLayer_CRV_EX"};
     shift.at(0) = x_crvex - x_trk;
@@ -623,7 +654,7 @@ void MainWindow::GeomDrawerExtracted(TGeoNode* node, REX::REveTrans& trans, REX:
     shift.at(2) = z_crvex - z_trk;
 
     for(auto& i: substrings_ex){
-      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, true, drawconfigf.getInt("CRVColor"));
+      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, true, drawconfigf.getInt("CrvColor"));
     }
 
     static std::vector <std::string> substrings_t1  {"CRSmotherLayer_CRV_T1"};
@@ -632,7 +663,7 @@ void MainWindow::GeomDrawerExtracted(TGeoNode* node, REX::REveTrans& trans, REX:
     shift.at(2) = z_crvt1 - z_trk;
 
     for(auto& i: substrings_t1){
-      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, true, drawconfigf.getInt("CRVColor"));
+      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, true, drawconfigf.getInt("CrvColor"));
     }
 
     static std::vector <std::string> substrings_t2  {"CRSmotherLayer_CRV_T2"};
@@ -641,7 +672,7 @@ void MainWindow::GeomDrawerExtracted(TGeoNode* node, REX::REveTrans& trans, REX:
     shift.at(2) = z_crvt2 - z_trk;
 
     for(auto& i: substrings_t2){
-      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, true, drawconfigf.getInt("CRVColor"));
+      showNodesByName(node,i,kFALSE, 0, trans, crvholder, maxlevel, level,  false, false, shift, false, true, drawconfigf.getInt("CrvColor"));
     }
   }
 }
@@ -722,26 +753,24 @@ void MainWindow::showEvents(REX::REveManager *eveMng, REX::REveElement* &eventSc
   double t2 = 1696.;
   std::vector<const KalSeedPtrCollection*> track_list = std::get<1>(data.track_tuple);
   if(drawOpts.addTracks and track_list.size() !=0) {
-    pass_data->FillKinKalTrajectory(eveMng, firstLoop, eventScene, data.track_tuple, KKOpts.addKalInter,  KKOpts.addTrkStrawHits, t1, t2); 
+    pass_data->FillKinKalTrajectory(eveMng, firstLoop, eventScene, data.track_tuple, KKOpts.addKalInter,  KKOpts.addTrkStrawHits, KKOpts.addTrkCaloHits, t1, t2); 
   }
   if(drawOpts.addComboHits) {
     std::vector<const ComboHitCollection*> combohit_list = std::get<1>(data.combohit_tuple);
     if(combohit_list.size() !=0 ) pass_data->AddComboHits(eveMng, firstLoop, data.combohit_tuple, eventScene, strawdisplay, drawOpts.addTrkErrBar);
   }
-
   if(drawOpts.addBkgClusters) {
     std::vector<const BkgClusterCollection*> bkgcluster_list = std::get<1>(data.bkgcluster_tuple);
     if(bkgcluster_list.size() !=0 ) pass_data->AddBkgClusters(eveMng, firstLoop, data.bkgcluster_tuple, eventScene);
   }
-
-  if(drawOpts.addCRVInfo){
+  if(drawOpts.addCrvRecoPulse){
     std::vector<const CrvRecoPulseCollection*> crvpulse_list = std::get<1>(data.crvpulse_tuple);
-    if(crvpulse_list.size() !=0) pass_data->AddCRVInfo(eveMng, firstLoop, data.crvpulse_tuple, eventScene, geomOpts.extracted, drawOpts.addCRVBars);
+    if(crvpulse_list.size() !=0) pass_data->AddCrvInfo(eveMng, firstLoop, data.crvpulse_tuple, eventScene, geomOpts.extracted, drawOpts.addCrvBars);
   }
 
-  if(drawOpts.addCRVClusters){
+  if(drawOpts.addCrvClusters){
     std::vector<const CrvCoincidenceClusterCollection*> crvcoin_list = std::get<1>(data.crvcoin_tuple);
-    if(crvcoin_list.size() !=0) pass_data->AddCRVClusters(eveMng, firstLoop, data.crvcoin_tuple, eventScene, geomOpts.extracted, drawOpts.addCRVBars);
+    if(crvcoin_list.size() !=0) pass_data->AddCrvClusters(eveMng, firstLoop, data.crvcoin_tuple, eventScene, geomOpts.extracted, drawOpts.addCrvBars);
   }
 
   if(drawOpts.addCaloDigis){
@@ -751,7 +780,7 @@ void MainWindow::showEvents(REX::REveManager *eveMng, REX::REveElement* &eventSc
 
   if(drawOpts.addClusters){
     std::vector<const CaloClusterCollection*> calocluster_list = std::get<1>(data.calocluster_tuple);
-    if(calocluster_list.size() !=0 ) pass_data->AddCaloClusters(eveMng, firstLoopCalo, data.calocluster_tuple, eventScene, drawOpts.addCrystalDraw, t1, t2);
+    if(calocluster_list.size() !=0 ) pass_data->AddCaloClusters(eveMng, firstLoopCalo, data.calocluster_tuple, eventScene, drawOpts.addCrystalDraw);
   }
 
   std::vector<const HelixSeedCollection*> helix_list = std::get<1>(data.helix_tuple);
@@ -803,7 +832,7 @@ void MainWindow::makeGeometryScene(REX::REveManager *eveMng, GeomOptions geomOpt
     auto trackerholder = new REX::REveElement("Tracker");
     auto caloholder = new REX::REveElement("Calorimeter");
     auto crystalsholder = new REX::REveElement("CalorimeterCrystals");
-    auto crvholder = new REX::REveElement("CRV");
+    auto crvholder = new REX::REveElement("Crv");
     auto targetholder = new REX::REveElement("TargetElements");
     auto beamlineholder = new REX::REveElement("DSBeamlineElements");
     auto solenoidholder = new REX::REveElement("SolenoidElements");
diff --git a/src/Mu2eEventDisplay_module.cc b/src/Mu2eEventDisplay_module.cc
index 8ecbde6..431c32f 100644
--- a/src/Mu2eEventDisplay_module.cc
+++ b/src/Mu2eEventDisplay_module.cc
@@ -107,7 +107,7 @@ namespace mu2e
           using Name=fhicl::Name;
           using Comment=fhicl::Comment;
           fhicl::Atom<int> diagLevel{Name("diagLevel"), Comment("for info"),0};
-          fhicl::Atom<bool> showCRV{Name("showCRV"), Comment("set false if you just want to see DS"),false};
+          fhicl::Atom<bool> showCrv{Name("showCrv"), Comment("set false if you just want to see DS"),false};
           fhicl::Atom<bool> showPS{Name("showPS"), Comment("set false if you just want to see inside DS"),false};
           fhicl::Atom<bool> showTS{Name("showTS"), Comment("set false if you just want to see inside DS"),false};
           fhicl::Atom<bool> showDS{Name("showDS"), Comment("set false if you just want to see inside DS"),false};
@@ -120,7 +120,7 @@ namespace mu2e
           fhicl::Atom<bool> showCaloCrystals{Name("showCaloCrystals"), Comment(""),true};
           fhicl::Atom<bool> addErrBar{Name("addErrBar"), Comment("show combo hit err bar"),true};
           fhicl::Atom<bool> addCrystalHits{Name("addCrystalHits"), Comment("show crystal hits if presrnt"),true};
-          fhicl::Atom<bool> addCRVBars{Name("addCRVBars"), Comment("show crv bars hit if presrnt"),true};
+          fhicl::Atom<bool> addCrvBars{Name("addCrvBars"), Comment("show crv bars hit if presrnt"),true};
           fhicl::Atom<bool> addKalInter{Name("addKalInter"), Comment("show Kal intersections"),true};
           fhicl::Atom<bool> addTrkStrawHits{Name("addTrkStrawHits"), Comment("show Kal trk straw hits"),true};
           fhicl::Atom<bool> addTrkCaloHits{Name("addTrkCaloHits"), Comment("show Kal trk cal ohits"),true};
@@ -160,15 +160,13 @@ namespace mu2e
 
         // Display control
         art::EventID displayedEventID_{};
-        REX::REveManager* eveMng_{nullptr};
-        EventDisplayManager* eventMgr_{nullptr};
-
+        
         // Control between the main thread and event-display thread
         std::condition_variable cv_{};
         std::mutex m_{};
 
         int  diagLevel_;
-        bool showCRV_;
+        bool showCrv_;
         bool showPS_;
         bool showTS_;
         bool showDS_;
@@ -181,7 +179,7 @@ namespace mu2e
         bool showCaloCrystals_;
         bool addErrBar_;
         bool addCrystalHits_;
-        bool addCRVBars_;
+        bool addCrvBars_;
         bool addKalInter_;
         bool addTrkStrawHits_;
         bool addTrkCaloHits_;
@@ -200,9 +198,12 @@ namespace mu2e
         bool showEM_;
 
         // Setup Custom GUI
-        GUI *fGui{nullptr};
-        PrintInfo *fPrint{nullptr};
-        TextSelect *fText{nullptr};
+        
+        std::unique_ptr<GUI> fGui{nullptr};
+        std::unique_ptr<TextSelect> fText{nullptr};
+        std::unique_ptr<PrintInfo> fPrint{nullptr};
+        REX::REveManager* eveMng_{nullptr};
+        std::unique_ptr<EventDisplayManager> eventMgr_{nullptr};
         double eventid_;
         double runid_;
         double subrunid_;
@@ -210,7 +211,7 @@ namespace mu2e
         int eventn;
         int runn;
         int subrunn;
-
+        int autoplay = 0;
         std::vector<std::shared_ptr<DataProduct>> listoflists;
         GeomOptions geomOpts;
         ConfigFileLookupPolicy configFile;
@@ -220,7 +221,7 @@ namespace mu2e
   Mu2eEventDisplay::Mu2eEventDisplay(const Parameters& conf)  :
     art::EDAnalyzer(conf),
     diagLevel_(conf().diagLevel()),
-    showCRV_(conf().showCRV()),
+    showCrv_(conf().showCrv()),
     showPS_(conf().showPS()),
     showTS_(conf().showTS()),
     showDS_(conf().showDS()),
@@ -233,7 +234,7 @@ namespace mu2e
     showCaloCrystals_(conf().showCaloCrystals()),
     addErrBar_(conf().addErrBar()),
     addCrystalHits_(conf().addCrystalHits()),
-    addCRVBars_(conf().addCRVBars()),
+    addCrvBars_(conf().addCrvBars()),
     addKalInter_(conf().addKalInter()),
     addTrkStrawHits_(conf().addTrkStrawHits()),
     addTrkCaloHits_(conf().addTrkCaloHits()),
@@ -246,17 +247,7 @@ namespace mu2e
     showEM_(conf().showEM()),
     seqMode_(conf().seqMode())
     {
-      std::cout<<"GDML file "<<gdmlname_<<std::endl;
-       if(!seqMode_){
-        // Take in Run, Event number
-          std::cout<<" Event Number : "<<std::endl;
-          cin>>eventn;
-          std::cout<<" SubRun Number : "<<std::endl;
-          cin>>subrunn;
-          std::cout<<" Run Number : "<<std::endl;
-          cin>>runn;
-      }
-      geomOpts.fill(showCRV_,showPS_, showTS_, showDS_, show2D_, caloVST_, showST_, extracted_, showSTM_, showCalo_, showTracker_, showCaloCrystals_, showEM_ );
+      geomOpts.fill(showCrv_,showPS_, showTS_, showDS_, show2D_, caloVST_, showST_, extracted_, showSTM_, showCalo_, showTracker_, showCaloCrystals_, showEM_ );
     }
 
   Mu2eEventDisplay::~Mu2eEventDisplay() {}
@@ -269,40 +260,32 @@ namespace mu2e
 
   void Mu2eEventDisplay::beginJob(){
       if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- starting ..."<<std::endl;
-      {
-            
-      std::unique_lock lock{m_};
-
-      appThread_ = std::thread{[this] { run_application(); }};
-
-      // Wait for app init to finish ... this will process pending timer events.
-      XThreadTimer sut([this]{ signalAppStart(); });
-      if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- starting wait on app start"<<std::endl;
-      cv_.wait(lock);
-      if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- app start signal received, starting eve init"<<std::endl;
-      //auto start1 = std::chrono::high_resolution_clock::now();
-
-      XThreadTimer suet([this]{ setup_eve(); });
-      //auto end1 = std::chrono::high_resolution_clock::now();
-      //std::cout<<" time through process setup evene"<<std::chrono::duration<double, std::milli>(end1 - start1).count()<<" ms "<<std::endl;
-      if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- starting wait on eve setup"<<std::endl;
-      cv_.wait(lock);
-      if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- eve setup apparently complete"<<std::endl;
+      {      
+        std::unique_lock lock{m_};
+        appThread_ = std::thread{[this] { run_application(); }};
+        // Wait for app init to finish ... this will process pending timer events.
+        XThreadTimer sut([this]{ signalAppStart(); });
+        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- starting wait on app start"<<std::endl;
+        cv_.wait(lock);
+        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- app start signal received, starting eve init"<<std::endl;
+        XThreadTimer suet([this]{ setup_eve(); });
+        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- starting wait on eve setup"<<std::endl;
+        cv_.wait(lock);
+        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : beginJob()] -- eve setup apparently complete"<<std::endl;
       }
   }
 
 
-  void Mu2eEventDisplay::beginRun(const art::Run&){
-
-  }
+  void Mu2eEventDisplay::beginRun(const art::Run&){}
 
   void Mu2eEventDisplay::printOpts(){
+    // Option to print out input options
     std::cout<<"*********** REve Mu2e **************"
     <<" User Options: "
     <<" addHits : "<< filler_.addHits_
     <<" addBkgClusters : "<<filler_.addBkgClusters_
     <<" addTimeClusters : "<<filler_.addTimeClusters_
-    <<" addCrvHits : "<<filler_.addCrvHits_
+    <<" addCrvRecoPulse : "<<filler_.addCrvRecoPulse_
     <<" addCrvClusters : "<<filler_.addCrvClusters_
     <<" addClusters : "<<filler_.addClusters_
     <<" addHelices : "<<filler_.addHelixSeeds_
@@ -311,231 +294,423 @@ namespace mu2e
   }
 
 
-  template <class T, class S> void Mu2eEventDisplay::FillAnyCollection(const art::Event& evt, std::vector<std::shared_ptr<DataProduct>>& list, std::tuple<std::vector<std::string>, std::vector<S>>& tuple){
-      // get all instances of products of type T
-      std::vector<art::Handle<T>> vah = evt.getMany<T>();
-      std::string name;
-      std::vector<std::string> alabel;
-      std::vector<S> alist;
-      // loop over the list of instances of products of this type
-      for (auto const& ah : vah) {
+template <class T, class S> 
+void Mu2eEventDisplay::FillAnyCollection(const art::Event& evt, std::vector<std::shared_ptr<DataProduct>>& list, std::tuple<std::vector<std::string>, std::vector<S>>& tuple){
+    
+    // Use Art's getMany() to retrieve a vector of all art::Handle<T> objects 
+    // that exist in the event record for the type T.
+    // 
+    std::vector<art::Handle<T>> vah = evt.getMany<T>();
+    
+    // Temporary variables to store the labels and the product pointers/handles.
+    std::string name;
+    std::vector<std::string> alabel; // Stores fully qualified names (label_instance_process)
+    std::vector<S> alist;  // Stores the actual product pointers (const T*)
+    
+    // Loop over the list of art::Handle<T> retrieved from the event.
+    for (auto const& ah : vah) {
+        // Get the Provenance (metadata) for the product associated with this handle.
+        // Provenance tells you which module created the data.
         const art::Provenance* prov = ah.provenance();
 
+        // --- Extract Provenance Information ---
+        
+        // Friendly Class Name (e.g., "CaloClusterCollection")
         std::string fcn = prov->friendlyClassName();
+        // Module Label (the name of the Art module that created it)
         std::string modn = prov->moduleLabel();
+        // Process Name (the Art process name, used for configuration context)
         std::string instn = prov->processName();
-        alist.push_back(ah.product());
+        
+        // Get the raw product pointer/handle and push it onto the list.
+        // The type S is typically const T* or a similar type that references the product.
+        alist.push_back(ah.product()); 
+        
+        // Create a unique, descriptive name string for this collection instance.
         std::string name = fcn + "_" + prov->moduleLabel() + "_" + instn;
+        
+        // Store the name so it can be displayed in the GUI alongside the collection.
         alabel.push_back(name);
+        
         if(diagLevel_ == 1){
-          std::cout<<"extracting name =  "<<fcn<<" "<<modn<<" "<<instn<<std::endl;
-          std::cout<<"with type =  "<<typeid(prov).name()<<std::endl;
+            std::cout<<"extracting name =  "<<fcn<<" "<<modn<<" "<<instn<<std::endl;
+            // Diagnostic printout of the provenance object type ID (for debugging)
+            std::cout<<"with type =  "<<typeid(prov).name()<<std::endl;
         }
-      }
-      tuple = std::make_tuple(alabel,alist);
-
+    }
+    
+    // Assign the list of labels and the list of products to the output tuple.
+    // This tuple is then used to populate the display structure.
+    tuple = std::make_tuple(alabel,alist);
     }
 
   void Mu2eEventDisplay::analyze(art::Event const& event){
 
-      //auto start = std::chrono::high_resolution_clock::now();
-
-      //remove previous event objects;
+      // Clear all previously stored event objects in the display data structure. 
+      // This prepares the structure for the new event's data.
       data.Reset();
-      // Update state relevant for displaying new event.
+
+      // Update the internal state variables based on the current event object ('event').
       displayedEventID_ = event.id();
       eventid_ = event.id().event();
       runid_ = event.run();
       subrunid_ = event.subRun();
 
+      // Temporary vector used during the collection filling process (often required by FillAnyCollection).
       std::vector<std::shared_ptr<DataProduct>> _chits;
 
-      if((seqMode_) or ( runid_ == runn and subrunid_ == subrunn and eventid_ == eventn)){
-        // Hand off control to display thread
-        std::unique_lock lock{m_};
-        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- Fill collections "<<std::endl;
-        //auto start1 = std::chrono::high_resolution_clock::now();
-        // fill the collection lists
-        if(filler_.addClusters_) {
-          if(specifyTag_) filler_.FillRecoCollections(event, data, CaloClusters);
-          else { FillAnyCollection<CaloClusterCollection, const CaloClusterCollection*>(event, _chits, data.calocluster_tuple);}
-        }
-        if(filler_.addCaloDigis_) {
-          if(specifyTag_) filler_.FillRecoCollections(event, data, CaloDigis);
-          else { FillAnyCollection<CaloDigiCollection, const CaloDigiCollection*>(event, _chits, data.calodigi_tuple);}
-        }
-
-        if(filler_.addHits_) {
-          if(specifyTag_) { filler_.FillRecoCollections(event, data, ComboHits); }
-          else { FillAnyCollection<ComboHitCollection, const ComboHitCollection*>(event, _chits, data.combohit_tuple ); }
-        }
-
-        if(filler_.addBkgClusters_) {
-          if(specifyTag_) { filler_.FillRecoCollections(event, data, BkgClusters); }
-          else { FillAnyCollection<BkgClusterCollection, const BkgClusterCollection*>(event, _chits, data.bkgcluster_tuple ); }
-        }
-
-        if(filler_.addHelixSeeds_){
-            if(specifyTag_) { filler_.FillRecoCollections(event, data, HelixSeeds); }
-            else { FillAnyCollection<HelixSeedCollection, const HelixSeedCollection*>(event, _chits, data.helix_tuple ); }
-        }
-
-        if(filler_.addKalSeeds_) {
-          if(specifyTag_) { filler_.FillRecoCollections(event, data, KalSeeds); }
-          else { FillAnyCollection<KalSeedPtrCollection, const KalSeedPtrCollection*>(event, _chits, data.track_tuple ); }
-        }
-
-        if(filler_.addMCTraj_) {
-          if(specifyTag_) { filler_.FillMCCollections(event, data, MCTrajectories); }
-          else { FillAnyCollection<MCTrajectoryCollection, const MCTrajectoryCollection*>(event, _chits, data.mctrack_tuple ); }
-        }
-
-        if(filler_.addSurfSteps_) {
-          if(specifyTag_) { filler_.FillMCCollections(event, data, SurfaceSteps); }
-          else { FillAnyCollection<SurfaceStepCollection, const SurfaceStepCollection*>(event, _chits, data.surfstep_tuple ); }
-        }
-        if(filler_.addSimParts_) {
-          if(specifyTag_) { filler_.FillMCCollections(event, data, SimParticles); }
-          else { FillAnyCollection<SimParticleCollection, const SimParticleCollection*>(event, _chits, data.sim_tuple ); }
-        }
-
-        if(filler_.addTimeClusters_) {
-          if(specifyTag_) { filler_.FillRecoCollections(event, data, TimeClusters);}
-          else { FillAnyCollection<TimeClusterCollection, const TimeClusterCollection*>(event, _chits, data.timecluster_tuple );}
-        }
-
-        if(filler_.addCrvHits_) {
-          if(specifyTag_) { filler_.FillRecoCollections(event, data, CrvRecoPulses); }
-          else { FillAnyCollection<CrvRecoPulseCollection, const CrvRecoPulseCollection*>(event, _chits, data.crvpulse_tuple );}
-        }
-
-        if(filler_.addCrvClusters_) {
-          if(specifyTag_) { filler_.FillRecoCollections(event, data, CrvCoincidenceCluster); }
-          else { FillAnyCollection<CrvCoincidenceClusterCollection, const CrvCoincidenceClusterCollection*>(event, _chits, data.crvcoin_tuple );}
-        }
-
-        if(filler_.addTrkHits_) filler_.FillRecoCollections(event, data, TrkHits);
-        if(filler_.addCosmicTrackSeeds_)  filler_.FillRecoCollections(event, data, CosmicTrackSeeds);
-        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- Event processing started "<<std::endl;
-        XThreadTimer proc_timer([this]{ process_single_event(); });
-
-        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- transferring to TApplication thread "<<std::endl;
-        cv_.wait(lock);
-        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- TApplication thread returning control "<<std::endl;
-        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] Ended Event "<<std::endl;
-        seqMode_ = true;
+      // User Input Handling (REve Command Interface) ---
+      // The fText pointer (TextSelect object) holds the Run/Event numbers entered by the user
+      // via the REve GUI command box.
+      
+      if (fText) {
+          // Retrieve the user-specified Run/Event numbers from the TextSelect object.
+          std::pair<int, int> user_input = fText->getRunEvent();
+          int user_run = user_input.first;
+          int user_event = user_input.second;
+          autoplay = fText->getAutoplay();
+          std::cout << "\n[Mu2eEventDisplay::analyze] -------------------------" << std::endl;
+          std::cout << "[Mu2eEventDisplay::analyze] User Input Detected:" << std::endl;
+          std::cout << "[Mu2eEventDisplay::analyze] Run Number:  " << user_run << std::endl;
+          std::cout << "[Mu2eEventDisplay::analyze] Event Number: " << user_event << std::endl;
+          std::cout << "[Mu2eEventDisplay::analyze] Autoplay set " << autoplay << std::endl;
+          std::cout << "[Mu2eEventDisplay::analyze] -------------------------\n" << std::endl;
+          
+          // Check if valid input was provided (Run and Event are non-zero).
+          if(user_run !=0 and user_event != 0){
+              // Store the user-requested event number internally.
+              runn = user_run;
+              eventn = user_event;
+              // Disable sequential processing mode. The module must stop after this event is found.
+              seqMode_ = false;
+          }
+      }
 
-        std::cout<<"test VALUE "<<eventMgr_->run<<std::endl;
+      // Event Filtering Logic ---
+      // Process the event ONLY IF:
+      // 1. We are in sequential mode (seqMode_ is true, meaning iterate through all events), OR
+      // 2. The current event matches the user-requested event (runn, eventn).
+      if((seqMode_) or ( runid_ == runn and subrunid_ == subrunid_ and eventid_ == eventn)){
+          
+          // Acquire a lock on the mutex. This ensures the Art thread (analyze) waits 
+          // for the REve thread (GUI) to finish processing the display before proceeding 
+          // to the next event or releasing the lock.
+          std::unique_lock lock{m_};
+          
+          if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- Fill collections "<<std::endl;
+          
+          // Filling Data Collections ---
+          // The following blocks conditionally load various data collections (CaloClusters, ComboHits, MCTrajectories, etc.)
+          // based on user configuration flags (filler_.add...).
+          // FillRecoCollections and FillAnyCollection are helper methods that retrieve data products
+          // from the event record and store them in the internal data structure for display.
+          
+          if(filler_.addClusters_) {
+              // If specifyTag_ is true, use the dedicated filler method (likely based on Art module tag).
+              if(specifyTag_) filler_.FillRecoCollections(event, data, CaloClusters);
+              // Otherwise, use the generic collection filler (likely based on type).
+              else { FillAnyCollection<CaloClusterCollection, const CaloClusterCollection*>(event, _chits, data.calocluster_tuple);}
+          }
+          
+          if(filler_.addCaloDigis_) {
+              if(specifyTag_) filler_.FillRecoCollections(event, data, CaloDigis);
+              else { FillAnyCollection<CaloDigiCollection, const CaloDigiCollection*>(event, _chits, data.calodigi_tuple);}
+          }
+
+          if(filler_.addHits_) {
+              if(specifyTag_) { filler_.FillRecoCollections(event, data, ComboHits); }
+              else { FillAnyCollection<ComboHitCollection, const ComboHitCollection*>(event, _chits, data.combohit_tuple ); }
+          }
+          if(filler_.addBkgClusters_) {
+              if(specifyTag_) { filler_.FillRecoCollections(event, data, BkgClusters); }
+            else { FillAnyCollection<BkgClusterCollection, const BkgClusterCollection*>(event, _chits, data.bkgcluster_tuple ); }
+          }
+          if(filler_.addHelixSeeds_){
+              if(specifyTag_) { filler_.FillRecoCollections(event, data, HelixSeeds); }
+              else { FillAnyCollection<HelixSeedCollection, const HelixSeedCollection*>(event, _chits, data.helix_tuple ); }
+          }
+
+          if(filler_.addKalSeeds_) {
+              if(specifyTag_) { filler_.FillRecoCollections(event, data, KalSeeds); }
+              else { FillAnyCollection<KalSeedPtrCollection, const KalSeedPtrCollection*>(event, _chits, data.track_tuple ); }
+          }
+
+          // --- MC Collections (Monte Carlo) ---
+          if(filler_.addMCTraj_) {
+              if(specifyTag_) { filler_.FillMCCollections(event, data, MCTrajectories); }
+              else { FillAnyCollection<MCTrajectoryCollection, const MCTrajectoryCollection*>(event, _chits, data.mctrack_tuple ); }
+          }
+
+          if(filler_.addSurfSteps_) {
+              if(specifyTag_) { filler_.FillMCCollections(event, data, SurfaceSteps); }
+              else { FillAnyCollection<SurfaceStepCollection, const SurfaceStepCollection*>(event, _chits, data.surfstep_tuple ); }
+          }
+          if(filler_.addSimParts_) {
+              if(specifyTag_) { filler_.FillMCCollections(event, data, SimParticles); }
+              else { FillAnyCollection<SimParticleCollection, const SimParticleCollection*>(event, _chits, data.sim_tuple ); }
+          }
+          // --- End MC Collections ---
+
+          if(filler_.addTimeClusters_) {
+              if(specifyTag_) { filler_.FillRecoCollections(event, data, TimeClusters);}
+              else { FillAnyCollection<TimeClusterCollection, const TimeClusterCollection*>(event, _chits, data.timecluster_tuple );}
+          }
+
+          if(filler_.addCrvRecoPulse_) {
+              if(specifyTag_) { filler_.FillRecoCollections(event, data, CrvRecoPulses); }
+              else { FillAnyCollection<CrvRecoPulseCollection, const CrvRecoPulseCollection*>(event, _chits, data.crvpulse_tuple );}
+          }
+
+          if(filler_.addCrvClusters_) {
+              if(specifyTag_) { filler_.FillRecoCollections(event, data, CrvCoincidenceCluster); }
+              else { FillAnyCollection<CrvCoincidenceClusterCollection, const CrvCoincidenceClusterCollection*>(event, _chits, data.crvcoin_tuple );}
+          }
+
+          if(filler_.addTrkHits_) filler_.FillRecoCollections(event, data, TrkHits);
+          if(filler_.addCosmicTrackSeeds_)  filler_.FillRecoCollections(event, data, CosmicTrackSeeds);
+
+          if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- Event processing started "<<std::endl;
+
+          // Thread Synchronization
+          // Start the single-event processing job (updating the REve display) in the REve/ROOT thread.
+          // The XThreadTimer ensures the display update happens outside the current Art/analysis thread.
+          XThreadTimer proc_timer([this]{ process_single_event(); }); 
+
+          if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- transferring to TApplication thread "<<std::endl;
+          
+          if (autoplay > 0) {
+              // Autoplay is ON (Autoplay value is the delay in seconds)
+              std::cout << "Auto play switched on.... waiting 10 s for REve display." << std::endl;
+              
+              auto timeout = std::chrono::seconds(10);
+              cv_.wait_for(lock, timeout); 
+
+              lock.unlock();
+              
+          } else {
+              cv_.wait(lock);
+          }
+          
+          // Reset these to return to sequential navigation
+          seqMode_ = true;
+          runn = 0;
+          eventn = 0;
+          
+
+          if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] -- TApplication thread returning control "<<std::endl;
+          if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : analyze()] Ended Event "<<std::endl;
+          
       }
+      
   }
 
     void Mu2eEventDisplay::endJob()
     {
-      if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : EndJob] Start "<<std::endl;
-      application_.Terminate(0);
-
-      if (appThread_.joinable()) {
-        appThread_.join();
-      }
-      if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : EndJob] End "<<std::endl;
+        // Check if the diagnostic level is set to print informational messages.
+        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : EndJob] Start "<<std::endl;
+        
+        // --- 1. Terminate the ROOT Application ---
+        // Terminate the TApplication instance. This is the main event loop 
+        // running in the separate thread (appThread_). 
+        // The argument '0' typically signals a normal shutdown.
+        application_.Terminate(0);
+
+        // --- 2. Join the Application Thread ---
+        // Check if the thread (where the TApplication/REve display is running) 
+        // is currently running and hasn't been joined yet.
+        if (appThread_.joinable()) {
+            // Wait for the application thread to finish its work and exit cleanly.
+            // This is crucial for proper thread synchronization and preventing 
+            // the main program from exiting before the thread resources are released.
+            // 
+            appThread_.join();
+        }
+        
+        // Final cleanup message.
+        if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : EndJob] End "<<std::endl;
     }
 
 
-
-  // Functions invoked by the threads explicitly created by this module
   void Mu2eEventDisplay::run_application()
   {
       // Without this the startup timer might not get invoked.
-      gSystem->ProcessEvents();
+      // Explicitly process any waiting system events (like timer ticks or thread signals) 
+      // that were queued before the TApplication event loop officially started. 
+      // This ensures initialization tasks (like setting up the REve browser/GUI) are executed promptly.
+      gSystem->ProcessEvents(); 
+
+      // Start the TApplication event loop. 
+      // The argument 'true' typically means that the function should return only when 
+      // the application is explicitly terminated (e.g., via application_.Terminate(0) in endJob()).
+      // This line blocks the appThread_ until the user closes the display or the Art job finishes.
+      // 
       application_.Run(true);
   }
 
 
   void Mu2eEventDisplay::setup_eve()
   {
-      RWebWindowsManager::AssignMainThrd();
-      eveMng_ = REX::REveManager::Create();
-      eveMng_->AllowMultipleRemoteConnections(false, false);
-      ROOT::RWebWindowsManager::SetUseSessionKey(false);
-      //InitGuiInfo()
-      fGui = new GUI();
-      fGui->SetName("Mu2eGUI");
-
-      fPrint = new PrintInfo();
-      fText = new TextSelect();
-
-      // call manager
-      eventMgr_ = new EventDisplayManager{eveMng_, cv_, m_, fGui, fText};
-
-      // access the world
-      auto world = eveMng_->GetWorld();
-
-      assert(world);
-
-      frame_ = new MainWindow();
-      frame_->makeGeometryScene(eveMng_, geomOpts, gdmlname_);
-
-      //add path to the custom GUI code here, this overrides ROOT GUI
-      eveMng_->AddLocation("mydir/", configFile("EventDisplay/CustomGUIv2"));
-      eveMng_->SetDefaultHtmlPage("file:mydir/eventDisplay.html");
-
-      // InitGuiInfo() cont'd
-      world->AddElement(fGui);
-      world->AddElement(fText);
-      world->AddElement(eventMgr_);
-      world->AddElement(fPrint);
-      std::cout<<"[Mu2eEventDisplay::setup_eve] run in display is set to "<<eventMgr_->run<<std::endl;
-
-      world->AddCommand("QuitRoot",  "sap-icon://log",  eventMgr_, "QuitRoot()");
-      world->AddCommand("NextEvent", "sap-icon://step", eventMgr_, "NextEvent()");
-      world->AddCommand("PrintMCInfo", "sap-icon://step", fPrint, "PrintMCInfo()");
-      world->AddCommand("PrintRecoInfo", "sap-icon://step", fPrint, "PrintRecoInfo()");
-      std::unique_lock lock{m_};
-      cv_.notify_all();
-
-  }
+    // Assign the current thread as the main thread for RWebWindowsManager. 
+    // This is critical for thread-safety and ensuring the display correctly manages events.
+    RWebWindowsManager::AssignMainThrd(); 
+
+    // Create the single instance of the REveManager. This is the core object 
+    // that manages all display elements, scenes, and remote connections.
+    eveMng_ = REX::REveManager::Create(); 
+
+    // Configure REve to disallow multiple simultaneous browser connections.
+    // The second 'false' is typically related to connection handling details.
+    eveMng_->AllowMultipleRemoteConnections(false, false); 
+
+    // Set the global WebWindowsManager to not use session keys for connections, 
+    // simplifying access to the display.
+    ROOT::RWebWindowsManager::SetUseSessionKey(false); 
+
+    // --- Object Creation (Using std::unique_ptr for robust lifetime management) ---
+
+    // Create the custom GUI object.
+    fGui = std::make_unique<GUI>(); 
+    fGui->SetName("Mu2eGUI");
+
+    // Create the PrintInfo object for displaying data details.
+    fPrint = std::make_unique<PrintInfo>(); 
+
+    // Create the TextSelect object, used to capture user-input Run/Event numbers.
+    fText = std::make_unique<TextSelect>(); 
+
+    // --- Event Manager Instantiation and Singleton Link ---
+
+    // Instantiate the core EventDisplayManager. It takes raw pointers to:
+    // 1. The REveManager (eveMng_)
+    // 2. The synchronization primitives (cv_, m_)
+    // 3. The custom GUI object (fGui.get())
+    eventMgr_ = std::make_unique<EventDisplayManager>(
+        eveMng_, 
+        cv_, 
+        m_, 
+        fGui.get()
+    );
+
+    // --- Scene Setup ---
+
+    // Get the top-level scene, the "World," which is the container for all elements.
+    auto world = eveMng_->GetWorld(); 
+    assert(world); // Ensure the world was successfully retrieved.
+
+    // Instantiate the custom MainWindow (likely handles the GDML geometry).
+    frame_ = new MainWindow(); 
+    // Load the geometry into the main window scene.
+    frame_->makeGeometryScene(eveMng_, geomOpts, gdmlname_); 
+
+    // --- Custom GUI and HTML Page Setup ---
+
+    // Add a location path for custom files (like JavaScript or CSS).
+    eveMng_->AddLocation("mydir/", configFile("EventDisplay/CustomGUIv2")); 
+    // Set the default HTML page that the web browser will load.
+    eveMng_->SetDefaultHtmlPage("file:mydir/eventDisplay.html"); 
+
+    // --- Add Elements to the World (Element ID Assignment occurs here) ---
+
+    // Elements must be added to a scene/world before their Element ID is assigned and valid.
+    world->AddElement(fText.get());     
+    world->AddElement(eventMgr_.get()); 
+    world->AddElement(fPrint.get());    
+    world->AddElement(fGui.get());     
+
+    // --- Final Linking and Command Registration ---
+
+    eventMgr_->setTextSelectId(fText->GetElementId()); 
+
+    // Register commands that the GUI buttons will execute. The command is routed to the 
+    // method on the specified element (eventMgr_.get() or fPrint.get()).
+    world->AddCommand("QuitRoot", "sap-icon://log", eventMgr_.get(), "QuitRoot()");
+    world->AddCommand("NextEvent", "sap-icon://step", eventMgr_.get(), "NextEvent()");
+    world->AddCommand("PrintMCInfo", "sap-icon://step", fPrint.get(), "PrintMCInfo()");
+    world->AddCommand("PrintRecoInfo", "sap-icon://step", fPrint.get(), "PrintRecoInfo()");
+    eventMgr_->setid(fText->GetElementId() );
+    // --- Signal Art Thread to Proceed ---
+
+    // Acquire a lock on the mutex.
+    std::unique_lock lock{m_}; 
+    // Signal the waiting Art thread (in analyze() or beginRun()) to continue processing 
+    // now that the REve display is fully initialized.
+    cv_.notify_all();
+    //std::cout << "[DEBUG] TextSelect object ID assigned: " << fText->GetElementId() << std::endl; 
+}
+  
+  
 
   // Actually interesting function responsible for drawing the current event
   void Mu2eEventDisplay::process_single_event()
-    {
+  {
+      
       if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : process_single_event] Start "<<std::endl;
-      eveMng_->DisableRedraw();
-      eveMng_->GetWorld()->BeginAcceptingChanges();
-      eveMng_->GetScenes()->AcceptChanges(true);
-
+      
+      // --- 1. Disable Redrawing and Start Change Tracking ---
+      
+      // Temporarily disable the browser redraw to prevent the display from updating 
+      // multiple times during the process, leading to flickering and slow performance.
+      eveMng_->DisableRedraw(); 
+      
+      // Tell the World Scene to start tracking changes. All element additions/modifications 
+      // are batched until EndAcceptingChanges() is called.
+      eveMng_->GetWorld()->BeginAcceptingChanges(); 
+      
+      // Tell all scenes managed by the REveManager to start accepting batched changes.
+      eveMng_->GetScenes()->AcceptChanges(true); 
+
+      // --- 2. Update GUI and PrintInfo Data Structures ---
+
+      // Transfer the core event identifiers to the GUI object for display.
       fGui->feventid = eventid_;
       fGui->fsubrunid = subrunid_;
       fGui->frunid = runid_;
 
+      // Transfer the relevant collection data to the PrintInfo object. 
+      // This allows the PrintInfo command to access and display details when triggered.
       fPrint->fcalocluster_tuple = data.calocluster_tuple;
       fPrint->fmctrack_tuple = data.mctrack_tuple;
       fPrint->ftrack_tuple = data.track_tuple;
 
-      std::cout<<"[Mu2eEventDisplay::process_single_event] display has run number set to "<<eventMgr_->run<<std::endl;
-      std::cout<<"[Mu2eEventDisplay::process_single_event] value in the text class "<<fText->get()<<std::endl;
-
-      fGui->StampObjProps();
+      // Update the custom properties displayed in the REve GUI (e.g., in a sidebar table).
+      fGui->StampObjProps(); 
 
+      // --- 3. Prepare the Scene and Data Options ---
+      
       if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : process_single_event] -- extract event scene "<<std::endl;
-      REX::REveElement* scene = eveMng_->GetEventScene();
+      // Get the dedicated scene for event data (where tracks, hits, etc., will be drawn).
+      REX::REveElement* scene = eveMng_->GetEventScene(); 
 
       if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : process_single_event] -- calls to data interface "<<std::endl;
 
-      // fill draw options
-      DrawOptions drawOpts(filler_.addCosmicTrackSeeds_, filler_.addHelixSeeds_, filler_.addKalSeeds_, filler_.addCaloDigis_, filler_.addClusters_, filler_.addHits_,  filler_.addBkgClusters_, filler_.addCrvHits_, filler_.addCrvClusters_, filler_.addTimeClusters_, filler_.addTrkHits_, filler_.addMCTraj_, filler_.addSurfSteps_, filler_.addSimParts_, addErrBar_, addCrystalHits_, addCRVBars_);
+      // Create a structure defining which data products should be drawn (based on module configuration).
+      DrawOptions drawOpts(filler_.addCosmicTrackSeeds_, filler_.addHelixSeeds_, filler_.addKalSeeds_, filler_.addCaloDigis_, filler_.addClusters_, filler_.addHits_, filler_.addBkgClusters_, filler_.addCrvRecoPulse_, filler_.addCrvClusters_, filler_.addTimeClusters_, filler_.addTrkHits_, filler_.addMCTraj_, filler_.addSurfSteps_, filler_.addSimParts_, addErrBar_, addCrystalHits_, addCrvBars_);
 
-      // fill kinkal options
+      // Create a structure defining visualization options specific to Kinematic/Kalman fitting results.
       KinKalOptions KKOpts(addKalInter_, addTrkStrawHits_, addTrkCaloHits_);
 
-      // call the "show events" function to add the
+      // --- 4. Draw the Event ---
+
+      // Call the core function responsible for converting data collections into REve elements (lines, points, clusters) 
+      // and adding them to the event scene.
       frame_->showEvents(eveMng_, scene, firstLoop_, firstLoopCalo_, data, drawOpts, particles_, strawdisplay_, geomOpts, KKOpts);
 
       if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : process_single_event] -- cluster added to scene "<<std::endl;
 
-      firstLoop_ = false;
-      eveMng_->GetScenes()->AcceptChanges(false);
-      eveMng_->GetWorld()->EndAcceptingChanges();
-      eveMng_->EnableRedraw();
+      // --- 5. Finalize Changes and Enable Redraw ---
+
+      // Set the flag to false, indicating subsequent events are not the "first loop" (allowing optimization).
+      firstLoop_ = false; 
+      
+      // Stop tracking changes in all scenes.
+      eveMng_->GetScenes()->AcceptChanges(false); 
+      
+      // Finalize the batch of changes for the World scene. This triggers the update signal.
+      eveMng_->GetWorld()->EndAcceptingChanges(); 
+      
+      // Re-enable the browser redraw. The browser now performs a single, optimized refresh 
+      // using all the batched changes.
+      eveMng_->EnableRedraw(); 
 
       if(diagLevel_ == 1) std::cout<<"[Mu2eEventDisplay : process_single_event] End "<<std::endl;
     }
diff --git a/src/PrintInfo.cc b/src/PrintInfo.cc
index a8f1db6..bdef046 100644
--- a/src/PrintInfo.cc
+++ b/src/PrintInfo.cc
@@ -4,189 +4,389 @@
 
 using namespace mu2e;
 
+
+/**
+ * @brief Prints summary information for Monte Carlo (MC) event data.
+ * * This function is typically invoked by the "PrintMCInfo" REve command button.
+ * It currently delegates to the PrintSimInfo method.
+ */
 void PrintInfo::PrintMCInfo(){
-  PrintSimInfo();
+    PrintMCTrajInfo();
+    PrintSimPartInfo();
 }
 
+/**
+ * @brief Prints summary information for all Reconstructed (Reco) event data.
+ * * This function is typically invoked by the "PrintRecoInfo" REve command button.
+ * It aggregates printing from tracking, calorimetry, and CRV components.
+ */
 void PrintInfo::PrintRecoInfo(){
-  PrintKalInfo();
-  PrintCaloInfo();
-  PrintCRVInfo();
+    PrintKalInfo();
+    PrintCaloInfo();
+    PrintCRVInfo();
 }
 
+void PrintInfo::PrintMCTrajInfo(){
+
+    std::vector<const MCTrajectoryCollection*> track_list = std::get<1>(fmctrack_tuple);
+    
+    if(track_list.size() > 0){
+        
+        // Set up stream for consistent formatting across all printouts
+        std::cout << std::fixed << std::setprecision(3);
+        
+        // Loop over all available MCTrajectory collections (different Art module outputs).
+        for(unsigned int j=0; j< track_list.size(); j++){
+            const MCTrajectoryCollection* trajcol = track_list[j];
+            
+            if(trajcol !=0){
+                
+                std::map<art::Ptr<mu2e::SimParticle>,mu2e::MCTrajectory>::const_iterator trajectoryIter;
+                
+                std::cout << "\n======================================================================================================================================================" << std::endl;
+                std::cout << "MC TRAJ (Primary) SIM PARTICLE INFORMATION: Collection " << j + 1 << std::endl;
+                std::cout << "Number of SimParticles = " << trajcol->size() << std::endl;
+                std::cout << "======================================================================================================================================================" << std::endl;
+
+                // --- Table Header ---
+                // Using setw() for fixed column width and right/left alignment
+                std::cout << std::left << std::setw(6) << "ID"
+                          << std::setw(10) << "PDGID"
+                          << std::setw(9) << "ENERGY"
+                          << std::setw(12) << "p0x" 
+                          << std::setw(12) << "p0y" 
+                          << std::setw(12) << "p0z" 
+                          << std::setw(12) << "posx"
+                          << std::setw(12) << "posy"
+                          << std::setw(12) << "posz"
+                          << std::setw(10) << "t0"
+                          << std::setw(12) << "p1x" 
+                          << std::setw(12) << "p1y" 
+                          << std::setw(12) << "p1z" 
+                          << std::setw(10) << "t1"
+                          << std::endl;
+                std::cout << "------------------------------------------------------------------------------------------------------------------------------------------------------" << std::endl;
+
+
+                // 3. Iterate over the SimParticle Ptrs and their associated MCTrajectories.
+                for(trajectoryIter=trajcol->begin(); trajectoryIter!=trajcol->end(); trajectoryIter++){
+                    
+                    // Access the SimParticle object
+                    const mu2e::SimParticle* simPtr = trajectoryIter->first.get();
+                    
+                    // --- Initial (Start) Kinematics ---
+                    int pdgID = simPtr->pdgId();
+                    double energy = simPtr->startMomentum().e();
+                    double t0 = simPtr->startGlobalTime();
+                    
+                    CLHEP::Hep3Vector p0 = simPtr->startMomentum().vect();
+                    CLHEP::Hep3Vector pos0 = simPtr->startPosition();
+                    
+                    // --- Final (End) Kinematics ---
+                    double t1 = simPtr->endGlobalTime();
+                    CLHEP::Hep3Vector p1 = simPtr->endMomentum().vect();
+                    
+                    // Extract the unique SimParticle ID.
+                    int id = simPtr->id().asInt();
 
-void PrintInfo::PrintSimInfo(){
-
-  std::vector<const MCTrajectoryCollection*> track_list = std::get<1>(fmctrack_tuple);
-  if(track_list.size() > 0){
-    for(unsigned int j=0; j< track_list.size(); j++){
-      const MCTrajectoryCollection* trajcol = track_list[j];
-      if(trajcol !=0){
-        std::map<art::Ptr<mu2e::SimParticle>,mu2e::MCTrajectory>::const_iterator trajectoryIter;
-        std::cout<<"MC TRAJ (Primary) SIM PARTICLE INFORMATION"<<std::endl;
-        std::cout<<"Number of SimParticles = "<<trajcol->size()<<std::endl;
-        std::cout<<"  "<<std::endl;
-        std::cout<<" ID  "<<"   PDGID   "<<" Energy    "<<"    p0x     "<<"     p0y      "<<"       p0z    "
-          <<"      posx    "<<"     posy      "<<"    posz    "<<"  t0      "<<"     p1x   "<<"    p1y   "<<"   p1z    "<<"    t1"<<std::endl;
-        for(trajectoryIter=trajcol->begin(); trajectoryIter!=trajcol->end(); trajectoryIter++){
-          std::string pdgID = std::to_string(trajectoryIter->first->pdgId());
-          std::string t0 = std::to_string(trajectoryIter->first->startGlobalTime());
-          std::string p0x = std::to_string(trajectoryIter->first->startMomentum().x());
-          std::string p0y = std::to_string(trajectoryIter->first->startMomentum().y());
-          std::string p0z = std::to_string(trajectoryIter->first->startMomentum().z());
-          std::string energy = std::to_string(trajectoryIter->first->startMomentum().e());
-          std::string posx = std::to_string(trajectoryIter->first->startPosition().x()); //FIXME - this is in Mu2e coords
-          std::string posy = std::to_string(trajectoryIter->first->startPosition().y());
-          std::string posz = std::to_string(trajectoryIter->first->startPosition().z());
-          std::string t1 = std::to_string(trajectoryIter->first->endGlobalTime());
-          std::string p1x = std::to_string(trajectoryIter->first->endMomentum().x());
-          std::string p1y = std::to_string(trajectoryIter->first->endMomentum().y());
-          std::string p1z = std::to_string(trajectoryIter->first->endMomentum().z());
-          std::string pos1x = std::to_string(trajectoryIter->first->endPosition().x());
-          std::string pos1y = std::to_string(trajectoryIter->first->endPosition().y());
-          std::string pos1z = std::to_string(trajectoryIter->first->endPosition().z());
-          std::string id = std::to_string(trajectoryIter->first->id().asInt());
-
-          std::cout<<" "<<id<<"      "<<pdgID<<"     "<<energy<<"    "<<p0x<<"     "<<p0y<<"     "<<p0z
-            <<"  "<<posx<<"  "<<posy<<"   "<<posz<<"  "<<t0<<"   "<<p1x<<"  "<<p1y<<"  "<<p1z<<"   "<<t1<<std::endl;
+                    // --- Print Data Row (using stream manipulators) ---
+                    std::cout << std::left << std::setw(6) << id
+                              << std::setw(10) << pdgID
+                              << std::right << std::setw(9) << energy
+                              << std::setw(12) << p0.x() 
+                              << std::setw(12) << p0.y() 
+                              << std::setw(12) << p0.z() 
+                              << std::setw(12) << pos0.x()
+                              << std::setw(12) << pos0.y()
+                              << std::setw(12) << pos0.z()
+                              << std::setw(10) << t0
+                              << std::setw(12) << p1.x() 
+                              << std::setw(12) << p1.y() 
+                              << std::setw(12) << p1.z() 
+                              << std::setw(10) << t1
+                              << std::endl;
+                }
+                std::cout << "======================================================================================================================================================" << std::endl;
+            }
         }
-      }
     }
-  }
+    // Restore default stream formatting (optional but good practice)
+    std::cout << std::scientific << std::setprecision(6);
+}
 
-  std::vector<const SimParticleCollection*> sim_list = std::get<1>(fsim_tuple);
+void PrintInfo::PrintSimPartInfo(){
+    std::vector<const SimParticleCollection*> sim_list = std::get<1>(fsim_tuple);
+    std::vector<const MCTrajectoryCollection*> track_list = std::get<1>(fmctrack_tuple);
     if(track_list.size() > 0){
-      for(unsigned int j=0; j< sim_list.size(); j++){
-        const SimParticleCollection* simcol = sim_list[j];
-        if(simcol !=0){
-          
-          std::cout<<"SIM PARTICLE INFORMATION"<<std::endl;
-          std::cout<<"Number of SimParticles = "<<simcol->size()<<std::endl;
-          std::cout<<"  "<<std::endl;
-          std::cout<<" ID  "<<"   PDGID   "<<" Energy    "<<"    p0x     "<<"     p0y      "<<"       p0z    "
-            <<"      posx    "<<"     posy      "<<"    posz    "<<"  t0      "<<"     p1x   "<<"    p1y   "<<"   p1z    "<<"    t1"<<std::endl;
-          const SimParticleCollection* simcol = sim_list[j];
-
-          if(simcol!=0){
-            for( auto const& simpair : *simcol) {
-              // Check user defined list of particles to plot
-              const mu2e::SimParticle& simpart = simpair.second;
-              std::string pdgID = std::to_string(simpart.pdgId());
-              std::string t0 = std::to_string(simpart.startGlobalTime() );
-              std::string p0x = std::to_string(simpart.startMomentum().x());
-              std::string p0y = std::to_string(simpart.startMomentum().y());
-              std::string p0z = std::to_string(simpart.startMomentum().z());
-              std::string energy = std::to_string(simpart.startMomentum().e());
-              std::string posx = std::to_string(simpart.startPosition().x()); //FIXME - this is in Mu2e coords
-              std::string posy = std::to_string(simpart.startPosition().y());
-              std::string posz = std::to_string(simpart.startPosition().z());
-              std::string t1 = std::to_string(simpart.endGlobalTime());
-              std::string p1x = std::to_string(simpart.endMomentum().x());
-              std::string p1y = std::to_string(simpart.endMomentum().y());
-              std::string p1z = std::to_string(simpart.endMomentum().z());
-              std::string pos1x = std::to_string(simpart.endPosition().x());
-              std::string pos1y = std::to_string(simpart.endPosition().y());
-              std::string pos1z = std::to_string(simpart.endPosition().z());
-              std::string id = std::to_string(simpart.id().asInt());
-
-              std::cout<<" "<<id<<"      "<<pdgID<<"     "<<energy<<"    "<<p0x<<"     "<<p0y<<"     "<<p0z
-              <<"  "<<posx<<"  "<<posy<<"   "<<posz<<"  "<<t0<<"   "<<p1x<<"  "<<p1y<<"  "<<p1z<<"   "<<t1<<std::endl;
-          }
+        
+        // Set up stream for consistent formatting across all printouts
+        std::cout << std::fixed << std::setprecision(3);
+        
+        // Loop over all available SimParticle collections.
+        for(unsigned int j=0; j< sim_list.size(); j++){
+            const SimParticleCollection* simcol = sim_list[j];
+            
+            // Safety check: ensure the pointer to the collection is valid.
+            if(simcol !=0){
+                
+                std::cout << "\n======================================================================================================================================================" << std::endl;
+                std::cout << "SIM PARTICLE INFORMATION (Collection " << j + 1 << ")" << std::endl;
+                std::cout << "Number of SimParticles = " << simcol->size() << std::endl;
+                std::cout << "======================================================================================================================================================" << std::endl;
+
+                // --- Table Header ---
+                std::cout << std::left << std::setw(6) << "ID"
+                          << std::setw(10) << "PDGID"
+                          << std::setw(9) << "ENERGY"
+                          << std::setw(12) << "p0x" 
+                          << std::setw(12) << "p0y" 
+                          << std::setw(12) << "p0z" 
+                          << std::setw(12) << "posx"
+                          << std::setw(12) << "posy"
+                          << std::setw(12) << "posz"
+                          << std::setw(10) << "t0"
+                          << std::setw(12) << "p1x" 
+                          << std::setw(12) << "p1y" 
+                          << std::setw(12) << "p1z" 
+                          << std::setw(10) << "t1"
+                          << std::endl;
+                std::cout << "------------------------------------------------------------------------------------------------------------------------------------------------------" << std::endl;
+
+
+                // Iterate over the SimParticleCollection (map<SimParticle::key_type, SimParticle>).
+                for( auto const& simpair : *simcol) {
+                    const mu2e::SimParticle& simpart = simpair.second;
+                    
+                    // --- Extract Initial (Start) Kinematics ---
+                    int pdgID = simpart.pdgId();
+                    double energy = simpart.startMomentum().e();
+                    double t0 = simpart.startGlobalTime();
+                    
+                    CLHEP::Hep3Vector p0 = simpart.startMomentum().vect();
+                    CLHEP::Hep3Vector pos0 = simpart.startPosition();
+                    
+                    // --- Extract Final (End) Kinematics ---
+                    double t1 = simpart.endGlobalTime();
+                    CLHEP::Hep3Vector p1 = simpart.endMomentum().vect();
+                    
+                    // Extract the unique SimParticle ID.
+                    int id = simpart.id().asInt();
+
+                    // --- Print Data Row (using stream manipulators) ---
+                    std::cout << std::left << std::setw(6) << id
+                              << std::setw(10) << pdgID
+                              << std::right << std::setw(9) << energy
+                              << std::setw(12) << p0.x() 
+                              << std::setw(12) << p0.y() 
+                              << std::setw(12) << p0.z() 
+                              << std::setw(12) << pos0.x()
+                              << std::setw(12) << pos0.y()
+                              << std::setw(12) << pos0.z()
+                              << std::setw(10) << t0
+                              << std::setw(12) << p1.x() 
+                              << std::setw(12) << p1.y() 
+                              << std::setw(12) << p1.z() 
+                              << std::setw(10) << t1
+                              << std::endl;
+                }
+                std::cout << "======================================================================================================================================================" << std::endl;
+            }
         }
-      }
     }
-  }
+    // Restore default stream formatting
+    std::cout << std::scientific << std::setprecision(6);
 }
 
-void  PrintInfo::PrintKalInfo(){
-  auto const& ptable = GlobalConstantsHandle<ParticleDataList>();
-  std::vector<const KalSeedPtrCollection*> ktrack_list = std::get<1>(ftrack_tuple);
-  std::vector<std::string> names = std::get<0>(ftrack_tuple);
-  if(ktrack_list.size() > 0){
-    for(unsigned int j=0; j< ktrack_list.size(); j++){
-      const KalSeedPtrCollection* seedcol = ktrack_list[j];
-      std::cout<<" "<<std::endl;
-      if(seedcol->size() !=0){
-        std::cout<<"KALSEED INFORMATION"<<std::endl;
-        for(auto const& kseedptr : *seedcol) {
-          auto const& kseed = *kseedptr;
-          // taking the first segment is arbitrary; this should be configured by intersection type TODO
-          auto const& kseg = kseed.segments()[0];
-          auto const& momvec = kseg.momentum3();
-          std::string kaltitle;
-          double d0(0.0);
-          // hypo-specific parts
-          if(kseed.loopHelixFit()){
-            auto lh = kseg.loopHelix();
-            d0 = lh.minAxisDist();
-          } else if(kseed.centralHelixFit()){
-            auto ch = kseg.centralHelix();
-            d0 = ch.d0();
-          }else if(kseed.kinematicLineFit()){
-            auto kl = kseg.kinematicLine();
-            d0 = kl.d0();
-          }
-          kaltitle += " status " + kseed.status().stringRep() + '\n';
-          kaltitle += " Particle " +  ptable->particle(kseed.particle()).name() + " mom " + std::to_string(momvec.R()) + "MeV/c, cos(Theta) " + std::to_string(cos(momvec.Theta())) + '\n';
-          kaltitle += " t0 " + std::to_string(kseed.t0Val()) + " ns, d0 " + std::to_string(d0) + " mm " + '\n';
-          unsigned nactive =0;
-          for (auto const& hit : kseed.hits()){
-            if (hit.strawHitState() >= WireHitState::inactive) ++nactive;
-          }
-          kaltitle += " N active hits " + std::to_string(nactive) + " fit consistency " + std::to_string(kseed.fitConsistency()) + '\n';
-          if(kseed.hasCaloCluster()){
-            kaltitle += " calo cluster energy " + std::to_string(kseed.caloCluster()->energyDep()) + '\n';
-          }else {
-            kaltitle += std::string(" no calo cluster ") + '\n';
-          }
-
-          std::cout<<kaltitle<<std::endl;
+void PrintInfo::PrintKalInfo(){
+    // Access the particle data table for PDG IDs to names conversion
+    auto const& ptable = GlobalConstantsHandle<ParticleDataList>(); 
+    
+    // Extract the vector of collection pointers and labels from the ftrack_tuple
+    std::vector<const KalSeedPtrCollection*> ktrack_list = std::get<1>(ftrack_tuple);
+    std::vector<std::string> names = std::get<0>(ftrack_tuple);
+    
+    if(ktrack_list.size() > 0){
+        
+        // Set up stream for consistent formatting (e.g., 3 decimal places)
+        std::cout << std::fixed << std::setprecision(3);
+        
+        for(unsigned int j=0; j< ktrack_list.size(); j++){
+            const KalSeedPtrCollection* seedcol = ktrack_list[j];
+            
+            if(seedcol->size() !=0){
+                
+                std::cout << "\n==============================================================================================================================" << std::endl;
+                std::cout << "KALSEED INFORMATION | Collection: " << names[j] << " | Tracks: " << seedcol->size() << std::endl;
+                std::cout << "==============================================================================================================================" << std::endl;
+
+                // --- Table Header ---
+                std::cout << std::left << std::setw(10) << "Particle"
+                          << std::right << std::setw(10) << "Mom (MeV)"
+                          << std::setw(10) << "Cos(Th)"
+                          << std::setw(10) << "t0 (ns)"
+                          << std::setw(10) << "d0 (mm)"
+                          << std::setw(8) << "NActive"
+                          << std::setw(12) << "Fit Cons"
+                          << std::setw(10) << "E Calo"
+                          << std::left << std::setw(15) << "Fit Status"
+                          << std::endl;
+                std::cout << "------------------------------------------------------------------------------------------------------------------------------" << std::endl;
+
+
+                for(auto const& kseedptr : *seedcol) {
+                    auto const& kseed = *kseedptr;
+                    
+                    // Taking the first segment is common for simple summary printing
+                    auto const& kseg = kseed.segments()[0]; 
+                    auto const& momvec = kseg.momentum3();
+                    
+                    double d0 = 0.0;
+                    
+                    // --- Extract d0 based on fit hypothesis ---
+                    if(kseed.loopHelixFit()){
+                        d0 = kseg.loopHelix().minAxisDist();
+                    } else if(kseed.centralHelixFit()){
+                        d0 = kseg.centralHelix().d0();
+                    }else if(kseed.kinematicLineFit()){
+                        d0 = kseg.kinematicLine().d0();
+                    }
+                    
+                    // --- Count active hits ---
+                    unsigned nactive = 0;
+                    for (auto const& hit : kseed.hits()){
+                        // Check if the hit state is active (>= inactive, assuming states are ordered)
+                        if (hit.strawHitState() >= WireHitState::inactive) { 
+                            ++nactive; 
+                        }
+                    }
+
+                    // --- Extract Calo Energy ---
+                    double caloE = kseed.hasCaloCluster() ? kseed.caloCluster()->energyDep() : 0.0;
+                    
+                    // --- Extract Particle Name ---
+                    std::string particleName = ptable->particle(kseed.particle()).name();
+                    
+                    // --- Print Data Row ---
+                    std::cout << std::left << std::setw(10) << particleName
+                              << std::right << std::setw(10) << momvec.R()           // Momentum Magnitude
+                              << std::setw(10) << cos(momvec.Theta())    // Cosine of Polar Angle
+                              << std::setw(10) << kseed.t0Val()          // Track t0
+                              << std::setw(10) << d0                     // d0 or minAxisDist
+                              << std::setw(8) << nactive                // Number of active hits
+                              << std::setw(12) << kseed.fitConsistency() // Fit Consistency
+                              << std::setw(10) << caloE                  // Calo Cluster Energy
+                              << std::left << std::setw(15) << kseed.status().stringRep() // Fit Status
+                              << std::endl;
+                }
+                std::cout << "==============================================================================================================================" << std::endl;
+            }
         }
-      }
     }
-  }
+    // Restore default stream formatting
+    std::cout << std::scientific << std::setprecision(6);
 }
 
 void PrintInfo::PrintCaloInfo(){
-  std::vector<const CaloClusterCollection*> calocluster_list = std::get<1>(fcalocluster_tuple);
-  if(calocluster_list.size()!=0){
-    for(unsigned int j = 0; j< calocluster_list.size(); j++){
-      const CaloClusterCollection* clustercol = calocluster_list[j];
-      std::cout<<" "<<std::endl;
-      std::cout<<"CALO CLUSTER INFORMATION"<<std::endl;
-      std::cout<<"  Energy  "<<"     Time  "<<"        X       "<<"      Y    "<<std::endl;
-      if(clustercol->size() != 0){
-        for(unsigned int i = 0; i < clustercol->size(); i++){
-          auto const& cluster= (*clustercol)[i];
-          // Info to print:
-          std::string cluster_energy = std::to_string(cluster.energyDep());
-          std::string cluster_time = std::to_string(cluster.time());
-          std::string cluster_x = std::to_string(cluster.cog3Vector().x());
-          std::string cluster_y = std::to_string(cluster.cog3Vector().y());
-          std::cout<<" "<<cluster_energy<<"   "<<cluster_time<<"   "<<cluster_x<<"    "<<cluster_y<<std::endl;
+    // Extract the vector of collection pointers from the fcalocluster_tuple.
+    std::vector<const mu2e::CaloClusterCollection*> calocluster_list = std::get<1>(fcalocluster_tuple);
+    std::vector<std::string> names = std::get<0>(fcalocluster_tuple);
+
+    if(!calocluster_list.empty()){
+        
+        // Set up stream for consistent formatting (e.g., 3 decimal places)
+        std::cout << std::fixed << std::setprecision(3);
+        
+        // Loop over all CaloCluster collections
+        for(unsigned int j = 0; j< calocluster_list.size(); j++){
+            const mu2e::CaloClusterCollection* clustercol = calocluster_list[j];
+            
+            if(clustercol && !clustercol->empty()){
+                
+                std::cout << "\n=============================================================================" << std::endl;
+                std::cout << "CALO CLUSTER INFORMATION | Collection: " << names[j] << " | Clusters: " << clustercol->size() << std::endl;
+                std::cout << "=============================================================================" << std::endl;
+
+                // --- Table Header ---
+                std::cout << std::right << std::setw(10) << "Energy"
+                          << std::setw(12) << "Time (ns)"
+                          << std::setw(12) << "X COG (mm)"
+                          << std::setw(12) << "Y COG (mm)"
+                          << std::setw(12) << "Z COG (mm)" // Added Z coordinate for completeness
+                          << std::endl;
+                std::cout << "-----------------------------------------------------------------------------" << std::endl;
+
+                // Iterate over the clusters in the current collection
+                for(unsigned int i = 0; i < clustercol->size(); i++){
+                    auto const& cluster= (*clustercol)[i];
+                    
+                    double energy = cluster.energyDep();
+                    double time = cluster.time();
+                    CLHEP::Hep3Vector cog = cluster.cog3Vector();
+                    
+                    // Print Data Row
+                    std::cout << std::right << std::setw(10) << energy
+                              << std::setw(12) << time
+                              << std::setw(12) << cog.x()
+                              << std::setw(12) << cog.y()
+                              << std::setw(12) << cog.z()
+                              << std::endl;
+                }
+                std::cout << "=============================================================================" << std::endl;
+            }
         }
-      }
     }
-  }
+    // Restore default stream formatting
+    std::cout << std::scientific << std::setprecision(6);
 }
 
+
 void PrintInfo::PrintCRVInfo(){
-  std::cout<<"CRV COINCIDENCE INFORMATION"<<std::endl;
-  std::vector<const CrvCoincidenceClusterCollection*> crvcoin_list = std::get<1>(fcrvcoin_tuple);
-  if(crvcoin_list.size()!=0){
-    for(unsigned int j = 0; j< crvcoin_list.size(); j++){
-      const CrvCoincidenceClusterCollection* crvcoincol = crvcoin_list[j];
-      std::cout<<"  avTime  "<<"        avX       "<<"      avY    "<<"      avZ       "<<std::endl;
-      if(crvcoincol->size() != 0){
-        for(unsigned int i = 0; i < crvcoincol->size(); i++){
-          mu2e::CrvCoincidenceCluster const  &cluster= (*crvcoincol)[i];
-          std::string coin_avtime = std::to_string(cluster.GetAvgHitTime());
-          std::string coin_avX = std::to_string(cluster.GetAvgHitPos().x());
-          std::string coin_avY = std::to_string(cluster.GetAvgHitPos().y());
-          std::string coin_avZ = std::to_string(cluster.GetAvgHitPos().z());
-          std::cout<<"    "<<coin_avtime<<"              "<<coin_avX<<"          "<<coin_avY<<"             "<<coin_avZ<<std::endl;
+    // Extract the vector of collection pointers and labels from the fcrvcoin_tuple.
+    std::vector<const mu2e::CrvCoincidenceClusterCollection*> crvcoin_list = std::get<1>(fcrvcoin_tuple);
+    std::vector<std::string> names = std::get<0>(fcrvcoin_tuple);
+
+    if(!crvcoin_list.empty()){
+        
+        // Set up stream for consistent formatting (e.g., 3 decimal places)
+        std::cout << std::fixed << std::setprecision(3);
+        
+        // Loop over all CrvCoincidenceCluster collections
+        for(unsigned int j = 0; j< crvcoin_list.size(); j++){
+            const mu2e::CrvCoincidenceClusterCollection* crvcoincol = crvcoin_list[j];
+            
+            if(crvcoincol && !crvcoincol->empty()){
+                
+                std::cout << "\n=============================================================================" << std::endl;
+                std::cout << "CRV COINCIDENCE INFORMATION | Collection: " << names[j] << " | Clusters: " << crvcoincol->size() << std::endl;
+                std::cout << "=============================================================================" << std::endl;
+
+                // --- Table Header ---
+                // Using right alignment for numerical data
+                std::cout << std::right << std::setw(12) << "Avg Time (ns)"
+                          << std::setw(12) << "Avg X (mm)"
+                          << std::setw(12) << "Avg Y (mm)"
+                          << std::setw(12) << "Avg Z (mm)"
+                          << std::endl;
+                std::cout << "-----------------------------------------------------------------------------" << std::endl;
+
+                // Iterate over the coincidence clusters in the current collection
+                for(unsigned int i = 0; i < crvcoincol->size(); i++){
+                    mu2e::CrvCoincidenceCluster const &cluster = (*crvcoincol)[i];
+                    
+                    double avTime = cluster.GetAvgHitTime();
+                    CLHEP::Hep3Vector avPos = cluster.GetAvgHitPos();
+
+                    // Print Data Row
+                    std::cout << std::right << std::setw(12) << avTime
+                              << std::setw(12) << avPos.x()
+                              << std::setw(12) << avPos.y()
+                              << std::setw(12) << avPos.z()
+                              << std::endl;
+                }
+                std::cout << "=============================================================================" << std::endl;
+            }
         }
-      }
     }
-  }
+    // Restore default stream formatting
+    std::cout << std::scientific << std::setprecision(6);
 }
diff --git a/src/TextSelect.cc b/src/TextSelect.cc
index d41de17..14d33d2 100644
--- a/src/TextSelect.cc
+++ b/src/TextSelect.cc
@@ -1,33 +1,36 @@
 #include "EventDisplay/inc/TextSelect.hh"
+#include <iostream>
 
-using namespace mu2e;
+namespace mu2e {
 
-/*TextSelect::TextSelect(){};
+// Setter: Called by the REve thread (EventDisplayManager)
+void TextSelect::set(int run, int event) {
+    // Lock the mutex for writing
+    std::lock_guard<std::mutex> lock(_mutex);
+    runN = run;
+    eventN = event;
+    std::cout<<"user has set "<<runN << " " << eventN <<std::endl;
+    std::cout << "[TextSelect::set] Run/Event set to: " << runN << "/" << eventN << std::endl;
+}
 
-TextSelect::TextSelect(
-    int runn,
-    int eventn)
-    : REveElement{"TextSelect"}, runN(runn), eventN(eventn)
-  {};*/
-  
-  
-int TextSelect::get(){
-  return runN;
+// Setter: Called by the REve thread (EventDisplayManager)
+void TextSelect::setAutoplay(int x) {
+    // Lock the mutex for writing
+    std::lock_guard<std::mutex> lock(_mutex);
+    autoplay_ = x;
+    std::cout << "[TextSelect::setAutoplay] set to: " << autoplay_ << std::endl;
 }
 
-int TextSelect::setRun(int run){
-        int N = run;
-        std::cout<<"set run "<<N<<std::endl;
-        return N;
-      }
+int TextSelect::getAutoplay(){
+  return autoplay_;
+}
 
-void TextSelect::set(int run, int event){
-  int N = setRun(run);
-  runN = N;
-  
-  std::cout<<" [TextSelect::set] set to "<<N<<std::endl;
-  std::cout<<" [TextSelect::set] run number in this class "<<runN<<std::endl;
+// Getter: Called by the art module thread (Mu2eEventDisplay::analyze)
+std::pair<int, int> TextSelect::getRunEvent() {
+    // Lock the mutex for reading
+    std::lock_guard<std::mutex> lock(_mutex);
+    std::cout<<"user has received "<<runN << " " << eventN <<std::endl;
+    return {runN, eventN};
 }
-   
 
-  
+}
diff --git a/src/classes.h b/src/classes.h
index 637e121..eb922b3 100644
--- a/src/classes.h
+++ b/src/classes.h
@@ -2,7 +2,6 @@
 #include "EventDisplay/inc/DataInterface.hh"
 #include "EventDisplay/inc/EventDisplayManager.hh"
 #include "EventDisplay/inc/DataCollections.hh"
-#include "EventDisplay/inc/GeomUtil.hh"
 #include "EventDisplay/inc/GUI.hh"
 #include "EventDisplay/inc/DataProduct.hh"
 #include "EventDisplay/inc/TextSelect.hh"
diff --git a/src/classes_def.xml b/src/classes_def.xml
index c19ceff..9965240 100644
--- a/src/classes_def.xml
+++ b/src/classes_def.xml
@@ -2,7 +2,6 @@
   <class name="mu2e::MainWindow"/>
   <class name="mu2e::DataInterface"/>
   <class name="mu2e::EventDisplayManager"/>
-  <class name="mu2e::GeomUtil"/>
   <class name="mu2e::GUI"/>
   <class name="mu2e::DataProduct"/>
   <class name="mu2e::TextSelect"/>