JAcousticsMonitor.sh

Go to the documentation of this file.

#!/bin/zsh
script=${0##*/}
 
if [ -z $JPP_DIR ]; then
    echo "Variable JPP_DIR undefined."
    exit
fi
 
source $JPP_DIR/setenv.sh $JPP_DIR >& /dev/null
 
zmodload zsh/mathfunc
 
set_variable:  DEBUG       ACOUSTICS_DEBUG        2
set_variable:  WORKDIR     ACOUSTICS_WORKDIR      ./
set_variable:  FORMAT      GRAPHICS_FORMAT        gif
set_variable+  BATCH       GRAPHICS_BATCH         -B
 
if do_usage $*; then
    usage "$script <detector file> (input file)+"\
          "\nInput files correspond to the output of JAcousticsEventBuilder[.sh]."
fi
 
if (( $# >= 2 )); then
    set_variable  DETECTOR        $argv[1]
    set_array     INPUT_FILES     $argv[2,-1]
else
    fatal "Wrong number of arguments."
fi
 
source JAcousticsToolkit.sh
 
$JPP_DIR/examples/JAcoustics/JAcousticsMonitor \
    -a $DETECTOR                                       \
    -f${^INPUT_FILES}                                  \
    -o $WORKDIR/monitor.root                           \
    -T $WORKDIR/tripod.txt                             \
    -Y $WORKDIR/transmitter.txt                        \
    -d $DEBUG --!       
 
JPlot1D \
    -f $WORKDIR/monitor.root:H\.\*size                 \
    -Y                                                 \
    -> "size"                                         \
    -\^ "number of events"                             \
    -L TL                                              \
    -T ""                                              \
    -o $WORKDIR/size.$FORMAT                           $BATCH
 
JPlot1D \
    -f $WORKDIR/monitor.root:H\.\*quality              \
    -XX                                                \
    -Y                                                 \
    -> "quality"                                      \
    -\^ "number of hits"                               \
    -L TL                                              \
    -T ""                                              \
    -o $WORKDIR/quality.$FORMAT                        $BATCH
 
JPlot1D \
    -f $WORKDIR/monitor.root:H\.\*rms                  \
    -Y                                                 \
    -> "RMS [s]"                                      \
    -\^ "number of events"                             \
    -N "X 505"                                         \
    -L TR                                              \
    -T ""                                              \
    -o $WORKDIR/rms.$FORMAT                            $BATCH
 
JPlot1D \
    -f $WORKDIR/monitor.root:H\.\*quantile             \
    -Y                                                 \
    -> "quantile [s]"                                 \
    -\^ "number of events"                             \
    -N "X 505"                                         \
    -L TR                                              \
    -T ""                                              \
    -o $WORKDIR/quantile.$FORMAT                       $BATCH
 
JPlot1D \
    -f $WORKDIR/monitor.root:H\.\*overlays             \
    -Y                                                 \
    -> "overlays"                                     \
    -\^ "number of events"                             \
    -L TR                                              \
    -T ""                                              \
    -o $WORKDIR/overlays.$FORMAT                       $BATCH
 
JPlot1D \
    -f $WORKDIR/monitor.root:H\.\*time                 \
    -XX                                                \
    -Y                                                 \
    -> "#Deltat [s]"                                  \
    -\^ "number of events"                             \
    -L TR                                              \
    -T ""                                              \
    -o $WORKDIR/time.$FORMAT                           $BATCH
 
JPlot1D \
    -f $WORKDIR/monitor.root:H\.\*multiplicity         \
    -Y                                                 \
    -> "multiplicity"                                 \
    -\^ "number of hits"                               \
    -L TR                                              \
    -T ""                                              \
    -o $WORKDIR/multiplicity.$FORMAT                   $BATCH
 
typeset -A EMITTERS
 
get_tripods+       $WORKDIR/tripod.txt       EMITTERS
get_transmitters+  $WORKDIR/transmitter.txt  EMITTERS
 
for EMITTER in ${(@k)EMITTERS}; do
 
    for KEY in event doubles "log10(Q)"; do
 
        JPlot2D \
            -f  "$WORKDIR/monitor.root:H\[${EMITTER}\].$KEY"        \
            -> "string"                                            \
            -< "floor"                                             \
            -O COLZ                                                 \
            -T "[${EMITTER}].$KEY"                                  \
            -o $WORKDIR/$KEY\[${EMITTER}\].$FORMAT                  $BATCH
    done
 
    JPlot2D \
        -f  "$WORKDIR/monitor.root:H\[${EMITTER}\].QR"          \
        -XX                                                     \
        -YY                                                     \
        -Z                                                      \
        -> "distance"                                          \
        -< "quality"                                           \
        -O COLZ                                                 \
        -T "[${EMITTER}]"                                       \
        -o $WORKDIR/QR\[${EMITTER}\].$FORMAT                    $BATCH
done
 
typeset -i NX
typeset -i NY
 
let "NY = sqrt(${#EMITTERS})"
let "NX = (${#EMITTERS} + $NY - 1)/ $NY"
 
for KEY in event doubles QR "log10(Q"; do
 
    montage \
        -tile ${NX}x${NY}                                   \
        -geometry +0+0                                      \
        $WORKDIR/${KEY}\[*\].$FORMAT                        \
        $WORKDIR/${KEY}.$FORMAT                             >& /dev/null
done
 
JPlot2D \
    -f  "$WORKDIR/monitor.root:H\[%\].QR"                   \
    -XX                                                     \
    -YY                                                     \
    -Z                                                      \
    -> "distance [m]"                                      \
    -< "quality"                                           \
    -O COLZ                                                 \
    -T ""                                                   \
    -o $WORKDIR/QR.2D.$FORMAT                               $BATCH
 
JProfile2D \
    -f  "$WORKDIR/monitor.root:H\[%\].QR"                   \
    -o $WORKDIR/profile.root                                \
    -P X                                                    \
    -O s
 
JFit \
    -f $WORKDIR/profile.root:\.\*                           \
    -o $WORKDIR/fit.root                                    \
    -F "[0] + [1]*x"                                        \
    -@ "p0 = +6.0"                                          \
    -@ "p1 = -1.0"                                          \
    -d 3
    
JPlot1D \
    -f $WORKDIR/fit.root:\.\*                               \
   -XX                                                     \
    -y "3 7"                                                \
    -> "distance [m]"                                      \
    -\^ "log(quality)"                                      \
    -T ""                                                   \
    -o $WORKDIR/QR.1D.$FORMAT                               $BATCH