config.resources

#! /usr/bin/env bash

########## config.resources ##########
# Set resource information for job tasks
# e.g. walltime, node, cores per node, memory etc.

if (( $# != 1 )); then

    echo "Must specify an input task argument to set resource variables!"
    echo "argument can be any one of the following:"
    echo "stage_ic aerosol_init"
    echo "prep prepsnowobs prepatmiodaobs"
    echo "atmanlinit atmanlrun atmanlfinal"
    echo "atmensanlinit atmensanlrun atmensanlfinal"
    echo "snowanl"
    echo "aeroanlinit aeroanlrun aeroanlfinal"
    echo "anal sfcanl analcalc analdiag fcst echgres"
    echo "upp atmos_products"
    echo "tracker genesis genesis_fsu"
    echo "verfozn verfrad vminmon fit2obs metp arch cleanup"
    echo "eobs ediag eomg eupd ecen esfc efcs epos earc"
    echo "init_chem mom6ic oceanice_products"
    echo "waveinit waveprep wavepostsbs wavepostbndpnt wavepostbndpntbll wavepostpnt"
    echo "wavegempak waveawipsbulls waveawipsgridded"
    echo "postsnd awips gempak npoess"
    echo "ocnanalprep prepoceanobs ocnanalbmat ocnanalrun ocnanalecen ocnanalchkpt ocnanalpost ocnanalvrfy"
    exit 1

fi

step=$1

echo "BEGIN: config.resources"

case ${machine} in
  "WCOSS2")   npe_node_max=128;;
  "HERA")     npe_node_max=40;;
  "ORION")    npe_node_max=40;;
  "HERCULES") npe_node_max=80;;
  "JET")
    case ${PARTITION_BATCH} in
      "xjet")          npe_node_max=24;;
      "vjet" | "sjet") npe_node_max=16;;
      "kjet")          npe_node_max=40;;
      *)
        echo "FATAL ERROR: Unknown partition ${PARTITION_BATCH} specified for ${machine}"
        exit 3
    esac
    ;;
  "S4")
    case ${PARTITION_BATCH} in
      "s4")  npe_node_max=32;;
      "ivy") npe_node_max=20;;
      *)
        echo "FATAL ERROR: Unknown partition ${PARTITION_BATCH} specified for ${machine}"
        exit 3
    esac
    ;;
  "AWSPW")
    export PARTITION_BATCH="compute"
    npe_node_max=40
    ;;
  "CONTAINER")
    npe_node_max=1
    ;;
  *)
    echo "FATAL ERROR: Unknown machine encountered by ${BASH_SOURCE[0]}"
    exit 2
    ;;
esac
export npe_node_max

