flashmatch::FlashMatchManager Class Reference

#include <FlashMatchManager.h>

Inheritance diagram for flashmatch::FlashMatchManager:

Public Member Functions
	FlashMatchManager (const std::string name="FlashMatchManager")
	Default constructor. More...
	~FlashMatchManager ()
	Default destructor. More...
const std::string &	Name () const
	Name getter. More...
void	Configure (const Config_t &cfg)
	Configuration. More...
flashmatch::BaseAlgorithm *	GetAlgo (flashmatch::Algorithm_t type)
	Algorithm getter. More...
flashmatch::BaseAlgorithm *	GetCustomAlgo (std::string name)
	Custom algorithm getter. More...
void	Emplace (flashmatch::QCluster_t &&obj)
	Emplacer of a TPC object (hidden from ROOT5 CINT) More...
void	Emplace (flashmatch::Flash_t &&obj)
	Emplacer of a TPC object (hidden from ROOT5 CINT) More...
void	Add (flashmatch::QCluster_t &obj)
	Adder of a TPC object. More...
void	Add (flashmatch::Flash_t &obj)
	Adder of a TPC object. More...
std::vector < flashmatch::FlashMatch_t >	Match ()
void	Reset ()
	Clears locally kept TPC object (QClusterArray_t) and flash (FlashArray_t), both provided by a user. More...
void	CanReuseFlash (bool ok=true)
	Configuration option: true => allows an assignment of the same flash to multiple TPC objects. More...
void	PrintConfig ()
const QClusterArray_t &	QClusterArray () const
	Access to an input: TPC objects in the form of QClusterArray_t. More...
const FlashArray_t &	FlashArray () const
	Access to an input: PMT objects in the form of FlashArray_t. More...
const std::vector< std::vector < flashmatch::FlashMatch_t > >	FullResultTPCFlash () const
	Access to a full results (if configured to store) for [tpc][flash] indexing. More...
const std::vector< std::vector < flashmatch::FlashMatch_t > >	FullResultFlashTPC () const
	Access to a full results (if configured to store) for [flash][tpc] indexing. More...
void	SetChannelMask (std::vector< int >)
	Sets the op channels to be used for matching. More...
void	SetTPCCryo (int tpc, int _cryo)
	Sets the TPC and Cryo numbers. More...
void	SetUncoatedPMTs (std::vector< int > ch_uncoated)
	Sets the channels sensitive to visible light. More...
void	SetSemiAnalyticalModel (std::unique_ptr< SemiAnalyticalModel > model)
Public Member Functions inherited from flashmatch::LoggerFeature
	LoggerFeature (const std::string logger_name="LoggerFeature")
	Default constructor. More...
	LoggerFeature (const LoggerFeature &original)
	Default copy constructor. More...
virtual	~LoggerFeature ()
	Default destructor. More...
const flashmatch::logger &	logger () const
	Logger getter. More...
void	set_verbosity (::flashmatch::msg::Level_t level)
	Verbosity level. More...
const std::string &	name () const
	Name getter, defined in a logger instance attribute. More...

Private Member Functions
void	AddCustomAlgo (BaseAlgorithm *alg)

Private Attributes
BaseFlashFilter *	_alg_flash_filter
	Flash filter algorithm. More...
BaseTPCFilter *	_alg_tpc_filter
	TPC filter algorithm. More...
BaseProhibitAlgo *	_alg_match_prohibit
	Flash matchinig prohibit algorithm. More...
BaseFlashMatch *	_alg_flash_match
	Flash matching algorithm. More...
BaseFlashHypothesis *	_alg_flash_hypothesis
	Flash hypothesis algorithm. More...
std::map< std::string, flashmatch::BaseAlgorithm * >	_custom_alg_m
QClusterArray_t	_tpc_object_v
	TPC object information collection (provided by a user) More...
FlashArray_t	_flash_v
	Flash object information collection (provided by a user) More...
bool	_allow_reuse_flash
	Configuration option to allow re-use of a flash (i.e. 1 flash can be assigned to multiple TPC object) More...
bool	_configured
	Configuration readiness flag. More...
std::string	_config_file
	Configuration file. More...
std::string	_name
	Name. More...
bool	_store_full
	Request boolean to store full matching result (per Match function call) More...
std::vector< std::vector < flashmatch::FlashMatch_t > >	_res_tpc_flash_v
	Full result container indexed by [tpc][flash]. More...
