mod_set_time Module Reference

Data Types
interface	set_startup_file_stack

Functions/Subroutines
subroutine	setup_time
subroutine	report_time_setup
subroutine	set_model_timestep
subroutine	ideal_time_string2time (string, flag, ntime, tstep)
integer(itime) function	calculate_number_of_timesteps (STIME, ETIME)
subroutine	set_last_file_time (NCF, STIME, STEP)
subroutine	set_startup_file_stack_by_time (STIME, STEP)
subroutine	set_startup_file_stack_by_cycle (step, ATIME)
subroutine	check_startup_file_dimensions
subroutine	get_first_output_time (STRING, FIRST_TIME)
subroutine	get_output_file_interval (STRING, INTERVAL)
subroutine	set_output_file_time (NCF, OUT_INTERVAL, NEXT_TIME, NEXT_STK, PREV_TIME, PREV_STK, STKLEN, STACK_MAX)

Function/Subroutine Documentation

calculate_number_of_timesteps()

integer(itime) function mod_set_time::calculate_number_of_timesteps	(	type(time), intent(in)	STIME,
		type(time), intent(in)	ETIME
	)

Definition at line 1268 of file mod_set_time.f90.

    IMPLICIT NONE
    INTEGER(itime)          :: TSTEP
    TYPE(TIME), INTENT(IN)  :: STIME, ETIME
    real(DP)                :: temp

    
    ! CALCULAT THE NUMBER OF TIME STEPS
    temp = seconds(etime-stime) /  seconds(imdti)
    tstep = ceiling(temp)-1 

Here is the caller graph for this function:

check_startup_file_dimensions()

subroutine mod_set_time::check_startup_file_dimensions

(

)

Definition at line 1460 of file mod_set_time.f90.

    IMPLICIT NONE
    integer                 :: status, I
    real(DP)                :: temp
    TYPE(TIME)              :: Atime
    TYPE(NCFILE), POINTER   :: NCF
    TYPE(NCDIM), POINTER   :: DIM
    logical found
    

!!!!!
!!!! I DON'T THINK WE REALLY NEED TO IMPLIMENT THIS - JUST LET IT
!!!! CRASH LATER!
!!!!!

    IF(.NOT. ASSOCIATED(nc_start)) CALL fatal_error &
         & ("The file object NC_START is not assocaited!")
    


    IF (startup_type .EQ. startup_type_crashrestart .OR. &
         & startup_type .EQ. startup_type_hotstart) THEN
    
       dim => find_dim(nc_start,"nele",found)
       IF(.not. found) CALL fatal_error&
            & ("START FILE IS MISSING A CRITICAL DIMENSION:",&
            &  trim(nc_start%FNAME))
       
       IF (dim%DIM /= ngl) CALL fatal_error&
            & ("START FILE DIMENSION 'nele' DOES NOT MATCH:",&
            &  trim(nc_start%FNAME))
       
       dim => find_dim(nc_start,"node",found)
       IF(.not. found) CALL fatal_error&
            & ("START FILE IS MISSING A CRITICAL DIMENSION:",&
            &  trim(nc_start%FNAME))
       
       IF (dim%DIM /= mgl) CALL fatal_error&
            & ("START FILE DIMENSION 'node' DOES NOT MATCH THE RUN FILE:",&
            &  trim(nc_start%FNAME))
    END IF

    IF(startup_uv_type .eq. startup_type_setvalues .OR. &
         & startup_turb_type .eq. startup_type_setvalues .OR.&
         & startup_ts_type .eq. startup_type_setvalues) THEN
       
       dim => find_dim(nc_start,"siglay",found)
       IF(.not. found) CALL fatal_error&
            & ("RESTART FILE IS MISSING A CRITICAL DIMENSION:",&
            &  trim(nc_start%FNAME))
       
       IF (dim%DIM /= kbm1) CALL fatal_error&
            & ("RESTART FILE DIMENSION 'siglay' DOES NOT MATCH THE RUN FILE:",&
            &  trim(nc_start%FNAME))
       
       dim => find_dim(nc_start,"siglev",found)
       IF(.not. found) CALL fatal_error&
            & ("RESTART FILE IS MISSING A CRITICAL DIMENSION:",&
            &  trim(nc_start%FNAME))
       
       IF (dim%DIM /= kbm1) CALL fatal_error&
            & ("RESTART FILE DIMENSION 'siglay' DOES NOT MATCH THE RUN FILE:",&
            &  trim(nc_start%FNAME))
    END IF

get_first_output_time()

subroutine mod_set_time::get_first_output_time	(	character(len=*), intent(in)	STRING,
		type(time), intent(out)	FIRST_TIME
	)

