Skip to content

Utilisation d'une machine virtuelle ProxMox

La machine lyoilcdaq01

Accès et utilisation

Accès

La machine virtuelle lyoilcdaq01 est une instance Linux Ubuntu 24.04.2 LTS sur le serveur pve.ip2i.in2p3.fr accessible par un navigateur avec les comptes habituels.

Elle est également accessible par ssh depuis lyoilc07 et lyocmsmu03 avec le même compte.

Cette machine a une haute disponibilité et est hébergée sur un de nos serveurs au centre de calcul.

En utilisant les scripts décrits dans cette documentation il est possible de réinstaller la totalité des services nécessaires aux prises de données sur une machine pré-installée avec Linux Ubuntu 24.04.2 LTS

Utilisation

Cette machine fournit sous docker l'ensemble des services nécessaire à l'acquisition et au slow control:

  • Bases de données MongoDB pour les ASICs, les configurations, les informations de runs, de tests et de slow control. Ces bases sont accessibles à distance à travers un tunnel ssh.

  • Les outils de visualisations du slow control Graphyte et Grafana

  • Le broker local MQTT pour le slow control Mosquitto

  • Le serveur apache httpd pour accéder au pages javascript de contrôle de la DAQ et du slow control

On utilise également cette machine pour les services (démons linux) suivant:

  • pico_mon qui se connecte à mosquitto et redirige les messages de statut de MQTT vers la base de donnée et les outils de visualisation (Graphyte/Grafana)

  • Sy1527Pico Interface MQTT vers le crate SY1527

  • WienerPico Interface MQTT vers le crate Wiener

Installation de pmdaq

L'installation par défaut est prévue pour se faire sur une version récente de linux sous Ubuntu (>20.X). L'installation sous une autre version de linux ou de macOs est possible mais n'est pas maintenue.

Pmdaq est basée sur deux librairies:

  • cpprest le framework C++ de Microsoft pour l'échange de message REST (message en JSON vers des services web). Elle est utilisée pour le contrôle et la configuration des processus
  • ZeroMQ une librairie d'échange de messages binaires utilisée pour la collecte des données

D'autres librairies sont également installées mais sont principalement liées au hardware utilisé à Lyon, les principales sont:

  • libftdi pour la lecture des cartes d'acquisition utilsant le bus USB
  • netlink++ pour la lecture de celle utilisant des sockets TCP/IP via une chip Wiznet
  • paho mqtt la librairie d'interface MQTT en C++ et python fournit par Eclipse.

Trois étapes sont nécessaires:

  • Récupérer le script d'installation

Afin de faciliter l'installation des différents software un script pmdaq_installer.sh est fourni et doit être recopié dans /usr/local/bin:

  wget https://mirabitl.web.cern.ch/daq_install/pmdaq_installer.sh
  chmod +x pmdaq_installer.sh
  sudo cp pmdaq_installer.sh /usr/local/bin

Et les commandes dispobibles sont obtenues avec:

mirabito@lyosdhcal15:~$ pmdaq_installer.sh -h
Usage :
    -D                  : Update and install needed debian packages 
    -M                  : Update and install needed brew packages on apple MACOS
    -C                   : Update and compile pmdaq 
    -p                        : Build the distribution packages.
    -h                        : print this message.
BUILDDIR is set 
Build is in /home/mirabito/Build  /home/mirabito/Build
number of processor 4

Comme on peut le voir sur cet exemple une variable d'environnement BUILDIR doit être déclarée pour spécifier à quel endroit la compilation doit s'effectuer:

mkdir -p ${HOME}/build
export BUILDIR=${HOME}/build
  • Installer les paquets nécessaires
  pmdaq_installer.sh -D
  • Compiler et installer le code dans /usr/local/pmdaq
pmdaq_installer.sh -C

Cette commande:

  • Crée le répertoire /opt/pmdaq s'il n'existe pas et télécharge le répertoire git de pmdaq
  • Met à jour le répertoire /opt/pmdaq et lance les compilations nécessaires avec cmake

