$treeview $search $mathjax $extrastylesheet
artdaq  v3_04_00
$projectbrief
$projectbrief
$searchbox

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
artdaq::add_config_archive_entry_Add_config_archive_entry_ Command class
art::AnalyzersConfig
artdaq::art_config_fileArt_config_file wraps a temporary file used to configure art
artdaq::artdaqappClass 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
artdaq::AutodetectTransferThe 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::BoardReaderAppBoardReaderApp is an artdaq::Commandable derived class which controls the BoardReaderCore state machine
artdaq::BoardReaderCoreBoardReaderCore 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
artdaq::BuildInfo< instanceName, Pkgs >BuildInfo is an art::EDProducer which saves information about package builds to the data file
artdaq::CapacityTestPolicyA RoutingMasterPolicy which tries to fully load the first receiver, then the second, and so on
artdaq::clear_config_archive_Clear_config_archive_ Command class
artdaq::cmd_The "cmd_" class serves as the base class for all artdaq's XML-RPC commands
artdaq::CommandableCommandable is the base class for all artdaq components which implement the artdaq state machine
artdaq::CommandableFragmentGeneratorCommandableFragmentGenerator 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::CommandableFragmentGeneratorTestCommandableFragmentGenerator derived class for testing
artdaq::CommanderInterfaceThis interface defines the functions used to transfer data between artdaq applications
artdaq::CompositeDriverCompositeDriver handles a set of lower-level generators
art::ConfigRequired configuration for art processes started by artdaq, with artdaq-specific defaults where applicable
artdaq::artdaqapp::ConfigConfiguration of artdaqapp. May be used for parameter validation
artdaq::RoutingReceiver::Config
NetMonTransportService::ConfigAllowed Configuration parameters of NetMonTransportService. May be used for configuration validation
artdaq::RequestReceiver::ConfigConfiguration of the RequestReceiver. May be used for parameter validation
artdaq::RequestSender::ConfigConfiguration of the RequestSender. May be used for parameter validation
artdaq::CommandableFragmentGenerator::ConfigConfiguration of the CommandableFragmentGenerator. May be used for parameter validation
artdaq::SharedMemoryEventManager::ConfigConfiguration of the SharedMemoryEventManager. May be used for parameter validation
artdaq::GenericFragmentSimulator::ConfigConfiguration of the GenericFragmentSimulator. May be used for parameter validation
artdaq::CommanderInterface::ConfigConfiguration of the CommanderInterface. May be used for parameter validation
artdaq::PortManager::ConfigConfiguration of PortManager. May be used for parameter validation
artdaq::DataSenderManager::ConfigConfiguration of DataSenderManager. May be used for parameter validation
artdaq::HostMap::ConfigTemplate for the host_map configuration parameter
artdaq::TransferInterface::ConfigConfiguration of the TransferInterface. May be used for parameter validation
artdaq::DataLoggerAppDataLoggerApp is an artdaq::Commandable derived class which controls the DataLoggerCore
artdaq::DataLoggerCoreDataLoggerCore 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::DataReceiverCoreDataReceiverCore implements the state machine for the DataReceiver artdaq application. DataReceiverCore receives Fragment objects from the DataReceiverManager, and sends them to the EventStore
artdaq::DataReceiverManagerReceives 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::DataSenderManagerSends Fragment objects using TransferInterface plugins. Uses Routing Tables if confgiured, otherwise will Round-Robin Fragments to the destinations
artdaq::DataSenderManager::DestinationsConfigConfiguration for transfers to destinations
artdaq::DispatcherAppDispatcherApp is an artdaq::Commandable derived class which controls the DispatcherCore
artdaq::DispatcherCoreDispatcherCore implements the state machine for the Dispatcher artdaq application. DispatcherCore processes incoming events in one of three roles: Data Logger, Online Monitor, or Dispatcher
anonymous_namespace{xmlrpc_commander.cc}::env_wrapWrapper for XMLRPC environment construction/destruction
artdaq::EventBuilderAppEventBuilderApp is an artdaq::Commandable derived class which controls the EventBuilderCore
artdaq::EventBuilderCoreEventBuilderCore implements the state machine for the EventBuilder artdaq application. EventBuilderCore receives Fragment objects from the DataReceiverManager, and sends them to the EventStore
artdaq::EventDumpWrite Event information to the console
art::FiltersConfig
finalThe BinaryFileOutput module streams art Events to a binary file, bypassing ROOT
artdaq::detail::FragCounterKeep track of the count of Fragments received from a set of sources
artdaq::FragmentReceiverManagerReceives 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::FragmentSnifferThis art::EDAnalyzer plugin tries to get Fragments from each event, asserting that the correct number of Fragments were present
artdaq::FragmentStoreElementThis class contains tracking information for all Fragment objects which have been received from a specific source
artdaq::GenericFragmentSimulatorGenericFragmentSimulator creates simulated Generic events, with data distributed according to a "histogram" provided in the configuration data
artdaq::GetPackageBuildInfoWrapper around the artdaq::GetPackageBuildInfo::getPackageBuildInfo function
artdaq::GlobalsThe artdaq::Globals class contains several variables which are useful across the entire artdaq system
artdaq::HostMap::HostConfigEntries in the host_map should have these parameters. May be used for parameter validation
artdaq::HostMap
artdaq::init_
art::RootOutputConfig::KeysToIgnore???
artdaq::legal_commands_Legal_commands_ Command class
MessHeadThis header is sent by the TCPSocket_transfer to allow for more efficient writev calls
artdaq::meta_command_Meta_command_ Command class
artdaq::MissingDataCheckCheck art::Event for potentially missing data
MPRGlobalTestFixtureMasterProductRegistry Test Fixture
artdaq::MulticastTransferMulticastTransfer is a TransferInterface implementation plugin that transfers data using Multicast
artdaq::NetMonHeaderHeader with length information for NetMonTransport messages
NetMonTransportServiceNetMonTransportService extends NetMonTransportServiceInterface. It sends events using DataSenderManager and receives events from the GlobalQueue
NetMonTransportServiceInterfaceInterface for NetMonTranportService. This interface is declared to art as part of the required registration of an art Service
art::NetMonWrapperThis class wraps NetMonTransportService so that it can act as an ArtdaqInput template class
artdaq::NoOpPolicyA RoutingMasterPolicy which simply assigns Sequence IDs to tokens in the order they were received
artdaq::NullTransferNullTransfer does not send or receive data, but acts as if it did
artdaq::RTIDDS::OctetsListenerA class that reads data from DDS
art::OutputsConfigConfiguration for the outputs block of artdaq art processes
artdaq::pause_
art::PhysicsConfigConfiguration of the physics block for artdaq art processes
artdaq::PortManager
artdaq::PrintBuildInfoAn art::EDAnalyzer which prints any artdaq::BuildInfo objects stored in the run
art::ProducersConfig
artdaq::RandomDelayFilterA 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::register_monitor_Register_monitor_ Command class
artdaq::reinit_
artdaq::report_Report_ Command class
artdaq::detail::RequestHeaderHeader of a RequestMessage. Contains magic bytes for validation and a count of expected RequestPackets
artdaq::detail::RequestMessageA RequestMessage consists of a RequestHeader and zero or more RequestPackets. They will usually be sent in two calls to send()
artdaq::detail::RequestPacketThe RequestPacket contains information about a single data request
artdaq::RequestReceiverReceive data requests and make them available to CommandableFragmentGenerator or other interested parties. Track received requests and report errors when inconsistency is detected
artdaq::RequestSenderThe RequestSender contains methods used to send data requests and Routing tokens
artdaq::resume_
artdaq::rollover_subrun_Rollover_subrun_ Command class
art::RootNetOutputAn 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::RootOutputConfigConfgiguration for ROOT output modules
artdaq::RoundRobinPolicyA 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::RoutingAckPacketA RoutingAckPacket contains the rank of the table receiver, plus the first and last sequence IDs in the Routing Table (for verification)
artdaq::RoutingMasterAppRoutingMasterApp is an artdaq::Commandable derived class which controls the RoutingMasterCore state machine
artdaq::RoutingMasterCoreRoutingMasterCore 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::RoutingMasterPolicyThe interface through which RoutingMasterCore obtains Routing Tables using received Routing Tokens
artdaq::detail::RoutingPacketEntryA row of the Routing Table
artdaq::detail::RoutingPacketHeaderThe header of the Routing Table, containing the magic bytes and the number of entries
artdaq::RoutingReceiver
artdaq::DataSenderManager::RoutingTableConfigConfiguration for Routing table reception
artdaq::detail::RoutingTokenThe 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::RoutingTokenConfigConfiguration for Routing token sending
artdaq::RTIDDSDDS Transport Implementation
artdaq::RTIDDSTransferRTIDDSTransfer is a TransferInterface implementation plugin that transfers data using RTI DDS
art::ServicesConfigConfiguration of the services block for artdaq art processes
art::ServicesSchedulerConfigConfiguration of the services.scheduler block for artdaq art processes
artdaq::SharedMemoryEventManagerThe SharedMemoryEventManager is a SharedMemoryManger which tracks events as they are built
artdaq::detail::SharedMemoryReader< getDefaultTypes >The SharedMemoryReader is a class which implements the methods needed by art::Source
artdaq::ShmemTransferA TransferInterface implementation plugin that transfers data using Shared Memory
ShmRTestFixtureSharedMemoryReader Test Fixture
artdaq::shutdown_Shutdown_ Command class
artdaq::soft_init_
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::SourceConfigConfiguration for the source block of artdaq art processes
artdaq::start_Command class representing a start transition
artdaq::StatisticsHelperThis class manages MonitoredQuantity instances for the *Core classes
artdaq::status_Status_ Command class
artdaq::stop_
artdaq::TCPSocketTransferTransferInterface implementation plugin that sends data using TCP sockets
anonymous_namespace{genToArt.cc}::ThrottledGeneratorThrottledGenerator: ensure that we only get one fragment per type at a time from the generator
TimeoutPerforms registered actions at specified intervals
Timeout::timeoutspecSpecification for a Timeout function
artdaq::trace_get_Trace_get_ Command class
artdaq::trace_set_Trace_set_ Command class
artdaq::TransferInterfaceThis interface defines the functions used to transfer data between artdaq applications
art::TransferOutputAn 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::TransferTestTest a set of TransferInterface plugins
artdaq::TransferWrapperTransferWrapper 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_commanderServes as the XMLRPC server run in each artdaq application

Generated on 5 Mar 2019 for artdaq by  doxygen 1.6.1