Requirements

The following machines have been tested for operation.

CRIB’s analysis machine

• Ubuntu 22.04.4 LTS
• gcc 11.4.0
• cmake 3.22.1
• ROOT 6.30/04
• yaml-cpp 0.7
• artemis commit ID a976bb9
• [new] TSrim python-develop branch

Example of installation of required dependencies

• for Ubuntu

sudo apt-get install binutils cmake dpkg-dev g++ gcc \
libssl-dev git libx11-dev \
libxext-dev libxft-dev libxpm-dev python3 libtbb-dev \
libvdt-dev libgif-dev \
gfortran libpcre3-dev \
libglu1-mesa-dev libglew-dev libftgl-dev \
libfftw3-dev libcfitsio-dev libgraphviz-dev \
libavahi-compat-libdnssd-dev libldap2-dev \
python3-dev python3-numpy libxml2-dev libkrb5-dev \
libgsl-dev qtwebengine5-dev nlohmann-json3-dev libmysqlclient-dev \
libyaml-cpp-dev

NOTE:

• From 2023/10, Ubuntu system is also avaliable. (issue48)
• We have confirmed that it works on RedHat-based Linux (Alma linux, Rocky linux etc.).

ROOT

Artemis uses ROOT library. For detailded information, please refer Installing ROOT

This is one example to install the ROOT from the source.

# You may update your local copy by issuing a `git pull` command from within `root_src/`.
cd install_dir
git clone https://github.com/root-project/root.git root_src
# check out the tag to specify the ROOT version
cd root_src
git checkout -b v6-30-04 refs/tags/v6-30-04
cd ..

mkdir root_build root_install && cd root_build
cmake -DCMAKE_INSTALL_PREFIX=../root_install -Dmathmore=ON ../root_src # && check cmake configuration output for warnings or errors
make -j4
make install
source ../root_install/bin/thisroot.sh # or thisroot.{fish,csh}

If there are any problems at the compile, additional packages may need to be installed. See also dependencies.

I recommend to write source thisroot.sh part in the .bashrc/.zshrc to load this library.

artemis

From the current situation, CRIB experiment doesn’t use GET system, so we describe how to install it without linking it to GET decoder.

Also, it can link to openMPI, but the below commands assume not using openMPI. See artemis repo for more information.

cd hoge
git clone https://github.com/artemis-dev/artemis.git -b develop
cd artemis
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=../install ..
make -j4
make install
source ../install/bin/thisartemis.sh

Then, <CMAKE_INSTALL_PREFIX>/bin/thisartemis.sh will be created and this shell script can configure the environment (ROOT, yaml-cpp, artemis libraries) to use artemis.

Also, I recommend to write source thisartemis.sh part in the .bashrc/.zshrc to load this library.

Another option is to use module command to manage the environment. It is also written in artemis repo.

Note

For the CRIB experiment setting, we modified some parts of artemis source.

Please check the CRIB configuration.

mount setting

For the convinience, we use one directory to store raw data (ridf files) and make symbolic link to each user work directory. So first, we need to make raw data directory.

There are three option to do so.

1. use the default SSD/HDD of analysis PC
2. use the external SSD/HDD of analysis PC (need to mount it)
3. use network file system (NFS) and mount it

1 and 2 options are mainly used for offline analysis, while 3 option is used for online analysis.

1. use the default SSD/HDD of analysis PC

If you have large size of main storage, the one option is easiest way. Just like:

cd ~
mkdir data (or where you want to put)
cd data
rsync hoge (cp or scp to put the raw data)

The symbolic link process will be done in the next process.

2. use the external SSD/HDD of analysis PC (need to mount it)

When your main storage is not so large, you may think to use external storage. For example, main storage is used for OS installation and external storage is used for experimental data. (I think this case is for personal analysis using your own PC.)

In that case, you need to do:

1. mount the external storage
2. check and set the file permission to be able to read or write it.

The format and mount process is very depend on the situation, so please check the way in other place. One important point is that we have output root file when we start to analysis, so it may need to make the directory for outputed root files in the external storage.

3. use network file system (NFS) and mount it

For online analysis, the best option is to get the data via a file server, as there is no time to transfer the raw data files each time.

This is example of CRIB system.

---
title: Network system of CRIB
---
graph LR;
    A(MPV E7) --> D{<strong>DAQ main PC</strong><br></br>file server}
    B(MPV1 J1) --> D
    C(MPV2 J1) --> D
    D --> E[Analysis PC]

If you mount some storage, please not the mount point because we need the information of mount point when we configure the new experiment environment.

energyloss calculator

Some CRIB-specific files use energy loss libraries.

SRIMlib installation

git clone https://github.com/okawak/SRIMlib.git
cd SRIMlib
mkdir build
cd build
cmake ..
make
make install

Before using this library, you need to make database file (just .root file)

cd ..
source thisSRIMlib.sh
update

If you want to make energy loss figures, “f” option will work.

update -f

Also, I recommend to write source thisSRIMlib.sh part in the .bashrc/.zshrc to load this library.

art_analysis

With this command, all initial settings of “art_analysis” are made.

curl --proto '=https' --tlsv1.2 -sSf https://okawak.github.io/artemis_crib/bin/init.sh | sh

After that, please add the following lines to the .bashrc/.zshrc.

# this is option
source /path/to/thisroot.sh &> /dev/null
source /path/to/thisartemis.sh &> /dev/null
source /path/to/thisSRIMlib.sh &> /dev/null

# need from this line!
export EXP_NAME="expname" # your experiment
export EXP_NAME_OLD="expname" # this is option
export PATH="${HOME}/art_analysis/bin:${PATH}"
source ${HOME}/art_analysis/bin/art_setting -q

The setting is all!

Then, the following commands (shellscript) will be downloaded.

artlogin.sh

This is loaded when you command artlogin. This command is described in the next chapter.

artnew

With this command, new artemis environment will be created interactively.

art_setting

This is like a library. The shellscript function artlogin, a etc. are written.

art_check

Checking these shellscript is updatable or not.