#!/bin/sh
# Script Name:  nos_ofs_create_forcing_obc.sh
#
# Purpose:
#   This program is used to generate Open Boundary Condition file for NOS OFS.
#   subtidal water levels are from NCEP Extra Tropical Storm Surge (ETSS)
#   gridded operational products of grib2 files. The temperature and salinity open boundary
#   conditions are generated from Navy Coastal Ocean Modeling (NCOM) operational products
#   if DBASE_TS=NCOM or from climatological dataset World Ocean Atlas 2005 if DBASE_TS=WOA05.
#   The most recently available products for the given time is searched and read in.
#   Several horizontal interpolation methods (determined by IGRD_OBC) are implemented,
#   and linear method is used for vertical interpolation from NCOM vertical coordinates
#   to ROMS sigma coordinates. Tidal forcing can also be generated from ADCIRC EC2001
#   database, and adjusted by the provided harmonic constants if needed.

#   The missing variables are filled with a missing value of -99999.0.
#
# Directory Location:   ~/scripts 
# Technical Contact:   	Aijun Zhang         Org:  NOS/CO-OPS
#                       Phone: 301-7132890 ext. 127  E-Mail: aijun.zhang@noaa.gov
#
# Usage: ./nos_ofs_create_forcing_obc.sh OFS 
#
# Input Parameters:
#  OFS:         Name of Operational Forecast System, e.g., TBOFS, CBOFS, DBOFS
#  TIME_START:  start time to grab data, e.g., YYYYMMDDHH (2008101500)
#  TIME_END:    end time to grab data, e.g., YYYYMMDDHH (2008101600)
#  DBASE_WL:    Data source Name of water level open boundary conditions
#
# Language:   Bourne Shell Script      
#
# Target Computer:  Super Computer at NCEP
#
# Estimated Execution Time: 300s 
#
# Suboutines/Functions Called:
#
# Input Files:
#   ROMS ocean model grid netCDF file  
# Output Files:
#   nos.ofs.${RUN}.obc.$yyyy$mm$dd.t${cyc}z.nc   
#   nos.ofs.${RUN}.roms.tides.nc
#   Fortran_OBC.log
#   Fortran_Tide.log
#
# Libraries Used: see the makefile
#  
# Error Conditions:
#  
# Modification History:
#  (1). Degui Cao
#       Implementation                    01/14/2010
#
# -------------------------------------------------------------------------
set -xa

echo 'The script nos_ofs_create_forcing_obc.sh started at UTC' `date -u +%Y%m%d%H`
echo 'The script nos_ofs_create_forcing_obc.sh started at UTC' `date -u +%Y%m%d%H` >> $jlogfile
echo 'The script nos_ofs_create_forcing_obc.sh started at UTC' `date -u +%Y%m%d%H` >> $nosjlogfile

TIME_START=$time_hotstart
TIME_END=$time_forecastend
TIME_NOW=$time_nowcastend
DBASE_WL=$DBASE_WL_NOW
DBASE_TS=$DBASE_TS_NOW

typeset -Z2 HH HH3 CYCLE
YYYY=`echo $TIME_START | cut -c1-4 `
MM=`echo $TIME_START |cut -c5-6 `
DD=`echo $TIME_START |cut -c7-8 `
HH=`echo $TIME_START |cut -c9-10 `

##  create tidal forcing netCDF file for ROMS
if [ $OCEAN_MODEL == "ROMS" -o $OCEAN_MODEL == "roms" ]
then
 if [ $CREATE_TIDEFORCING -gt 0 -o ! -s $HC_FILE_OFS ]; then
  echo 'creating tidal forcing netCDF file for ROMS !!! '
  rm -f Fortran_Tide.ctl Fortran_Tide.log
  echo ${RUN} > Fortran_Tide.ctl
  echo $OCEAN_MODEL >> Fortran_Tide.ctl
  echo ${TIME_START}00 >> Fortran_Tide.ctl
  echo $GRIDFILE >> Fortran_Tide.ctl
  echo $HC_FILE_OBC >> Fortran_Tide.ctl
  echo $HC_FILE_OFS >> Fortran_Tide.ctl
  echo $BASE_DATE >> Fortran_Tide.ctl 

  export pgm=nos_ofs_create_forcing_obc_tides
  . ./prep_step

  ./startmsg

  $EXECnos/nos_ofs_create_forcing_obc_tides < Fortran_Tide.ctl > Fortran_Tide.log
  export err=$?

  if [ $err -ne 0 ]
  then
    echo "$pgm did not complete normally, critical failure!"
    msg="$pgm did not complete normally, critical failure!"
    ./postmsg "$jlogfile" "$msg"
    ./postmsg "$nosjlogfile" "$msg"
    ./err_chk
  else
    echo "$pgm completed normally"
    msg="$pgm completed normally"
    ./postmsg "$jlogfile" "$msg"
    ./postmsg "$nosjlogfile" "$msg"
  fi