Definition at line 1527 of file mod_set_time.f90.

    IMPLICIT NONE
    CHARACTER(LEN=*),INTENT(IN) :: STRING
    TYPE(TIME), INTENT(OUT) :: FIRST_TIME
    INTEGER ::STATUS

    if (use_real_world_time) then
       first_time = read_datetime(string,date_format,timezone,status)
       if (status == 0 ) Call fatal_error &
            ("GET_FIRST_OUTPUT_TIME: Could not read the date string: "//trim(string))
    else
       ! THIS IS REALLY THE SAME AS WHAT IS NEEDED IN THIS CASE
       ! REALLY WE ARE GETTING THE START TIME NOT THE INTERVAL
       CALL get_output_file_interval(trim(string),first_time)
    end if
    

Here is the call graph for this function:

Here is the caller graph for this function:

get_output_file_interval()

subroutine mod_set_time::get_output_file_interval	(	character(len=*), intent(in)	STRING,
		type(time), intent(out)	INTERVAL
	)

Definition at line 1547 of file mod_set_time.f90.

    IMPLICIT NONE
    CHARACTER(LEN=*),INTENT(IN) :: STRING
    TYPE(TIME), INTENT(OUT) :: INTERVAL

    CHARACTER(LEN=4) :: FLAG
    TYPE(TIME) :: NTIME
    INTEGER(ITIME) :: tstep
    INTEGER :: I

    CALL  ideal_time_string2time(string,flag,ntime,tstep)

    IF (flag == 'time') THEN ! IF START AND END TIME WERE SPECIFIED

       interval = ntime
    
    ELSE IF(flag == 'step') THEN ! IF START AND END IINT WERE SPECIFIED

       interval= tstep * imdti

    ELSE
       CALL fatal_error('GET_OUTPUT_FILE_INTERVAL: bad flag value?')
    END IF
    

Here is the call graph for this function:

Here is the caller graph for this function:

ideal_time_string2time()

subroutine mod_set_time::ideal_time_string2time	(	character(len=*), intent(in)	string,
		character(len=4), intent(out)	flag,
		type(time), intent(out)	ntime,
		integer(itime), intent(out)	tstep
	)

Definition at line 1200 of file mod_set_time.f90.

    IMPLICIT NONE
    CHARACTER(LEN=*),INTENT(IN) :: STRING
    TYPE(TIME), INTENT(OUT) :: NTIME
    INTEGER(ITIME), INTENT(OUT) :: tstep
    CHARACTER(LEN=4), INTENT(OUT) :: FLAG
    
    INTEGER :: I

    INTEGER :: NLINE, NCHAR, INTVAL(150), NVAL
    REAL(DP) :: REALVAL(150)
    CHARACTER(LEN=40) :: VARNAME 
    CHARACTER(LEN=80) :: STRINGVAL(150)
    CHARACTER(LEN=7) :: VARTYPE
    LOGICAL :: LOGVAL


    nline = -1
    nchar = len_trim(string)
    
    CALL get_value(nline,nchar,string,varname,vartype,logval&
         &,stringval,realval,intval,nval)
    
    
    SELECT CASE(varname)
    CASE('days')
       IF(vartype == 'float')THEN
          ntime= days2time(realval(1))
          flag = "time"
       ELSE
          CALL fatal_error("IDEAL_TIME_STRING2TIME: Unknown Time or Length of Time:",&
               & trim(string), "Bad type (check for missing '.')")
       END IF
    CASE('seconds')
       
       IF(vartype == 'float')THEN
          ntime = seconds2time(realval(1))
          flag = "time"

       ELSE
          CALL fatal_error("IDEAL_TIME_STRING2TIME: Unknown Time or Length of Time:",&
               & trim(string), "Bad type (check for missing '.')")

       END IF
       
    CASE('cycle')
       
       IF(vartype == 'integer')THEN

          tstep = intval(1)
          flag = "step"

       ELSE
          CALL fatal_error("IDEAL_TIME_STRING2TIME: Unknown Time or Length of Time::",&
               & trim(string), "Bad type (remove '.' ?)")
       END IF
       
    CASE DEFAULT
       
          CALL fatal_error("IDEAL_TIME_STRING2TIME: Unknown Time or Length of Time::",&
               & trim(string), "Bad units, can be 'seconds' 'days' or 'cycle'")
       
    END SELECT
    
    

Here is the caller graph for this function:

report_time_setup()

subroutine mod_set_time::report_time_setup

(

)

Definition at line 1111 of file mod_set_time.f90.

    IMPLICIT NONE


    SELECT CASE(use_real_world_time)
    CASE(.true.)

       if(dbg_set(dbg_log)) then

          write(ipt,*) "! This case uses real world with specified start and end dates"


          call print_real_time(starttime,ipt,"Start Time",timezone)


          call print_real_time(endtime,ipt,"End Time",timezone)

          call print_time(imdte,ipt,"External Time STEP")
          write(ipt,*) "! DTE(seconds)       = ",dte
          call print_time(imdti,ipt,"Internal Time STEP")
          write(ipt,*) "! DTI(seconds)       = ",dti

          write(ipt,*) "!============================="
          write(ipt,*) "!  ISTART = ",istart
          write(ipt,*) "!  IEND   = ",iend
          write(ipt,*) "!============================="
          write(ipt,*) "!+++++++++++ FINISED MODEL TIME SETUP ++++++++++++++"
          write(ipt,*) "!==================================================="
       end if
    CASE(.false.)

       if(dbg_set(dbg_log)) then

          write(ipt,*) "!This is an idealized case with a specified runtime"


          call print_time(starttime,ipt,"Start Time")


          call print_time(endtime,ipt,"End Time")
          
          call print_time(imdte,ipt,"External Time STEP")
          write(ipt,*) "! DTE(seconds)       = ",dte
          call print_time(imdti,ipt,"Internal Time STEP")
          write(ipt,*) "! DTI(seconds)       = ",dti


          write(ipt,*) "! ============================="
          write(ipt,*) "!   ISTART = ",istart
          write(ipt,*) "!   IEND   = ",iend
          write(ipt,*) "! ============================="
          write(ipt,*) "! +++++++++++ FINISED MODEL TIME SETUP ++++++++++++++"
          write(ipt,*) "! ==================================================="
       end if
    END SELECT

Here is the caller graph for this function:

set_last_file_time()

subroutine mod_set_time::set_last_file_time	(	type(ncfile), pointer	NCF,
		type(time), intent(out)	STIME,
		integer(itime), intent(out)	STEP
	)

Definition at line 1281 of file mod_set_time.f90.

    IMPLICIT NONE
    TYPE(NCFILE), POINTER   :: NCF
    TYPE(TIME), INTENT(OUT)  :: Stime
    INTEGER(ITIME), INTENT(OUT) :: STEP

    INTEGER, TARGET :: FSTEP
    TYPE(TIME)              :: Atime
    integer                 :: status, I
    real(DP)                :: temp
    TYPE(NCVAR),  POINTER   :: VAR
    logical found
    
    IF(.NOT. ASSOCIATED(ncf)) CALL fatal_error &
         & ("SET_LAST_FILE_TIME: The file object is not assocaited!")
  

    status = set_file_time_type(ncf)
    IF(status /= 0) CALL fatal_error &
         & ("COULD NOT FIND A VALID TIME VARIABLE IN THE RESTART FILE: ",&
         & trim(ncf%FNAME))
    
    
    i = ncf%FTIME%STK_LEN
    
    IF (i .LE. 0) CALL fatal_error("FILE LENGTH IS LESS THAN ONE - NO VALID RESTART TIMES!")

    stime  =get_file_time_ncf(ncf,i)
    
    ncf%FTIME%PREV_STKCNT = i
    ncf%FTIME%PREV_IO     = stime
    
    var => find_var(ncf,'iint',found)
    IF(.not. found) CALL fatal_error("COULD NOT FIND VARIABLE 'iint'&
         & IN THE CRASH RESTART FILE OBJECT")
    var%scl_int => fstep
    CALL nc_read_var(var,i)
    
    step = fstep
    

Here is the caller graph for this function:

set_model_timestep()

subroutine mod_set_time::set_model_timestep

(

)

Definition at line 1171 of file mod_set_time.f90.

    IMPLICIT NONE
    if(dbg_set(dbg_log)) &
         & write(ipt,*) "!========= Setting up model time parameters ==========="


    ! CONVERT EXTSTEP TO MICROSECONDS AND MAKE IT AN INT
    imdte = seconds2time(extstep_seconds)

    ! Get floating point DTE from IMDTE    
    dte = seconds(imdte)

    if(dbg_set(dbg_io)) write(ipt,*) "! IMDTE (microseconds)= ",imdte
    if(dbg_set(dbg_io)) write(ipt,*) "! DTE (seconds)       = ",dte

    if (imdte .LE. zerotime) &
         & Call fatal_error("EXTSTEP_SECONDS must be greater than 10**-6 seconds!")

    if (isplit .LE. 0) &
         & Call fatal_error("ISPLIT must be greater than zero!")

    ! Get DTI from DTE and ISPLIT
    imdti = isplit * imdte
    dti = seconds(imdti)

Here is the caller graph for this function:

set_output_file_time()

subroutine mod_set_time::set_output_file_time	(	type(ncfile), pointer	NCF,
		type(time), intent(in)	OUT_INTERVAL,
		type(time), intent(in)	NEXT_TIME,
		integer, intent(in)	NEXT_STK,
		type(time), intent(in)	PREV_TIME,
		integer, intent(in)	PREV_STK,
		integer, intent(in)	STKLEN,
		integer, intent(in)	STACK_MAX
	)

Definition at line 1575 of file mod_set_time.f90.

    IMPLICIT NONE
    TYPE(NCFILE), POINTER      :: NCF
    TYPE(TIME), INTENT(IN)     :: NEXT_TIME, PREV_TIME
    TYPE(TIME), INTENT(IN) :: OUT_INTERVAL
    INTEGER, INTENT(IN)        :: STACK_MAX,STKLEN,NEXT_STK, PREV_STK

    TYPE(TIME)              :: ZEROTIME
    TYPE(NCFTIME), POINTER  :: FTM
    logical found
    
    IF(dbg_set(dbg_sbr)) WRITE(ipt,*)"SET_OUTPUT_FILE_TIME: START"
    
    IF(dbg_set(dbg_io)) THEN
       WRITE(ipt,*)"=== PRINTING IO INFO FOR: SET_OUTPUT_FILE_TIME ==="
       CALL print_time(out_interval,ipt,"OUT_INTERVAL")
       CALL print_time(next_time,ipt,"NEXT_TIME")
       WRITE(ipt,*)"NEXT_STK=",next_stk
       CALL print_time(prev_time,ipt,"PREV_TIME")
       WRITE(ipt,*)"PREV_STK=",prev_stk
       WRITE(ipt,*)"STKLEN=",stklen
       WRITE(ipt,*)"STACK_MAX=",stack_max
       WRITE(ipt,*)"=== END IO INFO FOR: SET_OUTPUT_FILE_TIME ==="
    END IF

    IF (.NOT.ASSOCIATED(ncf)) CALL fatal_error &
         & ('SET_OUTPUT_FILE_TIME: FILE OBJECT HANDLE IS NOT ASSOCIATED')
       
    IF (.NOT.ASSOCIATED(ncf%FTIME)) ncf%FTIME=>new_ftime()
    ftm => ncf%FTIME
    
    if (out_interval < zerotime) Call fatal_error &
         & ("The output interval must be greater than or equal to zero",&
         & "Check the run file INTERVAL")
 
    ! SET CURRENT STACK LENGTH
    ftm%STK_LEN=stklen

    ! SET THE MAXIMUM STACK SIZE FOR THE FILE
    ftm%MAX_STKCNT = stack_max
    
    ! SET THE OUPUT INTERVAL TIME
    ftm%INTERVAL = out_interval

    ! SET THE TIME OF THE NEXT OUTPUT
    ftm%NEXT_IO = next_time

    !SET THE STK OF THE NEXT OUTPUT
    ftm%NEXT_STKCNT = next_stk

    ! SET THE TIME OF THE PREV OUTPUT
    ftm%PREV_IO = prev_time
    
    !SET THE STK OF THE PREV OUTPUT
    ftm%PREV_STKCNT = prev_stk
    

    IF(dbg_set(dbg_io)) THEN
       WRITE(ipt,*) "! === DUMPING OUTPUT FILE TIMING INFO: ==="
       CALL print_ftime(ftm)
       WRITE(ipt,*) "! ========================================"

    ELSE IF (dbg_set(dbg_log)) THEN
       
       IF (use_real_world_time) then
          CALL print_real_time(next_time,ipt,'First Output Time')
       ELSE
          CALL print_time(next_time,ipt,'First Output Time')
       END IF
       
       CALL print_time(out_interval,ipt,"Output Interval")

    END IF
    
    nullify(ftm)
    
    IF(dbg_set(dbg_sbr)) WRITE(ipt,*)"SET_OUTPUT_FILE_TIME: END"
    

Here is the caller graph for this function:

set_startup_file_stack_by_cycle()

subroutine mod_set_time::set_startup_file_stack_by_cycle	(	integer(itime), intent(in)	step,
		type(time), intent(out), optional	ATIME
	)

Definition at line 1407 of file mod_set_time.f90.

    IMPLICIT NONE
    INTEGER(ITIME), INTENT(IN)  :: STEP
    TYPE(TIME), OPTIONAL, INTENT(OUT)     :: Atime
    integer                 :: status, I
    real(DP)                :: temp
    TYPE(NCFILE), POINTER   :: NCF
    TYPE(NCVAR),  POINTER   :: VAR
    INTEGER, TARGET :: FSTEP
    logical found

     IF(.NOT. ASSOCIATED(nc_start)) CALL fatal_error &
       & ("The file object NC_START is not assocaited!")


    status = set_file_time_type(nc_start)
    IF(status /= 0) CALL fatal_error &
         & ("COULD NOT FIND A VALID TIME VARIABLE IN THE RESTART FILE: ",&
         & trim(nc_start%FNAME))

    i = 0
    DO 
       i = i + 1
       IF (i .GT. nc_start%FTIME%STK_LEN) THEN

          CALL fatal_error &
               & ("COULD NOT FIND A MATCHING IINT CYCLE NUMBER IN THE RESTART FILE!:",&
               & trim(nc_start%FNAME))
       END IF

       var => find_var(nc_start,'iint',found)
       IF(.not. found) CALL fatal_error("COULD NOT FIND VARIABLE 'iint'&
            & IN THE HOTSTART FILE OBJECT")
       var%scl_int => fstep
       CALL nc_read_var(var,i)
       
       IF (fstep == step) THEN
          
          if (PRESENT(atime)) THEN
             atime = get_file_time_ncf(nc_start,i)
             
             nc_start%FTIME%PREV_STKCNT = i
             nc_start%FTIME%PREV_IO     = atime
          END if
          
          return
       END IF
       
    END DO
    
    

set_startup_file_stack_by_time()

subroutine mod_set_time::set_startup_file_stack_by_time	(	type(time), intent(in)	STIME,
		integer(itime), intent(out), optional	STEP
	)

Definition at line 1323 of file mod_set_time.f90.

    IMPLICIT NONE
    TYPE(TIME), INTENT(IN)  :: Stime
    INTEGER(ITIME), INTENT(OUT),OPTIONAL :: STEP

    INTEGER, TARGET :: FSTEP
    TYPE(TIME)              :: Atime
    integer                 :: status, I
    real(DP)                :: temp
    TYPE(NCFILE), POINTER   :: NCF
    TYPE(NCVAR),  POINTER   :: VAR
    logical found
    

     IF(.NOT. ASSOCIATED(nc_start)) CALL fatal_error &
       & ("The file object NC_START is not assocaited!")
  

    status = set_file_time_type(nc_start)
    IF(status /= 0) CALL fatal_error &
         & ("COULD NOT FIND A VALID TIME VARIABLE IN THE RESTART FILE: ",&
         & trim(nc_start%FNAME))

    i = 0
    DO 
       i = i + 1
       IF (i .GT. nc_start%FTIME%STK_LEN) THEN
          
          IF(dbg_set(dbg_log))&
               & CALL print_real_time(stime,ipt,"Asked for Start Time")
          
          IF(i == 2) THEN
            IF(dbg_set(dbg_log))&
                 & CALL print_real_time(get_file_time_ncf(nc_start,1),ipt,"The Only Restart Time Is")
             
          ELSE IF(i==1)THEN
             CALL fatal_error &
                  & ("Restart file has time dimension equal zero!:",&
                  & trim(nc_start%FNAME))
          ELSE
             atime  =get_file_time_ncf(nc_start,1)
             IF(dbg_set(dbg_log))&
                  & CALL print_real_time(atime,ipt,"First Restart Time")
             
             atime  =get_file_time_ncf(nc_start,i-1)
             IF(dbg_set(dbg_log))&
                  & CALL print_real_time(atime,ipt,"Last Restart Time")
          END IF
          
          CALL fatal_error &
               & ("COULD NOT FIND A MATCHING START TIME IN THE RESTART FILE!:",&
               & "(See time options printed above?)",&
               & trim(nc_start%FNAME))
       END IF
          
       atime = get_file_time_ncf(nc_start,i)
       
       
       !IF (ATIME == STime) THEN
       IF(abs(atime -stime)<0.1_sp*imdti) THEN
        
          nc_start%FTIME%PREV_STKCNT = i
          !NC_START%FTIME%PREV_IO     = ATIME

          nc_start%FTIME%PREV_IO     = stime

          IF (PRESENT(step)) THEN
             var => find_var(nc_start,'iint',found)
             IF(.not. found) CALL fatal_error("COULD NOT FIND VARIABLE 'iint'&
                  & IN THE HOTSTART FILE OBJECT")
             var%scl_int => fstep
             CALL nc_read_var(var,i)
             
             step = fstep
          END IF

          return
       END IF
       
    END DO
    
 

setup_time()

subroutine mod_set_time::setup_time

(

)

Definition at line 55 of file mod_set_time.f90.

    !===============================================================================!
    ! SETUP_TIME
    !===============================================================================!
    IMPLICIT NONE
    INTEGER STATUS
    TYPE(TIME)    :: RTIME
    TYPE(NCFILE), POINTER   :: NCF
    TYPE(NCVAR),  POINTER   :: VAR
    LOGICAL FOUND

    TYPE(TIME) :: INTERVAL_TIME, NEXT_TIME,PREV_TIME
    INTEGER :: STKLEN, STKMAX,PREVSTK,NEXTSTK

    INTEGER(itime) :: Dummy
    INTEGER :: I
    CHARACTER(LEN=4) :: BFLAG,EFLAG,FLAG


    ! SET THE TIME STEP
    CALL set_model_timestep !from runfile (imdte, dte, imdti, dti)


    SELECT CASE(startup_type)
       !=================================================
       ! HOTSTART 
    CASE("hotstart")
       !=================================================
       if(dbg_set(dbg_log)) then 
          WRITE(ipt,*)'!               SET TIME FOR HOTSTART                            !'
          WRITE(ipt,*)'!                                                                !'
       end if
       IF(.NOT. ASSOCIATED(nc_start)) CALL fatal_error&
            & ('STARUP FILE IS NOT ASSOCIATED IN SETUP_TIME!')
       
 
       SELECT CASE(use_real_world_time)
       CASE(.true.)

          ! GET THE START TIME
          starttime = read_datetime(start_date,date_format,timezone,status)
          if (status == 0) &
               & Call fatal_error("Could not read the date string START_DATE: "//trim(start_date))
          runfile_starttime = starttime

          ! GET THE END TIME
          EndTime = READ_DATETIME(END_DATE,DATE_FORMAT,TIMEZONE,status)
          if (status == 0) &
               & Call fatal_error("Could not read the date string END_DATE: "&
               &//trim(end_date))
          ! SANITY CHECK
          if(starttime .GT. endtime) &
               & Call fatal_error("Runfile Start_Date exceeds or equal to End_Date")
          
          ! FIND THE START TIME IN THE RESTART FILE AND SET ISTART
          CALL set_startup_file_stack(starttime,iint)

          ! ADVANCE THE TO THE FIRST TIME STEP OF THE MODEL FROM THE
          ! INITIAL CONDITION
          istart = iint +1

          !CALCULATE THE NUMBER OF STEPS AND IEND
          nsteps = calculate_number_of_timesteps(starttime,endtime)
          iend = istart + nsteps

          ! GET THE REFERENCE DATE TIME
          IF(date_reference /= 'default')THEN
        referencedate = read_datetime(date_reference,date_format,timezone,status)
            if (status == 0 ) &
               & Call fatal_error("Could not read the date string DATE_REFERENCE: "//trim(date_reference))
      ELSE
        referencedate%MJD   = 0
        referencedate%MuSOD = 0
      END IF  

       CASE (.false.)

          ! GET THE START AND END INFORMATION
          CALL ideal_time_string2time(start_date,bflag,starttime,iint)
          CALL ideal_time_string2time(end_date,eflag,endtime,iend)
          
          ! SANITY CHECK
          IF (bflag /= eflag) CALL fatal_error&
               ('IDEALIZED MODEL TIME SPECIFICATION IS INCORRENT',&
               &'BEGIN AND END CAN BE IN EITHER CYCLES OR TIME BUT NOT MIXED',&
               & trim(start_date),trim(end_date) )
          
          IF (bflag == 'time') THEN ! IF START AND END TIME WERE SPECIFIED

             !CALCULATE THE NUMBER OF STEPS
             nsteps = calculate_number_of_timesteps(starttime,endtime)

             ! FIND THE INITIAL CONDITION IN THE RESTART FILE
             CALL set_startup_file_stack(starttime,iint)

             ! ADVANCE THE TO THE FIRST TIME STEP OF THE MODEL FROM THE
             ! INITIAL CONDITION
             istart = iint +1

             ! GET IEND
             iend = istart + nsteps
             
             
          ELSE IF(bflag == 'step') THEN ! IF START AND END IINT WERE SPECIFIED

             ! CALCULATE NSTEPS
             nsteps = iend - iint  
             
             ! SANITY CHECK
             IF(nsteps .LT. 0) CALL fatal_error&
                  &('Number of steps can not be less than zero')


             ! FIND THE START IINT CYCLE IN THE RESTART FILE AND GET
             ! THE START TIME
             CALL set_startup_file_stack(iint,starttime)

             ! CALCULATE THE END TIME
             EndTime = StartTime + IMDTI * nsteps

             ! ADVANCE THE TO THE FIRST TIME STEP OF THE MODEL FROM THE
             ! INITIAL CONDITION
             istart = iint + 1


          ELSE
             CALL fatal_error('IDEAL_TIME_STRING2TIME returned invalid flag')

          END IF

       END SELECT

       ! SET THE INITIAL MODEL TIME
       inttime = starttime
       exttime = starttime
       runfile_starttime = starttime

          

       ! INITIALIZE IEXT
       iext = 1

       CALL report_time_setup

! SET THE OUT PUT TIME FOR THE DIFFERENT FILES
       IF (ncav_on) THEN
       
          CALL get_first_output_time(trim(ncav_first_out),next_time)
          
          CALL get_output_file_interval(trim(ncav_out_interval),interval_time)

          nextstk = 0
          prevstk = 0 
          prev_time = zerotime
          stklen = 0
          stkmax = ncav_output_stack


          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! TIME AVERAGE OUTPUT:"
          CALL set_output_file_time(nc_avg,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)


          if (starttime > next_time)&
               & Call fatal_error("The time of the first averaged output &
               &must be greater than or equal to the start time")
          
          if (endtime < next_time)&
               & Call fatal_error("The time of the first averaged output &
               &must be less than or equal to the end time")

       END IF

       IF (nc_on) THEN
       
          CALL get_first_output_time(trim(nc_first_out),next_time)
          
          CALL get_output_file_interval(trim(nc_out_interval),interval_time)

          nextstk = 0
          prevstk = 0 
          prev_time = zerotime
          stklen = 0
          stkmax = nc_output_stack


          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! NETCDF OUTPUT:"
          CALL set_output_file_time(nc_dat,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)



          if (starttime > next_time)&
               & Call fatal_error("The time of the first file output &
               &must be greater than or equal to the start time")
          
          if (endtime < next_time)&
               & Call fatal_error("The time of the first file output &
               &must be less than or equal to the end time")

       END IF

       IF (rst_on) THEN
       
 
       
          CALL get_first_output_time(trim(rst_first_out),next_time)
          
          CALL get_output_file_interval(trim(rst_out_interval),interval_time)

          nextstk = 0
          prevstk = 0 
          prev_time = zerotime
          stklen = 0
          stkmax = rst_output_stack


          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! RESTART OUTPUT:"
          CALL set_output_file_time(nc_rst,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)



          if (starttime > next_time)&
               & Call fatal_error("The time of the first restart output &
               &must be greater than or equal to the start time")
          
          if (endtime < next_time)&
               & Call fatal_error("The time of the first restart output &
               &must be less than or equal to the end time")

       END IF


!=================================================
! CRASHSTART 
    CASE("crashrestart") ! OR FORECAST MODE
!=================================================
       if(dbg_set(dbg_log)) then 
          WRITE(ipt,*)'!               SET TIME FOR CRASHRESTART                        !'
          WRITE(ipt,*)'!                                                                !'
       end if

       IF(.NOT. ASSOCIATED(nc_start)) CALL fatal_error&
            & ('STARUP FILE IS NOT ASSOCIATED IN SETUP_TIME!')
       
       IF(forecast_mode) THEN
          ! GET THE START TIME FROM THE NAMELIST
          starttime = read_datetime(start_date,date_format,timezone,status)
          if (status == 0) &
               & Call fatal_error("Could not read the date string START_DATE: "//trim(start_date))

          CALL set_startup_file_stack(starttime,iint)

       ELSE
          ! OTHERWISE GET THE LAST TIME IN THE RESTART FILE
          CALL  set_last_file_time(nc_start,starttime, iint)
       END IF

       SELECT CASE(use_real_world_time)
       CASE(.true.)

          runfile_starttime = read_datetime(start_date,date_format,timezone,status)
          if (status == 0) &
               & Call fatal_error("Could not read the date string START_DATE: "//trim(start_date))


          ! GET THE END TIME
          EndTime = READ_DATETIME(END_DATE,DATE_FORMAT,TIMEZONE,status)
          if (status == 0) &
               & Call fatal_error("Could not read the date string END_DATE: "&
               &//trim(end_date))

          ! SANITY CHECK
          if(starttime .GT. endtime) &
               & Call fatal_error("Runfile Start_Date exceeds or equal to End_Date")
          
          ! ADVANCE TO THE FIRST TIME STEP OF THE MODEL FROM THE
          ! INITIAL CONDITION
          istart = iint +1

          !CALCULATE THE NUMBER OF STEPS AND IEND
          nsteps = calculate_number_of_timesteps(starttime,endtime)
          iend = istart + nsteps

          ! GET THE REFERENCE DATE TIME
          IF(date_reference /= 'default')THEN
            referencedate = read_datetime(date_reference,date_format,timezone,status)
            if (status == 0 ) &
               & Call fatal_error("Could not read the date string DATE_REFERENCE: "//trim(date_reference))
      ELSE
        referencedate%MJD   = 0
        referencedate%MuSOD = 0
      END IF  

       CASE (.false.)

          ! GET THE START AND END INFORMATION
          CALL ideal_time_string2time(start_date,bflag,runfile_starttime,istart)


          CALL ideal_time_string2time(end_date,eflag,endtime,iend)

          ! SANITY CHECK
          IF (bflag /= eflag) CALL fatal_error&
               ('IDEALIZED MODEL TIME SPECIFICATION IS INCORRENT',&
               &'BEGIN AND END CAN BE IN EITHER CYCLES OR TIME BUT NOT MIXED',&
               & trim(start_date),trim(end_date) )
          
          IF (eflag == 'time') THEN ! IF START AND END TIME WERE SPECIFIED

             !CALCULATE THE NUMBER OF STEPS
             nsteps = calculate_number_of_timesteps(starttime,endtime)

             ! ADVANCE THE TO THE FIRST TIME STEP OF THE MODEL FROM THE
             ! INITIAL CONDITION
             istart = iint +1

             ! GET IEND
             iend = istart + nsteps
             
             
          ELSE IF(eflag == 'step') THEN ! IF START AND END IINT WERE SPECIFIED

             ! CALCULATE THE RUNFILE START TIME
             runfile_starttime = imdti * istart

             ! CALCULATE NSTEPS
             nsteps = iend - iint 
             
             ! SANITY CHECK
             IF(nsteps .LT. 0) CALL fatal_error&
                  &('Number of steps can not be less than zero')

             IF(istart .LT. 0) CALL fatal_error&
                  &('Starting time step can not be less than zero')

             ! CALCULATE THE END TIME
             EndTime = StartTime + IMDTI * nsteps

             ! ADVANCE THE TO THE FIRST TIME STEP OF THE MODEL FROM THE
             ! INITIAL CONDITION
             istart = iint + 1

          ELSE
             CALL fatal_error('IDEAL_TIME_STRING2TIME returned invalid flag')

          END IF

       END SELECT

       ! SET THE INITIAL MODEL TIME
       inttime = starttime
       exttime = starttime


       ! INITIALIZE IEXT
       iext = 1

       CALL report_time_setup

! SET THE OUT PUT TIME FOR THE DIFFERENT FILES
       IF (ncav_on) THEN
                 
          ! GET THE OUT PUT INTERVAL FROM RUN FILE
          CALL get_output_file_interval(trim(ncav_out_interval),interval_time)

          ! FIRST OUPUT TIME: Must open existing file and find out!
          ncf => new_file()
          ncf%FNAME=nc_avg%FNAME
          
          Call nc_open(ncf)
          CALL nc_load(ncf)

          ! GET THE CURRENT STACK LENGTH
          stklen = ncf%FTIME%stk_len
          
          !!! DAS{ 5.28.14

          ! GET THE TIME OF THE FIRST OUTPUT
          IF (stklen .GT. 1) THEN

             CALL update_file_bracket(ncf,starttime,status)
             IF(status == 0) THEN

                !PREV_TIME = NCF%FTIME%PREV_IO
                !PREVSTK= NCF%FTIME%PREV_STKCNT
                !
                !! SET THE NEXT OUTPUT
                !Nextstk = NCF%FTIME%NEXT_STKCNT 
                !NEXT_TIME = NCF%FTIME%NEXT_IO
                
                ! The last output will be the previous
                !PREV_TIME = NCF%FTIME%NEXT_IO 
                !PREVSTK   = NCF%FTIME%NEXT_STKCNT 

                !Nextstk   = NCF%FTIME%NEXT_STKCNT + 1
                !NEXT_TIME = NCF%FTIME%NEXT_IO + INTERVAL_TIME
                !!! END DAS

                IF(ncf%FTIME%NEXT_IO == starttime) then
                   next_time = starttime
                   nextstk = ncf%FTIME%NEXT_STKCNT + 1
                   
                   prev_time = ncf%FTIME%PREV_IO
                   prevstk = ncf%FTIME%PREV_STKCNT + 1

                else if (ncf%FTIME%PREV_IO == starttime) then
                   next_time = starttime
                   nextstk = ncf%FTIME%NEXT_STKCNT
                   
                   prev_time = starttime - interval_time
                   prevstk   = ncf%FTIME%PREV_STKCNT

                else
                   call fatal_error('Something is very wrong with update_file_bracket!')

                end if

             ELSE

                call fatal_error('Start time is before or after average output ???')

                ! THERE IS NO SAVED OUTPUT PAST THE RESART TIME
                !NEXT_TIME = GET_FILE_TIME_NCF(NCF,stklen)
                !NEXTSTK= STKLEN

                !prevstk = stklen - 1
                !PREV_TIME = NEXT_TIME - INTERVAL_TIME
                !
                !IF(StartTime > PREV_TIME) call Fatal_error&
                !     &("COULD NOT FIND VALID BRACKET FOR START TIME IN THE DATA FILE",&
                !     & "Try comparing the time in the restart and the data file?")

             END IF

          ELSE IF(stklen .eq. 1)THEN
              
             ! CHECK TO SEE WHETHER THIS OUTPUT IS AHEAD OF THE START TIME
             !PREV_TIME = GET_FILE_TIME_NCF(NCF,stklen)
             !IF (PREV_TIME <= StartTime) THEN
             !   PREVSTK= STKLEN
             !   
             !   ! SET THE NEXT OUTPUR
             !   Nextstk = stklen + 1
             !   NEXT_TIME = PREV_TIME + INTERVAL_TIME
             !ELSE
             !   NEXTSTK=STKLEN
             !   NEXT_TIME= PREV_TIME
             !   PREV_TIME= ZEROTIME
             !END IF

             next_time = get_file_time_ncf(ncf,stklen)
             if (next_time == starttime) then
                nextstk = stklen + 1

                prev_time = zerotime
                prevstk = 0


             else

                call fatal_error('Cant crash restart when the restart time is not an average output time!')

             end if



          ELSE
             ! IF THERE ARE NOT YET ANY TIMESTEPS IN THE FILE
             prev_time=zerotime
             prevstk=0
             nextstk=1
             CALL get_first_output_time(trim(ncav_first_out),next_time)
          END IF

          !DAS} 5.28.14


          IF(next_time < starttime) THEN 
             CALL print_time(starttime,ipt,"Start Time")
             CALL print_time(next_time,ipt,"First AVG OUTPUT")

             CALL fatal_error&
               & ("CAN NOT CONNECT TO EXISTING FILE - THERE IS A TIME GAP",&
               "BETWEEN THE EXISTING OUTPUT AND THE START TIME?")

          END IF

          
          if (endtime < next_time)&
               & Call fatal_error("The time of the first averaged output &
               &must be less than or equal to the end time")


          ! FINISHED WITH FILE
          CALL kill_file(ncf)
          

          ! SET THE STACK MAX
          stkmax = ncav_output_stack


          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! TIME AVERAGE OUTPUT:"
          CALL set_output_file_time(nc_avg,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)


           Call print_file(nc_avg)
           
       END IF

       IF (nc_on) THEN
          
          CALL get_output_file_interval(trim(nc_out_interval),interval_time)

          ! FIRST OUPUT TIME: Must open existing file and find out!
          ncf => new_file()
          ncf%FNAME=nc_dat%FNAME
          
          Call nc_open(ncf)
          CALL nc_load(ncf)

          ! GET THE CURRENT STACK LENGTH
          stklen = ncf%FTIME%stk_len

          ! GET THE TIME OF THE FIRST OUTPUT
          IF (stklen .GT. 1) THEN

             CALL update_file_bracket(ncf,starttime,status)
             IF(status == 0) THEN
                prev_time = ncf%FTIME%PREV_IO
                prevstk= ncf%FTIME%PREV_STKCNT
                
                ! SET THE NEXT OUTPUT
                nextstk = ncf%FTIME%NEXT_STKCNT 
                next_time = ncf%FTIME%NEXT_IO
                
             ELSE

                ! THERE IS NO SAVED OUTPUT PAST THE RESART TIME
                prev_time = get_file_time_ncf(ncf,stklen)
                prevstk= stklen

                nextstk = stklen + 1
                next_time = prev_time + interval_time

                IF(starttime > next_time) call fatal_error&
                     &("COULD NOT FIND VALID BRACKET FOR START TIME IN THE DATA FILE",&
                     & "Try comparing the time in the restart and the data file?")

             END IF

          ELSE IF(stklen .eq. 1) THEN
             
             prev_time = get_file_time_ncf(ncf,stklen)
             IF (prev_time <= starttime) THEN
                prevstk= stklen
                
                ! SET THE NEXT OUTPUR
                nextstk = stklen + 1
                next_time = prev_time + interval_time
             ELSE
                nextstk=stklen
                next_time= prev_time
                prev_time= zerotime
             END IF

          ELSE
             ! IF THERE ARE NOT YET ANY TIMESTEPS IN THE FILE
             prev_time=zerotime
             prevstk=0
             nextstk=1
             CALL get_first_output_time(trim(nc_first_out),next_time)
          END IF
         
          IF(next_time < starttime) THEN 
             CALL print_time(starttime,ipt,"Start Time")
             CALL print_time(next_time,ipt,"First DATA OUTPUT")

             CALL fatal_error&
               & ("CAN NOT CONNECT TO EXISTING FILE - THERE IS A TIME GAP",&
               "BETWEEN THE EXISTING OUTPUT AND THE START TIME?")

          END IF

          if (endtime < next_time)&
               & Call fatal_error("The time of the first file output &
               &must be less than or equal to the end time")

          
          ! SET THE STACK MAX
          stkmax = nc_output_stack

          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! NETCDF OUTPUT:"
          CALL set_output_file_time(nc_dat,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)
          
          ! FINISHED WITH FILE
          CALL kill_file(ncf)

       END IF

       IF (rst_on) THEN
       
          CALL get_output_file_interval(trim(rst_out_interval),interval_time)

          ! GET THE CURRENT STACK LENGTH
          stklen = nc_start%FTIME%stk_len

          ncf => nc_start

          ! GET THE TIME OF THE FIRST OUTPUT
          IF (stklen .GT. 1) THEN

             ! RESET STACK AND TIME AND LET BRACKET FIND IT
             ncf%FTIME%PREV_IO = zerotime
             ncf%FTIME%prev_stkcnt = 0
             CALL update_file_bracket(ncf,starttime,status)
             IF(status /= 0) call fatal_error&
                  &(" COULD NOT FIND VALID BRACKET FOR START TIME IN THE DATA FILE")

             ! SPECIAL FOR THE RESTART FILE -
             ! MAKE SURE THE PREVIOUS TIME IS THE START TIME FOR
             ! READING HOTSTART
             IF (ncf%FTIME%PREV_IO == starttime) THEN

                prev_time = ncf%FTIME%PREV_IO
                prevstk= ncf%FTIME%PREV_STKCNT
                
                ! SET THE NEXT OUTPUT
                nextstk = ncf%FTIME%NEXT_STKCNT
                next_time = ncf%FTIME%NEXT_IO
             ELSE IF (ncf%FTIME%NEXT_IO == starttime) THEN

                prev_time= ncf%FTIME%NEXT_IO
                prevstk= ncf%FTIME%NEXT_STKCNT
                
                next_time= prev_time + interval_time
                nextstk = prevstk + 1
                
             ELSE
                CALL fatal_error("DID NOT MATCH START TIME TO RESTART FILE")
             END IF


          ELSE IF(stklen .eq. 1) THEN
                        
             prev_time = get_file_time_ncf(ncf,stklen)
             prevstk= stklen
             
             ! SET THE NEXT OUTPUT
             nextstk = stklen + 1
             next_time = prev_time + interval_time
             

          ELSE

             CALL fatal_error("What a mess this is... ",&
                  &"I suggest a strong cocktail before you try and figure this one out!")

          END IF


          ! SET BACK TO CORRECT TIME FOR STARTUP
          ncf%FTIME%PREV_IO= prev_time
          ncf%FTIME%PREV_STKCNT=prevstk
          
          ncf%FTIME%NEXT_IO = next_time
          ncf%FTIME%NEXT_STKCNT = nextstk
                   
          if (endtime < next_time)&
               & Call fatal_error("The time of the first file output &
               &must be less than or equal to the end time")

          ! SET THE STACK MAX
          stkmax = rst_output_stack

          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! RESTART OUTPUT:"
          CALL set_output_file_time(nc_rst,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)


       END IF

!=================================================
! COLDSTART 
    CASE("coldstart")
!=================================================
       if(dbg_set(dbg_log)) then 
          WRITE(ipt,*)'!                SET TIME FOR COLDSTART                          !'
          WRITE(ipt,*)'!                                                                !'
       end if


       SELECT CASE(use_real_world_time)
       CASE(.true.)
          
          ! GET THE START TIME
          starttime = read_datetime(start_date,date_format,timezone,status)
          if (status == 0 ) &
               & Call fatal_error("Could not read the date string START_DATE: "//trim(start_date))

          ! GET THE END TIME
          EndTime = READ_DATETIME(END_DATE,DATE_FORMAT,TIMEZONE,status)
          if (status == 0) &
               & Call fatal_error("Could not read the date string END_DATE: "&
               &//trim(end_date))

          ! SANITY CHECK
          if(starttime .GT. endtime) &
               & Call fatal_error("Runfile Start_Date exceeds or equal to End_Date")
          
          ! GET THE REFERENCE DATE TIME
          IF(date_reference /= 'default')THEN
            referencedate = read_datetime(date_reference,date_format,timezone,status)
            if (status == 0 ) &
               & Call fatal_error("Could not read the date string DATE_REFERENCE: "//trim(date_reference))
      ELSE
        referencedate%MJD   = 0
        referencedate%MuSOD = 0
      END IF  

          !CALCULATE THE NUMBER OF STEPS AND IEND
          iint = 0
          istart = 1
          nsteps = calculate_number_of_timesteps(starttime,endtime)
          iend = istart + nsteps

          IF(ASSOCIATED(nc_start)) THEN
             IF(dbg_set(dbg_log)) WRITE(ipt,*) &
                  & "! SETTING PREV_STCKNT FOR NETCDF COLD START FILE 1"

             CALL set_startup_file_stack(starttime)
             
          ELSE
             IF(dbg_set(dbg_log)) WRITE(ipt,*) &
                  & "! NO NETCDF COLD START FILE"

          END IF

          
          
       CASE(.false.) ! THIS MODEL IS USING IDEALIZED TIME

           ! GET THE START AND END INFORMATION
          CALL ideal_time_string2time(start_date,bflag,starttime,iint)          
          CALL ideal_time_string2time(end_date,eflag,endtime,iend)
          
          ! SANITY CHECK
          IF (bflag /= eflag) CALL fatal_error&
               ('IDEALIZED MODEL TIME SPECIFICATION IS INCORRENT',&
               &'BEGIN AND END CAN BE IN EITHER CYCLES OR TIME BUT NOT MIXED',&
               & trim(start_date),trim(end_date) )

          IF (bflag == 'time') THEN

             !CALCULATE THE NUMBER OF STEPS             
             iint = 0
             istart = 1
             nsteps = calculate_number_of_timesteps(starttime,endtime)
             iend = istart + nsteps

             IF(ASSOCIATED(nc_start)) THEN
                IF(dbg_set(dbg_log)) WRITE(ipt,*) &
                     & "! SETTING PREV_STCKNT FOR NETCDF COLD START FI&
                     &LE 2"

             CALL set_startup_file_stack(starttime)

             ELSE
                IF(dbg_set(dbg_log)) WRITE(ipt,*) &
                     & "! NO NETCDF COLD START FILE"
                
             END IF

             
          ELSE IF(bflag == 'step') THEN

             ! CALCULATE NSTEPS
             nsteps = iend - iint 

             ! SANITY CHECK
             IF(nsteps .LT. 0) CALL fatal_error&
                  &('Number of steps can not be less than zero')

             ! CALCULATE THE START TIME
             starttime = imdti * iint
             
             ! CALCULATE THE END TIME
             EndTime = IMDTI * iend
             
             ! ADVANCE THE TO THE FIRST TIME STEP OF THE MODEL FROM THE
             ! INITIAL CONDITION
             istart = iint +1


             IF(ASSOCIATED(nc_start)) THEN
                IF(dbg_set(dbg_log)) WRITE(ipt,*) &
                     & "! SETTING PREV_STCKNT FOR NETCDF COLD START FI&
                     &LE 3"

             CALL set_startup_file_stack(iint)

             ELSE
                IF(dbg_set(dbg_log)) WRITE(ipt,*) &
                     & "! NO NETCDF COLD START FILE"
                
             END IF

          ELSE
             CALL fatal_error('IDEAL_TIME_STRING2TIME returned invalid flag')

          END IF

       END SELECT
       
       inttime = starttime
       exttime = starttime
       runfile_starttime = starttime


       ! INITIALIZE IEXT
       iext = 1

       ! IF THERE IS AN INITIAL CONDITION FILE SET THE STCKNT
       IF(ASSOCIATED(nc_start)) THEN ! ONLY DO THIS IF THERE IS A STARTUP FILE
          CALL set_startup_file_stack(starttime)
       END IF

       CALL report_time_setup

! SET THE OUT PUT TIME FOR THE DIFFERENT FILES
       IF (ncav_on) THEN
       
          CALL get_first_output_time(trim(ncav_first_out),next_time)
          
          CALL get_output_file_interval(trim(ncav_out_interval),interval_time)

          nextstk = 0
          prevstk = 0 
          prev_time = zerotime
          stklen = 0
          stkmax = ncav_output_stack


          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! TIME AVERAGE OUTPUT:"
          CALL set_output_file_time(nc_avg,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)


          if (starttime > next_time)&
               & Call fatal_error("The time of the first averaged output &
               &must be greater than or equal to the start time")
          
          if (endtime < next_time)&
               & Call fatal_error("The time of the first averaged output &
               &must be less than or equal to the end time")

       END IF

       IF (nc_on) THEN
       
          CALL get_first_output_time(trim(nc_first_out),next_time)
          
          CALL get_output_file_interval(trim(nc_out_interval),interval_time)

          nextstk = 0
          prevstk = 0 
          prev_time = zerotime
          stklen = 0
          stkmax = nc_output_stack


          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! NETCDF OUTPUT:"
          CALL set_output_file_time(nc_dat,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)



          if (starttime > next_time)&
               & Call fatal_error("The time of the first file output &
               &must be greater than or equal to the start time")
          
          if (endtime < next_time)&
               & Call fatal_error("The time of the first file output &
               &must be less than or equal to the end time")

       END IF

       IF (rst_on) THEN
       
 
       
          CALL get_first_output_time(trim(rst_first_out),next_time)
          
          CALL get_output_file_interval(trim(rst_out_interval),interval_time)

          nextstk = 0
          prevstk = 0 
          prev_time = zerotime
          stklen = 0
          stkmax = rst_output_stack


          IF(dbg_set(dbg_log)) WRITE(ipt,*) "! RESTART OUTPUT:"
          CALL set_output_file_time(nc_rst,interval_time,next_time&
               &,nextstk,prev_time,prevstk,stklen,stkmax)



          if (starttime > next_time)&
               & Call fatal_error("The time of the first restart output &
               &must be greater than or equal to the start time")
          
          if (endtime < next_time)&
               & Call fatal_error("The time of the first restart output &
               &must be less than or equal to the end time")

       END IF

!===========================================
    CASE DEFAULT
!===========================================

       CALL fatal_error("UNKNOWN STARUP TYPE IN RUNFILE")

!===========================================
    END SELECT
!===========================================


!================================================
!
! MAKE SURE THAT OUTPUT INTERVALS ARE AN INTEGER 
! NUMBER OF TIME STEPS
!
!================================================

    IF(rst_on) THEN
       interval_time = nc_rst%FTIME%INTERVAL
       next_time = nc_rst%FTIME%NEXT_IO

       IF(mod(interval_time,imdti) /= zerotime) THEN
          CALL fatal_error("RST_OUT_INTERVAL must be an integer number of int&
               &ernal time steps!")
       END IF
       IF(mod((next_time - starttime),imdti) /= zerotime) THEN
          CALL fatal_error("RST_FIRST_OUT must be an integer number of int&
               &ernal time steps from the StartTime!")
       END IF

    END IF

    IF(nc_on)THEN
       interval_time = nc_dat%FTIME%INTERVAL
       next_time = nc_dat%FTIME%NEXT_IO
       IF(mod(interval_time,imdti) /= zerotime) THEN
          CALL fatal_error("NC_OUT_INTERVAL must be an integer number of int&
               &ernal time steps!")
       END IF
       IF(mod((next_time - starttime),imdti) /= zerotime) THEN
          CALL fatal_error("NC_FIRST_OUT must be an integer number of int&
               &ernal time steps from the StartTime!")
       END IF       
          

    END IF

    IF(ncav_on)THEN
       interval_time = nc_avg%FTIME%INTERVAL
       next_time = nc_avg%FTIME%NEXT_IO
       
       IF(mod(interval_time,imdti) /= zerotime) THEN
          CALL fatal_error("NCAV_OUT_INTERVAL must be an integer number of int&
               &ernal time steps!")
       END IF
       IF(mod((next_time - starttime),imdti) /= zerotime) THEN
          CALL fatal_error("NCAV_FIRST_OUT must be an integer number of int&
               &ernal time steps from the StartTime!")
       END IF


       ! CHECK TO MAKE SURE THAT THE RESTART TIMES MATCH THE AVERAGE
       ! OUTPUT TIMES
       IF(rst_on) THEN
          IF(mod(nc_rst%FTIME%INTERVAL,interval_time) /= zerotime) THEN
             CALL fatal_error("NCAV_OUT_INTERVAL: The restart file int&
                  &erval must be an integer number of Average intervals!")
       
          END IF

          IF(mod(nc_rst%FTIME%NEXT_IO-next_time,interval_time) /= zerotime) THEN
             CALL fatal_error&
                  &("NCAV_FIRST_OUT: Any Restart dump time must also be a average output time!",&
                  & "MOD(RST_FIRST_OUT - NCAV_FIRST_OUT,NCAV_OUT_INTERVAL)/=0 IS AN ERROR")
       
          END IF


       END IF

    END IF



!================================================
!
! SETUP RECALCULATION TIMES FOR RHO_MEAN
!
!================================================
    IF(recalculate_rho_mean) THEN
       recalc_rho_mean = starttime

       CALL ideal_time_string2time(interval_rho_mean,flag,delt_rho_mean,nsteps)
          
       IF(flag == 'step') THEN

          ! SANITY CHECK
          IF(nsteps .LE. 0) CALL fatal_error&
               &('Number of steps for INTERVAL_RHO_MEAN can not be less than zero')
          
          ! CALCULATE THE START TIME
          delt_rho_mean = imdti * nsteps
    
          ELSE IF(flag == 'time') THEN

          ! SANITY CHECK
          IF(delt_rho_mean .LE. zerotime) CALL fatal_error&
               &('INTERVAL_RHO_MEAN can not be LE zero seconds!')
          
       END IF

       IF (rst_on) THEN

          interval_time = nc_rst%FTIME%INTERVAL
          next_time = nc_rst%FTIME%NEXT_IO

          IF(mod(interval_time,delt_rho_mean) /= zerotime) THEN
             CALL warning("MODEL RESTART IS NOT PERFECT WHEN USING RHO MEAN RECALCULATION,",&
                  "TO FIX: SET MOD(RST_OUT_INTERVAL,INTERVAL_RHO_MEAN)==0!")
          END IF


          IF(mod((next_time - starttime),delt_rho_mean) /= zerotime) THEN
             CALL warning("MODEL RESTART IS NOT PERFECT WHEN USING RHO MEAN RECALCULATION,",&
                  "TO FIX: SET MOD(RST_FIRST_OUT-StartTime,INTERVAL_RHO_MEAN)==0!")
          END IF

       END IF

    END IF

Here is the call graph for this function:

Here is the caller graph for this function: