daq2raw::BeamlineUnpack Class Reference

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-09-26/DAQ2RawDigit/testbeam/BeamlineUnpack.h"

Public Member Functions
	BeamlineUnpack (const fhicl::ParameterSet &pset)
	~BeamlineUnpack ()
void	reconfigure (const fhicl::ParameterSet &pset)
void	EndSpill ()
void	Unpack (const LariatFragment *spillFrag, const std::vector< TDUFragment * > tduFrag, unsigned int run=0, std::string filename="")
BeamlineEvents *	GetBeamlineEvents () const

Private Member Functions
std::vector< TriggerPattern::TriggerPattern_t >	CleanTriggers (const TriggerFragment &triggerFrag)
std::vector< TDUFragment * >	CleanTDU (const std::vector< TDUFragment * > &tduFrags)
void	UnpackConfig (unsigned int run)
void	UnpackTrigger (const std::vector< TriggerPattern::TriggerPattern_t > &beamlineTriggers, const std::vector< TDUFragment * > &beamlineTDUs, std::string filename="")
void	UnpackDigits (const std::vector< V1742Fragment > &frags)
void	UnpackWC (const TDCFragment &frag)

Private Attributes
art::ServiceHandle< beamlineutil::BeamlineChannelMap >	fChannelMap
art::ServiceHandle< beamlinegeo::BeamlineGeometry >	fGeometry
art::ServiceHandle< beamlineutil::BeamlineMagneticField >	fMagneticField
std::string	fTriggerSource
bool	fUnpackTrigger
bool	fUnpackDigitizer
bool	fUnpackWireChamber
bool	fUnpackTDU
unsigned int	fChannelsPerTDC
unsigned int	fTDCsPerWC
unsigned int	fTriggerLatency
int	fTDUOffset
BeamlineEvents *	fBeamlineEvents

Detailed Description

Definition at line 184 of file BeamlineUnpack.h.

Constructor & Destructor Documentation

daq2raw::BeamlineUnpack::BeamlineUnpack

(

const fhicl::ParameterSet &

pset

)

Definition at line 292 of file BeamlineUnpack.cxx.

References reconfigure().

                                                                   :
  fBeamlineEvents(nullptr) {
  this->reconfigure(pset);
}

daq2raw::BeamlineUnpack::~BeamlineUnpack

(

)

Definition at line 298 of file BeamlineUnpack.cxx.

References EndSpill().

                                       {
  this->EndSpill();
}

Member Function Documentation

std::vector< TDUFragment * > daq2raw::BeamlineUnpack::CleanTDU ( const std::vector< TDUFragment * > &  tduFrags )

private

Definition at line 345 of file BeamlineUnpack.cxx.

Referenced by Unpack().

                                                                       {

  // filter just beamline triggers from
  // the TDU timestamps
  std::vector<TDUFragment*> beamlineTDUs;

  // also remove duplicated timestamps
  std::vector<uint64_t> prevTs;

  for (std::vector<TDUFragment*>::const_iterator tduFragIt = tduFrags.begin();
       tduFragIt != tduFrags.end(); ++tduFragIt) {

    const TDUFragment::TDUFragment_t& tduFrag = (*tduFragIt)->tduFragment[0];

    if (tduFrag.type == 1 and
        std::find(prevTs.begin(), prevTs.end(), tduFrag.timestamp) == prevTs.end()) {
      beamlineTDUs.push_back(*tduFragIt);
      prevTs.push_back(tduFrag.timestamp);
    }

  }

  return beamlineTDUs;

}

std::vector< TriggerPattern::TriggerPattern_t > daq2raw::BeamlineUnpack::CleanTriggers ( const TriggerFragment &  triggerFrag )

private

Definition at line 319 of file BeamlineUnpack.cxx.

References fTriggerLatency, and submit_syst::pattern.

Referenced by Unpack().

                                                                       {

  // filter triggers saved by the trigger
  // board to remove any which occured directly
  // after the previous one
  std::vector<TriggerPattern::TriggerPattern_t> beamlineTriggers;

  uint32_t prevT = 0;
  for (size_t trigIt = 0; trigIt < triggerFrag.triggerFragment.nEntries; ++trigIt) {

    TriggerPattern::TriggerPattern_t pattern =
      triggerFrag.triggerFragment.patterns[trigIt];

    if (pattern.timeStamp - prevT > fTriggerLatency)
      beamlineTriggers.push_back(pattern);

    prevT = pattern.timeStamp;

  }

  return beamlineTriggers;

}

