icarus::TriggerConfigurationExtractor Class Reference

Class to extract PMT readout board configuration. More...

#include <TriggerConfigurationExtractor.h>

Inheritance diagram for icarus::TriggerConfigurationExtractor:

Public Member Functions
	TriggerConfigurationExtractor (std::string const &expectedFragmentType="ICARUSTriggerUDP")
	Learns the name of the trigger fragment type. More...
Public Member Functions inherited from icarus::TriggerConfigurationExtractorBase
ConfigurationData_t	extract (fhicl::ParameterSet const &config) const
	Extracts all supported Trigger configuration from config. More...

Private Member Functions
icarus::TriggerConfiguration	extractTriggerConfiguration (fhicl::ParameterSet const &pset) const
	Extracts trigger readout board configuration from pset. More...
std::optional < fhicl::ParameterSet >	readTriggerConfig (fhicl::ParameterSet const &pset, std::string const &key) const
	Returns the specified Trigger readout board configuration. More...
unsigned long	parsePrescaleString (std::string prescaleString, std::size_t source) const
unsigned int	parseWindowMode (std::string bitStr) const

Private Attributes
std::string const	fExpectedFragmentType

Static Private Attributes
static std::vector< std::regex > const	ConfigurationNames { std::regex{ "icarustrigger.*" } }
	Regular expressions matching all names of supported Trigger configurations. More...

Interface
icarus::TriggerConfiguration	extract (fhicl::ParameterSet const &config) const
	Extracts all supported Trigger configuration from config. More...
static bool	mayHaveConfiguration (fhicl::ParameterSet const &pset)
	Returns whether pset may contain the needed configuration. More...
static bool	isGoodConfiguration (fhicl::ParameterSet const &pset, std::string const &key)
	Returns whether the specified key of pset is a good configuration. More...

Additional Inherited Members
Public Types inherited from icarus::TriggerConfigurationExtractorBase
using	ConfigurationData_t = icarus::TriggerConfiguration
Static Public Member Functions inherited from icarus::TriggerConfigurationExtractorBase
static fhicl::ParameterSet	convertConfigurationDocuments (fhicl::ParameterSet const &container, std::string const &configListKey, std::initializer_list< std::regex const > components)
	Returns a parameter set with the content of configuration_documents key from container. More...
template<typename RBegin , typename REnd >
static bool	matchKey (std::string const &key, RBegin rbegin, REnd rend)
static bool	mayHaveConfiguration (fhicl::ParameterSet const &pset)
	Returns whether pset may contain the needed configuration. More...

Detailed Description

Class to extract PMT readout board configuration.

This is an example of PMT readout board configuration taken from ICARUS run 4774 (destinations and metrics have been omitted):