std::vector< std::vector < flashmatch::FlashMatch_t > >	_res_flash_tpc_v
	Full result container indexed by [flash][tpc]. More...
int	_tpc = 0
	TPC number where to perform the matching. More...
int	_cryo = 0
	Cryo number where to perform the matching. More...

Detailed Description

Definition at line 29 of file FlashMatchManager.h.

Constructor & Destructor Documentation

flashmatch::FlashMatchManager::FlashMatchManager

(

const std::string

name = "FlashMatchManager"

)

Default constructor.

Definition at line 20 of file FlashMatchManager.cxx.

    : LoggerFeature(name)
    , _alg_flash_filter(nullptr)
    , _alg_tpc_filter(nullptr)
    , _alg_match_prohibit(nullptr)
    , _alg_flash_match(nullptr)
    , _alg_flash_hypothesis(nullptr)
    , _configured(false)
    , _name(name)
  {
    _allow_reuse_flash = true;
  }

flashmatch::FlashMatchManager::~FlashMatchManager ( )

inline

Default destructor.

Definition at line 37 of file FlashMatchManager.h.

{}

Member Function Documentation

void flashmatch::FlashMatchManager::Add

(

flashmatch::QCluster_t &

obj

)

Adder of a TPC object.

Definition at line 187 of file FlashMatchManager.cxx.

  { _tpc_object_v.push_back(obj); }

void flashmatch::FlashMatchManager::Add

(

flashmatch::Flash_t &

obj

)

Adder of a TPC object.

Definition at line 193 of file FlashMatchManager.cxx.

  {
    if(!obj.Valid()) throw OpT0FinderException("Invalid Flash_t object cannot be registered!");
    _flash_v.push_back(obj);
  }

void flashmatch::FlashMatchManager::AddCustomAlgo ( BaseAlgorithm *  alg )

private

Definition at line 82 of file FlashMatchManager.cxx.

  {
    if(_custom_alg_m.find(alg->AlgorithmName()) != _custom_alg_m.end()) {
      std::stringstream ss;
      ss << "Duplicate name: " << alg->AlgorithmName() << std::endl;
      throw OpT0FinderException(ss.str());
      }
    _custom_alg_m[alg->AlgorithmName()] = alg;
  }

void flashmatch::FlashMatchManager::CanReuseFlash ( bool  ok = true )

inline

Configuration option: true => allows an assignment of the same flash to multiple TPC objects.

Definition at line 77 of file FlashMatchManager.h.

    { _allow_reuse_flash = ok; }

void flashmatch::FlashMatchManager::Configure

(

const Config_t &

cfg

)

Configuration.

Definition at line 92 of file FlashMatchManager.cxx.

  {
    /*
    ::fcllite::ConfigManager cfg_mgr("FlashMatchManager");

    cfg_mgr.AddCfgFile(_config_file);

    auto const& main_cfg = cfg_mgr.Config();
    */
    auto const& mgr_cfg = main_cfg.get<flashmatch::Config_t>(Name());

    _allow_reuse_flash = mgr_cfg.get<bool>("AllowReuseFlash");
    this->set_verbosity((msg::Level_t)(mgr_cfg.get<unsigned int>("Verbosity")));
    _store_full = mgr_cfg.get<bool>("StoreFullResult");

    auto const flash_filter_name = mgr_cfg.get<std::string>("FlashFilterAlgo","");
    auto const tpc_filter_name   = mgr_cfg.get<std::string>("TPCFilterAlgo","");
    auto const prohibit_name     = mgr_cfg.get<std::string>("ProhibitAlgo","");
    auto const hypothesis_name   = mgr_cfg.get<std::string>("HypothesisAlgo","");
    auto const match_name        = mgr_cfg.get<std::string>("MatchAlgo","");
    std::vector<std::string> custom_algo_v;
    custom_algo_v = mgr_cfg.get<std::vector<std::string> >("CustomAlgo",custom_algo_v);

    if(!flash_filter_name.empty()) _alg_flash_filter     = FlashFilterFactory::get().create(flash_filter_name,flash_filter_name);
    if(!tpc_filter_name.empty()  ) _alg_tpc_filter       = TPCFilterFactory::get().create(tpc_filter_name,tpc_filter_name);
    if(!prohibit_name.empty()    ) _alg_match_prohibit   = FlashProhibitFactory::get().create(prohibit_name,prohibit_name);
    if(!hypothesis_name.empty()  ) _alg_flash_hypothesis = FlashHypothesisFactory::get().create(hypothesis_name,hypothesis_name);
    if(!match_name.empty()       ) _alg_flash_match      = FlashMatchFactory::get().create(match_name,match_name);
    for(auto const& name : custom_algo_v)
      if(!name.empty()) AddCustomAlgo(CustomAlgoFactory::get().create(name,name));

    // checks
    if (_alg_match_prohibit)
      _alg_match_prohibit->Configure(main_cfg.get<flashmatch::Config_t>(_alg_match_prohibit->AlgorithmName()));

    if (_alg_flash_hypothesis)
      _alg_flash_hypothesis->Configure(main_cfg.get<flashmatch::Config_t>(_alg_flash_hypothesis->AlgorithmName()));

    if (_alg_flash_match) {
      _alg_flash_match->SetFlashHypothesis(_alg_flash_hypothesis);
      _alg_flash_match->Configure(main_cfg.get<flashmatch::Config_t>(_alg_flash_match->AlgorithmName()));
    }

    for (auto& name_ptr : _custom_alg_m)
      name_ptr.second->Configure(main_cfg.get<flashmatch::Config_t>(name_ptr.first));

    _configured = true;
  }

