#!/usr/bin/python
import os
from ecflow import *
from datetime import date,timedelta

lmp_envir = "para"
gfsmos_envir = "para"
nammos_envir = "para"
hrrr_envir = "para"
rap_envir = "para"
nammos_envir = "para"

lmp_ver = "v2.4"
glmp_ver = "v2.4"

#TODO:
# Any jobs within the same environment (prod/para/test) as the lmp/glmp should be added to
# the suite definition instead of being defined as externs.
# Should we also make all triggers within the same suite relative?

def zpad(i): return str(i).zfill(2)

def build_lmp_run(hour, minute):
    previous_hour = ( hour + 23 ) % 24
    # assume 6-hour cycles
    current_cycle = hour - (hour % 6)
    previous_cycle = previous_hour - (previous_hour % 6)

    # The hrrr_prep job is triggered by the finish of the 15th projection of the
    # previous HRRR cycle and the 1hcnvltg_hrrrprep job is triggered by the finish
    # of the 18th projection of the previous HRRR cycle, where "previous HRRR cycle"
    # is prev_hr-1 for 30m and 45m runs and prev_hr-2 for 00m and 15m runs.
    # 24*60 - (1*60 + 30) = 1350
    hrrr_hour =  int(( (hour*60 + minute) + 1350 ) % 1440 / 60)
    hrrr_cycle = int(hrrr_hour - (hrrr_hour % 6))

    # LMP refreshes GFSMOS/NAMMOS model outputs 4 times a day, namely 04z, 10z, 16z
    # and 22z, where 04z refers to the base 0430z run, etc.  So 04-09z shouldn't run
    # unless the 00z GFSMOS and 00z NAMMOS finish, 10z-15z LMP shouldn't run unless
    # the 06z MOSes finish, and so on.
    # 24*60 - (4*60 + 30) = 1170
#    mos_cycle = int(( ( (hour*60 + minute) + 1170 ) % 1440 / 360 ) * 6)
    mos_cycle = int(hrrr_hour - (hrrr_hour % 6))

    lmp_run_family = Family(zpad(minute))

    ##########################
    # Tasks for all lmp runs #
    ##########################

    # prep job requires that the previous cycle of the gfsmos and lmp (of the same
    # "minute" run) be complete
    prep = lmp_run_family.add_task("jlmp_prep")
    if previous_cycle == current_cycle:
      lmp_trigger = "../../{0}z/{1} == complete".format(zpad(previous_hour), zpad(minute))
    elif lmp_envir == "test":
      lmp_trigger = "/test/lmp{0}/{1}z/{2} == complete".format(zpad(previous_cycle), zpad(previous_hour), zpad(minute))
    else:
      lmp_trigger = "/{0}/primary/{1}/lmp/v2.4/{2}z/{3} == complete".format(lmp_envir, zpad(previous_cycle), zpad(previous_hour), zpad(minute))
#    prep.add_trigger("/{0}{1}/gfs/mos/prdgen/jgfsmos_prdgen == complete and {2}".format(gfsmos_envir, zpad(mos_cycle), lmp_trigger))

    # hrrr_prep requires the previous cycle of the hrrr
    hrrr_prep = lmp_run_family.add_task("jlmp_hrrr_prep")
#    hrrr_prep.add_trigger("/{0}{1}/hrrr/{2}z/conus/post/post/jhrrr_post_f18 == complete".format(hrrr_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))

    rap_prep = lmp_run_family.add_task("jlmp_rap_prep")
