LArbys · twongjirad · Sep 4, 2021 · Sep 4, 2021 · Sep 4, 2021 · Oct 28, 2021
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -0,0 +1,126 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+ublarcvapp is a C++ framework with Python bindings for analyzing Liquid Argon Time Projection Chamber (LArTPC) data from the MicroBooNE neutrino physics experiment. It provides tools for:
+- Deep learning-based particle tagging and classification
+- 3D reconstruction algorithms
+- Image manipulation and processing
+- Monte Carlo truth analysis
+- Event filtering and selection
+
+## Build Commands
+
+### Prerequisites Setup
+Ensure these environment variables are set:
+- `LARCV_LIBDIR` - LArCV library directory
+- `LARLITE_LIBDIR` and `LARLITE_INCDIR` - larlite directories
+- `LARCV_INCDIR` - LArCV include directory
+- `LAROPENCV_LIBDIR` and `LAROPENCV_INCDIR` - LArOpenCV directories
+- Optional: `GEO2D_BASEDIR` - for Geo2D support
+
+### Building
+```bash
+mkdir build
+cd build
+cmake ..
+make -j4
+make install
+source ../configure.sh
+```
+
+### Running Tests
+Tests are located in individual module `test/` directories. Example:
+```bash
+cd ublarcvapp/Reco3D/test
+python test_astar.py
+
+cd ublarcvapp/UBImageMod/test
+python test_ubsplit.py [input_larcv_file] [adc_producer_name]
+```
+
+## Code Architecture
+
+### Core Components
+
+1. **Processing Framework** (`LLCVProcessor/`)
+   - `LLCVProcessBase` - Base class for all processing modules
+   - `LLCVProcessDriver` - Manages processing chain execution
+   - Configuration via `.cfg` files
+
+2. **Image Processing** (`UBImageMod/`)
+   - `UBSplitDetector` - Splits detector images into subregions
+   - `UBCropLArFlow` - Crops sparse larflow data
+   - `InfillImageStitcher` - Stitches subimages back together
+
+3. **3D Reconstruction** (`Reco3D/`)
+   - `AStar3DAlgo` - A* pathfinding for 3D track reconstruction
+   - Configuration through `AStar3DAlgoConfig`
+   - Supports both regular and proton-specific tracking
+
+4. **Deep Learning Integration** (`DLTagger/`)
+   - `DLTagger` - Main interface for DL model predictions
+   - `MRCNNMatch` - Mask R-CNN matching algorithms
+   - Integrates with external DL model servers
+
+5. **Monte Carlo Tools** (`MCTools/`)
+   - Truth matching utilities
+   - Space charge effect corrections
+   - Flash matching algorithms
+
+### Key Design Patterns
+
+1. **Factory Pattern**: Most algorithms use factory registration:
+   ```cpp
+   static LArbysImageFactory __global_LArbysImageFactory__;
+   ```
+
+2. **Configuration**: Algorithms use dedicated config classes:
+   ```cpp
+   class AlgoConfig : public larcv::PSet {
+     // Configuration parameters
+   };
+   ```
+
+3. **Process Chain**: Modules inherit from `LLCVProcessBase` and implement:
+   - `configure()` - Setup from config file
+   - `initialize()` - One-time initialization
+   - `process()` - Per-event processing
+   - `finalize()` - Cleanup
+
+### Data Flow
+
+1. Input: ROOT files containing larcv::EventImage2D, larlite::event_* objects
+2. Processing: Chain of LLCVProcess modules
+3. Output: Modified/new data products saved to output ROOT files
+
+## Development Guidelines
+
+### Adding New Modules
+
+1. Create directory under `ublarcvapp/`
+2. Add CMakeLists.txt with:
+   ```cmake
+   set(MODULE_NAME YourModule)
+   add_subdirectory(${MODULE_NAME})
+   ```
+3. Implement classes inheriting from `LLCVProcessBase`
+4. Add LinkDef.h for ROOT dictionary generation
+5. Register with factory if needed
+
+### Working with Sparse Data
+
+Many algorithms work with sparse representations:
+- Use `larcv::EventSparseTensor2D` for sparse image data
+- Convert between dense/sparse with utility functions
+- Handle coordinate transformations carefully
+
+### Coordinate Systems
+
+Be aware of multiple coordinate systems:
+- Wire/tick 2D coordinates per plane
+- 3D spatial coordinates (with/without space charge effects)
+- Image pixel coordinates
+- Detector geometry coordinates
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -7,14 +7,28 @@ if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
 endif()
 
 # CFLAGS