void flashmatch::FlashMatchManager::Emplace

(

flashmatch::QCluster_t &&

obj

)

Emplacer of a TPC object (hidden from ROOT5 CINT)

Definition at line 190 of file FlashMatchManager.cxx.

  { _tpc_object_v.emplace_back(std::move(obj)); }

void flashmatch::FlashMatchManager::Emplace

(

flashmatch::Flash_t &&

obj

)

Emplacer of a TPC object (hidden from ROOT5 CINT)

Definition at line 199 of file FlashMatchManager.cxx.

  {
    if(!obj.Valid()) throw OpT0FinderException("Invalid Flash_t object cannot be registered!");
    _flash_v.emplace_back(std::move(obj));
  }

const FlashArray_t& flashmatch::FlashMatchManager::FlashArray ( ) const

inline

Access to an input: PMT objects in the form of FlashArray_t.

Definition at line 86 of file FlashMatchManager.h.

{ return _flash_v; }

const std::vector<std::vector<flashmatch::FlashMatch_t> > flashmatch::FlashMatchManager::FullResultFlashTPC ( ) const

inline

Access to a full results (if configured to store) for [flash][tpc] indexing.

Definition at line 93 of file FlashMatchManager.h.

    { return _res_flash_tpc_v; }

const std::vector<std::vector<flashmatch::FlashMatch_t> > flashmatch::FlashMatchManager::FullResultTPCFlash ( ) const

inline

Access to a full results (if configured to store) for [tpc][flash] indexing.

Definition at line 89 of file FlashMatchManager.h.

    { return _res_tpc_flash_v; }

BaseAlgorithm * flashmatch::FlashMatchManager::GetAlgo

(

flashmatch::Algorithm_t

type

)

Algorithm getter.

Definition at line 141 of file FlashMatchManager.cxx.

  {
    if (!_configured)
      FLASH_WARNING() << "Algorithm may be not configured yet!" << std::endl;

    // Figure out the type of a provided algorithm
    switch (type) {

    // TPC filter
    case kTPCFilter:
      return _alg_tpc_filter;

    // Flash filter
    case kFlashFilter:
      return _alg_flash_filter;

    // Match prohibit algo
    case kMatchProhibit:
      return _alg_match_prohibit;

    // Flash matching
    case kFlashMatch:
      return _alg_flash_match;

    // Flash hypothesis
    case kFlashHypothesis:
      return _alg_flash_hypothesis;

    // Fuck it
    default:
      std::stringstream ss;
      ss << "Unsupported algorithm type: " << type;
      throw OpT0FinderException(ss.str());
    }
    return nullptr;
  }

flashmatch::BaseAlgorithm * flashmatch::FlashMatchManager::GetCustomAlgo

(

std::string

name

)

Custom algorithm getter.

Definition at line 178 of file FlashMatchManager.cxx.

  {
    if(_custom_alg_m.find(name) == _custom_alg_m.end()) {
      FLASH_ERROR() << "Algorithm name " << name << " not found!" << std::endl;
      throw OpT0FinderException();
    }
    return _custom_alg_m[name];
  }

std::vector< FlashMatch_t > flashmatch::FlashMatchManager::Match

(

)

