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 81 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 266 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 237 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 38 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 295 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 133 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 214 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 310 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.

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.

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.

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.

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.

m_partition_number

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

private

Definition at line 57 of file SSPLEDCalibWrapper.hpp.

m_pulse1_width_ticks

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

private

Definition at line 67 of file SSPLEDCalibWrapper.hpp.

m_pulse2_width_ticks

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

private

Definition at line 68 of file SSPLEDCalibWrapper.hpp.

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.

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.

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.

---

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