artdaq::AggregatorApp | AggregatorApp is an artdaq::Commandable derived class which controls the AggregatorCore |
artdaq::AggregatorCore | AggregatorCore implements the state machine for the Aggregator artdaq application. AggregatorCore processes incoming events in one of three roles: Data Logger, Online Monitor, or Dispatcher |
art::ArtdaqInput< U > | This template class provides a unified interface for reading data into art |
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::BoardReaderApp | BoardReaderApp is an artdaq::Commandable derived class which controls the BoardReaderCore state machine |
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 |
Builder | Runs the builder test |
artdaq::BuildInfo< instanceName, Pkgs > | BuildInfo is an art::EDProducer which saves information about package builds to the data file |
artdaq::CapacityTestPolicy | A RoutingMasterPolicy which tries to fully load the first receiver, then the second, and so on |
artdaq::cmd_ | The "cmd_" class serves as the base class for all artdaq's XML-RPC commands |
artdaq::Commandable | Commandable is the base class for all artdaq components which implement the artdaq state machine |
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 |
artdaqtest::CommandableFragmentGeneratorTest | CommandableFragmentGenerator derived class for testing |
artdaq::CompositeDriver | CompositeDriver handles a set of lower-level generators |
final::Config | |
artdaq::Config | Helper class for configuring the builder test |
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 |
art::detail::DummyProductCache | |
artdaq::EventBuilderApp | EventBuilderApp is an artdaq::Commandable derived class which controls the EventBuilderCore |
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::EventDump | Write Event information to the console |
artdaq::EventStore | Collects Fragment objects, until it receives a complete event, at which point the event is handed over to the art thread |
final | The BinaryFileOutput module streams art Events to a binary file, bypassing ROOT |
artdaq::detail::FragCounter | Keep track of the count of Fragments received from a set of sources |
artdaq::FragmentSniffer | This art::EDAnalyzer plugin tries to get Fragments from each event, asserting that the correct number of Fragments were present |
artdaq::FragmentStoreElement | This class contains tracking information for all Fragment objects which have been received from a specific source |
artdaq::GenericFragmentSimulator | GenericFragmentSimulator creates simulated Generic events, with data distributed according to a "histogram" provided in the configuration data |
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 |
artdaq::init_ | |
art::detail::KeptProvenance | |
final::Config::KeysToIgnore | |
artdaq::legal_commands_ | Legal_commands_ Command class |
LockFile | Create a "lock file", removing it upon class destruction |
MessHead | This header is sent by the TCPSocket_transfer to allow for more efficient writev calls |
MPIProg | A wrapper for a MPI program. Similar to MPISentry |
artdaq::MPISentry | Initializes and finalizes the MPI context that the artdaq applciations run in |
artdaq::MPITransfer | MPITransfer is a TransferInterface implementation plugin that transfers data using MPI |
MPRGlobalTestFixture | MasterProductRegistry Test Fixture |
artdaq::MulticastTransfer | MulticastTransfer is a TransferInterface implementation plugin that transfers data using Multicast |
artdaq::NetMonHeader | Header with length information for NetMonTransport messages |
NetMonTransportService | NetMonTransportService extends NetMonTransportServiceInterface. It sends events using DataSenderManager and receives events from the GlobalQueue |
NetMonTransportServiceInterface | Interface for NetMonTranportService. This interface is declared to art as part of the required registration of an art Service |
art::NetMonWrapper | This class wraps NetMonTransportService so that it can act as an ArtdaqInput template class |
artdaq::NoOpPolicy | A RoutingMasterPolicy which simply assigns Sequence IDs to tokens in the order they were received |
artdaq::NullTransfer | NullTransfer does not send or receive data, but acts as if it did |
artdaq::RTIDDS::OctetsListener | A class that reads data from DDS |
art::RootDAQOutFile::OutputItem | |
artdaq::pause_ | |
artdaq::PrintBuildInfo | An art::EDAnalyzer which prints any artdaq::BuildInfo objects stored in the run |
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 |
artdaq::detail::RawEventQueueReader | The RawEventQueueReader is a class which implements the methods needed by art::Source |
artdaq::register_monitor_ | Register_monitor_ Command class |
artdaq::reinit_ | |
artdaq::report_ | Report_ Command class |
REQRTestFixture | RawEventQueueReader Test Fixture |
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::reset_stats_ | Reset_stats_ Command class |
artdaq::resume_ | |
art::RootDAQOutFile | |
art::RootMPIOutput | 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 |
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::RoutingAckPacket | A RoutingAckPacket contains the rank of the table receiver, plus the first and last sequence IDs in the Routing Table (for verification) |
artdaq::RoutingMasterApp | RoutingMasterApp is an artdaq::Commandable derived class which controls the RoutingMasterCore state machine |
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 |
RoutingMasterTest | Runs the routing_master test |
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::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::RTIDDS | DDS Transport Implementation |
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::shutdown_ | Shutdown_ Command class |
artdaq::soft_init_ | |
art::RootDAQOutFile::OutputItem::Sorter | |
art::Source_generator< artdaq::detail::RawEventQueueReader > | 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) |
artdaq::start_ | Command class representing a start transition |
artdaq::StatisticsHelper | This class manages MonitoredQuantity instances for the *Core classes |
artdaq::status_ | Status_ Command class |
artdaq::stop_ | |
artdaq::TCPSocketTransfer | TransferInterface implementation plugin that sends data using TCP sockets |
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::TransferInterface | This interface defines the functions used to transfer data between artdaq applications |
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 |
artdaq::unregister_monitor_ | Unregister_monitor_ Command class |
artdaq::xmlrpc_commander | Serves as the XMLRPC server run in each artdaq application |