dunedaq::sspmodules::SSPLEDCalibWrapper Class Reference

#include <SSPLEDCalibWrapper.hpp>

Collaboration diagram for dunedaq::sspmodules::SSPLEDCalibWrapper:

Public Types
using	data_t = nlohmann::json

Public Member Functions
	SSPLEDCalibWrapper ()
	SSPLEDCalibWrapper Constructor.
	~SSPLEDCalibWrapper ()
	SSPLEDCalibWrapper (const SSPLEDCalibWrapper &)=delete
	SSPLEDCalibWrapper is not copy-constructible.
SSPLEDCalibWrapper &	operator= (const SSPLEDCalibWrapper &)=delete
	SSPLEDCalibWrapper is not copy-assignable.
	SSPLEDCalibWrapper (SSPLEDCalibWrapper &&)=delete
	SSPLEDCalibWrapper is not move-constructible.
SSPLEDCalibWrapper &	operator= (SSPLEDCalibWrapper &&)=delete
	SSPLEDCalibWrapper is not move-assignable.
void	init (const appmodel::SSPLEDCalibModule *mcfg)
void	conf (const appmodel::SSPLEDCalibModule *mcfg)
void	start (const data_t &args)
void	stop (const data_t &args)

Private Member Functions
void	validate_config (const data_t &args)
void	configure_single_pulse ()
void	configure_burst_mode ()
void	manual_configure_device (const std::vector< const appmodel::SSPRegister * > &hw_conf)

Private Attributes
dunedaq::sspmodules::DeviceInterface *	m_device_interface
std::atomic< bool >	m_run_marker
std::atomic< bool >	m_configure
unsigned int	m_board_id {0}
unsigned long	m_board_ip
unsigned int	m_partition_number {0}
unsigned int	m_timing_address {0}
unsigned long	m_module_id
bool	m_burst_mode = false
bool	m_double_pulse = false
bool	m_single_pulse = false
unsigned int	m_number_channels {12}
unsigned int	m_channel_mask {4095}
unsigned int	m_burst_count {1}
unsigned int	m_double_pulse_delay_ticks {0}
unsigned int	m_pulse1_width_ticks {0}
unsigned int	m_pulse2_width_ticks {0}
unsigned int	m_pulse_bias_percent_270nm {0}
unsigned int	m_pulse_bias_percent_367nm {0}
std::string	m_instance_name_for_metrics

Detailed Description

Definition at line 26 of file SSPLEDCalibWrapper.hpp.

Member Typedef Documentation

data_t

using dunedaq::sspmodules::SSPLEDCalibWrapper::data_t = nlohmann::json

Definition at line 40 of file SSPLEDCalibWrapper.hpp.

Constructor & Destructor Documentation

SSPLEDCalibWrapper() [1/3]

dunedaq::sspmodules::SSPLEDCalibWrapper::SSPLEDCalibWrapper

(

)

SSPLEDCalibWrapper Constructor.

Parameters

name	Instance name for this CardWrapper instance

Definition at line 29 of file SSPLEDCalibWrapper.cpp.

  : m_device_interface(0)
  , m_run_marker{ false }
{
}

~SSPLEDCalibWrapper()

dunedaq::sspmodules::SSPLEDCalibWrapper::~SSPLEDCalibWrapper

(

)

Definition at line 35 of file SSPLEDCalibWrapper.cpp.

{
}

SSPLEDCalibWrapper() [2/3]

dunedaq::sspmodules::SSPLEDCalibWrapper::SSPLEDCalibWrapper ( const SSPLEDCalibWrapper & )

delete

SSPLEDCalibWrapper is not copy-constructible.

SSPLEDCalibWrapper() [3/3]

dunedaq::sspmodules::SSPLEDCalibWrapper::SSPLEDCalibWrapper ( SSPLEDCalibWrapper && )

delete

SSPLEDCalibWrapper is not move-constructible.

Member Function Documentation

conf()

void dunedaq::sspmodules::SSPLEDCalibWrapper::conf

(

const appmodel::SSPLEDCalibModule *

mcfg

)