Et l'on obtient l'installation suivante dans /usr/local/pmdaq

    /usr/local/pmdaq/
    ├── bin
    │   ├── combdaq
    │   ├── daq_webaccess
    │   ├── daq_webaccess.service
    │   ├── daq_webaccess_service_daemon
    │   ├── dbt
    │   ├── mga
    │   ├── mgjob
    │   ├── mgmqtt
    │   ├── mgroc
    │   ├── mgslow
    │   ├── mg_webaccess
    │   ├── mg_webaccess.service
    │   ├── mg_webaccess_service_daemon
    │   ├── pmd
    │   ├── pmdaemon
    │   ├── pmdaq_service_daemon
    │   ├── pnsdaemon
    │   ├── pnse
    │   ├── pns_service_daemon
    │   ├── scannet
    │   └── slowctrl
    ├── etc
    │   ├── Log4cxxConfig.xml
    │   ├── pmdaq.bashrc
    │   ├── pmdaq.conf
    │   ├── pmdaq.service
    │   ├── pns.conf
    │   └── pns.service
    ├── lib
    │   ├── libapp_demo.so
    │   ├── libapp_genesys.so
    │   ├── libapp_syx27.so
    │   ├── libapp_wiener.so
    │   ├── libapp_zup.so
    │   ├── libevb_builder.so
    │   ├── libevb_producer.so
    │   ├── libevb.so
    │   ├── libgrStore.so
    │   ├── liblyon_db.so
    │   ├── liblyon_dif.so
    │   ├── liblyon_febv1.so
    │   ├── liblyon_febv2.so
    │   ├── liblyon_gricv0.so
    │   ├── liblyon_gricv1.so
    │   ├── liblyon_ipdc.so
    │   ├── liblyon_liboard.so
    │   ├── liblyon_mbdaq0.so
    │   ├── liblyon_mbmdcc.so
    │   ├── liblyon_mdcc.so
    │   ├── liblyon_mpi.so
    │   ├── liblyon_pmr.so
    │   ├── liblyon_ptdc.so
    │   ├── liblyon_sdcc.so
    │   ├── liblyon_shm_data_source.so
    │   ├── liblyon_wbmdcc.so
    │   ├── liblyon_wizcc.so
    │   ├── liblyon_wtricv0.so
    │   ├── liblyon_wtricv1.so
    │   ├── libmgStore.so
    │   ├── libmqttStore.so
    │   ├── libpmdaq.so
    │   ├── libpns.so
    │   ├── libproc_binarywriter.so
    │   ├── libproc_dummywriter.so
    │   └── libproc_shmwriter.so
    └── share
        ├── combrc.py
        ├── combrc_threaded.py
        ├── daqrc.py
        ├── mbmdcc.py
        ├── MongoAsic.py
        ├── MongoHR2.py
        ├── MongoJob.py
        ├── MongoLiroc.py
        ├── MongoMqtt.py
        ├── MongoMROC.py
        ├── MongoPR2.py
        ├── MongoRoc.py
        ├── MongoSlow.py
        ├── pmdaqrc.py
        ├── pnsAccess.py
        ├── prettyjson.py
        ├── rcslow.py
        ├── serviceAccess.py
        ├── session.py
        └── xml2mongo.py

Installation et configuration de docker

Installation

Il faut utiliser le script docker-install.sh dans /opt/pmdaq/docker:

#!/bin/bash
sudo apt update
sudo apt upgrade -y

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the repository to Apt sources:
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Il installe le démon dockeret le plugin composequi permet d'utiliser le fichier YAML suivant (/opt/pmdaq/docker/docker-compose.yml)

version: "3.8"
services:
  mongodb:
    image : mongo:6-jammy
    container_name: mongodb
    environment:
      - PUID=1000
      - PGID=1000
      - MONGO_INITDB_ROOT_USERNAME=root
      - MONGO_INITDB_ROOT_PASSWORD=RPC_2008
    volumes:
      - /data/mongo/database:/data/db
    ports:
      - 27017-27019:27017-27019
    restart: unless-stopped
  mosquitto:
    image : eclipse-mosquitto
    container_name: mosquitto
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - /data/docker-mosquitto/mosquitto:/mosquitto
      - /data/docker-mosquitto/mosquitto/data:/mosquitto/data
      - /data/docker-mosquitto/mosquitto/log:/mosquitto/log
    ports:
      - 1883:1883
      - 8883:8883
      - 8080:8080
      - 9001:9001
    restart: unless-stopped
  graphite:
    image : graphiteapp/graphite-statsd
    container_name: graphite
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - /data/graphite/storage:/opt/graphite/storage
    ports:
      - 80:80
      - 2003-2004:2003-2004
      - 2023-2024:2023-2024
      - 8126:8126
      - 8125:8125/udp
    restart: unless-stopped
  grafana:
    image: grafana/grafana:8.4.4
    container_name: grafana-server
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=RPC_2008
      - GF_PLUGINS_ALLOW_LOADING_UNSIGNED_PLUGINS=grafana-mqtt-datasource
    ports:
      - 3000:3000
    volumes:
      - /data/docker-grafana/grafana_plugins:/var/lib/grafana/plugins
      - /data/docker-grafana/grafana_data:/var/lib/grafana
  apache:
    image: httpd:2.4
    container_name: mon_apache
    ports:
      - 7070:80
    volumes:
      - /usr/local/pmdaq/htdocs:/usr/local/apache2/htdocs/
    restart: always