#    rap_prep.add_trigger("/{0}{1}/hrrr/{2}z/conus/post/post/jhrrr_post_f18 == complete and /{3}{1}/rap/{2}z/post/post/jrap_post_f21:wrfgrib2_ready".format(hrrr_envir, zpad(hrrr_cycle), zpad(hrrr_hour), rap_envir))

    cigvis_mosfcst = lmp_run_family.add_task("jlmp_cigvis_mosfcst")
    cigvis_mosfcst.add_trigger("jlmp_prep == complete")

    raphrrr_fcst = lmp_run_family.add_task("jlmp_raphrrr_fcst")
    raphrrr_fcst.add_trigger("jlmp_hrrr_prep == complete and jlmp_rap_prep == complete")

    station_fcst = lmp_run_family.add_task("jlmp_station_fcst")
    station_fcst.add_trigger("jlmp_prep == complete and jlmp_raphrrr_fcst == complete and jlmp_cigvis_mosfcst == complete")

    # for main cycle, also triggers off of cnv and ltg families
    prdgen = Task("jlmp_prdgen")
    if minute == 30:
        prdgen.add_trigger("jlmp_station_fcst == complete and cnv == complete and ltg == complete and pop == complete and jlmp_akcnvltg_prdgen == complete")
    else:
        prdgen.add_trigger("jlmp_station_fcst == complete")

    ########################################
    # Tasks for main lmp runs only (HH:30) #
    ########################################

    if minute == 30:

        # pop family
        pop_family = Family("pop")

        pop_rapprep = pop_family.add_task("jlmp_pop_rapprep")
        #pop_rapprep.add_trigger("/{0}{1}/rap/{2}z/post/post/jrap_post_f21 == complete".format(rap_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))

        pop_mosfcst = pop_family.add_task("jlmp_pop_mosfcst")
        pop_mosfcst.add_trigger("jlmp_pop_rapprep == complete and ../jlmp_1hcnvltg_hrrrprep == complete")

        pop_blmpfcst = pop_family.add_task("jlmp_pop_blmpfcst")
        pop_blmpfcst.add_trigger("../jlmp_1hcnvltg_radltgprep == complete and jlmp_pop_mosfcst == complete")

        pop_meldfcst = pop_family.add_task("jlmp_pop_meldfcst")
        pop_meldfcst.add_trigger("jlmp_pop_blmpfcst == complete")

        pop_prdgen = pop_family.add_task("jlmp_pop_prdgen")
        pop_prdgen.add_trigger("jlmp_pop_meldfcst == complete")

        #cnv/ltg family

        cnv_family = Family("cnv")
        ltg_family = Family("ltg")

        # cnvltg_prep is run separately for cnv and ltg
#        cl_prep_trigger = "/{0}{1}/nam/tm00/mos/jnam_mos == complete and ../lmp_prep == complete and /{2}{3}/gfs/mos/forecast/jgfsmos_fcst == complete".format(nammos_envir, zpad(mos_cycle), gfsmos_envir, zpad(mos_cycle))
        cl_prep_trigger = "../jlmp_prep == complete"
#        
        cl_prep = cnv_family.add_task("jlmp_cnvltg_prep")
        cl_prep.add_trigger(cl_prep_trigger)
        cl_prep = ltg_family.add_task("jlmp_cnvltg_prep")
        cl_prep.add_trigger(cl_prep_trigger)

        # cnvltg_fcst is run separately for cnv and ltg
        cl_fcst = cnv_family.add_task("jlmp_cnvltg_fcst")
        cl_fcst.add_trigger("jlmp_cnvltg_prep == complete")
        cl_fcst = ltg_family.add_task("jlmp_cnvltg_fcst")
        cl_fcst.add_trigger("jlmp_cnvltg_prep == complete")

        # cnvltg_prdgen is run separately for cnv and ltg
        cl_prdgen = cnv_family.add_task("jlmp_cnvltg_prdgen")
        cl_prdgen.add_trigger("jlmp_cnvltg_fcst == complete")
        cl_prdgen = ltg_family.add_task("jlmp_cnvltg_prdgen")
        cl_prdgen.add_trigger("jlmp_cnvltg_fcst == complete")

        hcl_mrmsprep = lmp_run_family.add_task("jlmp_1hcnvltg_mrmsprep")
#        hcl_mrmsprep.add_trigger("/{0}{1}/gfs/mos/prep/jgfsmos_prep == complete".format(gfsmos_envir, zpad(mos_cycle)))

        hcl_hrrrprep = lmp_run_family.add_task("jlmp_1hcnvltg_hrrrprep")
#        hcl_hrrrprep.add_trigger("/{0}{1}/hrrr/{2}z/conus/post/post/jhrrr_post_f18 == complete".format(hrrr_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))

        hcl_radltgprep = lmp_run_family.add_task("jlmp_1hcnvltg_radltgprep")
        hcl_radltgprep.add_trigger("jlmp_1hcnvltg_mrmsprep == complete and jlmp_1hcnvltg_hrrrprep == complete")

        hcl_mosfcst = lmp_run_family.add_task("jlmp_1hcnvltg_mosfcst")
