hycom.py

"""This module will one day contain the implementation of the HyCOM
initialization and forecast jobs."""

import re, os, glob, datetime
import produtil.fileop, produtil.log
import hwrf.numerics
import hwrf.hwrftask, hwrf.coupling, hwrf.exceptions
from produtil.cd import NamedDir
from produtil.fileop import make_symlink
from produtil.datastore import FileProduct, COMPLETED, RUNNING, FAILED
from produtil.run import *
from produtil.log import jlogger
from hwrf.numerics import to_datetime,to_datetime_rel,TimeArray

def yesno(x):
    return 'YES' if x else 'NO'

def scriptexe(task,path):
    """Generates a produtil.prog.Runner for running a Hycom ksh
    script.  Adds a bunch of variables from config sections."""
    there=task.confstrinterp(path)
    e=exe(there)
    vars=dict()
    for k,v in task.conf.items(task.confstr('strings','hycomstrings')):
        vars[k]=str(v)
    for k,v in task.conf.items(task.confstr('bools','hycombools')):
        vars[k]=yesno(v)
    RTOFSDIR=task.meta('RTOFSDIR','')
    if RTOFSDIR:
        vars['RTOFSDIR']=RTOFSDIR
    return    e.env(**vars)

def read_RUNmodIDout(path):
    RUNmodIDout=''
    with open(path,'rt') as f:
        for line in f:
            m=re.match('^export RUNmodIDout=(.*)$',line)
            if m:
                RUNmodIDout=m.groups()[0]
    return RUNmodIDout