*daq: {
   fragment_receiver: {

      ....

      fpga_init_params: {
         MajLevelBeamCryo1: {
            name: "Majority level inside Beam Gate cryo1"
            value: "5"
         }
         MajLevelBeamCryo2: {
            name: "Majority level inside Beam Gate cryo2"
            value: "5"
         }
         MajLevelEnableCryo1: {
            name: "Majority level inside enable and outside Beam Gate cryo1"
            value: "10"
         }
         MajLevelEnableCryo2: {
            name: "Majority level inside enable and outside Beam Gate cryo2"
            value: "10"
         }
         MajorityTriggerType: {
            name: "Majority Trigger Type"
            value: "majo1or2"
         }
         RunType: {
            name: "Run type"
            value: "Majority"
         }
         SlidingWindowCryo1: {
            name: "Sliding window option cryo1"
            value: "Separated Window"
         }
         SlidingWindowCryo2: {
            name: "Sliding window option cryo2"
            value: "Separated Window"
         }
         Veto: {
            name: "Veto beam gate [ns]"
            value: "4000"
         }
      }

      ....

      generator: "ICARUSTriggerUDP"

      ....    

      spexi_init_params: {
         BNB1DOffset: {
            name: "BNB ($1D) Early Warning Offset"
            value: "0"
         }
         BNBBESOffset: {
            name: "BNB (gatedBES) Early Warning Offset"
            value: "0"
         }
         BNBBeamWidth: {
            name: "BNB Beam Gate Width [ns]"
            value: "8000"
         }
         BNBEnableWidth: {
            name: "BNB Enable Gate Width [ns]"
            value: "2000000"
         }
         GateSelection: {
            name: "Gate Selection [hex]"
            value: "FF"
         }
         MI12Ethertype: {
            name: "MI12 Ethertype"
            value: "5752"
         }
         MI12MACAddressLSB: {
            name: "MI12 MAC Address (LSB)"
            value: "30E971C8"
         }
         MI12MACAddressMSB: {
            name: "MI12 MAC Address (MSB)"
            value: "0800"
         }
         MI60Ethertype: {
            name: "MI60 Ethertype"
            value: "5752"
         }
         MI60MACAddressLSB: {
            name: "MI60 MAC Address (LSB)"
            value: "30E93B4F"
         }
         MI60MACAddressMSB: {
            name: "MI60 MAC Address (MSB)"
            value: "0800"
         }
         NuMIADOffset: {
            name: "NUMI ($AD) Early Warning Offset"
            value: "0"
         }
         NuMIBeamWidth: {
            name: "NuMI Beam Gate Width [ns]"
            value: "18000"
         }
         NuMIEnableWidth: {
            name: "NuMI Enable Gate Width [ns]"
            value: "2000000"
         }
         NuMIMIBSOffset: {
            name: "NuMI (MIBS$74) Early Warning Offset"
            value: "0"
         }
         OffBeamBNBBeamWidth: {
            name: "OffBeam-BNB Gate Width [ns]"
            value: "8000"
         }
         OffBeamBNBEnableWidth: {
            name: "OffBeam-BNB Enable Gate Width [ns]"
            value: "2000000"
         }
         OffBeamGateRate: {
            name: "OffBeam Gate Rate"
            value: "00010003"
         }
         OffBeamNuMIBeamWidth: {
            name: "OffBeam-NuMI Gate Width [ns]"
            value: "18000"
         }
         OffBeamNuMIEnableWidth: {
            name: "OffBeam-NuMI Enable Gate Width [ns]"
            value: "2000000"
         }
         PPSWidth: {
            name: "PPS Pulse Width [ns]"
            value: "1000"
         }
         PreScaleBNBNuMI: {
            name: "Prescale BNB-NuMI Number"
            value: "00010001"
         }
         PreScaleOffBeam: {
            name: "Prescale OffBeam Number"
            value: "00020002"
         }
         PrescaleZeroBias: {
            name: "Prescale ZeroBias Number"
            value: "0064"
         }
         TPCTriggerDelay: {
            name: "TPC Trigger Delay/400"
            value: "3250"
         }
         ZeroBiasEnableWidth: {
            name: "ZeroBias Enable Gate Width [ns]"
            value: "2000000"
         }
         ZeroBiasFreq: {
            name: "ZeroBias Frequency Period [ns]"
            value: "1000000000"
         }
         ZeroBiasWidth: {
            name: "ZeroBias Gate Width [ns]"
            value: "1600"
         }
      }
      use_wr_time: true
      wr_time_offset_ns: 1e9
    }

    ....     

*}

Definition at line 309 of file TriggerConfigurationExtractor.h.

Constructor & Destructor Documentation

icarus::TriggerConfigurationExtractor::TriggerConfigurationExtractor ( std::string const &  expectedFragmentType = "ICARUSTriggerUDP" )

inline

Learns the name of the trigger fragment type.

Definition at line 317 of file TriggerConfigurationExtractor.h.

    : fExpectedFragmentType{ expectedFragmentType }
    {}

Member Function Documentation

icarus::TriggerConfiguration icarus::TriggerConfigurationExtractor::extract

(

fhicl::ParameterSet const &

config

)

const

Extracts all supported Trigger configuration from config.

Parameters

config

a FHiCL parameter set with component configuration

Returns

an object with the supported Trigger configuration

All Trigger-related configuration that is known to this code is extracted and returned.

Definition at line 114 of file TriggerConfigurationExtractor.cxx.

{
  
  std::optional<icarus::TriggerConfiguration> config;
  
  for (std::string const& key: pset.get_names()) {
    
    std::optional<fhicl::ParameterSet> triggerConfigPset
      = readTriggerConfig(pset, key);
    
    if (!triggerConfigPset) continue;
    
    std::optional triggerConfig
      = extractTriggerConfiguration(*triggerConfigPset);
    
    if (config) {
      throw cet::exception{ "TriggerConfigurationExtractor" }
        << "Found multiple configurations for the trigger:"
        << "\n" << std::string(80, '-') << "\n"
        << *config
        << "\n" << std::string(80, '-') << "\n"
        << "and"
        << "\n" << std::string(80, '-') << "\n"
        << *triggerConfig
        << "\n" << std::string(80, '-') << "\n"
        ;
    }
    
    config = std::move(triggerConfig);
    
  } // for
  if (!config) {
    throw cet::exception{ "TriggerConfigurationExtractor" }
      << "No trigger configuration found (fragment type: '"
      << fExpectedFragmentType << "').\n";
  }
  
  return *config;
} // icarus::PMTconfigurationExtractor::extract()