-SET(CMAKE_C_FLAGS "-std=gnu99 -pedantic -fPIC -pedantic -fopenmp -mtune=native")
-SET(CMAKE_CXX_FLAGS "-std=c++11 -Wall -fPIC -pedantic -fopenmp -mtune=native")
+#SET(CMAKE_C_FLAGS "-std=gnu99 -pedantic -fPIC -pedantic -fopenmp -mtune=native")
+#SET(CMAKE_CXX_FLAGS "-Wall -fPIC -pedantic -fopenmp -mtune=native")
 
 ## Dependencies
 
 #---CERN ROOT (required)
 find_package(ROOT CONFIG REQUIRED)
-
+# we set the compiler version based on the one used for ROOT
+execute_process(
+    COMMAND bash "-c" "root-config --features"
+    OUTPUT_VARIABLE TEST_ROOT_CXX_STANDARD )
+if (${TEST_ROOT_CXX_STANDARD} MATCHES "cxx17")
+  message( STATUS "using cxx17")
+  set(CMAKE_CXX_STANDARD 17)
+elseif (${TEST_ROOT_CXX_STANDARD} MATCHES "cxx14")
+  message( STATUS "using cxx14")
+  set(CMAKE_CXX_STANDARD 14)
+else ()
+  message( STATUS "using cxx11")  
+  set(CMAKE_CXX_STANDARD 11)
+endif()
+
 #---LArCV (required)
 set( larcv_DIR "$ENV{LARCV_LIBDIR}/cmake/larcv")
 find_package( larcv REQUIRED )
@@ -55,9 +69,12 @@ endif()
 
 #---Eigen3
 find_package(Eigen3 REQUIRED)
+get_property(EIGEN3_INCLUDE_DIRS TARGET Eigen3::Eigen PROPERTY INTERFACE_INCLUDE_DIRECTORIES )
 
 #---LArLite
-set( LARLITE_INC_DIRS "$ENV{LARLITE_COREDIR}" "$ENV{LARLITE_BASEDIR}" "$ENV{LARLITE_USERDEVDIR}" "$ENV{LARLITE_BASEDIR}/../" )
+set( larlite_DIR $ENV{LARLITE_LIBDIR}/cmake/larlite )
+find_package( larlite REQUIRED )
+set( LARLITE_INC_DIRS "$ENV{LARLITE_INCDIR}" )
 set( LARLITE_LIB_DIR  "$ENV{LARLITE_LIBDIR}" )
 set( HAS_LARLITE 1 )
 file( GLOB LARLITE_LIBS "$ENV{LARLITE_LIBDIR}/libLArLite*.so" )
@@ -83,9 +100,42 @@ if (Boost_FOUND)
     message(STATUS "Using boost libraries: ${Boost_LIBRARIES}")
     message(STATUS "Using boost thread library: ${Boost_THREAD_LIBRARY}")
     link_directories(${Boost_LIBRARY_DIRS})
+else()
+    message(STATUS "Boost not found")
 endif (Boost_FOUND)
 
