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:  FORMAT             GRAPHICS_FORMAT        gif
set_variable+  BATCH              GRAPHICS_BATCH         -B

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

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

set_variable  DETECTOR            $argv[1]
set_variable  INPUT_FILE          $argv[2]

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

source JAcoustics.sh   $DETECTOR_ID

CHECK_EXIT_CODE


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                    \
       -E $EMITTER                                  \
       -d $DEBUG --!
done


HISTOGRAMS=(`ls $WORKDIR/canberra\[*\].root`)

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

set_variable  X    `JPrintResult -f $WORKDIR/sum.root:\.\* -F GetMean`
set_variable  RMS  `JPrintResult -f $WORKDIR/sum.root:\.\* -F GetRMS`

let XMIN="$X - 3.0*$RMS"
let XMAX="$X + 3.0*$RMS"

JFit \
    -f $WORKDIR/sum.root:\.\*                      \
    -F "$FORMULA"                                  \
    -@ "p0 = GetMaximum"                           \
    -@ "p1 = $X"                                   \
    -@ "p2 = 0.5*$RMS"                             \
    -x "$XMIN $XMAX"                               \
    -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/sum.root
rm -f $WORKDIR/fit.root

kill_child_processes_at_exit

attach getModule -a $DETECTOR

typeset -Z 4 STRING
typeset -Z 2 FLOOR

set_variable  FIRST_FLOOR  1

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_variable  X    `JPrintResult -f $WORKDIR/canberra\[$EMITTER\].root:${MODULE} -F GetMean`
                set_variable  RMS  `JPrintResult -f $WORKDIR/canberra\[$EMITTER\].root:${MODULE} -F GetRMS`

                let XMIN="$X - 3.0*$RMS"
                let XMAX="$X + 3.0*$RMS"

                JFit \
                    -f $WORKDIR/canberra\[$EMITTER\].root:${MODULE}     \
                    -F "$FORMULA"                                       \
                    -@ "p0 = GetMaximum"                                \
                    -@ "p1 = $X"                                        \
                    -@ "p2 = $RMS"                                      \
                    -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