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