-#INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIR} )
+#---HDF5 (for machine learning data output)
+find_package(HDF5 COMPONENTS C CXX QUIET)
+if(HDF5_FOUND)
+    message(STATUS "Found HDF5: ${HDF5_VERSION}")
+    add_compile_definitions(HAVE_HDF5)
+else()
+    message(STATUS "HDF5 not found, HDF5 output features will be disabled")
+endif()
+
+#---HighFive (header-only HDF5 C++ interface)
+if(HDF5_FOUND)
+    # Try to find HighFive as an installed package first
+    find_package(HighFive QUIET)
+    if(NOT HighFive_FOUND)
+        # If not found, check if it exists as a submodule or in a known location
+        if(EXISTS "$ENV{UBDL_BASEDIR}/extern/highfive/include")
+            set(HIGHFIVE_INCLUDE_DIR "$ENV{UBDL_BASEDIR}/extern/highfive/include")
+            message(STATUS "Found HighFive headers at: ${HIGHFIVE_INCLUDE_DIR}")
+            set(HighFive_FOUND TRUE)
+        else()
+            message(STATUS "HighFive not found. To use HDF5 features, please:")
+            message(STATUS "  1. Install HighFive: https://github.com/highfive-devs/highfive/tree/main ")
+            message(STATUS "  2. Or add as submodule: git submodule add https://github.com/highfive-devs/highfive/tree/main extern/highfive")
+        endif()
+    else()
+        message(STATUS "Found HighFive package")
+    endif()
+
+    if(HighFive_FOUND)
+        add_compile_definitions(HAVE_HIGHFIVE)
+    endif()
+endif()
 
 #--- glog
 #find_package(glog REQUIRED)

diff --git a/python/ublarcvapp/__init__.py b/python/ublarcvapp/__init__.py
@@ -17,3 +17,4 @@
     ROOT.gSystem.Load(l)
 
 import ROOT.ublarcvapp as ublarcvapp
+ublarcvapp.mctools.MCPixelPGraph
diff --git a/ublarcvapp/CMakeLists.txt b/ublarcvapp/CMakeLists.txt
@@ -1,22 +1,19 @@
-add_subdirectory(LLCVProcessor)
 add_subdirectory(dbscan)
-add_subdirectory(Reco3D)
-add_subdirectory(ContourTools)
-
+#add_subdirectory(Reco3D)
+#add_subdirectory(LArOpenCVHandle)
+add_subdirectory(ContourTools) # requires opencv, laropencv
 if (HAS_LARLITE)
+  set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -DHAS_LARLITE")  
   add_subdirectory(LArliteHandler)
+  add_subdirectory(LLCVProcessor)
   add_subdirectory(UBImageMod)
   add_subdirectory(UBWireTool)
   add_subdirectory(ubdllee)
-  add_subdirectory(Filter)
+#  add_subdirectory(Filter)
   add_subdirectory(MCTools)
+  add_subdirectory(UBPhotonLib)
+  add_subdirectory(ParticleToPixelUtils)
 endif()
-
-
-if (LARCV_USE_GEO2D)
-  add_subdirectory(LArOpenCVHandle)
-endif()
-
-if (Boost_FOUND)
-  add_subdirectory(DLTagger)
-endif()
+#if (Boost_FOUND)
+#  add_subdirectory(DLTagger)
+#endif()
diff --git a/ublarcvapp/ContourTools/CMakeLists.txt b/ublarcvapp/ContourTools/CMakeLists.txt
@@ -1,31 +1,61 @@
 set(MODULE_NAME ContourTools)
 
+set(LIBNAME LArCVApp_${MODULE_NAME})
+
 # Collect the headers
-file(GLOB HEADERS "*.h")
+set( HEADERS
+  ContourShapeMeta.h
+  ContourCluster.h
+  ContourClusterAlgo.h  
+  #ContourAStarClusterAlgo.h
+)
 
