AsicBackgroundLibraryCreator Class Reference

Finds ASICs with single signal hit, records info to the library. More...

#include <AsicBackgroundLibraryCreator.h>

Inheritance diagram for AsicBackgroundLibraryCreator:

Collaboration diagram for AsicBackgroundLibraryCreator:

Public Types
using	IOTypes = std::tuple< AIOTypes... >
	Types that should be served to apply on invokation.
using	IOVectors = std::tuple< std::vector< AIOTypes >... >
	Vector types that should be served to apply on invokation.

Public Member Functions
	AsicBackgroundLibraryCreator ()=default
	Default constructor.
void	initialize () final
	Access database here, open library for writing:
void	beginRun () final
	Reload channel map if needed.
std::string	getDescription () final
	Short description of the findlet.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters to a module.
void	apply (const std::vector< CDCWireHit > &wireHits, const std::vector< CDCTrack > &tracks) final
	Main algorithm marking hit as background.
void	terminate () final
	write out the library
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
void	beginEvent () override
	Receive and dispatch signal for the start of a new event.
void	endRun () override
	Receive and dispatch signal for the end of the run.

Protected Types
using	ToVector = typename ToVectorImpl< T >::Type
	Short hand for ToRangeImpl.

Protected Member Functions
void	addProcessingSignalListener (ProcessingSignalListener *psl)
	Register a processing signal listener to be notified.
int	getNProcessingSignalListener ()
	Get the number of currently registered listeners.

Private Types
using	Super = Findlet< const CDCWireHit, const CDCTrack >
	Type of the base class.

Private Member Functions
void	selectAsic (const std::vector< const CDCWireHit * > &wireHits, const std::vector< CDCTrack > &tracks)
	Algorithm to select suitable ASIC for library creation. More...

Private Attributes
std::unique_ptr< DBArray< CDCChannelMap > >	m_channelMapFromDB
	Channel map retrieved from DB.
std::map< int, std::pair< int, int > >	m_map
	map from ewire to board/channel ID
std::string	m_library_name {"CDCAsicLibrary.root"}
	output library name
size_t	m_minimal_hit_number {1}
	min. number of hits in ASIC for background check
double	m_distance_signal_max {0.25}
	maximal distance from track to signal hit
double	m_distance_background_min {0.5}
	minimal distance from track to background hit
bool	m_use_axial_hits_only {false}
	use axial layers only
bool	m_write_extra_vars {false}
	extra vars to the library
size_t	m_minimal_hits_on_track {40}
	min. number of hits on the track
std::unique_ptr< Recorder >	m_recorder
	Recorder for the root output.
asicChannel	m_asic_info [8]
	all 8 channels
UChar_t	m_board {0}
	signal boardID
UChar_t	m_channel {0}
	signal channelID
UChar_t	m_n_hit {0}
	For debuging, store also number of channels with hits.
float	m_dist_signal {0}
	Distance to signal hit.
float	m_dist_bg {0}
	min. distance to non-linked hits
Short_t	m_adc_sig {0}
	ADC of the signal.
Short_t	m_adc_max_bg {0}
	Max. ADC background.
UShort_t	m_n_hit_track {0}
	Number of hits on the track.
std::vector< ProcessingSignalListener * >	m_subordinaryProcessingSignalListeners
	References to subordinary signal processing listener contained in this findlet.
bool	m_initialized = false
	Flag to keep track whether initialization happend before.
bool	m_terminated = false
	Flag to keep track whether termination happend before.
std::string	m_initializedAs
	Name of the type during initialisation.

Detailed Description

Finds ASICs with single signal hit, records info to the library.

Definition at line 29 of file AsicBackgroundLibraryCreator.h.

Member Function Documentation

selectAsic()

void selectAsic ( const std::vector< const CDCWireHit * > &  wireHits, const std::vector< CDCTrack > &  tracks  )

private

Algorithm to select suitable ASIC for library creation.

This is abnormal situation, detected for few runs, related to CDC unpacker. Hits are to be marked as background.

Definition at line 178 of file AsicBackgroundLibraryCreator.cc.

{
 
  if (wireHits.size() < m_minimal_hit_number) {
    return;
  };
 
  if (wireHits.size() > 8) {
    B2ERROR("Number of hits per asic should not exceed 8, observe too many hits." << LogVar("nHits", wireHits.size()));
    return;
  }
 
 
  // count taken non-background hits:
  int count = 0;
  const CDCWireHit* signal = nullptr;
  for (auto& hit : wireHits) {
    if (!(*hit)->hasBackgroundFlag() && (*hit)->hasTakenFlag()) {
      count += 1;
      signal = hit;
    }
  }
 
  // require one and only one taken hit
  if (count != 1) {
    return;
  }
 
 
  // check if only axial hits are used:
 
  if ((!signal->isAxial()) && m_use_axial_hits_only) {
    return;
  }
 
  // find the track to which this hit belongs
  const CDCTrack* signalTrack = nullptr;
  for (auto& track : tracks) {
    for (auto& hit : track) {
      if (&hit.getWireHit() == signal) {
        signalTrack = &track;
        break;
      }
    }
    if (signalTrack != nullptr) {
      break;
    }
  }
 
  if (signalTrack == nullptr) {
    B2DEBUG(29, "AsicBackgroundLibraryCreator::No track found for the signal hit");
    return;
  }
 
  m_n_hit_track = signalTrack->size();
 
  if (m_n_hit_track < m_minimal_hits_on_track) return;
 
  // check the distance from the track to each signal hit
  const auto& trajectory = signalTrack->getStartTrajectory3D();
 
  m_dist_bg = 1000.;
 
  for (auto& hit : wireHits) {
 
    const float dist = getDist2D(trajectory, hit);
 
 
    if (hit == signal) {
      m_dist_signal = dist;
      if (dist > m_distance_signal_max) return;
    } else {
      m_dist_bg = min(m_dist_bg, dist);
      if (dist < m_distance_background_min) return;
    }
  }
 
 
  // Ok, passes all cuts !
 
  // reset the library entries
  for (auto& channel : m_asic_info) {
    channel.TDC = -1;
    channel.ADC = -1;
    channel.TOT = -1;
  }
 
  // add to the library
 
  m_n_hit = wireHits.size();
 
  m_adc_max_bg = 0;
  for (auto& hit : wireHits) {
    auto eWire = hit->getWireID().getEWire();
    auto channel = m_map[eWire].second;
    auto asicCH = channel % 8;
    m_asic_info[asicCH].ADC = hit->getHit()->getADCCount();
    m_asic_info[asicCH].TDC = hit->getHit()->getTDCCount();
    m_asic_info[asicCH].TOT = hit->getHit()->getTOT();
 
    if (hit != signal) {
      m_adc_max_bg = max(m_adc_max_bg, m_asic_info[asicCH].ADC);
    }
  }
  // also signal hit info
  auto eWire = signal->getWireID().getEWire();
  m_channel = m_map[eWire].second;
  m_board   = m_map[eWire].first;
  m_adc_sig = signal->getHit()->getADCCount();
 
  // make sure that ADC of the signal is >= than ADC of the background:
  if (m_adc_sig < m_adc_max_bg) return;
 
  // write out
  m_recorder->capture();
}

---

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

• tracking/trackFindingCDC/findlets/complete/include/AsicBackgroundLibraryCreator.h
• tracking/trackFindingCDC/findlets/complete/src/AsicBackgroundLibraryCreator.cc