dune Namespace Reference

Namespaces
	apa
	detail
	frame14
	HDF5Utils
	HDFFileReader
	tde
	testing
	Namespace including DUNE-specific testing.

Classes
class	AnalysisTree
	Creates a simple ROOT tree with tracking and calorimetry information. More...
class	AnalysisTreeDataStruct
class	AnaRootParser
	Creates a simple ROOT tree with tracking and calorimetry information. More...
class	AnaRootParserDataStruct
class	CalibrationdEdXPDSP
class	ChannelInformation
class	CheckAuxDet
class	CheckGeometry
class	CheckRecoEnergy
struct	ColdataBlock
struct	ColdataHeader
struct	ColdataSegment
struct	ContainerValueType
	Class whose "type" contains the base data type of the container. More...
struct	ContainerValueType< std::vector< AnalysisTreeDataStruct::BoxedArray< A > > >
struct	ContainerValueType< std::vector< AnaRootParserDataStruct::BoxedArray< A > > >
struct	ContainerValueType< std::vector< T > >
class	CounterFilter
class	CTBFragment
class	dEdxcalibration
class	DisambigAlg35t
class	DisambigAlgProtoDUNESP
class	DisambigFromSpacePoints
class	DPChannelId
class	DUNEGeometryHelper
class	EmLikeHits
class	EnergyReco
class	EnergyRecoOutput
class	FelixCompressor
class	FelixDecoder
class	FelixFragment
class	FelixFragmentBase
class	FelixFragmentCompressed
class	FelixFragmentReordered
class	FelixFragmentUnordered
class	FelixFrame
class	FelixIntegrityTest
class	FelixRawDecoder
class	FelixReorder
class	Frame14Fragment
class	Frame14FragmentUnordered
class	HDF5RawInputDetail
class	HitFinder35t
class	HitFinderProtoDUNESP
class	HitInformation
class	HitLineFitAlg
class	HitRepeater
struct	HuffTree
class	IcebergChannelMapService
struct	IndexCrate
struct	IndexCrateCard
struct	IndexCrateCardChan
struct	IndexCrateCardChanHash
struct	IndexCrp
struct	IndexCrpView
struct	IndexCrpViewChan
struct	IndexCrpViewChanHash
struct	IndexRawSeqn
struct	IndexRawSeqnHash
struct	MetaData
class	michelremoving
class	MicroSlice
class	MicroSliceWriter
class	MilliSlice
class	MilliSliceFragment
class	MilliSliceFragmentWriter
class	MilliSliceWriter
class	NanoSlice
class	NanoSliceWriter
class	NeutrinoEnergyRecoAlg
	NeutrinoEnergyRecoAlg class. More...
class	PDDPChannelMap
class	PdspChannelMapService
struct	PdspHDFFileReader
	The PdspHDFFileReader is a class which implements the methods needed by art::Source. More...
class	PennMicroSlice
class	PennMicroSliceWriter
class	PennMilliSlice
class	PennMilliSliceFragment
class	PennMilliSliceWriter
class	PFPEfficiency
class	ProtoDUNETimeStamp
class	protonanalysis
class	RceFragment
class	RceRawDecoder
class	ReorderFacility
class	RMSHitFinderAlg
struct	ROOTTreeCode
	Contains ROOTTreeCode<>::code, ROOT tree character for branch of type T. More...
struct	ROOTTreeCode< Double_t >
struct	ROOTTreeCode< Int_t >
struct	ROOTTreeCode< Short_t >
class	SignalToNoise
class	SlidingAverage
class	SSPFragment
class	SSPFragmentWriter
class	SSPRawDecoder
class	T0Counter
class	TimeBasedDisambig
class	TimingFragment
class	TimingRawDecoder
class	ToyFragment
class	ToyFragmentWriter
class	VDColdboxChannelMapService
class	VDColdboxPDSDecoder
class	VDColdboxTDEChannelMapService
struct	WIBHeader
class	XYZcalibration