-# Remove LinkDef.h
-list(FILTER HEADERS EXCLUDE REGEX ".*LinkDef.h$")
-
-# However, the file(GLOB...) allows for wildcard additions:
-file(GLOB SOURCES "*.cxx")
+# Collect the sources
+add_library( ${LIBNAME} SHARED
+  ContourShapeMeta.cxx
+  ContourCluster.cxx
+  ContourClusterAlgo.cxx  
+  #ContourAStarClusterAlgo.cxx
+)
 
-# library name
-set(LIBNAME LArCVApp_${MODULE_NAME})
-#message("opencv libs: ${OpenCV_LIBS}")
-#message("laropencv libs: ${LAROPENCV_LIBS}")
-#message("opencv inc: ${OpenCV_INCLUDE_DIRS}")
+set_target_properties(${LIBNAME} PROPERTIES PUBLIC_HEADER "${HEADERS}")
 
-# includes
-include_directories(${LARCV_INCLUDE_DIR} $ENV{LAROPENCV_BASEDIR} $ENV{UBLARCVAPP_BASEDIR} ${OpenCV_INCLUDE_DIRS} ${GEO2D_INC_DIR} $ENV{LARLITE_USERDEVDIR} )
+target_include_directories(${LIBNAME}
+  PUBLIC
+  $<INSTALL_INTERFACE:include/ublarcvapp/${MODULE_NAME}>
+  PRIVATE
+  ${PROJECT_SOURCE_DIR}
+  ${LARLITE_INCLUDE_DIR}
+  ${LARCV_INCLUDE_DIR}
+  ${OpenCV_INCLUDE_DIRS}
+  ${GEO2D_INC_DIR}
+  ${LAROPENCV_INC_DIR}
+)
+#target_include_directories(${LIBNAME} PUBLIC ${LARCV_INCLUDE_DIR} ${LARLITE_INC_DIRS})
+target_link_libraries( ${LIBNAME} PUBLIC
+  opencv_imgcodecs
+  opencv_core  
+  LArCVCoreBase
+  LArCVCoreDataFormat
+  LArCVCoreCVUtil
+  ${GEO2D_LIBS}  
+  ${LAROPENCV_LIBS}  
+  #LArCVApp_LArOpenCVHandle
+  #LArCVApp_Reco3D  
+)
+include_directories( ${CMAKE_CURRENT_SOURCE_DIR}
+  ${PROJECT_SOURCE_DIR}
+  ${LARLITE_INCLUDE_DIR}
+  ${LARCV_INCLUDE_DIR}
+  ${OpenCV_INCLUDE_DIRS}
+  ${GEO2D_INC_DIR}
+)
 
 # Generate the dictionary
 ROOT_GENERATE_DICTIONARY(G__${LIBNAME} ${HEADERS} LINKDEF LinkDef.h)
 