Pour l'utiliser il faut avoir créer dans /data les différents répertoires référencés:

  • /data/docker-mosquitto/mosquitto/{data,log,config}

  • Le répertoire config doit être créé avec le fichier suivant :

    • /data/docker-mosquitto/mosquitto/config/mosquitto.conf
# following two lines required for > v2.0
allow_anonymous true
listener 1883
listener 8080
protocol websockets
connection_messages true
log_timestamp true
persistence true
autosave_interval 600
allow_zero_length_clientid true 
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log

  • /data/graphite/storage

  • /data/docker-grafane/{grafana_plugins,grafana_data}

  • /data/mongo/database

Le démarrage et l'arrêt des containers se fait avec

cd /opt/pmdaq/docker
# Démarage
docker compose up -d
#Liste
docker ps
#Arrêt
docker compose down

Configuration de MongoDB

Installation des outils

mongosh, mongodump et mongorestore
wget https://repo.mongodb.org/apt/ubuntu/dists/noble/mongodb-org/8.0/multiverse/binary-amd64/mongodb-org-server_8.0.9_amd64.deb
sudo apt install -y mongodb-mongosh
wget -qO- https://www.mongodb.org/static/pgp/server-8.0.asc | sudo tee /etc/apt/trusted.gpg.d/server-8.0.asc
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list
sudo apt install -y mongodb-mongosh
sudo apt install mongodb-database-tools

Création des bases de données

Il faut se connecter à mongodb:

mongosh -u root -p --host lyoilcdaq01 --port 27017

Et ensuite pour chaque base créer un utilsateur avec

> use MONROC
> db.createUser({ user:'acqilc', pwd:'Rzzzzz8', roles: [{ role:'readWrite',db:'MONROC'}]})

Pour chacune des bases : LYONROC,FEBROC,PICMIC et SLOW

Sauvegarde et restauration

Sauvegarde
mongodump --forceTableScan --host lyoilcdaq01 --port 27017 --username acqilc --password Rzzzzz8 --db SLOW  --authenticationDatabase SLOW  --out /data/backup/
Restauration
mongorestore --host lyoilcdaq01 --port 27017 -u acqilc --authenticationDatabase PICMIC --db PICMIC picmic/PICMIC

Remarque

1) On peut meme changer le nom de la base avec

   mongodump --db ancienne_base
   mongorestore --nsFrom="ancienne_base.*" --nsTo="nouvelle_base.*" dump/

2) Les bases sont sauvegardées quotidiennement et copiés sur lyoilc07 et lyocmsmu06 par crontab:

25 16 * * * mongodump --forceTableScan --host lyoilcdaq01 --port 27017 --username acqilc --password Rzzzzz8 --db LYONROC  --authenticationDatabase LYONROC  --out /data/backup/
30 16 * * * mongodump --forceTableScan --host lyoilcdaq01 --port 27017 --username acqilc --password Rzzzzz8 --db PICMIC  --authenticationDatabase PICMIC  --out /data/backup/
35 16 * * * mongodump --forceTableScan --host lyoilcdaq01 --port 27017 --username acqcmsmu --password OzzzzzI --db FEBROC  --authenticationDatabase FEBROC  --out /data/backup/
40 16 * * * mongodump --forceTableScan --host lyoilcdaq01 --port 27017 --username acqilc --password Rzzzzz8 --db SLOW  --authenticationDatabase SLOW  --out /data/backup/
50 16 * * * rsync -axv /data/backup/ acqcmsmu@lyocmsmu06:/data/backup
52 16 * * * rsync -axv /data/backup/ acqilc@lyoilc07:/data/backup

