DAQToOffline::SSPReformatterAlgs Class Reference

#include <SSPReformatterAlgs.h>

Public Member Functions
	SSPReformatterAlgs (fhicl::ParameterSet const &pset)
void	SSPFragmentToWaveformsAndHits (artdaq::Fragments const &rawFragments, std::vector< raw::OpDetWaveform > &opDetWaveformVector, std::vector< recob::OpHit > &opHitVector)
std::vector< raw::OpDetWaveform >	SSPFragmentToOpDetWaveform (artdaq::Fragments const &raw)
	Construct a waveform from each trigger. More...
std::vector< recob::OpHit >	SSPHeaderToOpHit (artdaq::Fragments const &raw)
void	PrintHeaderInfo (const SSPDAQ::EventHeader *daqHeader)
	Print out header information. More...
unsigned int	CheckAndGetNTriggers (const artdaq::Fragment &frag, const lbne::SSPFragment sspf)
	Load the milislice. More...
const SSPDAQ::EventHeader *	GetHeaderAndAdvance (const unsigned int *&dataPointer)
	Load the header. More...
uint32_t	GetPeakSum (const SSPDAQ::EventHeader *daqHeader)
unsigned short	GetOpChannel (const SSPDAQ::EventHeader *daqHeader)
unsigned long	GetGlobalFirstSample (const SSPDAQ::EventHeader *daqHeader)
unsigned long	GetInternalFirstSample (const SSPDAQ::EventHeader *daqHeader)
unsigned long	GetBaselineSum (const SSPDAQ::EventHeader *daqHeader)
unsigned long	GetIntegratedSum (const SSPDAQ::EventHeader *daqHeader)
unsigned int	GetPeakTime (const SSPDAQ::EventHeader *daqHeader)
unsigned int	GetWaveformLength (const SSPDAQ::EventHeader *daqHeader)
double	ClockFrequency ()
	Return the NOvAClockFrequency. More...

Private Member Functions
raw::OpDetWaveform	ConstructWaveformAndAdvance (const SSPDAQ::EventHeader *daqHeader, const unsigned int *&dataPointer)
	Construct a waveform from the adc vector, advance the data pointer when done. More...
recob::OpHit	ConstructOpHit (const SSPDAQ::EventHeader *daqHeader)
	Construct an OpHit object from the daqHeader. More...
void	BuildOpDetChannelMap (std::string fChannelMapFile)

Private Attributes
double	NOvAClockFrequency
std::map< int, int >	theChannelMap
int	m1
int	i1
int	i2
double	SPESize

Detailed Description

Definition at line 30 of file SSPReformatterAlgs.h.

Constructor & Destructor Documentation

DAQToOffline::SSPReformatterAlgs::SSPReformatterAlgs

(

fhicl::ParameterSet const &

pset

)

Definition at line 26 of file SSPReformatterAlgs.cc.

                                                                                 :
                                                     NOvAClockFrequency(pset.get<double>("NOvAClockFrequency")), // in MHz
                                                     m1(pset.get<int>("SSPm1")),
                                                     i1(pset.get<int>("SSPi1")),
                                                     i2(pset.get<int>("SSPi2")),
                                                     SPESize(pset.get<float>("SPESize"))

{
  BuildOpDetChannelMap(pset.get<std::string>("OpDetChannelMapFile"));
}

Member Function Documentation

void DAQToOffline::SSPReformatterAlgs::BuildOpDetChannelMap ( std::string  fChannelMapFile )

private

Definition at line 245 of file SSPReformatterAlgs.cc.

{
    theChannelMap.clear();

    int onlineChannel;
    int offlineChannel;
    
    std::string fullname;
    cet::search_path sp("FW_SEARCH_PATH");
    sp.find_file(fChannelMapFile, fullname);
    
    if ( fullname.empty() ) {
      mf::LogWarning("DAQToOffline") << "Input spectrum file "
                                        << fChannelMapFile
                                        << " not found in FW_SEARCH_PATH, using debugging map!\n";
    } 
    else {
      mf::LogVerbatim("DAQToOffline") << "Build Online->Offline channel Map from " << fullname;
      std::ifstream infile(fullname);
      while (infile.good()) {
        infile >> onlineChannel >> offlineChannel;
        theChannelMap[onlineChannel] = offlineChannel;
        mf::LogVerbatim("DAQToOffline") << "   " << onlineChannel << " -> " << offlineChannel;
      }
    }
    
}

