Managing the Online Event Displays at P1

Contacts & People

On-call phone:

  • CERN internal: 16-1094
  • External: +41-76-487-1094

Experts:

Shifters:

(To be updated)

Relevant pages and mailing lists:

Relevant pages

These are read-only. To edit them from P1, change the host in the address from "pc-atlas-www.cern.ch" to "atlasop.cern.ch". More info here: https://atlasop.cern.ch/twiki/bin/view/SysAdmins/FAQ

Relevant mailing lists

atlas-tdaq-eventdisplays@cern.ch

Accessing P1 machines

You must have a remote role to access the P1 network. You may also need an expert role to access the pc-tdq-mon-xx machines and execute some specific commands.

  • Request roles through the web page: https://atlasop.cern.ch/amrm/api/request_role/
  • Select DQM:remote and DQM:expert, and explain your task in "Reason" window
  • After your request is approved by one of DQ coordinators, you can connect to the P1 gateway.

For more info: https://atlasop.cern.ch/twiki/bin/view/SysAdmins/FAQ

Then, connect to the P1 gateway:

ssh -XY atlasgw.cern.ch

answer the questions, then, when asked to choose a host, you can choose, for example:

  • pc-atlas-pub-01 or pc-atlas-pub-02 , the default landing virtual machine, for all standard operations at P1
  • pc-tdq-mon-29 or pc-tdq-mon-30 , these are the machines where the actual EventDisplay partition runs on
  • pc-atlas-cr-proj1 or pc-atlas-cr-proj2 , these are the machines where the Atlantis instances on the projectors run (usually on 2, right hand side of ACR)

P1 Environment setup

Setup Athena when needed:

# Setup Athena
export AtlasSetup=/sw/atlas/AtlasSetup
alias asetup='source $AtlasSetup/scripts/asetup.sh'

Setup the TDAQ release (every time you open a shell in P1):

# Setup TDAQ7
source /det/tdaq/scripts/setup_TDAQ_tdaq-07-01-00.sh

# Setup TDAQ8
source /det/tdaq/scripts/setup_tdaq-08-03-01.sh

add these lines to the .bashrc or .bash_profile file in your home folder at P1 (or create a new .sh file, which you will source it from them):

ATH=$PATH:$HOME/bin

# Setup TDAQ/OKS
source /det/tdaq/scripts/setup_TDAQ_tdaq-07-01-00.sh

export TDAQ_DB_DATA=/atlas/oks/${TDAQ_VERSION}/
export TDAQ_DB_USER_REPOSITORY=~/db/${TDAQ_VERSION}/

# Setup Athena
export AtlasSetup=/sw/atlas/AtlasSetup
alias asetup='source $AtlasSetup/scripts/asetup.sh'

# Not sure where this comes from, but OKS doesn't like it
#unset LC_CTYPE
#export LANG=en_US.UTF-8
export ROOT_INCLUDE_PATH=/sw/extras/sw_tmp/current/tdq/tdaq-06-01-00/usr/includ\
e:${ROOT_INCLUDE_PATH}
export PATH

unset USERNAME

Source the .bashrc file again, to set everything

The EventDisplays partition

After setting up the TDAQ release, one can start the EventDisplays partition:

setup_daq -d ${TDAQ_DB_REPOSITORY}/combined/partitions/EventDisplays.data.xml -p EventDisplays

The -p option sets the name of the partition to start, for our purpose we want to start the EventDisplays partition

The command starts the TDAQ IGUI.

Screenshot-ATLAS TDAQ SOFTWARE - Partition EventDisplays.png
TDAQ IGUI

To get the control on the partition, click on "Access Control" in the top menu, then choose "Control" (the default option is "Display"). Please, be sure to go back to "Display" before shutting down the TDAQ IGUI, otherwise the partition is shutdown when IGUI is closed.

If the EventDisplays partition is already set up, the TDAQ IGUI can also be started with:

igui_start -p EventDisplays

Applications

There are different applications which run to correctly produce event displays

If you double-click on the segment Server-EventDisplay-Segment, you will get the list of all the applications running. At the time of writing three applications need to run for the online Event Displays machinery:

  • JiveXML-Server: Produces the Jive XML files for Atlantis from events picked by the Athena-EventDisplay-Segments.
  • Atlantis-ImageProducer: it produces the Atlantis event displays shown in the ACR and served by the "browser" at:
  • Atlantis-PublicImageProducer: it takes a random subset of the events, to be shown on the "public" web page. The public images are made from the same events as the internal ones, but with a different image setup.
Please note that the events are not selected or chosen of flagged: they are only randomly picked from the whole set of events

if you click on them, and then double-click on their name in the right panel, you can get the machine: at the time of writing they run on pc-tdq-mon-29 or pc-tdq-mon-30.

Screenshot-ATLAS TDAQ SOFTWARE - Partition EventDisplays-1.png
Running applications

The machines where the applications run are configured in the partition OKS file:

combined/segments/Sever-EventDisplays-Segment.data.xml

See the "Partition OKS files" section for more information.

Event Processing

Events for the online event displays are produced on-the-fly taking data from TDAQ directly, and reconstructing them online.

If you double-click on the "Athena-EventDisplays-segment" bar, you will get the list of all *event processor" instances running. At the time of writing, you will see 6 instances running, three on pc-tdq-mon-29 (you see the name of the machine at the end of the text string) and three on pc-tdq-mon-30.

Screenshot-ATLAS TDAQ SOFTWARE - Partition EventDisplays-2.png
Running event processors

The number of instances and the machines where they run are configured in the partition OKS file:

combined/segments/Athena-EventDisplays-Segment.data.xml

See the "Partition OKS files" section for more information.

Useful commands

Please note that you can only see partitions running in the same TDAQ release as your P1 environment setup. For example, if you setup TDAQ8 you can only see partitions running in TDAQ8. If the ATLAS partition is running in TDAQ8, the EventDisplays partition has to be setup with TDAQ8 in order to talk to ATLAS.

  • ipc_ls -P: lists all partitions running. You should see, among the others, the three partitions needed for the whole Online Event Displays machinery:
    • ATLAS
    • EventDisplays
    • GMTestPartition: Global Monitoring test partition which loops over a set of pre-recorded events to mimic the ATLAS partition for testing.

  • ipc_ls -p EventDisplays: lists applications for the given partition

  • pmg_kill_partition: if the partition goes really really bad... then you can use pmg_kill_partition to kill it!
  • You can take a look at the other pmg family commands:
$ compgen -A command pmg
pmg_ctrl_panel
pmg_is_panel
pmg_extract_exit_code.sh
pmg_list_partition
pmg_kill_app
pmg_kill_agent
pmglauncher
pmg_wait_app
pmg_start_app
pmg_killall_on_host
pmg_list_on_host
pmg_dump_manifest
pmgserver
pmg_sleep_process
pmg_kill_partition

More information

More information on the partition here:

Partition OKS files

The OKS database repositories are stored at /atlas/oks/ under directories named by the TDAQ versions .The following files are related to the EventDisplays partition:

  • combined/partitions/EventDisplays.data.xml: The main partition OKS file
  • combined/segments/Athena-EventDisplays-Segment.data.xml: The segment hosting 6 instances of event processors
  • combined/segments/Server-EventDisplays-Segment.data.xml: The segment hosting the JiveXML server and the two Atlantis image producers.
  • combined/sw/EventDisplay_SW_Repository.data.xml: Defines the Athena release and the path to Event Display software install area

More information: https://twiki.cern.ch/twiki/bin/view/Atlas/DaqHltOks#3_2_OKS_Server_User_s_Guide

Update OKS files

This is needed when changing Athena release for the online Event Displays. See the "Switch to a new release" section for detailed instructions.

# After setup TDAQ release
oks-checkout.sh ${TDAQ_DB_REPOSITORY}/combined/partitions/EventDisplays.data.xml
# do some modifications
oks-commit.sh -m "INSERT COMMENT HERE" -u <filename>

Import OKS files to new repository

This is needed when migrating to a new TDAQ release.

Instruction with git-based OKS (TDAQ-09-01-00 and later):