Definition at line 83 of file SSPLEDCalibWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::conf called." << std::endl;
 
  try {
    m_device_interface->ConfigureLEDCalib(conf); //This sets up the ethernet interface and make sure that the pdts is synched
    m_device_interface->SetRegisterByName("module_id", m_module_id);
    //m_device_interface->SetRegisterByName("eventDataInterfaceSelect", m_cfg.interface_type);
  } catch (const std::exception & e) {
    throw FailedLEDCalibrationConf(ERS_HERE, e);
  }
 
  if ( conf->get_pulse_mode() == "single") {
    m_single_pulse = true;
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: I think that you want SSP LED Calib module to be in single pulse..." << std::endl;
  } else if ( conf->get_pulse_mode() == "burst") {
    m_burst_mode = true;
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: I think that you want SSP LED Calib module to be in BURST MODE..." << std::endl;
  }
 
  if ( (m_single_pulse && m_burst_mode) ) {
    std::stringstream ss;
    ss << "ERROR: SOMEHOW ENDED UP WITH SEVERAL PULSE MODES SET ON!!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_burst_mode) {
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: Configuring for BURST MODE..." << std::endl;
    this->configure_burst_mode();
  } else if (m_single_pulse) {
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: Configuring for single pulse mode..." << std::endl;
    this->configure_single_pulse();
  } else {
    std::stringstream ss;
    ss << "ERROR: SOMEHOW ENDED UP WITH NO PULSE MODES SET ON!!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  //if there are "literal" entries in the configuration they are explicit writes to the specified register with given value
  //these literal entries are paresed and applied last after any other parameters so this method call needs to be after the
  //other configuration calls
  this->manual_configure_device(conf->get_hardware_configuration());
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::conf complete.";
}

configure_burst_mode()

void dunedaq::sspmodules::SSPLEDCalibWrapper::configure_burst_mode ( )

private

Definition at line 258 of file SSPLEDCalibWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureBurstMode called.";
 
  m_device_interface->SetRegister(0x80000464, 0x000002E7); //pdts_cmd_control_1
  m_device_interface->SetRegister(0x80000940, 0x00030036); //pdts_cmd_delay_0
  m_device_interface->SetRegister(0x80000944, 0x00030036); //pdts_cmd_delay_1
  m_device_interface->SetRegister(0x80000948, 0x00030036); //pdts_cmd_delay_2
  m_device_interface->SetRegister(0x8000094C, 0x00030036); //pdts_cmd_delay_3
  m_device_interface->SetRegister(0x80000950, 0x00030036); //pdts_cmd_delay_4
  m_device_interface->SetRegister(0x80000954, 0x00030036); //pdts_cmd_delay_5
  m_device_interface->SetRegister(0x80000958, 0x00030036); //pdts_cmd_delay_6
  m_device_interface->SetRegister(0x8000095C, 0x00030036); //pdts_cmd_delay_7
  m_device_interface->SetRegister(0x80000960, 0x00030036); //pdts_cmd_delay_8
  m_device_interface->SetRegister(0x80000964, 0x00030036); //pdts_cmd_delay_9
  m_device_interface->SetRegister(0x80000968, 0x00030036); //pdts_cmd_delay_10
  m_device_interface->SetRegister(0x8000096C, 0x00030036); //pdts_cmd_delay_11
  m_device_interface->SetRegister(0x80000970, 0x00030036); //pdts_cmd_delay_12
  m_device_interface->SetRegister(0x80000974, 0x00030036); //pdts_cmd_delay_13
  m_device_interface->SetRegister(0x80000978, 0x00030036); //pdts_cmd_delay_14
  m_device_interface->SetRegister(0x8000097C, 0x00030036); //pdts_cmd_delay_15
  m_device_interface->SetRegister(0x80000468, 0x80000000); //pdts_cmd_control_2
  m_device_interface->SetRegister(0x80000520, 0x00000011); //pulser_mode_control
  m_device_interface->SetRegister(0x80000448, m_burst_count); //cal_count
  
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureBurstMode completed.";
}

configure_single_pulse()

void dunedaq::sspmodules::SSPLEDCalibWrapper::configure_single_pulse ( )

private