Configuration et utilisation des démons Linux

La collecte des informations de slow control pico_mon

Le démon pico_mon est un programme python basé sur une ancienne API graphite et sur une plus récente de paho.mqtt (Eclipse). Pour utiliser ces deux API on doit créer un environnement python virtuel avec:

cd /opt/pmdaq/
deactivate
rm -rf /opt/pmdaq/venv
python3.12 -m venv /opt/pmdaq/venv
source /opt/pmdaq/venv/bin/activate
pip install --upgrade pip
pip install paho-mqtt==2.1
pip install graphyte
pip install pymongo

Le démon peut ensuite être installé avec:

cd /opt/pmdaq/mqtt/pico/services
# Modifier le fichier pico_mon.json avant de le copier
sudo cp pico_mon.json /etc
# Initialisation du service
sudo systemctl disable pico_mon 
sudo service pico_mon stop
sudo cp pico_mon.service /lib/systemd/system/
sudo systemctl enable pico_mon 
sudo service pico_mon stop

Le fichier de configuration /etc/pico_mon.json est le suivant:

{
    "mongo":"axxxxxc/Rzzzzz8@lyoilcdaq01:27017@SLOW",
    "graphyte":"lyoilcdaq01.in2p3.fr",
    "broker":{"host":"lyoilcdaq01.in2p3.fr","port":1883},
    "sessions":["pico_test","pico_dome"]

}

Chaque tag est explicite pour décrire l'accès à la base de donnée (mongo), à la visualisation (graphyte) , au broker MQTT (broker) et au domaines de surveillance (sessions). Une fois modifié , on peut démarrer le service avec:

sudo service pico_mon start
# Surveillance du journal
journalctl -u pico_mon.service -n 100

Le démon de contrôle du crate SY1527 Sy1527Pico

Le contrôle du crate SY1527 implique l'installation du dernier driver CAENHvWrapper.

Celui-ci nécessite une version ancienne de la librairie *Openssl * :

#!/bin/bash

# Pour le dernier CAENHvwrapper CAENHVWrapper-6.6-build20240424.tgz il faut la librairie crypto1.1 qui n'est plus dans Ubuntu24

OPENSSL_VERSION="1.1.1s"
INSTALL_DIR="/usr/local/openssl"
PROFILE_FILE="$HOME/.bashrc"

# Détection shell (zsh support)
if [[ $SHELL == *zsh ]]; then
  PROFILE_FILE="$HOME/.zshrc"
fi


echo "🔧 Téléchargement d'OpenSSL $OPENSSL_VERSION..."
cd /tmp
mkdir ssl
cd /tmp/ssl
wget -c https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz

echo "📦 Extraction..."

tar xf openssl-${OPENSSL_VERSION}.tar.gz
cd openssl-${OPENSSL_VERSION} || exit

echo "⚙️ Configuration..."
./config --prefix="${INSTALL_DIR}"

echo "🔨 Compilation..."
make -j"$(nproc)"

echo "🧪 Test..."
make test

echo "📦 Installation..."
sudo make install

echo "🛠️ Mise à jour de LD_LIBRARY_PATH... (modifier le .bashrc si non desire"
LD_LINE="export LD_LIBRARY_PATH=${INSTALL_DIR}/lib:\$LD_LIBRARY_PATH"

# Ajouter la ligne si elle n'existe pas déjà
if ! grep -Fxq "$LD_LINE" "$PROFILE_FILE"; then
  echo "$LD_LINE" >> "$PROFILE_FILE"
  echo "✅ Ajouté à $PROFILE_FILE"
else
  echo "ℹ️ LD_LIBRARY_PATH déjà présent dans $PROFILE_FILE"
fi

On peut ensuite installer le driver:

### Driver CAEN
cd /tmp/
mkdir caen
cd caen/
cp /opt/pmdaq/extras/CAENHVWrapper-6.6-build20240424.tgz .
tar zxvf CAENHVWrapper-6.6-build20240424.tgz
cd CAENHVWrapper-6.6/
sudo ./install.sh

Une fois le driver installé, on peut installer le service:

cd /opt/pmdaq/mqtt/sy1527
./install_pico