unsigned int DAQToOffline::SSPReformatterAlgs::CheckAndGetNTriggers	(	const artdaq::Fragment &	frag,
		const lbne::SSPFragment	sspf
	)

Load the milislice.

Definition at line 206 of file SSPReformatterAlgs.cc.

{
    mf::LogDebug("DAQToOffline") << "\n"
                                 << "SSP fragment "     << frag.fragmentID() 
                                 << " has total size: " << sspf.hdr_event_size()
                                 << " and run number: " << sspf.hdr_run_number()
                                 << " with " << sspf.total_adc_values() << " total ADC values"
                                 << "\n"
                                 << "\n";

    const SSPDAQ::MillisliceHeader* meta=0;
    //get the information from the header
    if(frag.hasMetadata())
    {
        meta = &(frag.metadata<lbne::SSPFragment::Metadata>()->sliceHeader);
            
        mf::LogInfo("DAQToOffline")
          << "===Slice metadata====" << "\n"
          << "  Start time         " << meta->startTime << "\n"
          << "  End time           " << meta->endTime << "\n"
          << "  Packet length      " << meta->length << "\n"
          << "  Number of triggers " << meta->nTriggers << "\n"
          << "=====================";
    }
    else
    {
        mf::LogWarning("DAQToOffline") << "SSP fragment has no metadata associated with it.";
    }

    // No metadata, no trigger count
    if (meta == 0) return 0;

    return meta->nTriggers;
}

double DAQToOffline::SSPReformatterAlgs::ClockFrequency ( )

inline

Return the NOvAClockFrequency.

Definition at line 68 of file SSPReformatterAlgs.h.

{ return NOvAClockFrequency; }

recob::OpHit DAQToOffline::SSPReformatterAlgs::ConstructOpHit ( const SSPDAQ::EventHeader *  daqHeader )

private

Construct an OpHit object from the daqHeader.

< Derived Optical channel

< first sample time in ticks

< first sample time in microseconds

Definition at line 421 of file SSPReformatterAlgs.cc.

{
  // Get basic information from the header
  unsigned short     OpChannel   = GetOpChannel(daqHeader);                  ///< Derived Optical channel
  unsigned long      FirstSample = GetGlobalFirstSample(daqHeader);;         ///< first sample time in ticks
  double             TimeStamp   = ((double)FirstSample)/NOvAClockFrequency; ///< first sample time in microseconds
  
  auto const* ts = lar::providerFrom<detinfo::DetectorClocksService>();
  
  double peakTime = ((double)GetPeakTime(daqHeader)) * ts->OpticalClock().TickPeriod(); // microseconds
  double width = ((double)i1) * ts->OpticalClock().TickPeriod(); // microseconds
  
  double pedestal = ((double)GetBaselineSum(daqHeader)) / ((double)i1);
  double area = ((double)GetIntegratedSum(daqHeader))  - pedestal * i2;
  double peak = ((double)GetPeakSum(daqHeader)) / ((double)m1) - pedestal;
  
  
  recob::OpHit ophit(OpChannel,
                     TimeStamp+peakTime,  // Relative Time
                     TimeStamp+peakTime,  // Absolute time
                     0,          // Frame, not used by DUNE
                     width,
                     area,
                     peak,
                     area / SPESize, // PE
                     0.);
  
  return ophit;
}

raw::OpDetWaveform DAQToOffline::SSPReformatterAlgs::ConstructWaveformAndAdvance ( const SSPDAQ::EventHeader *  daqHeader, const unsigned int *&  dataPointer  )

private

Construct a waveform from the adc vector, advance the data pointer when done.

< Derived Optical channel

< first sample time in ticks

< first sample time in microseconds

Definition at line 387 of file SSPReformatterAlgs.cc.

{
  
  // Get basic information from the header
  unsigned short     OpChannel   = GetOpChannel(daqHeader);                  ///< Derived Optical channel
  unsigned long      FirstSample = GetGlobalFirstSample(daqHeader);          ///< first sample time in ticks
  double             TimeStamp   = ((double)FirstSample)/NOvAClockFrequency; ///< first sample time in microseconds

  // Print some debugging info
  PrintHeaderInfo(daqHeader);
  
  // Get ADC Count, create pointer to adcs
  unsigned int          nADC       = GetWaveformLength(daqHeader);
  const unsigned short* adcPointer = reinterpret_cast<const unsigned short*>(dataPointer);
  
  // Initialize the waveform
  raw::OpDetWaveform Waveform(TimeStamp, OpChannel, nADC);
  
  // Build up the waveform
  for(size_t idata = 0; idata < nADC; idata++) {
    const unsigned short* adc = adcPointer + idata;
    Waveform.push_back(*adc);
  }
  
  // Advance the dataPointer to the next header
  dataPointer+=nADC/2;
  
  return Waveform;
}

unsigned long DAQToOffline::SSPReformatterAlgs::GetBaselineSum

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 355 of file SSPReformatterAlgs.cc.

{
  return ((daqHeader->group4 & 0x00FF) << 16) + daqHeader->preriseLow;
  
}

unsigned long DAQToOffline::SSPReformatterAlgs::GetGlobalFirstSample

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 333 of file SSPReformatterAlgs.cc.

{
  return (   ( (unsigned long)daqHeader->timestamp[3] << 48 )
           + ( (unsigned long)daqHeader->timestamp[2] << 32 )
           + ( (unsigned long)daqHeader->timestamp[1] << 16 )
           + ( (unsigned long)daqHeader->timestamp[0] ) );
}

const SSPDAQ::EventHeader * DAQToOffline::SSPReformatterAlgs::GetHeaderAndAdvance

(

const unsigned int *&

dataPointer

)

Load the header.

Definition at line 276 of file SSPReformatterAlgs.cc.

{
  // Load the event header, advance the pointer
  const SSPDAQ::EventHeader* daqHeader=reinterpret_cast<const SSPDAQ::EventHeader*>(dataPointer);
  dataPointer += sizeof(SSPDAQ::EventHeader)/sizeof(unsigned int);
  return daqHeader;
}

unsigned long DAQToOffline::SSPReformatterAlgs::GetIntegratedSum

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 363 of file SSPReformatterAlgs.cc.

{
  return ((unsigned int)(daqHeader->intSumHigh) << 8) + (((unsigned int)(daqHeader->group4) & 0xFF00) >> 8);
}

unsigned long DAQToOffline::SSPReformatterAlgs::GetInternalFirstSample

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 345 of file SSPReformatterAlgs.cc.

{
  return (   ((uint64_t)((uint64_t)daqHeader->intTimestamp[3] << 32))
           + ((uint64_t)((uint64_t)daqHeader->intTimestamp[2]) << 16)
           + ((uint64_t)((uint64_t)daqHeader->intTimestamp[1])) );
}

unsigned short DAQToOffline::SSPReformatterAlgs::GetOpChannel

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 303 of file SSPReformatterAlgs.cc.

{
  unsigned short OpChannel = -1;
  
  // Extract values we need for the data product
  if ( theChannelMap.size() == 0) {
    // No channel map, default to debugging map
    int HardwareChannel = ((daqHeader->group2 & 0x000F) >> 0); // Channel Number
    int SSPNumber       = ((daqHeader->group2 & 0x00F0) >> 4); // Module Number
    OpChannel = 100*SSPNumber + HardwareChannel;
  }
  else if ( theChannelMap.find(daqHeader->group2) != theChannelMap.end() ) {
    OpChannel = theChannelMap[daqHeader->group2];
  }
  else {
    int HardwareChannel = ((daqHeader->group2 & 0x000F) >> 0); // Channel Number
    int SSPNumber       = ((daqHeader->group2 & 0x00F0) >> 4); // Module Number
    mf::LogWarning("DAQToOffline") << "SSP " << SSPNumber << " Channel " << HardwareChannel
                                             << "(" << daqHeader->group2 << ") "
                                             << " not in the map (OK for uninstrumented channels), skipping." << std::endl;
    throw cet::exception( "SSP Channel Invalid" );
  }

  return OpChannel;
}

uint32_t DAQToOffline::SSPReformatterAlgs::GetPeakSum

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 289 of file SSPReformatterAlgs.cc.

{
  uint32_t peaksum = ((daqHeader->group3 & 0x00FF) >> 16) + daqHeader->peakSumLow;
  if(peaksum & 0x00800000) {
    peaksum |= 0xFF000000;
  }
  return peaksum;
}

unsigned int DAQToOffline::SSPReformatterAlgs::GetPeakTime

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 370 of file SSPReformatterAlgs.cc.