## output corms flag information
  if grep "COMPLETED SUCCESSFULLY" Fortran_Tide.log /dev/null 2>&1
  then
     echo "TIDAL FORCING COMPLETED SUCCESSFULLY 100" >> $CORMSLOG
     echo "TIDAL_FORCING DONE 100 " >> $CORMSLOG

  else
     echo "TIDAL FORCING COMPLETED SUCCESSFULLY 0" >> $CORMSLOG
     echo "TIDAL_FORCING DONE 0 " >> $CORMSLOG
  fi
 else
  echo "USE OLD TIDAL FORCING FILE 100" >> $CORMSLOG
  echo "TIDAL_FORCING DONE 100 " >> $CORMSLOG 
 fi
fi
# for sure to get enough data, two more hours will be acquired. 
#TIME_START=`$NDATE -1 $TIME_START `
#TIME_END=`$NDATE +1 $TIME_END `

#  create Open Boundary forcing File (subtidal WL, T, and S)for OFS
if [ -s ETSS_FILE ]
then
   rm -f ETSS_FILE
fi   
#if [ $DBASE_WL == "ETSS" ]
#then
# --------------------------------------------------------------------------
#     process ETSS using wgrib utility
#     Find the first available ETSS forecast file by the provided start time       
# --------------------------------------------------------------------------
echo 'process ETSS from : ' $time_hotstart 'to ' $time_forecastend
CYCLE=$HH
NCEPPRODDIR=${COMETSS}'/gfs.'$YYYY$MM$DD
GRB2FILE=${NCEPPRODDIR}/"mdlsurgegrid."${CYCLE}"con"

INPUTTIME=$YYYY$MM$DD$CYCLE
CURRENTTIME=$INPUTTIME

while [ ! -s $GRB2FILE ]
do
   echo 'grib2 file is ' $GRB2FILE 'not found'
   CURRENTTIME=`$NDATE -1 $CURRENTTIME `
   if [ $CURRENTTIME -le ` $NDATE -60 $INPUTTIME ` ]
   then
    echo 'no valid ETSS operational products is available for the given time period'
    msg="ABNORMAL EXIT: no valid ETSS operational products is available for the given time period   "
    ./postmsg "$jlogfile" "$msg"
    ./postmsg "$nosjlogfile" "$msg"
    err=1;export err;err_chk
    touch err.${RUN}.$PDY1.t${HH}z
    exit
   fi
   YYYY=`echo $CURRENTTIME | cut -c1-4 `
   MM=`echo $CURRENTTIME |cut -c5-6 `
   DD=`echo $CURRENTTIME |cut -c7-8 `
   CYCLE=`echo $CURRENTTIME |cut -c9-10 `
   NCEPPRODDIR=${COMETSS}'/gfs.'$YYYY$MM$DD
   GRB2FILE=${NCEPPRODDIR}/"mdlsurgegrid."${CYCLE}"con"
done
echo "first ETSS grib2 file : " $GRB2FILE " is found"
echo "Time of the first available ETSS products is at cycle" $YYYY $MM $DD $CYCLE
echo $GRB2FILE > ETSS_FILE
echo $CURRENTTIME >> ETSS_FILE
while [ $CURRENTTIME -le $TIME_NOW ]
do 
   CURRENTTIME=`$NDATE +1 $CURRENTTIME `
   YYYY=`echo $CURRENTTIME | cut -c1-4 `
   MM=`echo $CURRENTTIME |cut -c5-6 `
   DD=`echo $CURRENTTIME |cut -c7-8 `
   CYCLE=`echo $CURRENTTIME |cut -c9-10 `
   NCEPPRODDIR=${COMETSS}'/gfs.'$YYYY$MM$DD
   GRB2FILE=${NCEPPRODDIR}/"mdlsurgegrid."${CYCLE}"con"
   if [ -s $GRB2FILE ]
   then
      echo $GRB2FILE >> ETSS_FILE
      echo $CURRENTTIME >> ETSS_FILE
   fi  