class HYCOMInit(hwrf.hwrftask.HWRFTask):
    def remove_ocean(): self.uncouple()

    def __init__(self,dstore,conf,section,taskname=None,fcstlen=126,
                 **kwargs):
        super(HYCOMInit,self).__init__(dstore,conf,section,
                                       taskname=taskname,**kwargs)
        self.forecast_exe=None
        self.step3_worked=False
        self.run_coupled=True
        self.fcstlen=fcstlen
        self.make_products()
    def make_products(self):
        """Initializes all Product objects to make them available to
        future jobs."""
        # Add the HyCOM-specific products whose delivery location is
        # in COM with the standard output file prefix
        # (invest99l.2017110318).
        logger=self.log()
        self.hycom_settings=FileProduct(
            self.dstore,'hycom_settings',self.taskname,location=
            self.confstrinterp('{com}/{out_prefix}.hycom_settings'))

        # prodnameA and prodnameB are three-hourly:
        fhrs=range(int(self.fcstlen+24.001))
        fhrs=fhrs[0::3]
        atime=to_datetime(self.conf.cycle)
        ftimes=[to_datetime_rel(t*3600,atime) for t in fhrs]
        self.init_file2a=TimeArray(atime,ftimes[-1],3*3600.0)
        self.init_file2b=TimeArray(atime,ftimes[-1],3*3600.0)
        for ftime in ftimes:
            prodnameA=self.timestr('hwrf_basin.{fahr:03d}.a',ftime,atime)
            filepathA=self.icstr('{com}/{out_prefix}.{pn}',pn=prodnameA)
            prodnameB=self.timestr('hwrf_basin.{fahr:03d}.b',ftime,atime)
            filepathB=self.icstr('{com}/{out_prefix}.{pn}',pn=prodnameB)
            self.init_file2a[ftime]=FileProduct(
                self.dstore,prodnameA,self.taskname,location=filepathA)
            self.init_file2b[ftime]=FileProduct(
                self.dstore,prodnameB,self.taskname,location=filepathB)

        # The optional_file is only created if init_script3 succeeds:
        #    self.optional_file=FileProduct(
        #        self.dstore,'optional_file',self.taskname,location=
        #        self.confstrinterp('{com}/{out_prefix}.optional_file'))

        # initial conditions:
        self.restart_out=dict()
        for ab in 'ab':
            for what in ('restart_out','restart_outR'):
                local=what+'.'+ab # like restart_out.a or restart_outR.b
                self.restart_out[local]=FileProduct(self.dstore,local,self.taskname)

        self.spin_archv_a=FileProduct(self.dstore,'spin_archv_a',self.taskname)
        self.spin_archv_b=FileProduct(self.dstore,'spin_archv_b',self.taskname)

        # forcing files for coupled run
        self.forcing_products=dict()
        ffiles=['airtmp','precip','presur','radflx','shwflx','surtmp',
                'tauewd','taunwd','vapmix','wndspd']
        for ffile in ffiles:
            for ab in 'ab':
                file='forcing.%s.%s'%(ffile,ab)
                comf=self.confstrinterp('{com}/{out_prefix}.'+file)
                prod=FileProduct(self.dstore,file,self.taskname,location=comf)
                prod.location=comf
                self.forcing_products[file]=prod
                logger.debug('%s => %s (%s)'%(file,comf,repr(prod))) 

        self.limits=FileProduct(
            self.dstore,'limits',self.taskname,location=
            self.confstrinterp('{com}/{out_prefix}.limits'))

        self.blkdat_input=FileProduct(
            self.dstore,'blkdat.input',self.taskname,location=
            self.confstrinterp('{com}/{out_prefix}.standalone.blkdat.input'))

    def fill_ocstatus(self,ocstatus,logger):
        """Fills the ocean status files with information.  This is
        called from exhwrf_ocean_init after a successful call to the
        run() function below.  The ocstatus argument is the
        hwrf.coupling.OceanStatus object that fills the files."""
        # First argument: True=run coupled, False=don't
        # Second argument: the logger argument sent to this function
        # Third argument: a list of extra lines to dump into fill_ocstatus
        ocstatus.set(self.run_coupled,logger,[
                'forecast_exe=%s'%self.forecast_exe,
                'step3_worked='+('YES' if self.step3_worked else 'NO'),   ])
    def recall_ocstatus(self,ocstatus,logger):
        """Reads the ocean status back in during the forecast and
        check_init jobs, filling the self.run_coupled,
        self.forecast_exe and self.step3_worked variables."""
        # Get the name of the first ocstatus file for error reporting:
        for filename in ocstatus.fileiter():
            break

        # Read the lins of the ocstatus file:
        lines=ocstatus.read(logger)
        for line in lines:
            # See if any lines are KEY=VALUE lines, and split them into parts
            m=re.match('^ *([^ =]+) *= *(.*?) *$',line)
            if not m:
                logger.warning('%s: unparseable ocstatus line: %s'
                               %(filename,line))
                continue
            (key,value)=m.groups()
            value=value.strip()
            key=key.strip()

            # See if any recognized key=value lines are present:
            if key=='RUN_COUPLED':
                if value=='YES':     self.run_coupled=True
                elif value=='NO':    self.run_coupled=False
                else:
                    logger.warning('%s: ignoring unrecognized RUN_COUPLED value %s'%(
                            filename,repr(value)))
            elif key=='forecast_exe': self.forecast_exe=value
            elif key=='step3_worked': self.step3_worked=value=='YES'
            else:
                logger.warning('%s: ignoring unkown key %s'%(filename,key))

    def find_rtofs_data(self):
        """!Fills the RTOFS staging area with RTOFS data."""

        logger=self.log()
        cyc=self.conf.cycle

        rtofs_atime=datetime.datetime(cyc.year,cyc.month,cyc.day,0)
        rtofs_ymd=rtofs_atime.strftime('%Y%m%d')

        # Input directories:
        tardir=self.confstr('RTOFS_TAR','/dev/null')
        histdir=self.confstr('RTOFS_HIST','/dev/null')
        fcstdir=self.confstr('RTOFS_FCST','/dev/null')

        # Decide the staging directory:
        outdir=self.confstr('RTOFS_STAGE','')
        if not outdir:
            outdir=os.path.join(self.workdir,
                                rtofs_atime.strftime('rtofs.%Y%m%d'))

        # Get data:
        ni=hwrf.namelist.NamelistInserter(self.conf,self.section)
        with NamedDir(outdir,keep=True,logger=logger,rm_first=False) as d:
            parmin=self.confstrinterp('{PARMhwrf}/hwrf_get_rtofs.nml.in')
            parmout='get_rtofs.nml'
            with open(parmin,'rt') as inf:
                with open(parmout,'wt') as outf:
                    outf.write(ni.parse(inf,logger,parmin,atime=rtofs_atime))
            checkrun(mpirun(mpi(self.getexe('hwrf_get_rtofs')),allranks=True),
                     logger=logger)

    def run(self):
        """Runs the hycom initialization.  Raises an exception if
        something goes wrong.  Returns on success."""
        logger=self.log()
        # Reset coupling status information:
        self.step3_worked=False
        self.forecast_exe=None
        self.run_coupled=False
        try:
            self.state=RUNNING
            # Inside the "with" block, we create and cd to the work
            # directory and then cd back out at the end.  The
            # "rm_first=True" means the directory is deleted first if
            # it already exists upon entry of the "with" block.
            with NamedDir(self.workdir,keep=not self.scrub,
                          logger=logger,rm_first=True) as d:
                # Run first init script and raise an exception if it fails:
                checkrun(scriptexe(self,'{USHhwrf}/hycom/select_domain.sh'),
                         logger=logger)
                self.hycom_settings.deliver(frominfo='./hycom_settings')

                self.find_rtofs_data()

                # Run second init script and raise an exception if it fails:
                checkrun(scriptexe(self,'{USHhwrf}/hycom/create_bc_ic.sh'),
                         logger=logger)

                # Find the executable chosen by select_domain.sh
                RUNmodIDout=read_RUNmodIDout('./hycom_settings')
                self.forecast_exe=self.icstr('{forecast_exe}',
                                             RUNmodIDout=RUNmodIDout)

                # Run the standalone:
                checkrun(mpirun(mpi(self.forecast_exe)*90),logger=self.log())

                # Deliver BC A files:
                for (ftime,prod) in self.init_file2a.iteritems():
                    fromloc=prod.prodname # delivery source
                    prod.deliver(frominfo=fromloc,keep=True,logger=logger)

                # Deliver BC B files:
                for (ftime,prod) in self.init_file2b.iteritems():
                    fromloc=prod.prodname # delivery source
                    prod.deliver(frominfo=fromloc,keep=True,logger=logger)

                # Deliver restart files
                for(prodname,prod) in self.restart_out.iteritems():
                    (local,ab)=prodname.split('.')
                    loc=self.icstr('{'+local+'}',ab=ab,RUNmodIDout=RUNmodIDout)
                    prod.deliver(location=loc,frominfo=prodname,
                                 keep=True,logger=logger)

                # Deliver last standalone archv A and B files:
                notab=self.conf.cycle.strftime('archv.%Y_%j_%H.')
                for ab in 'ab':
                    loc=self.icstr('{spin_archv}',ab=ab,RUNmodIDout=RUNmodIDout)
                    self.spin_archv_a.deliver(
                        frominfo=notab+ab,location=loc,keep=True,
                        logger=logger)

                # Run third init script and raise an exception if it fails:
                checkrun(scriptexe(self,'{USHhwrf}/hycom/init_step3.sh'),
                         logger=logger)

                # Deliver the forcing files: 
                for (name,prod) in self.forcing_products.iteritems():
                    prod.deliver(frominfo='./'+name)

                self.limits.deliver(frominfo='./limits')

                self.blkdat_input.deliver(frominfo='./blkdat.input')

                # Make sure we run coupled:
                self.run_coupled=True
            self.state=COMPLETED
        except Exception as e:
            logger.error('Unhandled exception in ocean init: %s'
                         %(str(e),),exc_info=True)
            self.state=FAILED
            raise
        except:  # fatal signal, other catastrophic errors
            self.state=FAILED
            raise