{
  return (daqHeader->group3 & 0xFF00) >> 8 ;
}

unsigned int DAQToOffline::SSPReformatterAlgs::GetWaveformLength

(

const SSPDAQ::EventHeader *

daqHeader

)

Definition at line 378 of file SSPReformatterAlgs.cc.

{
  unsigned int nADC=(daqHeader->length-sizeof(SSPDAQ::EventHeader)/sizeof(unsigned int))*2;
  return nADC;
}

void DAQToOffline::SSPReformatterAlgs::PrintHeaderInfo

(

const SSPDAQ::EventHeader *

daqHeader

)

Print out header information.

Definition at line 161 of file SSPReformatterAlgs.cc.

{
  auto FirstSample = GetGlobalFirstSample(daqHeader);
  auto InternalSample = GetInternalFirstSample(daqHeader);
  auto TimeStamp = ((double)FirstSample)/NOvAClockFrequency;
  auto InternalTimeStamp = ((double)InternalSample)/NOvAClockFrequency;
  
  mf::LogDebug("DAQToOffline")
  << "Header:                             " << daqHeader->header   << "\n"
  << "Length:                             " << daqHeader->length   << "\n"
  << "Trigger type:                       " << ((daqHeader->group1 & 0xFF00) >> 8) << "\n"
  << "Status flags:                       " << ((daqHeader->group1 & 0x00F0) >> 4) << "\n"
  << "Header type:                        " << ((daqHeader->group1 & 0x000F) >> 0) << "\n"
  << "Trigger ID:                         " << daqHeader->triggerID << "\n"
  << "Module ID:                          " << ((daqHeader->group2 & 0xFFF0) >> 4) << "\n"
  << "Channel ID:                         " << ((daqHeader->group2 & 0x000F) >> 0) << "\n"
  << "OpChannel:                          " << GetOpChannel(daqHeader) << "\n"
  << "External (NOvA) timestamp:          " << FirstSample << " ticks" << "\n"
  << "                                    " << TimeStamp << " microseconds" << "\n"
  // these first_ ouptuts are a little ill-defined anyway since they are not
  // reset by run but rather with the job
  //<< "Since first sample this run:        " << FirstSample-first_FirstSample << " ticks" << "\n"
  //<< "                                    " << TimeStamp-first_TimeStamp << " microseconds" << "\n"
  << "Peak sum:                           " << GetPeakSum(daqHeader) << "\n"
  << "Peak time:                          " << GetPeakTime(daqHeader) << "\n"
  
  << "Baseline Sum (Prerise):             " << GetBaselineSum(daqHeader) << "\n"
  << "Integrated sum:                     " << GetIntegratedSum(daqHeader) << "\n"
  << "Baseline:                           " << daqHeader->baseline << "\n"
  << "CFD Timestamp interpolation points: " << daqHeader->cfdPoint[0] << " " << daqHeader->cfdPoint[1]
  << " " << daqHeader->cfdPoint[2] << " " << daqHeader->cfdPoint[3] << "\n"
  << "Internal interpolation point:       " << daqHeader->intTimestamp[0] << "\n"
  << "Internal timestamp:                 " << InternalSample << " ticks\n"
  << "                                    " << InternalTimeStamp << " microseconds" << "\n"
  //<< "Relative internal timestamp:        " << InternalSample-first_InternalSample << " ticks" << "\n"
  //<< "                                    " << InternalTimeStamp-first_InternalTimeStamp << " microseconds"
  << ""  ;
  
}

std::vector< raw::OpDetWaveform > DAQToOffline::SSPReformatterAlgs::SSPFragmentToOpDetWaveform

(

artdaq::Fragments const &

raw

)

Construct a waveform from each trigger.

Definition at line 85 of file SSPReformatterAlgs.cc.

{
  std::vector<raw::OpDetWaveform> opDetWaveformVector;

  unsigned int numFragments = rawFragments.size();

  for (size_t idx = 0; idx < numFragments; ++idx) {
    const auto& frag(rawFragments[idx]);
    lbne::SSPFragment sspf(frag);

    unsigned int nTriggers = CheckAndGetNTriggers(frag, sspf);
      
    const unsigned int* dataPointer = sspf.dataBegin();

        
    for (unsigned int triggersProcessed = 0;
         (nTriggers==0 || triggersProcessed < nTriggers) && dataPointer < sspf.dataEnd();
         ++triggersProcessed) {

      try {
        auto daqHeader = GetHeaderAndAdvance(dataPointer);
        opDetWaveformVector.emplace_back( ConstructWaveformAndAdvance(daqHeader, dataPointer) );
      }
      catch (cet::exception const&) {
        continue;
      }
      
    } // End of loop over triggers
  } // End of loop over fragments (rawFragments)

  return opDetWaveformVector;
}

