PatternLUTMaker.cxx

// Analyzer file which writes a LUT text file from input cluster text file (made
// in ClusterTripletMaker) containing only those cluster combination entries
// which occur with a frequency above the lut_threshold parameter
 
#include "Tools/PatternLUTMaker.h"
 
namespace tools {
 
PatternLUTMaker::PatternLUTMaker(const std::string& name,
                                 framework::Process& process)
    : Analyzer(name, process) {}
 
void PatternLUTMaker::configure(framework::config::Parameters& ps) {
  input_file_ = ps.get<std::string>("input_file");
  output_file_ = ps.get<std::string>("output_file");
  lut_threshold_ = ps.get<double>("lut_threshold");
  verbose_ = ps.get<int>("verbosity");
 
  // The LUT threshold is the minimum percentage of times that a track
  // must appear in a pool of events to be written to the LUT.
  // Example --- horizontal tracks whose pad 1-2 and pad 2-3 delta values
  //             are both 0 make up ~80% of tracks out of 10.000 events,
  //             while a track with deltas (+22,-22), meaning pad 1 cluster in
  //             e.g. bar 4, pad 2 cluster in bar 26, and pad 3 cluster in bar 4
  //             only appears once in 10.000 events (0.01%). The straight
  //             tracks are written to the LUT and the single "anomaly" is not.
  // Primary motivation here is for use in the case of an unknown TS
  // misalignment.
 
  ldmx_log(info) << "In PatternLUTMaker: configure done!" << std::endl;
  ldmx_log(info) << "Got parameters: \nInput file:   " << input_file_
                 << "\nOutput file:     " << output_file_
                 << "\nLUT threshold:     " << lut_threshold_
                 << "\nVerbosity:      " << verbose_;
 
  return;
}
 
void PatternLUTMaker::onProcessStart() {
  infile_.open(input_file_);
  outfile_.open(output_file_);
 
  if (total_lines_ > 0) return;
  int ev;
  float p1, p2, p3;
  while (infile_ >> ev >> p1 >> p2 >> p3) {
    float p12 =
        p2 -
        p1;  // for each cluster combination, calculate vertical propagation
    float p23 =
        p3 - p2;  // between pads 1 and 2 (p12) and between pads 2 and 3 (p23);
    groups_[{p12, p23}].push_back(
        {ev, p1, p2, p3});  // and group by these values
    total_lines_++;         //(the "propagation patterns").
  }
  return;
}
 
void PatternLUTMaker::analyze(const framework::Event& event) {}
 
void PatternLUTMaker::onProcessEnd() {
  ldmx_log(info) << "total_lines = " << total_lines_;
  ldmx_log(info) << "groups = " << groups_.size();
  int combs =
      0;  // combs will be the total number of patterns written to the LUT
  int tracks = 0;  // and tracks the number of tracks contained within those
                   // pattern groups
 
  if (verbose_) {
    ldmx_log(info) << "Total number of cluster combinations: " << total_lines_
                   << "\n"
                   << "Number of different propagation patterns: "
                   << groups_.size() << "\n"
                   << "LUT Threshold: " << lut_threshold_ * 100 << "%\n";
  }
 
  for (auto& g : groups_) {
    int count = g.second.size();
    double frac = static_cast<double>(count) / total_lines_;
 
    if (verbose_) {
      ldmx_log(debug) << "(" << g.first.first << "," << g.first.second
                      << ") appears " << count << " times, (" << frac * 100
                      << " %)" << "\n";
    }
 
    if (frac >
        lut_threshold_) {  // write to outfile_ (LUT file) if over threshold
      combs++;
      for (auto& line : g.second) {
        tracks++;
        outfile_ << line.p1_ << " " << line.p2_ << " " << line.p3_ << "\n";
      }
    }
  }
 
  if (verbose_) {
    ldmx_log(info) << "\nLUT textfile written." << "\n"
                   << combs << " combinations (" << tracks
                   << " tracks) written to LUT.\n";
  }
  return;
}
}  // namespace tools
 
DECLARE_ANALYZER(tools::PatternLUTMaker)