# import files from TDAQ-09-00-00 to TDAQ-09-01-00
cd /atlas/oks/tdaq-09-00-00/
source /det/tdaq/scripts/setup_TDAQ_tdaq-09-01-00.sh
oks-import.sh -m "import files from tdaq-09-00-00 release" combined/sw/EventDisplay_SW_Repository.data.xml combined/segments/Athena-EventDisplays-Segment.data.xml combined/segments/Server-EventDisplays-Segment.data.xml combined/partitions/EventDisplays.data.xml

# setup TDAQ7 and check out the files
source /det/tdaq/scripts/setup_TDAQ_tdaq-07-01-00.sh
mkdir db
cd db
oks-checkout.sh combined/sw/EventDisplay_SW_Repository.data.xml
oks-checkout.sh combined/segments/Server-EventDisplays-Segment.data.xml
oks-checkout.sh combined/segments/Athena-EventDisplays-Segment.data.xml
oks-checkout.sh combined/partitions/EventDisplays.data.xml
cd tdaq-07-01-00/combined

# setup TDAQ8 and try to import the files one-by-one. Resolve any OKS errors during the import.
source /det/tdaq/scripts/setup_tdaq-08-03-01.sh
(# update Tags in EventDisplay_SW_Repository.data.xml from x86_64-slc6-gcc62-opt to x86_64-centos7-gcc8-opt)
oks-import.sh -d combined sw/EventDisplay_SW_Repository.data.xml
oks-import.sh -d combined segments/Athena-EventDisplays-Segment.data.xml
(# update dependency of Server-EventDisplays-Segment.data.xml from daq/schema/new-test-repository.schema.xml to test-repository.schema.xml)
oks-import.sh -d combined segments/Server-EventDisplays-Segment.data.xml
(# update Tags in EventDisplays.data.xml from x86_64-slc6-gcc62-opt to x86_64-centos7-gcc8-opt)
oks-import.sh -d combined partitions/EventDisplays.data.xml

Online Event Displays machinery

The whole online event displays machinery can be found in the folder:

/det/dqm/EventDisplays

If you list the directory, you will find current, which is a soft link to the current release of the machinery used at P1. This sets up the software for EventDisplay-segments running on pc-tdq-mon-29/30. When the main ATLAS partition starts these segments are automatically restarted to pick up the current run conditions (run tag, B-field, etc...).

For special running conditions it is sometimes useful to setup two instances of the EventDisplay-Segments, one on pc-tdq-mon-29 and one on pc-tdq-mon-30. This is needed when the express stream is not a sub-set of the physics stream, i.e. Beam Splashes. To do this setup the partition as normal, pointing to all streams of type physics. When the main ATLAS partition starts (Look for our partitions restarting) then switch the current softlink to point at an instance pointing at streams of type express. Then restart manually the segments on one of pc-tdq-mon-29 OR pc-tdq-mon-30.

Create a new release

When you make a new release, please make sure to do the following steps:

  • check out the necessary packages
  • compile on a pc-atlas-pub-xx machine at P1, or on lxplus
  • if compilation is OK, test the Event Processor jobs at P1

If it is an official release for the online Event Displays, you can either put the new release folder in /det/dqm/EventDisplays directly, or create the release folder elsewhere and copy it to /det/dqm/EventDisplays after compilation.

The the folder structure may differ between release 20, 21 and 22.

Release 22

Make a new directory, whose name should reflect the new Athena release we use or the specific purpose the release is made for:

rel='22.0.9'
mkdir Athena-${rel}
cd Athena-${rel}
mkdir source build
cd source
source /sw/atlas/AtlasSetup/scripts/asetup.sh --input=None Athena,${rel},here

Check out the needed packages in the new release and compile them all:

  • Projects/WorkDir
  • graphics/EventDisplaysOnline
  • graphics/JiveXML
  • HLT/Services/JiveXMLServer
  • atlantis

rel='22.0.9'

git init
git config core.sparseCheckout true
git remote add origin https://:@gitlab.cern.ch:8443/atlas/athena.git
echo Projects/WorkDir >>.git/info/sparse-checkout
echo graphics/EventDisplaysOnline >>.git/info/sparse-checkout
echo graphics/JiveXML >>.git/info/sparse-checkout
echo HLT/Services/JiveXMLServer >>.git/info/sparse-checkout
git fetch --all --tags --prune
git checkout release/${rel} -b ${rel}

kinit -f
git clone https://:@gitlab.cern.ch:8443/atlas/atlantis.git
# If compiled at P1, update java and ant path in atlantis/CMakeLists.txt:
# change java path to /sw/atlas/sw/lcg/external/Java/JDK/Oracle_1.7.0_40/amd64
# change ant path to /sw/atlas/sw/lcg/external/Java/Ant/1.7.0/share/bin/ant

cd ../build
cmake ../source/Projects/WorkDir/
make

Release 21

Check out the needed packages and compile them all.

rel='21.1.56'

cd /det/dqm/EventDisplays/
mkdir AthenaP1-${rel}
cd AthenaP1-${rel}
mkdir source build
cd source
source /sw/atlas/AtlasSetup/scripts/asetup.sh --input=None --cmakeversion 3.14.3 AthenaP1,${rel},here

git init
git config core.sparseCheckout true
git remote add origin https://:@gitlab.cern.ch:8443/atlas/athena.git
#echo graphics/AtlantisJava >>.git/info/sparse-checkout # obsolete. Atlantis has been moved out of athena.
echo graphics/EventDisplaysOnline >>.git/info/sparse-checkout
echo graphics/JiveXML >>.git/info/sparse-checkout
echo HLT/Services/JiveXMLServer >>.git/info/sparse-checkout
git fetch --all --tags --prune
git checkout release/${rel} -b ${rel}

git clone https://:@gitlab.cern.ch:8443/atlas/atlantis.git # check out Atlantis

cd ../build
cmake ../source
make

At the time of writing, the last working version in release 21 is /det/dqm/EventDisplays/AthenaP1-21.1.27_GIT_asetup_wrapper/, which has a patched asetup_wrapper from the HLT/HLTUtils package to make it compatible with the current version of AtlasSetup installed at P1. To use this release:

cd /det/dqm/EventDisplays
ln -nfs AthenaP1-21.1.27_GIT_asetup_wrapper current
ls -l current
current -> AthenaP1-21.1.27_GIT_asetup_wrapper/

source /det/tdaq/scripts/setup_TDAQ_tdaq-07-01-00.sh
setup_daq -d /atlas/oks/tdaq-07-01-00/combined/partitions/EventDisplays.data.xml -p EventDisplays

Release 20

$ ls -l current
current -> AtlasP1MON-20.11.0.8.1/
$ mkdir AtlasP1MON-20.11.0.8.2
$ ln -nfs AtlasP1MON-20.11.0.8.2 current # replacing the symlink
$ ls -l current
current -> AtlasP1MON -20.11.0.8.2/

then, you should edit the asetup file, specially the fields:

  • release
  • testarea

and sometimes, when used and when needed:

* CORAL_DBLOOKUP_PATH

The, you should run:

asetup --input=asetup
source update.sh # check out tags and compile

The script update.sh checks out all the needed tags (both Atlantis and VP1) and compiles them all. (You might be asked to type your password many times, for SVN) This should become unnecessary as packages are swept into P1MON.

When you make a new release, please make sure to do the following steps:

  • source the tags
  • compile on a standard P1 machine
  • if compilation is OK, points the current symlink to the folder of the new release

Sometime you might also want to then check the file:

  • /det/dqm/EventDisplays/current/Reconstruction/RecExample/RecExOnline/share/RecExOnline_emonsvc.py: it asks to emon the full list of tags

Test a new release

The athena event processor jobs can be tested outside the EventDisplays partition. In order to do that, setup TDAQ and some basic environment variables, and then launch the athena job:

source /det/tdaq/scripts/setup_tdaq-08-03-01.sh
cd <the-compiled-release-folder>/source
source /sw/atlas/AtlasSetup/scripts/asetup.sh --restore
# or source /sw/atlas/AtlasSetup/scripts/asetup.sh --input=None Athena,22.0.9,here
export TDAQ_IPC_TIMEOUT=15000
source ../build/x86_64-centos7-gcc8-opt/setup.sh
cd ..
mkdir run
cd run
athena ../source/graphics/EventDisplaysOnline/share/EventDisplay_jobOptions.py >& log1 &

By default, the event processor reads events from the ATLAS partition and reconstruct them on-the-fly. In case the ATLAS partition is not running, connect the jobs to GMTestPartition to get test events. In order to do that, modify graphics/EventDisplaysOnline/share/EventDisplay_jobOptions.py to change partitionName from 'ATLAS' to 'GMTestPartition'.

Switch to a new release

Once you have created, compiled and test the new release, you have now to make the EventDisplays partition use it. In order to do that, please follow these steps:

  • Check the release pointed by current. Update the symlink of current to point to the new release:
cd /det/dqm/EventDisplays
ls -l current
ln -nfs Athena-22.0.18 current
ls -l current
current -> Athena-22.0.18/

  • Update the partition OKS file

# setup TDAQ
source /det/tdaq/scripts/setup_TDAQ_tdaq-09-02-01.sh
# check out the OKS files in a tmp directory and cd to it:
cd `oks_clone_repository`
# Update ED_VERSION value in combined/sw/EventDisplay_SW_Repository.data.xml
# Commit the change
oks-commit.sh -m 'Event display switched to Athena xx.x.xx' -u `pwd`

# in your home directory
mkdir db
cd db
source /det/tdaq/scripts/setup_tdaq-08-03-01.sh
oks-checkout.sh ${TDAQ_DB_REPOSITORY}/combined/sw/EventDisplay_SW_Repository.data.xml
cd tdaq-08-03-01
# Update ED_VERSION value in combined/sw/EventDisplay_SW_Repository.data.xml
oks-commit.sh -m "switch to Athena <version numbr>" -u combined/sw/EventDisplay_SW_Repository.data.xml

  • Restart the EventDisplays partition
    • Stop the current EventDisplay partition from the TDAQ IGUI (You should be in "Control" mode)
    • Put an ELOG with stop reason like change of ED release from xxx to xxx (if not a mere dev test)
    • Unconfig and Shutdown the partition
    • Click the "Commit & Reload" button and reload the OKS file that you updated in the previous step.
    • Initialize, Config and Start the partition
    • Start
    • Put an ELOG with start reason like change of ED release from xxx to xxx (if not a mere dev test)
    • you will get a message saying "Master trigger not defined"... no worries (hopefully)!

  • After partition restarts, check logs:
    • ssh pc-tdq-mon-29 (or 30)
    • cd /logs/tdaq-08-03-01/EventDisplays
    • ls -ltr
    • open a log file, e.g.: vi Athena-EventProcessor:Athena-EventDisplays-Segment:EventDisplays-Rack:pc-tdq-mon-29:2_pc-tdq-mon-29.cern.ch_1462191488.outt, for example
    • check the release

Once you have created, compiled and set the new release, you have now to make ATLAS use it. In order to do that, please follow these steps:

  • Stop the current EventDisplay partition from the TDAQ GUI (You should be in "Control" mode)
  • Put an ELOG with stop reason (if not a mere dev test)
  • Unconfig
  • Config
  • Check run parameters in https://atlasop.cern.ch/overview/
  • set values of data flags according to the run parameters; leave empty the other parameters
  • you will get a message saying "Master trigger not defined"... no worries (hopefully)!
  • check logs:
    • ssh pc-tdq-mon-29 (or 30)
    • cd /logs/tdaq-06-01-01/EventDisplays
    • ls -ltr
    • open a log file, e.g.: vi Athena-EventProcessor:Athena-EventDisplays-Segment:EventDisplays-Rack:pc-tdq-mon-29:2_pc-tdq-mon-29.cern.ch_1462191488.outt, for example
    • check:
      • is_T0_project_tag: check if it is updated with the right current information; e.g.:
        • Py:RecExOnline_globalconfig INFO is_T0_project_tag = data_test
      • toroidCurrent: check if it is updated with the right current information; e.g.:
        • Py:RecExOnline_globalconfig INFO toroidCurrent = 0.034407

Note:

When the ATLAS partition goes down and then restarts, the EventDisplays partition is automatically restarted when the ATLAS one hits "Start". That is because the EventDisplays partition takes parameters from the main ATLAS partition.

Directory structure:

atlantis

  • atlantis: it stores the config files for the Atlantis images

  • graphics/AtlantisJava: it stores the config files for the Atlantis images
At the end of Run 2, the AtlantisJava package has been moved out of athena to a standalone git repository at https://gitlab.cern.ch/atlas/atlantis

EventDisplaysOnline

  • graphis/EventDisplaysOnline: it stores scripts to do online reconstruction and produce files.

graphics/EventDisplaysOnline/share

The main one is: EventDisplay_jobOptions.py , which is the main Athena jobOptions. It is called by the EventDisplays partition OKS file Athena-EventDisplays-Segment.data.xml to create instances of event processors in the Athena-EventDisplays-Segment.

The most important settings are:

  • keycount: number of DCM per job connecting
  • timeout: in milliseconds; 10 minutes is OK for default run
  • keyname: name of the machines I'm talking to
  • streamType: name of the data stream I'm looking at
  • beamName: "cosmics" or "collisions"
  • partitionName: name of the partition we want to read from
  • ConditionsTag: should be checked periodically, in order to get the latest
  • doJiveXML: it is set to "false" here, because it is done afterwards
  • OutputDirectory: where the output event displays are eventually stored

After having set the output folder, the script calls (include, actually) the WaitForAtlas_jobOptions.py jobOption script, which looks for the ATLAS partition to read data from. (It is different for Cosmics.)

## Pause this thread until the ATLAS partition is up
include ("EventDisplaysOnline/WaitForAtlas_jobOptions.py")

After that 6 instances of the event producers are set:

## Setup unique output files (so that multiple Athenas on the same machine don't interfere)
jobId = os.environ.get('TDAQ_APPLICATION_NAME', '').split(':')
if not len(jobId) == 5:
    from random import randint
    jobId = ['Athena-EventProcessor', 'Athena-EventDisplays-Segment', 'EventDisplays-Rack', 'tmp', '%d' % randint(0, 999)]

After that, Athena is set and the three main jobOption scripts are started:

include ("EventDisplaysOnline/JiveXMLServer_jobOptions.py")
include ("EventDisplaysOnline/Atlantis_jobOptions.py")
include ("EventDisplaysOnline/VP1_jobOptions.py")

  • JiveXMLServer_jobOptions.py: select what kind of events go to the public stream. See "Public Stream" section.
  • Atlantis_jobOptions.py: Atlantis specific job options
  • VP1_jobOptions.py: VP1 specific job options

graphics/EventDisplaysOnline/python

  • PruneAlg.py: algorithm for pruning event display files, i.e. it cleans the output folder to keep only the latest N (1000, by default) event displays
  • EventUtils.py: ???
  • EventDisplaysConfig.py: this reads the TDAQ info from IS
  • OnlineEventDisplaysSvc.py: it takes the events from Reconstructions, and it distributes them into different streams. It retrieves run info and trigger info and splits the events into folders. Also, it picks events for the "Public" folder

Event displays in the ACR

On ACR machines you can start the Atlantis event display by clicking in the bottom on "Monitoring"-->"Atlantis"

This will open a dialog (a KDialog instance), which then starts the program.

The dialog is started through a script, which is stored in:

  • /det/dqm/scripts/start_atlantis.sh :
    • starts the application on ACR machines
  • /det/dqm/scripts/atlantis_setup.sh
    • called by start_atlantis.sh to setup the environment

Both are symlinks to the current scripts; e.g. at the time of writing:

$ ls -l start_atlantis.sh
start_atlantis.sh -> start_atlantis.sh.newclient
$ ls -l atlantis_setup.sh
atlantis_setup.sh -> atlantis_setup.sh.newclient

The screen of the machine "PC-ATLAS-CR-PROJ1" (sitting at the left side of the Shift Leader seat, or, better, between the Shift Leader and the DQ seats) is mirrored on the ACR wall through the projectors. The 4 projectors mirror the different virtual screens of this machine.

To start the Atlantis event display:

  • "Monitoring"
  • "Atlantis"
  • select the data stream
  • set the update rate: 5 seconds for the refresh rate (it is 1 second for event processing)

then the display is set and started.

You can start the monitoring clicking on the "Monitoring" bottom menu, then "Atlantis". Then you are asked to select the stream. You can open multiple instances of this monitoring event display. Usually two are opened: one projected on the wall through the central projector, plus another one projected on the far right side of the wall. The two are usually taking events from two different streams (e.g.: physics_Main and physics_StandBy ).

If you want to change the stream while it's running, you can open the Atlantis menu, and change the data stream in the ComboBox list.

The streams in that list are defined in the script: ???

The on-screen dialogs live in: /det/dqm/scripts . There you find three main scripts:

  • atlantis_setup.sh
  • start_atlantis.sh
  • start_VP1.sh

They are softlinks to the actual scripts, which are customized for different different needs or data taking periods (cosmics, ...).

atlantis_setup.sh script

Here you find settings like the server machine, the refresh rate, the Java memory options for Atlantis, the color map or the event which is shown as default:

...
# default server to connect to
ATLANTIS_SERVER="pc-tdq-mon-29"; export ATLANTIS_SERVER

# default refresh rate (server)
ATLANTIS_REFRESH_RATE_SERVER="5"; export ATLANTIS_REFRESH_RATE_SERVER

# default refresh rate (file)
ATLANTIS_REFRESH_RATE_FILE="10"; export ATLANTIS_REFRESH_RATE_FILE

# default event to display
ATLANTIS_DEFAULT_EVENT="MinBias_900GeV_2009.zip"; export ATLANTIS_DEFAULT_EVENT
...

start_atlantis.sh script

Inside this script you will find the settings for the dialog which starts Atlantis on the Monitoring machine. Here you define what the user gets in the dialog and the default choices.

start_VP1.sh script

This is the script to launch VP1 on machines at ACR. OBSOLETE!!! NEEDS TO BE UPDATED!!!

The "Live" machinery

Machinery

To resume: events are produced at P1 on machines pc-tdq-mon-29/30. Then stored at P1 in the folder /atlas/EventDisplayEvents. Then they are transferred to offline (virtual) machines with chron jobs.

How to access the offline machine (outside P1):

ssh aiatlas006

To access it, you should be member of the group: atlas-adc-restricted-users-evdisp To add yourself as a member, please go to: https://e-groups.cern.ch/e-groups/EgroupsSearchForm.do

Then:

  • /data1/EventDisplayServer/: get the offline event display files, copied from the P1 folder
  • /data1/atlas-live: ???
  • /data1/atlived: (empty) ???
  • /data1/lhsee: images for the Android "LHSee" application

  • /data: (copy of data1 ???)

Interfaces:

The "ATLAS-Live" is the web interface which serves the event displays reconstructed on-the-fly at P1 by the Online Event Displays machinery.

It has two interfaces:

  • a Collaboration internal page:
  • a Public page:

The Collaboration page shows all the latest event displays produced online. The Public one shows a random sub-set of the internal displays. Note: events served as Public are not selected at all, they are only a random sub-set. Maybe we want to apply some simple filters, like number of tracks? That could be useful to only show events with something inside... To be discussed???

Live Server:

The server runs on the machine aiatlas006.cern.ch mentioned above.

The main scripts live on aiatlas006:

  • /var/www/EventDisplayServer/atlid/atlived.py: the main script which is run from system as a service service_atlived.sh , which is defined in:
  • /var/www/scripts/init.d/atlived

To start/stop the Live machinery:

  • service atlived start
  • service atlived stop

Public stream

JiveXMLServer _jobOptions.py

/det/dqm/EventDisplays/current/graphics/EventDisplaysOnline/share/JiveXMLServer_jobOptions.py

  • change:
    • projectTags=['data16_13TeV']
    • publicStreams=['physics_Main']
  • compile
  • Unconfig
  • Config

then ../python/OnlineEventDisplaysSvc.py shuffles streams and then picks up a random sub-set of events to be shown to public. Please note that the events are not selected or chosen of flagged: they are only randomly picked from the whole set of events

Other useful stuff

-- RiccardoMariaBianchi - 2016-04-22 RiccardoMariaBianchi - 2016-05-02 LiaoshanShi - 2020-03-03

Edit | Attach | Watch | Print version | History: r20 < r19 < r18 < r17 < r16 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r20 - 2021-03-23 - LiaoshanShi
 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    Main All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2021 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
or Ideas, requests, problems regarding TWiki? use Discourse or Send feedback