void DAQToOffline::SSPReformatterAlgs::SSPFragmentToWaveformsAndHits	(	artdaq::Fragments const &	rawFragments,
		std::vector< raw::OpDetWaveform > &	opDetWaveformVector,
		std::vector< recob::OpHit > &	opHitVector
	)

Construct OpDetWaveform objects from triggers with full waveforms and construct OpHit objects from triggers which only have headers.

Definition at line 41 of file SSPReformatterAlgs.cc.

{
  unsigned int numFragments = rawFragments.size();
  
  for (size_t idx = 0; idx < numFragments; ++idx) {
    const auto& frag(rawFragments[idx]);
    lbne::SSPFragment sspf(frag);
    
    unsigned int nTriggers = CheckAndGetNTriggers(frag, sspf);
    
    const unsigned int* dataPointer = sspf.dataBegin();
    
    
    for (unsigned int triggersProcessed = 0;
         (nTriggers==0 || triggersProcessed < nTriggers) && dataPointer < sspf.dataEnd();
         ++triggersProcessed) {
      
      try {
        auto daqHeader = GetHeaderAndAdvance(dataPointer);
        if ( GetWaveformLength(daqHeader) > 0) {
          // We have a waveform
          opDetWaveformVector.emplace_back( ConstructWaveformAndAdvance(daqHeader, dataPointer) );
          
        }
        else {
          // We only have a header
          opHitVector.emplace_back( ConstructOpHit(daqHeader) );
        }
        
      }
      catch (cet::exception const&) {
        continue;
      }
    } // End of loop over triggers
  } // End of loop over fragments (rawFragments)

  
}

std::vector< recob::OpHit > DAQToOffline::SSPReformatterAlgs::SSPHeaderToOpHit

(

artdaq::Fragments const &

raw

)

Definition at line 120 of file SSPReformatterAlgs.cc.

{
  std::vector<recob::OpHit> opHitVector;
  
  unsigned int numFragments = rawFragments.size();
  
  
  for (size_t idx = 0; idx < numFragments; ++idx) {
    const auto& frag(rawFragments[idx]);
    lbne::SSPFragment sspf(frag);
    
    unsigned int nTriggers = CheckAndGetNTriggers(frag, sspf);
    const unsigned int* dataPointer = sspf.dataBegin();
    
    
    for (unsigned int triggersProcessed = 0;
         (nTriggers==0 || triggersProcessed < nTriggers) && dataPointer < sspf.dataEnd();
         ++triggersProcessed) {
      
      
      try {
        auto daqHeader = GetHeaderAndAdvance(dataPointer);
        opHitVector.emplace_back( ConstructOpHit(daqHeader) );
        
        // Advance the dataPointer to the next header
        unsigned int nADC = GetWaveformLength(daqHeader);
        dataPointer+=nADC/2;
      }
      catch (cet::exception const&) {
        continue;
      }
    } // End of loop over triggers
  } // End of loop over fragments (rawFragments)
  
  return opHitVector;
}

Member Data Documentation

int DAQToOffline::SSPReformatterAlgs::i1

private

Definition at line 82 of file SSPReformatterAlgs.h.

int DAQToOffline::SSPReformatterAlgs::i2

private

Definition at line 83 of file SSPReformatterAlgs.h.

int DAQToOffline::SSPReformatterAlgs::m1

private

Definition at line 81 of file SSPReformatterAlgs.h.

double DAQToOffline::SSPReformatterAlgs::NOvAClockFrequency

private

Definition at line 78 of file SSPReformatterAlgs.h.

double DAQToOffline::SSPReformatterAlgs::SPESize

private

Definition at line 84 of file SSPReformatterAlgs.h.

std::map<int,int> DAQToOffline::SSPReformatterAlgs::theChannelMap

private

Definition at line 79 of file SSPReformatterAlgs.h.

---

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

• dunetpc/dune/daqinput35t/SSPReformatterAlgs.h
• dunetpc/dune/daqinput35t/SSPReformatterAlgs.cc