#        hcl_mosfcst.add_trigger("/{0}{1}/nam/tm00/mos/jnam_mos_prep == complete and /{2}{3}/gfs/mos/prep/jgfsmos_stn_prep == complete".format(nammos_envir, zpad(mos_cycle), gfsmos_envir, zpad(mos_cycle)))

        # 1hcnvltg_mospreds is run separately for cnv and ltg
        hcl_mospreds = cnv_family.add_task("jlmp_1hcnvltg_mospreds")
        hcl_mospreds.add_trigger("../jlmp_1hcnvltg_mosfcst == complete")
        hcl_mospreds = ltg_family.add_task("jlmp_1hcnvltg_mospreds")
        hcl_mospreds.add_trigger("../jlmp_1hcnvltg_mosfcst == complete")

        hcl_fcst = lmp_run_family.add_task("jlmp_1hcnvltg_fcst")
        hcl_fcst.add_trigger("jlmp_1hcnvltg_radltgprep == complete and cnv/jlmp_1hcnvltg_mospreds == complete and ltg/jlmp_1hcnvltg_mospreds == complete")

        # 1hcnvltg_prdgen is run separately for cnv and ltg
        hcl_prdgen = cnv_family.add_task("jlmp_1hcnvltg_prdgen")
        hcl_prdgen.add_trigger("../jlmp_1hcnvltg_fcst == complete")
        hcl_prdgen = ltg_family.add_task("jlmp_1hcnvltg_prdgen")
        hcl_prdgen.add_trigger("../jlmp_1hcnvltg_fcst == complete")

        # Alaska cnvltg
        akcl_rapprep = lmp_run_family.add_task("jlmp_akcnvltg_rapprep")
#        akcl_rapprep.add_trigger("/{0}{1}/rap/{2}z/post/post/jrap_post_f21 == complete".format(rap_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))
               
        akcl_mrmsprep = lmp_run_family.add_task("jlmp_akcnvltg_mrmsprep")

        akcl_radltgprep = lmp_run_family.add_task("jlmp_akcnvltg_radltgprep")
        akcl_radltgprep.add_trigger("jlmp_akcnvltg_mrmsprep == complete")

        akcl_mosfcst = lmp_run_family.add_task("jlmp_akcnvltg_mosfcst")
        akcl_mosfcst.add_trigger("jlmp_akcnvltg_rapprep == complete")

        akcl_blmpfcst = lmp_run_family.add_task("jlmp_akcnvltg_blmpfcst")
        akcl_blmpfcst.add_trigger("jlmp_akcnvltg_radltgprep == complete and jlmp_akcnvltg_mosfcst == complete")

        akcl_meldfcst = lmp_run_family.add_task("jlmp_akcnvltg_meldfcst")
        akcl_meldfcst.add_trigger("jlmp_akcnvltg_blmpfcst == complete")

        akcl_prdgen = lmp_run_family.add_task("jlmp_akcnvltg_prdgen")
        akcl_prdgen.add_trigger("jlmp_akcnvltg_meldfcst == complete")

        lmp_run_family.add_family(cnv_family)
        lmp_run_family.add_family(ltg_family)
        lmp_run_family.add_family(pop_family)

        ak_prdgen = lmp_run_family.add_task("jlmp_ak_prdgen")
#        if lmp_envir == "test":
#           ak_prdgen.add_trigger("../../../../glmp/v2.4/{0}z/{1}/cig/glmp_meld_prdgen_ak == complete and ../../../glmp{0}/{1}z/{2}/vis/glmp_meld_prdgen_ak == complete".format(zpad(hour), zpad(minute)))
#        else:
        ak_prdgen.add_trigger("../../../../glmp/v2.4/{0}z/{1}/cig/jglmp_meld_prdgen_ak == complete and ../../../../glmp/v2.4/{0}z/{1}/vis/jglmp_meld_prdgen_ak == complete".format(zpad(hour), zpad(minute)))

    lmp_run_family.add_task(prdgen)

    # the run actually starts 3 minutes before the "run time"
    if minute == 0:
        lmp_run_family.add_time("{0}:{1}".format(zpad(previous_hour), "57"))
    else:
        lmp_run_family.add_time("{0}:{1}".format(zpad(hour), zpad(minute-3)))

    return lmp_run_family

def build_glmp_run(hour, minute):
    previous_hour = ( hour + 23 ) % 24
    # assume 6-hour cycles
    current_cycle = hour - (hour % 6)
    previous_cycle = previous_hour - (previous_hour % 6)

    # GLMP refreshes GFSMOS model outputs twice a day, namely 06z and 18z, where 06z
    # refers to the main 0630z run, etc.  So 06z-17z shouldn't run unless the 00z
    # GFSMOS is complete and 18z-05z GLMP shouldn't run unless the 12z MOS is finished
    # 24*60 - (6*60 + 30) = 1050
#    mos_cycle = ( ( (hour*60 + minute) + 1050 ) % 1440 / 720 ) * 12

    rap_hour =  int(( (hour*60 + minute) + 1350 ) % 1440 / 60)
    rap_cycle = int(rap_hour - (rap_hour % 6))

    mos_cycle = int(rap_hour - (rap_hour % 6))

    glmp_run_family = Family(zpad(minute))

    ###########################
    # Tasks for all glmp runs #
    ###########################

    obs_prep = glmp_run_family.add_task("jglmp_obs_prep")

#    hrrr_prep = glmp_run_family.add_task("jglmp_hrrr_prep")
#    if lmp_envir == "test":
#      hrrr_prep.add_trigger("../../../lmp{0}/{1}z/{2}/lmp_hrrr_prep == complete".format(zpad(current_cycle), zpad(hour), zpad(minute)))
#    else:
#      hrrr_prep.add_trigger("../../../lmp/{0}z/{1}/lmp_hrrr_prep == complete".format(zpad(hour), zpad(minute)))

    raphrrr_fcst = glmp_run_family.add_task("jglmp_raphrrr_fcst")
    if lmp_envir == "test":
       raphrrr_fcst.add_trigger("../../../../lmp/{1}z/{2}/jlmp_hrrr_prep == complete".format(zpad(current_cycle), zpad(hour), zpad(minute)))
    else:
       raphrrr_fcst.add_trigger("../../../../lmp/v2.4/{0}z/{1}/jlmp_hrrr_prep == complete".format(zpad(hour), zpad(minute)))

    rap1h_prep = glmp_run_family.add_task("jglmp_rap1h_prep")
#    rap1h_prep.add_trigger("/{0}{1}/rap/{2}z/post/post/jrap_post_f21 == complete".format(rap_envir, zpad(rap_cycle), zpad(rap_hour)))

    fcst_rap3 = glmp_run_family.add_task("jglmp_fcst_rap3")
    if lmp_envir == "test":
       fcst_rap3.add_trigger("../../../lmp{0}/{1}z/{2}/jlmp_rap_prep == complete and /{3}{4}/rap/{5}z/post/post/jrap_post_f21 == complete".format(zpad(current_cycle), zpad(hour), zpad(minute), rap_envir, zpad(rap_cycle), zpad(rap_hour)))
    else:
#       fcst_rap3.add_trigger("../../../../lmp/v2.4/{0}z/{1}/lmp_rap_prep == complete and /{2}{3}/rap/{4}z/post/post/jrap_post_f21 == complete".format(zpad(hour), zpad(minute), rap_envir, zpad(rap_cycle), zpad(rap_hour)))
      fcst_rap3.add_trigger("../../../../lmp/v2.4/{0}z/{1}/jlmp_rap_prep == complete".format(zpad(hour), zpad(minute)))

    vis_family = glmp_run_family.add_family("vis")
    sky_family = glmp_run_family.add_family("sky")
    cig_family = glmp_run_family.add_family("cig")

    obs_granalysis = vis_family.add_task("jglmp_obs_granalysis")
    obs_granalysis.add_trigger("../jglmp_obs_prep == complete and ../jglmp_rap1h_prep == complete")
    obs_granalysis = sky_family.add_task("jglmp_obs_granalysis")
    obs_granalysis.add_trigger("../jglmp_obs_prep == complete and ../jglmp_rap1h_prep == complete")
    obs_granalysis = cig_family.add_task("jglmp_obs_granalysis")
    obs_granalysis.add_trigger("../jglmp_obs_prep == complete and ../jglmp_rap1h_prep == complete")

    obs_granalysis_ak = cig_family.add_task("jglmp_obs_granalysis_ak")
    obs_granalysis_ak.add_trigger("../jglmp_obs_prep == complete and ../jglmp_rap1h_prep == complete")
    obs_granalysis_ak = vis_family.add_task("jglmp_obs_granalysis_ak")
    obs_granalysis_ak.add_trigger("../jglmp_obs_prep == complete and ../jglmp_rap1h_prep == complete")

    obs_prdgen = vis_family.add_task("jglmp_obs_prdgen")
    obs_prdgen.add_trigger("jglmp_obs_granalysis == complete")
    obs_prdgen = sky_family.add_task("jglmp_obs_prdgen")
    obs_prdgen.add_trigger("jglmp_obs_granalysis == complete")
    obs_prdgen = cig_family.add_task("jglmp_obs_prdgen")
    obs_prdgen.add_trigger("jglmp_obs_granalysis == complete")

    obs_prdgen_ak = vis_family.add_task("jglmp_obs_prdgen_ak")
    obs_prdgen_ak.add_trigger("jglmp_obs_granalysis_ak == complete")
    obs_prdgen_ak = cig_family.add_task("jglmp_obs_prdgen_ak")
    obs_prdgen_ak.add_trigger("jglmp_obs_granalysis_ak == complete")

    if lmp_envir == "test":
      fcst_granalysis_p_trigger = "../../../../lmp{0}/{1}z/{2}/jlmp_prdgen == complete and ../jglmp_raphrrr_fcst == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
      fcst_granalysis_p_ak_trigger = "../../../../lmp{0}/{1}z/{2}/jlmp_prdgen == complete and ../jglmp_fcst_rap3 == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
      fcst_granalysis_trigger = "../../../../lmp{0}/{1}z/{2}/jlmp_prdgen == complete and ../jglmp_obs_prep == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
    else:
      fcst_granalysis_p_trigger = "../../../../../lmp/v2.4/{0}z/{1}/jlmp_prdgen == complete and ../jglmp_raphrrr_fcst == complete".format(zpad(hour), zpad(minute))
      fcst_granalysis_p_ak_trigger = "../../../../../lmp/v2.4/{0}z/{1}/jlmp_prdgen == complete and ../jglmp_fcst_rap3 == complete".format(zpad(hour), zpad(minute))
      fcst_granalysis_trigger = "../../../../../lmp/v2.4/{0}z/{1}/jlmp_prdgen == complete and ../jglmp_obs_prep == complete".format(zpad(hour), zpad(minute))

    fcst_granalysis_p = vis_family.add_task("jglmp_fcst_granalysis_p")
    fcst_granalysis_p.add_trigger(fcst_granalysis_p_trigger)
    fcst_granalysis_p.add_variable('NCPUS', '12')
    fcst_granalysis_p.add_variable('NTHREADS', '4')
    fcst_granalysis_p.add_variable('MEM', '40')
    fcst_granalysis_p.add_variable('NTASK', '3')
    fcst_granalysis_p = cig_family.add_task("jglmp_fcst_granalysis_p")
    fcst_granalysis_p.add_trigger(fcst_granalysis_p_trigger)
    fcst_granalysis_p.add_variable('NCPUS', '12')
    fcst_granalysis_p.add_variable('NTHREADS', '4')
    fcst_granalysis_p.add_variable('MEM', '40')
    fcst_granalysis_p.add_variable('NTASK', '3')
    fcst_granalysis_p = sky_family.add_task("jglmp_fcst_granalysis_p")
    fcst_granalysis_p.add_trigger(fcst_granalysis_p_ak_trigger)
    fcst_granalysis_p.add_variable('NCHUNKS', '2')
    fcst_granalysis_p.add_variable('NCPUS', '76')
    fcst_granalysis_p.add_variable('NTHREADS', '4')
    fcst_granalysis_p.add_variable('MEM', '60')
    fcst_granalysis_p.add_variable('NTASK', '38')
    fcst_granalysis = sky_family.add_task("jglmp_fcst_granalysis")
    fcst_granalysis.add_trigger(fcst_granalysis_trigger)
    fcst_granalysis.add_variable('NCHUNKS', '2')
    fcst_granalysis.add_variable('NCPUS', '76')
    fcst_granalysis.add_variable('NTHREADS', '4')
    fcst_granalysis.add_variable('MEM', '60')
    fcst_granalysis.add_variable('NTASK', '38')

    fcst_granalysis_p_ak = vis_family.add_task("jglmp_fcst_granalysis_p_ak")
    fcst_granalysis_p_ak.add_trigger(fcst_granalysis_p_ak_trigger)
    fcst_granalysis_p_ak.add_variable('NCPUS', '12')
    fcst_granalysis_p_ak.add_variable('NTHREADS', '4')
    fcst_granalysis_p_ak.add_variable('MEM', '40')
    fcst_granalysis_p_ak.add_variable('NTASK', '3')
    fcst_granalysis_p_ak = cig_family.add_task("jglmp_fcst_granalysis_p_ak")
    fcst_granalysis_p_ak.add_trigger(fcst_granalysis_p_ak_trigger)
    fcst_granalysis_p_ak.add_variable('NCPUS', '12')
    fcst_granalysis_p_ak.add_variable('NTHREADS', '4')
    fcst_granalysis_p_ak.add_variable('MEM', '40')
    fcst_granalysis_p_ak.add_variable('NTASK', '3')

    fcst_meld = vis_family.add_task("jglmp_fcst_meld")
    fcst_meld.add_trigger("../jglmp_raphrrr_fcst == complete and jglmp_fcst_granalysis_p == complete and jglmp_obs_granalysis == complete")
    fcst_meld.add_variable('NCPUS','3')
    fcst_meld = cig_family.add_task("jglmp_fcst_meld")
    fcst_meld.add_trigger("../jglmp_raphrrr_fcst == complete and jglmp_fcst_granalysis_p == complete and jglmp_obs_granalysis == complete")
    fcst_meld.add_variable('NCPUS','3')

    fcst_meld_ak = vis_family.add_task("jglmp_fcst_meld_ak")
    fcst_meld_ak.add_trigger("jglmp_fcst_granalysis_p_ak == complete and jglmp_obs_granalysis_ak == complete")
    fcst_meld_ak = cig_family.add_task("jglmp_fcst_meld_ak")
    fcst_meld_ak.add_trigger("jglmp_fcst_granalysis_p_ak == complete and jglmp_obs_granalysis_ak == complete")

    meld_prdgen = vis_family.add_task("jglmp_meld_prdgen")
    meld_prdgen.add_trigger("jglmp_fcst_meld == complete")
    meld_prdgen = cig_family.add_task("jglmp_meld_prdgen")
    meld_prdgen.add_trigger("jglmp_fcst_meld == complete")

    meld_prdgen_ak = vis_family.add_task("jglmp_meld_prdgen_ak")
    meld_prdgen_ak.add_trigger("jglmp_fcst_meld_ak == complete")
    meld_prdgen_ak = cig_family.add_task("jglmp_meld_prdgen_ak")
    meld_prdgen_ak.add_trigger("jglmp_fcst_meld_ak == complete")

    fcst_prdgen = sky_family.add_task("jglmp_fcst_prdgen")
    fcst_prdgen.add_trigger("jglmp_fcst_granalysis == complete and ../cig/jglmp_meld_prdgen == complete")
    fcst_prdgen_p = sky_family.add_task("jglmp_fcst_prdgen_p")
    fcst_prdgen_p.add_trigger("jglmp_fcst_granalysis_p == complete")

    #########################################
    # Tasks for main glmp runs only (HH:30) #
    #########################################

    if minute == 30:

        fcst_granalysis_p = vis_family.find_task("jglmp_fcst_granalysis_p")
        fcst_granalysis_p.delete_variable('NCPUS')
        fcst_granalysis_p.delete_variable('NTHREADS')
        fcst_granalysis_p.delete_variable('MEM')
        fcst_granalysis_p.delete_variable('NTASK')
        fcst_granalysis_p.add_variable('NCHUNKS', '2')
        fcst_granalysis_p.add_variable('NCPUS', '76')
        fcst_granalysis_p.add_variable('NTHREADS', '4')
        fcst_granalysis_p.add_variable('MEM', '60')
        fcst_granalysis_p.add_variable('NTASK', '38')

        fcst_granalysis_p = vis_family.find_task("jglmp_fcst_granalysis_p_ak")
        fcst_granalysis_p.delete_variable('NCPUS')
        fcst_granalysis_p.delete_variable('NTHREADS')
        fcst_granalysis_p.delete_variable('MEM')
        fcst_granalysis_p.delete_variable('NTASK')
        fcst_granalysis_p.add_variable('NCHUNKS', '2')
        fcst_granalysis_p.add_variable('NCPUS', '76')
        fcst_granalysis_p.add_variable('NTHREADS', '4')
        fcst_granalysis_p.add_variable('MEM', '60')
        fcst_granalysis_p.add_variable('NTASK', '38')

        fcst_granalysis_p = cig_family.find_task("jglmp_fcst_granalysis_p")
        fcst_granalysis_p.delete_variable('NCPUS')
        fcst_granalysis_p.delete_variable('NTHREADS')
        fcst_granalysis_p.delete_variable('MEM')
        fcst_granalysis_p.delete_variable('NTASK')
        fcst_granalysis_p.add_variable('NCHUNKS', '2')
        fcst_granalysis_p.add_variable('NCPUS', '76')
        fcst_granalysis_p.add_variable('NTHREADS', '4')
        fcst_granalysis_p.add_variable('MEM', '60')
        fcst_granalysis_p.add_variable('NTASK', '38')

        fcst_granalysis_p = cig_family.find_task("jglmp_fcst_granalysis_p_ak")
        fcst_granalysis_p.delete_variable('NCPUS')
        fcst_granalysis_p.delete_variable('NTHREADS')
        fcst_granalysis_p.delete_variable('MEM')
        fcst_granalysis_p.delete_variable('NTASK')
        fcst_granalysis_p.add_variable('NCHUNKS', '2')
        fcst_granalysis_p.add_variable('NCPUS', '76')
        fcst_granalysis_p.add_variable('NTHREADS', '4')
        fcst_granalysis_p.add_variable('MEM', '60')
        fcst_granalysis_p.add_variable('NTASK', '38')


        fcst_meld = vis_family.find_task("jglmp_fcst_meld")
        fcst_meld.delete_variable('NCPUS')
        fcst_meld.add_variable('NCPUS','38')
        fcst_meld.add_variable('MEM','60')
        fcst_meld = cig_family.find_task("jglmp_fcst_meld")
        fcst_meld.delete_variable('NCPUS')
        fcst_meld.add_variable('NCPUS','38')
        fcst_meld.add_variable('MEM','60')

        glmp_mos_prdgen = glmp_run_family.add_task("jglmp_mos_prep")
