JAcceptanceTest.sh

Go to the documentation of this file.

#!/bin/zsh

version=1.0
script=${0##*/}


if [ -z $JPP_DIR ]; then
    echo "Variable JPP_DIR undefined."
    exit
fi

source $JPP_DIR/setenv.sh $JPP_DIR

set_variable   DEFAULT_VALUE   \"NULL\"
set_variable:  FORMAT          GRAPHICS_FORMAT        gif
set_variable+  BATCH           GRAPHICS_BATCH         -B

if do_usage $*; then
    usage "$script <daq file> <detector file> <output directory>"
fi

if (( $# != 3)); then
    fatal "Wrong number of arguments."
fi

set_variable    OUTPUT_DIR          $argv[3]
set_variable    DETECTOR_FILE       $argv[2]
set_variable    DAQ_FILE            $argv[1]

set_variable    OUTPUT_JC_TOT       ${OUTPUT_DIR}/$(basename $DAQ_FILE .root)_JC_TOT.root
set_variable    OUTPUT_JMERGE_TOT   ${OUTPUT_DIR}/$(basename $DAQ_FILE .root)_JMerge_TOT.root
set_variable    OUTPUT_JFIT_TOT     ${OUTPUT_DIR}/$(basename $DAQ_FILE .root)_JFit_TOT.root
set_variable    PMT_PARAMETERS_FILE ${OUTPUT_DIR}/$(basename $DAQ_FILE .root)_TOT.txt
set_variable    OUTPUT_JDA          ${OUTPUT_DIR}/$(basename $DAQ_FILE .root)_JDA.root


set_variable    SELECTOR            JDAQTimesliceL0

JCalibrateToT \
    -a ${DETECTOR_FILE}       \
    -C ${SELECTOR}            \
    -O filter                 \
    -f ${DAQ_FILE}            \
    -o ${OUTPUT_JC_TOT}       \
    --!

JMergeCalibrateToT \
    -f ${OUTPUT_JC_TOT}       \
    -o ${OUTPUT_JMERGE_TOT}   \
    --!

JFitToT \
    -P ${PMT_PARAMETERS_FILE} \
    -a ${DETECTOR_FILE}       \
    -f ${OUTPUT_JMERGE_TOT}   \
    -o ${OUTPUT_JFIT_TOT}     \
    -x "0.0 -1.0"             \
    -w                        \
    --!

JDomAnalyser \
          -f ${DAQ_FILE}     \
          -o ${OUTPUT_JDA}   \
          -C ${SELECTOR}     \
          --!

#---- loop over DOMs and for each print the gains (for copying into DIA interface)

eval `JPrintDetector -a $DETECTOR_FILE -O SUMMARY`

kill_child_processes_at_exit

set_variable    NUMBER_OF_PMTS      31

attach getModule -a $DETECTOR_FILE

for STRING in $STRINGS[*]; do
    for (( FLOOR = $FIRST_FLOOR; $FLOOR <= $LAST_FLOOR; FLOOR += 1 )); do

        GAINS=()
        RATES=()

        sput $STRING $FLOOR
        sget MODULE

        for (( PMT = 0; $PMT < $NUMBER_OF_PMTS; PMT += 1 )); do

            set_array    PMTparameters    $(JPrintPMTParameters -P ${PMT_PARAMETERS_FILE} -p "$MODULE.$PMT" -k "gain")
            set_variable gain             ${PMTparameters[2]}
            
            set_variable rate             $(JPrintResult -f ${OUTPUT_JDA}:rate_${MODULE}.${PMT}$ -F "GetMean")

            if [[ -z $rate ]]; then
                rate=$DEFAULT_VALUE
            fi
            if [[ -z $gain ]]; then
                gain=$DEFAULT_VALUE
            fi
                
            GAINS+=($gain)
            RATES+=($rate)

            JPlot1D \
                -f ${OUTPUT_JFIT_TOT}:${MODULE}\.${(l(2)(0))PMT}\.1ToT  \
                -> "ToT [ns]"                                          \
                -T "${MODULE}:${(l(2)(0))PMT}"                          \
                -o ${OUTPUT_DIR}/gain_${(l(2)(0))PMT}.$FORMAT           $BATCH

            JPlot1D \
                -f ${OUTPUT_JDA}:rate_${MODULE}.${PMT}$                 \
                -X                                                      \
                -> "Rate [kHz]"                                        \
                -T "${MODULE}:${(l(2)(0))PMT}"                          \
                -o ${OUTPUT_DIR}/rate_${(l(2)(0))PMT}.$FORMAT           $BATCH

            JPlot1D \
                -f ${OUTPUT_JDA}:time_${MODULE}.${PMT}$                 \
                -> "Frame Index"                                       \
                -\^ "Rate [kHz]"                                        \
                -O "hist"                                               \
                -T "${MODULE}:${(l(2)(0))PMT}"                          \
                -o ${OUTPUT_DIR}/time_${(l(2)(0))PMT}.$FORMAT           $BATCH

        done
        
        JSON="{\n\"module\":$MODULE,\n"

        JSON+="\"gains\":["
        JSON+=$(IFS=, ; echo "${GAINS[*]}")
        JSON+="],\n"

        JSON+="\"rates\":["
        JSON+=$(IFS=, ; echo "${RATES[*]}")
        JSON+="]\n}"

        echo -e ${JSON}
        
        montage \
            -tile 6x6                             \
            -geometry +0+0                        \
            ${OUTPUT_DIR}/gain*.$FORMAT           \
            ${OUTPUT_DIR}/${MODULE}_gain.$FORMAT  >& /dev/null

        montage \
            -tile 6x6                             \
            -geometry +0+0                        \
            ${OUTPUT_DIR}/rate*.$FORMAT           \
            ${OUTPUT_DIR}/${MODULE}_rate.$FORMAT  >& /dev/null
        
        montage \
            -tile 6x6                             \
            -geometry +0+0                        \
            ${OUTPUT_DIR}/time*.$FORMAT           \
            ${OUTPUT_DIR}/${MODULE}_time.$FORMAT  >& /dev/null
    done
done

rm -f ${OUTPUT_DIR}/gain*.$FORMAT
rm -f ${OUTPUT_DIR}/rate*.$FORMAT
rm -f ${OUTPUT_DIR}/time*.$FORMAT

detach