Typedefs
typedef uint32_t	word_t
typedef uint16_t	adc_t
typedef std::vector< uint16_t >	adc_v
typedef std::vector< dune::RceFragment >	RceFragments
using	HDF5RawInputSource = art::Source< HDF5RawInputDetail >
typedef multi_index_container< DPChannelId, indexed_by< ordered_unique< tag< IndexRawSeqn >, const_mem_fun< DPChannelId, const unsigned,&DPChannelId::seqn > >, hashed_unique< tag< IndexRawSeqnHash >, const_mem_fun< DPChannelId, const unsigned,&DPChannelId::seqn > >, hashed_non_unique< tag< IndexCrate >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crate > >, hashed_non_unique< tag< IndexCrateCard >, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crate >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::card > > >, ordered_unique< tag< IndexCrateCardChan >, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crate >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::card >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::cardch > > >, hashed_unique< tag< IndexCrateCardChanHash >, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crate >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::card >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::cardch > > >, hashed_non_unique< tag< IndexCrp >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crp > >, hashed_non_unique< tag< IndexCrpView >, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crp >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::view > > >, ordered_unique< tag< IndexCrpViewChan >, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crp >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::view >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::viewch > > >, hashed_unique< tag< IndexCrpViewChanHash >, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::crp >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::view >, const_mem_fun< DPChannelId, const unsigned short,&DPChannelId::viewch > > > > >	DPChannelTable
typedef std::map< unsigned int, std::vector< size_t > >	plane_keymap
typedef std::map< unsigned int, plane_keymap >	tpc_plane_keymap
typedef std::map< unsigned int, tpc_plane_keymap >	cryo_tpc_plane_keymap
typedef std::vector< HitInformation >	HitVec_t
typedef std::map< int, ChannelInformation >	ChanMap_t

Enumerations
enum	TimingCommand {   TimingCommand::TimeSync = 0x0, TimingCommand::Echo = 0x1, TimingCommand::SpillStart = 0x2, TimingCommand::SpillStop = 0x3,   TimingCommand::RunStart = 0x4, TimingCommand::RunStop = 0x5, TimingCommand::WibCalib = 0x6, TimingCommand::SSPCalib = 0x7,   TimingCommand::FakeTrig0 = 0x8, TimingCommand::FakeTrig1 = 0x9, TimingCommand::FakeTrig2 = 0xa, TimingCommand::FakeTrig3 = 0xb,   TimingCommand::BeamTrig = 0xc, TimingCommand::NoBeamTrig = 0xd, TimingCommand::ExtFakeTrig = 0xe }
enum	ProtoDUNETimingCommand {   ProtoDUNETimingCommand::TimeSync = 0x0, ProtoDUNETimingCommand::Echo = 0x1, ProtoDUNETimingCommand::SpillStart = 0x2, ProtoDUNETimingCommand::SpillStop = 0x3,   ProtoDUNETimingCommand::RunStart = 0x4, ProtoDUNETimingCommand::RunStop = 0x5, ProtoDUNETimingCommand::WibCalib = 0x6, ProtoDUNETimingCommand::SSPCalib = 0x7,   ProtoDUNETimingCommand::FakeTrig0 = 0x8, ProtoDUNETimingCommand::FakeTrig1 = 0x9, ProtoDUNETimingCommand::FakeTrig2 = 0xa, ProtoDUNETimingCommand::FakeTrig3 = 0xb,   ProtoDUNETimingCommand::BeamTrig = 0xc, ProtoDUNETimingCommand::NoBeamTrig = 0xd, ProtoDUNETimingCommand::ExtFakeTrig = 0xe }

Functions
std::ostream &	operator<< (std::ostream &out, CTBFragment const &f)
std::vector< char >	FelixCompress (const dune::FelixFragment &frag)
artdaq::Fragment	FelixDecompress (const std::vector< char > &buff)
artdaq::Fragment	FelixReorder (const uint8_t *src, const uint16_t &num_frames=6000)
FragmentType	toFragmentType (std::string t_string)
std::string	fragmentTypeToString (FragmentType val)
std::map< artdaq::Fragment::type_t, std::string >	makeFragmentTypeMap ()
const Frame14Fragment *	ParseFrame14Fragment (const artdaq::Fragment &fragment)
std::ostream &	operator<< (std::ostream &, SSPFragment const &)
std::ostream &	operator<< (std::ostream &, TimingFragment const &)
std::ostream &	operator<< (std::ostream &, ToyFragment const &)
void	display_bits (void *memstart, size_t nbytes, std::string sourcename)
template<typename S , typename T >
S	reinterpret_cast_checked (T inptr)
artdaq::Fragments	getHandleChecked (const art::Event &evt, const std::string &label, const std::string &fragtype, const bool &inContainer)

Variables
static std::vector< std::string > const	names
class dune::Frame14Fragmentstruct dune::frame14::__attribute__	aligned

Typedef Documentation

typedef uint16_t dune::adc_t

Definition at line 18 of file FelixFormat.hh.

typedef std::vector<uint16_t> dune::adc_v

Definition at line 19 of file FelixFormat.hh.

typedef std::map<int,ChannelInformation> dune::ChanMap_t

Definition at line 82 of file RobustHitFinderSupport.h.

typedef std::map< unsigned int, tpc_plane_keymap > dune::cryo_tpc_plane_keymap

Definition at line 48 of file DisambigFromSpacePoints_module.cc.

typedef multi_index_container< DPChannelId, indexed_by< ordered_unique< tag<IndexRawSeqn>, const_mem_fun< DPChannelId, const unsigned, &DPChannelId::seqn > >, hashed_unique< tag<IndexRawSeqnHash>, const_mem_fun< DPChannelId, const unsigned, &DPChannelId::seqn > >, hashed_non_unique< tag<IndexCrate>, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crate > >, hashed_non_unique< tag<IndexCrateCard>, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crate >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::card > > >, ordered_unique< tag<IndexCrateCardChan>, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crate >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::card >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::cardch > > >, hashed_unique< tag<IndexCrateCardChanHash>, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crate >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::card >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::cardch > > >, hashed_non_unique< tag<IndexCrp>, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crp > >, hashed_non_unique< tag<IndexCrpView>, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crp >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::view > > >, ordered_unique< tag<IndexCrpViewChan>, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crp >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::view >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::viewch > > >, hashed_unique< tag<IndexCrpViewChanHash>, composite_key< DPChannelId, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::crp >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::view >, const_mem_fun< DPChannelId, const unsigned short, &DPChannelId::viewch > > > > > dune::DPChannelTable

Definition at line 129 of file PDDPChannelMap.h.

using dune::HDF5RawInputSource = typedef art::Source<HDF5RawInputDetail>

Definition at line 130 of file HDF5RawInput_source.cc.

typedef std::vector<HitInformation> dune::HitVec_t

Definition at line 59 of file RobustHitFinderSupport.h.

typedef std::map< unsigned int, std::vector< size_t > > dune::plane_keymap

Definition at line 46 of file DisambigFromSpacePoints_module.cc.

typedef std::vector<dune::RceFragment> dune::RceFragments

Definition at line 13 of file RceFragment.hh.

typedef std::map< unsigned int, plane_keymap > dune::tpc_plane_keymap

Definition at line 47 of file DisambigFromSpacePoints_module.cc.

typedef uint32_t dune::word_t

Definition at line 17 of file FelixFormat.hh.

Enumeration Type Documentation

enum dune::ProtoDUNETimingCommand

strong

Enumerator
TimeSync
Echo
SpillStart
SpillStop
RunStart
RunStop
WibCalib
SSPCalib
FakeTrig0
FakeTrig1
FakeTrig2
FakeTrig3
BeamTrig
NoBeamTrig
ExtFakeTrig

Definition at line 19 of file ProtoDUNETimeStamp.h.

                                      {
        // From https://twiki.cern.ch/twiki/bin/view/CENF/TimingSystemAdvancedOp retrieved on 2018-09-07
        // The 'sync' bus has the following commands at the moment:
        TimeSync   = 0x0,
        Echo       = 0x1,
        SpillStart = 0x2,
        SpillStop  = 0x3,
        RunStart   = 0x4,
        RunStop    = 0x5,
        WibCalib   = 0x6,
        SSPCalib   = 0x7,
        FakeTrig0  = 0x8,
        FakeTrig1  = 0x9,
        FakeTrig2  = 0xa,
        FakeTrig3  = 0xb,
        BeamTrig   = 0xc,
        NoBeamTrig = 0xd,
        ExtFakeTrig= 0xe
  };

enum dune::TimingCommand

strong

Enumerator
TimeSync
Echo
SpillStart
SpillStop
RunStart
RunStop
WibCalib
SSPCalib
FakeTrig0
FakeTrig1
FakeTrig2
FakeTrig3
BeamTrig
NoBeamTrig
ExtFakeTrig

Definition at line 29 of file TimingFragment.hh.

                           {
    // From https://twiki.cern.ch/twiki/bin/view/CENF/TimingSystemAdvancedOp retrieved on 2018-10-02
    // The 'sync' bus has the following commands at the moment:
    TimeSync   = 0x0,
    Echo       = 0x1,
    SpillStart = 0x2,
    SpillStop  = 0x3,
    RunStart   = 0x4,
    RunStop    = 0x5,
    WibCalib   = 0x6,
    SSPCalib   = 0x7,
    FakeTrig0  = 0x8,
    FakeTrig1  = 0x9,
    FakeTrig2  = 0xa,
    FakeTrig3  = 0xb,
    BeamTrig   = 0xc,
    NoBeamTrig = 0xd,
    ExtFakeTrig   = 0xe
  };

Function Documentation

void dune::display_bits	(	void *	memstart,
		size_t	nbytes,
		std::string	sourcename
	)

Definition at line 10 of file Utilities.cc.

                                                                       {

  std::stringstream bitstr;
  bitstr << "The " << nbytes << "-byte chunk of memory beginning at " << static_cast<void*>(memstart) << " is : ";

  // -- NFB : Nov-20-2015
  // reversed the order of the bits when printing, so that the msb remain on the left
  for(unsigned int i = 0; i < nbytes; i++) {
    // bitstr << std::bitset<8>(*((dune::reinterpret_cast_checked<uint8_t*>(memstart))+(nbytes-i-1))) << " ";
    bitstr << std::bitset<8>(*((dune::reinterpret_cast_checked<uint8_t*>(memstart))+i)) << " ";
  }

  mf::LogInfo(sourcename.c_str()) << bitstr.str();
}

std::vector<char> dune::FelixCompress

(

const dune::FelixFragment &

frag

)

Definition at line 435 of file FelixCompress.hh.

                                                             {
  FelixCompressor compressor(frag);
  std::vector<char> result;
  compressor.compress_copy(result);

  return result;
}

artdaq::Fragment dune::FelixDecompress

(

const std::vector< char > &

buff

)