done  
rm -f ${OFS}.ETSS
if [ -s ETSS_FILE ]
then
   exec 5<&0 < ETSS_FILE
   read GRB2FILE1
   read CURRENTTIME1
   while read GRB2FILE2 
   do
      read CURRENTTIME2
      LENGTH=` $NHOUR $CURRENTTIME2 $CURRENTTIME1 `
      echo 'LENGTH= ' $LENGTH
      N=1
      while (( N <= $LENGTH))
      do
	 rm -f tmp.csv
	 $WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv
	 export err=$?
	 if [ $err -ne 0 ]
	 then
	   echo "$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv did not complete normally, critical failure!"
	   msg="$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv did not complete normally, critical failure!"
	   ./postmsg "$nosjlogfile" "$msg"
	   ./err_chk
	 else
	   echo "$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv completed normally!"
	   msg="$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv  completed normally!"
	   ./postmsg "$nosjlogfile" "$msg"
	 fi
	 cat tmp.csv >> ${OFS}.ETSS
	 (( N = N + 1 ))
      done
      CURRENTTIME1=$CURRENTTIME2
      GRB2FILE1=$GRB2FILE2 
   done 3<&-  
   N=1
   while (( N <= 97))
   do
      rm -f tmp.csv
      $WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv
      export err=$?
      if [ $err -ne 0 ]
      then
	echo "$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv did not complete normally, critical failure!"
	msg="$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv did not complete normally, critical failure!"
	./postmsg "$nosjlogfile" "$msg"
	./err_chk
      else
	echo "$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv completed normally!"
	msg="$WGRIB2 $GRB2FILE1 -d $N -undefine out-box ${MINLON}:${MAXLON} ${MINLAT}:${MAXLAT} -spread tmp.csv  completed normally!"
	./postmsg "$nosjlogfile" "$msg"
      fi
      cat tmp.csv >> ${OFS}.ETSS
      (( N = N + 1 ))
   done
fi
# --------------------------------------------------------------------------
#     End of decode ETSS grib2 forecast products
# --------------------------------------------------------------------------
#     Find and Process available RTOFS NetCDF files       
# --------------------------------------------------------------------------
if [ $DBASE_TS == 'RTOFS' ]; then
  COMNCOM=$COMRTOFS_3D
  echo 'process G-RTOFS from : ' $TIME_START 'to ' $TIME_END
  typeset -Z2 HH HH3 CYCLE
  typeset -Z3 fhr
  TIME_STARTm1=`$NDATE -24 $TIME_START `   # increase for one day = 24 hours
   YYYY=`echo $TIME_STARTm1 | cut -c1-4 `
  MM=`echo $TIME_STARTm1 |cut -c5-6 `
  DD=`echo $TIME_STARTm1 |cut -c7-8 `
  HH=`echo $TIME_STARTm1 |cut -c9-10 `
  CYCLE=00
  reg=reg1
  if [ $OFS == "CREOFS" -o $OFS == "creofs" -o $OFS == "SFBOFS" -o $OFS == "sfbofs" ]; then
    reg=reg2
  fi
  FILESIZE=800000000
  if [ $reg == "reg1" ]; then
     FILESIZE=800000000
  elif [ $reg == "reg2" ]; then
    FILESIZE=1100000000
  elif [ $reg == "reg3" ]; then
    FILESIZE=390000000
  fi
  TMPDATE[1]='0000000000'
  TMPFILE[1]=''
  LASTDATE='0000000000'
  NFILE=0
  CURRENTTIME=$YYYY$MM${DD}00

  if [ -s RTOFS_FILE ]; then
     rm -f  RTOFS_FILE
  fi  
  while [ $CURRENTTIME -le $TIME_NOW ]
  do 
     YYYY=`echo $CURRENTTIME |cut -c1-4 `
       MM=`echo $CURRENTTIME |cut -c5-6 `
       DD=`echo $CURRENTTIME |cut -c7-8 `
    NCEPPRODDIR=${COMRTOFS_3D}'/rtofs.'$YYYY$MM$DD
#    if [ $envir = "dev" ]; then
#      NCEPPRODDIR=${LOCALRTOFS}'/rtofs.'$YYYY$MM$DD
#    fi  
    N=24
    while (( N >= 0))
    do
      fhr=$N
      CDFFILE=${NCEPPRODDIR}/"rtofs_glo_3dz_n"${fhr}"_6hrly_hvr_${reg}.nc"
      if [ -s $CDFFILE ]; then
        filesize=`wc -c $CDFFILE | awk '{print $1}' `
        if [ $filesize -gt $FILESIZE ]; then
          TMPDATE1=`$NDATE -${fhr} $YYYY$MM${DD}00 `
	  if [ $TMPDATE1 -gt $LASTDATE ]; then
	     TMPDATE[NFILE]=$TMPDATE1
	     TMPFILE[NFILE]=$CDFFILE
	     LASTDATE=$TMPDATE1
             NFILE=`expr $NFILE + 1`
          fi 
        fi  
      fi  
      (( N = N - 1 ))
    done  
    CURRENTTIME=`$NDATE +24 $CURRENTTIME `   # increase for one day = 24 hours
  done
  NFILE_ANALYSIS=`expr $NFILE - 1`
  echo NFILE_ANALYSIS=$NFILE_ANALYSIS
  TIME_STARTm1=`$NDATE -24 $TIME_START `   # increase for one day = 24 hours
  YYYY=`echo $TIME_STARTm1 | cut -c1-4 `
  MM=`echo $TIME_STARTm1 |cut -c5-6 `
  DD=`echo $TIME_STARTm1 |cut -c7-8 `
  HH=`echo $TIME_STARTm1 |cut -c9-10 `
#  CURRENTTIME=$TIME_START
  CURRENTTIME=$YYYY$MM${DD}00
  NCEPPRODDIR=${COMRTOFS_3D}'/rtofs.'$YYYY$MM$DD
#  if [ $envir = "dev" ]; then
#    NCEPPRODDIR=${LOCALRTOFS}'/rtofs.'$YYYY$MM$DD
#  fi  
  NFILE9=`ls -l ${NCEPPRODDIR}/rtofs_glo_3dz_f*_6hrly_hvr_${reg}.nc | wc -l`
  if [ $NFILE9 -le 0 ]; then
    echo 'No RTOFS is found in '${NCEPPRODDIR}
    CURRENTTIME=`$NDATE -24 $CURRENTTIME`
    YYYY=`echo $CURRENTTIME |cut -c1-4 `
    MM=`echo $CURRENTTIME |cut -c5-6 `
    DD=`echo $CURRENTTIME |cut -c7-8 `
    NCEPPRODDIR=${COMRTOFS_3D}'/rtofs.'$YYYY$MM$DD
#    if [ $envir = "dev" ]; then
#       NCEPPRODDIR=${LOCALRTOFS}'/rtofs.'$YYYY$MM$DD
#    fi  
    NFILE9=`ls -l ${NCEPPRODDIR}/rtofs_glo_3dz_f*_6hrly_hvr_${reg}.nc | wc -l`
    if [ $NFILE9 -le 0 ]; then
      echo 'No RTOFS is found in '${NCEPPRODDIR}
      CURRENTTIME=`$NDATE -24 $YYYY$MM${DD}00 `
      YYYY=`echo $CURRENTTIME |cut -c1-4 `
      MM=`echo $CURRENTTIME |cut -c5-6 `
      DD=`echo $CURRENTTIME |cut -c7-8 `
      NCEPPRODDIR=${COMRTOFS_3D}'/rtofs.'$YYYY$MM$DD
#      if [ $envir = "dev" ]; then
#         NCEPPRODDIR=${LOCALRTOFS}'/rtofs.'$YYYY$MM$DD
#      fi  
      NFILE9=`ls -l ${NCEPPRODDIR}/rtofs_glo_3dz_f*_6hrly_hvr_${reg}.nc | wc -l`
    fi
  fi
  while [ $CURRENTTIME -le $TIME_NOW ]
  do 
     YYYY=`echo $CURRENTTIME |cut -c1-4 `
       MM=`echo $CURRENTTIME |cut -c5-6 `
       DD=`echo $CURRENTTIME |cut -c7-8 `
    CYCLE=`echo $CURRENTTIME |cut -c9-10 `
    NCEPPRODDIR=${COMRTOFS_3D}'/rtofs.'$YYYY$MM$DD
#    if [ $envir = "dev" ]; then
#       NCEPPRODDIR=${LOCALRTOFS}'/rtofs.'$YYYY$MM$DD
#    fi  
    N=1
    while (( N <= 72))
    do
      fhr=$N
      CDFFILE=${NCEPPRODDIR}/rtofs_glo_3dz_f${fhr}_6hrly_hvr_${reg}.nc
      if [ -s $CDFFILE ]; then
        filesize=`wc -c $CDFFILE | awk '{print $1}' `
        if [ $filesize -gt $FILESIZE ]; then
         TMPDATE1=`$NDATE +${fhr} $YYYY$MM${DD}00 `
	 if [ $TMPDATE1 -gt $LASTDATE ]; then
	     TMPDATE[NFILE]=$TMPDATE1
	     TMPFILE[NFILE]=$CDFFILE
	     LASTDATE=$TMPDATE1
             NFILE=`expr $NFILE + 1`
         fi 
         I=`expr $NFILE_ANALYSIS + 1`
         while (( I < $NFILE ))
         do
	    if [ $TMPDATE1 -eq ${TMPDATE[I]} ]; then
	      TMPDATE[I]=$TMPDATE1
	      TMPFILE[I]=$CDFFILE
            fi 
            (( I = I + 1 ))
         done  
        fi 
      fi  
      (( N = N + 1 ))
    done  
    CURRENTTIME=`$NDATE +24 $CURRENTTIME `
  done
  I=0
  while (( I < $NFILE ))
  do
    if [ ${TMPDATE[I]} -ge $TIME_START -a ${TMPDATE[I]} -le $TIME_END ]; then
      echo ${TMPFILE[I]} >> RTOFS_FILE
    fi   
    (( I = I + 1 ))
  done  
  if [ ! -s ${RTOFS_FILE} ]; then
     DBASE_TS='NCOM'
  fi  