#        glmp_mos_prdgen.add_trigger("/{0}{1}/gfs/mos/prdgen/jgfsmos_ext_prdgen == complete".format(gfsmos_envir, zpad(mos_cycle)))

        tdp_family = glmp_run_family.add_family("tdp")
        wsg_family = glmp_run_family.add_family("wsg")

        obs_granalysis = tdp_family.add_task("jglmp_obs_granalysis")
        obs_granalysis.add_trigger("../jglmp_obs_prep == complete and ../jglmp_mos_prep == complete")
        obs_granalysis = wsg_family.add_task("jglmp_obs_granalysis")
        obs_granalysis.add_trigger("../jglmp_obs_prep == complete and ../jglmp_mos_prep == complete")

        obs_prdgen = tdp_family.add_task("jglmp_obs_prdgen")
        obs_prdgen.add_trigger("jglmp_obs_granalysis == complete")
        obs_prdgen = wsg_family.add_task("jglmp_obs_prdgen")
        obs_prdgen.add_trigger("jglmp_obs_granalysis == complete")

        if lmp_envir == "test":
          fcst_granalysis_trigger = "../../../../lmp{0}/{1}z/{2}/lmp_prdgen == complete and glmp_obs_granalysis == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
        else:
          fcst_granalysis_trigger = "../../../../../lmp/v2.4/{0}z/{1}/jlmp_prdgen == complete and jglmp_obs_granalysis == complete".format(zpad(hour), zpad(minute))

        fcst_granalysis = tdp_family.add_task("jglmp_fcst_granalysis")
        fcst_granalysis.add_trigger(fcst_granalysis_trigger)
        fcst_granalysis.add_variable('NCPUS', '22')
        fcst_granalysis = wsg_family.add_task("jglmp_fcst_granalysis")
        fcst_granalysis.add_trigger(fcst_granalysis_trigger)
        fcst_granalysis.add_variable('NCPUS', '22')

        fcst_prdgen = tdp_family.add_task("jglmp_fcst_prdgen")
        fcst_prdgen.add_trigger("jglmp_fcst_granalysis == complete")
        fcst_prdgen = wsg_family.add_task("jglmp_fcst_prdgen")
        fcst_prdgen.add_trigger("jglmp_fcst_granalysis == complete")

        glmp_prdgen_nomads = glmp_run_family.add_task("jglmp_prdgen_nomads")
        glmp_prdgen_nomads.add_trigger("vis/jglmp_meld_prdgen == complete and vis/jglmp_meld_prdgen_ak == complete and cig/jglmp_meld_prdgen == complete and cig/jglmp_meld_prdgen_ak == complete and sky/jglmp_fcst_prdgen == complete")

    # the run actually starts 4 minutes before the "run time"
    if minute == 0:
        glmp_run_family.add_time("{0}:{1}".format(zpad(previous_hour), "56"))
    else:
        glmp_run_family.add_time("{0}:{1}".format(zpad(hour), zpad(minute-4)))

    return glmp_run_family


