 art::AnalyzersConfig | |
 FragCounter_test::Apply_id | |
 FragCounter_test::ApplyWithOffset_id | |
 artdaq::art_config_file | Art_config_file wraps a temporary file used to configure art |
 artdaq::artdaqapp | Class representing an artdaq application. Used by all "main" functions to start artdaq. |
 art::ArtdaqInput< U > | This template class provides a unified interface for reading data into art |
 ArtdaqSharedMemoryServiceInterface | Interface for ArtdaqSharedMemoryService. This interface is declared to art as part of the required registration of an art Service |
  ArtdaqSharedMemoryService | ArtdaqSharedMemoryService extends ArtdaqSharedMemoryServiceInterface. It receives events from shared memory using SharedMemoryEventReceiver. It also manages the artdaq Global varaibles my_rank and app_name. Users should retrieve a ServiceHandle to this class before using artdaq Globals to ensure the correct values are used |
 artdaq::BoardReaderCore | BoardReaderCore implements the state machine for the BoardReader artdaq application. It contains a CommandableFragmentGenerator, which generates Fragments which are then sent to a DataSenderManager by BoardReaderCore |
 BOOST_AUTO_TEST_CASE_FIXTURE | |
  CapacityTest_policy_t::Simple | |
  CommandableFragmentGenerator_t::BufferMode | |
  CommandableFragmentGenerator_t::BufferMode_KeepLatest | |
  CommandableFragmentGenerator_t::BufferMode_MultipleIDs | |
  CommandableFragmentGenerator_t::CircularBufferMode | |
  CommandableFragmentGenerator_t::CircularBufferMode_MultipleIDs | |
  CommandableFragmentGenerator_t::HardwareFailure_NonThreaded | |
  CommandableFragmentGenerator_t::HardwareFailure_Threaded | |
  CommandableFragmentGenerator_t::IgnoreRequests | |
  CommandableFragmentGenerator_t::IgnoreRequests_MultipleIDs | |
  CommandableFragmentGenerator_t::SequenceIDMode | |
  CommandableFragmentGenerator_t::SequenceIDMode_MultipleIDs | |
  CommandableFragmentGenerator_t::Simple | |
  CommandableFragmentGenerator_t::SingleMode | |
  CommandableFragmentGenerator_t::SingleMode_MultipleIDs | |
  CommandableFragmentGenerator_t::WindowMode_Function | |
  CommandableFragmentGenerator_t::WindowMode_Function_MultipleIDs | |
  CommandableFragmentGenerator_t::WindowMode_RequestAfterBuffer | |
  CommandableFragmentGenerator_t::WindowMode_RequestBeforeBuffer | |
  CommandableFragmentGenerator_t::WindowMode_RequestEndsAfterBuffer | |
  CommandableFragmentGenerator_t::WindowMode_RequestInBuffer | |
  CommandableFragmentGenerator_t::WindowMode_RequestOutsideBuffer | |
  CommandableFragmentGenerator_t::WindowMode_RequestStartsBeforeBuffer | |
  FragCounter_test::Apply | |
  FragCounter_test::ApplyWithOffset | |
  FragCounter_test::Construct | |
  FragCounter_test::nSlots | |
  GenericFragmentSimulator_t::Simple | |
  NoOp_policy_t::Simple | |
  RoundRobin_policy_t::LargeMinimumParticipants | |
  RoundRobin_policy_t::ManyMissingParticipants | |
  RoundRobin_policy_t::MinimumParticipants | |
  RoundRobin_policy_t::Simple | |
  RoundRobin_policy_t::VerifyRMPSharedPtr | |
 artdaqtest::BrokenTransferTest | A class which simulates several failure modes for TransferPlugins such as sender pause/restart and receiver pause/restart |
 CommandableFragmentGenerator_t::BufferMode_id | |
 CommandableFragmentGenerator_t::BufferMode_KeepLatest_id | |
 CommandableFragmentGenerator_t::BufferMode_MultipleIDs_id | |
 CommandableFragmentGenerator_t::CircularBufferMode_id | |
 CommandableFragmentGenerator_t::CircularBufferMode_MultipleIDs_id | |
 artdaq::Commandable | Commandable is the base class for all artdaq components which implement the artdaq state machine |
  artdaq::BoardReaderApp | BoardReaderApp is an artdaq::Commandable derived class which controls the BoardReaderCore state machine |
  artdaq::DataLoggerApp | DataLoggerApp is an artdaq::Commandable derived class which controls the DataLoggerCore |
  artdaq::DispatcherApp | DispatcherApp is an artdaq::Commandable derived class which controls the DispatcherCore |
  artdaq::EventBuilderApp | EventBuilderApp is an artdaq::Commandable derived class which controls the EventBuilderCore |
  artdaq::RoutingMasterApp | RoutingMasterApp is an artdaq::Commandable derived class which controls the RoutingMasterCore state machine |
 artdaq::CommanderInterface | This interface defines the functions used to transfer data between artdaq applications |
  artdaq::xmlrpc_commander | Serves as the XMLRPC server run in each artdaq application |
 artdaq::HostMap::Config | Template for the host_map configuration parameter. |
 artdaq::TransferInterface::Config | Configuration of the TransferInterface. May be used for parameter validation |
 artdaq::artdaqapp::Config | Configuration of artdaqapp. May be used for parameter validation |
 artdaq::RoutingReceiver::Config | Accepted configuration parameters for RoutingReceiver |
 Config | |
 ArtdaqSharedMemoryService::Config | Allowed Configuration parameters of NetMonTransportService. May be used for configuration validation |
 art::Config | Required configuration for art processes started by artdaq, with artdaq-specific defaults where applicable |
 art::RootDAQOut::Config | |
 artdaqtest::BrokenTransferTest::Config | Configuration parameters for BrokenTransferTest |
 art::RootNetOutput::Config | Allowed Configuration parameters of NetMonTransportService. May be used for configuration validation |
 artdaq::GenericFragmentSimulator::Config | Configuration of the GenericFragmentSimulator. May be used for parameter validation |
 artdaq::PortManager::Config | Configuration of PortManager. May be used for parameter validation |
 artdaq::DataSenderManager::Config | Configuration of DataSenderManager. May be used for parameter validation |
 artdaq::RequestReceiver::Config | Configuration of the RequestReceiver. May be used for parameter validation |
 artdaq::RequestSender::Config | Configuration of the RequestSender. May be used for parameter validation |
 artdaq::SharedMemoryEventManager::Config | Configuration of the SharedMemoryEventManager. May be used for parameter validation |
 artdaq::TokenReceiver::Config | Configuration of the TokenReceiver. May be used for parameter validation |
 artdaq::CommanderInterface::Config | Configuration of the CommanderInterface. May be used for parameter validation |
 artdaq::CommandableFragmentGenerator::Config | Configuration of the CommandableFragmentGenerator. May be used for parameter validation |
 FragCounter_test::Construct_id | |
 artdaq::DataReceiverCore | DataReceiverCore implements the state machine for the DataReceiver artdaq application. DataReceiverCore receives Fragment objects from the DataReceiverManager, and sends them to the EventStore |
  artdaq::DataLoggerCore | DataLoggerCore implements the state machine for the DataLogger artdaq application. DataLoggerCore processes incoming events in one of three roles: Data Logger, Online Monitor, or Dispatcher |
  artdaq::DispatcherCore | DispatcherCore implements the state machine for the Dispatcher artdaq application. DispatcherCore processes incoming events in one of three roles: Data Logger, Online Monitor, or Dispatcher |
  artdaq::EventBuilderCore | EventBuilderCore implements the state machine for the EventBuilder artdaq application. EventBuilderCore receives Fragment objects from the DataReceiverManager, and sends them to the EventStore |
 artdaq::DataReceiverManager | Receives Fragment objects from one or more DataSenderManager instances using TransferInterface plugins DataReceiverMaanger runs a reception thread for each source, and can automatically suppress reception from sources which are going faster than the others |
 artdaq::DataSenderManager | Sends Fragment objects using TransferInterface plugins. Uses Routing Tables if confgiured, otherwise will Round-Robin Fragments to the destinations |
 DDSDataReaderListener | |
  artdaq::RTIDDS::OctetsListener | A class that reads data from DDS |
 artdaq::detail::DefaultFragmentTypeTranslator | Default behavior for experiment-specific customizations in SharedMemoryReader |
 artdaq::DataSenderManager::DestinationsConfig | Configuration for transfers to destinations |
 EDAnalyzer | |
  artdaq::EventDump | Write Event information to the console |
  artdaq::FragmentSniffer | This art::EDAnalyzer plugin tries to get Fragments from each event, asserting that the correct number of Fragments were present |
  artdaq::FragmentWatcher | An art::EDAnalyzer module which checks events for certain error conditions (missing fragments, empty fragments, etc) |
  artdaq::MissingDataCheck | Check art::Event for potentially missing data |
  artdaq::PrintBuildInfo | An art::EDAnalyzer which prints any artdaq::BuildInfo objects stored in the run |
 EDFilter | |
  artdaq::RandomDelayFilter | A filter which delays for a random amount of time, then drops a random fraction of events. Used to simulate the delays and efficiency of real filters |
 EDProducer | |
  artdaq::BuildInfo< instanceName, Pkgs > | BuildInfo is an art::EDProducer which saves information about package builds to the data file |
 shared_memory_reader_t::end_of_data_id | |
 anonymous_namespace{xmlrpc_commander.cc}::env_wrap | Wrapper for XMLRPC environment construction/destruction |
 art::RootDAQOut::Config::FileNameSubstitution | |
 art::FiltersConfig | |
 shared_memory_reader_t::first_event_id | |
 artdaq::detail::FragCounter | Keep track of the count of Fragments received from a set of sources |
 FragmentGenerator | |
  artdaq::CommandableFragmentGenerator | CommandableFragmentGenerator is a FragmentGenerator-derived abstract class that defines the interface for a FragmentGenerator designed as a state machine with start, stop, etc., transition commands |
   artdaq::CompositeDriver | CompositeDriver handles a set of lower-level generators |
   artdaqtest::CommandableFragmentGeneratorTest | CommandableFragmentGenerator derived class for testing |
  artdaq::GenericFragmentSimulator | GenericFragmentSimulator creates simulated Generic events, with data distributed according to a "histogram" provided in the configuration data |
 artdaq::FragmentReceiverManager | Receives Fragment objects from one or more DataSenderManager instances using TransferInterface plugins DataReceiverMaanger runs a reception thread for each source, and can automatically suppress reception from sources which are going faster than the others |
 artdaq::FragmentStoreElement | This class contains tracking information for all Fragment objects which have been received from a specific source |
 artdaq::GetPackageBuildInfo | Wrapper around the artdaq::GetPackageBuildInfo::getPackageBuildInfo function |
 artdaq::Globals | The artdaq::Globals class contains several variables which are useful across the entire artdaq system |
 CommandableFragmentGenerator_t::HardwareFailure_NonThreaded_id | |
 CommandableFragmentGenerator_t::HardwareFailure_Threaded_id | |
 artdaq::HostMap::HostConfig | Entries in the host_map should have these parameters. May be used for parameter validation |
 artdaq::HostMap | |
 CommandableFragmentGenerator_t::IgnoreRequests_id | |
 CommandableFragmentGenerator_t::IgnoreRequests_MultipleIDs_id | |
 art::RootOutputConfig::KeysToIgnore | These keys should be ignored by the configuration validation processor |
 art::RootDAQOut::Config::KeysToIgnore | |
 RoundRobin_policy_t::LargeMinimumParticipants_id | |
 RoundRobin_policy_t::ManyMissingParticipants_id | |
 MessHead | This header is sent by the TCPSocket_transfer to allow for more efficient writev calls |
 method | |
  artdaq::cmd_ | The "cmd_" class serves as the base class for all artdaq's XML-RPC commands |
   artdaq::add_config_archive_entry_ | Add_config_archive_entry_ Command class |
   artdaq::clear_config_archive_ | Clear_config_archive_ Command class |
   artdaq::init_ | |
   artdaq::legal_commands_ | Legal_commands_ Command class |
   artdaq::meta_command_ | Meta_command_ Command class |
   artdaq::pause_ | |
   artdaq::register_monitor_ | Register_monitor_ Command class |
   artdaq::reinit_ | |
   artdaq::report_ | Report_ Command class |
   artdaq::resume_ | |
   artdaq::rollover_subrun_ | Rollover_subrun_ Command class |
   artdaq::shutdown_ | Shutdown_ Command class |
   artdaq::soft_init_ | |
   artdaq::start_ | Command class representing a start transition |
   artdaq::status_ | Status_ Command class |
   artdaq::stop_ | |
   artdaq::trace_get_ | Trace_get_ Command class |
   artdaq::trace_set_ | Trace_set_ Command class |
   artdaq::unregister_monitor_ | Unregister_monitor_ Command class |
 RoundRobin_policy_t::MinimumParticipants_id | |
 MPRGlobalTestFixture | MasterProductRegistry Test Fixture |
 artdaq::NetMonHeader | Header with length information for NetMonTransport messages |
 art::NetMonWrapper | This class wraps NetMonTransportService so that it can act as an ArtdaqInput template class |
 shared_memory_reader_t::new_run_id | |
 shared_memory_reader_t::new_subrun_id | |
 art::RootDAQOut::Config::NewSubStringForApp | |
 shared_memory_reader_t::nonempty_event_id | |
 FragCounter_test::nSlots_id | |
 art::RootDAQOutFile::OutputItem | |
 OutputModule | |
  art::ArtdaqOutput | This is the base class for artdaq OutputModules, providing the serialization interface for art Events. |
   art::RootNetOutput | An art::OutputModule which sends events using DataSenderManager. This module is designed for transporting Fragment-wrapped art::Events after they have been read into art, for example between the EventBuilder and the Aggregator |
   art::TransferOutput | An art::OutputModule which sends events using DataSenderManager. This module is designed for transporting Fragment-wrapped art::Events after they have been read into art, for example between the EventBuilder and the Aggregator |
 OutputModule | |
  art::BinaryFileOutput | The BinaryFileOutput module streams art Events to a binary file, bypassing ROOT |
  art::BinaryNetOutput | An art::OutputModule which sends Fragments using DataSenderManager. This module produces output identical to that of a BoardReader, for use in systems which have multiple layers of EventBuilders |
  art::RootDAQOut | |
 art::OutputsConfig | Configuration for the outputs block of artdaq art processes |
 art::PhysicsConfig | Configuration of the physics block for artdaq art processes |
 artdaq::PortManager | PortManager attempts to automatically detect interfaces and ports used for the various TCP and UDP sockets used by artdaq |
 art::ProducersConfig | Artdaq does not provide any producers |
 artdaq::detail::RequestHeader | Header of a RequestMessage. Contains magic bytes for validation and a count of expected RequestPackets |
 artdaq::detail::RequestMessage | A RequestMessage consists of a RequestHeader and zero or more RequestPackets. They will usually be sent in two calls to send() |
 artdaq::detail::RequestPacket | The RequestPacket contains information about a single data request |
 artdaq::RequestReceiver | Receive data requests and make them available to CommandableFragmentGenerator or other interested parties. Track received requests and report errors when inconsistency is detected. |
 artdaq::RequestSender | The RequestSender contains methods used to send data requests and Routing tokens |
 art::RootDAQOutFile | |
 art::RootOutputConfig | Confgiguration for ROOT output modules |
 artdaq::detail::RoutingAckPacket | A RoutingAckPacket contains the rank of the table receiver, plus the first and last sequence IDs in the Routing Table (for verification) |
 artdaq::RoutingMasterCore | RoutingMasterCore implements the state machine for the RoutingMaster artdaq application. RoutingMasterCore collects tokens from receivers, and at regular intervals uses these tokens to build Routing Tables that are sent to the senders |
 artdaq::RoutingMasterPolicy | The interface through which RoutingMasterCore obtains Routing Tables using received Routing Tokens |
  artdaq::CapacityTestPolicy | A RoutingMasterPolicy which tries to fully load the first receiver, then the second, and so on |
  artdaq::NoOpPolicy | A RoutingMasterPolicy which simply assigns Sequence IDs to tokens in the order they were received |
  artdaq::RoundRobinPolicy | A RoutingMasterPolicy which evenly distributes Sequence IDs to all receivers. If an uneven number of tokens have been received, extra tokens are stored for the next table update |
 artdaq::detail::RoutingPacketEntry | A row of the Routing Table |
 artdaq::detail::RoutingPacketHeader | The header of the Routing Table, containing the magic bytes and the number of entries |
 artdaq::RoutingReceiver | Class which receives routing tables and prints updates |
 artdaq::DataSenderManager::RoutingTableConfig | Configuration for Routing table reception |
 artdaq::detail::RoutingToken | The RoutingToken contains the magic bytes, the rank of the token sender, and the number of slots free. This is a TCP message, so additional verification is not necessary |
 artdaq::RequestSender::RoutingTokenConfig | Configuration for Routing token sending |
 artdaq::RTIDDS | DDS Transport Implementation |
 CommandableFragmentGenerator_t::SequenceIDMode_id | |
 CommandableFragmentGenerator_t::SequenceIDMode_MultipleIDs_id | |
 art::ServicesConfig | Configuration of the services block for artdaq art processes |
 art::ServicesSchedulerConfig | Configuration of the services.scheduler block for artdaq art processes |
 SharedMemoryManager | |
  artdaq::SharedMemoryEventManager | The SharedMemoryEventManager is a SharedMemoryManger which tracks events as they are built |
 artdaq::detail::SharedMemoryReader< getDefaultTypes, FTT > | The SharedMemoryReader is a class which implements the methods needed by art::Source |
 ShmRTestFixture | SharedMemoryReader Test Fixture |
  shared_memory_reader_t::end_of_data | |
  shared_memory_reader_t::first_event | |
  shared_memory_reader_t::new_run | |
  shared_memory_reader_t::new_subrun | |
  shared_memory_reader_t::nonempty_event | |
 CommandableFragmentGenerator_t::Simple_id | |
 GenericFragmentSimulator_t::Simple_id | |
 NoOp_policy_t::Simple_id | |
 RoundRobin_policy_t::Simple_id | |
 CapacityTest_policy_t::Simple_id | |
 CommandableFragmentGenerator_t::SingleMode_id | |
 CommandableFragmentGenerator_t::SingleMode_MultipleIDs_id | |
 art::Source_generator< artdaq::detail::SharedMemoryReader< artdaq::Fragment::MakeSystemTypeMap > > | Specialize an art source trait to tell art that we don't care about source.fileNames and don't want the files services to be used |
 art::Source_generator< ArtdaqInput< artdaq::TransferWrapper > > | Trait definition (must precede source typedef) |
 art::Source_generator< ArtdaqInput< NetMonWrapper > > | Trait definition (must precede source typedef) |
 art::SourceConfig | Configuration for the source block of artdaq art processes |
 artdaq::StatisticsHelper | This class manages MonitoredQuantity instances for the *Core classes |
 swig_artdaq | |
 anonymous_namespace{genToArt.cc}::ThrottledGenerator | ThrottledGenerator: ensure that we only get one fragment per type at a time from the generator |
 Timeout | Performs registered actions at specified intervals |
 Timeout::timeoutspec | Specification for a Timeout function |
 artdaq::TokenReceiver | Receives event builder "free buffer" tokens and adds them to a specified RoutingPolicy |
 artdaq::TransferInterface | This interface defines the functions used to transfer data between artdaq applications |
  artdaq::AutodetectTransfer | The AutodetectTransfer TransferInterface plugin sets up a Shmem_transfer plugin or TCPSocket_transfer plugin depending if the source and destination are on the same host, to maximize throughput |
  artdaq::MulticastTransfer | MulticastTransfer is a TransferInterface implementation plugin that transfers data using Multicast |
  artdaq::NullTransfer | NullTransfer does not send or receive data, but acts as if it did |
  artdaq::RTIDDSTransfer | RTIDDSTransfer is a TransferInterface implementation plugin that transfers data using RTI DDS |
  artdaq::ShmemTransfer | A TransferInterface implementation plugin that transfers data using Shared Memory |
  artdaq::TCPSocketTransfer | TransferInterface implementation plugin that sends data using TCP sockets |
 artdaq::TransferTest | Test a set of TransferInterface plugins |
 artdaq::TransferWrapper | TransferWrapper wraps a TransferInterface so that it can be used in the ArtdaqInput class to make an art::Source |
 RoundRobin_policy_t::VerifyRMPSharedPtr_id | |
 CommandableFragmentGenerator_t::WindowMode_Function_id | |
 CommandableFragmentGenerator_t::WindowMode_Function_MultipleIDs_id | |
 CommandableFragmentGenerator_t::WindowMode_RequestAfterBuffer_id | |
 CommandableFragmentGenerator_t::WindowMode_RequestBeforeBuffer_id | |
 CommandableFragmentGenerator_t::WindowMode_RequestEndsAfterBuffer_id | |
 CommandableFragmentGenerator_t::WindowMode_RequestInBuffer_id | |
 CommandableFragmentGenerator_t::WindowMode_RequestOutsideBuffer_id | |
 CommandableFragmentGenerator_t::WindowMode_RequestStartsBeforeBuffer_id | |