fi
# --------------------------------------------------------------------------
#     Find and Process available NCOM forecast files by the provided start time       
# --------------------------------------------------------------------------
if [ $DBASE_TS == 'NCOM' ]; then
  echo 'Find Good NCOM files from : ' $time_hotstart 'to ' $time_forecastend
  if [ -s NCOM_FILE ]; then
    rm -f NCOM_FILE
  fi   
  YYYY=`echo $TIME_START | cut -c1-4 `
  MM=`echo $TIME_START |cut -c5-6 `
  DD=`echo $TIME_START |cut -c7-8 `
  HH=`echo $TIME_START |cut -c9-10 `
  CYCLE=00
  NCOM_PRE="ncom_glb_regp01_"
  NCOM_PRE_TIDE="ncom_glb_regp01_tides_"
  FILESIZE=570000000
  if [ $OFS == "CREOFS" -o $OFS == "creofs" -o $OFS == "SFBOFS" -o $OFS == "sfbofs" ]; then
    NCOM_PRE="ncom_glb_regp07_"
    NCOM_PRE_TIDE="ncom_glb_regp07_tides_"
    FILESIZE=460000000
  fi
  NCEPPRODDIR=${COMNCOM}'/'$YYYY$MM$DD/wgrdbul
  NCOMFILE=${NCEPPRODDIR}/${NCOM_PRE}$YYYY$MM$DD${CYCLE}".nc.gz"
  NCOMTIDE=${NCEPPRODDIR}/${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}".nc.gz"
  INPUTTIME=$YYYY$MM$DD$CYCLE
  CURRENTTIME=$INPUTTIME
  if [ -s $NCOMFILE ]
  then
    filesize=`wc -c $NCOMFILE | awk '{print $1}' `
    if [ $filesize -lt $FILESIZE ]
    then
      echo 'Size of theNCOM file is too small'
      CURRENTTIME=`$NDATE -1 $CURRENTTIME `
      YYYY=`echo $CURRENTTIME | cut -c1-4 `
      MM=`echo $CURRENTTIME |cut -c5-6 `
      DD=`echo $CURRENTTIME |cut -c7-8 `
      CYCLE=`echo $CURRENTTIME |cut -c9-10 `
      NCEPPRODDIR=${COMNCOM}'/'$YYYY$MM$DD/wgrdbul
#     NCOMFILE=${NCEPPRODDIR}/"ncom_glb_regp01_"$YYYY$MM$DD${CYCLE}".nc.gz"
#     NCOMTIDE=${NCEPPRODDIR}/"ncom_glb_regp01_tides_"$YYYY$MM$DD${CYCLE}".nc.gz"
      NCOMFILE=${NCEPPRODDIR}/${NCOM_PRE}$YYYY$MM$DD${CYCLE}".nc.gz"
      NCOMTIDE=${NCEPPRODDIR}/${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}".nc.gz"

    fi 
  fi  
  while [ ! -s $NCOMFILE ]
  do
    echo 'NCOM file is ' $NCOMFILE 'not found'
    CURRENTTIME=`$NDATE -1 $CURRENTTIME `
    if [ $CURRENTTIME -le ` $NDATE -72 $INPUTTIME ` ]
    then
       echo 'no valid NCOM operational products is available for the given time period'
       msg="ABNORMAL EXIT: no valid NCOM operational products is available for the given time period   "
       ./postmsg "$jlogfile" "$msg"
       ./postmsg "$nosjlogfile" "$msg"
       DBASE_TS='WOA05'
       DBASE_WL='ETSS'
    fi
    YYYY=`echo $CURRENTTIME | cut -c1-4 `
    MM=`echo $CURRENTTIME |cut -c5-6 `
    DD=`echo $CURRENTTIME |cut -c7-8 `
    CYCLE=`echo $CURRENTTIME |cut -c9-10 `
    NCEPPRODDIR=${COMNCOM}'/'$YYYY$MM$DD/wgrdbul
 #  NCOMFILE=${NCEPPRODDIR}/"ncom_glb_regp01_"$YYYY$MM$DD${CYCLE}".nc.gz"
 #  NCOMTIDE=${NCEPPRODDIR}/"ncom_glb_regp01_tides_"$YYYY$MM$DD${CYCLE}".nc.gz"
    NCOMFILE=${NCEPPRODDIR}/${NCOM_PRE}$YYYY$MM$DD${CYCLE}".nc.gz"
    NCOMTIDE=${NCEPPRODDIR}/${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}".nc.gz"

  done
  filesize=`wc -c $NCOMFILE | awk '{print $1}' `
  if [ $filesize -gt $FILESIZE ]
  then
    gunzip -c $NCOMFILE >  ${NCOM_PRE}$YYYY$MM$DD${CYCLE}.nc
    if [ -s $NCOMTIDE ]
    then
      gunzip -c $NCOMTIDE >  ${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}.nc
    fi
    echo ${NCOM_PRE}$YYYY$MM$DD${CYCLE}.nc  > NCOM_FILE
    echo ${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}.nc  >> NCOM_FILE
#   echo ncom_glb_regp01_"$YYYY$MM$DD${CYCLE}".nc > NCOM_FILE
#   echo ncom_glb_regp01_tides_"$YYYY$MM$DD${CYCLE}".nc >> NCOM_FILE
  fi  
  echo "first NCOM file : " $NCOMFILE " is found"
  echo "Time of the first available NCOM products is at cycle" $YYYY $MM $DD $CYCLE
  while [ $CURRENTTIME -le $TIME_NOW ]
  do 
    CURRENTTIME=`$NDATE +1 $CURRENTTIME `
    YYYY=`echo $CURRENTTIME | cut -c1-4 `
    MM=`echo $CURRENTTIME |cut -c5-6 `
    DD=`echo $CURRENTTIME |cut -c7-8 `
    CYCLE=`echo $CURRENTTIME |cut -c9-10 `
    NCEPPRODDIR=${COMNCOM}'/'$YYYY$MM$DD/wgrdbul
#   NCOMFILE=${NCEPPRODDIR}/"ncom_glb_regp01_"$YYYY$MM$DD${CYCLE}".nc.gz"
#   NCOMTIDE=${NCEPPRODDIR}/"ncom_glb_regp01_tides_"$YYYY$MM$DD${CYCLE}".nc.gz"
    NCOMFILE=${NCEPPRODDIR}/${NCOM_PRE}$YYYY$MM$DD${CYCLE}".nc.gz"
    NCOMTIDE=${NCEPPRODDIR}/${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}".nc.gz"

    if [ -s $NCOMFILE ]
    then
      filesize=`wc -c $NCOMFILE | awk '{print $1}' `
      if [ $filesize -gt $FILESIZE ]
      then
        gunzip -c $NCOMFILE >  ${NCOM_PRE}$YYYY$MM$DD${CYCLE}.nc
        if [ -s $NCOMTIDE ]
        then
          gunzip -c $NCOMTIDE >  ${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}.nc
        fi

 #      gunzip -c $NCOMFILE >  ncom_glb_regp01_"$YYYY$MM$DD${CYCLE}".nc
 #      if [ -s $NCOMTIDE ]
 #      then
 #        gunzip -c $NCOMTIDE >  ncom_glb_regp01_tides_"$YYYY$MM$DD${CYCLE}".nc
 #      fi
 #      echo ncom_glb_regp01_"$YYYY$MM$DD${CYCLE}".nc >> NCOM_FILE
 #      echo ncom_glb_regp01_tides_"$YYYY$MM$DD${CYCLE}".nc >> NCOM_FILE
        echo ${NCOM_PRE}$YYYY$MM$DD${CYCLE}.nc  >> NCOM_FILE
        echo ${NCOM_PRE_TIDE}$YYYY$MM$DD${CYCLE}.nc  >> NCOM_FILE

      fi  
    fi  
  done  
fi
# --------------------------------------------------------------------------
#     End of searching NCOM forecast files       
# --------------------------------------------------------------------------
if [ $DBASE_WL == RTOFS ]; then
  TMPDATE[1]='0000000000'
  TMPFILE[1]=''
  LASTDATE='0000000000'
  NFILE=0
  CURRENTTIME=`$NDATE -24 $TIME_START `   # increase for one day = 24 hours
#  CURRENTTIME=$TIME_START
  if [ -s RTOFS_FILE_WL ]; then
     rm -f  RTOFS_FILE_WL
  fi  
  while [ $CURRENTTIME -le $TIME_NOW ]
  do 
     YYYY=`echo $CURRENTTIME |cut -c1-4 `
       MM=`echo $CURRENTTIME |cut -c5-6 `
       DD=`echo $CURRENTTIME |cut -c7-8 `
    CYCLE=`echo $CURRENTTIME |cut -c9-10 `
#    NCEPPRODDIR=/com/rtofs/prod'/rtofs.'$YYYY$MM$DD
    NCEPPRODDIR=${COMRTOFS_2D}'/rtofs.'$YYYY$MM$DD
    N=24
    while (( N >= 0))
    do
      fhr=$N
      CDFFILE=${NCEPPRODDIR}/rtofs_glo_2ds_n"${fhr}"_3hrly_diag.nc
      if [ $N -eq 0 ]; then
         CDFFILE=${NCEPPRODDIR}/rtofs_glo_2ds_n048_3hrly_diag.nc
      fi  
      if [ -s $CDFFILE ]; then
         TMPDATE1=`$NDATE -${fhr} $YYYY$MM${DD}00 `
	 if [ $TMPDATE1 -gt $LASTDATE ]; then
	     TMPDATE[NFILE]=$TMPDATE1
	     TMPFILE[NFILE]=$CDFFILE
	     LASTDATE=$TMPDATE1
             NFILE=`expr $NFILE + 1`
         fi 
      fi  
      (( N = N - 1 ))
    done  
    CURRENTTIME=`$NDATE +24 $CURRENTTIME `   # increase for one day = 24 hours
  done
  NFILE_ANALYSIS=`expr $NFILE - 1`
  CURRENTTIME=$TIME_START
  while [ $CURRENTTIME -le $TIME_NOW ]
  do 
     YYYY=`echo $CURRENTTIME |cut -c1-4 `
       MM=`echo $CURRENTTIME |cut -c5-6 `
       DD=`echo $CURRENTTIME |cut -c7-8 `
    CYCLE=`echo $CURRENTTIME |cut -c9-10 `
    NCEPPRODDIR=${COMRTOFS_2D}'/rtofs.'$YYYY$MM$DD
#    NCEPPRODDIR=/com/rtofs/prod'/rtofs.'$YYYY$MM$DD
    N=1
    while (( N <= 72))
    do
      fhr=$N
      CDFFILE=${NCEPPRODDIR}/rtofs_glo_2ds_f"${fhr}"_3hrly_diag.nc
      if [ -s $CDFFILE ]; then
         TMPDATE1=`$NDATE +${fhr} $YYYY$MM${DD}00 `
	 if [ $TMPDATE1 -gt $LASTDATE ]; then
	     TMPDATE[NFILE]=$TMPDATE1
	     TMPFILE[NFILE]=$CDFFILE
	     LASTDATE=$TMPDATE1
             NFILE=`expr $NFILE + 1`
         fi 
         I=`expr $NFILE_ANALYSIS + 1`
         while (( I < $NFILE ))
         do
	    if [ $TMPDATE1 -eq ${TMPDATE[I]} ]; then
	      TMPDATE[I]=$TMPDATE1
	      TMPFILE[I]=$CDFFILE
            fi 
            (( I = I + 1 ))
         done  
      fi  
      (( N = N + 1 ))
    done  
    CURRENTTIME=`$NDATE +24 $CURRENTTIME `
  done
  I=0
  while (( I < $NFILE ))
  do
   if [ ${TMPDATE[I]} -ge $TIME_START -a ${TMPDATE[I]} -le $TIME_END ]; then
      echo ${TMPFILE[I]} >> RTOFS_FILE_WL
   fi   
   (( I = I + 1 ))
  done  
  if [ ! -s $RTOFS_FILE_WL ]; then
    export DBASE_WL="ETSS"
  fi
fi
#     begin to generate OBC forcing file
# --------------------------------------------------------------------------
if [ $DBASE_TS == "WOA05" ]; then
   DBASE_WL="ETSS"
fi
if [ -s Fortran_OBC.ctl ]
then
   rm -f Fortran_OBC.ctl Fortran_OBC.log
fi   
echo ${RUN} > Fortran_OBC.ctl
echo $OCEAN_MODEL >> Fortran_OBC.ctl
echo $DBASE_WL  >> Fortran_OBC.ctl
echo ${RUN}.ETSS  >> Fortran_OBC.ctl
echo $DBASE_TS  >> Fortran_OBC.ctl
echo $COMNCOM  >> Fortran_OBC.ctl
echo $COMPORTS  >> Fortran_OBC.ctl
echo $NOSBUFR  >> Fortran_OBC.ctl
echo $USGSBUFR  >> Fortran_OBC.ctl
echo ${TIME_START}00 >> Fortran_OBC.ctl
echo ${TIME_END}00 >> Fortran_OBC.ctl
echo $IGRD_OBC >> Fortran_OBC.ctl
echo $FIXofs >> Fortran_OBC.ctl
if [ $OCEAN_MODEL == "SELFE" -o $OCEAN_MODEL == "selfe" ]
then
  echo $GRIDFILE_LL >> Fortran_OBC.ctl
else
  echo $GRIDFILE >> Fortran_OBC.ctl