case ${step} in
  "prep")
    export wtime_prep='00:30:00'
    export npe_prep=4
    export npe_node_prep=2
    export nth_prep=1
    if [[ "${machine}" == "WCOSS2" ]]; then
      export is_exclusive=True
    else
      export memory_prep="40GB"
    fi
    ;;

  "prepsnowobs")
    export wtime_prepsnowobs="00:05:00"
    export npe_prepsnowobs=1
    export nth_prepsnowobs=1
    export npe_node_prepsnowobs=1
    ;;

  "prepatmiodaobs")
    export wtime_prepatmiodaobs="00:30:00"
    export npe_prepatmiodaobs=1
    export nth_prepatmiodaobs=1
    export npe_node_prepatmiodaobs=$(( npe_node_max / nth_prepatmiodaobs ))
    ;;

  "aerosol_init")
    export wtime_aerosol_init="00:05:00"
    export npe_aerosol_init=1
    export nth_aerosol_init=1
    export npe_node_aerosol_init=$(( npe_node_max / nth_aerosol_init ))
    export NTASKS=${npe_aerosol_init}
    export memory_aerosol_init="6GB"
    ;;

  "waveinit")
    export wtime_waveinit="00:10:00"
    export npe_waveinit=12
    export nth_waveinit=1
    export npe_node_waveinit=$(( npe_node_max / nth_waveinit ))
    export NTASKS=${npe_waveinit}
    export memory_waveinit="2GB"
    ;;

  "waveprep")
    export wtime_waveprep="00:10:00"
    export npe_waveprep=5
    export npe_waveprep_gfs=65
    export nth_waveprep=1
    export nth_waveprep_gfs=1
    export npe_node_waveprep=$(( npe_node_max / nth_waveprep ))
    export npe_node_waveprep_gfs=$(( npe_node_max / nth_waveprep_gfs ))
    export NTASKS=${npe_waveprep}
    export NTASKS_gfs=${npe_waveprep_gfs}
    export memory_waveprep="100GB"
    export memory_waveprep_gfs="150GB"
    ;;

  "wavepostsbs")
    export wtime_wavepostsbs="00:20:00"
    export wtime_wavepostsbs_gfs="03:00:00"
    export npe_wavepostsbs=8
    export nth_wavepostsbs=1
    export npe_node_wavepostsbs=$(( npe_node_max / nth_wavepostsbs ))
    export NTASKS=${npe_wavepostsbs}
    export memory_wavepostsbs="10GB"
    export memory_wavepostsbs_gfs="10GB"
    ;;

  "wavepostbndpnt")
    export wtime_wavepostbndpnt="01:00:00"
    export npe_wavepostbndpnt=240
    export nth_wavepostbndpnt=1
    export npe_node_wavepostbndpnt=$(( npe_node_max / nth_wavepostbndpnt ))
    export NTASKS=${npe_wavepostbndpnt}
    export is_exclusive=True
    ;;

  "wavepostbndpntbll")
    export wtime_wavepostbndpntbll="01:00:00"
    export npe_wavepostbndpntbll=448
    export nth_wavepostbndpntbll=1
    export npe_node_wavepostbndpntbll=$(( npe_node_max / nth_wavepostbndpntbll ))
    export NTASKS=${npe_wavepostbndpntbll}
    export is_exclusive=True
    ;;

  "wavepostpnt")
    export wtime_wavepostpnt="04:00:00"
    export npe_wavepostpnt=200
    export nth_wavepostpnt=1
    export npe_node_wavepostpnt=$(( npe_node_max / nth_wavepostpnt ))
    export NTASKS=${npe_wavepostpnt}
    export is_exclusive=True
    ;;

  "wavegempak")
    export wtime_wavegempak="02:00:00"
    export npe_wavegempak=1
    export nth_wavegempak=1
    export npe_node_wavegempak=$(( npe_node_max / nth_wavegempak ))
    export NTASKS=${npe_wavegempak}
    export memory_wavegempak="1GB"
    ;;

  "waveawipsbulls")
    export wtime_waveawipsbulls="00:20:00"
    export npe_waveawipsbulls=1
    export nth_waveawipsbulls=1
    export npe_node_waveawipsbulls=$(( npe_node_max / nth_waveawipsbulls ))
    export NTASKS=${npe_waveawipsbulls}
    export is_exclusive=True
    ;;

  "waveawipsgridded")
    export wtime_waveawipsgridded="02:00:00"
    export npe_waveawipsgridded=1
    export nth_waveawipsgridded=1
    export npe_node_waveawipsgridded=$(( npe_node_max / nth_waveawipsgridded ))
    export NTASKS=${npe_waveawipsgridded}
    export memory_waveawipsgridded_gfs="1GB"
    ;;

  "atmanlinit")
    export layout_x=${layout_x_atmanl}
    export layout_y=${layout_y_atmanl}

    export layout_gsib_x=$(( layout_x * 3 ))
    export layout_gsib_y=$(( layout_y * 2 ))

    export wtime_atmanlinit="00:10:00"
    export npe_atmanlinit=1
    export nth_atmanlinit=1
    export npe_node_atmanlinit=$(( npe_node_max / nth_atmanlinit ))
    export npe_node_atmanlinit
    export memory_atmanlinit="3072M"
    ;;

  "atmanlrun")
    export layout_x=${layout_x_atmanl}
    export layout_y=${layout_y_atmanl}

    export wtime_atmanlrun="00:30:00"
    export npe_atmanlrun=$(( layout_x * layout_y * 6 ))
    export npe_atmanlrun_gfs=$(( layout_x * layout_y * 6 ))
    export nth_atmanlrun=1
    export nth_atmanlrun_gfs=${nth_atmanlrun}
    export npe_node_atmanlrun=$(( npe_node_max / nth_atmanlrun ))
    export memory_atmanlrun="96GB"
    export is_exclusive=True
    ;;

  "atmanlfinal")
    export wtime_atmanlfinal="00:30:00"
    export npe_atmanlfinal=${npe_node_max}
    export nth_atmanlfinal=1
    export npe_node_atmanlfinal=$(( npe_node_max / nth_atmanlfinal ))
    export is_exclusive=True
    ;;

  "snowanl")
    # below lines are for creating JEDI YAML
    case ${CASE} in
      "C768")
        layout_x=6
        layout_y=6
        ;;
      "C384")
        layout_x=5
        layout_y=5
        ;;
      "C192" | "C96" | "C48")
        layout_x=1
        layout_y=1
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
    esac

    export layout_x
    export layout_y

    export wtime_snowanl="00:15:00"
    export npe_snowanl=$(( layout_x * layout_y * 6 ))
    export nth_snowanl=1
    export npe_node_snowanl=$(( npe_node_max / nth_snowanl ))
    ;;

  "aeroanlinit")
    # below lines are for creating JEDI YAML
    case ${CASE} in
      "C768")
        layout_x=8
        layout_y=8
        ;;
      "C384")
        layout_x=8
        layout_y=8
        ;;
      "C192" | "C96")
        layout_x=8
        layout_y=8
        ;;
      "C48" )
        # this case is for testing only
        layout_x=1
        layout_y=1
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
    esac

    export layout_x
    export layout_y
    export wtime_aeroanlinit="00:10:00"
    export npe_aeroanlinit=1
    export nth_aeroanlinit=1
    export npe_node_aeroanlinit=$(( npe_node_max / nth_aeroanlinit ))
    export memory_aeroanlinit="3072M"
    ;;

  "aeroanlrun")
    case ${CASE} in
      "C768")
        layout_x=8
        layout_y=8
        ;;
      "C384")
        layout_x=8
        layout_y=8
        ;;
      "C192" | "C96")
        layout_x=8
        layout_y=8
        ;;
      "C48" )
        # this case is for testing only
        layout_x=1
        layout_y=1
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
    esac

    export layout_x
    export layout_y

    export wtime_aeroanlrun="00:30:00"
    export npe_aeroanlrun=$(( layout_x * layout_y * 6 ))
    export npe_aeroanlrun_gfs=$(( layout_x * layout_y * 6 ))
    export nth_aeroanlrun=1
    export nth_aeroanlrun_gfs=1
    export npe_node_aeroanlrun=$(( npe_node_max / nth_aeroanlrun ))
    export is_exclusive=True
    ;;

  "aeroanlfinal")
    export wtime_aeroanlfinal="00:10:00"
    export npe_aeroanlfinal=1
    export nth_aeroanlfinal=1
    export npe_node_aeroanlfinal=$(( npe_node_max / nth_aeroanlfinal ))
    export memory_aeroanlfinal="3072M"
    ;;

  "ocnanalprep")
    export wtime_ocnanalprep="00:10:00"
    export npe_ocnanalprep=1
    export nth_ocnanalprep=1
    export npe_node_ocnanalprep=$(( npe_node_max / nth_ocnanalprep ))
    export memory_ocnanalprep="24GB"
    ;;

  "prepoceanobs")
    export wtime_prepoceanobs="00:10:00"
    export npe_prepoceanobs=1
    export nth_prepoceanobs=1
    export npe_node_prepoceanobs=$(( npe_node_max / nth_prepoceanobs ))
    export memory_prepoceanobs="48GB"
    ;;

  "ocnanalbmat")
    npes=16
    case ${OCNRES} in
      "025") npes=480;;
      "050")  npes=16;;
      "500")  npes=16;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${OCNRES}"
        exit 4
    esac

    export wtime_ocnanalbmat="00:30:00"
    export npe_ocnanalbmat=${npes}
    export nth_ocnanalbmat=1
    export is_exclusive=True
    export npe_node_ocnanalbmat=$(( npe_node_max / nth_ocnanalbmat ))
    ;;

  "ocnanalrun")
    npes=16
    case ${OCNRES} in
      "025")
        npes=40
        memory_ocnanalrun="96GB"
        ;;
      "050")
        npes=16
        memory_ocnanalrun="96GB"
        ;;
      "500")
        npes=16
        memory_ocnanalrun="24GB"
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${OCNRES}"
        exit 4
    esac

    export wtime_ocnanalrun="00:15:00"
    export npe_ocnanalrun=${npes}
    export nth_ocnanalrun=1
    export is_exclusive=True
    export npe_node_ocnanalrun=$(( npe_node_max / nth_ocnanalrun ))
    export memory_ocnanalrun
    ;;

  "ocnanalecen")
    npes=16
    case ${OCNRES} in
      "025")
        npes=40
        memory_ocnanalecen="96GB"
        ;;
      "050")
        npes=16
        memory_ocnanalecen="96GB"
        ;;
      "500")
        npes=16
        memory_ocnanalecen="24GB"
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${OCNRES}"
        exit 4
    esac

    export wtime_ocnanalecen="00:10:00"
    export npe_ocnanalecen=${npes}
    export nth_ocnanalecen=1
    export is_exclusive=True
    export npe_node_ocnanalecen=$(( npe_node_max / nth_ocnanalecen ))
    export memory_ocnanalecen
    ;;

  "ocnanalchkpt")
    export wtime_ocnanalchkpt="00:10:00"
    export npe_ocnanalchkpt=1
    export nth_ocnanalchkpt=1
    export npe_node_ocnanalchkpt=$(( npe_node_max / nth_ocnanalchkpt ))
    case ${OCNRES} in
      "025")
        memory_ocnanalchkpt="128GB"
        npes=40;;
      "050")
        memory_ocnanalchkpt="32GB"
        npes=16;;
      "500")
        memory_ocnanalchkpt="32GB"
        npes=8;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${OCNRES}"
        exit 4
    esac
    export npe_ocnanalchkpt=${npes}
    export memory_ocnanalchkpt
    ;;

  "ocnanalpost")
    export wtime_ocnanalpost="00:30:00"
    export npe_ocnanalpost=${npe_node_max}
    export nth_ocnanalpost=1
    export npe_node_ocnanalpost=$(( npe_node_max / nth_ocnanalpost ))
    ;;

  "ocnanalvrfy")
    export wtime_ocnanalvrfy="00:35:00"
    export npe_ocnanalvrfy=1
    export nth_ocnanalvrfy=1
    export npe_node_ocnanalvrfy=$(( npe_node_max / nth_ocnanalvrfy ))
    export memory_ocnanalvrfy="24GB"
    ;;

  "anal")
    export wtime_anal="00:50:00"
    export wtime_anal_gfs="00:40:00"
    export npe_anal=780
    export nth_anal=5
    export npe_anal_gfs=825
    export nth_anal_gfs=5
    if [[ "${machine}" == "WCOSS2" ]]; then
      export nth_anal=8
      export nth_anal_gfs=8
    fi
    case ${CASE} in
      "C384")
        export npe_anal=160
        export npe_anal_gfs=160
        export nth_anal=10
        export nth_anal_gfs=10
        if [[ ${machine} = "S4" ]]; then
          #On the S4-s4 partition, this is accomplished by increasing the task
          #count to a multiple of 32
          if [[ ${PARTITION_BATCH} = "s4" ]]; then
            export npe_anal=416
            export npe_anal_gfs=416
          fi
          #S4 is small, so run this task with just 1 thread
          export nth_anal=1
          export nth_anal_gfs=1
          export wtime_anal="02:00:00"
        fi
        ;;
      "C192" | "C96" | "C48")
        export npe_anal=84
        export npe_anal_gfs=84
        if [[ ${machine} == "S4" ]]; then
          export nth_anal=4
          export nth_anal_gfs=4
          #Adjust job count for S4
          if [[ ${PARTITION_BATCH} == "s4" ]]; then
            export npe_anal=88
            export npe_anal_gfs=88
          elif [[ ${PARTITION_BATCH} == "ivy" ]]; then
            export npe_anal=90
            export npe_anal_gfs=90
          fi
        fi
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
        ;;
    esac
    export npe_node_anal=$(( npe_node_max / nth_anal ))
    export nth_cycle=${nth_anal}
    export npe_node_cycle=$(( npe_node_max / nth_cycle ))
    export is_exclusive=True
    ;;

  "analcalc")
    export wtime_analcalc="00:10:00"
    export npe_analcalc=127
    export ntasks="${npe_analcalc}"
    export nth_analcalc=1
    export nth_echgres=4
    export nth_echgres_gfs=12
    export npe_node_analcalc=$(( npe_node_max / nth_analcalc ))
    export is_exclusive=True
    export memory_analcalc="48GB"
    ;;

  "analdiag")
    export wtime_analdiag="00:15:00"
    export npe_analdiag=96             # Should be at least twice npe_ediag
    export nth_analdiag=1
    export npe_node_analdiag=$(( npe_node_max / nth_analdiag ))
    export memory_analdiag="48GB"
    ;;

  "sfcanl")
    export wtime_sfcanl="00:10:00"
    export npe_sfcanl=6
    export nth_sfcanl=1
    export npe_node_sfcanl=$(( npe_node_max / nth_sfcanl ))
    export is_exclusive=True
    ;;

  "fcst" | "efcs")
    export is_exclusive=True

    if [[ "${step}" == "fcst" ]]; then
      _CDUMP_LIST=${CDUMP:-"gdas gfs"}
    elif [[ "${step}" == "efcs" ]]; then
      _CDUMP_LIST=${CDUMP:-"enkfgdas enkfgfs"}
    fi

    # During workflow creation, we need resources for all CDUMPs and CDUMP is undefined
    for _CDUMP in ${_CDUMP_LIST}; do
      if [[ "${_CDUMP}" =~ "gfs" ]]; then
        export layout_x=${layout_x_gfs}
        export layout_y=${layout_y_gfs}
        export WRITE_GROUP=${WRITE_GROUP_GFS}
        export WRTTASK_PER_GROUP_PER_THREAD=${WRTTASK_PER_GROUP_PER_THREAD_GFS}
        ntasks_fv3=${ntasks_fv3_gfs}
        ntasks_quilt=${ntasks_quilt_gfs}
        nthreads_fv3=${nthreads_fv3_gfs}
      fi

      # PETS for the atmosphere dycore
      (( FV3PETS = ntasks_fv3 * nthreads_fv3 ))
      echo "FV3 using (nthreads, PETS) = (${nthreads_fv3}, ${FV3PETS})"

      # PETS for quilting
      if [[ "${QUILTING:-}" == ".true." ]]; then
        (( QUILTPETS = ntasks_quilt * nthreads_fv3 ))
        (( WRTTASK_PER_GROUP = WRTTASK_PER_GROUP_PER_THREAD ))
        export WRTTASK_PER_GROUP
      else
        QUILTPETS=0
      fi
      echo "QUILT using (nthreads, PETS) = (${nthreads_fv3}, ${QUILTPETS})"

      # Total PETS for the atmosphere component
      ATMTHREADS=${nthreads_fv3}
      (( ATMPETS = FV3PETS + QUILTPETS ))
      export ATMPETS ATMTHREADS
      echo "FV3ATM using (nthreads, PETS) = (${ATMTHREADS}, ${ATMPETS})"

      # Total PETS for the coupled model (starting w/ the atmosphere)
      NTASKS_TOT=${ATMPETS}

      # The mediator PETS can overlap with other components, usually it lands on the atmosphere tasks.
      # However, it is suggested limiting mediator PETS to 300, as it may cause the slow performance.
      # See https://docs.google.com/document/d/1bKpi-52t5jIfv2tuNHmQkYUe3hkKsiG_DG_s6Mnukog/edit
      # TODO: Update reference when moved to ufs-weather-model RTD
      MEDTHREADS=${nthreads_mediator:-1}
      MEDPETS=${MEDPETS:-${FV3PETS}}
      (( "${MEDPETS}" > 300 )) && MEDPETS=300
      export MEDPETS MEDTHREADS
      echo "MEDIATOR using (threads, PETS) = (${MEDTHREADS}, ${MEDPETS})"

      CHMPETS=0; CHMTHREADS=0
      if [[ "${DO_AERO}" == "YES" ]]; then
        # GOCART shares the same grid and forecast tasks as FV3 (do not add write grid component tasks).
        (( CHMTHREADS = ATMTHREADS ))
        (( CHMPETS = FV3PETS ))
        # Do not add to NTASKS_TOT
        echo "GOCART using (threads, PETS) = (${CHMTHREADS}, ${CHMPETS})"
      fi
      export CHMPETS CHMTHREADS

      WAVPETS=0; WAVTHREADS=0
      if [[ "${DO_WAVE}" == "YES" ]]; then
        (( WAVPETS = ntasks_ww3 * nthreads_ww3 ))
        (( WAVTHREADS = nthreads_ww3 ))
        echo "WW3 using (threads, PETS) = (${WAVTHREADS}, ${WAVPETS})"
        (( NTASKS_TOT = NTASKS_TOT + WAVPETS ))
      fi
      export WAVPETS WAVTHREADS

      OCNPETS=0; OCNTHREADS=0
      if [[ "${DO_OCN}" == "YES" ]]; then
        (( OCNPETS = ntasks_mom6 * nthreads_mom6 ))
        (( OCNTHREADS = nthreads_mom6 ))
        echo "MOM6 using (threads, PETS) = (${OCNTHREADS}, ${OCNPETS})"
        (( NTASKS_TOT = NTASKS_TOT + OCNPETS ))
      fi
      export OCNPETS OCNTHREADS

      ICEPETS=0; ICETHREADS=0
      if [[ "${DO_ICE}" == "YES" ]]; then
        (( ICEPETS = ntasks_cice6 * nthreads_cice6 ))
        (( ICETHREADS = nthreads_cice6 ))
        echo "CICE6 using (threads, PETS) = (${ICETHREADS}, ${ICEPETS})"
        (( NTASKS_TOT = NTASKS_TOT + ICEPETS ))
      fi
      export ICEPETS ICETHREADS

      echo "Total PETS for ${_CDUMP} = ${NTASKS_TOT}"

      if [[ "${_CDUMP}" =~ "gfs" ]]; then
        declare -x "npe_${step}_gfs"="${NTASKS_TOT}"
        declare -x "nth_${step}_gfs"=1  # ESMF handles threading for the UFS-weather-model
        declare -x "npe_node_${step}_gfs"="${npe_node_max}"
      else
        declare -x "npe_${step}"="${NTASKS_TOT}"
        declare -x "nth_${step}"=1  # ESMF handles threading for the UFS-weather-model
        declare -x "npe_node_${step}"="${npe_node_max}"
      fi

    done

    case "${CASE}" in
      "C48" | "C96" | "C192")
        declare -x "wtime_${step}"="00:15:00"
        declare -x "wtime_${step}_gfs"="03:00:00"
        ;;
      "C384")
        declare -x "wtime_${step}"="00:30:00"
        declare -x "wtime_${step}_gfs"="06:00:00"
        ;;
      "C768" | "C1152")
        declare -x "wtime_${step}"="00:30:00"
        declare -x "wtime_${step}_gfs"="06:00:00"
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
        ;;
    esac

    unset _CDUMP _CDUMP_LIST
    unset NTASKS_TOT
    ;;

  "oceanice_products")
    export wtime_oceanice_products="00:15:00"
    export npe_oceanice_products=1
    export npe_node_oceanice_products=1
    export nth_oceanice_products=1
    export memory_oceanice_products="96GB"
    ;;

  "upp")
    case "${CASE}" in
      "C48" | "C96")
        export npe_upp=${CASE:1}
      ;;
      "C192" | "C384" | "C768")
        export npe_upp=120
        export memory_upp="48GB"
      ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
      ;;
    esac
    export npe_node_upp=${npe_upp}

    export nth_upp=1

    export wtime_upp="00:15:00"
    if (( npe_node_upp > npe_node_max )); then
      export npe_node_upp=${npe_node_max}
    fi
    export is_exclusive=True
    ;;

  "atmos_products")
    export wtime_atmos_products="00:15:00"
    export npe_atmos_products=24
    export nth_atmos_products=1
    export npe_node_atmos_products="${npe_atmos_products}"
    export wtime_atmos_products_gfs="${wtime_atmos_products}"
    export npe_atmos_products_gfs="${npe_atmos_products}"
    export nth_atmos_products_gfs="${nth_atmos_products}"
    export npe_node_atmos_products_gfs="${npe_node_atmos_products}"
    export is_exclusive=True
    ;;

  "verfozn")
    export wtime_verfozn="00:05:00"
    export npe_verfozn=1
    export nth_verfozn=1
    export npe_node_verfozn=1
    export memory_verfozn="1G"
    ;;

  "verfrad")
    export wtime_verfrad="00:40:00"
    export npe_verfrad=1
    export nth_verfrad=1
    export npe_node_verfrad=1
    export memory_verfrad="5G"
    ;;

  "vminmon")
    export wtime_vminmon="00:05:00"
    export npe_vminmon=1
    export nth_vminmon=1
    export npe_node_vminmon=1
    export wtime_vminmon_gfs="00:05:00"
    export npe_vminmon_gfs=1
    export nth_vminmon_gfs=1
    export npe_node_vminmon_gfs=1
    export memory_vminmon="1G"
    ;;

  "tracker")
    export wtime_tracker="00:10:00"
    export npe_tracker=1
    export nth_tracker=1
    export npe_node_tracker=1
    export memory_tracker="4G"
    ;;

  "genesis")
    export wtime_genesis="00:25:00"
    export npe_genesis=1
    export nth_genesis=1
    export npe_node_genesis=1
    export memory_genesis="10G"
    ;;

  "genesis_fsu")
    export wtime_genesis_fsu="00:10:00"
    export npe_genesis_fsu=1
    export nth_genesis_fsu=1
    export npe_node_genesis_fsu=1
    export memory_genesis_fsu="10G"
    ;;

  "fit2obs")
    export wtime_fit2obs="00:20:00"
    export npe_fit2obs=3
    export nth_fit2obs=1
    export npe_node_fit2obs=1
    export memory_fit2obs="20G"
    if [[ ${machine} == "WCOSS2" ]]; then export npe_node_fit2obs=3 ; fi
    ;;

  "metp")
    export nth_metp=1
    export wtime_metp="03:00:00"
    export npe_metp=4
    export npe_node_metp=4
    export wtime_metp_gfs="06:00:00"
    export npe_metp_gfs=4
    export npe_node_metp_gfs=4
    export is_exclusive=True
    ;;

  "echgres")
    export wtime_echgres="00:10:00"
    export npe_echgres=3
    export nth_echgres=${npe_node_max}
    export npe_node_echgres=1
    if [[ "${machine}" == "WCOSS2" ]]; then
      export memory_echgres="200GB"
    fi
    ;;

  "init")
    export wtime_init="00:30:00"
    export npe_init=24
    export nth_init=1
    export npe_node_init=6
    export memory_init="70GB"
    ;;

  "init_chem")
    export wtime_init_chem="00:30:00"
    export npe_init_chem=1
    export npe_node_init_chem=1
    export is_exclusive=True
    ;;

  "mom6ic")
    export wtime_mom6ic="00:30:00"
    export npe_mom6ic=24
    export npe_node_mom6ic=24
    export is_exclusive=True
    ;;

  "arch" | "earc" | "getic")
    declare -x "wtime_${step}"="06:00:00"
    declare -x "npe_${step}"="1"
    declare -x "npe_node_${step}"="1"
    declare -x "nth_${step}"="1"
    declare -x "memory_${step}"="4096M"
    if [[ "${machine}" == "WCOSS2" ]]; then
      declare -x "memory_${step}"="50GB"
    fi
    ;;

  "cleanup")
    export wtime_cleanup="00:15:00"
    export npe_cleanup=1
    export npe_node_cleanup=1
    export nth_cleanup=1
    export memory_cleanup="4096M"
    ;;

  "stage_ic")
    export wtime_stage_ic="00:15:00"
    export npe_stage_ic=1
    export npe_node_stage_ic=1
    export nth_stage_ic=1
    export is_exclusive=True
    ;;

  "atmensanlinit")
    export layout_x=${layout_x_atmensanl}
    export layout_y=${layout_y_atmensanl}

    export wtime_atmensanlinit="00:10:00"
    export npe_atmensanlinit=1
    export nth_atmensanlinit=1
    export npe_node_atmensanlinit=$(( npe_node_max / nth_atmensanlinit ))
    export memory_atmensanlinit="3072M"
    ;;

  "atmensanlrun")
    export layout_x=${layout_x_atmensanl}
    export layout_y=${layout_y_atmensanl}

    export wtime_atmensanlrun="00:30:00"
    export npe_atmensanlrun=$(( layout_x * layout_y * 6 ))
    export npe_atmensanlrun_gfs=$(( layout_x * layout_y * 6 ))
    export nth_atmensanlrun=1
    export nth_atmensanlrun_gfs=${nth_atmensanlrun}
    export npe_node_atmensanlrun=$(( npe_node_max / nth_atmensanlrun ))
    export memory_atmensanlrun="96GB"
    export is_exclusive=True
    ;;

  "atmensanlfinal")
    export wtime_atmensanlfinal="00:30:00"
    export npe_atmensanlfinal=${npe_node_max}
    export nth_atmensanlfinal=1
    export npe_node_atmensanlfinal=$(( npe_node_max / nth_atmensanlfinal ))
    export is_exclusive=True
    ;;

  "eobs" | "eomg")
    export wtime_eobs="00:15:00"
    export wtime_eomg="00:30:00"
    case ${CASE} in
      "C768")                 export npe_eobs=200;;
      "C384")                 export npe_eobs=100;;
      "C192" | "C96" | "C48") export npe_eobs=40;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
        ;;
    esac
    export npe_eomg=${npe_eobs}
    export nth_eobs=2
    export nth_eomg=${nth_eobs}
    export npe_node_eobs=$(( npe_node_max / nth_eobs ))
    export is_exclusive=True
    # The number of tasks and cores used must be the same for eobs
    # See https://github.com/NOAA-EMC/global-workflow/issues/2092 for details
    # For S4, this is accomplished by running 10 tasks/node
    if [[ ${machine} = "S4" ]]; then
      export npe_node_eobs=10
    elif [[ ${machine} = "HERCULES" ]]; then
      # For Hercules, this is only an issue at C384; use 20 tasks/node
      if [[ ${CASE} = "C384" ]]; then
        export npe_node_eobs=20
      fi
    fi
    export npe_node_eomg=${npe_node_eobs}
    ;;

  "ediag")
    export wtime_ediag="00:15:00"
    export npe_ediag=48
    export nth_ediag=1
    export npe_node_ediag=$(( npe_node_max / nth_ediag ))
    export memory_ediag="30GB"
    ;;

  "eupd")
    export wtime_eupd="00:30:00"
    case ${CASE} in
      "C768")
        export npe_eupd=480
        export nth_eupd=6
        if [[ "${machine}" == "WCOSS2" ]]; then
          export npe_eupd=315
          export nth_eupd=14
        fi
        ;;
      "C384")
        export npe_eupd=270
        export nth_eupd=8
        if [[ "${machine}" == "WCOSS2" ]]; then
          export npe_eupd=315
          export nth_eupd=14
        elif [[ ${machine} == "S4" ]]; then
           export npe_eupd=160
           export nth_eupd=2
        fi
        ;;
      "C192" | "C96" | "C48")
        export npe_eupd=42
        export nth_eupd=2
        if [[ "${machine}" == "HERA" || "${machine}" == "JET" ]]; then
          export nth_eupd=4
        fi
        ;;
      *)
        echo "FATAL ERROR: Resources not defined for job ${job} at resolution ${CASE}"
        exit 4
        ;;
    esac
    export npe_node_eupd=$(( npe_node_max / nth_eupd ))
    export is_exclusive=True
    ;;

  "ecen")
    export wtime_ecen="00:10:00"
    export npe_ecen=80
    export nth_ecen=4
    if [[ "${machine}" == "HERA" ]]; then export nth_ecen=6; fi
    if [[ ${CASE} == "C384" || ${CASE} == "C192" || ${CASE} == "C96" || ${CASE} == "C48" ]]; then
      export nth_ecen=2
    fi
    export npe_node_ecen=$(( npe_node_max / nth_ecen ))
    export nth_cycle=${nth_ecen}
    export npe_node_cycle=$(( npe_node_max / nth_cycle ))
    export is_exclusive=True
    ;;

  "esfc")
    export wtime_esfc="00:08:00"
    export npe_esfc=80
    export nth_esfc=1
    export npe_node_esfc=$(( npe_node_max / nth_esfc ))
    export nth_cycle=${nth_esfc}
    export npe_node_cycle=$(( npe_node_max / nth_cycle ))
    export memory_esfc="80GB"
    ;;

  "epos")
    export wtime_epos="00:15:00"
    export npe_epos=80
    export nth_epos=1
    export npe_node_epos=$(( npe_node_max / nth_epos ))
    export is_exclusive=True
    ;;

  "postsnd")
    export wtime_postsnd="02:00:00"
    export npe_postsnd=40
    export nth_postsnd=8
    export npe_node_postsnd=10
    export npe_postsndcfp=9
    export npe_node_postsndcfp=1
    postsnd_req_cores=$(( npe_node_postsnd * nth_postsnd ))
    if (( postsnd_req_cores > npe_node_max )); then
        export npe_node_postsnd=$(( npe_node_max / nth_postsnd ))
    fi
    export is_exclusive=True
    ;;

  "awips")
    export wtime_awips="03:30:00"
    export npe_awips=1
    export npe_node_awips=1
    export nth_awips=1
    export memory_awips="3GB"
    ;;

  "npoess")
    export wtime_npoess="03:30:00"
    export npe_npoess=1
    export npe_node_npoess=1
    export nth_npoess=1
    export memory_npoess="3GB"
    ;;

  "gempak")
    export wtime_gempak="03:00:00"
    export npe_gempak=2
    export npe_gempak_gfs=28
    export npe_node_gempak=2
    export npe_node_gempak_gfs=28
    export nth_gempak=1
    export memory_gempak="4GB"
    export memory_gempak_gfs="2GB"
    ;;

  "mos_stn_prep")
    export wtime_mos_stn_prep="00:10:00"
    export npe_mos_stn_prep=3
    export npe_node_mos_stn_prep=3
    export nth_mos_stn_prep=1
    export memory_mos_stn_prep="5GB"
    export NTASK="${npe_mos_stn_prep}"
    export PTILE="${npe_node_mos_stn_prep}"
    ;;

  "mos_grd_prep")
    export wtime_mos_grd_prep="00:10:00"
    export npe_mos_grd_prep=4
    export npe_node_mos_grd_prep=4
    export nth_mos_grd_prep=1
    export memory_mos_grd_prep="16GB"
    export NTASK="${npe_mos_grd_prep}"
    export PTILE="${npe_node_mos_grd_prep}"
    ;;

  "mos_ext_stn_prep")
    export wtime_mos_ext_stn_prep="00:15:00"
    export npe_mos_ext_stn_prep=2
    export npe_node_mos_ext_stn_prep=2
    export nth_mos_ext_stn_prep=1
    export memory_mos_ext_stn_prep="5GB"
    export NTASK="${npe_mos_ext_stn_prep}"
    export PTILE="${npe_node_mos_ext_stn_prep}"
    ;;

  "mos_ext_grd_prep")
    export wtime_mos_ext_grd_prep="00:10:00"
    export npe_mos_ext_grd_prep=7
    export npe_node_mos_ext_grd_prep=7
    export nth_mos_ext_grd_prep=1
    export memory_mos_ext_grd_prep="3GB"
    export NTASK="${npe_mos_ext_grd_prep}"
    export PTILE="${npe_node_mos_ext_grd_prep}"
    ;;

  "mos_stn_fcst")
    export wtime_mos_stn_fcst="00:10:00"
    export npe_mos_stn_fcst=5
    export npe_node_mos_stn_fcst=5
    export nth_mos_stn_fcst=1
    export memory_mos_stn_fcst="40GB"
    export NTASK="${npe_mos_stn_fcst}"
    export PTILE="${npe_node_mos_stn_fcst}"
    ;;

  "mos_grd_fcst")
    export wtime_mos_grd_fcst="00:10:00"
    export npe_mos_grd_fcst=7
    export npe_node_mos_grd_fcst=7
    export nth_mos_grd_fcst=1
    export memory_mos_grd_fcst="50GB"
    export NTASK="${npe_mos_grd_fcst}"
    export PTILE="${npe_node_mos_grd_fcst}"
    ;;

  "mos_ext_stn_fcst")
    export wtime_mos_ext_stn_fcst="00:20:00"
    export npe_mos_ext_stn_fcst=3
    export npe_node_mos_ext_stn_fcst=3
    export nth_mos_ext_stn_fcst=1
    export memory_mos_ext_stn_fcst="50GB"
    export NTASK="${npe_mos_ext_stn_fcst}"
    export PTILE="${npe_node_mos_ext_stn_fcst}"
    export prepost=True
    ;;

  "mos_ext_grd_fcst")
    export wtime_mos_ext_grd_fcst="00:10:00"
    export npe_mos_ext_grd_fcst=7
    export npe_node_mos_ext_grd_fcst=7
    export nth_mos_ext_grd_fcst=1
    export memory_mos_ext_grd_fcst="50GB"
    export NTASK="${npe_mos_ext_grd_fcst}"
    export PTILE="${npe_node_mos_ext_grd_fcst}"
    ;;

  "mos_stn_prdgen")
    export wtime_mos_stn_prdgen="00:10:00"
    export npe_mos_stn_prdgen=1
    export npe_node_mos_stn_prdgen=1
    export nth_mos_stn_prdgen=1
    export memory_mos_stn_prdgen="15GB"
    export NTASK="${npe_mos_stn_prdgen}"
    export PTILE="${npe_node_mos_stn_prdgen}"
    export prepost=True
    ;;

  "mos_grd_prdgen")
    export wtime_mos_grd_prdgen="00:40:00"
    export npe_mos_grd_prdgen=72
    export npe_node_mos_grd_prdgen=18
    export nth_mos_grd_prdgen=4
    export memory_mos_grd_prdgen="20GB"
    export NTASK="${npe_mos_grd_prdgen}"
    export PTILE="${npe_node_mos_grd_prdgen}"
    export OMP_NUM_THREADS="${nth_mos_grd_prdgen}"
    ;;

  "mos_ext_stn_prdgen")
    export wtime_mos_ext_stn_prdgen="00:10:00"
    export npe_mos_ext_stn_prdgen=1
    export npe_node_mos_ext_stn_prdgen=1
    export nth_mos_ext_stn_prdgen=1
    export memory_mos_ext_stn_prdgen="15GB"
    export NTASK="${npe_mos_ext_stn_prdgen}"
    export PTILE="${npe_node_mos_ext_stn_prdgen}"
    export prepost=True
    ;;

  "mos_ext_grd_prdgen")
    export wtime_mos_ext_grd_prdgen="00:30:00"
    export npe_mos_ext_grd_prdgen=96
    export npe_node_mos_ext_grd_prdgen=6
    export nth_mos_ext_grd_prdgen=16
    export memory_mos_ext_grd_prdgen="30GB"
    export NTASK="${npe_mos_ext_grd_prdgen}"
    export PTILE="${npe_node_mos_ext_grd_prdgen}"
    export OMP_NUM_THREADS="${nth_mos_ext_grd_prdgen}"
    ;;

  "mos_wx_prdgen")
    export wtime_mos_wx_prdgen="00:10:00"
    export npe_mos_wx_prdgen=4
    export npe_node_mos_wx_prdgen=2
    export nth_mos_wx_prdgen=2
    export memory_mos_wx_prdgen="10GB"
    export NTASK="${npe_mos_wx_prdgen}"
    export PTILE="${npe_node_mos_wx_prdgen}"
    export OMP_NUM_THREADS="${nth_mos_wx_prdgen}"
    ;;

  "mos_wx_ext_prdgen")
    export wtime_mos_wx_ext_prdgen="00:10:00"
    export npe_mos_wx_ext_prdgen=4
    export npe_node_mos_wx_ext_prdgen=2
    export nth_mos_wx_ext_prdgen=2
    export memory_mos_wx_ext_prdgen="10GB"
    export NTASK="${npe_mos_wx_ext_prdgen}"
    export PTILE="${npe_node_mos_wx_ext_prdgen}"
    export OMP_NUM_THREADS="${nth_mos_wx_ext_prdgen}"
    ;;

  *)
    echo "FATAL ERROR: Invalid job ${step} passed to ${BASH_SOURCE[0]}"
    exit 1
    ;;

esac

echo "END: config.resources"