void daq2raw::BeamlineUnpack::EndSpill

(

)

Definition at line 372 of file BeamlineUnpack.cxx.

References fBeamlineEvents.

Referenced by ~BeamlineUnpack().

                                     {
  if (fBeamlineEvents)
    delete fBeamlineEvents;
  fBeamlineEvents = nullptr;
}

daq2raw::BeamlineEvents * daq2raw::BeamlineUnpack::GetBeamlineEvents

(

)

const

Definition at line 379 of file BeamlineUnpack.cxx.

References fBeamlineEvents.

                                                                      {
  return fBeamlineEvents;
}

void daq2raw::BeamlineUnpack::reconfigure

(

const fhicl::ParameterSet &

pset

)

Definition at line 303 of file BeamlineUnpack.cxx.

References fChannelsPerTDC, fTDCsPerWC, fTDUOffset, fTriggerLatency, fTriggerSource, fUnpackDigitizer, fUnpackTDU, fUnpackTrigger, fUnpackWireChamber, and fhicl::ParameterSet::get().

Referenced by BeamlineUnpack().

                                                                     {
  fTriggerSource     = pset.get<std::string>("TriggerSource", "Trigger");
  fUnpackTrigger     = pset.get<bool>("UnpackTrigger",     true);
  fUnpackDigitizer   = pset.get<bool>("UnpackDigitizer",   true);
  fUnpackWireChamber = pset.get<bool>("UnpackWireChamber", true);
  fUnpackTDU         = pset.get<bool>("UnpackTDU",         true);

  fChannelsPerTDC = pset.get<unsigned int>("ChannelsPerTDC", 64);
  fTDCsPerWC      = pset.get<unsigned int>("TDCsPerWC",      2);

  fTriggerLatency = pset.get<unsigned int>("TriggerLatency", 0);
  fTDUOffset      = pset.get<int>         ("TDUOffset",      0);
}

void daq2raw::BeamlineUnpack::Unpack	(	const LariatFragment *	spillFrag,
		const std::vector< TDUFragment * >	tduFrag,
		unsigned int	run = 0,
		std::string	filename = ""
	)

Definition at line 384 of file BeamlineUnpack.cxx.

References CleanTDU(), CleanTriggers(), allTimeWatchdog::endl, fBeamlineEvents, fTriggerSource, fUnpackDigitizer, fUnpackTDU, fUnpackTrigger, fUnpackWireChamber, UnpackConfig(), UnpackDigits(), UnpackTrigger(), and UnpackWC().

                                                         {

  // get trigger information
  const TriggerFragment triggerFrag = spillFrag->triggerFragment;

  // get digits
  const std::vector<V1742Fragment> v1742Frags = spillFrag->v1742Frags;

  // get wire chambers
  TDCFragment tdcFrag;
  if (fUnpackWireChamber and spillFrag->tdcFrags.size())
    tdcFrag = spillFrag->tdcFrags[0];

  mf::LogVerbatim("BeamlineUnpack::Unpack")
    << "There are " << triggerFrag.triggerFragment.nEntries << " triggers, "
    << v1742Frags.size() << " digitizer triggers, "
    << tdcFrag.tdcEvents.size() << " wire chamber triggers and "
    << tduFrags.size() << " TDU timestamps." << std::endl;

  // clean up various fragments of data
  std::vector<TriggerPattern::TriggerPattern_t> triggers_clean
    = CleanTriggers(triggerFrag);
  std::vector<TDUFragment*> tdu_clean = CleanTDU(tduFrags);

  mf::LogVerbatim("BeamlineUnpack::Unpack")
    << "After cleaning, there are " << triggers_clean.size() << " triggers, "
    << v1742Frags.size() << " digitizer triggers, "
    << tdcFrag.tdcEvents.size() << " wire chamber triggers and "
    << tdu_clean.size() << " TDU timestamps." << std::endl;

  // for testing and commissioning, we may have variable numbers of triggers
  // in each component.
  // deal with all possibilities
  unsigned int numTriggers = 0;
  if (fTriggerSource == "Trigger")
    numTriggers = triggers_clean.size();
  else if (fTriggerSource == "Digitizer")
    numTriggers = v1742Frags.size();
  else if (fTriggerSource == "WireChamber")
    numTriggers = tdcFrag.tdcEvents.size();
  else if (fTriggerSource == "TDU")
    numTriggers = tdu_clean.size();

  // strictly enforce the correct number of fragments for each of the
  // front-end data components we are trying to unpack
  if ((fUnpackTrigger and triggers_clean.size() != numTriggers) or
      (fUnpackDigitizer and v1742Frags.size() != numTriggers) or
      (fUnpackWireChamber and tdcFrag.tdcEvents.size() != numTriggers) or
      (fUnpackTDU and tdu_clean.size() != numTriggers))
    throw cet::exception("BeamlineUnpack")
      << "Inconsistent number of data fragments: "
      << "Triggers: " << triggers_clean.size() << "; "
      << "Digitizer: " << v1742Frags.size() << "; "
      << "Wire Chambers: " << tdcFrag.tdcEvents.size() << "; "
      << "TDU: " << tdu_clean.size() << "."
      << std::endl;

  // make a new BeamlineEvents object to contain the information
  fBeamlineEvents = new BeamlineEvents(numTriggers);

  // get the spill information
  //LariatFragment::SpillTrailer spillFrag = frag->spillTrailer;

  // unpack everything
  this->UnpackConfig(run);
  if (fUnpackTrigger or fUnpackTDU)
    this->UnpackTrigger(triggers_clean, tdu_clean, filename);
  if (fUnpackDigitizer)
    this->UnpackDigits(v1742Frags);
  if (fUnpackWireChamber)
    this->UnpackWC(tdcFrag);

  return;

}