auto icarus::TriggerConfigurationExtractor::extractTriggerConfiguration ( fhicl::ParameterSet const &  pset ) const

private

Extracts trigger readout board configuration from pset.

Parameters

pset	information source (FHiCL configuration)
boardName	name of the board we are given the configuration of

Returns

the requested configuration

Definition at line 157 of file TriggerConfigurationExtractor.cxx.

{
  
  auto const& triggerParams
    = pset.get<fhicl::ParameterSet>("daq.fragment_receiver");

  auto const& fpgaParams
    = pset.get<fhicl::ParameterSet>("daq.fragment_receiver.fpga_init_params");

  auto const& spexiParams
    = pset.get<fhicl::ParameterSet>("daq.fragment_receiver.spexi_init_params");
 
  icarus::TriggerConfiguration rc; // readout config, for friends


  rc.useWrTime                        
    = triggerParams.get<bool>("use_wr_time");
  rc.wrTimeOffset                     
    = triggerParams.get<unsigned int>("wr_time_offset_ns");
  
  rc.vetoDelay                        
    = fpgaParams.get<unsigned int>("Veto.value");

  rc.cryoConfig[icarus::trigger::kEast].majLevelInTime 
    = fpgaParams.get<unsigned int>("MajLevelBeamCryo1.value");   
  rc.cryoConfig[icarus::trigger::kEast].majLevelDrift  
    = fpgaParams.get<unsigned int>("MajLevelEnableCryo1.value");   
  rc.cryoConfig[icarus::trigger::kEast].slidingWindow  
    = parseWindowMode( fpgaParams.get<std::string>("SlidingWindowCryo1.value") );   
  rc.cryoConfig[icarus::trigger::kWest].majLevelInTime 
    = fpgaParams.get<unsigned int>("MajLevelBeamCryo2.value");   
  rc.cryoConfig[icarus::trigger::kWest].majLevelDrift  
    = fpgaParams.get<unsigned int>("MajLevelEnableCryo2.value");   
  rc.cryoConfig[icarus::trigger::kWest].slidingWindow  
    = parseWindowMode( fpgaParams.get<std::string>("SlidingWindowCryo2.value") );   
  rc.majorityTriggerType              
    = fpgaParams.get<std::string>( "MajorityTriggerType.value");
  rc.runType                          
    = fpgaParams.get<std::string>( "RunType.value");

  rc.tpcTriggerDelay        
    = spexiParams.get<unsigned int>("TPCTriggerDelay.value");

  auto gateSelection = sbn::bits::makeMask<sbn::gateSelection>         
    (std::stoul( spexiParams.get<std::string>("GateSelection.value"), nullptr, 16));

  // Read the prescale configuraton as string for now 
  auto prescaleMinBiasBeam = 
    spexiParams.get<std::string>("PreScaleBNBNuMI.value"); 
  auto prescaleMinBiasOffBeam = 
    spexiParams.get<std::string>("PreScaleOffBeam.value"); 
  auto offBeamGateRate = 
    spexiParams.get<std::string>("OffBeamGateRate.value"); 
  auto prescaleMinBiasCalibration =
    spexiParams.get<std::string>("PrescaleZeroBias.value");

  // BNB Full Config
  rc.gateConfig[icarus::trigger::kBNB].hasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::GateBNB);
  rc.gateConfig[icarus::trigger::kBNB].hasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::DriftGateBNB);
  rc.gateConfig[icarus::trigger::kBNB].hasMinBiasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasGateBNB);
  rc.gateConfig[icarus::trigger::kBNB].hasMinBiasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasDriftGateBNB);
  rc.gateConfig[icarus::trigger::kBNB].gateWidth 
    = spexiParams.get<unsigned int>("BNBBeamWidth.value");
  rc.gateConfig[icarus::trigger::kBNB].driftGateWidth          
    = spexiParams.get<unsigned int>("BNBEnableWidth.value");
  rc.gateConfig[icarus::trigger::kBNB].prescaleMinBias 
    = parsePrescaleString(prescaleMinBiasBeam, icarus::trigger::kBNB);
  rc.gateConfig[icarus::trigger::kBNB].earlyWarningOffset
    = spexiParams.get<unsigned int>("BNBBESOffset.value");
  rc.gateConfig[icarus::trigger::kBNB].earlyEarlyWarningOffset
    = spexiParams.get<unsigned int>("BNB1DOffset.value");

  // OffBeamBNB config
  rc.gateConfig[icarus::trigger::kOffBeamBNB].hasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::GateOffbeamBNB);
  rc.gateConfig[icarus::trigger::kOffBeamBNB].hasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::DriftGateOffbeamBNB);
  rc.gateConfig[icarus::trigger::kOffBeamBNB].hasMinBiasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasGateOffbeamBNB);
  rc.gateConfig[icarus::trigger::kOffBeamBNB].hasMinBiasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasDriftGateOffbeamBNB);
  rc.gateConfig[icarus::trigger::kOffBeamBNB].gateWidth            
    = spexiParams.get<unsigned int>("OffBeamBNBBeamWidth.value");
  rc.gateConfig[icarus::trigger::kOffBeamBNB].driftGateWidth             
    = spexiParams.get<unsigned int>("OffBeamBNBEnableWidth.value");
  rc.gateConfig[icarus::trigger::kOffBeamBNB].prescaleMinBias
    = parsePrescaleString(prescaleMinBiasOffBeam, icarus::trigger::kOffBeamBNB);
  rc.gateConfig[icarus::trigger::kOffBeamBNB].offBeamGateRate
    = parsePrescaleString( offBeamGateRate, icarus::trigger::kOffBeamBNB );

  // NuMI Configuration
  rc.gateConfig[icarus::trigger::kNuMI].hasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::GateNuMI);
  rc.gateConfig[icarus::trigger::kNuMI].hasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::DriftGateNuMI);
  rc.gateConfig[icarus::trigger::kNuMI].hasMinBiasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasGateNuMI);
  rc.gateConfig[icarus::trigger::kNuMI].hasMinBiasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasDriftGateNuMI);
  rc.gateConfig[icarus::trigger::kNuMI].gateWidth         
    = spexiParams.get<unsigned int>("NuMIBeamWidth.value");
  rc.gateConfig[icarus::trigger::kNuMI].driftGateWidth          
    = spexiParams.get<unsigned int>("NuMIEnableWidth.value");
  rc.gateConfig[icarus::trigger::kNuMI].prescaleMinBias
    = parsePrescaleString(prescaleMinBiasBeam, icarus::trigger::kNuMI);
  rc.gateConfig[icarus::trigger::kNuMI].earlyWarningOffset
    = spexiParams.get<unsigned int>("NuMIMIBSOffset.value");
  rc.gateConfig[icarus::trigger::kNuMI].earlyEarlyWarningOffset
    = spexiParams.get<unsigned int>("NuMIADOffset.value");

  // OffbeamNuMI config 
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].hasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::GateOffbeamNuMI);
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].hasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::DriftGateOffbeamNuMI);
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].hasMinBiasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasGateOffbeamNuMI);
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].hasMinBiasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasDriftGateOffbeamNuMI);
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].gateWidth            
    = spexiParams.get<unsigned int>("OffBeamNuMIBeamWidth.value");
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].driftGateWidth             
    = spexiParams.get<unsigned int>("OffBeamNuMIEnableWidth.value");
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].prescaleMinBias 
    = parsePrescaleString(prescaleMinBiasOffBeam, icarus::trigger::kOffBeamNuMI);
  rc.gateConfig[icarus::trigger::kOffBeamNuMI].offBeamGateRate
    = parsePrescaleString( offBeamGateRate, icarus::trigger::kOffBeamNuMI );

  // Calibration configuration
  rc.gateConfig[icarus::trigger::kCalibration].hasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::GateCalibration);
  rc.gateConfig[icarus::trigger::kCalibration].hasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::DriftGateCalibration);
  rc.gateConfig[icarus::trigger::kCalibration].hasMinBiasGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasGateCalibration);
  rc.gateConfig[icarus::trigger::kCalibration].hasMinBiasDriftGate
    = sbn::bits::hasBitSet(gateSelection, sbn::bits::gateSelection::MinbiasDriftGateCalibration);
  rc.gateConfig[icarus::trigger::kCalibration].gateWidth 
    = spexiParams.get<unsigned int>("ZeroBiasWidth.value");
  rc.gateConfig[icarus::trigger::kCalibration].driftGateWidth 
    = spexiParams.get<unsigned int>("ZeroBiasEnableWidth.value");
  rc.gateConfig[icarus::trigger::kCalibration].prescaleMinBias
    = parsePrescaleString( prescaleMinBiasCalibration, icarus::trigger::kCalibration );
  rc.gateConfig[icarus::trigger::kCalibration].period 
    = spexiParams.get<unsigned int>("ZeroBiasFreq.value"); //it is actually a period 

  return rc;

} // icarus::TriggerConfigurationExtractor::extractTriggerConfiguration()