fi  
echo $HC_FILE_OFS >> Fortran_OBC.ctl
echo $OBC_CTL_FILE >> Fortran_OBC.ctl
echo $OBC_CLIM_FILE >> Fortran_OBC.ctl
echo $OBC_FORCING_FILE >> Fortran_OBC.ctl
echo $CORMSLOG >> Fortran_OBC.ctl 
echo $BASE_DATE >> Fortran_OBC.ctl 
echo $MINLON  >> Fortran_OBC.ctl
echo $MINLAT >> Fortran_OBC.ctl 
echo $MAXLON >> Fortran_OBC.ctl 
echo $MAXLAT >> Fortran_OBC.ctl 
echo $KBm  >> Fortran_OBC.ctl
if [ $OCEAN_MODEL == "ROMS" -o $OCEAN_MODEL == "roms" ]
then
     echo $THETA_S >> Fortran_OBC.ctl 
     echo $THETA_B >> Fortran_OBC.ctl 
     echo $TCLINE >> Fortran_OBC.ctl 
else    
     echo $VGRID_CTL >> Fortran_OBC.ctl
fi    
echo NCOM_FILE >> Fortran_OBC.ctl
if [ $OCEAN_MODEL == "SELFE" -o $OCEAN_MODEL == "selfe" ]
then
    echo $Nudging_weight >> Fortran_OBC.ctl
    echo $STEP_NU_VALUE >> Fortran_OBC.ctl
fi  
  
export pgm=nos_ofs_create_forcing_obc
. ./prep_step
./startmsg
if [ $OCEAN_MODEL == "ROMS" -o $OCEAN_MODEL == "roms" ]
then
    $EXECnos/nos_ofs_create_forcing_obc < Fortran_OBC.ctl > Fortran_OBC.log
    export err=$?
elif [ $OCEAN_MODEL == "SELFE" -o $OCEAN_MODEL == "selfe" ]
then
    $EXECnos/nos_ofs_create_forcing_obc_selfe < Fortran_OBC.ctl > Fortran_OBC.log
    if [ -s temp_nu.in ]; then
      cp -p temp_nu.in $COMOUT/.
    else
       echo "OBC temp nudging file was not created"   
    fi  
    if [ -s salt_nu.in ]; then
      cp -p salt_nu.in $COMOUT/.
    else
       echo "OBC salt nudging file was not created"   
    fi  
    if [ -s elev3D.th ]; then
      cp -p elev3D.th $COMOUT/.
    else
       echo "WL OBC file was not created"   
    fi  
    export err=$?
    tar -cvf ${OBC_FORCING_FILE} elev3D.th temp_nu.in salt_nu.in
    
elif [ $OCEAN_MODEL == "FVCOM" -o $OCEAN_MODEL == "fvcom" ]
then
    $EXECnos/nos_ofs_create_forcing_obc_fvcom < Fortran_OBC.ctl > Fortran_OBC.log
    export err=$?
fi
## output corms flag information
if grep "COMPLETED SUCCESSFULLY" Fortran_OBC.log /dev/null 2>&1
then
     echo "OBC FORCING COMPLETED SUCCESSFULLY 100" >> $CORMSLOG
     echo "OBC_FORCING DONE 100 " >> $CORMSLOG
else
     echo "OBC FORCING COMPLETED SUCCESSFULLY 0" >> $CORMSLOG
     echo "OBC_FORCING DONE 0 " >> $CORMSLOG
     err=1;export err;err_chk
fi
if [ $err -ne 0 ]
then
   echo "$pgm did not complete normally, critical failure!"
   msg="$pgm did not complete normally, critical failure!"
   ./postmsg "$jlogfile" "$msg"
   ./postmsg "$nosjlogfile" "$msg"
   ./err_chk
else
    echo "$pgm completed normally"
    msg="$pgm completed normally"
    ./postmsg "$jlogfile" "$msg"
    ./postmsg "$nosjlogfile" "$msg"
fi


if [ -f $OBC_FORCING_FILE ]  
then
    cp $OBC_FORCING_FILE $COMOUT/$OBC_FORCING_FILE
    if [ $SENDDBN = YES ]; then
      $DBNROOT/bin/dbn_alert MODEL $DBN_ALERT_TYPE_NETCDF $job $COMOUT/$OBC_FORCING_FILE
    fi
else
   echo "NO $OBC_FORCING_FILE File Found"
fi

if [ -f $HC_FILE_OFS ]
then
    cp $HC_FILE_OFS $COMOUT/$HC_FILE_OFS 
else
    echo "NO $HC_FILE_OFS File Found"
fi

if [ -f Fortran_OBC.log ]
then
    cp Fortran_OBC.log $COMOUT/Fortran_OBC.t${cyc}z.log
else
   echo "NO Fortran_OBC.log Found"
fi

if [ -f Fortran_Tide.log ]
then
    cp Fortran_Tide.log $COMOUT/Fortran_Tide.t${cyc}z.log
else
    echo "NO Fortran_Tide.log Found"
fi

echo 'The script nos_ofs_create_forcing_obc.sh ended at UTC' `date -u +%Y%m%d%H`