Definition at line 229 of file SSPLEDCalibWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureSinglePulse called.";
 
  m_device_interface->SetRegister(0x80000464, 0x000002E7); //pdts_cmd_control_1
  m_device_interface->SetRegister(0x80000940, 0x00030036); //pdts_cmd_delay_0
  m_device_interface->SetRegister(0x80000944, 0x00030036); //pdts_cmd_delay_1
  m_device_interface->SetRegister(0x80000948, 0x00030036); //pdts_cmd_delay_2
  m_device_interface->SetRegister(0x8000094C, 0x00030036); //pdts_cmd_delay_3
  m_device_interface->SetRegister(0x80000950, 0x00030036); //pdts_cmd_delay_4
  m_device_interface->SetRegister(0x80000954, 0x00030036); //pdts_cmd_delay_5
  m_device_interface->SetRegister(0x80000958, 0x00030036); //pdts_cmd_delay_6
  m_device_interface->SetRegister(0x8000095C, 0x00030036); //pdts_cmd_delay_7
  m_device_interface->SetRegister(0x80000960, 0x00030036); //pdts_cmd_delay_8
  m_device_interface->SetRegister(0x80000964, 0x00030036); //pdts_cmd_delay_9
  m_device_interface->SetRegister(0x80000968, 0x00030036); //pdts_cmd_delay_10
  m_device_interface->SetRegister(0x8000096C, 0x00030036); //pdts_cmd_delay_11
  m_device_interface->SetRegister(0x80000970, 0x00030036); //pdts_cmd_delay_12
  m_device_interface->SetRegister(0x80000974, 0x00030036); //pdts_cmd_delay_13
  m_device_interface->SetRegister(0x80000978, 0x00030036); //pdts_cmd_delay_14
  m_device_interface->SetRegister(0x8000097C, 0x00030036); //pdts_cmd_delay_15
  m_device_interface->SetRegister(0x80000468, 0x80000000); //pdts_cmd_control_2
  m_device_interface->SetRegister(0x80000520, 0x00000011); //pulser_mode_control
  m_device_interface->SetRegister(0x80000448, 0x00000001); //cal_count
  
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureSinglePulse completed.";
}

init()

void dunedaq::sspmodules::SSPLEDCalibWrapper::init

(

const appmodel::SSPLEDCalibModule *

mcfg

)

Definition at line 40 of file SSPLEDCalibWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::init called." << std::endl;
 
  m_number_channels = conf->get_number_channels();
  m_channel_mask = conf->get_channel_mask();
  m_burst_count = conf->get_burst_count();
  m_double_pulse_delay_ticks = conf->get_double_pulse_delay_ticks();
  m_pulse1_width_ticks = conf->get_pulse1_width_ticks();
  m_pulse2_width_ticks = conf->get_pulse2_width_ticks();
  m_pulse_bias_percent_270nm = conf->get_pulse_bias_percent_270nm();
  m_pulse_bias_percent_367nm = conf->get_pulse_bias_percent_367nm();
 
  m_board_id = conf->get_board_id();
  m_module_id = conf->get_module_id();
  m_instance_name_for_metrics = "SSP LED Calib " + std::to_string(m_board_id);
  m_partition_number =conf->get_partition_number(); // this should be 0-3
 
  m_timing_address = conf->get_timing_address(); // 0x20 is default for 101, 0x2B for 304, and 0x36 for 603
  if (m_timing_address > 0xff) {
    std::stringstream ss;
    ss << "Error: Incorrect timing address set (" << m_timing_address << ")!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Board ID is listed as: " << m_board_id << std::endl
                              << "Partition Number is: " << m_partition_number << std::endl
                              << "Timing Address is: " << m_timing_address << std::endl
                              << "Module ID is: " << m_module_id << std::endl;
 
  try {
    m_device_interface = new dunedaq::sspmodules::DeviceInterface();
    m_device_interface->SetPartitionNumber(m_partition_number);
    m_device_interface->SetTimingAddress(m_timing_address);
  } catch (const std::exception & e) {
    throw FailedLEDCalibrationInit(ERS_HERE, e);
  }
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::init complete.";
}

manual_configure_device()

void dunedaq::sspmodules::SSPLEDCalibWrapper::manual_configure_device ( const std::vector< const appmodel::SSPRegister * > & hw_conf )

private

