Public Member Functions
	TestBeamClusterProducer (const std::string &name, framework::Process &process)

virtual void	configure (framework::config::Parameters &ps)
	Callback for the EventProcessor to configure itself from the given set of parameters.

virtual void	produce (framework::Event &event)
	Process the event and put new data products into it.

virtual void	addHit (uint idx, trigscint::TestBeamHit hit)
	add a hit at index idx to a cluster

virtual void	onProcessStart ()
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

virtual void	onProcessEnd ()
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.

virtual void	process (Event &event) final
	Processing an event for a Producer is calling produce.

Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class

	EventProcessor (const std::string &name, Process &process)
	Class constructor.

virtual	~EventProcessor ()=default
	Class destructor.

virtual void	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.

virtual void	onNewRun (const ldmx::RunHeader &run_header)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.

virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.

virtual void	onFileClose (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.

template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.

TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.

void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module_.

void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.

int	getLogFrequency () const
	Get the current logging frequency from the process.

int	getRunNumber () const
	Get the run number from the process.

std::string	getName () const
	Get the processor name.

void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Attributes
std::vector< ldmx::TrigScintCluster >	clusters_

double	seed_ {0.}

double	min_thr_ {0.}

int	max_width_ {2}

int	max_channel_id_ {11}

int	verbose_ {0}

double	pad_time_ {0.}

double	time_tolerance_ {0.}

std::string	input_collection_

std::string	output_collection_

std::string	pass_name_ {""}

float	centroid_ {0.}

float	val_ {0.}

float	val_e_ {0.}

std::vector< unsigned int >	v_added_indices_

std::vector< unsigned int >	v_used_indices_

float	beam_e_ {0.}

bool	do_clean_hits_ {false}
	boolean indicating whether we want to apply quality criteria from hit reconstruction

float	time_ {0.}

std::map< int, int >	hit_channel_map_

Additional Inherited Members
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms

NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.

logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Definition at line 23 of file TestBeamClusterProducer.h.

Constructor & Destructor Documentation

◆ TestBeamClusterProducer()

trigscint::TestBeamClusterProducer::TestBeamClusterProducer	(	const std::string &	name,
		framework::Process &	process )

inline

Definition at line 25 of file TestBeamClusterProducer.h.

26 : Producer(name, process) {}

framework::Producer::Producer

Producer(const std::string &name, Process &process)

Class constructor.

Definition EventProcessor.cxx:53

framework::Producer::process

virtual void process(Event &event) final

Processing an event for a Producer is calling produce.

Definition EventProcessor.h:276

Member Function Documentation

◆ addHit()

void trigscint::TestBeamClusterProducer::addHit	(	uint	idx,
		trigscint::TestBeamHit	hit )

virtual

add a hit at index idx to a cluster

Definition at line 437 of file TestBeamClusterProducer.cxx.

                                                                       {
  float ampl = hit.getPE();
  val_ += ampl;
  float energy = hit.getEnergy();
  val_e_ += energy;
 
  centroid_ += (idx + 1) * ampl;  // need non-zero weight of channel 0. shifting
                                  // centroid back by 1 in the end
  // this number gets divided by val at the end
  v_added_indices_.push_back(idx);
 
  beam_e_ += hit.getBeamEfrac() * energy;
  if (hit.getTime() > -990.) {
    time_ += hit.getTime() * ampl;
  }
 
  v_used_indices_.push_back(idx);
  /*    // not working properly, but i'd prefer this type of solution
        hit_channel_map_.erase( idx ) ;
        if (verbose_ > 1 ) {
        ldmx_log(debug) << "Removed used hit " << idx << " from list";
        }
        if ( hit_channel_map_.find( idx) != hit_channel_map_.end() )
        std::cerr << "----- WARNING! Hit still present in map after removal!! ";
  */
  if (verbose_ > 1) {
    ldmx_log(debug) << "   In addHit, adding hit at " << idx
                    << " with amplitude " << ampl
                    << ", updating cluster to current centroid "
                    << centroid_ / val_ - 1 << " and energy " << val_
                    << ". index vector now ends with "
                    << v_added_indices_.back();
  }
 
  return;
}

References ldmx::TrigScintHit::getBeamEfrac(), ldmx::CalorimeterHit::getEnergy(), ldmx::TrigScintHit::getPE(), and ldmx::CalorimeterHit::getTime().

Referenced by produce().

◆ configure()

void trigscint::TestBeamClusterProducer::configure ( framework::config::Parameters & parameters )

virtual

Callback for the EventProcessor to configure itself from the given set of parameters.

The parameters a processor has access to are the member variables of the python class in the sequence that has class_name equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters

parameters Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 8 of file TestBeamClusterProducer.cxx.

                                                                     {
  seed_ = ps.get<double>("seed_threshold");
  min_thr_ = ps.get<double>("clustering_threshold");
  max_width_ = ps.get<int>("max_cluster_width");
  max_channel_id_ = ps.get<int>("max_channel_nb");
  input_collection_ = ps.get<std::string>("input_collection");
  pass_name_ = ps.get<std::string>("input_pass_name");
  output_collection_ = ps.get<std::string>("output_collection");
  do_clean_hits_ = ps.get<bool>("do_clean_hits");
  verbose_ = ps.get<int>("verbosity");
 
  time_tolerance_ = ps.get<double>("time_tolerance");
  pad_time_ = ps.get<double>("pad_time");
  if (verbose_) {
    ldmx_log(info) << "In TestBeamClusterProducer: configure done!";
    ldmx_log(info) << "Got parameters: \nSeed threshold:   " << seed_
                   << "\nClustering threshold: " << min_thr_
                   << "\nMax cluster width: " << max_width_
                   << "\nExpected pad hit time: " << pad_time_
                   << "\nMax hit time delay: " << time_tolerance_
                   << "\n\t doCleanHits = " << do_clean_hits_
                   << "\nInput collection:     " << input_collection_
                   << "\nInput pass name:     " << pass_name_
                   << "\nOutput collection:    " << output_collection_
                   << "\nVerbosity: " << verbose_;
  }
 
  return;
}

References do_clean_hits_, and framework::config::Parameters::get().

◆ onProcessEnd()

void trigscint::TestBeamClusterProducer::onProcessEnd ( )

virtual

Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

Reimplemented from framework::EventProcessor.

Definition at line 480 of file TestBeamClusterProducer.cxx.

                                           {
  ldmx_log(debug) << "Process ends!";
 
  return;
}

◆ onProcessStart()

void trigscint::TestBeamClusterProducer::onProcessStart ( )

virtual

Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

Reimplemented from framework::EventProcessor.

Definition at line 474 of file TestBeamClusterProducer.cxx.

                                             {
  ldmx_log(debug) << "Process starts!";
 
  return;
}

◆ produce()

void trigscint::TestBeamClusterProducer::produce ( framework::Event & event )

virtual

Process the event and put new data products into it.

Parameters

event The Event to process.

Implements framework::Producer.

Definition at line 38 of file TestBeamClusterProducer.cxx.

                                                           {
  // parameters.
  // a cluster seeding threshold
  // a clustering threshold -- a lower boundary for being added at all (zero
  // suppression) -- tentative a maximum cluster width
  //
 
  // steps.
  // 1. get an input collection of digi hits. at most one entry per channel.
  // 2. access them by channel number
  // 3. clustering:
  //       a. add first hit > seedThr to cluster(ling) . store content as
  //       localMax. track size of cluster (1) b. if not in beginning of array:
  //       add cell before while content <  add next hit first hit > seedThr to
  //       cluster(ling) b. while content <  add next hit first hit > seedThr to
  //       cluster(ling)
 
  /*
 
 
 
    //Procedure: keep going until there is a seed. walk back at most 2 steps
    // add all the hits. clusters of up to 3 is fine.
    // if the cluster is > 3, then we need to do something.
    // if it's == 4, we'd want to split in the middle if there are two potential
    seeds. retain only the first half, cases are (seed = s, n - no/noise)
    // nsns , nssn, snsn, ssnn.  nnss won't happen (max 1 step back from s,
    unless there is nothing in front)
    // all these are ok to split like this bcs even if ssnn--> ss and some small
    nPE is lost, that's probably pretty negligible wrt the centroid position,
    with two seeds in one cluster
 
    // if it's > 4, cases are
    // nsnsn, nsnss, nssnn, nssns, snsnn, snsns, ssnnn, ssnns.
    // these are also all ok to just truncate after 2. and then the same check
    outlined above will happen to the next chunk.
 
    // so in short we can
    // 1. seed --> addHit
    // 2. walk back once --> addHit
    // 3. check next: if seed+1 exists && seed +2 exists,
    // 3a. if seed-1 is in already, stop here.
    // 3b. else if seed+3 exists, stop here.
    // 3c. else addHit(seed+1), addHit(seed+2)
    // 4. if seed+1 and !seed+2 --> addHit(seed+1)
    // 5. at this point, if clusterSize is 2 hits and seed+1 didn't exist, we
    can afford to walk back one more step and add whatever junk was there (we
    know it's not a seed)
 
 
    */
 
  if (verbose_) {
    ldmx_log(debug) << "produce() starts! Event number: "
                    << event.getEventHeader().getEventNumber();
  }
 
  // looper over digi hits and aggregate energy depositions for each detID
 
  const auto digis{event.getCollection<trigscint::TestBeamHit>(
      input_collection_, pass_name_)};
 
  if (verbose_) {
    ldmx_log(debug) << "Got digi collection " << input_collection_ << "_"
                    << pass_name_ << " with " << digis.size() << " entries ";
  }
 
  // TODO remove this once verified that the noise overlap bug is gone
  bool do_duplicate = true;
 
  // 1. store all the channel digi content in channel order
  auto i_digi{0};
  for (const auto& digi : digis) {
    // these are unordered hits, and this collection is zero-suppressed
    // map the index of the digi to the channel index
    ldmx_log(debug) << "Digi has PE count " << digi.getPE() << " and energy "
                    << digi.getEnergy();
 
    if (do_clean_hits_ && digi.getQualityFlag() && digi.getQualityFlag() != 4) {
      // allow for long pulse hits
      ldmx_log(debug) << "Skipping hit with non-zero quality flag  "
                      << digi.getQualityFlag();
      continue;
    }
    // cut on a min threshold (for a non-seeding hit to be added
    // to seeded clusters) already here
    if (digi.getPE() > min_thr_) {
      int id = digi.getBarID();
      if (id > max_channel_id_) {  // test beam has some uninstrumented channels
                                   // (could also consider setting these to 0 in
                                   // hit producer)
        ldmx_log(debug) << "Skipping channel with bar ID = " << id << " > "
                        << max_channel_id_ << " (max instrumented nb)";
        continue;
      }
      // first check if there is a (pure) noise hit at this channel,  and
      // replace it in that case. this is a protection against a problem that
      // shouldn't be there in the first place.
      if (do_duplicate &&
          hit_channel_map_.find((id)) != hit_channel_map_.end()) {
        int idx = id;
        std::map<int, int>::iterator itr = hit_channel_map_.find(idx);
        double old_val = digis.at(itr->second).getPE();
        if (verbose_) {
          ldmx_log(debug) << "Got duplicate digis for channel " << idx
                          << ", with already inserted value " << old_val
                          << " and new " << digi.getPE();
        }
        if (digi.getPE() > old_val) {
          hit_channel_map_.erase(itr->first);
          if (verbose_) {
            ldmx_log(debug)
                << "Skipped duplicate digi with smaller value for channel "
                << idx;
          }
        }
      }
 
      // don't add in late hits
      if (digi.getTime() > pad_time_ + time_tolerance_) continue;
 
      hit_channel_map_.insert(std::pair<int, int>(id, i_digi));
      // the channel number is the key, the digi list index is the value
 
      if (verbose_) {
        ldmx_log(debug) << "Mapping digi hit nb " << i_digi
                        << " with energy = " << digi.getEnergy()
                        << " MeV, nPE = " << digi.getPE() << " > " << min_thr_
                        << " to key/channel " << id;
      }
    }
    i_digi++;
  }
 
  // 2. now step through all the channels in the map and cluster the hits
 
  std::map<int, int>::iterator itr;
 
  // Create the container to hold the digitized trigger scintillator hits.
  std::vector<ldmx::TrigScintCluster> trig_scint_clusters;
 
  // loop over channels
  for (itr = hit_channel_map_.begin(); itr != hit_channel_map_.end(); ++itr) {
    // this hit may have disappeared
    if (hit_channel_map_.find(itr->first) == hit_channel_map_.end()) {
      if (verbose_ > 1) {
        ldmx_log(debug) << "Attempting to use removed hit at channel "
                        << itr->first << "; skipping.";
      }
      continue;
    }
 
    // i don't like this but for now, erasing elements in the map leads, as it
    // turns out, to edge cases where i miss out on hits or run into
    // non-existing indices. so while what i do below means that i don't need to
    // erase hits, i'd rather find a way to do that and skip this book keeping:
    bool has_used = false;
    for (const auto& index : v_used_indices_) {
      if (index == itr->first) {
        if (verbose_ > 1) {
          ldmx_log(warn) << "Attempting to re-use hit at channel " << itr->first
                         << "; skipping.";
        }
        has_used = true;
      }
    }
    if (has_used) continue;
    if (verbose_ > 1) {
      ldmx_log(debug) << "\t At hit with channel nb " << itr->first << ".";
    }
 
    if (hit_channel_map_.size() ==
        0)  // we removed them all..? shouldn't ever happen
    {
      if (verbose_)
        ldmx_log(warn) << "Time flies, and all clusters have already been "
                          "removed! Unclear how we even got here; interfering "
                          "here to get out of the loop. ";
      break;
    }
 
    trigscint::TestBeamHit digi = (trigscint::TestBeamHit)digis.at(itr->second);
 
    // skip all until hit a seed
    if (digi.getPE() >= seed_) {
      if (verbose_ > 1) {
        ldmx_log(debug) << "Seeding cluster with channel " << itr->first
                        << "; content " << digi.getPE();
      }
 
      // 1.  add seeding hit to cluster
 
      addHit(itr->first, digi);
 
      if (verbose_ > 1) {
        ldmx_log(debug) << "\t itr is pointing at hit with channel nb "
                        << itr->first << ".";
      }
 
      // ----- first look back one step
 
      // we have added the hit from the neighbouring channel to the list only if
      // it's above clustering threshold so no check needed now
      std::map<int, int>::iterator itr_back =
          hit_channel_map_.find(itr->first - 1);
 
      bool has_backed = false;
 
      if (itr_back !=
          hit_channel_map_
              .end()) {  // there is an entry for the previous
                         // channel, so it had content above threshold
        // but it wasn't enough to seed a cluster. so, unambiguous that it
        // should be added here because it's its only chance to get in.
 
        // need to check again for backwards hits
        has_used = false;
        for (const auto& index : v_used_indices_) {
          if (index == itr_back->first) {
            if (verbose_ > 1) {
              ldmx_log(warn) << "Attempting to re-use hit at channel "
                             << itr_back->first << "; skipping.";
            }
            has_used = true;
          }
        }
        if (!has_used) {
          digi = (trigscint::TestBeamHit)digis.at(itr_back->second);
 
          // 2. add seed-1 to cluster
          addHit(itr_back->first, digi);
          has_backed = true;
 
          if (verbose_ > 1) {
            ldmx_log(debug) << "Added -1 channel " << itr_back->first
                            << " to cluster; content " << digi.getPE();
            ldmx_log(debug) << "\t itr is pointing at hit with channel nb "
                            << itr->first << ".";
          }
 
        }  // if seed-1 wasn't used already
      }  // there exists a lower, unused neighbour
 
      // 3. check next: if seed+1 exists && seed +2 exists,
      //    3a. if seed-1 is in already, this is a case for a split, at seed. go
      //    directly to check on seed-2, don't add more here. 3b. else. addHit
      //    (seed+1) 3c. if seed+3 exists, this is a split, at seed+1. don't add
      //    more here. 3d. else addHit(seed+2)
      // 4. if seed+1 and !seed+2 --> go to addHit(seed+1)
 
      // --- now, step 3, 4: look ahead 1 step from seed
 
      if (v_added_indices_.size() < max_width_) {
        // (in principle these don't need to be different iterators, but it
        // makes the logic easier to follow)
        std::map<int, int>::iterator itr_neighb =
            hit_channel_map_.find(itr->first + 1);
        if (itr_neighb !=
            hit_channel_map_
                .end()) {  // there is an entry for the next channel,
                           // so it had content above threshold
          // seed+1 exists
          // check if there is sth in position seed+2
          if (hit_channel_map_.find(itr_neighb->first + 1) !=
              hit_channel_map_.end()) {  // a hit with that key exists, so
                                         // seed+1 and seed+2 exist
            if (!has_backed) {  // there is no seed-1 in the cluster. room for
                                // at least seed+1, and for seed+2 only if there
                                // is no seed+3
              // 3b
              digi = (trigscint::TestBeamHit)digis.at(itr_neighb->second);
              addHit(itr_neighb->first, digi);
 
              if (verbose_ > 1) {
                ldmx_log(debug)
                    << "No -1 hit. Added +1 channel " << itr_neighb->first
                    << " to cluster; content " << digi.getPE();
                ldmx_log(debug) << "\t itr is pointing at hit with channel nb "
                                << itr->first << ".";
              }
 
              if (v_added_indices_.size() < max_width_) {
                if (hit_channel_map_.find(itr_neighb->first + 2) ==
                    hit_channel_map_
                        .end()) {  // no seed+3. also no seed-1. so add seed+2
                  // 3d.  add seed+2 to the cluster
                  itr_neighb = hit_channel_map_.find(itr->first + 2);
                  digi = (trigscint::TestBeamHit)digis.at(itr_neighb->second);
                  addHit(itr_neighb->first, digi);
                  if (verbose_ > 1) {
                    ldmx_log(debug)
                        << "No +3 hit. Added +2 channel " << itr_neighb->first
                        << " to cluster; content " << digi.getPE();
                    ldmx_log(debug)
                        << "\t itr is pointing at hit with channel nb "
                        << itr->first << ".";
                  }
                }
 
              }  // if no seed+3 --> added seed+2
            }  // if seed-1 wasn't added
          }  // if seed+2 exists. then already added seed+1.
          else {  // so: if not, then we need to add seed+1 here. (step 4)
            digi = (trigscint::TestBeamHit)digis.at(
                itr_neighb->second);  // itrNeighb hasn't moved since there was
                                      // no seed+2
            addHit(itr_neighb->first, digi);
 
            if (verbose_ > 1) {
              ldmx_log(debug)
                  << "Added +1 channel " << itr_neighb->first
                  << " as last channel to cluster; content " << digi.getPE();
              ldmx_log(debug) << "\t itr is pointing at hit with channel nb "
                              << itr->first << ".";
            }
          }
        }  // if seed+1 exists
        // 5. at this point, if clusterSize is 2 hits and seed+1 didn't exist,
        // we can afford to walk back one more step and add whatever junk was
        // there (we know it's not a seed)
        else if (has_backed &&
                 hit_channel_map_.find(itr_back->first - 1) !=
                     hit_channel_map_
                         .end()) {  // seed-1 has been added, but not seed+1,
                                    // and there is a hit in seed-2
          itr_back = hit_channel_map_.find(itr->first - 2);
          digi = (trigscint::TestBeamHit)digis.at(itr_back->second);
          addHit(itr_back->first, digi);
 
          if (verbose_ > 1) {
            ldmx_log(debug) << "Added -2 channel " << itr_back->first
                            << " to cluster; content " << digi.getPE();
          }
          if (verbose_ > 1) {
            ldmx_log(debug) << "\t itr is pointing at hit with channel nb "
                            << itr->first << ".";
          }
 
        }  // check if add in seed -2
 
      }  // if adding another hit, going forward, was allowed
 
      // done adding hits to cluster. calculate centroid
      centroid_ /= val_;  // final weighting step: divide by total
      centroid_ -= 1;     // shift back to actual channel center
 
      ldmx::TrigScintCluster cluster;
 
      if (verbose_ > 1) {
        ldmx_log(debug) << "Now have " << v_added_indices_.size()
                        << " hits in the cluster ";
      }
      cluster.setSeed(v_added_indices_.at(0));
      cluster.setIDs(v_added_indices_);
      cluster.setNHits(v_added_indices_.size());
      cluster.setCentroid(centroid_);
      cluster.setEnergy(val_e_);
      cluster.setPE(val_);
      cluster.setTime(time_ / val_);
      cluster.setBeamEfrac(beam_e_ / val_e_);
 
      trig_scint_clusters.push_back(cluster);
 
      ldmx_log(trace) << cluster;
 
      centroid_ = 0;
      val_ = 0;
      val_e_ = 0;
      beam_e_ = 0;
      time_ = 0;
      v_added_indices_.resize(
          0);  // book keep which channels have already been added to a cluster
 
      if (verbose_ > 1) {
        ldmx_log(debug)
            << "\t Finished processing of seeding hit with channel nb "
            << itr->first << ".";
      }
 
    }  // if content enough to seed a cluster
 
    if (hit_channel_map_.begin() == hit_channel_map_.end()) {
      if (verbose_)
        ldmx_log(warn) << "Time flies, and all clusters have already been "
                          "removed! Interfering here to get out of the loop. ";
      break;
    }
  }  // over channels
 
  if (trig_scint_clusters.size() > 0)
    event.add(output_collection_, trig_scint_clusters);
 
  hit_channel_map_.clear();
  v_used_indices_.resize(
      0);  // book keep which channels have already been added to a cluster
 
  return;
}

References addHit(), do_clean_hits_, ldmx::TrigScintHit::getPE(), ldmx::TrigScintCluster::setBeamEfrac(), ldmx::TrigScintCluster::setCentroid(), ldmx::TrigScintCluster::setEnergy(), ldmx::TrigScintCluster::setIDs(), ldmx::TrigScintCluster::setNHits(), ldmx::TrigScintCluster::setPE(), ldmx::TrigScintCluster::setSeed(), and ldmx::TrigScintCluster::setTime().

Member Data Documentation

◆ beam_e_

float trigscint::TestBeamClusterProducer::beam_e_ {0.}

private

Definition at line 94 of file TestBeamClusterProducer.h.

94{0.};

◆ centroid_

float trigscint::TestBeamClusterProducer::centroid_ {0.}

private

Definition at line 76 of file TestBeamClusterProducer.h.

76{0.};

◆ clusters_

std::vector<ldmx::TrigScintCluster> trigscint::TestBeamClusterProducer::clusters_

private

Definition at line 43 of file TestBeamClusterProducer.h.

◆ do_clean_hits_

bool trigscint::TestBeamClusterProducer::do_clean_hits_ {false}

private

boolean indicating whether we want to apply quality criteria from hit reconstruction

Definition at line 98 of file TestBeamClusterProducer.h.

98{false};

Referenced by configure(), and produce().

◆ hit_channel_map_

std::map<int, int> trigscint::TestBeamClusterProducer::hit_channel_map_

private

Definition at line 104 of file TestBeamClusterProducer.h.

◆ input_collection_

std::string trigscint::TestBeamClusterProducer::input_collection_

private

Definition at line 67 of file TestBeamClusterProducer.h.

◆ max_channel_id_

int trigscint::TestBeamClusterProducer::max_channel_id_ {11}

private

Definition at line 55 of file TestBeamClusterProducer.h.

55{11};

◆ max_width_

int trigscint::TestBeamClusterProducer::max_width_ {2}

private

Definition at line 52 of file TestBeamClusterProducer.h.

52{2};

◆ min_thr_

double trigscint::TestBeamClusterProducer::min_thr_ {0.}

private

Definition at line 49 of file TestBeamClusterProducer.h.

49{0.};

◆ output_collection_

std::string trigscint::TestBeamClusterProducer::output_collection_

private

Definition at line 70 of file TestBeamClusterProducer.h.

◆ pad_time_

double trigscint::TestBeamClusterProducer::pad_time_ {0.}

private

Definition at line 61 of file TestBeamClusterProducer.h.

61{0.};

◆ pass_name_

std::string trigscint::TestBeamClusterProducer::pass_name_ {""}

private

Definition at line 73 of file TestBeamClusterProducer.h.

73{""};

◆ seed_

double trigscint::TestBeamClusterProducer::seed_ {0.}

private

Definition at line 46 of file TestBeamClusterProducer.h.

46{0.};

◆ time_

float trigscint::TestBeamClusterProducer::time_ {0.}

private

Definition at line 101 of file TestBeamClusterProducer.h.

101{0.};

◆ time_tolerance_

double trigscint::TestBeamClusterProducer::time_tolerance_ {0.}

private

Definition at line 64 of file TestBeamClusterProducer.h.

64{0.};

◆ v_added_indices_

std::vector<unsigned int> trigscint::TestBeamClusterProducer::v_added_indices_

private

Definition at line 85 of file TestBeamClusterProducer.h.

◆ v_used_indices_

std::vector<unsigned int> trigscint::TestBeamClusterProducer::v_used_indices_

private

Definition at line 88 of file TestBeamClusterProducer.h.

◆ val_

float trigscint::TestBeamClusterProducer::val_ {0.}

private

Definition at line 79 of file TestBeamClusterProducer.h.

79{0.};

◆ val_e_

float trigscint::TestBeamClusterProducer::val_e_ {0.}

private

Definition at line 82 of file TestBeamClusterProducer.h.

82{0.};

◆ verbose_

int trigscint::TestBeamClusterProducer::verbose_ {0}

private

Definition at line 58 of file TestBeamClusterProducer.h.

58{0};

The documentation for this class was generated from the following files:

TrigScint/include/TrigScint/TestBeamClusterProducer.h
TrigScint/src/TrigScint/TestBeamClusterProducer.cxx

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TestBeamClusterProducer()

Member Function Documentation

◆ addHit()

◆ configure()

◆ onProcessEnd()

◆ onProcessStart()

◆ produce()

Member Data Documentation

◆ beam_e_

◆ centroid_

◆ clusters_

◆ do_clean_hits_

◆ hit_channel_map_

◆ input_collection_

◆ max_channel_id_

◆ max_width_

◆ min_thr_

◆ output_collection_

◆ pad_time_

◆ pass_name_

◆ seed_

◆ time_

◆ time_tolerance_

◆ v_added_indices_

◆ v_used_indices_

◆ val_

◆ val_e_

◆ verbose_