Il faut ensuite modifié le fichier Sy1527Pico.service pour rajouter la ligne Environment et recopier le fichier dans /lib/systemd/system

After = network.target

[Service]
Environment="LD_LIBRARY_PATH=/usr/local/openssl/lib:/lib:/usr/lib:/usr/local/lib"
ExecStart = /usr/local/paho/bin/Sy1527Pico.exe
Restart=always
RestartSec=5

[Install]
WantedBy = multi-user.target

et pour finir:

sudo cp Sy1527Pico.service /lib/systemd/system/

Avant de lancer le service il faut lui fournir le fichier de configuration /etc/pico_settings.json 

{
    "debug":1,
    "id":"pico_demo",
    "subid":"dome_caen",
    "wiznet":{ "use":1,"dhcp":1,"ip":"192.168.12.2","gw":"192.168.12.1"},
    "mqtt":{"server":"134.158.139.152","keepalive":120},
    "sy1527":{"account":"admin/admin@lyoac28","first":110,"last":29,"period":60,"list":[0,1,2,3,4,5,30,31,32,33,34,35]},
    "wiener":{"address":"lyoilchv01.ipnl.in2p3.fr","first":0,"last":15,"period":60},
    "rp2040":{"use":0,"period":30},
    "bme":{"use":0,"i2c":0,"sda":4,"scl":5,"period":10},
    "hih":{"use":0,"i2c":1,"sda":26,"scl":27,"period":30},
    "genesys":{"use":0,"uart":0,"tx":0,"rx":1,"baud":9600,"address":1,"period":30},
    "zup":{"use":0,"uart":0,"tx":0,"rx":1,"baud":9600,"address":1,"period":30},
    "cpwplus":{"use":0,"uart":0,"tx":0,"rx":1,"baud":9600,"period":30},
    "brooks":{"use":0,"uart":0,"tx":0,"rx":1,"baud":19200,"rst":2,"devices":[0],"period":30}

}

Les 2 tags importants sont l'adresse du broker mqtt et celle du crate sy1527

On peut ensuite démarrer le service:

sudo service Sy1527Pico start

Le démon de contrôle du crate WienerWienerPico

L'accès au crate Wiener se fait par des messages snmp . Malheureusement la version disponible sous Ubuntu ne permet pas d'avoir la précision optimale sur les valeurs de courant des canaux HV. On doit donc compiler une version récente de SNMP et installer le service avec:

# On installe une version recente de snmp dans /usr/local
cd /tmp
sudo apt install libperl-dev
tar zxvf /opt/pmdaq/extras/net-snmp-5.9.4.tar.gz
cd net-snmp-5.9.4/
./configure
make
sudo make install
cd /opt/pmdaq/mqtt/wiener
sudo cp WIENER-CRATE-MIB.txt /usr/local/share/snmp/mibs

. install_pico

On doit également modifier le service pour déclarer le LD_LIBRARY_PATH:

[Unit]
Description = Starting WienerPico  service
After = network.target

[Service]
Environment="LD_LIBRARY_PATH=/usr/local/lib:/lib:/usr/lib:/usr/local/lib"
ExecStart = /usr/local/paho/bin/WienerPico.exe
Restart=always
RestartSec=5

[Install]
WantedBy = multi-user.target

et encore une fois vérifier que le fichier /etc/pico_settings.json contient un tag wiener correct. On peut ensuite démarrer le service:

sudo service WienerPico start

Code d'analyse

Le code d'analyse rocanalysis est installé dans le répertoire /home/acqilc/rocanalysis. Il est installable avec la commande:

git clone http://gitlab.in2p3.fr:l-mirabito/rocanalysis.git

rocanalysis permet la lecture des fichiers contenant les données brutes lues par les différents ASIcs et boards à Lyon:

  • HardRoc: PMR et GRICV0/1

  • PETIROC: FEBV1, FEBV2

  • LIROC: Liroc test board

La documentation du package est en cours de rédaction, mais un point important est que le code est utilisable sur les fermes SLURM en utilisant apptainer

Important

La même approche peut être utilisé pour tous les codes de simulation ou d'analyse:

  • Création d'une image SIF contenant toutes les librairies nécessaires

  • Recompilation et création d'une image contenant le code désiré d'analyse

  • Copie de cette image sur la ferme SLURM où sont accessibles les données et soumission de jobs utilisant cette image