bool icarus::TriggerConfigurationExtractor::isGoodConfiguration ( fhicl::ParameterSet const &  pset, std::string const &  key  )

static

Returns whether the specified key of pset is a good configuration.

Definition at line 68 of file TriggerConfigurationExtractor.cxx.

{
  return matchKey(key, ConfigurationNames.begin(), ConfigurationNames.end());
} // icarus::PMTconfigurationExtractor::isGoodConfiguration()

static bool icarus::TriggerConfigurationExtractor::mayHaveConfiguration ( fhicl::ParameterSet const &  pset )

inlinestatic

Returns whether pset may contain the needed configuration.

Definition at line 326 of file TriggerConfigurationExtractor.h.

    { return pset.has_key("configuration_documents"); }

unsigned long icarus::TriggerConfigurationExtractor::parsePrescaleString ( std::string  prescaleString, std::size_t  source  ) const

private

Definition at line 76 of file TriggerConfigurationExtractor.cxx.

{

    /* 
    * The prescale strings represents the hex econding of a 32-bit number
    * The first, least significative 16-bit word is the prescale associated
    * to BNB, while the most significative 16-bits are associated to NuMI.
    * if the word has only 16-bits (4 character string) then it is the 
    * prescale associated to the calibration gate
    */

    using namespace std::string_literals;
    switch( source ){
      case icarus::trigger::kBNB:          return std::stoul( prescaleString.substr(4,8), nullptr, 16);   
      case icarus::trigger::kNuMI:         return std::stoul( prescaleString.substr(0,4), nullptr, 16);
      case icarus::trigger::kOffBeamBNB:   return std::stoul( prescaleString.substr(4,8), nullptr, 16); 
      case icarus::trigger::kOffBeamNuMI:  return std::stoul( prescaleString.substr(0,4), nullptr, 16);
      case icarus::trigger::kCalibration:  return std::stoul( prescaleString, nullptr ,16);
    }
    throw std::runtime_error(" icarus::TriggerConfigurationExtractor::parsePrescaleString triggerSource{"s
    + std::to_string(source) + "}): unknown value"s);

}