void daq2raw::BeamlineUnpack::UnpackConfig ( unsigned int  run )

private

Definition at line 464 of file BeamlineUnpack.cxx.

References daq2raw::BeamlineEvent::AddConfig(), gen_flatrecord::config, e, fBeamlineEvents, daq2raw::BeamlineEvents::FindEvent(), fMagneticField, beamlineutil::BeamlineMagneticField::MagneticField(), daq2raw::BeamlineEvents::NumEvents(), rawdata::RawBeamlineConfig::SetBeamlineRun(), and rawdata::RawBeamlineConfig::SetBField().

Referenced by Unpack().

                                                         {

  rawdata::RawBeamlineConfig config;

  // beamline run
  config.SetBeamlineRun(run);

  // magnetic field
  float b_field = 0.;
  try {
    b_field = fMagneticField->MagneticField(run);
  }
  catch (cet::exception& e) {
    e.what();
  }
  config.SetBField(b_field);

  for (unsigned int event = 0; event < fBeamlineEvents->NumEvents(); ++event)
    fBeamlineEvents->FindEvent(event)->AddConfig(config);

  return;

}

void daq2raw::BeamlineUnpack::UnpackDigits ( const std::vector< V1742Fragment > &  frags )

private

Definition at line 561 of file BeamlineUnpack.cxx.

References beamlineutil::BeamlineChannelMap::ActiveDigitChannel(), daq2raw::BeamlineEvent::AddCherenkov(), daq2raw::BeamlineEvent::AddMuonStack(), daq2raw::BeamlineEvent::AddOtherDigit(), daq2raw::BeamlineEvent::AddPaddleDigit(), daq2raw::BeamlineEvent::AddToF(), daq2raw::BeamlineEvent::AddWCDigit(), beamlinegeo::Cherenkov, beamlineutil::BeamlineChannelMap::DigitChannel(), fBeamlineEvents, fChannelMap, daq2raw::BeamlineEvents::FindEvent(), beamlinegeo::MuonStack, beamlinegeo::Other, beamlinegeo::Paddle, rawdata::RawBeamlineDigit::SetWaveform(), submit_nova_art::timestamp, beamlinegeo::ToF, and beamlinegeo::WCDigit.