class HYCOMIniter(hwrf.coupling.ComponentIniter):
    def __init__(self,hycomfcst,ocstatus):
        self.hycomfcst=hycomfcst
        self.ocstatus=ocstatus
    @property
    def hycominit(self):
        return self.hycomfcst.hycominit
    def check_coupled_inputs(self,logger):
        """This subroutine is run by the check_init job and checks to
        see if the initialization has succeeded.  It returns True if
        the inputs are all present, and False if they're not."""
        hf=self.hycomfcst
        hi=hf.hycominit
        hi.recall_ocstatus(self.ocstatus,logger)
        if not hi.run_coupled:
            logger.warning('Hycom init says we will not run coupled.')
            return True
        # We get here if we run coupled.  The HYCOMInit.run() function
        # always makes the init_file1 and init_file2 products:
        prods=list()

        # Check A files:
        for (ftime,prod) in hi.init_file2a.iteritems():
            prods.append(prod)
        # Check B files
        for (ftime,prod) in hi.init_file2b.iteritems():
            prods.append(prod)
        # Check restart files
        # add restart files
        # Check forcing files
        # add forcing files

        #if hi.step3_worked:
        #    prods.append(hi.optional_file)
        #else:
        #    logger.info('init_step3 did not work, so skipping optional_file')
        count=0
        for prod in prods:
            if not prod.available:
                logger.error('%s: product not available'%(prod.did,))
            elif not prod.location:
                logger.error('%s: no path set in database'%(prod.did,))
            elif not os.path.exists(prod.location):
                logger.error('%s: %s: file does not exist'%(
                        prod.did,prod.location))
            else:
                logger.info('%s: %s: product is delivered'%(
                        prod.did,prod.location))
                count+=1
        if count<len(prods):
            logger.error('Have only %d of %d products.  Ocean init failed.'%(
                    count,len(prods)))
            return False
        else:
            logger.info('Rejoice: we have all coupled inputs')
            return True
    def link_coupled_inputs(self,just_check,logger):
        """Called from the forecast job.  If just_check=True, this
        calls check_coupled_inputs.  Otherwise, this links all hycom
        inputs to the local directory."""
        if just_check:
            return self.check_coupled_inputs(logger)
        hi=self.hycomfcst.hycominit
        hi.recall_ocstatus(self.ocstatus,logger)
        if not hi.run_coupled:
            logger.warning('Hycom init says we will not run coupled.')
            return True

        # List of product object to link/copy:
        prods=list()

        # A files:
        for (ftime,prod) in hi.init_file2a.iteritems():
            prods.append(prod)
        # B files
        for (ftime,prod) in hi.init_file2b.iteritems():
            prods.append(prod)

        # Make the subdirectories
        if not just_check:
            produtil.fileop.makedirs('nest',logger=logger)
            produtil.fileop.makedirs('incup',logger=logger)

        # Now link the inputs:
        cycle=self.hycominit.conf.cycle
        for prod in prods:
            if not prod.available or not prod.location or \
                    not os.path.exists(prod.location):
                msg='%s: input not present (location=%s available=%s)'\
                    %(prod.did, repr(prod.location), repr(prod.available))
                logger.error(msg)
                raise hwrf.exceptions.OceanInitFailed(msg)
            m=re.match('hwrf_basin.0*(\d+).([ab])',prod.prodname)
            if not m:
                make_symlink(prod.location,prod.prodname,
                             logger=logger,force=True)
            else:
                (hr,ab)=m.groups()
                hr=int(hr)
                logger.info('Link hour %s relative to cycle %s.'%(repr(hr),repr(cycle)))
                t=hwrf.numerics.to_datetime_rel(hr*3600,cycle)
                name1=t.strftime('nest/archv.%Y_%j_%H.')+ab
                name2=t.strftime('incup/incupd.%Y_%j_%H.')+ab
                for name in ( name1, name2 ):
                    make_symlink(prod.location,name,
                                 logger=logger,force=True)

        # DAN link restart file (bill02l.2015061600.rtofs_hat10.restart.[ab])
        op=hi.icstr('{out_prefix}.')
        nop=len(op)
        assert(nop>5)
        for part in [ 'rtofs','limits','forcing' ]:
            globby=hi.icstr('{com}/{out_prefix}.{part}*',part=part)
            nfound=0
            # Path will be something like:
            # /path/to/com/2015061600/02L/bill02l.2015061600.rtofs_hat10.restart.a
            # ipref is index of the "." after 2015061600
            # localname is rtofs_hat10.restart.a
            # finalname is hat10.restart_in.a
            for path in glob.glob(globby):
                nfound+=1
                ipref=path.rfind(op)
                localname=path[ipref+nop:]
                # Rename restart files:
                finalname=re.sub('.*\.restart\.([^/]*)','restart_in.\\1',localname)
                make_symlink(path,finalname,force=True,logger=logger)
            logger.info('%s: %d files linked\n',globby,nfound)
            assert(nfound>0)
    
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.rtofs_hat10.restart.a','restart_in.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.rtofs_hat10.restart.b','restart_in.b',force=True,logger=logger)

        # # DAN link in limits file (bill02l.2015061600.rtofs_hat10.limits)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.limits','limits',force=True,logger=logger)

        # # DAN link in forcing files
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.airtmp.a','forcing.airtmp.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.airtmp.b','forcing.airtmp.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.precip.a','forcing.precip.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.precip.b','forcing.precip.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.presur.a','forcing.presur.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.presur.b','forcing.presur.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.radflx.a','forcing.radflx.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.radflx.b','forcing.radflx.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.shwflx.a','forcing.shwflx.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.shwflx.b','forcing.shwflx.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.surtmp.a','forcing.surtmp.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.surtmp.b','forcing.surtmp.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.tauewd.a','forcing.tauewd.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.tauewd.b','forcing.tauewd.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.taunwd.a','forcing.taunwd.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.taunwd.b','forcing.taunwd.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.vapmix.a','forcing.vapmix.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.vapmix.b','forcing.vapmix.b',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.wndspd.a','forcing.wndspd.a',force=True,logger=logger)
        # make_symlink('/pan2/projects/hwrfv3/Dan.Iredell/pytmp/HyHWRF-2015/com/2015061600/02L/bill02l.2015061600.forcing.wndspd.b','forcing.wndspd.b',force=True,logger=logger)

        if not just_check:
            hsprod=self.hycominit.hycom_settings
            assert(hsprod is not None)
            assert(hsprod.available)
            assert(hsprod.location)
            RUNmodIDout=read_RUNmodIDout(hsprod.location)
            self.link_hycom_fix(RUNmodIDout)
            self.link_hycom_parm(RUNmodIDout)
        return True

    def link_hycom_parm(self,RUNmodIDout):
        logger=self.hycominit.log()
        mine={ 'fcst.blkdat.input':'blkdat.input',
               'patch.input.90':'patch.input',
               'ports.input':'ports.input' }
        for (parmbase,localname) in mine.iteritems():
            parmfile=self.hycominit.icstr(
                '{PARMhwrf}/hwrf_{RUNmodIDout}.basin.{PARMBASE}',
                RUNmodIDout=RUNmodIDout,PARMBASE=parmbase)
            produtil.fileop.make_symlink(parmfile,localname,logger=logger,force=True)

    def link_hycom_fix(self,RUNmodIDout):
        assert(RUNmodIDout)
        logger=self.hycominit.log()
        globby=self.hycominit.icstr('{FIXhycom}/hwrf_{RUNmodIDout}.basin.*',
                          RUNmodIDout=RUNmodIDout)
        forcewanted=set(['chl.a','chl.b','kpar.a','kpar.b','offlux.a','offlux.b','rivers.a','rivers.b'])
        n=0
        nlinked=0
        for path in glob.glob(globby):
            basename=os.path.basename(path)
            fd=basename.find('forcing')
            linked=False
            n+=1
            if fd<0:
                bd=basename.find('basin.')
                if bd>0:
                    produtil.fileop.make_symlink(path,basename[(bd+6):],logger=logger,force=True)
                    linked=True
            else:
                forcetype=basename[(fd+8):]
                if forcetype in forcewanted:
                    produtil.fileop.make_symlink(path,'forcing.'+forcetype,logger=logger,force=True)
                    linked=True
            if not linked:
                logger.info('%s: not linking %s'%(basename,path))
            else:
                nlinked+=1
        logger.info('Linked %d of %d HyCOM fix files for RUNmodIDout=%s'%(
                    nlinked,n,repr(RUNmodIDout)))
        produtil.fileop.make_symlink('../relax.rmu.a','nest/rmu.a',logger=logger,force=True)
        produtil.fileop.make_symlink('../relax.rmu.b','nest/rmu.b',logger=logger,force=True)

    def make_exe(self,task,exe,ranks):
        """Returns an MPIRanksBase to run the executable chosen by the
        initialization.  This function must only be called after
        link_coupled_inputs"""
        if not isinstance(ranks,int):
            raise TypeError('The ranks argument to make_exe must be an int.  You provided a %s %s'%(type(ranks).__name__,repr(ranks)))
        wantexe=task.hycominit.forecast_exe
        if not wantexe:
            raise hwrf.exceptions.OceanExeUnspecified(
                'The forecast_exe option was not specified in the '
                'ocean status file.')
        return mpi(wantexe)*ranks