Definition at line 287 of file SSPLEDCalibWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureDevice called.";
  TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: Processing the Hardware Configuration list..." << std::endl;
  for (auto regValuesIter : hw_conf) {
    std::string m_name = regValuesIter->get_name();
    unsigned int regAddr = regValuesIter->get_address();
    unsigned int regVal = regValuesIter->get_value();
    unsigned int regMask = regValuesIter->get_mask();
    m_device_interface->SetRegister(regAddr, regVal, regMask);
  }
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureDevice complete.";
} // NOLINT(readability/fn_size)

operator=() [1/2]

SSPLEDCalibWrapper & dunedaq::sspmodules::SSPLEDCalibWrapper::operator= ( const SSPLEDCalibWrapper & )

delete

SSPLEDCalibWrapper is not copy-assignable.

operator=() [2/2]

SSPLEDCalibWrapper & dunedaq::sspmodules::SSPLEDCalibWrapper::operator= ( SSPLEDCalibWrapper && )

delete

SSPLEDCalibWrapper is not move-assignable.

start()

void dunedaq::sspmodules::SSPLEDCalibWrapper::start

(

const data_t &

args

)

Definition at line 132 of file SSPLEDCalibWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Start pulsing SSPLEDCalibWrapper of card " << m_board_id << "...";
 
  if (m_run_marker.load()) {
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Run Marker says that SSPLEDCalibWrapper card " << m_board_id << " is already pulsing...";
    return;
  }
 
  unsigned int base_bias_regAddress = 0x40000340;
  unsigned int base_timing_regAddress = 0x800003C0;
 
  if (m_number_channels == 5) {
    base_bias_regAddress = 0x4000035C;
    base_timing_regAddress = 0x800003DC;
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Configuring board with 5 channels..." ;
  } else if (m_number_channels == 12) {
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Configuring board with 12 channels..." ;
  } else {    
    std::stringstream ss;
    ss << "ERROR: SOMEHOW ENDED UP WITHOUT NUMBER OF CHANNELS SET!!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
  
  unsigned int pulse_bias_setting_270nm = ( m_pulse_bias_percent_270nm);
  unsigned int pulse_bias_setting_367nm = ( m_pulse_bias_percent_367nm/2);
  
  for (unsigned int counter = 0; counter < m_number_channels ; counter++) {
    unsigned int bias_regAddress =  base_bias_regAddress + 0x4*(counter);  //0x40000340 - 0x4000036C
    unsigned int bias_regVal = 0x00040000;
    unsigned int timing_regAddress =  base_timing_regAddress + 0x4*(counter); //0x80003C0 - 0x800003EC
    unsigned int timing_regVal = 0x0; //the highest byte sets 8 (pdts trigger) + 1 (953.5 Hz) for burst mode, but 8 (pdts trigger) + 7 (single shot) for single
    if (m_single_pulse) {
      timing_regVal = 0xF0000000;
    } else if (m_burst_mode) {
      timing_regVal = 0x90000000;
    }
      
    TLOG(TLVL_FULL_DEBUG) << "Channel map is 0x" << std::hex << m_channel_mask << " and the comparison is 0x" << (1 << counter ) << std::endl;
    if ( (m_channel_mask & ( (unsigned int)1 << counter)) == ((unsigned int)1 << counter) ) {      
      if ( counter < 6) {
    bias_regVal = bias_regVal + pulse_bias_setting_270nm;
      } else {
    bias_regVal = bias_regVal + pulse_bias_setting_367nm;
      }
      timing_regVal = timing_regVal + m_pulse1_width_ticks;
      timing_regVal = timing_regVal + (m_pulse2_width_ticks << 8);
      timing_regVal = timing_regVal + (m_double_pulse_delay_ticks << 16);
      TLOG(TLVL_FULL_DEBUG) << "Will turn on " << std::dec << counter << " channel at bias register 0x" << std::hex << bias_regAddress << " with bias value 0x" << bias_regVal << std::endl;
      TLOG(TLVL_FULL_DEBUG) << " and set the width regsiter 0x" << std::hex << timing_regAddress << " to value of 0x" << timing_regVal << std::dec << std::endl;
      m_device_interface->SetRegister(bias_regAddress, bias_regVal); //BIAS_DAC_CONFIG_N
      if ( (counter == 7) && ! ( (m_channel_mask & ( (unsigned int)1 << counter)) == ((unsigned int)1 << (counter-1) ) ) )  {
    //this is a really convoluted situation where for the very specific 12 channel board that arrived at CERN in June 2022
    //the bias for channel 7 was not working and so the bias is taken from channel 6
    //which means that if channel 7 is to be turned on while channel 6 is masked off
    //you still have to bias channel 6 in order for the led on channel 7 to emmit light
    m_device_interface->SetRegister((bias_regAddress - 0x4), bias_regVal); //BIAS_DAC_CONFIG_N
      }
    
      m_device_interface->SetRegister(timing_regAddress, timing_regVal); //cal_CONFIG_N
    } else {
      TLOG(TLVL_FULL_DEBUG) << "Will turn off channel " << std::dec << counter << " at timing register 0x" << std::hex << timing_regAddress << std::dec << std::endl;
      m_device_interface->SetRegister(bias_regAddress, 0x0); //BIAS_DAC_CONFIG_N
      m_device_interface->SetRegister(timing_regAddress, 0x0); //cal_CONFIG_N
    }
  }
 
  m_device_interface->SetRegister(0x40000300, 0x1); //writing 0x1 to this register applies the bias voltage settings
 
  m_run_marker = true;
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Start pulsing SSPLEDCalibWrapper of card " << m_board_id << " complete.";
}