unsigned int icarus::TriggerConfigurationExtractor::parseWindowMode ( std::string  bitStr ) const

private

Definition at line 102 of file TriggerConfigurationExtractor.cxx.

                                                                                        {
  for (unsigned int bitValue = 0; bitValue < value(sbn::bits::triggerWindowMode::NBits); ++bitValue) {
    auto const bit = static_cast<sbn::bits::triggerWindowMode>(bitValue);
    if (bitStr == bitName(bit)) return bitValue;
  }
  throw cet::exception{ "TriggerConfigurationExtractor" }
    << "Trigger window mode '" << bitStr << "' is not known.\n";
}

std::optional< fhicl::ParameterSet > icarus::TriggerConfigurationExtractor::readTriggerConfig ( fhicl::ParameterSet const &  pset, std::string const &  key  ) const

private

Returns the specified Trigger readout board configuration.

Parameters

pset	parameter set including key
key	key of the Trigger readout configuration candidate

Returns

the configuration, or an empty object if key does not represent one

Definition at line 316 of file TriggerConfigurationExtractor.cxx.

{
  std::optional<fhicl::ParameterSet> config;
  
  do { // fake loop for fast exit
    
    // it must be a parameter set
    if (!pset.has_key(key) || !pset.is_key_to_table(key)) break;
    
    auto boardPSet = pset.get<fhicl::ParameterSet>(key);
    
    // its "fragment_type" must be the expected one
    std::string fragmentType;
    if (!boardPSet.get_if_present("daq.fragment_receiver.generator", fragmentType))
      break;
    if (fragmentType != fExpectedFragmentType) break;
    
    config.emplace(std::move(boardPSet)); // success
  } while (false);
  return config;
} // icarus::TriggerConfigurationExtractor::readTriggerConfig()

Member Data Documentation

std::vector< std::regex > const icarus::TriggerConfigurationExtractor::ConfigurationNames { std::regex{ "icarustrigger.*" } }

staticprivate

Regular expressions matching all names of supported Trigger configurations.

Definition at line 352 of file TriggerConfigurationExtractor.h.

std::string const icarus::TriggerConfigurationExtractor::fExpectedFragmentType

private

Definition at line 349 of file TriggerConfigurationExtractor.h.

---

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

• TriggerConfigurationExtractor.h
• TriggerConfigurationExtractor.cxx