Definition at line 445 of file FelixCompress.hh.

                                                            {
  artdaq::Fragment result;
  const char* src = buff.data();

  // Read metadata and apply to fragment.
  const MetaData* meta = reinterpret_cast<MetaData const*>(src);
  size_t num_frames = meta->num_frames;
  uint16_t unique_values = meta->unique_values;
  result.resizeBytes(num_frames * sizeof(FelixFrame));
  src += sizeof(MetaData);

  // Handle for filling fragment data.
  FelixFrame* frame = reinterpret_cast<FelixFrame*>(result.dataBeginBytes());

  // Access error frames field.
  std::vector<uint8_t> bad_headers(num_frames/8+1);
  memcpy(&bad_headers[0], src, num_frames/8+1);
  src += num_frames / 8 + 1;

  // Access saved headers and generate headers.
  unsigned sizeof_header_set = sizeof(WIBHeader) + 4 * sizeof(ColdataHeader);
  const WIBHeader* whead = reinterpret_cast<WIBHeader const*>(src);
  std::vector<const ColdataHeader*> chead(4);
  for(unsigned i = 0; i < 4; ++i) {
    chead[i] = reinterpret_cast<ColdataHeader const*>(
        src + sizeof(WIBHeader) + i * sizeof(ColdataHeader));
  }
  size_t bad_header_counter = 0;
  for (unsigned i = 0; i < num_frames; ++i) {
    const WIBHeader* curr_whead;
    std::vector<const ColdataHeader*> curr_chead(4);
    // See if the current headers were bad.
    bool bad_header = (bad_headers[i / 8] >> (7 - (1 % 8))) & 1;
    if(bad_header) {
      ++bad_header_counter;
      // Set current headers to be the bad one.
      std::cout << "BAD HEADER\n";
      curr_whead = reinterpret_cast<WIBHeader const*>(
          src + bad_header_counter * sizeof_header_set);
      for (unsigned j = 0; j < 4; ++j) {
        curr_chead[j] = reinterpret_cast<ColdataHeader const*>(
            src + bad_header_counter * sizeof_header_set +
            sizeof(WIBHeader) + j * sizeof(ColdataHeader));
      }
    } else {
      // Set current headers to be the first.
      curr_whead = whead;
      for(unsigned j = 0; j < 4; ++j) {
        curr_chead[j] = chead[j];
      }
    }
    // Assign header fields.
    (frame + i)->set_sof(curr_whead->sof);
    (frame + i)->set_version(curr_whead->version);
    (frame + i)->set_fiber_no(curr_whead->fiber_no);
    (frame + i)->set_crate_no(curr_whead->crate_no);
    (frame + i)->set_slot_no(curr_whead->slot_no);
    (frame + i)->set_mm(curr_whead->mm);
    (frame + i)->set_oos(curr_whead->oos);
    (frame + i)->set_wib_errors(curr_whead->wib_errors);
    (frame + i)->set_timestamp(curr_whead->timestamp() + i * 25);
    (frame + i)->set_wib_counter(curr_whead->wib_counter());
    (frame + i)->set_z(curr_whead->z);
    for(unsigned j = 0; j < 4; ++j) {
      (frame + i)->set_s1_error(j, curr_chead[j]->s1_error);
      (frame + i)->set_s2_error(j, curr_chead[j]->s2_error);
      (frame + i)->set_coldata_convert_count(
          j, curr_chead[j]->coldata_convert_count + i * 25);
      (frame + i)->set_error_register(j, curr_chead[j]->error_register);
    }
  }
  src += (bad_header_counter+1) * sizeof_header_set;

  // Read frequency table and generate a Huffman tree.
  std::unordered_map<uint16_t, unsigned> freq_table;
  for (unsigned i = 0; i < unique_values; ++i) {
    const uint16_t* v = reinterpret_cast<uint16_t const*>(src);
    const uint32_t* f =
        reinterpret_cast<uint32_t const*>(src + sizeof(uint16_t));
    freq_table[*v] = *f;
    src += sizeof(uint16_t) + sizeof(uint32_t);
  }
  std::vector<HuffTree::Node> nodes;
  for (auto p : freq_table) {
    HuffTree::Node curr_node;
    curr_node.value = p.first;
    curr_node.frequency = p.second;
    nodes.push_back(curr_node);
  }
  HuffTree hufftree;
  hufftree.make_tree(nodes);

  // Read ADC values from the buffer.
  size_t bits_read = 0;
  for (unsigned i = 0; i < num_frames * 256; ++i) {
    // Pointer to walk through the tree.
    HuffTree::Node* pnode = hufftree.root;
    while (pnode->left != NULL) {
      if (*src >> (bits_read % 8) & 1) {  // Next bit is 1.
        pnode = pnode->right;
      } else {  // Next bit is 0.
        pnode = pnode->left;
      }
      // Increment bits read and possibly the source pointer.
      ++bits_read;
      if (bits_read % 8 == 0) {
        ++src;  // Next byte reached.
      }
    }
    // Value reached.
    adc_t found_val = pnode->value;
#ifdef PREV
    if (i % num_frames != 0) {
      found_val += (frame + i % num_frames - 1)->channel(i / num_frames);
    }
#endif
    (frame + i % num_frames)->set_channel(i / num_frames, found_val);
  }

  return result;
}

artdaq::Fragment dune::FelixReorder	(	const uint8_t *	src,
		const uint16_t &	num_frames = 6000
	)

Definition at line 91 of file FelixReordererFacility.hh.

                                                                 {
  artdaq::Fragment result;
  dune::FelixFragmentBase::Metadata meta = {0xabc, 1, 1, 0, num_frames, 0, num_frames};
  result.setMetadata(meta);
  result.resizeBytes(num_frames * (256*sizeof(adc_t) + sizeof(WIBHeader) + 4*sizeof(ColdataHeader))+ (num_frames+7)/8);
  uint8_t *dest = result.dataBeginBytes();

  ReorderFacility facility(false);
  facility.do_reorder_start(num_frames);
  facility.do_reorder(dest, src, num_frames);
  std::cout << "INFO: " << facility.get_info() << '\n';
  unsigned size = facility.reorder_final_size();
  result.resizeBytes(size);

  return result;
}