stop()

void dunedaq::sspmodules::SSPLEDCalibWrapper::stop

(

const data_t &

args

)

Definition at line 207 of file SSPLEDCalibWrapper.cpp.

{
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Stop pulsing SSPLEDCalibWrapper of card " << m_board_id << "...";
  if (!m_run_marker.load()) {
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "The run_marker says that SSPLEDCalibWrapper card " << m_board_id << " is already stopped, but stopping anyways...";
  }
 
  for (unsigned int counter = 0; counter < 12; counter++) { //switch this to 12 for a 12 channel SSP
    unsigned int bias_regAddress =  0x40000340 + 0x4*(counter);
    unsigned int timing_regAddress =  0x800003c0 + 0x4*(counter);
    m_device_interface->SetRegister(bias_regAddress, 0x00000000); //BIAS_DAC_CONFIG_N
    m_device_interface->SetRegister(timing_regAddress, 0x00000000); //cal_CONFIG_N
  }
 
  m_device_interface->SetRegister(0x40000300, 0x1); //writing 0x1 to this register applies the bias voltage settings
 
  m_run_marker = false;
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Stop pulsing SSPLEDCalibWrapper of card " << m_board_id << " complete.";
}

validate_config()

void dunedaq::sspmodules::SSPLEDCalibWrapper::validate_config ( const data_t & args )

private

Definition at line 302 of file SSPLEDCalibWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::validate_config called.";
 
  if ( ! ( (m_number_channels == 5) || (m_number_channels == 12) ) ) {
    std::stringstream ss;
    ss << "ERROR: Incorrect number_channels value " << m_number_channels << " is not equal to 5 or 12!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_channel_mask > 4095) {
    std::stringstream ss;
    ss << "ERROR: Incorrect channel_maks value " << m_channel_mask << " is higher than the limit of 4095!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (!( m_single_pulse || m_burst_mode ) ) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse_mode value. Neither single or burst."
       << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
  
  if (m_double_pulse_delay_ticks > 4095) {
    std::stringstream ss;
    ss << "ERROR: Strange!! double_pulse_delay_ticks value is " << m_double_pulse_delay_ticks << ", which is greater than the limit of 4095"
       << std::endl;
    TLOG() << ss.str();
    //throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_burst_count > 10000) {
    std::stringstream ss;
    ss << "ERROR: Strange!! burst_count value is " << m_burst_count << ", which is more time than in a drift readout window"
       << std::endl;
    TLOG() << ss.str();
    //throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_pulse1_width_ticks > 255) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse1_width_ticks value is " << m_pulse1_width_ticks << ", which is greater than the limit of 255!!!"
       << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
    if (m_pulse2_width_ticks > 255) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse2_width_ticks value is " << m_pulse2_width_ticks << ", which is greater than the limit of 255!!!"
       << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_pulse_bias_percent_270nm > 4095) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse_bias_percent_270nm value is " << m_pulse_bias_percent_270nm << ", which is greater than 100 percent!!!"
       << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
  
  if (m_pulse_bias_percent_367nm > 4095) {
    std::stringstream ss;
      ss << "ERROR: Incorrect pulse_bias_percent_367nm value is " << m_pulse_bias_percent_367nm << ", which is greater than 100 percent!!!"
     << std::endl;
      TLOG() << ss.str();
      throw ConfigurationError(ERS_HERE, ss.str());
  }
  
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::validate_config complete.";
}