class WRFCoupledHYCOM(hwrf.coupling.CoupledWRF):
    """This subclass of CoupledWRF runs the HyCOM-coupled WRF."""
    def __init__(self,dstore,conf,section,wrf,ocstatus,keeprun=True,
                 wrfdiag_stream='auxhist1',hycominit=None,**kwargs):
        if not isinstance(hycominit,HYCOMInit):
            raise TypeError(
                'The hycominit argument to WRFCoupledHYCOM.__init__ must be a '
                'HYCOMInit object.  You passed a %s %s.'%
                (type(hycominit).__name__,repr(hycominit)))
        super(WRFCoupledHYCOM,self).__init__(dstore,conf,section,wrf,keeprun,
                                           wrfdiag_stream,**kwargs)
        self._hycominit=hycominit
        hycominiter=HYCOMIniter(self,ocstatus)

        self.couple('coupler','hwrf_wm3c','wm3c_ranks',1)
        self.couple('hycom','hycom','ocean_ranks',90,hycominiter)
        self.couple('wrf','wrf','wrf_ranks')

    @property
    def hycominit(self):
        """Returns the HYCOMInit object."""
        return self._hycominit

class HYCOMPost(hwrf.hwrftask.HWRFTask):
    """Runs the ocean post-processor on the HyCOM output, in parallel
    with the model."""
    def __init__(self,ds,conf,section,fcstlen,hycom,**kwargs):
        super(HYCOMPost,self).__init__(ds,conf,section,**kwargs)
        self.fcstlen=fcstlen
        self.hycom=hycom # the WRFCoupledHYCOM object
    def run(self):
        """Called from the ocean post job to run the HyCOM post."""
        logger=self.log()
        self.state=RUNNING
        try:
            checkrun(scriptexe(self,'{USHhwrf}/hycom/ocean_post.sh'),
                     logger=logger)
            self.state=COMPLETED
        except Exception as e:
            self.state=FAILED
            logger.error("Ocean post failed: %s"%(str(e),),exc_info=True)
            raise
    def unrun(self):
        """Called from the unpost job to delete the HyCOM post output
        in preparation for a rerun of the entire post-processing for
        the cycle."""
        logger=self.log()
        self.state=RUNNING
        try:
            checkrun(scriptexe(self,'{USHhwrf}/hycom/ocean_unpost.sh'),
                     logger=logger)
            self.state=COMPLETED
        except Exception as e:
            self.state=FAILED
            logger.error("Ocean post failed: %s"%(str(e),),exc_info=True)
            raise