std::string dune::fragmentTypeToString

(

FragmentType

val

)

Definition at line 24 of file FragmentType.cc.

{
  if (val < FragmentType::INVALID) {
    return names[val - FragmentType::MISSED];
  }
  else {
    return "INVALID/UNKNOWN";
  }
}

artdaq::Fragments dune::getHandleChecked	(	const art::Event &	evt,
		const std::string &	label,
		const std::string &	fragtype,
		const bool &	inContainer
	)

Definition at line 14 of file RawDecodingUtils.cc.

                                                                                       {
  
  artdaq::Fragments fragments;

/*  
  art::Handle<artdaq::Fragments> handleFragments;

  if (expectFragsInContainer) {
    art::InputTag itag1(label, "Container");
    handleFragments = evt.getHandle<artdaq::Fragments>(itag1);
  } 
  else {
    art::inputTag itag2(label, fragtype);
    handleFragments = evt.getHandle<artdaq::Fragments>(itag2);
  }

  if(!handleFragments.isValid()) {
    std::cerr << "Run: " << evt.run()
              << ", SubRun: " << evt.subRun()
              << ", Event: " << evt.event()
              << " is NOT VALID" << std::endl;

    if (expectFragsInContainer) {
      //throw cet::exception("getHandleChecked") << "getHandle call for fragments of type \"Container\" NOT VALID";
      throw std::runtime_error("(THIS SHOULD BE CHANGED TO A cet::exception) getHandle call for fragments NOT VALID");
    } else {
      //      throw cet::exception("getHandleChecked") << "getHandle call for fragments of type \"" << fragtype << "\" NOT VALID";
      throw std::runtime_error("(THIS SHOULD BE CHANGED TO A cet::exception) getHandle call for fragments NOT VALID");
    }
  }
  if (expectFragsInContainer) {
    
    for (auto cont : *handleFragments)
      {
        artdaq::ContainerFragment contf(cont);

        for (size_t ii = 0; ii < contf.block_count(); ++ii)
          {
            size_t fragSize = contf.fragSize(ii);
            artdaq::Fragment thisfrag;
            thisfrag.resizeBytes(fragSize);

            std::cout << "Copying " << fragSize << " bytes from " << contf.at(ii) << " to " << thisfrag.headerAddress() << std::endl;
            memcpy(thisfrag.headerAddress(), contf.at(ii), fragSize);

            std::cout << "Putting new fragment into output vector" << std::endl;             
            fragments.emplace_back(thisfrag);
          }
      }
  } else {

    for(auto const& frag: *handleFragments){
      fragments.emplace_back( frag );
    }
  }
*/
  // C++11 will move, rather than copy, a vector on return
  return fragments;
}

std::map< artdaq::Fragment::type_t, std::string > dune::makeFragmentTypeMap

(

)

Definition at line 35 of file FragmentType.cc.

{
  auto output = artdaq::Fragment::MakeSystemTypeMap();
  for (auto name : names)
    {
      output[toFragmentType(name)] = name;
    }
  return output;
}

std::ostream& dune::operator<<	(	std::ostream &	out,
		CTBFragment const &	f
	)

Definition at line 6 of file CTBFragment.cc.

                                                                      {

    out << "Fragment size: " << f.artdaq_Fragment_.dataSizeBytes() << " -> " << f._n_words << " words" << std::endl ;

    for ( unsigned int i = 0; i < f.NWords() ; ++i ) {

      if ( f.Trigger(i) ) {
        out << "Trigger word " << std::hex << f.Trigger(i) -> word_type
            << ", payload: "  << f.Trigger(i) -> trigger_word
            << ", TS: " << f.Trigger(i) -> timestamp << std::dec << std::endl ;
      }
      else if ( f.ChStatus(i) ) {
        out << "Check Status word " << std::hex 
            << " PDS " << f.ChStatus(i) -> get_pds() 
            << ", CRT: " << f.ChStatus(i) -> get_crt()
            << ", Beam: " << f.ChStatus(i) -> get_beam() 
            << ", TS: " << f.ChStatus(i) -> timestamp
            << std::dec << std::endl ;

      }
      else if ( f.Feedback(i) ) {
        out << "Feedback word  " << std::hex 
            << ", Padding: " << f.Feedback(i) -> padding
            << ", Source: " << f.Feedback(i) -> source
            << ", Code: " << f.Feedback(i) -> code
            << ", TS: " << f.Feedback(i) -> timestamp << std::dec << std::endl ;

      }
      else {
        out << "type: " << std::hex << f.Word(i) -> word_type 
            << ", payload: " << f.Word(i) -> payload 
            << ", TS: " << f.Word(i) -> timestamp << std::dec << std::endl ;
      }

    }


    return out ;
  }