Referenced by Unpack().

                                                                              {

  // Look through all triggers
  for (unsigned int v1742FragIt = 0; v1742FragIt < frags.size(); ++v1742FragIt) {

    const V1742Fragment& v1742Frag = frags[v1742FragIt];

    std::vector<rawdata::RawBeamlineDigit> cherenkovDigits, tofDigits,
      muonStackDigits, paddleDigits, wcDigits, otherDigits;

    // Get all channels for this V1742 fragment
    for (unsigned int waveform = 0; waveform < v1742Frag.waveForms.size(); ++waveform) {

      if (!fChannelMap->ActiveDigitChannel(waveform))
        continue;

      uint64_t timestamp
        = static_cast<uint64_t>(v1742Frag.triggerTimeStamps[static_cast<int>(waveform/8)]); // timestamps are saved per group
      long double timestamp_ns = static_cast<long double>(timestamp) * 8.5; //ns

      rawdata::RawBeamlineDigit digit(fChannelMap->DigitChannel(waveform));
      digit.SetWaveform(v1742Frag.waveForms[waveform].data);
      digit.SetTimestamp(timestamp_ns);

      switch (digit.ChannelID().System) {
      case beamlinegeo::BeamlineSystem::Cherenkov:
        cherenkovDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::ToF:
        tofDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::MuonStack:
        muonStackDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::Paddle:
        paddleDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::WCDigit:
        wcDigits.push_back(digit); break;
      case beamlinegeo::BeamlineSystem::Other:
        otherDigits.push_back(digit); break;
      default:
        break;
      }

    }

    fBeamlineEvents->FindEvent(v1742FragIt)->AddToF(tofDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddCherenkov(cherenkovDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddMuonStack(muonStackDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddPaddleDigit(paddleDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddWCDigit(wcDigits);
    fBeamlineEvents->FindEvent(v1742FragIt)->AddOtherDigit(otherDigits);

  }

  return;

}

void daq2raw::BeamlineUnpack::UnpackTrigger ( const std::vector< TriggerPattern::TriggerPattern_t > &  beamlineTriggers, const std::vector< TDUFragment * > &  beamlineTDUs, std::string  filename = ""  )

private

Definition at line 489 of file BeamlineUnpack.cxx.

References daq2raw::BeamlineEvent::AddTDUTime(), daq2raw::BeamlineEvent::AddTimestamp(), daq2raw::BeamlineEvent::AddTrigger(), fBeamlineEvents, fChannelMap, daq2raw::BeamlineEvents::FindEvent(), fTDUOffset, fUnpackTDU, fUnpackTrigger, findDuplicateFiles::key, make_syst_table_plots::line, runNovaSAM::metadata, elec2geo::pos, rawdata::RawBeamlineTrigger::SetTimestamp(), submit_nova_art::timestamp, and beamlineutil::BeamlineChannelMap::TrigDetector().

Referenced by Unpack().

                                                                {

  // get number of triggers
  unsigned int numTrigs = fUnpackTDU ?
    beamlineTDUs.size() : beamlineTriggers.size();

  // get metadata, containing other information about the trigger
  std::string metadata;
  if (!filename.empty()) {
    char* fullpathname = (char*)filename.c_str();
    std::string relfilename = std::string(basename(fullpathname));
    art::ServiceHandle<IFDH> ifdhp;
    try {
      metadata = ifdhp->getMetadata(relfilename);
    }
    catch (WebAPIException) {
      metadata = "";
    }
  }

  // get trigger condition for this file
  std::string trigger_condition = "";
  std::istringstream metadataStream;
  metadataStream.str(metadata);
  while (metadataStream.good()) {
    std::string line, key, value;
    std::getline(metadataStream, line);
    size_t pos = line.find(":");
    if (pos != std::string::npos) {
      key = line.substr(0, pos);
      value = line.substr(pos+1);
      if (key.find("Beamline.BeamlineTrigger") != std::string::npos) {
        value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
        trigger_condition = value;
      }
    }
  }

  // make new RawBeamlineTriggers
  for (unsigned int triggerIt = 0; triggerIt < numTrigs; ++triggerIt) {

    // get timestamps
    uint64_t timestamp =
      fUnpackTrigger? static_cast<uint64_t>(beamlineTriggers[triggerIt].timeStamp) : 0;
    long double timestamp_ns = timestamp * 10; //ns

    // get tdu timestamp
    uint64_t tduTime = fUnpackTDU? (beamlineTDUs[triggerIt]->tduFragment.at(0).timestamp + fTDUOffset) : 0;

    // make trigger object
    rawdata::RawBeamlineTrigger trigger(fChannelMap->TrigDetector(),
                                        triggerIt);
    trigger.SetTimestamp(timestamp_ns);
    trigger.SetPattern(fUnpackTrigger? beamlineTriggers[triggerIt].inputPattern : 0);
    trigger.SetTDUTime(tduTime);
    trigger.SetTriggerCondition(trigger_condition);
    std::vector<rawdata::RawBeamlineTrigger> triggers = {trigger};

    // add to event
    fBeamlineEvents->FindEvent(triggerIt)->AddTrigger(triggers);
    fBeamlineEvents->FindEvent(triggerIt)->AddTimestamp(timestamp_ns);
    fBeamlineEvents->FindEvent(triggerIt)->AddTDUTime(tduTime);

  }

  return;

}

void daq2raw::BeamlineUnpack::UnpackWC ( const TDCFragment &  frag )

private

Definition at line 618 of file BeamlineUnpack.cxx.

References daq2raw::BeamlineEvent::AddWC(), allTimeWatchdog::endl, fBeamlineEvents, fChannelMap, fChannelsPerTDC, fGeometry, daq2raw::BeamlineEvents::FindEvent(), fTDCsPerWC, makeTrainCVSamples::int, beamlinegeo::BeamlineGeometry::NumWCs(), daq2raw::BeamlineEvent::SetBadEvent(), submit_nova_art::timestamp, submit_hadd::u, and beamlineutil::BeamlineChannelMap::WCDetector().

Referenced by Unpack().

                                                            {

  // loop over events
  unsigned int event = 0;
  std::vector<std::vector<TDCFragment::TdcEventData> > tdcEvents = frag.tdcEvents;
  for (std::vector<std::vector<TDCFragment::TdcEventData> >::const_iterator tdcEventIt = tdcEvents.begin();
       tdcEventIt != tdcEvents.end(); ++tdcEventIt, ++event) {

    std::vector<rawdata::RawBeamlineWC> wcs(fGeometry->NumWCs());
    for (unsigned int wc_num = 0; wc_num < wcs.size(); ++wc_num)
      wcs[wc_num] = rawdata::RawBeamlineWC(fChannelMap->WCDetector(wc_num));

    // get the timestamp for this event
    // Non-trivial!
    // See https://cdcvs.fnal.gov/redmine/attachments/51083/TDC_Format_Description_B.pdf for a full description
    // Each TDC header has a 'controller timestamp' (16 bit, 1.18 ns ticks) and 'tdc timestamp' (32 bit, 9.4 ns ticks)
    //  --> I _believe_ they should be the same for each TDC in the event (so enforce this)
    // The bits 11..3 for the controller timestamp should be identical to bits 8..0 in the TDC timestamp
    // In order to construct the full timestamp, need to concatenate the 3 lsbs from the controller timestamp
    //   to the TDC timestamp to make a 35 bit word.  This is a timestamp in 1.18 ns ticks since the start of the spill
    std::map<unsigned int, uint16_t> controllerTimestamps;
    std::map<unsigned int, uint32_t> tdcTimestamps;

    // loop over TDCs in this event
    for (std::vector<TDCFragment::TdcEventData>::const_iterator tdcIt = tdcEventIt->begin(); tdcIt != tdcEventIt->end(); ++tdcIt) {

      unsigned int tdcNumber = (int)tdcIt->tdcEventHeader.tdcNumber - 1;
      unsigned int wcNumber = tdcNumber / fGeometry->NumWCs();
      unsigned int tdc_on_wc = tdcNumber % fGeometry->NumWCs();
      unsigned int tdc_on_plane = tdc_on_wc % fTDCsPerWC;
      unsigned int plane_on_wc = tdc_on_wc / fTDCsPerWC;

      // timestamps
      controllerTimestamps[tdcNumber] = tdcIt->tdcEventHeader.controllerTimeStamp;
      tdcTimestamps[tdcNumber] = tdcIt->tdcEventHeader.tdcTimeStamp;

      // overflow register, one for each TDC so if any are set then the whole WC gets true
      if (tdcIt->tdcEventHeader.eventStatus != 0)
        fBeamlineEvents->FindEvent(event)->SetBadEvent();

      // loop over hits in this TDC
      for (std::vector<TDCFragment::TdcHit>::const_iterator hitIt = tdcIt->tdcHits.begin(); hitIt != tdcIt->tdcHits.end(); ++hitIt) {
        unsigned int channel_on_plane = (tdc_on_plane * fChannelsPerTDC) + (int)hitIt->channel;
        rawdata::RawBeamlineWC::WCPulse pulse(channel_on_plane, hitIt->timeBin);
        plane_on_wc ? wcs[wcNumber].AddYPulse(pulse) : wcs[wcNumber].AddXPulse(pulse);
      }

    }

    // form total timestamp for event relative to start of spill
    for (std::map<unsigned int, uint16_t>::const_iterator controllerTsIt = controllerTimestamps.begin();
         controllerTsIt != controllerTimestamps.end(); ++controllerTsIt)
      if (controllerTsIt->second != controllerTimestamps.begin()->second)
        throw cet::exception("BeamlineUnpack::UnpackWC")
          << "WC controller timestamps differ between TDC fragments." << std::endl;

    for (std::map<unsigned int, uint32_t>::const_iterator tdcTsIt = tdcTimestamps.begin();
         tdcTsIt != tdcTimestamps.end(); ++tdcTsIt)
      if (tdcTsIt->second != tdcTimestamps.begin()->second)
        throw cet::exception("BeamlineUnpack::UnpackWC")
          << "TDC timestamps differ between TDC fragments." << std::endl;

    uint32_t tdcTs = tdcTimestamps.begin()->second;
    uint32_t controllerTs = controllerTimestamps.begin()->second;

    uint16_t tdcCommon = tdcTs & 0x1FFu;
    uint16_t controllerCommon = (controllerTs & 0xFF8u) >> 3;
    if (tdcCommon != controllerCommon)
      throw cet::exception("BeamlineUnpack::UnpackWC")
        << "Synchronization problem between MWPC controller and TDC timestamps." << std::endl
        << "Bits 8..0 of TDC timestamp " << std::bitset<9>(tdcCommon) << "; "
        << "bits 11..3 of controller timetamp " << std::bitset<9>(controllerCommon) << std::endl;

    uint64_t timestamp = static_cast<uint64_t>(((std::bitset<35>(tdcTimestamps.begin()->second) << 3) |
                                                (std::bitset<35>(controllerTimestamps.begin()->second & 0x7))).to_ullong());
    long double timestamp_ns = timestamp * 1.18; //ns
    for (std::vector<rawdata::RawBeamlineWC>::iterator wcIt = wcs.begin(); wcIt != wcs.end(); ++wcIt)
      wcIt->SetTimestamp(timestamp_ns);

    fBeamlineEvents->FindEvent(event)->AddWC(wcs);

  }

  return;

}

Member Data Documentation

BeamlineEvents* daq2raw::BeamlineUnpack::fBeamlineEvents

private

Definition at line 236 of file BeamlineUnpack.h.

Referenced by EndSpill(), GetBeamlineEvents(), Unpack(), UnpackConfig(), UnpackDigits(), UnpackTrigger(), and UnpackWC().

art::ServiceHandle<beamlineutil::BeamlineChannelMap> daq2raw::BeamlineUnpack::fChannelMap

private

Definition at line 207 of file BeamlineUnpack.h.

Referenced by UnpackDigits(), UnpackTrigger(), and UnpackWC().

unsigned int daq2raw::BeamlineUnpack::fChannelsPerTDC

private

Definition at line 218 of file BeamlineUnpack.h.

Referenced by reconfigure(), and UnpackWC().

art::ServiceHandle<beamlinegeo::BeamlineGeometry> daq2raw::BeamlineUnpack::fGeometry

private

Definition at line 208 of file BeamlineUnpack.h.

Referenced by UnpackWC().

art::ServiceHandle<beamlineutil::BeamlineMagneticField> daq2raw::BeamlineUnpack::fMagneticField

private

Definition at line 209 of file BeamlineUnpack.h.

Referenced by UnpackConfig().

unsigned int daq2raw::BeamlineUnpack::fTDCsPerWC

private

Definition at line 219 of file BeamlineUnpack.h.

Referenced by reconfigure(), and UnpackWC().

int daq2raw::BeamlineUnpack::fTDUOffset

private

Definition at line 221 of file BeamlineUnpack.h.

Referenced by reconfigure(), and UnpackTrigger().

unsigned int daq2raw::BeamlineUnpack::fTriggerLatency

private

Definition at line 220 of file BeamlineUnpack.h.

Referenced by CleanTriggers(), and reconfigure().

std::string daq2raw::BeamlineUnpack::fTriggerSource

private

Definition at line 212 of file BeamlineUnpack.h.

Referenced by reconfigure(), and Unpack().

bool daq2raw::BeamlineUnpack::fUnpackDigitizer

private

Definition at line 214 of file BeamlineUnpack.h.

Referenced by reconfigure(), and Unpack().

bool daq2raw::BeamlineUnpack::fUnpackTDU

private

Definition at line 216 of file BeamlineUnpack.h.

Referenced by reconfigure(), Unpack(), and UnpackTrigger().

bool daq2raw::BeamlineUnpack::fUnpackTrigger

private

Definition at line 213 of file BeamlineUnpack.h.

Referenced by reconfigure(), Unpack(), and UnpackTrigger().

bool daq2raw::BeamlineUnpack::fUnpackWireChamber

private

Definition at line 215 of file BeamlineUnpack.h.

Referenced by reconfigure(), and Unpack().

---

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

• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-09-26/DAQ2RawDigit/testbeam/BeamlineUnpack.h
• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-09-26/DAQ2RawDigit/testbeam/BeamlineUnpack.cxx