plot-canberra.sh

Go to the documentation of this file.

#!/bin/zsh
script=${0##*/}

zmodload zsh/mathfunc

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

source $JPP_DIR/setenv.sh $JPP_DIR >& /dev/null

set_variable:  DEBUG              ACOUSTICS_DEBUG        2
set_variable:  WORKDIR            ACOUSTICS_WORKDIR      ./
set_variable   FORMULA            "[0] * exp(-0.5 * (x-[1])*(x-[1]) / ([2]*[2]))"  
set_variable   NUMBER_OF_ENTRIES  100                    
set_variable   TMIN_MS            -1.0                   
set_variable   TMAX_MS            +1.0                   
set_variable   RANGE              0-18
set_variable:  FORMAT             GRAPHICS_FORMAT        gif
set_variable+  BATCH              GRAPHICS_BATCH         -B

if do_usage $*; then
    usage "$script <detector file> <input file> [<lower floor>-<upper floor>]"\
          "\nInput file corresponds to the output of JKatoomba[.sh]."
fi

case $# in
    3) set_variable  RANGE          $argv[3];&
    2) set_variable  DETECTOR       $argv[1];
       set_variable  INPUT_FILE     $argv[2];;
    *) fatal "Wrong number of arguments."
esac

eval `JPrintDetector -a $DETECTOR -O IDENTIFIER`
eval `JPrintDetector -a $DETECTOR -O SUMMARY`

