Level 2 Trigger Software Interface

1
Level 2 Trigger Software Interface

• R. Moore,
• Michigan State University

2
L2 Crate
Trigger Control Computer
Data Input
Data Output
External Communications
Internal Communications
3
Software Components
L2 Software Framework
Administrator
MBus
Worker Level User code
Physics!
Tool Level User code
4
L2 Simulator
Online
Packed Data
I/Ogen
(testing only)
Unpack Data Chunk
Raw Chunk
I/Ogen
Offline
dynamic_castltgt
5
L2 Simulator

• L2 simulator runs online worker code only
• framework code (administrator) not included
  because it has no physics impact
• Online L2 framework replaced by offline code
• control hooks replaced by offline framework
  package
• data interface replaced to use unpacked data
  chunks

6
Writing L2 Code

• What you need to know
• L2 coding guidelines(http//d0lxmsu1.fnal.gov/L2/
  L2CodingGuidelines.pdf)
• How to use DOC
• How to use the offline build environment
• CTBuild user guide hopefully appearing soon?
• Input and output object formats
• tell Dylan and hell add them to the L2 I/Ogen
  configuration file
• Worker algorithm
• What you dont need to know!
• Unpacked data chunks
• Whether you are running online or offline

7
Creating a Worker

• Create a new package for the algorithm code
  named
• l2ltworker abbrevgtworker
• e.g. l2gblworker, l2cttworker
• Write the main worker class and put it into this
  package
• the same class is used online AND offline
• Class name ltworkergtWorker e.g. GlobalWorker
• Create a new package to interface to trigsim,
  called
• tsim_l2ltworker abbrevgt
• e.g. tsim_l2gbl, tsim_l2ctt

8
Writing the Worker Class

• Worker class is ONLINE code
• ALL L2 workers need one
• Required methods
• void processEvent(void)
• Plus others to be added later for monitoring,
  initialization etc.
• MUST obey L2 online coding guidelines no STL!
• processEvent(void)
• processes the current event
• Event I/O handled by offline or online framework

9
Offline Interface

• Use L2 specific macros to register with framework
• e.g. tsim_l2gbl.cpp

include "framework/Registry.hpp" include
"l2workersim/FrameworkMacros.hpp" include
"l2gblworker/GlobalWorker.hpp" include
"l2gblworker/GlobalEventInput.hpp" include
"l2gblworker/GlobalEventOutput.hpp" include
"l2workersim/WorkerSim.hpp" using namespace
l2gblworker using namespace l2workersim L2FWK_R
EGISTRY_IMPL(Global,"Name ")

• e.g. Regtsim_l2gbl.cpp

include "framework/Registry.hpp" include
"l2workersim/FrameworkMacros.hpp" L2FWK_REGISTRY_
DECL(Global)
10
Input Format
InputBufferltObjectgt ChunkInputBuffer
ltObjectgt

• Single MBT (or UDC if offline) channel maps to a
  template class
• Behaves like an array of the given object type
• Inherits from L2Header to allow access to header
  data

11
Output Format
Raw Data
Unpacked Data Chunk
L3Header
Channel
Node Header
Channel
Channel
Module
Channel
L3Trailer
Channel
12
High Level Format
Raw Data
Unpacked Data Chunk
Crate System L3 Output UBS
Inputs Module UBS Output

• Each worker and administrator has three possible
  output modules
• Normal L2 output
• Copy of inputs (UBS events)
• Special UBS event data output

13
Building the Output

• Output created by ChannelFiller templates which
  each fill one channel
• Template parameters
• Object type stored in channel
• Getter class
• Getter class fetches the data from the worker
  code
• bool gotData() returns true if there is more data
  to get
• ltObjectgt nextObject() returns the next object
• void newEvent() notifies class of a new event
• Some standard Getters provided

14
Event I/O

• Classes to access data created by evigen python
  script
• ltworkergtEventInput
• ltworkergtEventOutput
• Configuration file similar to Windows .ini files
• Full documentation being worked on

15
Example.evi

• Worker
• package l2gblworker
• name Global
• system GBL_L2
• stdout GBL_STD_OUTPUT
• ubsout GBL_UBS_OUTPUT
• ubsin GBL_UBS_INPUTS
• Input0
• name pTTrack
• object CTTPTTrack
• type unpacked
• limit 50
• system CTT_L2
• module CTT_STD_OUTPUT
• channel GBL_PTTRACK
• comment pT tracks from CTT

16
Example.evi II

• StdOutput0
• object Electron
• getter l2workerbase/FetchTag
• channel GBLOUT_ELECTRON
• majorver 0
• minorver 1
• StdOutput4
• object Tau
• getter l2workerbase/FetchTag
• channel GBLOUT_TAU
• majorver 0
• minorver 1
• UbsOutput0
• object Electron
• getter l2workerbase/FetchAll
• channel GBLOUT_ELECTRON
• majorver 0

17
Accessing the Data

• To access the input data inherit the EventInput
  class

class ATool public GlobalEventInput void
findElectron(void) void AToolfindElectron
(void) if (pTTrack.bunch() !
emCluster.bunch()) errlog ltlt Calling SCL
init! dphipTTracki.phi()-
emClusterj.phi()
18
Writing the Data

• To use provided Getter classes output objects
  inherit from a Creator

class Electron public CreatorltElectrongt

• This provides a static method create() which
  returns a pointer to a new class instance
• you cannot use new !

Electron myelectron Electroncreate()
19
Current Status

• Basic software packages written and docs in
  progress
• Basic interface stable, only minor changes or
  additions
• Ready for L2PPs to start using framework
• BUT still a little rough
• Need to liase with Dylan/me
• Not everything will work out of the box just
  yet
• Toy GlobalWorker written by Dylan
• Can test single Global tools

20
Still to do

• Add interface to L2 low level parser
• L2parser package written and documented
• Cant use RCP online code
• Add hook for monitoring data collectStatus()
• Add support for non-standard data formats
• e.g. CTT has private header
• if L2 input not stored in L3 raw data need to
  write a package to recreate it
• BUT some L1 packages will use L2 UDC standard
  (L1Cal)

21
Yet more to do

• Make a L2 release
• Currently all packages in CVS but not in a
  release
• Understand the build system (CTBuild/SRT/)
• Need to set compiler options
• e.g. -DOFFLINE, -DDEBUG
• CTBuild docs promised

22
Conclusion

• The basic L2 framework is complete and ready for
  use
• should remove a lot of the pain we have had to
  endure!
• Switching to online is easy once we have the
  hardware
• Code written 6 months ago
• Needs interfacing with low level device drivers
• Bells and whistles will be added over the next
  several months as interfaces are agreed upon
• monitoring
• configuration

23
Data I/O

• All L2 I/O done using I/Ogen classes
• Python script which generates code to convert
  between packed memory and C class
• handles multiple format versions in offline
• centralizes object formats to ensure
  compatibility
• interfaces easily to the (new) Unpacked Data
  Chunks
• creates routines to print data classes in
  human-readable form

24
I/Ogen in l2io
Configuration File l2io.iogen
Python Script
IO Classes
Data Classes