defs = Defs()

if lmp_envir == "test":
    suite = defs.add_suite("test")
if lmp_envir != "test":
      suite = defs.add_suite("{0}".format(lmp_envir))
family_base = suite.add_family("primary")

for cycle in range(0, 24, 6):
    family_base2 = family_base.add_family("{0}".format(zpad(cycle)))

    lmp_family_base = family_base2.add_family("lmp" if lmp_envir != "test" else "lmp{0}".format(zpad(cycle)))
#    lmp_family = suite.add_family("lmp")
    lmp_family_base.add_variable('PROJ', 'LAMP')
    lmp_family_base.add_variable('PACKAGEHOME', '/lfs/h1/ops/%ENVIR%/packages/lmp.%lmp_ver%')
    
    lmp_family = lmp_family_base.add_family("{0}".format(lmp_ver))

    for hour in range(cycle, cycle+6):
        hourly_lmp_family = lmp_family.add_family("{0}z".format(zpad(hour)))
        hourly_lmp_family.add_variable('CYC', zpad(hour))
        for minute in range(0, 60, 15):
            minute_lmp_family = hourly_lmp_family.add_family(build_lmp_run(hour, minute))
            minute_lmp_family.add_variable('MIN', zpad(minute))

    glmp_family_base = family_base2.add_family("glmp" if lmp_envir != "test" else "glmp{0}".format(zpad(cycle)))
    glmp_family_base.add_variable('PROJ', 'LAMP')
    glmp_family_base.add_variable('PACKAGEHOME', '/lfs/h1/ops/%ENVIR%/packages/glmp.%glmp_ver%')

    glmp_family = glmp_family_base.add_family("{0}".format(glmp_ver))

    for hour in range(cycle, cycle+6):
        hourly_glmp_family = glmp_family.add_family("{0}z".format(zpad(hour)))
        hourly_glmp_family.add_variable('CYC', zpad(hour))
        for minute in range(0, 60, 15):
            minute_glmp_family = hourly_glmp_family.add_family(build_glmp_run(hour, minute))
            minute_glmp_family.add_variable('MIN', zpad(minute))

    defs.auto_add_externs(False)
#    defs.auto_add_externs(True)
    defs.save_as_defs("lmp_{0}{1}.def".format(lmp_envir, zpad(cycle)))

#try:
    #cli = Client()

#except RuntimeError, e:
#    print str(e)