-# Generate the shared library from the sources
-add_library( ${LIBNAME} SHARED ${SOURCES} G__${LIBNAME}.cxx)
-set_target_properties(${LIBNAME} PROPERTIES PUBLIC_HEADER "${HEADERS}")
-target_include_directories(${LIBNAME} PUBLIC ${LARCV_INCLUDE_DIR} ${OpenCV_INCLUDE_DIRS} )
-target_link_libraries(${LIBNAME} LArCVCoreBase LArCVCoreDataFormat LArCVCoreCVUtil LArCVApp_LArOpenCVHandle LArCVApp_Reco3D ${LAROPENCV_LIBS} ${GEO2D_LIBS} opencv_core)
+# add dictionary file to sources                                                                                                                                               
+target_sources( ${LIBNAME} PRIVATE G__${LIBNAME}.cxx )
 
 # install libraries and headers
 install(TARGETS ${LIBNAME}

diff --git a/ublarcvapp/ContourTools/ContourAStarClusterAlgo.cxx b/ublarcvapp/ContourTools/ContourAStarClusterAlgo.cxx
@@ -4,8 +4,8 @@
 #include <stdexcept>
 
 // larlite
-#include "LArUtil/LArProperties.h"
-#include "LArUtil/Geometry.h"
+#include "larlite/LArUtil/LArProperties.h"
+#include "larlite/LArUtil/Geometry.h"
 
 // larcv
 #include "larcv/core/CVUtil/CVUtil.h"

diff --git a/ublarcvapp/ContourTools/ContourAStarClusterAlgo.h b/ublarcvapp/ContourTools/ContourAStarClusterAlgo.h
@@ -20,7 +20,7 @@
 #include <opencv2/imgproc.hpp>
 #include <opencv2/imgcodecs.hpp>
 
-#include "ContourShapeMeta.h"
+#include "ublarcvapp/ContourTools/ContourShapeMeta.h"
 
 namespace ublarcvapp {
 

diff --git a/ublarcvapp/ContourTools/ContourCluster.h b/ublarcvapp/ContourTools/ContourCluster.h
@@ -4,13 +4,13 @@
 #include <vector>
 #include <set>
 
-#include "ContourShapeMeta.h"
-
 #ifdef USE_OPENCV
 #include <opencv2/opencv.hpp>
 #include <opencv2/core/core.hpp>
 #endif
 
+#include "ublarcvapp/ContourTools/ContourShapeMeta.h"
+
 namespace ublarcvapp {
 
   class ContourCluster : public std::vector< std::vector<ContourShapeMeta> > {

diff --git a/ublarcvapp/ContourTools/ContourClusterAlgo.h b/ublarcvapp/ContourTools/ContourClusterAlgo.h
@@ -14,7 +14,7 @@
 
 #include <opencv2/core.hpp>
 
-#include "ContourShapeMeta.h"
+#include "ublarcvapp/ContourTools/ContourShapeMeta.h"
 
 namespace ublarcvapp {
 

diff --git a/ublarcvapp/DLTagger/CMakeLists.txt b/ublarcvapp/DLTagger/CMakeLists.txt
@@ -37,6 +37,7 @@ add_subdirectory( mrcnnmatch )
 message("headers: ${HEADERS}")
 message("project source dir: ${PROJECT_SOURCE_DIR}")
 message("eigen3: ${EIGEN3_INCLUDE_DIRS}")
+message("boost include dir: ${Boost_INCLUDE_DIRS}")
 
 get_target_property(ALL_HEADERS ${LIBNAME} PUBLIC_HEADER)
 
@@ -57,7 +58,7 @@ target_include_directories(${LIBNAME}
   )
 target_link_libraries(${LIBNAME} ${LARLITE_LIBS_USED} ${LARCV_LIBS_USED} ${UBLARCVAPP_LIBS_USED} ${LAROPENCV_LIBS} ${GEO2D_LIBS} opencv_core)
 
-include_directories( ${CMAKE_CURRENT_SOURCE_DIR} ${PROJECT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/mrcnnmatch ${LARCV_INCLUDE_DIR} ${LARLITE_INCLUDES} $ENV{CILANTRO_INC_DIR} ${EIGEN3_INCLUDE_DIRS} ${Boost_INCLUDE_DIR} ${OpenCV_INCLUDE_DIRS} )
+include_directories( ${CMAKE_CURRENT_SOURCE_DIR} ${PROJECT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/mrcnnmatch ${LARCV_INCLUDE_DIR} ${LARLITE_INCLUDES} $ENV{CILANTRO_INC_DIR} ${EIGEN3_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${OpenCV_INCLUDE_DIRS} )
 ROOT_GENERATE_DICTIONARY(G__${LIBNAME} ${ALL_HEADERS} LINKDEF LinkDef.h)
 target_sources( ${LIBNAME} PRIVATE G__${LIBNAME}.cxx )
Original file line number	Diff line number	Diff line change
Expand Up		@@ -17,3 +17,4 @@
		ROOT.gSystem.Load(l)

		import ROOT.ublarcvapp as ublarcvapp
		ublarcvapp.mctools.MCPixelPGraph