#!/usr/local/bin/bash -posix
#
#
# ASCA processing script.
# Written by Ron Watkins, 17Apr94.
#
# Modified and maintained by Don Jennings as of 03/01/95
#
# Change History:
#
# 5.5.0--> 5.5.1 Oct 11, 1995
#---------------
# o Numerous comments added by Ed Pier
#
# 5.4.3--> 5.5.0 Sept 10, 1995
#---------------
# o script now designed to run under version 2.0 (and higher) of the
# stream deamon script
# o took call to post-processing out of script; post processing runs
# as independent deamon from now on
# o took all trend copy code segments out of script; this is done by
# the post-processing deamon from now on
# o the shexit() now creates the error log file and copies the error log
# and job logs to the trend monitor area just before exiting.
# o now the processing configuration file must be specified with an
# absolute path (second command line argument)
# o the JOBLOGDIR, EXEDIR and AUTO variables are now specified in the
# processing configuration file
#
# 5.4.2--> 5.4.3 Aug 30, 1995
#---------------
# o fixed bug in attitude log trend copyout where the $att variable
# was misnamed $add. This has kept attitude trend logs from being
# properly copied since pv5.4.0.bash.
#
# 5.4.1--> 5.4.2 Aug 17, 1995
#---------------
# o fixed bug in report() function so that the correct time and event
# number are written to the header page for cleaned event (evt)
# data files
#
# 5.4.0--> 5.4.1 Aug 15, 1995
#---------------
# o fixed a bug in the SIS selection critera for the Sn_SATFm
# selection parameter. Was (Sn_SATFm<0||Sn_SATFm>1), now is
# (Sn_SATFm<1||Sn_SATFm>1)
#
# 5.3.2--> 5.4.0
#---------------
# o changed the SIS event threshold to 1000 and GIS event threshold to
# 500 for modal event merging (change in configuration file P5.2.3
# and higher)
# o now set the maxgrade parameter in faint to 6 when creating BRIGHT2
# mode data files (mode 12).
# o moved the faint.par and faintdfe.par file initialization inside the
# faint/faintdfe creation loop so that each new loop gets a fresh
# par file.
# o changed BR_EARTH selection critera for SIS event selections to
# > 20; was at > 25
# o The SIS selection critera T_DY_NT and T_SAA are now set according
# to the CCDMODE (1,2,3, or 4) of the event file
# o if the uspinum parameter from the job.par file does not have a
# value we now set USPINUM to "0"; before, USPINUM went without a
# value.
# o Added Sn_SATFm (telemetry saturation) selection critera to SIS
# selection equation.
#
# 5.3.1--> 5.3.2
#---------------
# o fixed a minor bug where some comments were not masked off with '#'
# characters.
# 5.3.0--> 5.3.1
#---------------
# o changed the T_SAA and T_DY_NT selection parameters for SIS selection
# so that (T_DY_NT<0)||(T_DY_NT>16))&&(T_SAA<0)||(T_SAA>16)
# 5.2.9--> 5.3.0
#---------------
# o fixed another silly little bug -- we got to get the steam deamon
# fixed so that we do not have to keep incrementing the major/minor
# version numbers when little fixes are made!!!!!!
# 5.2.8--> 5.2.9
#---------------
# o fixed minor bug that was inhibiting the copying of the objdist
# trend file out to the trend area
# 5.2.7--> 5.2.8
#---------------
# o fixed minor bug that was writing files to tape.create without
# striping the path
# 5.2.6--> 5.2.7
#---------------
# o set up to use mkfilter2 version 2.2
# o now delete all unused gis calibration files as soon as ascalin is
# finished
# o moved copy of mkf file to trend area after DFE correction takes
# place
# 5.2.5--> 5.2.6
#---------------
# o observation name is now taken from the telemetry file header instead
# of the object name list. If the telemetry file OBJECT keyword has
# no value then the job.par file is examined for the obs name.
# o added checkatt to the processing script.
# o added SIS event file creation to the processing script.
# o incorporated new version of mkfilter2 (mkfilter2.2) into script
# 5.2.4 -> 5.2.5
#---------------
# o observation combining code added that checks for the angular
# distance between all telemetry sets in the sequence. If the
# distance between any two sets is greater than MAX_SEPARATION then
# processing of the combined set will not occur.
# o moved the 'trim attitude' and 'merge attitude' functions into the
# processing script; before these were done by the merge_att_ext()
# funtion. Elimiated the merge_att_ext() function.
# o fixed portions of the ASCAMODE generation code so that string values
# are not surrounded by single quotes -- this was making fcreate fail
# when the ASCAMODE files were FITS wrapped.
# o integrated the proc.func function suite directly into the processing
# script. This was done to eliminate versioning mismatches between
# proc.func and processing scripts. The proc.func file is no longer
# used by processing.
# o added code to fits_wrap_ascii() so that any single quotes in
# to-be-wrapped ascii strings are replaced by two single quotes
# (ie, ' ==> '') before being processed by the fcreate ftool
# 5.2.3 -> 5.2.4
#---------------
# o added a filter to the gis3bitfix portion of code so that only
# mode 70 GIS files are acted upon.
# o added the "test" option to the script. When $4 = test, the script
# runs in test mode. Amongst other things, post processing is not
# called and the processing version number is not updated.
# o changed print command to echo in function fits_mem_sort()
# o modified shexit() so that it does not send out email or log errors
# when processing script is in test_run mode
# 5.2.2 ->5.2.3
#--------------
# o rewrote gis3bitfix portion of code so that it sends only 1 file at
# a time to gis3bitfix and check the DET_POS type (FLF or POW2)
# to use the correct calibration file.
# 5.2.1 ->5.2.2
#--------------
# o moved the gis3bitfix code segment to right after ascalin. This is
# so gis3bitfix receives corrected input files.
# o added giftool calls to interlace the gif output from ximage.
# o added the EXEDIR variable to point to the machine dependent
# executable directory (/usr/local/bin for example)
# o fixed the SIS ASCALIN portion of the script so that the 'tempofile'
# parameter is set to $REFDATA/$SISPICAL. Before, 'tempofile'
# was not being set at all for SIS files.
# 5.2.0 ->5.2.1
#--------------
# o Changed the attpath value in the attitude.par file from "." to
# "./" to reflect a feature in the FTOOLS 3.3 version of attitude
# o The ximage.bash script is now run in its own shell; before it was
# sourced from this script
#5.1.9 -> 5.2.0
#--------------
# o Added a 'shexit 1' when ximage.bash returns an error. This causes the
# processing shell to exit with an error.
#
#5.1.8 -> 5.1.9
#--------------
# o Changed public date value to 000000 in asca{log,mode}.txt files.
# o Copy sequence $JOB and error.log to trend staging area.
# o Re-aligned the text spacing and indents to improve readability.
# o Substituted $JOB for job.par.
# o Substituted $base for $base_name in xselect script creation to help
# prevent line wraps in script.
# o Replaced wastefull for loop with: cp attitude.files attitude.list.
# o Fixed bug which copied the .attlog file from merged data rather than
# the .attlog file from entire data when only 1 attitude file present.
# o Merged .mkf stage loop with mkdtime loop to reduce loop redundancy.
# o FITS wrap the ascalog.txt and ascamode.txt files to make sure they
# get
# archived with the data in post-processing.
# o Added re-direct of echo output for echo commands not going to $JOB.
#
#5.1.7 -> 5.1.8
#--------------
# o Removed quotes from some constant strings.
# o Added COORDPRO='ERROR' keyword to files prior to ascalin runs.
#
#5.1.6 -> 5.1.7
#--------------
# o Changed 'hostname' command to 'uname -n' to support Solaris.
# o Added Architecture 'uname -s' to $JOB for ID purposes.
# o Copied .dfe files to rev1 trend staging area.
# o Copied *hdr_page.txt and *_proc_info.txt to WEB directory for Don.
# o Added mail message to notify for post-processing errors.
#
#5.1.5 -> 5.1.6
#--------------
# o Modified error/warning tests for SISPI. Warnings were being detected
# as errors. Now warnings appear as STDOUT messages.
# o Added $SEQUENCE and $PROCEXT to teldef_ascalin.fits[1]
# o Removed the local copy of gis[23]_cal_files_used files.
#
#
##############################################################################
##############################################################################
##################### Define functions used in script ########################
##############################################################################
##############################################################################
#
##############################################################################
# This function will check the filesize of $1 and if nonzero, will print out
# all subsequent files to the $JOB along with error messages.
##############################################################################
errchk ()
{
typeset errlog="$1"
typeset message="$2"
typeset file
#######################################################
# shift the argument list two positions to the left
# so $3 is now $1, etc.
######################################################
shift 2
if [ "$(wc -l < $errlog)" -gt 0 ]; then
echo "$SH_VER:E2:BEGIN STDERR output from $message" >> $JOB
echo "File: $errlog" >> $JOB
cat $errlog >> $JOB
for file in $*; do
echo "File: $file" >>$JOB
cat $file >> $JOB
done
echo "$SH_VER:E0:END STDERR output from $message" >> $JOB
fi
rm -f $errlog
}
#
###############################################################################
#
# This function will uncompress a file from a remote to current directory and
# check the time order.
###############################################################################
zget ()
{
typeset from="$1"
typeset to="$2"
echo "$SH_VER:TM:Zcat $to.Z at $SECONDS" >> $JOB
########################
# uncompress
#######################
zcat $from > $to
if [ $? -gt 0 ]; then
################################
# error from zcat, so try again
################################
echo "$SH_VER:E1:Error on $to.Z zcat" >> $JOB
zcat $from > $to
if [ $? -gt 0 ]; then
###################################
# failed on the second try as well,
# so abort
###################################
echo "$SH_VER:E3:Zcat failed on $to.Z" >> $JOB
echo "$SH_VER:E0:Zcat failed on $to.Z" >> $JOB
echo "Zcat failed on $to.Z"
echo "Run aborted"
shexit 1
fi
#######################################################
# this code reached only if second try of zcat worked
#######################################################
echo "$SH_VER:E1:Retry on $to.Z zcat succeeded" >> $JOB
fi
echo "$SH_VER:TM:Zcat $to.Z complete at $SECONDS" >> $JOB
chmod 660 $to
#####################################################
# Run fverify to check the status of the input file.
# checks for correct FITS format
# abort if there are any problems
#####################################################
sed -e 's/,a,/,h,/' $FTOOLS/fverify.par > fverify.par
$FTOOLS/pset ./fverify.par infile=$to
$FTOOLS/pset ./fverify.par prhead=no
$FTOOLS/pset ./fverify.par testdata=no
$FTOOLS/fverify >> $JOB 2> log.tmp
if [ $(wc -l < log.tmp) -ne 0 ]; then
errchk log.tmp "FVERIFY $LINENO" fverify.par
echo "$SH_VER:CO:Fverify failed on RAW frf input file $to"
shexit 1
fi
rm -f fverify.par
}
#
###############################################################################
#
# This function adds or updates a fits keyword in a fits file. Add occurs if
# the keyword is not found in the header.
################################################################################
add_fits_keyword ()
{
########################################################
# positional param #1 is name of fits file + extention
# positional param #2 is keyword name
# positional param #3 is keyword contents
# positional param #4 is the comment (optional)
########################################################
sed -e 's/,a,/,h,/' $FTOOLS/fparkey.par > fparkey.par
$FTOOLS/pset ./fparkey.par value="$3"
$FTOOLS/pset ./fparkey.par fitsfile="$1"
$FTOOLS/pset ./fparkey.par keyword="$2"
if [ ! -z "$4" ]; then
###########################
# optional comment
###########################
$FTOOLS/pset ./fparkey.par comm="$4"
fi
$FTOOLS/pset ./fparkey.par add=yes
$FTOOLS/fparkey >> $JOB 2> log.tmp
errchk log.tmp "add_fits_keyword.FPARKEY $LINENO" fparkey.par
rm -f fparkey.par
}
#
###############################################################################
# This function retrieves the value of a keyword from a fits header.
# A number of variables are defined in the main ksh so that the function
# can communicate the results back to the main ksh.
###############################################################################
get_fits_keyword ()
{
##############################################################################
# positional param #1 is name of fits file + extention
# positional param #2 is keyword name
# external variables are needed: get_fits_keyword_value,get_fits_keyword_exist
##############################################################################
sed -e 's/,a,/,h,/' $FTOOLS/fkeypar.par > fkeypar.par
$FTOOLS/pset ./fkeypar.par fitsfile="$1"
$FTOOLS/pset ./fkeypar.par keyword="$2"
$FTOOLS/fkeypar >> $JOB 2> log.tmp
errchk log.tmp "get_fits_keyword.FKEYPAR $LINENO" fkeypar.par
####################################################
# look in fkeypar.par to see if the keyword exists
####################################################
get_fits_keyword_exist="$($FTOOLS/pget ./fkeypar.par exist)"
if [ "$get_fits_keyword_exist" = "yes" ]; then
#################################################
# keyword exists, so set get_fits_keyword_value
#################################################
get_fits_keyword_value="$($FTOOLS/pget ./fkeypar.par value)"
else
#################################################################
# keyword does not exist, so set get_fits_keyword_value to null
#################################################################
get_fits_keyword_value=""
fi
rm -f fkeypar.par
}
#
##############################################################################
#
# This function wraps a fits file around an ascii text file. The file max
# length is calculated with an awk program.
#
##############################################################################
fits_wrap_ascii ()
{
################################################################
# positional param #1 is name of the output fits file
# positional param #2 is name of the ascii file to be wrapped
################################################################
#############################################################################
# We have to replace any single quotes with two single quotes to make fcreate
# happy
#############################################################################
sed -e "s/\'/\'\'/g" $2 > wrap1.tmp
#########################################
# use awk to calculate maximum line length
###########################################
mll="$(awk 'BEGIN {ll=0} {if (length > ll) ll=length} END {print ll}' wrap1.tmp)"
##############################################################
# We have to place single quotes around each line for fcreate
###############################################################
perl -pe 's/(.+)/\047$1\047/||s/^/\047 \047/' wrap1.tmp > wrap2.tmp
sed -e 's/,a,/,h,/' $FTOOLS/fcreate.par > fcreate.par
echo "text A"${mll}" char" > fcreate.cdfile
$FTOOLS/pset ./fcreate.par cdfile=fcreate.cdfile
$FTOOLS/pset ./fcreate.par datafile="wrap2.tmp"
$FTOOLS/pset ./fcreate.par outfile="$1"
$FTOOLS/pset ./fcreate.par tbltype="ASCII"
$FTOOLS/fcreate >> $JOB 2> log.tmp
errchk log.tmp "fits_wrap_ascii.FCREATE $LINENO" fcreate.par fcreate.cdfile
rm -f fcreate.par fcreate.cdfile wrap1.tmp wrap2.tmp
}
#
###############################################################################
#
# This function will wrap a fits file around a GIF image. It uses the primary
# array within the FITS file to contain the image. BITPIX=8, NAXIS1=1 and
# NAXIS2=length-of-gif-file.
#
###############################################################################
fits_wrap_gif ()
{
############################################################
# positional param #1 is name of the output fits file
# positional param #2 is name of the gif file to be wrapped
############################################################
if [ ! -s $BIN/.gif.head -o ! -s $BIN/.gif.zero ]; then
echo "ERROR: Missing .gif.head and/or .gif.zero" >> $JOB
return
fi
cat $BIN/.gif.head > fwg.tmp
cat $2 >> fwg.tmp
cat $BIN/.gif.zero >> fwg.tmp
######################################
# convert from 2880 byte blocks
######################################
size="$(wc -c < fwg.tmp)"
dd if=fwg.tmp of=$1 ibs=2880 count="$(expr $size / 2880)" > /dev/null 2>&1
rm -f fwg.tmp
#############################################
# define NAXIS2 and FNAME keywords
#############################################
size="$(wc -c < $2)"
add_fits_keyword $1[0] NAXIS2 "$size" "length of data axis 2"
add_fits_keyword $1[0] FNAME "$2" "GIF filename"
}
#
###############################################################################
#
# This function checks the input file to see if it is in time order
# This check is necessary to trap ongoing bugs in various programs
# Returns without any message if the file is ok, else writes to the $JOB
# and returns status of "2"
#
###############################################################################
check_time_order ()
{
#######################################################################
# positional parameter #1 is the FITS file and extention to be tested
# positional parameter #2 is the FITS file column name to check
# positional parameter #3 is whether to check for equal times (yes/no)
#######################################################################
sed -e 's/,a,/,h,/' $FTOOLS/cktime.par > cktime.par
$FTOOLS/pset ./cktime.par infile="$1"
$FTOOLS/pset ./cktime.par colname="$2"
$FTOOLS/pset ./cktime.par ckequal=$3
$FTOOLS/cktime > cktime.log 2> log.tmp
errchk log.tmp "check_time_order.CKTIME $LINENO" cktime.par
last_line="$(tail -1 cktime.log)"
if [ $($BIN/recmp "$last_line" "ORDERED") -ne 0 ]; then
echo "$SH_VER:E1:Out of time order FITS file detected: $1" >> $JOB
cat cktime.log >> $JOB
rm -f cktime.par cktime.log
return 2
fi
rm -f cktime.par cktime.log
}
#
###############################################################################
#
# Preform a FITS Memory SORT on a given column name.
#
###############################################################################
fits_mem_sort ()
{
###############################################
# $1 = input FITS file + extension
# $2 = FITS column name to sort on
#################################################
sed -e 's/,a,/,h,/' $FTOOLS/fmemsort.par >./fmemsort.par
$FTOOLS/pset ./fmemsort.par infile=$1
$FTOOLS/pset ./fmemsort.par outfile=tmp.fits
$FTOOLS/pset ./fmemsort.par column=$2
$FTOOLS/pset ./fmemsort.par method=insert
$FTOOLS/pset ./fmemsort.par ascend=yes
$FTOOLS/pset ./fmemsort.par copyall=yes
$FTOOLS/pset ./fmemsort.par history=yes
$FTOOLS/fmemsort >> $JOB 2> log.tmp
errchk log.tmp "fits_mem_sort.FMEMSORT $LINENO" fmemsort.par
if [ -s ./tmp.fits ]
then
mv tmp.fits $1
echo "$TYPE:$PROC_VER:E1:$1 corrected using FMEMSORT" >>$JOB
fi
rm fmemsort.par
}
#
###############################################################################
# global return value for function add_ontimes
###############################################################################
add_ontimes ()
{
#######################################################################
# positional parameter #1 is the flat file list of files to accumlate
# ontimes for
#######################################################################
add_ontimes_value="0.0"
for file in $(cat $1); do
get_fits_keyword ${file}[0] ONTIME
add_ontimes_value="$(echo $add_ontimes_value $get_fits_keyword_value | nawk '{print $1+$2}')"
done
add_ontimes_value="$(echo $add_ontimes_value | nawk '{print int($1)}')"
}
#
###############################################################################
#
# Function to exit the script in a clean way and notify the logfiles.
#
###############################################################################
shexit ()
{
typeset -i level="$1"
typeset log="$AUTO/lists/processing.done.list"
if [ "$TEST_RUN" = "true" ]
then
exit $level
fi
if [ "$level" -eq 0 ]; then
echo "$SH_VER:M1:${SEQUENCE}_${PROCEXT} Finished @ $(date)" >> $log
else
echo "$SH_VER:E1:${SEQUENCE}_${PROCEXT} Error @ $(date)" \
"error=$level" >> $log
echo "$SH_VER:E1:${SEQUENCE}_${PROCEXT} Error @ $(date) error=$level"
mail -s "$TYPE:Error exit" $USERNAME <<- EOF
Sequence ${SEQUENCE}.${PROCEXT} has non-zero exit status!
Host: $(uname -n)
Directory: $RUN_DIR
EOF
fi
rm -f $COMMAND
#
#####################################################################
# create the error log
# the error log contains all the E2 and E3 error messages which
# were reported to the job log
######################################################################
ERROR_LOG="${ADSE}_$PROCEXT.error.log"
echo "ASCA Operations Job Log Error Summary" > $ERROR_LOG
echo " " >> $ERROR_LOG
echo $(date) >> $ERROR_LOG
echo "Sequence: " $SEQUENCE >> $ERROR_LOG
echo " " >> $ERROR_LOG
echo "Start of E2, E3 errors found" >> $ERROR_LOG
sed -n -e '/.*\:E[23]\:.*/,/.*\:E0\:.*/p' $JOB >> $ERROR_LOG
echo "End of summary" >> $ERROR_LOG
###############################################################
# transfer the job.log and error.log files to the trend area
################################################################
cp $JOB $JOBLOGDIR/${ADSE}_$PROCEXT.$JOB
chmod 644 $JOBLOGDIR/${ADSE}_$PROCEXT.$JOB
cp $ERROR_LOG $JOBLOGDIR/$ERROR_LOG
chmod 644 $JOBLOGDIR/$ERROR_LOG
##########################################################
# exit to the parent shell with the appropriate status
##########################################################
exit $level
}
#
###############################################################################
#
# Compute the modal ID.
#
###############################################################################
get_modal_id ()
{
##########################################
# Argument 1 is the MODAL configuration.
##########################################
$BIN/lockit $MODAL_LIST
id="$(awk '$0~/'"$1"'/{print NR}' < $MODAL_LIST)"
if [ -z "$id" ]; then
echo "$1" >> $MODAL_LIST
id="$(awk '$0~/'"$1"'/{print NR}' < $MODAL_LIST)"
fi
$BIN/unlockit $MODAL_LIST
echo $id
}
#
###############################################################################
#
# Check the OBJECT keyword for existance and supply if missing.
#
###############################################################################
check_object ()
{
#########################################
# try to get it from the $1 FITS file header
############################################
get_fits_keyword $1[1] OBJECT
if [ "$get_fits_keyword_exist" = yes ]; then
OBJECT="$get_fits_keyword_value"
echo "$SH_VER:CO:Using keyword OBJECT: $OBJECT from $1 header" >> $JOB
$FTOOLS/pset ./job.par object="$OBJECT"
return
fi
##############################################
# try to get it from the job.par file
##############################################
OBJECT="$($FTOOLS/pget ./job.par object)"
if [ -n "$OBJECT" ]
then
echo "$SH_VER:CO:Using keyword OBJECT: $OBJECT from job.par" >> $JOB
add_fits_keyword $1[1] OBJECT "$OBJECT" "Name of object"
return
fi
#####################################################
# try to get it from the first troublesome name list
#####################################################
OBJECT="$(grep $SEQUENCE $AUTO/lists/NAMELIST1 | awk -F: '{print $2}')"
if [ ! -z "$OBJECT" ]; then
echo "$SH_VER:CO:Using keyword OBJECT: $OBJECT from namelist file" >> $JOB
add_fits_keyword $1[1] OBJECT "$OBJECT" "Name of object"
$FTOOLS/pset ./job.par object="$OBJECT"
return
fi
#####################################################
# try to get it from the second troublesome name list
#####################################################
OBJECT="$(grep $SEQUENCE $AUTO/lists/NAMELIST2 | awk -F: '{print $2}')"
if [ ! -z "$OBJECT" ]; then
echo "$SH_VER:CO:Using keyword OBJECT: $OBJECT from namelist file" >> $JOB
add_fits_keyword $1[1] OBJECT "$OBJECT" "Name of object"
$FTOOLS/pset ./job.par object="$OBJECT"
return
fi
########################################################
# if you've gotten this far, the object name can't be
# found anywhere, so abort the script
#######################################################
echo "$SH_VER:E1:OBJECT name UNKNOWN, exit 1" >> $JOB
echo "$SH_VER:E1:OBJECT name UNKNOWN, exit 1"
shexit 1
}
#
##############################################################################
##############################################################################
######################### Begin script main body #############################
##############################################################################
##############################################################################
trap - HUP
#
########################################
######################################
##
## initialize variables
##
####################################
#####################################
############################################
# names of important directories and files
############################################
export HOST=`uname -n | awk -F. '{print $1}'`
export JOB=job.log
export add_ontimes_value="0.0"
export get_fits_keyword_value
export get_fits_keyword_exist
#############################################################################
# Read in command Line parameters:
#
# $1 Data TYPE, ao or pv
# $2 Job configuration file
# $3 Processing Directory (aka. Run directory)
# $4 test toggle switch, blank ==> run in regular operation mode,
# "test_run" ==> run in test mode
#############################################################################
export TYPE="$1"
export CONFIG="$2"
export RUN_DIR="$3"
export PROV_VER="$(echo $CONFIG | awk 'BEGIN{FS="/"}{print $NF}')"
#########################################################
# determine the run type -- standard run or test run
#########################################################
if [ "$4" = "test_run" ]
then
TEST_RUN="true"
else
TEST_RUN="false"
fi
export TEST_RUN
########################################
# append TYPE to PROC_VER to get SH_VER
#######################################
case "$TYPE" in
ao) export SH_VER="AO:$PROC_VER" ;;
pv) export SH_VER="PV:$PROC_VER" ;;
* ) echo "E3:No data TYPE found"
shexit 1 ;;
esac
######################################################################
# check if RUN_DIR has a non-null value and is an existing directory
######################################################################
if [ -z "$RUN_DIR" -o ! -d "$RUN_DIR" ]; then
echo "$TYPE:RUN_DIR is illegal for this shell job"
exit 1
fi
########################################################
# change directory to directory where processing happens
#########################################################
cd $RUN_DIR
####################################
# log some things
##################################
if [ "$TEST_RUN" = "true" ]
then
echo "$SH_VER:LO:Start TEST RUN at $(date)" > $JOB
else
echo "$SH_VER:LO:Start at $(date)" > $JOB
fi
echo "$SH_VER:LO:Hostname $(uname -n)" >> $JOB
echo "$SH_VER:LO:Architecture $(uname -s)" >> $JOB
echo "$SH_VER:LO:Processing directory $RUN_DIR" >> $JOB
echo "$SH_VER:LO:Process num = $$" >> $JOB
echo "$SH_VER:LO:Process script = ${0##*/}" >> $JOB
#####################################
# read in the configuration file
#####################################
. $CONFIG
##################################################################
# check if job.par exists and has something in it. If not, quit
#################################################################
if [ ! -s job.par ]; then
echo "$SH_VER:E3:NO JOB.PAR FOUND!!!!" >> $JOB
echo "$SH_VER:E3:NO JOB.PAR FOUND!!!!"
shexit 1
fi
#####################################################################
# read some variables from job.par and assign some related variables
######################################################################
export BIN="$AUTO/bin"
export SEQUENCE="$($FTOOLS/pget ./job.par sequence)"
export SEQPROCNUM="$($FTOOLS/pget ./job.par seqprocnum)"
export ORBIT="$($FTOOLS/pget ./job.par orbit)"
export PROCEXT="$(echo $SEQPROCNUM | nawk '{printf ("%03d", $0)}')"
export ADSE="ad$SEQUENCE"
#######################################################################
# update the proc.history file so that version numbers may be tracked
# unless this is just a test run
########################################################################
if [ "$TEST_RUN" = "false" ]
then
echo "$SEQUENCE $PROC_VER START $(date +%y%m%d%H%M%S)" >> $PROC_HIST
fi
##############################################################################
###############################################################################
##
## RUN APPLICATIONS PROGRAMS HERE
##
###############################################################################
###############################################################################
##############################################################################
# Create FLAT job.par.info. This file contains one entry per attitude and
# telemetry file. It's used to make it easier to get at the staging directory,
# filenames, and Euler angles for each file.
###############################################################################
rm -f job.par.info
typeset max="$($FTOOLS/pget ./job.par frfcnt)"
typeset -i cnt_i=1
while [ $cnt_i -le $max ]; do
#######################################
# file number string with leading zeros
#######################################
cnt="$(echo $cnt_i | nawk '{printf ("%03d", $0)}')"
#############################
# FRF (telemetry) file names
#############################
arc_tel="$($FTOOLS/pget ./job.par frffile_$cnt)"
tel=${arc_tel##*/}
tel=${tel%.Z}
####################################
# spaceccraft attitude file names
###################################
arc_att="$($FTOOLS/pget ./job.par attfile_$cnt)"
att=${arc_att##*/}
att=${att%.Z}
################
# Euler angles
################
e1="$($FTOOLS/pget ./job.par euler1_$cnt)"
e2="$($FTOOLS/pget ./job.par euler2_$cnt)"
e3="$($FTOOLS/pget ./job.par euler3_$cnt)"
###################################
# make a new line in job.par.info
###################################
echo "$tel $arc_tel $att $arc_att $e1 $e2 $e3" >> job.par.info
let cnt_i+=1
done
#
###############################################################################
##########################################################################
##
## Do the following first for telemetry files, then for attitude files:
## > uncompress file and transfer to working directory
## > check for various error in files.
##
###########################################################################
############################################################################
##################################
# loop over lines in job.par.info
##################################
typeset -i tel_cnt=0
for tel in $(awk '{print $1}' job.par.info); do
###############################
# uncompress telemetry file
#############################
arc_tel="$(grep $tel job.par.info | awk '{print $2}')"
zget $arc_tel $tel
##################################################
# check if looking at correct object in the sky
#################################################
echo "$SH_VER:TM:Check OBJECT keyword at $SECONDS" >> $JOB
check_object $tel
######################################
# check that telemetry is time ordered
######################################
echo "$SH_VER:TM:Verify telemetry time ordered at $SECONDS" >> $JOB
check_time_order $tel[1] TIME yes
#########################################################
# check that telemetry file has correct sequence number
#########################################################
get_fits_keyword $tel[1] SEQNUM
if [ "$SEQUENCE" != "$get_fits_keyword_value" ]; then
echo "$SH_VER:E3:$tel DOES NOT BELONG TO SEQ $SEQUENCE!"
shexit 1
fi
############################################################
# check for time overlaps between consecutive files.
############################################################
################################
# if this is the first file.....
################################
let tel_cnt+=1
if [ $tel_cnt -eq 1 ]; then
last_fname=$tel
##########################################
# read the time at the end of this file
#########################################
####################
# find the last row
####################
get_fits_keyword $tel[1] NAXIS2
last_row="$get_fits_keyword_value"
##########################################################
# reformat template table parameter file (change ",a," to ",h," )
###########################################################
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
#######################################
# set values in table parameter file
#######################################
$FTOOLS/pset ./ftabpar.par fitsfile="$tel[1]"
$FTOOLS/pset ./ftabpar.par column=TIME
$FTOOLS/pset ./ftabpar.par row="$last_row"
##########################################
# read last time value in telemetry file
#########################################
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "FTABPAR $LINENO" ftabpar.par
last_time="$($FTOOLS/pget ./ftabpar.par value)"
##########################################################
# don't need table parameter file any more, so remove it
#########################################################
rm ./ftabpar.par
###########################################################
# skip the rest of this loop and go to next telemetry file
###########################################################
continue
fi
########################################################################
# this code only reached for files after the first one
#
# Each 2->N file must be checked against the previous file and fselecte'd
#########################################################################
##########################################################
# read first time entry from telemetry file
##########################################################
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
$FTOOLS/pset ./ftabpar.par fitsfile="$tel[1]"
$FTOOLS/pset ./ftabpar.par column=TIME
$FTOOLS/pset ./ftabpar.par row=1
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "FTABPAR $LINENO" ftabpar.par
first_time="$($FTOOLS/pget ./ftabpar.par value)"
###########################################################################
# compare first time entry of this file to last entry of the previous file
###########################################################################
time_cmp="$($STOOLS/floatcmp $last_time $first_time)"
if [ "$time_cmp" != "lt" ]; then
##################################################################
# the current file overlaps the previous file so it must be fixed
##################################################################
echo "$SH_VER:E1:Time overlap between telemetry files detected" >> $JOB
echo "$SH_VER:TM:Begin correct $tel overlap at $SECONDS" >> $JOB
######################################
# 1st create the new telemetry file
######################################
sed -e 's/,a,/,h,/' $FTOOLS/fselect.par > fselect.par
$FTOOLS/pset ./fselect.par infile="$tel[1]"
$FTOOLS/pset ./fselect.par outfile=tmp.fits
$FTOOLS/pset ./fselect.par expr="(TIME - $last_time) .gt. 0.1"
$FTOOLS/fselect >> $JOB 2> log.tmp
errchk log.tmp "FSELECT $LINENO" fselect.par
rm fselect.par
#########################################
# fix the keywords in the new tel file
########################################
get_fits_keyword $last_fname[1] ORBIT1
add_fits_keyword tmp.fits[1] ORBIT0 "$get_fits_keyword_value" \
"Corrected from $last_fname"
get_fits_keyword $last_fname[1] MTIME1
add_fits_keyword tmp.fits[1] MTIME0 "$get_fits_keyword_value" \
"Corrected from $last_fname"
get_fits_keyword $last_fname[1] DATE1
add_fits_keyword tmp.fits[1] DATE0 "$get_fits_keyword_value" \
"(dd/mm/yy) Corrected from $last_fname"
get_fits_keyword $last_fname[1] TIME1
add_fits_keyword tmp.fits[1] TIME0 "$get_fits_keyword_value" \
"Corrected from $last_fname"
mv tmp.fits $tel
echo "$SH_VER:TM:$tel corrected at $SECONDS" >> $JOB
echo "$SH_VER:E1:$tel corrected." >> $JOB
fi
########################
# end of the loop stuff:
#########################
last_fname=$tel
#################################################
# read last time entry of current telemetry file
#################################################
get_fits_keyword $tel[1] NAXIS2
last_row="$get_fits_keyword_value"
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
$FTOOLS/pset ./ftabpar.par fitsfile="$tel[1]"
$FTOOLS/pset ./ftabpar.par column=TIME
$FTOOLS/pset ./ftabpar.par row="$last_row"
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "FTABPAR $LINENO" ftabpar.par
last_time="$($FTOOLS/pget ./ftabpar.par value)"
done
###############################################################################
# Setup the frfread parameter set in file frfread.par
##############################################################################
sed -e 's/,a,/,h,/' ${FRFREAD%/*}/frfread.par > frfread.par
###################################
# file originated here at Goddard
##################################
$FTOOLS/pset ./frfread.par origin=GSFC
########################
# set object keyword
########################
get_fits_keyword "$tel[1]" OBJECT
if [ "$get_fits_keyword_exist" = yes ]; then
#############################################
# there is an object listed in telemetry file
#############################################
OBJECT="$(echo $get_fits_keyword_value | tr -d \')"
$FTOOLS/pset ./frfread.par object="$OBJECT"
else
############################################################
# no object name in telemetry file, so use sequence number
############################################################
$FTOOLS/pset ./frfread.par object="$SEQUENCE"
fi
##################################################
# read sequence processing PI team type code number
# and set SEQPI accordingly
################################################
typeset -i seq_type="$($FTOOLS/pget ./job.par seq_type)"
case $seq_type in
1 ) SEQPI="$($FTOOLS/pget ./job.par jppiname)" ;;
2 ) SEQPI="$($FTOOLS/pget ./job.par uspiname)" ;;
3 ) SEQPI="$($FTOOLS/pget ./job.par jppiname)" ;;
4 ) SEQPI="$($FTOOLS/pget ./job.par uspiname)" ;;
6 ) SEQPI="$($FTOOLS/pget ./job.par uspiname)" ;;
7 ) SEQPI="$($FTOOLS/pget ./job.par jppiname)" ;;
8 ) SEQPI="$($FTOOLS/pget ./job.par uspiname)" ;;
9 ) SEQPI="Manager" ;;
11) SEQPI="$($FTOOLS/pget ./job.par uspiname)" ;;
* ) SEQPI="Unknown PI"
echo "$SH_VER:E1:Unknown sequence type $seq_type" >> $JOB ;;
esac
$FTOOLS/pset ./frfread.par seqpi="$SEQPI"
###############################################################################
############################################################################
##
## Assemble attitude file(s), check sequence ownership and time order.
##
############################################################################
###############################################################################
###############################################
# loop over all attitude files in job.par.info
###############################################
typeset -i att_cnt=0
for att in $(awk '{print $3}' job.par.info); do
#########################
# uncompres attitude file
##########################
arc_att="$(grep $att job.par.info | awk '{print $4}')"
zget $arc_att $att
echo "$SH_VER:TM:Check OBJECT keyword at $SECONDS" >> $JOB
#################################
# check astronomical object name
#################################
check_object $att
###################################################
# record attitude file name in file attitude.files
###################################################
echo "$att" >> attitude.files
############################################
# check that attitude file is time ordered
############################################
echo "$SH_VER:TM:Verify attitude time ordered at $SECONDS" >> $JOB
check_time_order $att[1] TIME yes
#########################################################
# check that attitude file has correct sequence number
#########################################################
get_fits_keyword $att[1] SEQNUM
if [ "$SEQUENCE" != "$get_fits_keyword_value" ]; then
echo "$SH_VER:E3:$att DOES NOT BELONG TO SEQ $SEQUENCE!"
shexit 1
fi
######################################################
# check for time overlaps between consecutive files.
######################################################
#############################
# for the first attitude file:
############################
let att_cnt+=1
if [ $att_cnt -eq 1 ]; then
last_fname=$att
#################################################
# read last time element of first attitude file
#################################################
get_fits_keyword $att[1] NAXIS2
last_row="$get_fits_keyword_value"
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
$FTOOLS/pset ./ftabpar.par fitsfile="$att[1]"
$FTOOLS/pset ./ftabpar.par column=TIME
$FTOOLS/pset ./ftabpar.par row="$last_row"
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "FTABPAR $LINENO" ftabpar.par
last_time="$($FTOOLS/pget ./ftabpar.par value)"
rm ./ftabpar.par
####################################################
#skip the rest of the loop and go on to next file
####################################################
continue
fi
##################################################
# this code not reached for the first attitude file
#
# Each 2->N file must be checked against the previous file and fselecte'd
###########################################################################
#####################################################
# read first time value for current attitude file
####################################################
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
$FTOOLS/pset ./ftabpar.par fitsfile="$att[1]"
$FTOOLS/pset ./ftabpar.par column=TIME
$FTOOLS/pset ./ftabpar.par row=1
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "FTABPAR $LINENO" ftabpar.par
first_time="$($FTOOLS/pget ./ftabpar.par value)"
######################################################################
# compare the start of this file to the end of the last attitude file
######################################################################
time_cmp="$($STOOLS/floatcmp $last_time $first_time)"
if [ "$time_cmp" != "lt" ]; then
###################################################################
# the current file overlaps the previous file so it must be fixed
###################################################################
echo "$SH_VER:E1:Time overlap between attitude files detected" >> $JOB
echo "$SH_VER:TM:Begin correct $att overlap at $SECONDS" >> $JOB
###################################
# 1st create the new attitude file
###################################
sed -e 's/,a,/,h,/' $FTOOLS/fselect.par > fselect.par
$FTOOLS/pset ./fselect.par infile="$att[1]"
$FTOOLS/pset ./fselect.par outfile=tmp.fits
$FTOOLS/pset ./fselect.par expr="(TIME - $last_time) .gt. 0.1"
$FTOOLS/fselect >> $JOB 2> log.tmp
errchk log.tmp "FSELECT $LINENO" fselect.par
rm fselect.par
##########################################
# fix the keywords in the new attitude file
#########################################
get_fits_keyword $last_fname[1] ORBIT1
add_fits_keyword tmp.fits[1] ORBIT0 "$get_fits_keyword_value" \
"Corrected from $last_fname"
get_fits_keyword $last_fname[1] MTIME1
add_fits_keyword tmp.fits[1] MTIME0 "$get_fits_keyword_value" \
"Corrected from $last_fname"
get_fits_keyword $last_fname[1] DATE1
add_fits_keyword tmp.fits[1] DATE0 "$get_fits_keyword_value" \
"(dd/mm/yy) Corrected from $last_fname"
get_fits_keyword $last_fname[1] TIME1
add_fits_keyword tmp.fits[1] TIME0 "$get_fits_keyword_value" \
"Corrected from $last_fname"
mv tmp.fits $att
echo "$SH_VER:TM:$att corrected at $SECONDS" >> $JOB
echo "$SH_VER:E1:$att corrected." >> $JOB
fi
#####################
# end of loop stuff
#####################
last_fname=$att
################################################
# read last time value for this attitude file
###############################################
get_fits_keyword $att[1] NAXIS2
last_row="$get_fits_keyword_value"
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
$FTOOLS/pset ./ftabpar.par fitsfile="$att[1]"
$FTOOLS/pset ./ftabpar.par column=TIME
$FTOOLS/pset ./ftabpar.par row="$last_row"
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "FTABPAR $LINENO" ftabpar.par
last_time="$($FTOOLS/pget ./ftabpar.par value)"
done
#
###############################################################################
#############################################################################
##
## Obtain the latest ORBIT file.
## note: ORBIT is set from job.par file
##
#############################################################################
############################################################################
####################################################################
# check if ORBIT is defined and that it specifies a non-empty file
####################################################################
if [ -z "$ORBIT" -o ! -s "$ORBIT" ]; then
echo "$SH_VER:E2:File $ORBIT missing" >> $JOB
echo "$SH_VER:E2:File $ORBIT missing"
shexit 1
fi
######################################################
# copy orbit file into working directory as frf.orbit
#######################################################
cp $ORBIT ./frf.orbit
chmod 644 ./frf.orbit
add_fits_keyword frf.orbit[1] FNAME frf.orbit
#
###############################################################################
###############################################################################
##
## Determine pointing information from attitude file(s)
##
###############################################################################
###############################################################################
###############################################################################
# create "trimmed" versions of all attitude files
###############################################################################
echo "$SH_VER:TM:create trimmed attitude files at $SECONDS" >> $JOB
typeset -i naxis2
typeset -i low
typeset -i high
##################################################
# loop over attitude files
# these were relisted in the file attidue.files
##################################################
for file in $(cat attitude.files)
do
#########################################################
# read the number of entries in the attitude file table
#########################################################
get_fits_keyword $file[1] NAXIS2
naxis2=$get_fits_keyword_value
###########################################################################
# check if trimming needed for this file (are there more than 300 rows?)
###########################################################################
if [ $naxis2 -gt 300 ]; then
#################################################
# file needs to be trimmed
# move all but the first and last 100 rows to file_trim
#################################################
low=100
high=naxis2-100
echo "$SH_VER:LO:keep rows $low to $high in $file" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/fselect.par > fselect.par
$FTOOLS/pset ./fselect.par infile="$file[1]"
$FTOOLS/pset ./fselect.par outfile="${file}_trim"
$FTOOLS/pset ./fselect.par expr="(#row >= $low) && (#row <= $high)"
$FTOOLS/fselect >> $JOB 2> log.tmp
errchk log.tmp "FSELECT $LINENO" fselect.par
else
##################################################
# less than or equal to 300 rows, no need to trim
# copy entire file to file_trim
###################################################
echo "$SH_VER:LO:$file <= 300 rows; no triming performed" >> $JOB
cp $file ${file}_trim
fi
#######################################################
# record trimmed attitude file names in attitude.trim
#######################################################
echo "${file}_trim" >> attitude.trim
done
####################################
# don't need fselect.par any more
###################################
rm -f fselect.par
###############################################################################
#
# find the mean RA,DEC for each trimmed attitude file that is
# part of this sequence. For N >= 2, make sure the seperation between any 2
# sets is < MAX_SEPARATION; if not true, then do not process this sequence.
#
#############################################################################
echo "$SH_VER:TM:calculate trimmed attitude parameters at $SECONDS" >> $JOB
typeset -i attnum=0
###############################################################################
# set up the stools objdist command
# this command will have the ra and dec from each attitude file appended to it.
# command is later run to make sure
###############################################################################
command="$STOOLS/objdist $MAX_SEPARATION"
######################################
# loop through trimmed attitude files
######################################
for att in $(cat attitude.trim)
do
###################################################################
# read attitude file
# put processed mean spacecraft attitude info into attitude.out
##################################################################
echo "$SH_VER:LO:Derive parameters for $att independently" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/attitude.par > attitude.par
$FTOOLS/pset ./attitude.par attitude="$att[1]"
$FTOOLS/pset ./attitude.par attpath=./
$FTOOLS/pset ./attitude.par pointing=ATT
#######################################################################
# read attitude file, report any errors, and copy results to log file
#######################################################################
$FTOOLS/attitude > ./attitude.out 2> log.tmp
errchk log.tmp "ATTITUDE $LINENO" attitude.par
cat ./attitude.out >> $JOB
###################################################################
# check the mean attitude information just read into attitude.out
###################################################################
echo "$SH_VER:LO:run CHECKATT on attitude output from $att" >> $JOB
$STOOLS/checkatt ./attitude.out 1.0 y y -1 >> $JOB 2>> $JOB
if [ "$( $FTOOLS/pget ./attitude.par valid)" = "yes" ]
then
################################################################
# attitude information checks out
# concatenate mean ra and dec values onto the end of command
################################################################
attnum=attnum+1
ra=$($FTOOLS/pget ./attitude.par ra_avg)
dec=$($FTOOLS/pget ./attitude.par dec_avg)
tmp=$command' '$ra' '$dec
command="$tmp"
else
###########################################
# attitude information messed up, so quit
###########################################
echo "$SH_VER:E2:ERROR calculating attitude parameters for $att" >> $JOB
echo "$SH_VER:E2:job terminating at $SECONDS" >> $JOB
shexit 1
fi
done
############################################################################
# if there is more than one attitude file (attnum >= 2) then run the object
# distance STOOL on the RA,DEC values
#############################################################################
if [ $attnum -gt 1 ]
then
echo "$SH_VER:LO:Running OBJDIST on RA,DEC values at $SECONDS" >> $JOB
$command > ./objdist.$$
############################################################
# list the trimmed attitude files at the end of objdist.
###########################################################
echo "ATTITUDE files used:" >> ./objdist.$$
for att in $(cat attitude.trim)
do
echo "$att" >> ./objdist.$$
done
####################################
# put objdist output into log file
####################################
cat ./objdist.$$ >> $JOB
################################################
# check if any warnings were issued by objdist.
# if so, quit
###############################################
if [ -n "$(cat ./objdist.$$ | grep "WARNING")" ]
then
echo "$SH_VER:E2:MAX separation parameter exceeded; job terminating at $SECONDS" >> $JOB
shexit 1
fi
################################
# remove objdist temporary file
################################
rm -f /tmp/objdist.$$
##############################################################
# tack the sequence number onto the objdist output file name
# in order to keep this file.
##############################################################
mv ./objdist.$$ ./objdist.$SEQUENCE
else
###########################################################################
# there is only one telemetry file, so no need to worry if they match up
##########################################################################
echo "$SH_VER:LO:Only 1 attitude/telem set found, skipping OBJDIST" >> $JOB
fi
##################################################################
# don't need attitude.par (which helped read attitude files)
# or attitude.out (which contained the mean attitude information)
# any more
#################################################################
rm -f attitude.par attitude.out
###############################################################################
#
# find the mean RA,DEC for each standard attitude file that is
# part of this sequence. We do this only for future reference.
#
##############################################################################
echo "$SH_VER:TM:calculate standard attitude parameters at $SECONDS" >> $JOB
########################################################################
# loop through attitude files (note these are the un-trimmed versions)
########################################################################
for att in $(cat attitude.files)
do
######################################
# read attitude file into file.attlog
######################################
echo "$SH_VER:LO:Derive parameters for $att independently" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/attitude.par > attitude.par
$FTOOLS/pset ./attitude.par attitude="$att[1]"
$FTOOLS/pset ./attitude.par attpath=./
$FTOOLS/pset ./attitude.par pointing=ATT
$FTOOLS/attitude > $att.attlog 2> log.tmp
errchk log.tmp "ATTITUDE $LINENO" attitude.par
################################################
# run checkatt and put results into log file
###############################################
echo "$SH_VER:LO:run CHECKATT on attitude output from $att" >> $JOB
$STOOLS/checkatt $att.attlog 1.0 y y -1 >> $JOB 2>> $JOB
###################################
# put .attlog file into log file
###################################
cat $att.attlog >> $JOB
done
###############################################################################
#
# merge the trimmed attitude files
#
###############################################################################
echo "$SH_VER:TM:Begin merge of trimmed attitude files at $SECONDS" >> $JOB
####################################
# clear out any old fselect.par files
#####################################
rm -f fselect.par
#############################################
# tack "[1]" onto trimmed attitude file list.
# store thses in attitude.trim.ext
#############################################
awk '{printf"%s[1]\n",$1}' attitude.trim > attitude.trim.ext
#############################
# prepare fmerge.par file
#############################
sed -e 's/,a,/,h,/' $FTOOLS/fmerge.par > fmerge.par
$FTOOLS/pset ./fmerge.par infiles="@attitude.trim.ext"
$FTOOLS/pset ./fmerge.par outfile="${ADSE}a.att"
$FTOOLS/pset ./fmerge.par copyprime=yes
##############################################################################
# note that we use the DATE-END TIME-END TSTOP values from the last attitude
# file in the merged attitude file
##############################################################################
$FTOOLS/pset ./fmerge.par lastkey="ORBIT1 MTIME1 DATE1 TIME1 MTIME1-1 DATE1-1 TIME1-1"
$FTOOLS/pset ./fmerge.par history=yes
##################################
# merge the files
##################################
$FTOOLS/fmerge >> $JOB 2> log.tmp
errchk log.tmp "FMERGE $LINENO" fmerge.par
###########################################################
# make sure merged attitude file is still time ordered
##########################################################
check_time_order ${ADSE}a.att[1] TIME yes
############################################################
# delete trimmed attitude files if this is not a test run
###########################################################
if [ "$TEST_RUN" != "true" ]
then
for file in $(cat attitude.trim)
do
rm -f $file
done
fi
############################################
# cleanup various attitude related files
############################################
rm -f attitude.trim
rm -f attitude.files
rm -f attitude.par
rm -f attitude.trim.ext
rm -f fmerge.par
###########################################################################
# Compute the mean RA and DEC from the merged attitude.
###########################################################################
echo "$SH_VER:TM:Compute mean RA/DEC from attitude at $SECONDS" >> $JOB
echo "$SH_VER:LO:This is computed from the merged attitude files" >> $JOB
###########################
# prepare attitude.par file
###########################
sed -e 's/,a,/,h,/' $FTOOLS/attitude.par > attitude.par
$FTOOLS/pset ./attitude.par attitude="${ADSE}a.att[1]"
$FTOOLS/pset ./attitude.par attpath=./
$FTOOLS/pset ./attitude.par pointing=ATT
###########################################################
# read merged attitude file
# put results into $ADSE.attlog temporarily
# and permanently into log file
###########################################################
$FTOOLS/attitude > $ADSE.attlog 2> log.tmp
errchk log.tmp "ATTITUDE $LINENO" attitude.par
cat $ADSE.attlog >> $JOB
rm -f $ADSE.attlog
############################################
# check validity of merged attitude file
###########################################
valid="$($FTOOLS/pget ./attitude.par valid)"
if [ "$valid" = "yes" ]; then
#################################
# merged attitude file is valid,
# record mean RA, DEC, and ROLL
# dump these onto log file
#################################
RA="$($FTOOLS/pget ./attitude.par ra_avg)"
DEC="$($FTOOLS/pget ./attitude.par dec_avg)"
ROLL="$($FTOOLS/pget ./attitude.par roll_avg)"
echo "$SH_VER:CO:Using telemetry mean RA = $RA" >> $JOB
echo "$SH_VER:CO:Using telemetry mean DEC = $DEC" >> $JOB
fi
#########################################
# check for various invalid possibilities
##########################################
if [ "$valid" != "yes" -o "$RA" = "NaN" ]; then
###########################################################################
# RA is Not a Number,
# try to read it from merged attitude fits file header
# with either RA or RA_NON keyword
# if neither exist, set RA to "0.0" by default
###########################################################################
RA="0.0"
get_fits_keyword "${ADSE}a.att[1]" RA
if [ "$get_fits_keyword_exist" = "yes" ]; then
##########################
# there is an RA keyword
#########################
RA="$get_fits_keyword_value"
else
##############################
# try for an RA_NOM keyword
##############################
get_fits_keyword "${ADSE}a.att[1]" RA_NOM
if [ "$get_fits_keyword_exist" = "yes" ]; then
##############################
# there is an RA_NOM keyword
##############################
RA="$get_fits_keyword_value"
fi
fi
#########################################
# dump the updated RA to the log file
##########################################
echo "$SH_VER:CO:Using source RA = $RA" >> $JOB
fi
########
# DEC
#######
if [ "$valid" != "yes" -o "$DEC" = "NaN" ]; then
########################################################################
# check for DEC or DEC_NOM keywords in merged attitude fits file header
########################################################################
DEC="0.0"
get_fits_keyword "${ADSE}a.att[1]" DEC
if [ "$get_fits_keyword_exist" = "yes" ]; then
DEC="$get_fits_keyword_value"
else
get_fits_keyword "${ADSE}a.att[1]" DEC_NOM
if [ "$get_fits_keyword_exist" = "yes" ]; then
DEC="$get_fits_keyword_value"
fi
fi
######################
# dump DEC to log file
######################
echo "$SH_VER:CO:Using source DEC = $DEC" >> $JOB
fi
##################################################
# if attiude read wasn't valid, set ROLL to 0.0
#################################################
if [ "$valid" != "yes" ]; then
ROLL=0.0
fi
#################################
# set RA and DEC in frfread.par
################################
$FTOOLS/pset ./frfread.par ranom="$RA"
$FTOOLS/pset ./frfread.par decnom="$DEC"
####################################
# calculate galactic coordinates
####################################
Lii="$($STOOLS/ecl2gal $RA $DEC | awk '{print $1}')"
Bii="$($STOOLS/ecl2gal $RA $DEC | awk '{print $2}')"
echo "$SH_VER:CO:Computed Galactic Lii = $Lii" >> $JOB
echo "$SH_VER:CO:Computed Galactic Bii = $Bii" >> $JOB
#######################################
# read euler angles from attitude.par
#######################################
Euler1="$($FTOOLS/pget ./attitude.par euler1)"
Euler2="$($FTOOLS/pget ./attitude.par euler2)"
Euler3="$($FTOOLS/pget ./attitude.par euler3)"
########################################################
# remove merged attitude file unless this is a test run
########################################################
if [ $"TEST_RUN" != "true" ]
then
rm -f ${ADSE}a.att
fi
###############################################################################
# Create .frffiles
###############################################################################
echo "$SH_VER:TM:Create FRFREAD .frffiles file at $SECONDS" >> $JOB
echo "frf_directory,s,h,\"./\",,,\"frf directory\"" > .frffiles
###########################################
# list each telemetry file into .frffiles
###########################################
for tel in $(awk '{print $1}' job.par.info); do
echo "frf_file,s,h,\"$tel\",,,\"frf telemetry file\"" >> .frffiles
done
#
############################################################################
##########################################################################
##
## Run frfread
##
## FRF stands for "First Reduction File"
##
## This splits one big telemetry file into lots of little ones,
## A housekeeping (HK) file is produced for each instrument.
## An event file containing photon data is produced for each instrument
## and with a new file created each time the spacecraft changes mode
##
## File naming conventions:
##
## Base FRF telemetry file: ft*.* where the *.* varation is given by:
## yymmdd_hhmm.hhmm (start date, start time, end time)
##
## Modally split telemetry FRFREAD "raw" event files. The first * in each
## name stands for yymmdd_hhmm_hhmm . The second * stands for the 6 digit
## modal configuration sequence.
##
## ft*G2*[LMH].fits -- [LMH] bit rate GIS2 FRFREAD "raw" event files
## ft*G3*[LMH].fits -- [LMH] bit rate GIS3 FRFREAD "raw" event files
## ft*S0*[LMH].fits -- [LMH] bit rate SIS0 FRFREAD "raw" event files
## ft*S1*[LMH].fits -- [LMH] bit rate SIS1 FRFREAD "raw" event files
##
## Housekeepping and associated files. The * stands for yymmdd_hhmm_hhmm .
##
## ft*G2HK.fits -- GIS2 house keeping file
## ft*G3HK.fits -- GIS3 house keeping file
## ft*S0HK.fits -- SIS0 house keeping file
## ft*S1HK.fits -- SIS1 house keeping file
## ft*CMHK.fits -- common house keeping file
##
##########################################################################
##########################################################################
echo "$SH_VER:TM:Start $FRFREAD at $SECONDS" >> $JOB
$FRFREAD >> $JOB 2> log.tmp
####################
# check for errors
####################
if [ $? -ne 0 ]; then
echo "$SH_VER:E1:FRFREAD returned non-zero exit status!" >> $JOB
cat log.tmp >> $JOB
echo "$SH_VER:E1:FRFREAD returned non-zero exit status!"
shexit 1
fi
##############################################################
# check if there is more than one line with "^coordinate"
# in the output from frfread
# report results to log file
#############################################################
egrep '^coordinate' log.tmp > log1.tmp
if [ $(wc -l < log1.tmp) -gt 0 ]; then
echo "$SH_VER:E1:STDERR output from frfreadng $LINENO" >> $JOB
cat log1.tmp >> $JOB
echo "$SH_VER:E0:STDERR output from frfreadng $LINENO" >> $JOB
fi
rm -f log1.tmp
#################################################
# check for lines without "^coordinate" in them
# these are errors
##################################################
egrep -v '^coordinate' log.tmp > log2.tmp
errchk log2.tmp "frfreadng $LINENO" frfread.par .frffiles
rm -f log.tmp
############################################################
# loop through files in working directory which start with
# ft, end with .fits and don't have HK in them
# these are all the files containing photon data
# remove all the files which have no events
#############################################################
for file in $(ls | egrep '^ft.*\.fits$' | grep -v HK); do
if [ $($STOOLS/getnevents < $file) -eq 0 ]; then
echo "$SH_VER:E1:$file dropped with 0 events" >> $JOB
rm $file
fi
done
####################################################################
# list the remaining files starting with ^ft and ending in .fits
# (telemetry files and housekeeping files)
# into the file RAW_FRF.list
###################################################################
ls | egrep '^ft.*\.fits$' > RAW_FRF.list
###############################################
# don't need frfread.par or .frffiles any more
##############################################
rm -f frfread.par .frffiles
#
###############################################################################
###############################################################################
##
## build SIS rate files from the HK (housekeeping) files
##
## SIS rate files are called ad[sequence #]S[0/1].rate
## after these two files are created, they are moved to directory
## $SIS_RATE_STAGE
##
## The steps in making the rate files are:
## 1) merge all HK files
## 2) expand them with hkexpand
## 3) set saturation flags for the CCDS
##
## Temporary files:
## S[0/1]hk.fits
## S[0/1]hk.telem
##
## The following code was translated into bash/ksh from a csh script written
## by Keith Gendreau and Eric Gothelf (hkfixer)
############################################################################
#########################################
# loop over the SIS0 and SIS1 HK files
########################################
for inst in S0 S1
do
echo "$SH_VER:TM:Begin $inst rate file create at $SECONDS" >> $JOB
###################################################
# count the number of HK files for this intrument
###################################################
ls *${inst}HK.fits > ./${inst}hk.list
num_hk_files=$(echo ./${inst}hk.list | wc -l)
#####################################################
# if no HK files found for this SIS do not continue
#####################################################
if [ $num_hk_files -eq 0 ]
then
echo "$SH_VER:L0: no HK files found for ${inst}" >> $JOB
echo "$SH_VER:L0: cannot make ${inst} rate file" >> $JOB
continue
fi
################################################################
# if more than 1 HK file is found for this SIS then merge them
# the merged file is called [s0/s1]hk.fits
################################################################
if [ $num_hk_files -gt 1 ]
then
fmerge @${inst}hk.list ${inst}hk.fits - clobber=yes
else
cp $(cat ${inst}hk.list) ${inst}hk.fits
fi
############################################################
# figure out which CCDs are involved in the merged HK file
# store list of CCDs in list
# (fdump makes an ascii dump of a fits file)
############################################################
$FTOOLS/fdump ${inst}hk.fits outfile=./hk.dmp columns="NAME" rows=- prhead=no showunit=no showrow=no
list=$(cat hk.dmp | grep '_SATF' | sort | uniq | sed "s/${inst}_SATF//g")
rm -f ./hk.dmp
###########################################################################
# make wordlist file for hkexpand - this tells which keywords to copy over
###########################################################################
echo ${inst}_BRATE > ./wordlist
echo ${inst}_MODE >> ./wordlist
echo ${inst}_ARENA >> ./wordlist
##########################################################################
# we only add the following keywords to the wordlist if the corresponding
# CCD is listed in the HK file
##########################################################################
for i in $list
do
echo "$SH_VER:L0: CCD $i in use for ${inst}" >> $JOB
echo ${inst}'_TELM'$i >> ./wordlist
echo ${inst}'_LRWX'$i >> ./wordlist
echo ${inst}'_LRWY'$i >> ./wordlist
done
#######################################################################
# make an expanded HK file for the columns in 'wordlist'
# The expanded file is called [s0/s1]hk.telem
#
# compressed HK format is three collumns: TIME PARAMETER_NAME VALUE
# uncompressed format has one collumn for each parameter
#######################################################################
rm -f ${inst}hk.telem
$FTOOLS/hkexpand ${inst}hk.fits ${inst}hk.telem "@wordlist" mode=h >> $JOB 2> log.tmp
errchk log.tmp "HKEXPAND $LINENO"
####################################################################
# There is an error in the original HK file - let's fix it now.
#
# The telemetry is SATURATED if the number of telemetried events
# equals the telemetry limit:
#
# SIS MODE DATA MODE BIT RATE TELEMETRY LIMIT
#
# 4 CCD BRIGHT LOW 32
# MEDIUM 128 BRIGHT = 1
# HIGH 1024 FAINT = 2
#
# FAINT LOW 8 LOW = 1
# MEDIUM 32 MEDIUM = 2
# HIGH 256 FAINT = 4
#
#
# Then Sn_SATm is set to TRUE
# n=[0/1] for SIS0 or SIS1
# m= CCD number
########################################################################
rm -f ./out1.tmp
rm -f ./out2.tmp
old=./out1.tmp
new=./out2.tmp
cp ${inst}hk.telem ./out1.tmp
#################################################
# loop over all CCDs used in the merged HK file
#################################################
for c in $list
do
############################################################################
# In the following statement, expr is set to:
#
# (S[0/1]_BRATE.eq.1 .and. S[0/1]_MODE.eq.2 .and. S[0/1]_TELM${c}.ne.32 ).or.
# (S[0/1]_BRATE.eq.2 .and. S[0/1]_MODE.eq.2 .and. S[0/1]_TELM${c}.ne.128 ).or.
# (S[0/1]_BRATE.eq.4 .and. S[0/1]_MODE.eq.2 .and. S[0/1]_TELM${c}.ne.1024).or.
# (S[0/1]_BRATE.eq.1 .and. S[0/1]_MODE.eq.1 .and. S[0/1]_TELM${c}.ne.8 ).or.
# (S[0/1]_BRATE.eq.2 .and. S[0/1]_MODE.eq.1 .and. S[0/1]_TELM${c}.ne.32 ).or.
# (S[0/1]_BRATE.eq.4 .and. S[0/1]_MODE.eq.1 .and. S[0/1]_TELM${c}.ne.256 )
#
# fcalc evaluates this expression and sets S[0/1]_SAT[CCD number] equal to
# the result
#
#############################################################################
expr="(${inst}_BRATE.eq.1.and.${inst}_MODE.eq.2.and.${inst}_TELM${c}.ne.32).or.(${inst}_BRATE.eq.2.and.${inst}_MODE.eq.2.and.${inst}_TELM${c}.ne.128).or.(${inst}_BRATE.eq.4.and.${inst}_MODE.eq.2.and.${inst}_TELM${c}.ne.1024).or.(${inst}_BRATE.eq.1.and.${inst}_MODE.eq.1.and.${inst}_TELM${c}.ne.8).or.(${inst}_BRATE.eq.2.and.${inst}_MODE.eq.1.and.${inst}_TELM${c}.ne.32).or.(${inst}_BRATE.eq.4.and.${inst}_MODE.eq.1.and.${inst}_TELM${c}.ne.256)"
fcalc $old $new ${inst}_SAT${c} "$expr" >> $JOB 2> log.tmp
errchk log.tmp "FCALC $LINENO"
######################################
# swap pointers to old and new files
######################################
tmp=$old
old=$new
new=$tmp
##############################################
#clear out the new file to recieve more input
##############################################
rm -f $new
done
###################################################################
# rename the resulting file to its true product name if it exists
###################################################################
if [ -r $old ]
then
###################################
# file $old exists and is readable
# copy it to ad[SEQ #]S[0/1].rate
###################################
mv $old ./'ad'$SEQUENCE${inst}'.rate'
else
################################
# error: file $old doesn't exist
################################
echo "$SH_VER:E1: rate files for instrument ${inst} not created" >> $JOB
fi
##########
# cleanup
##########
rm -f out1.tmp out2.tmp wordlist ${inst}hk.fits ${inst}hk.telem
rm -f ${inst}hk.list
done
#
###############################################################################
###############################################################################
##
## Run temp2gain
## this takes the telemetry files (unsplit FRF file)
## and calculates instrument sensitivity as a function of time and temperature.
##
## the resulting "gain history files" are named after the original
## telemetry files but with punctuation removed and .ghf appended
##
## the .tbl file is the gain history file in ascii format
##
###############################################################################
###############################################################################
echo "$SH_VER:TM:Begin GIS gain history create at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $ISASBIN/temp2gain.par > temp2gain.par
$FTOOLS/pset ./temp2gain.par histfile="$GAINHISTCAL"
###############################
# loop through telemetry files
###############################
for tel in $(awk '{print $1}' job.par.info); do
#################################################################
# ghf_fname is telemetry file name with all .'s and _'s removed
# and .ghf appended
###############################################################
ghf_fname="$(echo $tel | tr '.' '_').ghf"
echo "$SH_VER:LO:Create $ghf_fname" >> $JOB
$FTOOLS/pset ./temp2gain.par frffile="$tel"
$FTOOLS/pset ./temp2gain.par outfile="$ghf_fname"
$FTOOLS/pset ./temp2gain.par tblfile="$tel.tbl"
$FTOOLS/pset ./temp2gain.par type=0
$FTOOLS/pset ./temp2gain.par steptime=600
#############################
# run temp2gain
#############################
$ISASBIN/temp2gain > temp2gain.log 2> log1.tmp
#########################
# check for errors
########################
grep "Error|Warning" log1.tmp > log.tmp
grep -v "Error|Warning" log1.tmp >> $JOB
rm log1.tmp
errchk log.tmp "TEMP2GAIN $LINENO" temp2gain.par
################################################
# dump any messages from temp2gain to log file
################################################
if [ $(wc -l < temp2gain.log) -gt 0 ]; then
echo "$SH_VER:L2:STDOUT output from temp2gain $LINENO" >> $JOB
echo "$SH_VER:LO:File is $tel" >> $JOB
cat temp2gain.log >> $JOB
echo "$SH_VER:L0:STDOUT output from temp2gain $LINENO" >> $JOB
fi
rm temp2gain.log
###########################################
# check if ghf file is still time ordered
##########################################
check_time_order $ghf_fname[1] CAL_START yes
check_time_order $ghf_fname[1] CAL_STOP yes
######################################
# tell the ghf files their names
#####################################
add_fits_keyword $ghf_fname[0] FNAME $ghf_fname
add_fits_keyword $ghf_fname[1] FNAME $ghf_fname
done
rm -f temp2gain.par
#
###############################################################################
# Run mkfilter2
# produces filter file used by xselect
# uses HK files, frf.orbit, $RIGID=rigidity.data[version], frf.orbit, and
# attitude file to do this.
#
# 9/8/95 rigidity.data lives in /aps/calibration
#
# output files are named after telemetry files with punctuation
# removed and .mkf appended
###############################################################################
echo "$SH_VER:TM:Begin MKFILTER2 at $SECONDS" >> $JOB
cp $LEAPTABLE ./${LEAPTABLE##/*/}
############################
# loop over attitude files
############################
for tel in $(awk '{print $1}' job.par.info); do
echo "$SH_VER:LO:Run mkfilter2 on $tel" >> $JOB
##############################################
# get name of attitude file from job.par.info
###############################################
att="$(grep $tel job.par.info | awk '{print $3}')"
########################################################
# base is telemetry file name with punctuation removed
########################################################
base="$(echo $tel | tr '.' '_')"
sed -e 's/,a,/,h,/' $ISASBIN/mkfilter2.par > mkfilter2.par
$FTOOLS/pset ./mkfilter2.par s0_hk=${base}S0HK.fits
$FTOOLS/pset ./mkfilter2.par s1_hk=${base}S1HK.fits
$FTOOLS/pset ./mkfilter2.par g2_hk=${base}G2HK.fits
$FTOOLS/pset ./mkfilter2.par g3_hk=${base}G3HK.fits
$FTOOLS/pset ./mkfilter2.par rigidity=$RIGID
$FTOOLS/pset ./mkfilter2.par orbit=frf.orbit
$FTOOLS/pset ./mkfilter2.par leapsec=./${LEAPTABLE##/*/}
$FTOOLS/pset ./mkfilter2.par attitude=$att
$FTOOLS/pset ./mkfilter2.par euler="$Euler1 $Euler2 $Euler3"
$FTOOLS/pset ./mkfilter2.par binwidth=32
$FTOOLS/pset ./mkfilter2.par outfile=$base.mkf
$FTOOLS/pset ./mkfilter2.par clobber=yes
##################
# run mkfilter2
##################
$ISASBIN/mkfilter2 >> $JOB 2> log.tmp
errchk log.tmp "MKFILTER2 $LINENO" mkfilter2.par
#####################################
# check if mkf file is time ordered
# if not, fix it
####################################
check_time_order $base.mkf[1] TIME yes
if [ $? -eq 2 ]; then
fits_mem_sort $base.mkf[1] TIME
fi
done
##########################
# done with mkfilter2.par
#########################
rm -f mkfilter2.par
###############################################################################
# Run mkdtime to fill the deadtime columns in .mkf files
###############################################################################
echo "$SH_VER:TM:Begin MKDTIME at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/mkdtime.par > mkdtime.par
$FTOOLS/pset ./mkdtime.par outfile=NONE
##########################
# loop through .mkf files
##########################
for file in $(ls | egrep '\.mkf$'); do
$FTOOLS/pset ./mkdtime.par infile="$file"
$FTOOLS/mkdtime >> $JOB 2> log.tmp
errchk log.tmp "mkdtime $LINENO" mkdtime.par
done
rm -f mkdtime.par
#
#############################################################################
#############################################################################
##
## begin ASCALIN runs on GIS files
##
##############################################################################
##############################################################################
echo "$SH_VER:TM:Start ASCALIN/GIS at $SECONDS" >> $JOB
######################################################
# create ascalin.fail.list and ascalin.ok.list files
######################################################
touch ascalin.fail.list
touch ascalin.ok.list
###############################################################
# copy $G[2/3][ON/OFF][POW/FLF]MAP files to working directory
# These are the telescope definition files (calfiles)
# 9/8/95 these reside in /aps/calibration
# and are called gas[2/3]_ano_[off/on]_[flf/pow2].fits
###############################################################
cp $G2ONPOWMAP ./${G2ONPOWMAP##/*/}
cp $G2OFFPOWMAP ./${G2OFFPOWMAP##/*/}
cp $G2ONFLFMAP ./${G2ONFLFMAP##/*/}
cp $G2OFFFLFMAP ./${G2OFFFLFMAP##/*/}
cp $G3ONPOWMAP ./${G3ONPOWMAP##/*/}
cp $G3OFFPOWMAP ./${G3OFFPOWMAP##/*/}
cp $G3ONFLFMAP ./${G3ONFLFMAP##/*/}
cp $G3OFFFLFMAP ./${G3OFFFLFMAP##/*/}
####################
# set up ascalin.par
####################
sed -e 's/,a,/,h,/' $FTOOLS/ascalin.par > ascalin.par
$FTOOLS/pset ./ascalin.par history=yes
$FTOOLS/pset ./ascalin.par ranom="$RA"
$FTOOLS/pset ./ascalin.par decnom="$DEC"
$FTOOLS/pset ./ascalin.par verbose=no
#############################################################
# loop over all event files (modaly split) which have
# mode number "70" (GIS PH mode)
############################################################
for CURRENT_FITS in $(ls | egrep '70[HML]\.fits$' | sort); do
add_fits_keyword "$CURRENT_FITS[0]" COORDPRO ERROR
######################################################
# read POS_DET (position determination method) equals FLF or POW2
# and ANO_TUNE
# from current event file
######################################################
get_fits_keyword "$CURRENT_FITS[0]" POS_DET
POS_DET="$get_fits_keyword_value"
get_fits_keyword "$CURRENT_FITS[0]" ANO_TUNE
ANO_TUNE="$get_fits_keyword_value"
###########################################################################
# determine which Telescope Definition to use (i.e. set calfile parameter)
#
###########################################################################
case $CURRENT_FITS in
*G2*) case $POS_DET in
###################
# GIS2 files
###################
*POW*) case $ANO_TUNE in
*ON*) $FTOOLS/pset ./ascalin.par calfile="${G2ONPOWMAP##/*/}"
echo "${G2ONPOWMAP##/*/}" >> gis2_cal_files_used ;;
* ) $FTOOLS/pset ./ascalin.par calfile="${G2OFFPOWMAP##/*/}"
echo "${G2OFFPOWMAP##/*/}" >> gis2_cal_files_used ;;
esac ;;
*FLF*) case $ANO_TUNE in
*ON*) $FTOOLS/pset ./ascalin.par calfile="${G2ONFLFMAP##/*/}"
echo "${G2ONFLFMAP##/*/}" >> gis2_cal_files_used ;;
* ) $FTOOLS/pset ./ascalin.par calfile="${G2OFFFLFMAP##/*/}"
echo "${G2OFFFLFMAP##/*/}" >> gis2_cal_files_used ;;
esac ;;
* ) echo "Unknown POS_DET=$POS_DET for $CURRENT_FITS" >> $JOB
echo "File skipped" >> $JOB
echo $CURRENT_FITS >> ascalin.fail.list
continue ;;
esac ;;
*G3*) case $POS_DET in
###################
# GIS2 files
###################
*POW*) case $ANO_TUNE in
*ON*) $FTOOLS/pset ./ascalin.par calfile="${G3ONPOWMAP##/*/}"
echo "${G3ONPOWMAP##/*/}" >> gis3_cal_files_used ;;
* ) $FTOOLS/pset ./ascalin.par calfile="${G3OFFPOWMAP##/*/}"
echo "${G3OFFPOWMAP##/*/}" >> gis3_cal_files_used ;;
esac ;;
*FLF*) case $ANO_TUNE in
*ON*) $FTOOLS/pset ./ascalin.par calfile="${G3ONFLFMAP##/*/}"
echo "${G3ONFLFMAP##/*/}" >> gis3_cal_files_used ;;
* ) $FTOOLS/pset ./ascalin.par calfile="${G3OFFFLFMAP##/*/}"
echo "${G3OFFFLFMAP##/*/}" >> gis3_cal_files_used ;;
esac ;;
* ) echo "Unknown POS_DET=$POS_DET for $CURRENT_FITS" >> $JOB
echo "File skipped" >> $JOB
echo $CURRENT_FITS >> ascalin.fail.list
continue ;;
esac ;;
esac
#########################################
# read TLM_FILE keyword
#########################################
get_fits_keyword "$CURRENT_FITS[0]" TLM_FILE
export TLM_FILE="$(echo "$get_fits_keyword_value" | tr -d \')"
################################################
# set tempofile = Temporal history file
# better known as the gain history file (.ghf)
#################################################
$FTOOLS/pset ./ascalin.par tempofile="$(echo ${TLM_FILE} | tr '.' '_').ghf"
########################################################################
# check if $TLM_FILE is in job.par.info and get
# name of corresponding attitude file
#
# If possible set pointing=USER and attitude to correct attitude file
# in order to use correct attitude file for pointing information
# Otherwise, set pointing=EULER and attitude=euler
# in order to use euler angles for pointing information.
# If possible, the Euler angles are taken from job.par.info,
# otherewise, they are just set to zero
##################################################################
attitude="$(grep $TLM_FILE job.par.info | awk '{print $3}')"
if [ -n "$attitude" -a -s "$attitude" ]; then
#####################################################################
# $TLM_FILE is in job.par.info
# since attitude is defined and points to an existing non-empty file
#####################################################################
$FTOOLS/pset ./ascalin.par attitude="$attitude"
$FTOOLS/pset ./ascalin.par pointing=USER
else
#############################################
# use euler angles from job.par.info instead
#############################################
$FTOOLS/pset ./ascalin.par attitude=euler
$FTOOLS/pset ./ascalin.par pointing=EULER
###################################################
# get corresponding euler angles from job.par.info
###################################################
export EULER1="$(grep $TLM_FILE job.par.info | awk '{print $5}')"
export EULER2="$(grep $TLM_FILE job.par.info | awk '{print $6}')"
export EULER3="$(grep $TLM_FILE job.par.info | awk '{print $7}')"
if [ -z "$EULER1" ]; then
#############################################
# can't get euler angles from job.par.info
############################################
$FTOOLS/pset ./ascalin.par eulerphi=0.0
$FTOOLS/pset ./ascalin.par eulertheta=0.0
$FTOOLS/pset ./ascalin.par eulerpsi=0.0
else
##################################
# use euler angles in ascalin.par
##################################
$FTOOLS/pset ./ascalin.par eulerphi="$EULER1"
$FTOOLS/pset ./ascalin.par eulertheta="$EULER2"
$FTOOLS/pset ./ascalin.par eulerpsi="$EULER3"
fi
fi
########################################################
# set datafile to the current modally split event file
########################################################
$FTOOLS/pset ./ascalin.par datafile="$CURRENT_FITS"
################################
# run ascalin
################################
$FTOOLS/ascalin > ascalin.log 2> log.tmp
######################
# check for errors
######################
cp log.tmp log1.tmp
errchk log1.tmp "ascalin $LINENO" ascalin.par
#######################################
# was ascalin terminated prematurely?
#######################################
log_lines="$(grep "Program terminated prematurely" log.tmp | wc -l)"
if [ "$log_lines" -gt 0 ]; then
echo $CURRENT_FITS >> ascalin.fail.list
else
echo $CURRENT_FITS >> ascalin.ok.list
fi
###################################################
# report what there is to report to the log file
###################################################
if [ $(sed -n -e '2,$p' < ascalin.log | wc -l) -gt 0 ]; then
echo "$SH_VER:L2:STDOUT output from ascalin $LINENO" >> $JOB
echo "$SH_VER:LO:File is $CURRENT_FITS" >> $JOB
cat ascalin.log >> $JOB
echo "$SH_VER:L0:STDOUT output from ascalin $LINENO" >> $JOB
fi
rm ascalin.log
done
#########################################
# remove unused gis calibration files
#########################################
if [ -z "$(grep ${G2ONPOWMAP##/*/} gis2_cal_files_used)" ]
then
rm -f ${G2ONPOWMAP##/*/}
fi
################################################################
if [ -z "$(grep ${G2OFFPOWMAP##/*/} gis2_cal_files_used)" ]
then
rm -f ${G2OFFPOWMAP##/*/}
fi
################################################################
if [ -z "$(grep ${G2ONFLFMAP##/*/} gis2_cal_files_used)" ]
then
rm -f ${G2ONFLFMAP##/*/}
fi
################################################################
if [ -z "$(grep ${G2OFFFLFMAP##/*/} gis2_cal_files_used)" ]
then
rm -f ${G2OFFFLFMAP##/*/}
fi
################################################################
if [ -z "$(grep ${G3ONPOWMAP##/*/} gis3_cal_files_used)" ]
then
rm -f ${G3ONPOWMAP##/*/}
fi
################################################################
if [ -z "$(grep ${G3OFFPOWMAP##/*/} gis3_cal_files_used)" ]
then
rm -f ${G3OFFPOWMAP##/*/}
fi
################################################################
if [ -z "$(grep ${G3ONFLFMAP##/*/} gis3_cal_files_used)" ]
then
rm -f ${G3ONFLFMAP##/*/}
fi
################################################################
if [ -z "$(grep ${G3OFFFLFMAP##/*/} gis3_cal_files_used)" ]
then
rm -f ${G3OFFFLFMAP##/*/}
fi
###################
# remove par files
####################
rm -f ascalin.par
###############################################################################
###############################################################################
##
## begin ASCALIN runs on SIS files
##
###############################################################################
###############################################################################
echo "$SH_VER:TM:Start ASCALIN/SIS at $SECONDS" >> $JOB
######################################################################
# copy telescope definition file (calfile) to working directory
# these live in /aps/callibration
#######################################################################
cp $S0MAP ${S0MAP##/*/}
cp $S1MAP ${S1MAP##/*/}
######################
# prepare ascalin.par
######################
sed -e 's/,a,/,h,/' $FTOOLS/ascalin.par > ascalin.par
$FTOOLS/pset ./ascalin.par history=yes
$FTOOLS/pset ./ascalin.par ranom="$RA"
$FTOOLS/pset ./ascalin.par decnom="$DEC"
$FTOOLS/pset ./ascalin.par verbose=no
###########################
# loop through fits files
###########################
for CURRENT_FITS in $(ls | egrep '0[12][HML]\.fits$' | sort); do
add_fits_keyword "$CURRENT_FITS[0]" COORDPRO ERROR
#######################################################################
# choose correct telescope definition file (calfile) for SIS0 or SIS1
#######################################################################
case $CURRENT_FITS in
*S0*) $FTOOLS/pset ./ascalin.par calfile="${S0MAP##/*/}" ;;
*S1*) $FTOOLS/pset ./ascalin.par calfile="${S1MAP##/*/}" ;;
* ) echo "Unknown instrument FITS file $CURRENT_FITS" >> $JOB
echo "File skipped" >> $JOB
continue ;;
esac
$FTOOLS/pset ./ascalin.par tempofile="$REFDATA/$SISPICAL"
#########################################################################
# get TLM_FILE keyword from fits file
# this is parent frf telemetry file name from modally split event file
########################################################################
get_fits_keyword "$CURRENT_FITS[0]" TLM_FILE
export TLM_FILE="$(echo "$get_fits_keyword_value" | tr -d \')"
##############################################################
# try to get corresponding attitude file from job.par.info
##############################################################
attitude="$(grep $TLM_FILE job.par.info | awk '{print $3}')"
if [ -n "$attitude" -a -s "$attitude" ]; then
##################################################
# sucessfully got attutude file from job.par.info
##################################################
$FTOOLS/pset ./ascalin.par pointing=USER
$FTOOLS/pset ./ascalin.par attitude="$attitude"
else
##############################################
# use euler angles from job.par.info instead
#############################################
$FTOOLS/pset ./ascalin.par attitude=euler
$FTOOLS/pset ./ascalin.par pointing=EULER
export EULER1="$(grep $TLM_FILE job.par.info | awk '{print $5}')"
export EULER2="$(grep $TLM_FILE job.par.info | awk '{print $6}')"
export EULER3="$(grep $TLM_FILE job.par.info | awk '{print $7}')"
if [ -z "$EULER1" ]; then
##################################################
# couldn't get euler angles, so set them to zero
##################################################
$FTOOLS/pset ./ascalin.par eulerphi=0.0
$FTOOLS/pset ./ascalin.par eulertheta=0.0
$FTOOLS/pset ./ascalin.par eulerpsi=0.0
else
$FTOOLS/pset ./ascalin.par eulerphi="$EULER1"
$FTOOLS/pset ./ascalin.par eulertheta="$EULER2"
$FTOOLS/pset ./ascalin.par eulerpsi="$EULER3"
fi
fi
####################################################################
# set datafile in ascalin.par to current modally split event file
####################################################################
$FTOOLS/pset ./ascalin.par datafile="$CURRENT_FITS"
####################
# run ascalin
####################
$FTOOLS/ascalin > ascalin.log 2> log.tmp
#####################
# check for errors
#####################
cp log.tmp log1.tmp
errchk log1.tmp "ascalin $LINENO" ascalin.par
###########################################
# check if ascalin terminated prematurely
##########################################
log_lines="$(grep "Program terminated prematurely" log.tmp | wc -l)"
if [ "$log_lines" -gt 0 ]; then
echo $CURRENT_FITS >> ascalin.fail.list
else
echo $CURRENT_FITS >> ascalin.ok.list
fi
##############################################
# report what there is to report to log file
###############################################
if [ $(sed -n -e '2,$p' > $JOB
echo "$SH_VER:LO:File is $CURRENT_FITS" >> $JOB
cat ascalin.log >> $JOB
echo "$SH_VER:L0:STDOUT output from ascalin $LINENO" >> $JOB
fi
##########################
# done with ascalin.log
##########################
rm ascalin.log
done
rm -f ascalin.par
###########################################
# report ascalin failures to log file
##########################################
if [ -s ascalin.fail.list ]; then
echo "$SH_VER:LO:BEGIN ascalin.fail.list:" >> $JOB
cat ascalin.fail.list >> $JOB
echo "$SH_VER:LO:END of ascalin.fail.list" >> $JOB
fi
#
###############################################################################
###############################################################################
##
## Run gis3bitfix on ascalin-corrected GIS files if the observation time falls
## between Feb 10 and Apr 8 1994; this is to correct an on-board spacecraft
## related problem.
##
## uses calibration files, gain history file and attitude file(s)
## in order to fix modally split event files for the GIS3 with mode
## number ending in "70" (PH mode)
##
#############################################################################
#############################################################################
echo "$SH_VER:TM:Begin gis3bitfix at $SECONDS" >> $JOB
typeset -i filedate
#########################################################################
# loop over all event (telemetry) files listed in the job.par.info file
#########################################################################
for file in $(awk '{print $1}' < job.par.info); do
name=${file#ft}
filedate=${name%_*}
###############################################################
# if the obs time is not in the proper interval then ignore it
###############################################################
if [ $filedate -lt 940210 -o 940408 -lt $filedate ]; then
continue
fi
######################################################################
# from here to end of loop only executed if the date is in the range
# were a fix needs to be done
######################################################################
############################
# set the attitude file name
############################
attfile="$(grep $file job.par.info | awk '{print $3}')"
####################################
# set the gis3bitfix list name
#################################
evtlist=gis3bitfix.list
##########################################################################
# set the base name for all the event files to be processed by gis3bitfix
##########################################################################
base=${file%?????}_${file#??????????????}
###########################################################################
# process all GIS3 event files of mode number 70 (GIS PH mode)
# that are part of the appropriate
# base name
###########################################################################
for j in $(ls ${base}G3???70[HML].fits)
do
ls $j > gis3bitfix.list
timfile="$base.ghf"
###########################################################################
# see what method was used to determine S/C position for this event file and
# choose the appropriate calibration file for that method
############################################################################
get_fits_keyword "$j[0]" POS_DET
if [ -n "$(echo $get_fits_keyword_value | grep 'FLF')" ]
then
#########################
# POS_DET contains "FLF"
########################
calfile=$REFDATA/$GIS3BFCAL_FLF
echo "$SH_VER:LO:using FLF cal file for $j" >> $JOB
else
##################################
# POS_DET does not contain 'FLF"
#################################
if [ -n "$(echo $get_fits_keyword_value | grep 'POW2')" ]
then
calfile=$REFDATA/$GIS3BFCAL_POW2
echo "$SH_VER:LO:using POW2 cal file for $j" >> $JOB
else
calfile=$REFDATA/$GIS3BFCAL_FLF
echo "$SH_VER:LO: Warning: unknown positioning type:" >> $JOB
echo "$SH_VER:LO: using FLF cal file for $j" >> $JOB
fi
fi
####################################
# run gis3bitfix on the event file
####################################
echo "$SH_VER:LO:running gis3bitfix on $j" >> $JOB
$FTOOLS/gis3bitfix.e $evtlist $calfile $timfile $attfile > gis3bitfix.log 2> log.tmp
######################
# check for errors
######################
errchk log.tmp "gis3bitfix $LINENO" gis3bitfix.log gis3bitfix.list
done
done
#######################################################
# copy original frf telemetry files files to file.fix
#######################################################
for file in $(ls | egrep '\.fix$'); do
echo "$SH_VER:LO:mv $file to ${file%.fix}" >> $JOB
mv $file ${file%.fix}
done
#####################
# clean up files
#####################
rm -f gis3bitfix.list
rm -f gis3bitfix.log
#
###############################################################################
#
# Convert SIS FAINT data to BRIGHT for frfread data
#
# takes modally split event files for the SIS with mode code ending in "01"
# and creates correspongoinf files with mode number changed.
#
# when mimicing ASCA onboard conversion mode code => "02"
# when applying dark frame error corrections mode code => "12"
#
################################################################################
echo "$SH_VER:TM:Start FAINT->BRIGHT at $SECONDS" >> $JOB
############################################
# assign SPLIT0 and SPLIT1
# defaults are 40
############################################
SPLIT0=40
SPLIT1=40
########################################################################
# loop through files ending in "02[H/M/L].fits" (split event files)
# (SIS BRIGHT mode)
########################################################################
for CURRENT_FITS in $(ls | egrep '02[HML]\.fits$'); do
###########################
# read S0_SPTRO to SLITP0
###########################
get_fits_keyword "$CURRENT_FITS[0]" S0_SPTR0
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT0="$get_fits_keyword_value"
break
fi
##########################
# read S0_SPTR1 to SPLIT0
##########################
get_fits_keyword "$CURRENT_FITS[0]" S0_SPTR1
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT0="$get_fits_keyword_value"
break
fi
##########################
# read S0_SPTR2 to SPLIT0
##########################
get_fits_keyword "$CURRENT_FITS[0]" S0_SPTR2
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT0="$get_fits_keyword_value"
break
fi
##########################
# read S0_SPTR3 to SPLIT0
##########################
get_fits_keyword "$CURRENT_FITS[0]" S0_SPTR3
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT0="$get_fits_keyword_value"
break
fi
###################################################################
# set SPLIT0 to 40 and break out of loop
###################################################################
SPLIT0=40
break
done
###############################################################################
# loop through files ending in "02[H/M/L].fits" (modally split telemetry files)
###############################################################################
for CURRENT_FITS in $(ls | egrep '02[HML]\.fits$'); do
############################
# read S1_SPTR0 into SPLIT1
############################
get_fits_keyword "$CURRENT_FITS[0]" S1_SPTR0
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT1="$get_fits_keyword_value"
break
fi
############################
# read S1_SPTR1 into SPLIT1
############################
get_fits_keyword "$CURRENT_FITS[0]" S1_SPTR1
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT1="$get_fits_keyword_value"
break
fi
############################
# read S1_SPTR2 into SPLIT1
############################
get_fits_keyword "$CURRENT_FITS[0]" S1_SPTR2
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT1="$get_fits_keyword_value"
break
fi
############################
# read S1_SPTR3 into SPLIT1
############################
get_fits_keyword "$CURRENT_FITS[0]" S1_SPTR3
if [ "$get_fits_keyword_exist" = "yes" ]; then
SPLIT1="$get_fits_keyword_value"
break
fi
##############################################################
# set SPLIT1=40 and break out of loop
###############################################################
SPLIT1=40
break
done
########################################################################
# loop through files ending in "01[H/M/L].fits" (FAINT mode event files)
########################################################################
for infile in $(ls | egrep '01[HML]\.fits$'); do
####################################
# set up faint.par and faintdfe.par
####################################
sed -e 's/,a,/,h,/' $FTOOLS/faint.par > faint.par
sed -e 's/,a,/,h,/' $FTOOLS/faintdfe.par > faintdfe.par
###################
# set outfile
##################
case $infile in
*01H*) outfile="${infile%01H.fits}02H.fits" ;;
*01M*) outfile="${infile%01M.fits}02M.fits" ;;
*01L*) outfile="${infile%01L.fits}02L.fits" ;;
esac
#########################
# set split in faint.par
#########################
case $infile in
*S0*) $FTOOLS/pset ./faint.par split="$SPLIT0" ;;
*S1*) $FTOOLS/pset ./faint.par split="$SPLIT1" ;;
* ) $FTOOLS/pset ./faint.par split=40 ;;
esac
######################################
# set infile and outfile in faint.par
######################################
echo "$SH_VER:LO:Create $outfile" >> $JOB
$FTOOLS/pset ./faint.par infile="$infile[1]"
$FTOOLS/pset ./faint.par outfile="$outfile"
###################################################################
# run ftool faint
# bright=yes means mimic ASCA onboard FAINT to BRIGHT conversion
##################################################################
$FTOOLS/faint bright=yes >> $JOB 2> log.tmp
errchk log.tmp "faint $LINENO" faint.par
##########################################
# drop outfile if it contains no events
#######################################
if [ $($STOOLS/getnevents < $outfile) -eq 0 ]; then
echo "$SH_VER:E1:$outfile dropped with 0 events" >> $JOB
rm $outfile
continue
fi
#################################
# set parameters in faintdfe.par
#################################
$FTOOLS/pset ./faintdfe.par infile="$infile[1]"
$FTOOLS/pset ./faintdfe.par outfile="${infile%.fits}.dfe"
###############################################
# run faintdfe
# dfe stands for dark frame error correction
###############################################
$FTOOLS/faintdfe 2> log.tmp | grep -v nrecords >> $JOB
errchk log.tmp "faintdfe $LINENO" faintdfe.par
#####################################################################
# prepare to run faint again, this time using dfe files
# and again operating on the files with mode code ending in "01"
# this time the resulting files will have mode code ending in "12"
# Here FAINT mode data are converted into BRIGHT2 mode data
# which is corrected for dark frame error and echo effect.
####################################################################
case $infile in
*01H*) outfile="${infile%01H.fits}12H.fits" ;;
*01M*) outfile="${infile%01M.fits}12M.fits" ;;
*01L*) outfile="${infile%01L.fits}12L.fits" ;;
esac
echo "$SH_VER:LO:Create $outfile" >> $JOB
$FTOOLS/pset ./faint.par dfefile="${infile%.fits}.dfe"
$FTOOLS/pset ./faint.par outfile="$outfile"
$FTOOLS/pset ./faint.par maxgrade=6
##############################################################
# run faint again
# this time with bright=no meaning do not mimic ASCA onboard
# faint to bright conversion
##############################################################
$FTOOLS/faint bright=no \ >> $JOB 2> log.tmp
errchk log.tmp "faint $LINENO" faint.par
if [ $($STOOLS/getnevents < $outfile) -eq 0 ]; then
echo "$SH_VER:E1:$outfile dropped with 0 events" >> $JOB
rm $outfile
fi
done
########################
# cleanup files
########################
rm -f faint.par faintdfe.par
################################################
# make a list of .dfe files in s0.dfe and s1.dfe
###############################################
for file in $(ls | egrep '^ft.*\.dfe$'); do
case "$file" in
*S0*) cat "$file" >> s0.dfe ;;
*S1*) cat "$file" >> s1.dfe ;;
* ) echo "$SH_VER:E1:Unrecognized ft*.dfe file $file" >> $JOB ;;
esac
rm "$file"
done
#########################################################################
# if there is anything in the s0 list, sort it, remove duplicate and
# put it into ad[sequence number]_s).dfe
########################################################################
if [ -s s0.dfe ]; then
sort -n s0.dfe | uniq > ${ADSE}_s0.dfe
##########################################
# put a fits header on the .dfe file list
##########################################
fits_wrap_ascii ${ADSE}_s0_dfe.wrap ${ADSE}_s0.dfe
add_fits_keyword ${ADSE}_s0_dfe.wrap[0] FNAME \
${ADSE}_s0_dfe.wrap STRIP${ADSE}_s0.dfe
fi
######################################################
# do all the same things for the SIS1 .dfe file list
######################################################
if [ -s s1.dfe ]; then
sort -n s1.dfe | uniq > ${ADSE}_s1.dfe
fits_wrap_ascii ${ADSE}_s1_dfe.wrap ${ADSE}_s1.dfe
add_fits_keyword ${ADSE}_s1_dfe.wrap[0] FNAME \
${ADSE}_s1_dfe.wrap STRIP${ADSE}_s1.dfe
fi
#############################################################################
# Run dfe2mkf to populate mkfilter columns with dfe information
# dfe means dark frame error
# uses dfe file lists ad[sequence]_s0.dfe made above
############################################################################
echo "$SH_VER:TM:Start DFE2MKF at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/dfe2mkf.par > dfe2mkf.par
#######################################
# loop through al .mkf (filter) files
#######################################
for file in $(ls | egrep '\.mkf$'); do
$FTOOLS/pset ./dfe2mkf.par outfile="$file"
###################
# SIS0
###################
if [ -s ${ADSE}_s0.dfe ]; then
$FTOOLS/pset ./dfe2mkf.par infile="${ADSE}_s0.dfe"
$FTOOLS/pset ./dfe2mkf.par instrument=SIS0
$FTOOLS/dfe2mkf >> $JOB 2> log.tmp
errchk log.tmp "dfe2mkf $LINENO" dfe2mkf.par
fi
#################
# SIS1
#################
if [ -s ${ADSE}_s1.dfe ]; then
$FTOOLS/pset ./dfe2mkf.par infile="${ADSE}_s1.dfe"
$FTOOLS/pset ./dfe2mkf.par instrument=SIS1
$FTOOLS/dfe2mkf >> $JOB 2> log.tmp
errchk log.tmp "dfe2mkf $LINENO" dfe2mkf.par
fi
done
rm -f dfe2mkf.par
#
###############################################################################
# SISPI is used to fill the SIS PI column in the FRF science files.
# works on files with mode code ending in "02" or "12"
# (SIS BRIGHT and BRIGHT2 mode data)
# PI means "Pulse Invariant"
##########################################################################
echo "$SH_VER:TM:Start SIS PI column fill at $SECONDS" >> $JOB
###################################################################
# make a list of SIS files modally split event file
# with mode code ending in "02" or "12"
##################################################################
ls | egrep 'S[01].*[01]2[HML]\.fits$' > sispi.list
#############################
# prepare sispi.par
#############################
sed -e 's/,a,/,h,/' $FTOOLS/sispi.par > sispi.par
$FTOOLS/pset ./sispi.par datafile=@sispi.list
$FTOOLS/pset ./sispi.par calfile="$REFDATA/$SISPICAL"
$FTOOLS/pset ./sispi.par launch=no
$FTOOLS/pset ./sispi.par verbose=yes
$FTOOLS/pset ./sispi.par history=yes
$FTOOLS/pset ./sispi.par gainnom=-99.0
#############################
# run sispi
#############################
$FTOOLS/sispi >> /dev/null 2> log.tmp
########################
# check for errors
########################
grep -i "warning" log.tmp | sort | uniq > log1.tmp
grep -i -v "warning" log.tmp > log2.tmp
if [ $(wc -l < log1.tmp) -gt 0 ]; then
echo "$SH_VER:L2:STDOUT output from SISPI $LINENO" >> $JOB
cat log1.tmp >> $JOB
echo "$SH_VER:L0:STDOUT output from SISPI $LINENO" >> $JOB
fi
rm -f log.tmp log1.tmp
errchk log2.tmp "sispi $LINENO" sispi.par sispi.list
rm -f sispi.par sispi.list
###############################################################################
# update frfread output to point to useful files
# i.e. sets a bunch of FITS keywords which indicate associated files
###############################################################################
echo "$SH_VER:TM:Update .fits with REF keywords at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/fmodhead.par > fmodhead.par
$FTOOLS/pset ./fmodhead.par tmpfil=fmodhead.txt
#########################################################################
# loop through all the event files created by frfread
#########################################################################
for file in $(ls | egrep '[HLM]\.fits$'); do
associated_ihk="${file%??????.fits}HK.fits"
associated_chk="${file%????????.fits}CMHK.fits"
associated_tlm="${file%????????.fits}"
associated_mkf="${associated_tlm}.mkf"
associated_att="${associated_tlm%?????}.${associated_tlm#??????????????}"
associated_att="fa${associated_att#ft}"
associated_orb="frf.orbit"
echo "FNAME $file / File name" > fmodhead.txt
echo "FNIHK $associated_ihk[1] / Instrument HK file" >> fmodhead.txt
echo "FNCHK $associated_chk[1] / Common HK file" >> fmodhead.txt
echo "FNMKF $associated_mkf[1] / MKFILTER file" >> fmodhead.txt
echo "FNATT $associated_att[1] / ATTITUDE file" >> fmodhead.txt
echo "FNORB $associated_orb[1] / ORBIT file" >> fmodhead.txt
echo "FNSGTI $file[2] / STD Good Time Intervals" >> fmodhead.txt
echo "FNAGTI $file[3] / ALL Good Time Intervals" >> fmodhead.txt
echo "SEQNUM $SEQUENCE / Observation sequence number" >> fmodhead.txt
echo "SEQPNUM $PROCEXT / Number of times sequence processed" >> fmodhead.txt
echo "PROCVER $PROC_VER / Processing script version" >> fmodhead.txt
$FTOOLS/fmodhead infile=$file[0] >> $JOB 2> log.tmp
errchk log.tmp "fmodhead $LINENO" fmodhead.par fmodhead.txt
$FTOOLS/fmodhead infile=$file[1] >> $JOB 2> log.tmp
errchk log.tmp "fmodhead $LINENO" fmodhead.par fmodhead.txt
done
#########################################################################
# loop through all the housekeeping files created by frfread
#########################################################################
for file in $(ls | egrep '^ft.*HK\.fits$'); do
echo "FNAME $file / File name" > fmodhead.txt
echo "SEQNUM $SEQUENCE / Sequential number from ODB" >> fmodhead.txt
echo "SEQPNUM $PROCEXT / Number of times sequence processed" >> fmodhead.txt
echo "PROCVER $PROC_VER / Processing script version" >> fmodhead.txt
$FTOOLS/fmodhead infile=$file[0] >> $JOB 2> log.tmp
errchk log.tmp "fmodhead $LINENO" fmodhead.par fmodhead.txt
$FTOOLS/fmodhead infile=$file[1] >> $JOB 2> log.tmp
errchk log.tmp "fmodhead $LINENO" fmodhead.par fmodhead.txt
done
rm -f fmodhead.par fmodhead.txt
#
#############################################################################
###########################################################################
##
## Create modal merge list files
##
###########################################################################
#############################################################################
echo "$SH_VER:TM:Create modal list files at $SECONDS" >> $JOB
#####################################################################
# make a list of telemetry (non-housekeeping) files which got ascalin'ed
# sucessfully
# store list in pure.tmp
#####################################################################
touch pure.tmp
for file in $(ls | egrep '^ft.*\.fits$' | grep -v HK); do
if [ $(grep $file ascalin.fail.list | wc -l) -eq 0 ]; then
echo $file >> pure.tmp
fi
done
###########################################################################
# make gis2_photon_merge_list
# successfully processed (ascalin'ed) telemetry files for the GIS2
# are fed to gissortcode and gissortsplit.
#
# The output of gissortcode has two collumns. The first is a long string
# with lots of detailed information about the spacecraft mode
# the second is the filename from stdin.
#
# gis2_photon_merge_list contains three collumns.
# total_events output_filename long_mode_string
# with one line for each unique mode string derived fron all the ascalin'ed
# GIS2 event files. These are sorted in order of decreasing number of events
#
# output_filename has the format:
# G2[3digit key number][2-digit mode code (e.g.70][h/m/l].prelist
#
# Each of these files contains a list of the original files which had
# the same mode.
#########################################################################
grep G2 pure.tmp | $STOOLS/gissortcode 2>> $JOB | sort | \
$STOOLS/gissortsplit 2>> $JOB | sort -r > gis2_photon_merge_list
typeset -i merge_index_i=1
#####################################################################
# loop through the files in gis2_photon_merge_list
# these are the
# G2[3digit key number][2-digit mode code (e.g.70][h/m/l].prelist
# files which contain list of event filenames for a particular mode
####################################################################
for file in $(awk '{print $2}' gis2_photon_merge_list); do
###########################################
# remove files ending in 71[h/m/l].prelist
###########################################
case $file in
*71[hml]\.prelist)
echo "$SH_VER:E1:Removing $file, MPC mode" >> $JOB
rm -f $file
continue ;;
esac
############################################################
# if you get down to
# files with fewer than $GIS_EVENTS_MIN events,
# then remove the current file and bust out of this loop
############################################################
nevt="$(grep $file gis2_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $GIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $GIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
###########################################################
# set model_config, modal_id
###########################################################
modal_config="$(grep $file gis2_photon_merge_list | awk -F\' '{print $2}')"
modal_id=$(get_modal_id "$modal_config")
###############################################
# format merge_index with three leading zeros
###############################################
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
####################################################################
# rename .prelist file to .modallist
# file gis2_modallist has 3 collumns
# filename number_of_events and modal_id
# where:
# filename catalogs the .modallist files
###################################################################
tmp=${file#?????}
export new_events_name="g2${merge_index}${tmp%prelist}modallist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt $modal_id" >> gis2_modallist
let merge_index_i+=1
done
rm -f gis2_photon_merge_list
##################################################################
# do much the same thing, except this time using gissc and gisss
# and rename .prelist files to .giflist
# the only difference in gissc is that it only prints files with
# bitrate M or H and it records the bitrate as "X"
# gisss exits if it detects a bitrate other than "X" and does not include
# bitrate in the output_filenames it creates.
##################################################################
grep G2 pure.tmp | $STOOLS/gissc 2>> $JOB | sort | \
$STOOLS/gisss 2>> $JOB | sort -r > gis2_photon_merge_list
for file in $(awk '{print $2}' gis2_photon_merge_list); do
###################################################################
# remove files with mode code ending in 71 and .prelist extension
###################################################################
case $file in
*71\.prelist)
echo "$SH_VER:E1:Removing $file, MPC mode" >> $JOB
rm -f $file
continue ;;
esac
#########################################################
# remove files with fewer than $GIS_EVENTS_MIN events
# and bust out of loop
#########################################################
nevt="$(grep $file gis2_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $GIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $GIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
##############################################
# format merge index with three leading zeros
###############################################
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
####################################################################
# rename .prelist file to .giflist
# files are called:
# G2[3digit key number][2-digit mode code (e.g.70].giflist
###################################################################
tmp=${file#?????}
export new_events_name="g2${merge_index}${tmp%prelist}giflist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt" >> gis2_giflist
let merge_index_i+=1
done
rm -f gis2_photon_merge_list
#######################################
# same thing for the GIS 3
#######################################
grep G3 pure.tmp | $STOOLS/gissortcode 2>> $JOB | sort | \
$STOOLS/gissortsplit 2>> $JOB | sort -r > gis3_photon_merge_list
typeset -i merge_index_i=1
for file in $(awk '{print $2}' gis3_photon_merge_list); do
case $file in
*71[hml]\.prelist)
echo "$SH_VER:E1:Removing $file, MPC mode" >> $JOB
rm -f $file
continue ;;
esac
nevt="$(grep $file gis3_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $GIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $GIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
modal_config="$(grep $file gis3_photon_merge_list | awk -F\' '{print $2}')"
modal_id=$(get_modal_id "$modal_config")
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
tmp=${file#?????}
export new_events_name="g3${merge_index}${tmp%prelist}modallist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt $modal_id" >> gis3_modallist
let merge_index_i+=1
done
rm -f gis3_photon_merge_list
grep G3 pure.tmp | $STOOLS/gissc 2>> $JOB | sort | \
$STOOLS/gisss 2>> $JOB | sort -r > gis3_photon_merge_list
for file in $(awk '{print $2}' gis3_photon_merge_list); do
case $file in
*71\.prelist)
echo "$SH_VER:E1:Removing $file, MPC mode" >> $JOB
rm -f $file
continue ;;
esac
nevt="$(grep $file gis3_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $GIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $GIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
tmp=${file#?????}
export new_events_name="g3${merge_index}${tmp%prelist}giflist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt" >> gis3_giflist
let merge_index_i+=1
done
rm -f gis3_photon_merge_list
##############################
# similar for the SIS0
################################
grep S0 pure.tmp | $STOOLS/sis0sortcode 2>> $JOB | sort | \
$STOOLS/sis0sortsplit 2>> $JOB | sort -r > sis0_photon_merge_list
typeset -i merge_index_i=1
for file in $(awk '{print $2}' sis0_photon_merge_list); do
case $file in
*[01]2[hml]\.prelist) ;;
*) echo "$SH_VER:E1:Removing $file, not bright mode" >> $JOB
rm -f $file
continue ;;
esac
nevt="$(grep $file sis0_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $SIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $SIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
modal_config="$(grep $file sis0_photon_merge_list | awk -F\' '{print $2}')"
modal_id=$(get_modal_id "$modal_config")
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
tmp=${file#?????}
export new_events_name="s0${merge_index}${tmp%prelist}modallist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt $modal_id" >> sis0_modallist
let merge_index_i+=1
done
rm -f sis0_photon_merge_list
grep S0 pure.tmp | $STOOLS/sis0sc 2>> $JOB | sort | \
$STOOLS/sis0ss 2>> $JOB | sort -r > sis0_photon_merge_list
for file in $(awk '{print $2}' sis0_photon_merge_list); do
case $file in
*[01]2\.prelist) ;;
*) echo "$SH_VER:E1:Removing $file, not bright mode" >> $JOB
rm -f $file
continue ;;
esac
nevt="$(grep $file sis0_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $SIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $SIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
tmp=${file#?????}
export new_events_name="s0${merge_index}${tmp%prelist}giflist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt" >> sis0_giflist
let merge_index_i+=1
done
rm -f sis0_photon_merge_list
######################
# similar for the SIS1
######################
grep S1 pure.tmp | $STOOLS/sis1sortcode 2>> $JOB | sort | \
$STOOLS/sis1sortsplit 2>> $JOB | sort -r > sis1_photon_merge_list
typeset -i merge_index_i=1
for file in $(awk '{print $2}' sis1_photon_merge_list); do
case $file in
*[01]2[hml]\.prelist) ;;
*) echo "$SH_VER:E1:Removing $file, not bright mode" >> $JOB
rm -f $file
continue ;;
esac
nevt="$(grep $file sis1_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $SIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $SIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
modal_config="$(grep $file sis1_photon_merge_list | awk -F\' '{print $2}')"
modal_id=$(get_modal_id "$modal_config")
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
tmp=${file#?????}
export new_events_name="s1${merge_index}${tmp%prelist}modallist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt $modal_id" >> sis1_modallist
let merge_index_i+=1
done
rm -f sis1_photon_merge_list
grep S1 pure.tmp | $STOOLS/sis1sc 2>> $JOB | sort | \
$STOOLS/sis1ss 2>> $JOB | sort -r > sis1_photon_merge_list
for file in $(awk '{print $2}' sis1_photon_merge_list); do
case $file in
*[01]2\.prelist) ;;
*) echo "$SH_VER:E1:Removing $file, not bright mode" >> $JOB
rm -f $file
continue ;;
esac
nevt="$(grep $file sis1_photon_merge_list | awk '{print $1}')"
if [ $nevt -lt $SIS_EVENTS_MIN ]; then
echo "$SH_VER:E1:Removing $file nevt = $nevt < $SIS_EVENTS_MIN" >> $JOB
rm -f $file
continue
fi
merge_index="$(echo $merge_index_i | nawk '{printf ("%03d", $0)}')"
tmp=${file#?????}
export new_events_name="s1${merge_index}${tmp%prelist}giflist"
mv $file $new_events_name
echo "$SH_VER:LO:Reorder $file to $new_events_name" >> $JOB
echo "$new_events_name $nevt" >> sis1_giflist
let merge_index_i+=1
done
rm -f sis1_photon_merge_list
rm -f pure.tmp
###############################################################################
###############################################################################
##
## Create initial FFILECAT catalogs.
##
## ffilecat takes a bunch of files and lists then along with their
## selected keywords in another fits file
##
## here a .cat fits file is produced for each .modallist and .giflist file
#############################################################################
##############################################################################
echo "$SH_VER:TM:Create initial catalogs at $SECONDS" >> $JOB
cat $GIS_KEYWORDS > gis.keywords
cat $SIS0_KEYWORDS > sis0.keywords
cat $SIS1_KEYWORDS > sis1.keywords
##############################################
# set up parameters for ffilecat.par
###############################################
sed -e 's/,a,/,h,/' $FTOOLS/ffilecat.par > ffilecat.par
$FTOOLS/pset ./ffilecat.par maxlen=1
$FTOOLS/pset ./ffilecat.par minlen=0
$FTOOLS/pset ./ffilecat.par aform=A8
$FTOOLS/pset ./ffilecat.par eform=E9.3E1
$FTOOLS/pset ./ffilecat.par iform=I6
$FTOOLS/pset ./ffilecat.par omit=no
$FTOOLS/pset ./ffilecat.par quiet=yes
$FTOOLS/pset ./ffilecat.par infile=@ffilecat.cat
##############################
# work on GIS2 first
#############################
touch gis2_cat_list
$FTOOLS/pset ./ffilecat.par keywords=@gis.keywords
##########################################
# loop through the GIS2 .modallist files
#########################################
for list in $(ls | egrep 'g2.*\.modallist$'); do
############################################################
# catalog is name of output file for ffilecat
# it is the same as the current .modallist file but with a
# .cat extension instead
###########################################################
catalog="$ADSE${list%.modallist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
###########################
# create ffilecat.cat
###########################
cat /dev/null > ffilecat.cat
###################################
# set modal_id from gis2_modallist
###################################
typeset -i modal_id="$(grep $list gis2_modallist | awk '{printf("%d",$3)}')"
######################################################
# loop over files listed in current .modallist file
#####################################################
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
add_fits_keyword $file[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
###############################################
# set output file to $catalog as defined above
###############################################
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
#############################
# run ffilecat
#############################
$FTOOLS/ffilecat >> $JOB 2> log.tmp
###########################
# check for errors
############################
errchk log.tmp "ffilecat $LINENO" ffilecat.par gis.keywords ffilecat.cat
#############################################
# record name of .cat file in gis2_cat_list
#############################################
echo "$catalog" >> gis2_cat_list
###############################
# set ontime and events
##############################
add_ontimes $list
ontime="$add_ontimes_value"
events="$(grep $list gis2_modallist | awk '{printf("%d",$2)}')"
###############################################
# define various FITS keywords in .cat file
#############################################
add_fits_keyword $catalog[0] ONTIME $ontime "Cat cumlative ONTIME"
add_fits_keyword $catalog[0] NEVENTS $events "Cat cumlative NEVENTS"
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
add_fits_keyword $catalog[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
rm -f gis2_modallist
############################################################
# do something similar for the .giflist files
###########################################################
$FTOOLS/pset ./ffilecat.par keywords=@gis.keywords
##################################
# loop over .giflist files
##################################
for list in $(ls | egrep 'g2.*\.giflist$'); do
catalog="$ADSE${list%.giflist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
cat /dev/null > ffilecat.cat
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
done
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
############################
# run ffilecat
#############################
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par gis.keywords ffilecat.cat
###################################
# list .cat files in gis2_cat_list
###################################
echo "$catalog" >> gis2_cat_list
###########################################
# fill in some FITS keywords in .cat file
##########################################
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
done
rm -f gis2_giflist
################################
# do the same for the gis3
################################
touch gis3_cat_list
$FTOOLS/pset ./ffilecat.par keywords=@gis.keywords
for list in $(ls | egrep 'g3.*\.modallist$'); do
catalog="$ADSE${list%.modallist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
cat /dev/null > ffilecat.cat
typeset -i modal_id="$(grep $list gis3_modallist | awk '{printf("%d",$3)}')"
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
add_fits_keyword $file[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par gis.keywords ffilecat.cat
echo "$catalog" >> gis3_cat_list
add_ontimes $list
ontime="$add_ontimes_value"
events="$(grep $list gis3_modallist | awk '{printf("%d",$2)}')"
add_fits_keyword $catalog[0] ONTIME $ontime "Cat cumlative ONTIME"
add_fits_keyword $catalog[0] NEVENTS $events "Cat cumlative NEVENTS"
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
add_fits_keyword $catalog[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
rm -f gis3_modallist
$FTOOLS/pset ./ffilecat.par keywords=@gis.keywords
for list in $(ls | egrep 'g3.*\.giflist$'); do
catalog="$ADSE${list%.giflist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
cat /dev/null > ffilecat.cat
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
done
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par gis.keywords ffilecat.cat
echo "$catalog" >> gis3_cat_list
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
done
rm -f gis3_giflist
##########################
# do the same for the SIS0
###########################
touch sis0_cat_list
$FTOOLS/pset ./ffilecat.par keywords=@sis0.keywords
for list in $(ls | egrep 's0.*\.modallist$'); do
catalog="$ADSE${list%.modallist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
cat /dev/null > ffilecat.cat
typeset -i modal_id="$(grep $list sis0_modallist | awk '{printf("%d",$3)}')"
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
add_fits_keyword $file[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par sis0.keywords ffilecat.cat
echo "$catalog" >> sis0_cat_list
add_ontimes $list
ontime="$add_ontimes_value"
events="$(grep $list sis0_modallist | awk '{printf("%d",$2)}')"
add_fits_keyword $catalog[0] ONTIME $ontime "Cat cumlative ONTIME"
add_fits_keyword $catalog[0] NEVENTS $events "Cat cumlative NEVENTS"
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
add_fits_keyword $catalog[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
rm -f sis0_modallist
$FTOOLS/pset ./ffilecat.par keywords=@sis0.keywords
for list in $(ls | egrep 's0.*\.giflist$'); do
catalog="$ADSE${list%.giflist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
cat /dev/null > ffilecat.cat
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
done
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par sis0.keywords ffilecat.cat
echo "$catalog" >> sis0_cat_list
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
done
rm -f sis0_giflist
############################
# do the same for the sis1
#############################
touch sis1_cat_list
$FTOOLS/pset ./ffilecat.par keywords=@sis1.keywords
for list in $(ls | egrep 's1.*\.modallist$'); do
catalog="$ADSE${list%.modallist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
cat /dev/null > ffilecat.cat
typeset -i modal_id="$(grep $list sis1_modallist | awk '{printf("%d",$3)}')"
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
add_fits_keyword $file[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par sis0.keywords ffilecat.cat
echo "$catalog" >> sis1_cat_list
add_ontimes $list
ontime="$add_ontimes_value"
events="$(grep $list sis1_modallist | awk '{printf("%d",$2)}')"
add_fits_keyword $catalog[0] ONTIME $ontime "Cat cumlative ONTIME"
add_fits_keyword $catalog[0] NEVENTS $events "Cat cumlative NEVENTS"
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
add_fits_keyword $catalog[1] MODAL_ID "$modal_id" "Modal Configuration ID"
done
rm -f sis1_modallist
$FTOOLS/pset ./ffilecat.par keywords=@sis1.keywords
for list in $(ls | egrep 's1.*\.giflist$'); do
catalog="$ADSE${list%.giflist}.cat"
echo "$SH_VER:LO:Create $catalog" >> $JOB
cat /dev/null > ffilecat.cat
for file in $(cat $list); do
echo "$file[0]" >> ffilecat.cat
done
$FTOOLS/pset ./ffilecat.par outfile="$catalog"
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par sis0.keywords ffilecat.cat
echo "$catalog" >> sis1_cat_list
add_fits_keyword $catalog[1] DATADIR "./"
add_fits_keyword $catalog[1] HKDIR "./"
get_fits_keyword "$(head -1 $list)[0]" INSTRUME
add_fits_keyword $catalog[1] INSTRUME "$get_fits_keyword_value"
get_fits_keyword "$(head -1 $list)[0]" TELESCOP
add_fits_keyword $catalog[1] TELESCOP "$get_fits_keyword_value"
done
rm -f sis1_giflist
rm -f ffilecat.cat ffilecat.par
rm -f gis.keywords sis0.keywords sis1.keywords
#
###############################################################################
###############################################################################
##
## Try to generate GIS products here.
##
## This is done with xselect
##
###############################################################################
###############################################################################
echo "$SH_VER:TM:Start GIS XSELECT on modal at $SECONDS" >> $JOB
xselpar="$(ls $FTOOLS/xsel*.par)"
cp $xselpar ${xselpar##*/}
####################################################################
# loop over .giflist decendant .cat files for the GIS2 and GIS3
# i.e. those listed in gis2_cat_list and gis3_cat_list
####################################################################
for file in $(cat gis2_cat_list gis3_cat_list | awk '{print $1}'); do
###################################
# Don't process mode 71 MPC data.
###################################
case $file in
*71[hml].cat) continue ;;
*71.cat ) continue ;;
esac
######################################
# Determine if 256 or 64 data arrays.
######################################
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
$FTOOLS/pset ./ftabpar.par fitsfile="$file[1]"
$FTOOLS/pset ./ftabpar.par column=RAWXBINS
$FTOOLS/pset ./ftabpar.par row=1
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "FTABPAR $LINENO" ftabpar.par
typeset -i rawxbins="$($FTOOLS/pget ./ftabpar.par value)"
rm ./ftabpar.par
####################################################
# Set local configuration for this specific file.
# determine the region filter to be used by xselect
# and xexpr to select good events
####################################################
echo "(SAA==0)&&(ELV>10)&&(COR>6)" > xexpr
echo "&&(ACS==0)&&(ANG_DIST>0)&&(ANG_DIST<0.01)" >> xexpr
case $file in
*g2*) echo "&&(G2_L1>0)" >> xexpr
case $rawxbins in
64) region=$GIS2_REGION64 ;;
* ) region=$GIS2_REGION256 ;;
esac ;;
*g3*) echo "&&(G3_L1>0)" >> xexpr
case $rawxbins in
64) region=$GIS3_REGION64 ;;
* ) region=$GIS3_REGION256 ;;
esac ;;
* ) echo "$SH_VER:E1:Bad filename, unknown instrument $file" >> $JOB
continue ;;
esac
###############################
# Show the current file status.
###############################
echo "$SH_VER:LO:=============================================" >> $JOB
echo "$SH_VER:LO:Run GIS XSELECT on $file" >> $JOB
echo "$SH_VER:LO:RAWXBINS=$rawxbins" >> $JOB
echo "$SH_VER:LO:Filter Region ($region):" >> $JOB
awk '{print " ", $0}' $region >> $JOB
echo "$SH_VER:LO:Selection Expression:" >> $JOB
awk '{print " ", $0}' xexpr >> $JOB
######################################
# Configure the XSELECT command file.
######################################
base=${file%.cat}
###############################
# some premininary setup stuff
###############################
echo "$base" > $base.xco
echo " " >> $base.xco
echo "%ED%off" >> $base.xco
echo "set dumpcat" >> $base.xco
echo "set mission ASCA" >> $base.xco
echo "load obscat load_str=$file" >> $base.xco
echo "set datadir ." >> $base.xco
echo "choose 1-**" >> $base.xco
####################################
# make unfiltered event files: .unf
####################################
echo "extract events" >> $base.xco
echo "save events outfile=$base.unf use_events=yes" >> $base.xco
####################
# filter and clean
####################
echo "select mkf \"@xexpr\" data_dir=. mkf_def_expr=ft*.mkf" >> $base.xco
echo "filter region $region" >> $base.xco
echo "gisclean" >> $base.xco
###########################################################
# make filtered and cleaned event and detector image files
###########################################################
echo "extract \"events image\"" >> $base.xco
echo "save events outfile=$base.evt use_events=yes" >> $base.xco
echo "save image outfile=$base.detimg" >> $base.xco
#########################
# make an actual skymap
#########################
echo "clear mkf" >> $base.xco
echo "clear region all" >> $base.xco
echo "set XYNAME X Y" >> $base.xco
echo "extract image" >> $base.xco
echo "save image outfile=$base.img" >> $base.xco
###############
# quit xselect
###############
echo "exit save_session=no" >> $base.xco
#################################
# some things for the log file
#################################
echo "$SH_VER:LO:XSELECT command file:" >> $JOB
awk '{print " ", $0}' $base.xco >> $JOB
##########################
# run xselect
############################
$FTOOLS/xselect @$base.xco < /dev/null > /dev/null 2>&1
#######################
# check for errors
#######################
if [ $? -ne 0 ]; then
echo "$SH_VER:E1:Error in Xselect detected, return code != 0" >> $JOB
echo "$SH_VER:E1:Purging $base files" >> $JOB
rm -f $base.evt
rm -f $base.img
rm -f $base.detimg
fi
##################################################
# remove .evt files which have no events in them
##################################################
if [ -s "$base.evt" ]; then
if [ $($STOOLS/getnevents < $base.evt) -eq 0 ]; then
echo "$SH_VER:E1:No events in $base.evt" >> $JOB
echo "$SH_VER:E1:Products deleted for $base.cat" >> $JOB
rm -f $base.evt
rm -f $base.img
rm -f $base.detimg
else
add_fits_keyword $base.unf[0] FNAME "$base.unf"
add_fits_keyword $base.unf[1] FNAME "$base.unf"
add_fits_keyword $base.evt[0] FNAME "$base.evt"
add_fits_keyword $base.evt[1] FNAME "$base.evt"
add_fits_keyword $base.img[0] FNAME "$base.img"
add_fits_keyword $base.detimg[0] FNAME "$base.detimg"
fi
else
echo "$SH_VER:E1:No Xselect products for $base.cat" >> $JOB
cat xsel.log >> $JOB
fi
#################################
# take care of the xsel.log file
#################################
cat $base.xco >> xsel.log
rm -f $base.xco
mv xsel.log ${base}_xsel.log
fits_wrap_ascii ${base}_xsel_log.wrap ${base}_xsel.log
add_fits_keyword ${base}_xsel_log.wrap[0] FNAME \
${base}_xsel_log.wrap STRIP${base}_xsel.log
done
rm -f ${xselpar##*/} xsel.log xexpr
#
################################################################################
# now run gqaplot on the selected data
# gqa stands for GIS quick analysis
# gqaplot makes rough plots of image, light curve and spectrum
################################################################################
echo "$SH_VER:TM:Start GQAPLOT at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/gqaplot.par > gqaplot.par
$FTOOLS/pset ./gqaplot.par device=/PS
$FTOOLS/pset ./gqaplot.par phname=PI
$FTOOLS/pset ./gqaplot.par phalog=yes
$FTOOLS/pset ./gqaplot.par xname=DETX
$FTOOLS/pset ./gqaplot.par yname=DETY
#################################################
# loop through .evt files for the GIS2 and GIS3
#################################################
for file in $(ls | egrep 'g[23].*\.evt$'); do
$FTOOLS/pset ./gqaplot.par infile="$file"
$FTOOLS/pset ./gqaplot.par outfile="${file%evt}out"
#########################
# run gqaplot
#########################
$FTOOLS/gqaplot >> $JOB 2> log.tmp
##################
# check for errors
###################
errchk log.tmp "gqaplot $LINENO" gqaplot.par
##############################
# shuffle output files around
##############################
mv pgplot.ps ${file%evt}ps
fits_wrap_ascii ${file%.evt}_gqa_out.wrap ${file%evt}out
add_fits_keyword ${file%.evt}_gqa_out.wrap[0] FNAME \
${file%.evt}_gqa_out.wrap "STRIP${file%evt}out"
fits_wrap_ascii ${file%.evt}_gqa_ps.wrap ${file%evt}ps
add_fits_keyword ${file%.evt}_gqa_ps.wrap[0] FNAME \
${file%.evt}_gqa_ps.wrap "STRIP${file%evt}ps"
done
rm -f gqaplot.par
################################################################################
# while we are here, collect the science times for these files
# i.e. exposure times
##########################################################################
echo "$SH_VER:TM:Collect science time for products at $SECONDS" >> $JOB
touch ${ADSE}_science_times.gis2
touch ${ADSE}_science_times.gis3
###############################
# loop through GIS .evt files
###############################
for file in $(ls | egrep 'g.*\.evt'); do
SELECT_ONTIME=$($STOOLS/compute_exposure $file[2]) 2>> $JOB
INT_SELECT_ONTIME=$($STOOLS/float2int $SELECT_ONTIME)
case $file in
*g2*) echo "GIS2 $file $INT_SELECT_ONTIME" >> ${ADSE}_science_times.gis2 ;;
*g3*) echo "GIS3 $file $INT_SELECT_ONTIME" >> ${ADSE}_science_times.gis3 ;;
esac
done
##############################################################################
##############################################################################
##
## now move on to SIS (Boo Hiss)
##
##############################################################################
##############################################################################
echo "$SH_VER:TM:Start SIS XSELECT on modal at $SECONDS" >> $JOB
xselpar="$(ls $FTOOLS/xsel*.par)"
cp $xselpar ${xselpar##*/}
########################################################
# loop through files in sis0_cat_list and sis1_cat_list
########################################################
for file in $(cat sis0_cat_list sis1_cat_list | awk '{print $1}'); do
################################################
# Only process the BRIGHT and BRIGHT2 mode data.
#################################################
case $file in
*[01]2[hml].cat) ;;
*[01]2.cat ) ;;
* ) continue ;;
esac
###################################################
# Get S?CCDLST='0 1 2 3' (or whatever is observed)
###################################################
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
case $file in
*s0*) $FTOOLS/pset ./ftabpar.par column=S0CCDLST ;;
*s1*) $FTOOLS/pset ./ftabpar.par column=S1CCDLST ;;
esac
$FTOOLS/pset ./ftabpar.par fitsfile="$file[1]"
$FTOOLS/pset ./ftabpar.par row=1
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "ftabpar $LINENO" ftabpar.par
ccdlst="$($FTOOLS/pget ./ftabpar.par value)"
#######################################
# get the number of active CCDs in SIS
#######################################
case $file in
*s0*) $FTOOLS/pset ./ftabpar.par column=S0CCDMOD ;;
*s1*) $FTOOLS/pset ./ftabpar.par column=S1CCDMOD ;;
esac
$FTOOLS/pset ./ftabpar.par fitsfile="$file[1]"
$FTOOLS/pset ./ftabpar.par row=1
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "ftabpar $LINENO" ftabpar.par
ccdmode="$($FTOOLS/pget ./ftabpar.par value)"
#################################################
# Build expression from CCD power configuration.
#################################################
echo "(SAA==0)&&(BR_EARTH>20)&&(ELV>10)&&(COR>6)" > xexpr
echo "&&(ACS==0)&&(ANG_DIST>0)&&(ANG_DIST<0.01)&&(FOV==0)" >> xexpr
case $file in
*s0*) $BIN/ccd_select.pl 0 "$ccdlst" >> xexpr ;;
*s1*) $BIN/ccd_select.pl 1 "$ccdlst" >> xexpr ;;
esac
####################################################################
# set the Sn_SATFm selection critera for each active CCD in the SIS
####################################################################
for ccd in $ccdlst
do
case $file in
*s0*) echo "&&((S0_SATF${ccd}<1)||(S0_SATF${ccd}>1))" >> xexpr
;;
*s1*) echo "&&((S1_SATF${ccd}<1)||(S1_SATF${ccd}>1))" >> xexpr
;;
esac
done
###########################################################################
# set the T_DY_NT and T_SAA selection critera depending upon the number of
# CCDs active in the SIS
###########################################################################
case $ccdmode in
1) echo "&&((T_DY_NT<0)||(T_DY_NT>16))&&((T_SAA<0)||(T_SAA>16))" >> xexpr
;;
2) echo "&&((T_DY_NT<0)||(T_DY_NT>32))&&((T_SAA<0)||(T_SAA>32))" >> xexpr
;;
3) echo "&&((T_DY_NT<0)||(T_DY_NT>64))&&((T_SAA<0)||(T_SAA>64))" >> xexpr
;;
4) echo "&&((T_DY_NT<0)||(T_DY_NT>64))&&((T_SAA<0)||(T_SAA>64))" >> xexpr
;;
*) echo "$SH_VER:E1:Cannot determine CCD mode; defaulting to 4CCD mode" >> $JOB
echo "&&((T_DY_NT<0)||(T_DY_NT>64))&&((T_SAA<0)||(T_SAA>64))" >> xexpr
;;
esac
####################################
# Show the current file status.
####################################
echo "$SH_VER:LO:=============================================" >> $JOB
echo "$SH_VER:LO:Run SIS XSELECT on $file" >> $JOB
echo "$SH_VER:LO:SIS CCD Chips $ccdlst" >> $JOB
echo "$SH_VER:LO:Selection Expression:" >> $JOB
awk '{print " ", $0}' xexpr >> $JOB
######################################
# Configure the XSELECT command file.
######################################
base=${file%.cat}
echo "$base" > $base.xco
echo " " >> $base.xco
echo "%ED%off" >> $base.xco
echo "set dumpcat" >> $base.xco
echo "set mission ASCA" >> $base.xco
echo "load obscat load_str=$file" >> $base.xco
echo "set datadir ." >> $base.xco
echo "choose 1-**" >> $base.xco
echo "extract events" >> $base.xco
echo "save events outfile=$base.unf use_events=yes" >> $base.xco
echo "select mkf \"@xexpr\" data_dir=. mkf_def_expr=ft*.mkf" >> $base.xco
echo "extract events" >> $base.xco
echo "save events outfile=$base.evtsel use_events=yes" >> $base.xco
echo "sisclean saoimage=no sis_plot=no clean=2 cellsize=5 log_prob=-5.24" \
" bkg_thr=3 clean_phalow=0 clean_phahi=4095" >> $base.xco
echo "save clean outfile=$base.evt use_events=yes" >> $base.xco
echo "extract image" >> $base.xco
echo "save image outfile=$base.detimg" >> $base.xco
echo "clear mkf" >> $base.xco
echo "set XYNAME X Y" >> $base.xco
echo "extract image" >> $base.xco
echo "save image outfile=$base.img" >> $base.xco
echo "exit save_session=no" >> $base.xco
###############################
# some things for the log file
###############################
echo "$SH_VER:LO:XSELECT command file:" >> $JOB
awk '{print " ", $0}' $base.xco >> $JOB
######################
# run xselect
#######################
$FTOOLS/xselect @$base.xco < /dev/null > /dev/null 2>&1
##########################
# check for errors
##########################
if [ $? -ne 0 ]; then
echo "$SH_VER:E1:Error in Xselect detected, return code != 0" >> $JOB
echo "$SH_VER:E1:Purging $base files" >> $JOB
rm -f $base.evtsel
rm -f $base.evt
rm -f $base.img
rm -f $base.detimg
fi
###########################
# remove empty files
###########################
if [ -s "$base.evt" ]; then
if [ $($STOOLS/getnevents < $base.evt) -eq 0 ]; then
rm -f $base.evtsel
rm -f $base.evt
rm -f $base.img
rm -f $base.detimg
echo "$SH_VER:E1:No events in $base.evt" >> $JOB
echo "$SH_VER:E1:Products deleted for $base.cat" >> $JOB
else
add_fits_keyword $base.unf[0] FNAME "$base.unf"
add_fits_keyword $base.unf[1] FNAME "$base.unf"
add_fits_keyword $base.evt[0] FNAME "$base.evt"
add_fits_keyword $base.evt[1] FNAME "$base.evt"
add_fits_keyword $base.img[0] FNAME "$base.img"
add_fits_keyword $base.detimg[0] FNAME "$base.detimg"
fi
else
echo "$SH_VER:E1:No Xselect products for $base.cat" >> $JOB
cat xsel.log >> $JOB
fi
###############################
# take care of xselect log file
###############################
cat $base.xco >> xsel.log
rm -f $base.xco
mv xsel.log ${base}_xsel.log
fits_wrap_ascii ${base}_xsel_log.wrap ${base}_xsel.log
add_fits_keyword ${base}_xsel_log.wrap[0] FNAME \
${base}_xsel_log.wrap STRIP${base}_xsel.log
done
rm -f ${xselpar##*/} xsel.log
rm -f xexpr
################################################################################
# now run sqaplot on the selected data
##############################################################################
echo "$SH_VER:TM:Start SQAPLOT at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/sqaplot.par > sqaplot.par
$FTOOLS/pset ./sqaplot.par device=/PS
############################
# loop through .evtsel files
##############################
for file in $(ls | egrep 's[01].*\.evtsel$'); do
$FTOOLS/pset ./sqaplot.par infile="$file[1]"
$FTOOLS/pset ./sqaplot.par outfile="${file%evtsel}out"
$FTOOLS/pset ./sqaplot.par eventfile=NONE
if [ $($BIN/recmp $file "01[hml]\.evtsel") -eq 0 ]; then
$FTOOLS/pset ./sqaplot.par split=40
get_fits_keyword $file[0] SPLTH0S1
if [ "$get_fits_keyword_exist" = "yes" ]; then
$FTOOLS/pset ./sqaplot.par split="$get_fits_keyword_value"
fi
get_fits_keyword $file[0] SPLTH1S1
if [ "$get_fits_keyword_exist" = "yes" ]; then
$FTOOLS/pset ./sqaplot.par split="$get_fits_keyword_value"
fi
get_fits_keyword $file[0] SPLTH2S1
if [ "$get_fits_keyword_exist" = "yes" ]; then
$FTOOLS/pset ./sqaplot.par split="$get_fits_keyword_value"
fi
get_fits_keyword $file[0] SPLTH3S1
if [ "$get_fits_keyword_exist" = "yes" ]; then
$FTOOLS/pset ./sqaplot.par split="$get_fits_keyword_value"
fi
fi
################################################
# turn off telemetry saturation until it works
################################################
$FTOOLS/sqaplot telemetry=no > log.tmp 2>&1
###############################################
# supress # of chips present error from sqplot
###############################################
if [ $(grep "#chips with events" log.tmp | wc -l) -gt 0 ]; then
echo "$SH_VER:E1:SQAPLOT message \'#chips with events" \
"for $file ignored" >> $JOB
grep -v "#chips with events" log.tmp > log.tmp2
mv log.tmp2 log.tmp
fi
errchk log.tmp "sqaplot $LINENO" sqaplot.par
mv pgplot.ps ${file%evtsel}ps
fits_wrap_ascii ${file%.evtsel}_sqa_out.wrap ${file%evtsel}out
add_fits_keyword ${file%.evtsel}_sqa_out.wrap[0] FNAME \
${file%.evtsel}_sqa_out.wrap "STRIP${file%evtsel}out"
fits_wrap_ascii ${file%.evtsel}_sqa_ps.wrap ${file%evtsel}ps
add_fits_keyword ${file%.evtsel}_sqa_ps.wrap[0] FNAME \
${file%.evtsel}_sqa_ps.wrap "STRIP${file%evtsel}ps"
done
echo "$SH_VER:LO:*.evtsel files removed after sqaplot" >> $JOB
rm -f sqaplot.par ${ADSE}*.evtsel
################################################################################
# while we are here, collect the science times for these files
############################################################################
echo "$SH_VER:TM:Collect science time for products at $SECONDS" >> $JOB
touch ${ADSE}_science_times.sis0
touch ${ADSE}_science_times.sis1
########################
# loop through .evp files
##########################
for file in $(ls | egrep 's.*\.evt'); do
SELECT_ONTIME=$($STOOLS/compute_exposure $file[2]) 2>> $JOB
INT_SELECT_ONTIME=$($STOOLS/float2int $SELECT_ONTIME)
case $file in
*s0*) echo "SIS0 $file $INT_SELECT_ONTIME" >> ${ADSE}_science_times.sis0 ;;
*s1*) echo "SIS1 $file $INT_SELECT_ONTIME" >> ${ADSE}_science_times.sis1 ;;
esac
done
#
################################################################################
###############################################################################
##
## Run the ximage process to create the GIF files and the interlace them with
## giftool. Terminate if the ximage.bash script returns an error
##
##############################################################################
###############################################################################
echo "$SH_VER:TM:Run XIMAGE at $SECONDS" >> $JOB
serverFile="/aps/automation/lists/Xservers.list"
###############################################
# Set the operating system dependent features
###############################################
case `uname -s` in
SunOS )
case `uname -r` in
4*)
export XIMAGE="$XANADU/sun4/bin/ximage"
export EXT="sun" ;;
5*)
export XIMAGE="$XANADU/sol/bin/ximage"
export EXT="sol" ;;
esac ;;
ULTRIX)
export XIMAGE="$XANADU/ulx/bin/ximage"
export EXT="ulx" ;;
esac
csh $XANADU/tools/initu.csh
xco="ximage.xco"
########################################################################
# find an X server that will allow us to connect; Ximage needs this for
# some silly reason
########################################################################
echo "$DISPLAY : value of DISPLAY just before trying x server" >> $JOB
oldDISPLAY=$DISPLAY
DISPLAY=""
for i in $(cat $serverFile | grep -v '^#')
do
DISPLAY=$i':0'
$EXEDIR/XserverTest
if [ $? -eq 0 ]
then
echo "Using $DISPLAY as X server for Ximage run" >> $JOB
break
else
DISPLAY=""
fi
done
if [ -z "$DISPLAY" ]
then
echo "$SH_VER:E1:X no X servers found, skip GIF images" >> $JOB
else
##########################################################################
# loop over all of the Sky images (.img files) and send them into Ximage
# for GIF processing
##########################################################################
for file in $(ls | egrep '^ad.*[gs][0123].....\.img$'); do
echo "read/fits $file" > $xco
echo "smooth" >> $xco
echo "cpd /ppm" >> $xco
echo "disp/noframe" >> $xco
echo "grid" >> $xco
echo "scale" >> $xco
echo "exit" >> $xco
echo "$SH_VER:LO:===========================================" >> $JOB
$XIMAGE @$xco >> $JOB 2> log.tmp
errchk log.tmp "ximage $LINENO" $xco
$PPMTOGIF < ppmfile.ppm > ${file%.img}_img.gif 2>> $JOB
rm -f ppmfile.ppm
done
rm -f $xco
DISPLAY=$oldDISPLAY
fi
############################################################################
# loop over all the gifs; run giftool on them, copy them to the $GIF_STAGE
# directory and then FITS wrap them
#############################################################################
for file in $(ls | egrep '\.gif$'); do
$EXEDIR/giftool -i -B $file
fits_wrap_gif ${file%.gif}_gif.wrap $file
add_fits_keyword ${file%.gif}_gif.wrap[0] FNAME \
${file%.gif}_gif.wrap[0] "STRIP$file"
done
#
###############################################################################
#
# Create final FFILECAT catalogs.
#
###############################################################################
echo "$SH_VER:TM:Create final catalogs at $SECONDS" >> $JOB
rm -f *.cat
cat $GIS_KEYWORDS > gis.keywords
cat $SIS0_KEYWORDS > sis0.keywords
cat $SIS1_KEYWORDS > sis1.keywords
echo TIMEDEL >> gis.keywords
echo TIMEDEL >> sis0.keywords
echo TIMEDEL >> sis1.keywords
for file in $(cat RAW_FRF.list); do
if [ -s "$file" ]; then
case $file in
ft*G2*[HML].fits) echo "$file[0]" >> gis2_raw.cat ;;
ft*G3*[HML].fits) echo "$file[0]" >> gis3_raw.cat ;;
ft*S0*[HML].fits) echo "$file[0]" >> sis0_raw.cat ;;
ft*S1*[HML].fits) echo "$file[0]" >> sis1_raw.cat ;;
esac
fi
done
rm -f RAW_FRF.list
for file in $(ls); do
case $file in
ft*G2*[HML].fits) echo "$file[0]" >> gis2_frf.cat ;;
ad*g2*[hml].unf ) echo "$file[0]" >> gis2_unf.cat ;;
ad*g2*[hml].evt ) echo "$file[0]" >> gis2_evt.cat ;;
ft*G3*[HML].fits) echo "$file[0]" >> gis3_frf.cat ;;
ad*g3*[hml].unf ) echo "$file[0]" >> gis3_unf.cat ;;
ad*g3*[hml].evt ) echo "$file[0]" >> gis3_evt.cat ;;
ft*S0*[HML].fits) echo "$file[0]" >> sis0_frf.cat ;;
ad*s0*[hml].unf ) echo "$file[0]" >> sis0_unf.cat ;;
ad*s0*[hml].evt ) echo "$file[0]" >> sis0_evt.cat ;;
ft*S1*[HML].fits) echo "$file[0]" >> sis1_frf.cat ;;
ad*s1*[hml].unf ) echo "$file[0]" >> sis1_unf.cat ;;
ad*s1*[hml].evt ) echo "$file[0]" >> sis1_evt.cat ;;
esac
done
sed -e 's/,a,/,h,/' $FTOOLS/ffilecat.par > ffilecat.par
$FTOOLS/pset ./ffilecat.par maxlen=1
$FTOOLS/pset ./ffilecat.par minlen=0
$FTOOLS/pset ./ffilecat.par aform=A8
$FTOOLS/pset ./ffilecat.par eform=E9.3E1
$FTOOLS/pset ./ffilecat.par iform=I6
$FTOOLS/pset ./ffilecat.par omit=no
$FTOOLS/pset ./ffilecat.par quiet=yes
for file in $(ls | egrep '...._...\.cat$'); do
catalog="${ADSE}_$file"
case $file in
gis2*) $FTOOLS/pset ./ffilecat.par keywords=@gis.keywords ;;
gis3*) $FTOOLS/pset ./ffilecat.par keywords=@gis.keywords ;;
sis0*) $FTOOLS/pset ./ffilecat.par keywords=@sis0.keywords ;;
sis1*) $FTOOLS/pset ./ffilecat.par keywords=@sis1.keywords ;;
esac
$FTOOLS/pset ./ffilecat.par infile="@$file"
$FTOOLS/pset ./ffilecat.par outfile=$catalog
$FTOOLS/ffilecat >> $JOB 2> log.tmp
errchk log.tmp "ffilecat $LINENO" ffilecat.par $file
rm -f datamode.tmp
for name in $(cat $file); do
get_fits_keyword ${name%???}[1] DATAMODE
echo "$get_fits_keyword_value" | tr -d \' | tr -d ' ' >> datamode.tmp
done
datamode=":"
for name in $(sort datamode.tmp | uniq); do
datamode="$datamode::$name"
done
rm -f datamode.tmp
datamode=${datamode#::}
datamode=${datamode#:}
add_fits_keyword $catalog[0] FNAME "$catalog" 'File name'
add_fits_keyword $catalog[1] FNAME "$catalog" 'File name'
add_fits_keyword $catalog[1] TELESCOP 'ASCA' 'Telescope (mission) name'
case $file in
gis2*) add_fits_keyword $catalog[1] INSTRUME 'GIS2' 'Instrument ID' ;;
gis3*) add_fits_keyword $catalog[1] INSTRUME 'GIS3' 'Instrument ID' ;;
sis0*) add_fits_keyword $catalog[1] INSTRUME 'SIS0' 'Instrument ID' ;;
sis1*) add_fits_keyword $catalog[1] INSTRUME 'SIS1' 'Instrument ID' ;;
esac
add_fits_keyword $catalog[1] DATAMODE "$datamode" 'Observational datamode'
rm -f $file
done
rm -f ffilecat.par
rm -f gis.keywords sis0.keywords sis1.keywords
################################################################################
# Get PI name/address for ASCA*.txt and header pages.
##############################################################################
USPINUM="$($FTOOLS/pget ./job.par uspinum)"
if [ -z "$USPINUM" ]
then
USPINUM="0"
fi
USPINAME="$($FTOOLS/pget ./job.par uspiname)"
USPIADR1="$($FTOOLS/pget ./job.par uspiaddr1)"
USPIADR2="$($FTOOLS/pget ./job.par uspiaddr2)"
USPIADR3="$($FTOOLS/pget ./job.par uspiaddr3)"
USPIADR4="$($FTOOLS/pget ./job.par uspiaddr4)"
USPIADR5="$($FTOOLS/pget ./job.par uspiaddr5)"
USPIEADR="$($FTOOLS/pget ./job.par uspiemail)"
JPPINUM="$($FTOOLS/pget ./job.par jppinum)"
JPPINAME="$($FTOOLS/pget ./job.par jppiname)"
JPPIADR1="$($FTOOLS/pget ./job.par jppiaddr1)"
JPPIADR2="$($FTOOLS/pget ./job.par jppiaddr2)"
JPPIADR3="$($FTOOLS/pget ./job.par jppiaddr3)"
JPPIADR4="$($FTOOLS/pget ./job.par jppiaddr4)"
JPPIADR5="$($FTOOLS/pget ./job.par jppiaddr5)"
JPPIEADR="$($FTOOLS/pget ./job.par jppiemail)"
#
##############################################################################
###############################################################################
##
## Create the ascamode.txt file.
##
#############################################################################
#############################################################################
echo "$SH_VER:TM:Create ASCAMODE at $SECONDS" >> $JOB
proposal_type="$($BIN/proposal_type $SEQUENCE)"
proposal_number="$($FTOOLS/pget ./job.par proposal)"
target_number="$($FTOOLS/pget ./job.par targetnum)"
if [ "$USPINUM" -ne 0 ]; then
piname="$USPINAME"
else
piname="$JPPINAME"
fi
logfile=${ADSE}_ascamode.txt
rm -f $logfile
touch $logfile
#################################
# loop through unfiltered files
#################################
for base_file in $(ls | egrep '\.unf$'); do
#################################################
# $file is the corresponding filtered event file
#################################################
file=${base_file%.unf}.evt
echo -n "$SEQUENCE|$OBJECT|$RA|$DEC|$Lii|$Bii|" >> $logfile
tel="unknown"
TSTART=0
TSTOP=0
mode="unknown"
bit_rate=0
modal_id=0
get_fits_keyword $base_file[0] TLM_FILE
if [ "$get_fits_keyword_exist" = yes ]; then
tel="$get_fits_keyword_value"
tmp="$(echo $tel | sed s/\'//g)"
tel="$tmp"
fi
get_fits_keyword $base_file[0] TSTART
if [ "$get_fits_keyword_exist" = yes ]; then
TSTART="$get_fits_keyword_value"
fi
get_fits_keyword $base_file[0] TSTOP
if [ "$get_fits_keyword_exist" = yes ]; then
TSTOP="$get_fits_keyword_value"
fi
get_fits_keyword $base_file[0] DATAMODE
if [ "$get_fits_keyword_exist" = yes ]; then
mode="$get_fits_keyword_value"
tmp="$(echo $mode | sed s/\'//g)"
mode="$tmp"
fi
get_fits_keyword $base_file[0] BIT_RATE
if [ "$get_fits_keyword_exist" = yes ]; then
bit_rate="$get_fits_keyword_value"
tmp="$(echo $bit_rate | sed s/\'//g)"
bit_rate="$tmp"
fi
get_fits_keyword $base_file[1] MODAL_ID
if [ "$get_fits_keyword_exist" = yes ]; then
modal_id="$get_fits_keyword_value"
fi
echo -n "$tel|$TSTART|$TSTOP|$mode|$bit_rate|$modal_id|" >> $logfile
###################################################################
# Compute statistics from XSELECT products based on instrument ID.
###################################################################
gis_ontime=0
gis_count_rate=0
gis_count_rate_error=0
sis_ontime=0
sis_count_rate=0
sis_count_rate_error=0
case $base_file in
*g[23]*)
######################
# GIS
######################
gis_ontime=0
gis_nevents=0
get_fits_keyword $base_file[0] ONTIME
if [ "$get_fits_keyword_exist" = yes ]; then
gis_ontime="$get_fits_keyword_value"
fi
get_fits_keyword $base_file[0] NEVENTS
if [ "$get_fits_keyword_exist" = yes ]; then
gis_nevents="$get_fits_keyword_value"
fi
if [ "$gis_ontime" = "0" ]; then
echo "$SH_VAR:E1:Division by zero, ontime=0 in $base_file" >> $JOB
gis_count_rate=0
else
gis_count_rate="$($STOOLS/floatdiv $gis_nevents $gis_ontime)"
fi
gis_count_rate_error="$($STOOLS/sqrt $gis_count_rate)" ;;
*s[01]*)
#########################
# SIS
#########################
sis_ontime=0
sis_nevents=0
get_fits_keyword $base_file[0] ONTIME
if [ "$get_fits_keyword_exist" = yes ]; then
sis_ontime="$get_fits_keyword_value"
fi
get_fits_keyword $base_file[0] NEVENTS
if [ "$get_fits_keyword_exist" = yes ]; then
sis_nevents="$get_fits_keyword_value"
fi
if [ "$sis_ontime" = "0" ]; then
echo "$SH_VAR:E1:Division by zero, ontime=0 in $base_file" >> $JOB
sis_count_rate=0
else
sis_count_rate="$($STOOLS/floatdiv $sis_nevents $sis_ontime)"
fi
sis_count_rate_error="$($STOOLS/sqrt $sis_count_rate)" ;;
esac
echo -n "$gis_ontime|$gis_count_rate|$gis_count_rate_error|" >> $logfile
echo -n "$sis_ontime|$sis_count_rate|$sis_count_rate_error|" >> $logfile
gis_ontime=0
gis_count_rate=0
gis_count_rate_error=0
sis_ontime=0
sis_count_rate=0
sis_count_rate_error=0
if [ -s $file ]; then
case $file in
*g[23]*)
gis_ontime=0
gis_nevents=0
get_fits_keyword $file[0] ONTIME
if [ "$get_fits_keyword_exist" = yes ]; then
gis_ontime="$get_fits_keyword_value"
fi
get_fits_keyword $file[0] NEVENTS
if [ "$get_fits_keyword_exist" = yes ]; then
gis_nevents="$get_fits_keyword_value"
fi
if [ "$gis_ontime" = "0" ]; then
echo "$SH_VAR:E1:Division by zero, ontime=0 in $file" >> $JOB
gis_count_rate=0
else
gis_count_rate="$($STOOLS/floatdiv $gis_nevents $gis_ontime)"
fi
gis_count_rate_error="$($STOOLS/sqrt $gis_count_rate)" ;;
*s[01]*)
sis_ontime=0
sis_nevents=0
get_fits_keyword $file[0] ONTIME
if [ "$get_fits_keyword_exist" = yes ]; then
sis_ontime="$get_fits_keyword_value"
fi
get_fits_keyword $file[0] NEVENTS
if [ "$get_fits_keyword_exist" = yes ]; then
sis_nevents="$get_fits_keyword_value"
fi
if [ "$sis_ontime" = "0" ]; then
echo "$SH_VAR:E1:Division by zero, ontime=0 in $file" >> $JOB
sis_count_rate=0
else
sis_count_rate="$($STOOLS/floatdiv $sis_nevents $sis_ontime)"
fi
sis_count_rate_error="$($STOOLS/sqrt $sis_count_rate)" ;;
esac
fi
echo -n "$gis_ontime|$gis_count_rate|$gis_count_rate_error|" >> $logfile
echo -n "$sis_ontime|$sis_count_rate|$sis_count_rate_error|" >> $logfile
echo -n "$piname|" >> $logfile
echo -n "$proposal_type|$proposal_number|$target_number|" >> $logfile
echo "000000" >> $logfile
done
##############################
# Check for FAINT & MPC data.
##############################
touch tel.list
for file in $(ls | egrep '[07]1[HML]\.fits$'); do
get_fits_keyword $base_file[0] TLM_FILE
if [ "$get_fits_keyword_exist" = yes ]; then
echo "$get_fits_keyword_value" >> tel.list
fi
done
TSTART=0
TSTOP=0
bit_rate=0
modal_id=0
gis_ontime=0
gis_count_rate=0
gis_count_rate_error=0
sis_ontime=0
sis_count_rate=0
sis_count_rate_error=0
for tel in $(sort tel.list | uniq); do
echo -n "$SEQUENCE|$OBJECT|$RA|$DEC|$Lii|$Bii|" >> $logfile
case $tel in
*01[HML]*) mode="FAINT" ;;
*71[HML]*) mode="MPC" ;;
esac
echo -n "$tel|$TSTART|$TSTOP|$mode|$bit_rate|$modal_id|" >> $logfile
echo -n "$gis_ontime|$gis_count_rate|$gis_count_rate_error|" >> $logfile
echo -n "$sis_ontime|$sis_count_rate|$sis_count_rate_error|" >> $logfile
echo -n "$gis_ontime|$gis_count_rate|$gis_count_rate_error|" >> $logfile
echo -n "$sis_ontime|$sis_count_rate|$sis_count_rate_error|" >> $logfile
echo -n "$piname|" >> $logfile
echo -n "$proposal_type|$proposal_number|$target_number|" >> $logfile
echo "000000" >> $logfile
done
rm -f tel.list
fits_wrap_ascii ${logfile%.txt}_txt.wrap $logfile
#
################################################################################
###############################################################################
##
## Create the ascalog.txt file.
##
##############################################################################
################################################################################
echo "$SH_VER:TM:Create ASCALOG at $SECONDS" >> $JOB
logfile=${ADSE}_ascalog.txt
rm -f $logfile
touch $logfile
####################################
# loop through FRF telemetry files
####################################
for tel in $(awk '{print $1}' job.par.info); do
echo -n "$SEQUENCE|$OBJECT|$RA|$DEC|$Lii|$Bii|" >> $logfile
get_fits_keyword $tel[0] TSTART
TSTART=0
if [ "$get_fits_keyword_exist" = yes ]; then
TSTART="$get_fits_keyword_value"
fi
get_fits_keyword $tel[0] TSTOP
TSTOP=0
if [ "$get_fits_keyword_exist" = yes ]; then
TSTOP="$get_fits_keyword_value"
fi
echo -n "$tel|$TSTART|$TSTOP|" >> $logfile
###########################################################
# Set the base FRF name for the associated telemetry file.
###########################################################
frf_base="${tel%.????}_${tel#??????????????}"
##################################################################
# Integrate the ontime and nevents over associated GIS FRF files.
##################################################################
gis_ontime=0
gis_nevents=0
for file in $(ls | egrep "${frf_base}G[23].....[HML]\.fits$"); do
get_fits_keyword $file[1] ONTIME
if [ "$get_fits_keyword_exist" = yes ]; then
gis_ontime="$($STOOLS/floatadd $gis_ontime $get_fits_keyword_value)"
fi
get_fits_keyword $file[1] NEVENTS
if [ "$get_fits_keyword_exist" = yes ]; then
gis_nevents="$($STOOLS/floatadd $gis_nevents $get_fits_keyword_value)"
fi
done
if [ "$gis_ontime" = "0" ]; then
echo "$SH_VAR:E1:Division by zero, GIS ontime=0 in $file" >> $JOB
gis_count_rate=0
else
gis_count_rate="$($STOOLS/floatdiv $gis_nevents $gis_ontime)"
fi
gis_count_rate_error="$($STOOLS/sqrt $gis_count_rate)"
###################################################################
# Integrate the ontime and nevents over associated SIS FRF files.
###################################################################
sis_ontime=0
sis_nevents=0
for file in $(ls | egrep "${frf_base}S[01].....[HML]\.fits$"); do
get_fits_keyword $file[1] ONTIME
if [ "$get_fits_keyword_exist" = yes ]; then
sis_ontime="$($STOOLS/floatadd $sis_ontime $get_fits_keyword_value)"
fi
get_fits_keyword $file[1] NEVENTS
if [ "$get_fits_keyword_exist" = yes ]; then
sis_nevents="$($STOOLS/floatadd $sis_nevents $get_fits_keyword_value)"
fi
done
if [ "$sis_ontime" = "0" ]; then
echo "$SH_VAR:E1:Division by zero, SIS ontime=0 in $file" >> $JOB
sis_count_rate=0
else
sis_count_rate="$($STOOLS/floatdiv $sis_nevents $sis_ontime)"
fi
sis_count_rate_error="$($STOOLS/sqrt $sis_count_rate)"
echo -n "$gis_ontime|$gis_count_rate|$gis_count_rate_error|" >> $logfile
echo -n "$sis_ontime|$sis_count_rate|$sis_count_rate_error|" >> $logfile
echo -n "$piname|" >> $logfile
echo -n "$proposal_type|$proposal_number|$target_number|" >> $logfile
echo "000000" >> $logfile
done
fits_wrap_ascii ${logfile%.txt}_txt.wrap $logfile
#
###############################################################################
###############################################################################
##
## Create GIS HK textual dump files.
##
################################################################################
################################################################################
echo "$SH_VER:TM:Create text dumps of GIS HK files at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/ghkdump.par > ghkdump.par
for file in $(ls | egrep '^ft.*G[23]HK\.fits$'); do
outfile=${file%.fits}.txt
$FTOOLS/pset ./ghkdump.par infile="$file"
$FTOOLS/pset ./ghkdump.par outfile="$outfile"
$FTOOLS/ghkdump >> $JOB 2> log.tmp
errchk log.tmp "ghkdump $LINENO" ghkdump.par
wrapfile=${outfile%.txt}_txt.wrap
fits_wrap_ascii $wrapfile $outfile
add_fits_keyword $wrapfile[0] FNAME $wrapfile STRIP$outfile
done
rm -f ghkdump.par
#
###############################################################################
##############################################################################
##
## Create the processing header page.
##
##############################################################################
###############################################################################
echo "$SH_VER:TM:Create processing summary page at $SECONDS" >> $JOB
PROC_INFO="${ADSE}_proc_info.txt"
HEAD_PAGE="${ADSE}_hdr_page.txt"
echo " " > $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "ASCA Processing Summary " $(date) >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "Processing Script and Version: " ${0##*/} $PROC_VER >> $HEAD_PAGE
echo "PROCSCRIPT=$0" > $PROC_INFO
echo "PROCVER=$SH_VER" >> $PROC_INFO
echo "PROCLEVEL=$SEQPROCNUM" >> $PROC_INFO
echo "FTOOLS=${FTOOLSBASE##*/}" >> $PROC_INFO
echo "GAINHISTVER=$GAINHISTVER" >> $PROC_INFO
echo "Sequence Number = " $SEQUENCE " Object Name = " $OBJECT >> $HEAD_PAGE
echo "RA =" $RA " DEC =" $DEC >> $HEAD_PAGE
echo "Lii =" $Lii" Bii =" $Bii >> $HEAD_PAGE
echo "PROCDATE=$(date +%y%m%d)" >> $PROC_INFO
echo "PROCTIME=$(date +%H%M%S)" >> $PROC_INFO
echo "SEQUENCE=$SEQUENCE" >> $PROC_INFO
echo "OBJECT='$OBJECT'" >> $PROC_INFO
echo "RA=$RA" >> $PROC_INFO
echo "DEC=$DEC" >> $PROC_INFO
echo "Lii=$Lii" >> $PROC_INFO
echo "Bii=$Bii" >> $PROC_INFO
echo "ROLL=$ROLL" >> $PROC_INFO
if [ "$USPINUM" -ne 0 ]; then
echo "U.S. PI INFO:" >> $HEAD_PAGE
echo "USPINUM=$USPINUM" >> $PROC_INFO
if [ "$USPINAME" != "" ]; then
echo "PI: " "$USPINAME" >> $HEAD_PAGE
echo "USPINAME='$USPINAME'" >> $PROC_INFO
else
echo "PI: " "NO Name" >> $HEAD_PAGE
echo "USPINAME=\"NO Name\"" >> $PROC_INFO
fi
if [ "$USPIADR1" != "" ]; then
echo " " "$USPIADR1" >> $HEAD_PAGE
echo "USPIADR1='$USPIADR1'" >> $PROC_INFO
fi
if [ "$USPIADR2" != "" ]; then
echo " " "$USPIADR2" >> $HEAD_PAGE
echo "USPIADR2='$USPIADR2'" >> $PROC_INFO
fi
if [ "$USPIADR3" != "" ]; then
echo " " "$USPIADR3" >> $HEAD_PAGE
echo "USPIADR3='$USPIADR3'" >> $PROC_INFO
fi
if [ "$USPIADR4" != "" ]; then
echo " " "$USPIADR4" >> $HEAD_PAGE
echo "USPIADR4='$USPIADR4'" >> $PROC_INFO
fi
if [ "$USPIADR5" != "" ]; then
echo " " "$USPIADR5" >> $HEAD_PAGE
echo "USPIADR5='$USPIADR5'" >> $PROC_INFO
fi
if [ "$USPIEADR" != "" ]; then
echo " " "$USPIEADR" >> $HEAD_PAGE
echo "USPIEADR='$USPIEADR'" >> $PROC_INFO
fi
fi
if [ "$JPPINUM" -ne 0 ]; then
echo "Japanese PI INFO:" >> $HEAD_PAGE
echo "JPPINUM=$JPPINUM" >> $PROC_INFO
if [ "$JPPINAME" != "" ]; then
echo "PI: " "$JPPINAME" >> $HEAD_PAGE
echo "JPPINAME='$JPPINAME'" >> $PROC_INFO
else
echo "PI: " "NO Name" >> $HEAD_PAGE
echo "JPPINAME='NO Name'" >> $PROC_INFO
fi
if [ "$JPPIADR1" != "" ]; then
echo " " "$JPPIADR1" >> $HEAD_PAGE
echo "JPPIADR1='$JPPIADR1'" >> $PROC_INFO
fi
if [ "$JPPIADR2" != "" ]; then
echo " " "$JPPIADR2" >> $HEAD_PAGE
echo "JPPIADR2='$JPPIADR2'" >> $PROC_INFO
fi
if [ "$JPPIADR3" != "" ]; then
echo " " "$JPPIADR3" >> $HEAD_PAGE
echo "JPPIADR3='$JPPIADR3'" >> $PROC_INFO
fi
if [ "$JPPIADR4" != "" ]; then
echo " " "$JPPIADR4" >> $HEAD_PAGE
echo "JPPIADR4='$JPPIADR4'" >> $PROC_INFO
fi
if [ "$JPPIADR5" != "" ]; then
echo " " "$JPPIADR5" >> $HEAD_PAGE
echo "JPPIADR5='$JPPIADR5'" >> $PROC_INFO
fi
if [ "$JPPIEADR" != "" ]; then
echo " " "$JPPIEADR" >> $HEAD_PAGE
echo "JPPIEADR='$JPPIEADR'" >> $PROC_INFO
fi
fi
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "Telemetry files used:" >> $HEAD_PAGE
typeset -i SEQ_MISSION_TIME=0
TOTAL_MISSION_TIME="0.0E0"
STARTUTDATE=""
ENDUTDATE=""
STARTUTTIME=""
ENDUTTIME=""
for file in $(awk '{print $1}' job.par.info); do
FILENAME=$file
get_fits_keyword $file[1] ORBIT0
ORBIT0="$get_fits_keyword_value"
get_fits_keyword $file[1] ORBIT1
ORBIT1="$get_fits_keyword_value"
get_fits_keyword $file[1] MTIME0
MTIME0="$get_fits_keyword_value"
get_fits_keyword $file[1] MTIME1
MTIME1="$get_fits_keyword_value"
get_fits_keyword $file[1] DATE0
MTIME="$($STOOLS/floatdiff $MTIME1 $MTIME0)"
TOTAL_MISSION_TIME="$($STOOLS/floatadd $TOTAL_MISSION_TIME $MTIME)"
DATE0="$get_fits_keyword_value"
get_fits_keyword $file[1] DATE1
DATE1="$get_fits_keyword_value"
get_fits_keyword $file[1] TIME0
TIME0="$get_fits_keyword_value"
get_fits_keyword $file[1] TIME1
TIME1="$get_fits_keyword_value"
get_fits_keyword $file[1] DATEF
DATEF="$get_fits_keyword_value"
get_fits_keyword $file[1] TIMEF
TIMEF="$get_fits_keyword_value"
echo $FILENAME " Included Mission Time =" $MTIME >> $HEAD_PAGE
echo " Start orbit:" $ORBIT0 " End orbit:" $ORBIT1 >> $HEAD_PAGE
echo " Start mission time:" $MTIME0 " End mission time:" $MTIME1 \
>> $HEAD_PAGE
echo " Start UT date:" $DATE0 " End UT date:" $DATE1 >> $HEAD_PAGE
echo " Start UT time:" $TIME0 " End UT time:" $TIME1 >> $HEAD_PAGE
echo " File create UT date/time:" $DATEF $TIMEF >> $HEAD_PAGE
if [ -z "$STARTUTDATE" ]; then
STARTUTDATE=$DATE0
fi
if [ -z "$STARTUTTIME" ]; then
STARTUTTIME=$TIME0
fi
ENDUTDATE=$DATE1
ENDUTTIME=$TIME1
done
echo "STARTUTDATE=$STARTUTDATE" >> $PROC_INFO
echo "ENDUTDATE=$ENDUTDATE" >> $PROC_INFO
echo "STARTUTTIME=$STARTUTTIME" >> $PROC_INFO
echo "ENDUTTIME=$ENDUTTIME" >> $PROC_INFO
echo " " >> $HEAD_PAGE
echo "Attitude files used:" >> $HEAD_PAGE
for file in $(awk '{print $3}' job.par.info); do
FILENAME=$file
get_fits_keyword $file[1] ORBIT0
ORBIT0="$get_fits_keyword_value"
get_fits_keyword $file[1] ORBIT1
ORBIT1="$get_fits_keyword_value"
get_fits_keyword $file[1] MTIME0
MTIME0="$get_fits_keyword_value"
get_fits_keyword $file[1] MTIME1
MTIME1="$get_fits_keyword_value"
get_fits_keyword $file[1] DATE0
DATE0="$get_fits_keyword_value"
get_fits_keyword $file[1] DATE1
DATE1="$get_fits_keyword_value"
get_fits_keyword $file[1] TIME0
TIME0="$get_fits_keyword_value"
get_fits_keyword $file[1] TIME1
TIME1="$get_fits_keyword_value"
get_fits_keyword $file[1] DATEF
DATEF="$get_fits_keyword_value"
get_fits_keyword $file[1] TIMEF
TIMEF="$get_fits_keyword_value"
echo $FILENAME >> $HEAD_PAGE
echo " Start orbit:" $ORBIT0 " End orbit:" $ORBIT1 >> $HEAD_PAGE
echo " Start mission time:" $MTIME0 " End mission time:" $MTIME1 \
>> $HEAD_PAGE
echo " Start UT date:" $DATE0 " End UT date:" $DATE1 >> $HEAD_PAGE
echo " Start UT time:" $TIME0 " End UT time:" $TIME1 >> $HEAD_PAGE
echo " File create UT date/time:" $DATEF $TIMEF >> $HEAD_PAGE
done
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "Processing Products Report" >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "Final catalogs and their associated products:" >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "Total Mission Time for this sequence =" \
$($STOOLS/float2int $TOTAL_MISSION_TIME) >> $HEAD_PAGE
echo "TOTALTIME=$TOTAL_MISSION_TIME" >> $PROC_INFO
echo " " >> $HEAD_PAGE
#########################################################################
# define a function which prints the number of events and ontime
# for an unfiltered fevent file and the corresponding filtered event
# file if there is one.
#########################################################################
report ()
{
typeset nevents=0
typeset ontime=0
get_fits_keyword $1[0] NEVENTS
nevents="$get_fits_keyword_value"
get_fits_keyword $1[0] ONTIME
ontime="$get_fits_keyword_value"
echo "$1 ${ontime}sec ${nevents}evt" >> $HEAD_PAGE
if [ -r ${1%unf}evt ]; then
get_fits_keyword ${1%unf}evt[0] NEVENTS
nevents="$get_fits_keyword_value"
get_fits_keyword ${1%unf}evt[0] ONTIME
ontime="$get_fits_keyword_value"
echo "${1%unf}evt ${ontime}sec ${nevents}evt" >> $HEAD_PAGE
fi
for file in $(ls ${1%.unf}*); do
echo " $file" >> $HEAD_PAGE
done
}
#################################
# more stuff for the header page
#################################
echo "GIS2" >> $HEAD_PAGE
for file in $(ls | egrep 'gis2_...\.cat$'); do
echo "$file" >> $HEAD_PAGE
done
for file in $(ls | egrep 'g2.*\.unf$'); do
report $file
done
echo " " >> $HEAD_PAGE
echo "GIS3" >> $HEAD_PAGE
for file in $(ls | egrep 'gis3_...\.cat$'); do
echo "$file" >> $HEAD_PAGE
done
for file in $(ls | egrep 'g3.*\.unf$'); do
report $file
done
echo " " >> $HEAD_PAGE
echo "SIS0" >> $HEAD_PAGE
for file in $(ls | egrep 'sis0_...\.cat$'); do
echo "$file" >> $HEAD_PAGE
done
for file in $(ls | egrep 's0.*\.unf$'); do
report $file
done
echo " " >> $HEAD_PAGE
echo "SIS1" >> $HEAD_PAGE
for file in $(ls | egrep 'sis1_...\.cat$'); do
echo "$file" >> $HEAD_PAGE
done
for file in $(ls | egrep 's1.*\.unf$'); do
report $file
done
echo " " >> $HEAD_PAGE
rm -f gis2_cat_list
rm -f gis3_cat_list
rm -f sis0_cat_list
rm -f sis1_cat_list
echo " " >> $HEAD_PAGE
echo "End of processing summary" >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "Configuration Summary from the job log" >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
egrep ':CO:' $JOB >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "End of configuration summary" >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "Error Summary from the job log" >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "E2 errors are serious and should not appear. They are handled" \
>> $HEAD_PAGE
echo " by processing staff and if they are present should be reported" \
>> $HEAD_PAGE
echo " to ascahelp@legacy.gsfc.nasa.gov" >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
$BIN/report.errors $JOB >> $HEAD_PAGE
echo " " >> $HEAD_PAGE
echo "End of error summary" >> $HEAD_PAGE
echo "End of job log summary" >> $HEAD_PAGE
fits_wrap_ascii ${HEAD_PAGE%.txt}_txt.wrap $HEAD_PAGE
add_fits_keyword ${HEAD_PAGE%.txt}_txt.wrap[0] FNAME \
${HEAD_PAGE%.txt}_txt.wrap STRIP$HEAD_PAGE
chmod 644 $PROC_INFO
#
#############################################################################
#############################################################################
##
## Last is the tape contents file.
##
#############################################################################
#############################################################################
echo "$SH_VER:TM:Create tape contents file at $SECONDS" >> $JOB
typeset -i file_cnt=0
#############################
# define some functions
#############################
tape_print ()
{
if [ -s "$1" ]; then
file_kb="$(ls -s $1 | awk '{print $1}')"
else
file_kb=0
fi
if [ "$(fgrep $1 tape.create | wc -l)" -eq 0 ]; then
let file_cnt+=1
echo $file_cnt "'"${1##*/}"'" $file_kb "'"$2"'" >> tape.contents
echo ${1##*/} >> tape.create
fi
}
add_tape_science_files ()
{
get_fits_keyword $1[1] NAXIS2
FILE_NUMBER="$get_fits_keyword_value"
sed -e 's/,a,/,h,/' $FTOOLS/ftabpar.par > ftabpar.par
$FTOOLS/pset ./ftabpar.par fitsfile="$1[1]"
$FTOOLS/pset ./ftabpar.par column=FILENAME
typeset -i file_index=0
while [ $file_index -lt $FILE_NUMBER ]; do
let file_index+=1
$FTOOLS/pset ./ftabpar.par row="$file_index"
$FTOOLS/ftabpar >> $JOB 2> log.tmp
errchk log.tmp "ftabpar $LINENO" ftabpar.par
name="$($FTOOLS/pget ./ftabpar.par value)"
case $name in
*G[23]*.fits) tape_print $name "FRF GIS Science file" ;;
*S[01]*.fits) tape_print $name "FRF SIS Science file" ;;
*G[23]*.fits) tape_print $name "FRF GIS Science file" ;;
*S[01]*.fits) tape_print $name "FRF SIS Science file" ;;
*G[23]*.fits) tape_print $name "FRF GIS Science file" ;;
*S[01]*.fits) tape_print $name "FRF SIS Science file" ;;
*g[23]*.unf ) tape_print $name "Unfiltered GIS Science file" ;;
*s[01]*.unf ) tape_print $name "Unfiltered SIS Science file" ;;
*g[23]*.evt ) tape_print $name "Filtered GIS Science file" ;;
*s[01]*.evt ) tape_print $name "Filtered SIS Science file" ;;
* ) tape_print $name "Science file" ;;
esac
done
}
rm -f tape.create
touch tape.create
tape_print ${ADSE}_tape.cat "Tape contents list FITS file"
tape_print ${ADSE}_hdr_page_txt.wrap "Processing Summary Page"
########################
# Catalogs of products.
########################
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_raw.cat ]; then
tape_print ${ADSE}_${inst}_raw.cat "${inst} RAW FRF products catalog"
fi
done
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_frf.cat ]; then
tape_print ${ADSE}_${inst}_frf.cat "${inst} FRF products catalog"
fi
done
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_unf.cat ]; then
tape_print ${ADSE}_${inst}_unf.cat "${inst} unfiltered products catalog"
fi
done
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_evt.cat ]; then
tape_print ${ADSE}_${inst}_evt.cat "${inst} filtered products catalog"
fi
done
# Catalogs of products.
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_raw.cat ]; then
add_tape_science_files ${ADSE}_${inst}_raw.cat
fi
done
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_frf.cat ]; then
add_tape_science_files ${ADSE}_${inst}_frf.cat
fi
done
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_unf.cat ]; then
add_tape_science_files ${ADSE}_${inst}_unf.cat
fi
done
for file in $(ls | egrep '\.evt$' | egrep -v '[hml]\.evt$'); do
case $file in
*g[23]*.evt ) tape_print $file "Filtered GIS Science file" ;;
*s[01]*.evt ) tape_print $file "Filtered SIS Science file" ;;
esac
done
for inst in gis2 gis3 sis0 sis1; do
if [ -s ${ADSE}_${inst}_evt.cat ]; then
add_tape_science_files ${ADSE}_${inst}_evt.cat
fi
done
########################
# Important products.
########################
for file in $(ls | egrep '^ft.*\.mkf$'); do
tape_print $file "MKFILTER file"
done
for file in $(ls | egrep '\.img$'); do
tape_print $file "Xselect modal sky image"
done
for file in $(ls | egrep '\.detimg$'); do
tape_print $file "Xselect modal detector image"
done
for file in $(ls | egrep '_gqa_out\.wrap$'); do
tape_print $file "FITS wrapped GQAPLOT ascii product"
done
for file in $(ls | egrep '_gqa_ps\.wrap$'); do
tape_print $file "FITS wrapped GQAPLOT PS product"
done
for file in $(ls | egrep '_sqa_out\.wrap$'); do
tape_print $file "FITS wrapped SQAPLOT ascii product"
done
for file in $(ls | egrep '_sqa_ps\.wrap$'); do
tape_print $file "FITS wrapped SQAPLOT PS product"
done
for file in $(ls | egrep '_xsel_log\.wrap$'); do
tape_print $file "FITS wrapped Xselect run log"
done
for file in $(ls | egrep 'gif\.wrap$'); do
tape_print $file "FITS wrapped GIF image"
done
for file in $(ls | egrep '_txt\.wrap$'); do
tape_print $file "FITS wrapped GIS HK dump"
done
for file in $(ls | egrep '\.ghf$'); do
tape_print $file "GIS Gain History file"
done
for file in $(sort -u < gis2_cal_files_used); do
tape_print ${file##/*/} "GIS2 calibration file"
done
for file in $(sort -u < gis3_cal_files_used); do
tape_print ${file##/*/} "GIS3 calibration file"
done
tape_print ${S0MAP##/*/} "SIS0 telescope calibration file"
tape_print ${S1MAP##/*/} "SIS1 telescope calibration file"
if [ -s ${ADSE}_s0_dfe.wrap ]; then
tape_print ${ADSE}_s0_dfe.wrap "SIS0 DFE files"
fi
if [ -s ${ADSE}_s1_dfe.wrap ]; then
tape_print ${ADSE}_s1_dfe.wrap "SIS1 DFE files"
fi
######################
# Secondary products.
######################
for file in $(cat ascalin.fail.list); do
tape_print $file "ASCALIN corrupted Science file"
done
for file in $(ls | egrep '^ft.*CMHK\.fits$'); do
tape_print $file "Common Housekeeping File"
done
for file in $(ls | egrep '^ft.*G2HK\.fits$'); do
tape_print $file "GIS2 Instrument Housekeeping File"
done
for file in $(ls | egrep '^ft.*G3HK\.fits$'); do
tape_print $file "GIS3 Instrument Housekeeping File"
done
for file in $(ls | egrep '^ft.*S0HK\.fits$'); do
tape_print $file "SIS0 Instrument Housekeeping File"
done
for file in $(ls | egrep '^ft.*S1HK\.fits$'); do
tape_print $file "SIS1 Instrument Housekeeping File"
done
tape_print frf.orbit "Orbit file"
for file in ft??????_????.????; do
tape_print $file "Raw telemetry file"
done
for file in fa??????_????.????; do
tape_print $file "Attitude file"
done
fits_wrap_ascii modal_config.fits $MODAL_LIST
tape_print modal_config.fits "ASCA Modal Configuration table"
fits_wrap_ascii ${ADSE}_rigid.wrap $RIGID
add_fits_keyword ${ADSE}_rigid.wrap[0] FNAME \
${ADSE}_rigid.wrap STRIP${RIGID##*/}
tape_print ${ADSE}_rigid.wrap "FITS wrapped Rigidity Data table"
tape_print $LEAPTABLE "Leap Second Correction table"
# i hate this
echo "$SH_VER:LO:$JOB closed for conversion to FITS" >> $JOB
fits_wrap_ascii ${ADSE}_joblog.wrap $JOB
add_fits_keyword ${ADSE}_joblog.wrap[0] FNAME \
${ADSE}_joblog.wrap STRIP${ADSE}_$JOB
tape_print ${ADSE}_joblog.wrap "Processing job log"
##############################################
# create tape.cat file
##############################################
sed -e 's/,a,/,h,/' $FTOOLS/fcreate.par > fcreate.par
$FTOOLS/pset ./fcreate.par cdfile=fcreate.cdfile
$FTOOLS/pset ./fcreate.par datafile=tape.contents
$FTOOLS/pset ./fcreate.par outfile="${ADSE}_tape.cat"
$FTOOLS/pset ./fcreate.par tbltype=ASCII
echo "filenum I4" > fcreate.cdfile
echo "filename A57" >> fcreate.cdfile
echo "filesize I7 kilobytes" >> fcreate.cdfile
echo "descrip A64" >> fcreate.cdfile
$FTOOLS/fcreate >> $JOB 2> log.tmp
errchk log.tmp "FCREATE $LINENO" fcreate.par fcreate.cdfile tape.contents
add_fits_keyword ${ADSE}_tape.cat[0] FNAME \
${ADSE}_tape.cat STRIP${ADSE}_tape.txt
rm -f fcreate.par fcreate.cdfile
#########################################################################
# Update all outputs with standard keywords
#########################################################################
echo "$SH_VER:TM:Update output fits with standard keywords at $SECONDS" >> $JOB
######################################
# assemble what you will need to know
######################################
if [ -z "$USPINAME" ]; then
USPINAME="NOT AVAILABLE"
fi
if [ -z "$USPIADR1" ]; then
USPIADR1=" "
fi
if [ -z "$USPIADR2" ]; then
USPIADR2=" "
fi
if [ -z "$USPIADR3" ]; then
USPIADR3=" "
fi
if [ -z "$USPIADR4" ]; then
USPIADR4=" "
fi
if [ -z "$USPIADR5" ]; then
USPIADR5=" "
fi
if [ -z "$USPIEADR" ]; then
USPIEADR=" "
fi
if [ -z "$JPPINAME" ]; then
JPPINAME="NOT AVAILABLE"
fi
if [ -z "$JPPIADR1" ]; then
JPPIADR1=" "
fi
if [ -z "$JPPIADR2" ]; then
JPPIADR2=" "
fi
if [ -z "$JPPIADR3" ]; then
JPPIADR3=" "
fi
if [ -z "$JPPIADR4" ]; then
JPPIADR4=" "
fi
if [ -z "$JPPIADR5" ]; then
JPPIADR5=" "
fi
if [ -z "$JPPIEADR" ]; then
JPPIEADR=" "
fi
sed -e 's/,a,/,h,/' $FTOOLS/fmodhead.par > fmodhead.par
$FTOOLS/pset ./fmodhead.par tmpfil=fmodhead.txt
echo "SEQNUM $SEQUENCE / Sequential number from ODB" > fmodhead.txt
echo "SEQPNUM $PROCEXT / Number of times sequence processed" >> fmodhead.txt
echo "PROCVER $PROC_VER / Processing Configuration number" >> fmodhead.txt
if [ "$USPINUM" -gt 0 ]; then
echo "USPINUM $USPINUM" >> fmodhead.txt
echo "USPINAME '$USPINAME'" >> fmodhead.txt
echo "USPIADR1 '$USPIADR1'" >> fmodhead.txt
echo "USPIADR2 '$USPIADR2'" >> fmodhead.txt
echo "USPIADR3 '$USPIADR3'" >> fmodhead.txt
echo "USPIADR4 '$USPIADR4'" >> fmodhead.txt
echo "USPIADR5 '$USPIADR5'" >> fmodhead.txt
echo "USPIEADR '$USPIEADR'" >> fmodhead.txt
fi
if [ "$JPPINUM" -gt 0 ]; then
echo "JPPINUM $JPPINUM" >> fmodhead.txt
echo "JPPINAME '$JPPINAME'" >> fmodhead.txt
echo "JPPIADR1 '$JPPIADR1'" >> fmodhead.txt
echo "JPPIADR2 '$JPPIADR2'" >> fmodhead.txt
echo "JPPIADR3 '$JPPIADR3'" >> fmodhead.txt
echo "JPPIADR4 '$JPPIADR4'" >> fmodhead.txt
echo "JPPIADR5 '$JPPIADR5'" >> fmodhead.txt
echo "JPPIEADR '$JPPIEADR'" >> fmodhead.txt
fi
for file in $(cat tape.create); do
if [ "$file" = "${file##*/}" ]; then
$FTOOLS/pset ./fmodhead.par infile="$file[0]"
$FTOOLS/fmodhead >> $JOB 2> log.tmp
errchk log.tmp "FMODHEAD $LINENO" fmodhead.par
fi
done
echo "SEQNUM $SEQUENCE / Sequential number from ODB" > fmodhead.txt
echo "SEQPNUM $PROCEXT / Number of times sequence processed" >> fmodhead.txt
for file in $(cat tape.create); do
if [ $($BIN/recmp $file "\.img") -eq 0 ] ||
[ $($BIN/recmp $file "\.detimg") -eq 0 ] ||
[ $($BIN/recmp $file "_img_gif\.wrap") -eq 0 ] ||
[ $($BIN/recmp $file "teldef_ascalin\.fits") -eq 0 ]; then
continue
fi
if [ "$file" = "${file##*/}" ]; then
$FTOOLS/pset ./fmodhead.par infile="$file[1]"
$FTOOLS/fmodhead >> $JOB 2> log.tmp
errchk log.tmp "FMODHEAD $LINENO" fmodhead.par
fi
done
rm -f fmodhead.par fmodhead.txt
################################################################################
# Run fverify on contents of tape.create.
##############################################################################
echo "$SH_VER:TM:Begin fverify of tape.create contents at $SECONDS" >> $JOB
sed -e 's/,a,/,h,/' $FTOOLS/fverify.par > fverify.par
$FTOOLS/pset ./fverify.par prhead=no
$FTOOLS/pset ./fverify.par testdata=yes
for file in $(cat tape.create); do
$FTOOLS/pset ./fverify.par infile="$file"
$FTOOLS/pset ./fverify.par prhead=no
$FTOOLS/pset ./fverify.par testdata=no
$FTOOLS/fverify >> $JOB 2> log.tmp
errchk log.tmp "FVERIFY $LINENO" fverify.par
done
rm -f fverify.par
################################################################################
# WRITE FINAL DATA TO $JOB
# The $JOB is closed from the point-of-view of operations
##############################################################################
echo "$SH_VER:TM:Job end at $SECONDS" $(date) >> $JOB
###############################################################################
# tell the automation we ended OK
##############################################################################
echo "$SEQUENCE $PROC_VER END $(date +%y%m%d%H%M%S)" >> $PROC_HIST
###########################################################
# exit the script, printing the error log when doing so
##########################################################
shexit 0
###############################################################################
# Thats all folks
###############################################################################
#