CORE FUNCTION: executes algorithms to find a match of TPC object and flash provided by users.
The execution takes following steps:
0) TPC filter algorithm if provided (optional)
1) Flash filter algorithm if provided (optional)
3) Flash matching algorithm (required)
4) Returns match information for created TPC object & flash pair which respects the outcome of 3)

Definition at line 206 of file FlashMatchManager.cxx.

  {
    // Clear some history variables
    _res_tpc_flash_v.clear();
    _res_flash_tpc_v.clear();
    if(_store_full) {
      _res_tpc_flash_v.resize(_tpc_object_v.size(),std::vector<flashmatch::FlashMatch_t>(_flash_v.size()));
      _res_flash_tpc_v.resize(_flash_v.size(),std::vector<flashmatch::FlashMatch_t>(_tpc_object_v.size()));
    }

    // Create also a result container
    std::vector<FlashMatch_t> result;

    if (!_alg_flash_match)
      throw OpT0FinderException("Flash matching algorithm is reuqired! (not attached)");
    if (!_alg_flash_hypothesis)
      throw OpT0FinderException("Flash hypothesis algorithm is required! (not attached)");

    if (!_configured)
      throw OpT0FinderException("Have not configured yet!");

    if(_tpc_object_v.empty() || _flash_v.empty()) return result;

    //
    // Filter stage: for both TPC and Flash
    //

    // IDArray_t to store candidate list of tpc/flash to be used for matching
    IDArray_t tpc_index_v;
    IDArray_t flash_index_v;

    // Figure out which tpc object to use: if algorithm provided, ask it. Else use all.
    if (_alg_tpc_filter)
      tpc_index_v = _alg_tpc_filter->Filter(_tpc_object_v);
    else {
      tpc_index_v.reserve(_tpc_object_v.size());
      for (size_t i = 0; i < _tpc_object_v.size(); ++i) tpc_index_v.push_back(i);
    }

    FLASH_INFO() << "TPC Filter: " << _tpc_object_v.size() << " => " << tpc_index_v.size() << std::endl;

    // Figure out which flash to use: if algorithm provided, ask it. Else use all
    if (_alg_flash_filter)
      flash_index_v = _alg_flash_filter->Filter(_flash_v);
    else {
      flash_index_v.reserve(_flash_v.size());
      for (size_t i = 0; i < _flash_v.size(); ++i) flash_index_v.push_back(i);
    }
    FLASH_INFO() << "Flash Filter: " << _flash_v.size() << " => " << flash_index_v.size() << std::endl;

    //
    // Flash matching stage
    //

    // use multi-map for possible equally-scored matches
    std::multimap<double, FlashMatch_t> score_map;

    // Double loop over a list of tpc object & flash
    // Call matching function to inspect the compatibility.
    for (size_t tpc_index = 0; tpc_index < tpc_index_v.size(); ++tpc_index) {
      // Loop over flash list
      for (auto const& flash_index : flash_index_v) {
        FLASH_INFO() << "TPC index " << tpc_index << ", Flash index " << flash_index << std::endl;
        auto const& tpc   = _tpc_object_v[tpc_index_v[tpc_index]]; // Retrieve TPC object
        auto const& flash = _flash_v[flash_index];    // Retrieve flash

        if (tpc.size() == 0 )
          continue;

        // run the match-prohibit algo first
        if (_alg_match_prohibit) {
          bool compat = _alg_match_prohibit->MatchCompatible( tpc, flash);
          if (compat == false) {
            FLASH_INFO() << "Match not compatible. " << std::endl;
            continue;
          }
        }
        auto start = high_resolution_clock::now();
        auto res = _alg_flash_match->Match( tpc, flash ); // Run matching
        auto end = high_resolution_clock::now();
        auto duration = duration_cast<nanoseconds>(end - start);
        FLASH_INFO() << "Match duration = " << duration.count() << "ns" << std::endl;

        // ignore this match if the score is <= 0
        if (res.score <= 0) continue;

        // Else we store this match. Assign TPC & flash index info
        res.tpc_id = tpc_index_v[tpc_index];//_index;
        res.flash_id = flash_index;//_index;
        res.duration = duration.count();


        if(_store_full) {
          _res_tpc_flash_v[res.tpc_id][res.flash_id] = res;
          _res_flash_tpc_v[res.flash_id][res.tpc_id] = res;
        }
        // For ordering purpose, take an inverse of the score for sorting
        score_map.emplace( 1. / res.score, res);

        FLASH_DEBUG() << "Candidate Match: "
                      << " TPC=" << tpc_index << " (" << tpc.min_x() << " min x)" << " @ " << tpc.time
                      << " with Flash=" << flash_index << " @ " << flash.time
                      << " ... Score=" << res.score
                      << " ... PE=" << flash.TotalPE()
                      << std::endl;
      }
    }

    // We have a score-ordered list of match information at this point.
    // Prepare return match information by respecting a score of each possible match.
    // Note _allow_reuse_flash becomes relevant here as well.

    // Create a std::set of tpc/flash IDs to keep track of already-matched tpc/flash input.
    std::set<ID_t> tpc_used, flash_used;
    result.reserve(tpc_index_v.size());
    // Loop over score map created with matching algorithm
    for (auto& score_info : score_map) {

      auto&       match_info  = score_info.second;   // match information
      auto const& tpc_index   = match_info.tpc_id;   // matched tpc original id
      auto const& flash_index = match_info.flash_id; // matched flash original id

//      std::cout<<"tpc_index and flash_index : "<<tpc_index<<", "<<flash_index<<std::endl ;

      // If this tpc object is already assigned (=better match found), ignore
      if (tpc_used.find(tpc_index) != tpc_used.end()) continue;

      // If this flash object is already assigned + re-use is not allowed, ignore
      if (!_allow_reuse_flash && flash_used.find(flash_index) != flash_used.end()) continue;

      // Reaching this point means a new match. Yay!
      FLASH_INFO () << "Concrete Match: " << " TPC=" << tpc_index << " Flash=" << flash_index
                    << " Score=" << match_info.score
                    << std::endl;

      // Register to a list of a "used" flash and tpc info
      tpc_used.insert(tpc_index);
      flash_used.insert(flash_index);

      // std::move matched info from the map to result vector
      result.emplace_back( match_info );

    }
    // Return result
    return result;

  }