set_variable  FIRST_FLOOR    ${RANGE%%-*}
set_variable  LAST_FLOOR     ${RANGE##*-}

source JAcoustics.sh   $DETECTOR_ID

CHECK_EXIT_CODE

typeset -Z 4 STRING
typeset -Z 2 FLOOR

typeset -A TRIPODS

get_tripods $WORKDIR/tripod.txt TRIPODS

for EMITTER in ${(@k)TRIPODS}; do

    JCanberra \
        -a $DETECTOR                                 \
        -f $INPUT_FILE                               \
        -o "$WORKDIR/canberra[${EMITTER}].root"      \
        -T $WORKDIR/tripod.txt                       \
        -V $WORKDIR/sound_velocity.txt               \
        -M $WORKDIR/mechanics.txt                    \
        -H $WORKDIR/hydrophone.txt                   \
        -E $EMITTER                                  \
        -d $DEBUG --!
done

kill_child_processes_at_exit

attach getModule -a $DETECTOR

for STRING in $STRINGS[*]; do

    echo -n "Creating graphics for string $STRING.."

    HISTOGRAMS=()

    for EMITTER in ${(@k)TRIPODS}; do

        set_variable  STRING_TXT          $WORKDIR/string_${STRING}\[${EMITTER}\].txt
        set_variable  STRING_ROOT         $WORKDIR/string_${STRING}\[${EMITTER}\].root

        rm -f $STRING_TXT

        for (( FLOOR = $FIRST_FLOOR; $FLOOR <= $LAST_FLOOR; FLOOR += 1 )); do

            sput $STRING $FLOOR
            sget  MODULE

            set_variable  N  `JPrintResult -f $WORKDIR/canberra\[$EMITTER\].root:${MODULE} -F GetEntries`

            if [[ -n "$N" ]] && (( $N >= $NUMBER_OF_ENTRIES )); then

                set_array  Q  `JPrintQuantiles -f $WORKDIR/canberra\[$EMITTER\].root:${MODULE} -Q "0.33 0.50 0.66"`

                let XMIN="$Q[2] - 5.0*($Q[3] - $Q[1])"
                let XMAX="$Q[2] + 5.0*($Q[3] - $Q[1])"

                JFit \
                    -f $WORKDIR/canberra\[$EMITTER\].root:${MODULE}     \
                    -F "$FORMULA"                                       \
                    -@ "p0 = GetMaximum"                                \
                    -@ "p1 = $Q[2]"                                     \
                    -@ "p2 = 0.5*($Q[3] - $Q[1])"                       \
                    -x "$XMIN $XMAX"                                    \
                    -O L                                                \
                    -o $WORKDIR/fit.root                                \
                    -d $DEBUG

                if ( `JPrintFit -f $WORKDIR/fit.root:\.\* -@p0 >& /dev/null` ); then

                    set_array P1 `JPrintFit -f $WORKDIR/fit.root:\.\* -@p1`
                    set_array P2 `JPrintFit -f $WORKDIR/fit.root:\.\* -@p2`

                    ((P1[1] =     $P1[1]  * 1.0e3))     # [ms]
                    ((P2[1] = abs($P2[1]) * 1.0e3))     # [ms]

                    printf "%2d %9.6f %9.6f\n" $FLOOR $P1[1] $P2[1] >> $STRING_TXT
                fi

                rm -f $WORKDIR/fit.root
            fi
        done

        JGraph \
            -f $STRING_TXT                            \
            -o $STRING_ROOT

        HISTOGRAMS+=(${STRING_ROOT})
    done

    JPlot1D \
        -f${^HISTOGRAMS}":.*"                          \
        -w 800x400                                     \
        -x "-0.5 18.5"                                 \
        -y "$TMIN_MS $TMAX_MS"                         \
        -\> "floor"                                    \
        -\^ "#Deltat [ms]"                             \
        -N "X 505"                                     \
        -T "[$STRING]"                                 \
        -L TR                                          \
        -o $WORKDIR/string_${STRING}.$FORMAT           $BATCH

    echo " -> $WORKDIR/string_${STRING}.$FORMAT"

done

detach

# summary plots

HISTOGRAMS=()

for EMITTER in ${(@k)TRIPODS}; do
    HISTOGRAMS+=("$WORKDIR/canberra[${EMITTER}].root")
done

JOpera1D \
    -f${^HISTOGRAMS}":.*toa"                       \
    -u Add                                         \
    -o $WORKDIR/sum.root                           >& /dev/null

set_array  Q  `JPrintQuantiles -f $WORKDIR/sum.root:\.\* -Q "0.33 0.50 0.66"`

JFit \
    -f $WORKDIR/sum.root:\.\*                      \
    -F "$FORMULA"                                  \
    -@ "p0 = GetMaximum"                           \
    -@ "p1 = $Q[2]"                                \
    -@ "p2 = 0.5*($Q[3] - $Q[1])"                  \
    -o $WORKDIR/fit.root                           \
    -d $DEBUG

let XMIN="$TMIN_MS * 1.0e-3"
let XMAX="$TMAX_MS * 1.0e-3"

JPlot1D \
    -f $WORKDIR/fit.root:\.\*                      \
    -\> "#Deltat [s]"                              \
    -x "$XMIN $XMAX"                               \
    -N "X 505"                                     \
    -T ""                                          \
    -s 0                                           \
    -o $WORKDIR/canberra.$FORMAT                   $BATCH

rm -f $WORKDIR/p1.{txt,root}
rm -f $WORKDIR/p2.{txt,root}

for STRING in $STRINGS[*]; do
    for EMITTER in ${(@k)TRIPODS}; do

        set_variable  STRING_TXT          

        awk '{ print $2 }' $WORKDIR/string_${STRING}\[${EMITTER}\].txt >> $WORKDIR/p1.txt
        awk '{ print $3 }' $WORKDIR/string_${STRING}\[${EMITTER}\].txt >> $WORKDIR/p2.txt

    done
done

$JPP_DIR/examples/JGizmo/JHistogram1D \
    -x "200 $TMIN_MS $TMAX_MS"                     \
    -f $WORKDIR/p1.txt                             \
    -o $WORKDIR/p1.root

$JPP_DIR/examples/JGizmo/JHistogram1D \
    -x "200 0.0 0.2"                               \
    -f $WORKDIR/p2.txt                             \
    -o $WORKDIR/p2.root

typeset -A X_LABEL

X_LABEL[p1]="#Deltat [ms]"
X_LABEL[p2]="#sigma [ms]"

for P in p1 p2; do

    JPlot1D \
        -f $WORKDIR/${P}.root:\.\*                     \
        -\> "$X_LABEL[${P}]"                           \
        -\^ "number of modules"                        \
        -N "X 505"                                     \
        -T ""                                          \
        -s 1110                                        \
        -o $WORKDIR/${P}.$FORMAT                       $BATCH
done

rm -f $WORKDIR/p1.{txt,root}
rm -f $WORKDIR/p2.{txt,root}
rm -f $WORKDIR/fit.root