Member Data Documentation

m_board_id

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_board_id {0}

private

Definition at line 55 of file SSPLEDCalibWrapper.hpp.

{0};  // this is the ID of the SSP board

m_board_ip

unsigned long dunedaq::sspmodules::SSPLEDCalibWrapper::m_board_ip

private

Definition at line 56 of file SSPLEDCalibWrapper.hpp.

m_burst_count

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_burst_count {1}

private

Definition at line 65 of file SSPLEDCalibWrapper.hpp.

{1};

m_burst_mode

bool dunedaq::sspmodules::SSPLEDCalibWrapper::m_burst_mode = false

private

Definition at line 60 of file SSPLEDCalibWrapper.hpp.

m_channel_mask

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_channel_mask {4095}

private

Definition at line 64 of file SSPLEDCalibWrapper.hpp.

{4095};

m_configure

std::atomic<bool> dunedaq::sspmodules::SSPLEDCalibWrapper::m_configure

private

Definition at line 52 of file SSPLEDCalibWrapper.hpp.

m_device_interface

dunedaq::sspmodules::DeviceInterface* dunedaq::sspmodules::SSPLEDCalibWrapper::m_device_interface

private

Definition at line 48 of file SSPLEDCalibWrapper.hpp.

m_double_pulse

bool dunedaq::sspmodules::SSPLEDCalibWrapper::m_double_pulse = false

private

Definition at line 61 of file SSPLEDCalibWrapper.hpp.

m_double_pulse_delay_ticks

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_double_pulse_delay_ticks {0}

private

Definition at line 66 of file SSPLEDCalibWrapper.hpp.

{0};

m_instance_name_for_metrics

std::string dunedaq::sspmodules::SSPLEDCalibWrapper::m_instance_name_for_metrics

private

Definition at line 72 of file SSPLEDCalibWrapper.hpp.

m_module_id

unsigned long dunedaq::sspmodules::SSPLEDCalibWrapper::m_module_id

private

Definition at line 59 of file SSPLEDCalibWrapper.hpp.

m_number_channels

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_number_channels {12}

private

Definition at line 63 of file SSPLEDCalibWrapper.hpp.

{12};

m_partition_number

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_partition_number {0}

private

Definition at line 57 of file SSPLEDCalibWrapper.hpp.

{0};

m_pulse1_width_ticks

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_pulse1_width_ticks {0}

private

Definition at line 67 of file SSPLEDCalibWrapper.hpp.

{0};

m_pulse2_width_ticks

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_pulse2_width_ticks {0}

private

Definition at line 68 of file SSPLEDCalibWrapper.hpp.

{0};

m_pulse_bias_percent_270nm

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_pulse_bias_percent_270nm {0}

private

Definition at line 69 of file SSPLEDCalibWrapper.hpp.

{0};

m_pulse_bias_percent_367nm

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_pulse_bias_percent_367nm {0}

private

Definition at line 70 of file SSPLEDCalibWrapper.hpp.

{0};

m_run_marker

std::atomic<bool> dunedaq::sspmodules::SSPLEDCalibWrapper::m_run_marker

private

Definition at line 51 of file SSPLEDCalibWrapper.hpp.

m_single_pulse

bool dunedaq::sspmodules::SSPLEDCalibWrapper::m_single_pulse = false

private

Definition at line 62 of file SSPLEDCalibWrapper.hpp.

m_timing_address

unsigned int dunedaq::sspmodules::SSPLEDCalibWrapper::m_timing_address {0}

private

Definition at line 58 of file SSPLEDCalibWrapper.hpp.

{0};

---

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

• /github/workspace/dunedaq/sourcecode/sspmodules/src/SSPLEDCalibWrapper.hpp
• /github/workspace/dunedaq/sourcecode/sspmodules/src/SSPLEDCalibWrapper.cpp