const std::string & flashmatch::FlashMatchManager::Name

(

)

const

Name getter.

Definition at line 33 of file FlashMatchManager.cxx.

  { return _name; }

void flashmatch::FlashMatchManager::PrintConfig

(

)

Definition at line 354 of file FlashMatchManager.cxx.

                                      {

    std::cout << "---- FLASH MATCH MANAGER PRINTING CONFIG     ----" << std::endl
              << "_allow_reuse_flash = " << _allow_reuse_flash << std::endl
              << "_name = " << _name << std::endl
              << "_alg_flash_filter?" << std::endl;
    if (_alg_flash_filter)
      std::cout << "\t" << _alg_flash_filter->AlgorithmName() << std::endl;
    std::cout << "_alg_tpc_filter?" << std::endl;
    if (_alg_tpc_filter)
      std::cout << "\t" << _alg_tpc_filter->AlgorithmName() << std::endl;
    std::cout << "_alg_match_prohibit?" << std::endl;
    if (_alg_match_prohibit)
      std::cout << "\t" << _alg_match_prohibit->AlgorithmName() << std::endl;
    std::cout << "_alg_flash_hypothesis?" << std::endl;
    if (_alg_flash_hypothesis)
      std::cout << "\t" << _alg_flash_hypothesis->AlgorithmName() << std::endl;
    std::cout << "_alg_flash_match?" << std::endl;
    if (_alg_flash_match)
      std::cout << "\t" << _alg_flash_match->AlgorithmName() << std::endl;
    std::cout << "_custom_alg_m?" << std::endl;
    for (auto& name_ptr : _custom_alg_m)
      std::cout << "\t" << name_ptr.first << std::endl;
    std::cout << "---- END FLASH MATCH MANAGER PRINTING CONFIG ----" << std::endl;
  }

const QClusterArray_t& flashmatch::FlashMatchManager::QClusterArray ( ) const

inline

Access to an input: TPC objects in the form of QClusterArray_t.

Definition at line 83 of file FlashMatchManager.h.

{ return _tpc_object_v; }

void flashmatch::FlashMatchManager::Reset ( )

inline

Clears locally kept TPC object (QClusterArray_t) and flash (FlashArray_t), both provided by a user.

Definition at line 73 of file FlashMatchManager.h.

    { _tpc_object_v.clear(); _flash_v.clear(); }

void flashmatch::FlashMatchManager::SetChannelMask

(

std::vector< int >

ch_mask

)

Sets the op channels to be used for matching.

Definition at line 380 of file FlashMatchManager.cxx.

                                                               {

    if (!_alg_flash_hypothesis) {
      throw OpT0FinderException("Flash hypothesis algorithm is required to set channel mask!");
    }

    _alg_flash_hypothesis->SetChannelMask(ch_mask);
  }

