Structure of Tagger Code

Structure of the Tagger Code

The tagger breaks down into the following modules, all located in the app folder:

• ThruMu: through-going muon tagger
• StopMu: stopping muon tagger
• ContainedROI: clusters un-tagged pixels from above steps, defines approx. 3D space-points for it. Also contains the flash-matching routines to select which clusters (thrumu, stopmu, or contained) are consistent enough with the in-time flash
• TaggerCROI: module to bring all the pieces together into one routine.

The program to all the tagger code is in TaggerCOI/bin and is called run_tagger (the source, run_tagger.cxx is in the same folder). If you want to trace the code, run_tagger.cxx is the place to start.

Note that there is another program to re-run the tagger after the track-finding stage. Using saved information about found thrumu, stopmu, and contained tracks, one can rerun the portion of the tagger responsible for selecting which tracks should be passed downstream. This helps decouple the tagger into two parts: track finding and track selecting. This routine is also in TaggerCROI/bin and is called rerun_containedroi.

Structure of each of the components

ThruMu

• The first stage of ThruMu involves finding candidate regions of the detector where the particles crossed one of the side of the TPC boundaries. Code to find boundary crossings on the downstream, upstream, top, and bottom sides are in BMTBoundaryMuonAlgo.h/.cxx. The code to find where a particle crossed the anode and cathode are in FlashMuonTaggerAlgo.h/.cxx.
• Next the ThruMu stage is connected the boundary points together to get through-going muons. This is performed by ThruMuTracker.h/.cxx. (But this will change soon and this wiki will be updated accordingly at that point)
• What is saved after the ThruMu stages is the left over boundary crossing points and the thrumu tracks found. You can see what the input and output of the ThruMu portions by looking at TaggerCROI::runThru in app/TaggerCROI/TaggerCROIAlgo.cxx.

StopMu

• The primary routine of the StopMu code is in StopMuCluster
• The StopMu code relies a lot on the clustering routines found in app/UntaggedClustering. It is separated out, because the same routines will be used for finding contained clusters.
• StopMu code is also anticipated to change a decent amount over the next week or so. This is due to its disappointing performance and potentially, run-away memory usage.

ContainedROI

• The first part of the ContainedROI is to cluster un-tagged pixels and build some sort of 3D object to represent this charge. This is app/ContainedROI/ContainedROI.h/.cxx.
• Like the StopMu code, it uses pixel clustering routines stored in app/UntaggedClustering
• The portion of the code that does the selection of clusters is in app/ContainedROI/TaggerFlashMatchAlgo.h/.cxx

TaggerCROI

• This module brings everything together. The tagger algo as a whole is brought together in TaggerCroiAlgo.h/.cxx.
• Note that each stage makes a "payload", that is the data it outputs. This is to try to make it more clear what each stage produces and also what it requires. The definition of the payloads are in TaggerCROITypes.h/.cxx.
• The routines responsible for writing the payload data to disk are in PayloadWriteMethods.h/.cxx. Hopefully separating this out will allow easier integration into other frameworks (like LArSoft)
• Again, the bindary to run the tagger code is in bin/run_tagger