Installation de apptainer

sudo apt install -y software-properties-common
sudo apt autoremove
sudo add-apt-repository -y ppa:a
sudo apt update
sudo apt install apptainer

Compilation des images utilisables par slurm

cd ${HOME}/rocanalysis/sif
#Ubuntu 222
apptainer build preinstall.sif b_preinstall.def
# Pmdaq
sudo apptainer build pmdaq.sif b_pmdaq.def
# rocanalysis
sudo apptainer build rocanalsyis.sif  localsoft.def
# Update of rocanalysis
sudo apptainer build current_analysis.sif  current.def

En cas de modification du code, seule la dernière compilation est nécessaire. On peut ensuite utiliser l'image current_analysis.sif sur la ferme slurm de l'IP2I:

# Copie de l'image sur le disque de groupe
scp current_analysis.sif /gridgroup/cms/mirabito

Il faut ensuite se connecter à lyoui via lyoserv

Utilisation des images sif sur la ferme

Le plus simple est de donner un exemple d'analyse de données. Le programme principal de rocanalysis , btr , doit analyser un fichier JSON lui indiquant la localisation des donnée, le numéro de run et la localisation des fichiers de géométrie (cablage, position des chambres). A partir d'un fichier etc/templategric.json:

{
"plugins":[
        "proc_hr2Reco","proc_gricReco"
    ],
    "reco":{
        "hr2":{"histos":3,"nplans":4,"gric":3},
        "gric":{"tricot":1,"streamers":1,"n2d":4,"dist":5.0,"histos":1,"tracks":1,"display":0,
                "track_algo":{
                    "minpoint":4,
                    "dcut":5.75,
                    "pcut":0.03,
                    "first":1,
                    "last":7
                }
               }
    },
    "runs":
    [
        [RUNNUMBER,"/DATA/","SMM*_*"]

    ],
    "process":
    {
        "directory":"/RESULTS/histos/",
         ...

           "edges":1
    },

    "setup_desc": {
        "file":"/usr/local/rocanalysis/etc/PULSALYS2021_3.json"
    }
}

On peut créer des scripts pour chaque run avec le fichier results/batch_gric.sh:

#!/bin/bash

source /usr/local/pmdaq/etc/pmdaq.bashrc 
source /usr/local/rocanalysis/etc/rocanalysis.bashrc 
export ROOTSYS=/opt/root
export LD_LIBRARY_PATH=${ROOTSYS}/lib:$LD_LIBRARY_PATH
export PATH=${ROOTSYS}/bin:$PATH
cat /RESULTS/etc/templategric.json | sed -e 's,RUNNUMBER,'$1',g'  > /RESULTS/tmp/run$1.json ;
time btr /RESULTS/tmp/run$1.json &> /RESULTS/tmp/run$1.log

exit

Evidemment les répertoires /DATA et /RESULTS n'existe pas sur lyoserv ou lyoui mais peuvent être montés dans le container démarré par apptainer

Dans le script suivant hvscan.sh on crée un job par run ou le script results/batch_gric.sh est appelé dans un container. Les jobs sont ensuite distribués aux différents workers:

#!/bin/bash
#
#SBATCH --ntasks=200
#SBATCH --spread-job

for i in  {1784..1788}
do
cat > jobtmp.sh <<EOF
#!/bin/bash                                                                     
echo
echo
echo -n "Hostname:              " ; hostname -f
echo -n "Uptime:                " ; uptime
echo
echo -n "Je suis:               "; id -a
echo



apptainer exec --bind /gridgroup/cms/mirabito/results/:/RESULTS,/gridgroup/cms/mirabito/gric2024:/DATA /gridgroup/cms/mirabito/current_analysis.sif /RESULTS/batch_gric.sh RUNNB

EOF
cat jobtmp.sh | sed -e 's,JNAME,job'$i',g' | sed -e 's,RUNNB,'$i',g' >  /gridgroup/cms/mirabito/results/sub_$i.sh
chmod +x    /gridgroup/cms/mirabito/results/sub_$i.sh
srun -n 1  /gridgroup/cms/mirabito/results/sub_$i.sh &
done

wait


echo "End of the job"

Il suffit ensuite de se connecter a lyoui et de soumettre le job:

sbatch hvscan.sh
# view status
squeue -u mirabito