void flashmatch::FlashMatchManager::SetSemiAnalyticalModel

(

std::unique_ptr< SemiAnalyticalModel >

model

)

Definition at line 405 of file FlashMatchManager.cxx.

                                                                                         {
    if (_alg_flash_hypothesis) {
      _alg_flash_hypothesis->SetSemiAnalyticalModel(std::move(model));
    }
  }

void flashmatch::FlashMatchManager::SetTPCCryo	(	int	tpc,
		int	_cryo
	)

Sets the TPC and Cryo numbers.

Definition at line 389 of file FlashMatchManager.cxx.

                                                      {
    _tpc = tpc;
    _cryo = cryo;

    if (_alg_flash_match) {
      _alg_flash_match->SetTPCCryo(_tpc, _cryo);
    }
  }

void flashmatch::FlashMatchManager::SetUncoatedPMTs

(

std::vector< int >

ch_uncoated

)

Sets the channels sensitive to visible light.

Definition at line 398 of file FlashMatchManager.cxx.

                                                                    {
    if (_alg_flash_hypothesis) {
      _alg_flash_hypothesis->SetUncoatedPMTs(ch_uncoated);
    }
  }

Member Data Documentation

BaseFlashFilter* flashmatch::FlashMatchManager::_alg_flash_filter

private

Flash filter algorithm.

Definition at line 113 of file FlashMatchManager.h.

BaseFlashHypothesis* flashmatch::FlashMatchManager::_alg_flash_hypothesis

private

Flash hypothesis algorithm.

Definition at line 117 of file FlashMatchManager.h.

BaseFlashMatch* flashmatch::FlashMatchManager::_alg_flash_match

private

Flash matching algorithm.

Definition at line 116 of file FlashMatchManager.h.

BaseProhibitAlgo* flashmatch::FlashMatchManager::_alg_match_prohibit

private

Flash matchinig prohibit algorithm.

Definition at line 115 of file FlashMatchManager.h.

BaseTPCFilter* flashmatch::FlashMatchManager::_alg_tpc_filter

private

TPC filter algorithm.

Definition at line 114 of file FlashMatchManager.h.

bool flashmatch::FlashMatchManager::_allow_reuse_flash

private

Configuration option to allow re-use of a flash (i.e. 1 flash can be assigned to multiple TPC object)

Definition at line 129 of file FlashMatchManager.h.

std::string flashmatch::FlashMatchManager::_config_file

private

Configuration file.

Definition at line 133 of file FlashMatchManager.h.

bool flashmatch::FlashMatchManager::_configured

private

Configuration readiness flag.

Definition at line 131 of file FlashMatchManager.h.

int flashmatch::FlashMatchManager::_cryo = 0

private

Cryo number where to perform the matching.

Definition at line 145 of file FlashMatchManager.h.

std::map<std::string,flashmatch::BaseAlgorithm*> flashmatch::FlashMatchManager::_custom_alg_m

private

A set of custom algorithms (not to be executed but to be configured)

Definition at line 122 of file FlashMatchManager.h.

FlashArray_t flashmatch::FlashMatchManager::_flash_v

private

Flash object information collection (provided by a user)

Definition at line 127 of file FlashMatchManager.h.

std::string flashmatch::FlashMatchManager::_name

private

Name.

Definition at line 135 of file FlashMatchManager.h.

std::vector<std::vector<flashmatch::FlashMatch_t> > flashmatch::FlashMatchManager::_res_flash_tpc_v

private

Full result container indexed by [flash][tpc].

Definition at line 141 of file FlashMatchManager.h.

std::vector<std::vector<flashmatch::FlashMatch_t> > flashmatch::FlashMatchManager::_res_tpc_flash_v

private

Full result container indexed by [tpc][flash].

Definition at line 139 of file FlashMatchManager.h.

bool flashmatch::FlashMatchManager::_store_full

private

Request boolean to store full matching result (per Match function call)

Definition at line 137 of file FlashMatchManager.h.

int flashmatch::FlashMatchManager::_tpc = 0

private

TPC number where to perform the matching.

Definition at line 143 of file FlashMatchManager.h.

QClusterArray_t flashmatch::FlashMatchManager::_tpc_object_v

private

TPC object information collection (provided by a user)

Definition at line 125 of file FlashMatchManager.h.

---

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

• FlashMatchManager.h
• FlashMatchManager.cxx