std::ostream & dune::operator<<	(	std::ostream &	os,
		ToyFragment const &	f
	)

Definition at line 30 of file ToyFragment.cc.

                                                                      {
  os << "ToyFragment event size: "
     << f.hdr_event_size()
     << ", run number: "
     << f.hdr_run_number()
     << "\n";

  return os;
}

std::ostream & dune::operator<<	(	std::ostream &	os,
		SSPFragment const &	f
	)

Definition at line 21 of file SSPFragment.cc.

                                                                      {
  os << "SSPFragment event size: "
     << f.hdr_event_size()
     << ", run number: "
     << f.hdr_run_number()
     << "\n";

  return os;
}

std::ostream & dune::operator<<	(	std::ostream &	os,
		TimingFragment const &	f
	)

Definition at line 3 of file TimingFragment.cc.

                                                                         {
  os << "TimingFragment size=" << std::dec << f.size()
     << ", cookie 0x"          << std::hex << f.get_cookie()
     << ", scmd 0x"            << std::hex << f.get_scmd()
     << ", tcmd 0x"            << std::hex << f.get_tcmd()
     << ", timestamp 0x"       << std::hex << f.get_tstamp()
     << ", evtctr="            << std::dec << f.get_evtctr()
     << ", cksum 0x"           << std::hex << f.get_cksum()
     << ", last_run_start 0x"  << std::hex << f.get_last_runstart_timestamp()
     << ", last_spill_start 0x"<< std::hex << f.get_last_spillstart_timestamp()
     << ", last_spill_end 0x"  << std::hex << f.get_last_spillend_timestamp()

     << std::dec << "\n";

  return os;
}

const Frame14Fragment* dune::ParseFrame14Fragment

(

const artdaq::Fragment &

fragment

)

Definition at line 187 of file Frame14Fragment.hh.

                                                                            {
  // const Frame14Fragment::Metadata *meta = fragment.metadata<Frame14Fragment::Metadata>();
  // Check meta and potentially return a different unpacker 
  return new Frame14FragmentUnordered(fragment);
}

template<typename S , typename T >

S dune::reinterpret_cast_checked

(

T

inptr

)

Definition at line 28 of file Utilities.hh.

                                    {

  S outptr = reinterpret_cast<S>( inptr );

  const void* inptr_void = static_cast<const void*>( inptr );
  const void* outptr_void = static_cast<const void*>( outptr );

  if ( inptr_void != outptr_void ) {
    throw cet::exception("reinterpret_cast_checked") << "Error: reinterpret_cast casted " << inptr_void << " to " << outptr_void << " => results of the cast can't be trusted";
  }

  return outptr;
}

dune::FragmentType dune::toFragmentType

(

std::string

t_string

)

Definition at line 10 of file FragmentType.cc.

{
  std::transform(t_string.begin(),
                 t_string.end(),
                 t_string.begin(),
                 toupper);
  auto it = std::find(names.begin(), names.end(), t_string);
  return (it == names.end()) ?
    FragmentType::INVALID :
    static_cast<FragmentType>(artdaq::Fragment::FirstUserFragmentType +
                              (it - names.begin()));
}

Variable Documentation

class dune::Frame14Fragmentstruct dune::frame14::__attribute__ dune::aligned

std::vector<std::string> const dune::names

static

Initial value:

{ "MISSED",
          "TPC",
          "PHOTON",
          "TRIGGER",
          "TIMING",
          "TOY1",
          "TOY2",
          "FELIX",
          "CRT",
          "CTB",
          "CPUHITS",
          "DEVBOARDHITS",
          "FRAME14",
          "UNKNOWN" }

Definition at line 8 of file FragmentType.hh.