Beispiel #1
0
 def test_patch_case(self):
     patch_nml = f90nml.read('types_patch.nml')
     f90nml.patch('types_uppercase.nml', patch_nml, 'tmp.nml')
     test_nml = f90nml.read('tmp.nml')
     try:
         self.assertEqual(test_nml, patch_nml)
     finally:
         os.remove('tmp.nml')
Beispiel #2
0
 def test_default_patch(self):
     patch_nml = f90nml.read("types_patch.nml")
     f90nml.patch("types.nml", patch_nml)
     test_nml = f90nml.read("types.nml~")
     try:
         self.assertEqual(test_nml, patch_nml)
     finally:
         os.remove("types.nml~")
def calc_species_param(species_list,species_filename,norm_filename):
    norm_file = f90nml.read(norm_filename)
    eBar = norm_file["normalizationParameters"]["eBar"]
    mBar = norm_file["normalizationParameters"]["mBar"]
    
    species_file = f90nml.read(species_filename)
    Z=numpy.array([species_file["speciesCharge"][x] for x in species_list])/eBar
    mHat=numpy.array([species_file["speciesMass"][x] for x in species_list])/mBar
    return [Z,mHat]
Beispiel #4
0
  def prepare_wrfda_namelist(self, domain):
    # set domain specific workdir
    wrfda_workdir = os.path.join(self.wrfda_workdir, "d0" + str(domain))
    # read WRFDA namelist
    wrfda_namelist = os.path.join(self.config['filesystem']['wrfda_dir'],
                                  'var/test/tutorial/namelist.input')
    wrfda_nml = f90nml.read(wrfda_namelist)

    # read WRF namelist in WRF work_dir
    wrf_nml = f90nml.read(os.path.join(self.config['filesystem']['wrf_run_dir'],
                                       'namelist.input'))
    ## silent remove file if exists
    ##utils.silentremove(os.path.join(wrfda_workdir, 'fg'))
    ## create symlink of wrfinput_d0${domain}
    ##os.symlink(os.path.join(self.rundir, 'wrfinput_d0' + str(domain)),
    ##          os.path.join(wrfda_workdir, 'fg'))
    # set domain specific information in namelist
    for var in ['e_we', 'e_sn', 'e_vert', 'dx', 'dy']:
      # get variable from ${RUNDIR}/namelist.input
      var_value = wrf_nml['domains'][var]
      # set domain specific variable in WRDFA_WORKDIR/namelist.input
      wrfda_nml['domains'][var] = var_value[domain - 1]
    for var in ['mp_physics', 'ra_lw_physics', 'ra_sw_physics', 'radt',
                'sf_sfclay_physics', 'sf_surface_physics', 'bl_pbl_physics',
                'cu_physics', 'cudt', 'num_soil_layers']:
      # get variable from ${RUNDIR}/namelist.input
      var_value = wrf_nml['physics'][var]
      # set domain specific variable in WRDFA_WORKDIR/namelist.input
      try:
        wrfda_nml['physics'][var] = var_value[domain - 1]
      except TypeError:
        wrfda_nml['physics'][var] = var_value
    obsproc_nml = f90nml.read(os.path.join(self.obs[domain][0], 'namelist.obsproc'))
    # sync wrfda namelist with obsproc namelist
    wrfda_nml['wrfvar18']['analysis_date'] = obsproc_nml['record2']['time_analysis']
    wrfda_nml['wrfvar21']['time_window_min'] = obsproc_nml['record2']['time_window_min']
    wrfda_nml['wrfvar22']['time_window_max'] = obsproc_nml['record2']['time_window_max']
    if check_cv5():
      wrfda_nml['wrfvar7']['cv_options'] =  5
      wrfda_nml['wrfvar6']['max_ext_its'] = 2
      wrfda_nml['wrfvar5']['check_max_iv'] = True
    else:
      wrfda_nml['wrfvar7']['cv_options'] =  3
    tana = utils.return_validate(obsproc_nml['record2']['time_analysis'][:-6])
    wrfda_nml['time_control']['start_year'] = tana.year
    wrfda_nml['time_control']['start_month'] = tana.month
    wrfda_nml['time_control']['start_day'] = tana.day
    wrfda_nml['time_control']['start_hour'] = tana.hour
    wrfda_nml['time_control']['end_year'] = tana.year
    wrfda_nml['time_control']['end_month'] = tana.month
    wrfda_nml['time_control']['end_day'] = tana.day
    wrfda_nml['time_control']['end_hour'] = tana.hour
    # save changes to wrfda_nml
    utils.silentremove(os.path.join(wrfda_workdir, 'namelist.input'))
    wrfda_nml.write(os.path.join(wrfda_workdir, 'namelist.input'))
Beispiel #5
0
    def test_default_patch(self):
        patch_nml = f90nml.read('types_patch.nml')
        f90nml.patch('types.nml', patch_nml)
        test_nml = f90nml.read('types.nml~')
        try:
            self.assertEqual(test_nml, patch_nml)
        finally:
            os.remove('types.nml~')

        # The above behavior is only for paths, not files
        with open('types.nml') as nml_file:
            self.assertRaises(ValueError, f90nml.patch, nml_file, patch_nml)
Beispiel #6
0
 def test_patch_files(self):
     patch_nml = f90nml.read('types_patch.nml')
     with open('types.nml') as f_in:
         with open('tmp.nml', 'w') as f_out:
             f90nml.patch(f_in, patch_nml, f_out)
             self.assertFalse(f_in.closed)
             self.assertFalse(f_out.closed)
     try:
         test_nml = f90nml.read('tmp.nml')
         self.assertEqual(test_nml, patch_nml)
     finally:
         os.remove('tmp.nml')
Beispiel #7
0
def read_pars(parpath):

    par_key="parameter"
    name_key="name"
    unit_key="units"
    long_name_key="long_name"
    out_name_key="out_name"

    result=[]

    parf=f90nml.read(parpath)
    pars=parf[par_key]
    for p in pars:
        name=p.get(name_key,None)
        if(not name):
            print "ERROR: cannot read parameter without valid name from par-table"
            continue
        oname=p.get(out_name_key,None)
        if(not oname):
            print "ERROR: cannot read parameter",name,"without valid output name from par-table"
            continue
        lname=p.get(long_name_key,None)
        unit=p.get(unit_key,None)
        item=nemo_par(name)
        item.long_name=lname
        item.out_name=oname
        item.unit=unit
        result.append(item)

    print "parsing parameter table ",parpath
    print "done, read",len(result),"entries"
    return result
Beispiel #8
0
  def get_obsproc_dirs(self):
    '''
    get list of observation names and workdirs for obsproc
		'''
    # read WRF namelist in WRF work_dir
    wrf_nml = f90nml.read(os.path.join(self.config['filesystem']['wrf_run_dir'],
                                       'namelist.input'))
		# initialize variables
    obsnames, obsproc_workdirs = [], []
		# 
    for dom in range(1, self.max_dom + 1):
      try:
        obsname = self.config['filesystem']['obs_filename_d' + str(dom)]
        obsnames.append(obsname)
        obsproc_workdirs.append(os.path.join(
                                self.config['filesystem']['work_dir'],
                                'obsproc', obsname))
      except KeyError:
        obsname = self.config['filesystem']['obs_filename']
        obsnames.append(obsname)
        obsproc_workdirs.append(os.path.join(
                                self.config['filesystem']['work_dir'],
                                'obsproc', obsname))
    # merge everything into a dict
    # domain: (workdir, obsname)
    obs = dict(zip(range(1, self.max_dom + 1), zip(obsproc_workdirs, obsnames)))
    return obs
    def test_bit_repro_repeat(self):
        """
        Test that a run reproduces saved checksums.
        """

        exp_bit_repo1 = setup_exp_from_base('1deg_jra55_iaf', '1deg_jra55_iaf_bit_repo1')
        exp_bit_repo2 = setup_exp_from_base('1deg_jra55_iaf', '1deg_jra55_iaf_bit_repo2')

        # Reconfigure to a 1 day and do run
        for exp in [exp_bit_repo1, exp_bit_repo2]:
            with open(exp.accessom2_config) as f:
                nml = f90nml.read(f)

            nml['date_manager_nml']['restart_period'] = [0, 0, 86400]
            nml.write(exp.accessom2_config, force=True)
            exp.build_and_run()

        # Compare expected to produced.
        assert os.path.exists(exp_bit_repo1.accessom2_out_000)
        expected = self.checksums_to_list(exp_bit_repo1.accessom2_out_000)
        expected.sort()

        assert os.path.exists(exp_bit_repo2.accessom2_out_000)
        produced = self.checksums_to_list(exp_bit_repo2.accessom2_out_000)
        produced.sort()

        if produced != expected:
            with open('checksums-produced-test_bit_repo.txt', 'w') as f:
                f.write('\n'.join(produced))
            with open('checksums-expected-test_bit_repo.txt', 'w') as f:
                f.write('\n'.join(expected))

        assert len(produced) > 0
        assert len(produced) == len(expected)
        assert produced == expected
Beispiel #10
0
    def extract_input_file(self):
        """
        Extract the GS2 input file from the NetCDF file to the run dir..
        """

        # Taken from extract_input_file in the GS2 scripts folder:
        #1: Get the input_file variable from the netcdf file
        #2: Only print lines between '${VAR} = "' and '" ;'
        # (i.e. ignore header and footer)
        #3: Convert \\n to new lines
        #4: Delete empty lines
        #5: Ignore first line
        #6: Ignore last line
        #7: Fix " style quotes
        #8: Fix ' style quotes
        bash_extract_input = (""" ncdump -v input_file ${FILE} | """ +
                          """ sed -n '/input_file = /,/" ;/p' | """ +
                          """ sed 's|\\\\\\\\n|\\n|g' | """ +
                          """ sed '/^ *$/d' | """ +
                          """ tail -n+2 | """ +
                          """ head -n-2 | """ +
                          """ sed 's|\\\\\\"|\\"|g' | """ +
                          """ sed "s|\\\\\\'|\\'|g" """)
        os.system('FILE=' + self.cdf_file + '; ' +
                  bash_extract_input + ' > ' +
                  self.run_dir + 'input_file.in')
        self.gs2_in = nml.read(self.run_dir + 'input_file.in')
Beispiel #11
0
    def set_model_pathnames(self):
        super(Cice, self).set_model_pathnames()

        self.build_exec_path = os.path.join(self.codebase_path,
                                            'build_access-om_360x300_6p')

        ice_nml_path = os.path.join(self.control_path, self.ice_nml_fname)
        self.ice_in = f90nml.read(ice_nml_path)

        # Assume local paths are relative to the work path
        setup_nml = self.ice_in['setup_nml']

        res_path = os.path.normpath(setup_nml['restart_dir'])
        if not os.path.isabs(res_path):
            res_path = os.path.join(self.work_path, res_path)
        self.work_init_path = res_path
        self.work_restart_path = res_path

        work_out_path = os.path.normpath(setup_nml['history_dir'])
        if not os.path.isabs(work_out_path):
            work_out_path = os.path.join(self.work_path, work_out_path)
        self.work_output_path = work_out_path

        # Determine if there is a work input path
        grid_nml = self.ice_in['grid_nml']
        input_path, _ = os.path.split(grid_nml['grid_file'])
        if input_path and not input_path == '.':
            assert not os.path.isabs(input_path)
            self.work_input_path = os.path.join(self.work_path, input_path)

        # Assert that kmt uses the same directory
        kmt_input_path, _ = os.path.split(grid_nml['kmt_file'])
        assert input_path == kmt_input_path
    def test_bit_repro_historical(self):
        """
        Test that a run reproduces saved checksums.
        """

        exp_bit_repo = setup_exp_from_base('1deg_jra55_iaf', '1deg_jra55_iaf_bit_repo')

        # Reconfigure to a 1 day and do run
        with open(exp_bit_repo.accessom2_config) as f:
            nml = f90nml.read(f)

        nml['date_manager_nml']['restart_period'] = [0, 0, 86400]
        nml.write(exp_bit_repo.accessom2_config, force=True)
        exp_bit_repo.build_and_run()

        assert os.path.exists(exp_bit_repo.accessom2_out_000)
        produced = self.checksums_to_list(exp_bit_repo.accessom2_out_000)

        # Compare expected to produced.
        test_stdout = os.path.join(exp_bit_repo.exp_path, 'test', 'access-om2.out')
        assert os.path.exists(test_stdout)
        expected = self.checksums_to_list(test_stdout)

        assert len(produced) > 0
        for line in produced:
            if line not in expected:
                with open('checksums-produced-test_bit_repo.txt', 'w') as f:
                    f.write('\n'.join(produced))
                with open('checksums-expected-test_bit_repo.txt', 'w') as f:
                    f.write('\n'.join(expected))
Beispiel #13
0
 def test_repatch(self):
     f90nml.patch('repatch.nml', self.repatch_nml, 'tmp.nml')
     test_nml = f90nml.read('tmp.nml')
     try:
         self.assertEqual(test_nml, self.repatch_nml)
     finally:
         os.remove('tmp.nml')
Beispiel #14
0
    def test_colwidth(self):
        test_nml = f90nml.read("multiline.nml")
        test_nml.colwidth = 40
        self.assert_write(test_nml, "multiline_colwidth.nml")

        self.assertRaises(ValueError, setattr, test_nml, "colwidth", -1)
        self.assertRaises(TypeError, setattr, test_nml, "colwidth", "xyz")
Beispiel #15
0
 def prepare_symlink_files(self, domain):
   '''
   prepare WRFDA directory
   '''
   # set domain specific workdir
   wrfda_workdir = os.path.join(self.wrfda_workdir, "d0" + str(domain))
   # read obsproc namelist
   obsproc_nml = f90nml.read(os.path.join(self.obs[domain][0],
                                          'namelist.obsproc'))
   # symlink da_wrfvar.exe, LANDUSE.TBL, be.dat.cv3
   os.symlink(os.path.join(
     self.config['filesystem']['wrfda_dir'],'var/da/da_wrfvar.exe'
     ), os.path.join(wrfda_workdir, 'da_wrfvar.exe'))
   if self.check_cv5():
     # cv5:
     os.symlink(self.config['options_wrfda']['be.dat_d0' + str(domain)],
                os.path.join(wrfda_workdir, 'be.dat'))
   else:
     # cv3
     os.symlink(os.path.join(
       self.config['filesystem']['wrfda_dir'],'var/run/be.dat.cv3'
       ), os.path.join(wrfda_workdir, 'be.dat'))
   os.symlink(os.path.join(
     self.config['filesystem']['wrfda_dir'],'run/LANDUSE.TBL'
     ), os.path.join(wrfda_workdir, 'LANDUSE.TBL'))
   # symlink output of obsproc
   os.symlink(os.path.join(self.obs[domain][0],
              'obs_gts_' + obsproc_nml['record2']['time_analysis'] + '.3DVAR',
             ), os.path.join(wrfda_workdir, 'ob.ascii'))
Beispiel #16
0
    def test_column_width(self):
        test_nml = f90nml.read('multiline.nml')
        test_nml.column_width = 40
        self.assert_write(test_nml, 'multiline_colwidth.nml')

        self.assertRaises(ValueError, setattr, test_nml, 'column_width', -1)
        self.assertRaises(TypeError, setattr, test_nml, 'column_width', 'xyz')
Beispiel #17
0
    def setup(self):
        # FMS initialisation
        super(Mom, self).setup()

        input_nml_path = os.path.join(self.work_path, 'input.nml')
        input_nml = f90nml.read(input_nml_path)

        use_core2iaf = self.config.get('core2iaf')
        if use_core2iaf:
            self.core2iaf_setup()

        # Set the runtime
        if self.expt.runtime:
            ocean_solo_nml = input_nml['ocean_solo_nml']

            ocean_solo_nml['years'] = self.expt.runtime['years']
            ocean_solo_nml['months'] = self.expt.runtime['months']
            ocean_solo_nml['days'] = self.expt.runtime['days']
            ocean_solo_nml['seconds'] = self.expt.runtime.get('seconds', 0)

            input_nml.write(input_nml_path, force=True)

        # Construct the land CPU mask
        if self.expt.config.get('mask_table', False):
            self.create_mask_table(input_nml)
Beispiel #18
0
 def _prepare_namelist(self, datestart, dateend):
   '''
   prepare wps namelist
   '''
   # read WPS namelist in WPS work_dir
   wps_nml = f90nml.read(self.config['options_wps']['namelist.wps'])
   # get numer of domains
   ndoms = wps_nml['share']['max_dom']
   # check if ndoms is an integer and >0
   if not (isinstance(ndoms, int) and ndoms>0):
     raise ValueError("'domains_max_dom' namelist variable should be an " \
                     "integer>0")
   # check if both datestart and dateend are a datetime instance
   if not all([ isinstance(dt, datetime) for dt in [datestart, dateend] ]):
     raise TypeError("datestart and dateend must be an instance of datetime")
   # set new datestart and dateend
   wps_nml['share']['start_date'] = [datetime.strftime(datestart,
                                                         '%Y-%m-%d_%H:%M:%S')] * ndoms
   wps_nml['share']['end_date'] = [datetime.strftime(dateend,
                                                       '%Y-%m-%d_%H:%M:%S')] * ndoms
   # write namelist in wps work_dir
   utils.silentremove(os.path.join(
     self.config['filesystem']['work_dir'], 'wps', 'namelist.wps'))
   wps_nml.write(os.path.join(
     self.config['filesystem']['work_dir'], 'wps', 'namelist.wps'))
Beispiel #19
0
 def read_namelist(self):
   '''
   read user supplied namelist
   '''
   self.nml = f90nml.read(self.namelist)
   # get list of namelist keys
   self.keys = self.nml.keys()
 def get_value_from_input_or_defaults(self,groupname,varname):
     varname = varname.lower()
     groupname = groupname.lower()
     inputs = f90nml.read(self.input_name)
     if not varname in inputs[groupname].keys():
         return Sfincs_input.defaults[groupname][varname]
     else:
         return inputs[groupname][varname]
Beispiel #21
0
    def set_timestep(self, timestep):

        input_nml_path = os.path.join(self.work_path, 'input.nml')
        input_nml = f90nml.read(input_nml_path)

        input_nml['ocean_model_nml']['dt_ocean'] = timestep

        input_nml.write(input_nml_path, force=True)
def create_species(normalization,filename="species",database_filename = os.path.abspath(__file__).rsplit("/",1)[0] + "/species_database.namelist"):
    """ creates a Species object from a .csv file containing species, and a Normalization object"""

    filename="." + "/" + filename
    names=[x.strip() for x in open(filename,'r').read().split('\n')[0].split(',')]
    database = f90nml.read(database_filename)
    Zs = np.array([database["speciesCharge"][x] for x in names])/normalization.eBar
    mHats = np.array([database["speciesMass"][x] for x in names])/normalization.mBar
    return Species(Zs,mHats,names)
Beispiel #23
0
    def set_timestep(self, t_step):

        namcpl_path = os.path.join(self.work_path, 'namcouple')
        namcpl = Namcouple(namcpl_path, 'access')
        namcpl.set_ice_ocean_coupling_timestep(str(t_step))
        namcpl.write()

        for model in self.expt.models:

            if model.model_type in ('cice', 'cice5'):

                # Set namcouple timesteps

                ice_ts = model.config.get('timestep')
                if ice_ts:
                    model.set_oasis_timestep(ice_ts)

                # Set ACCESS coupler timesteps

                input_ice_path = os.path.join(model.work_path, 'input_ice.nml')
                input_ice = f90nml.read(input_ice_path)

                input_ice['coupling_nml']['dt_cpl_io'] = t_step

                input_ice.write(input_ice_path, force=True)

            elif model.model_type == 'matm':

                input_atm_path = os.path.join(model.work_path, 'input_atm.nml')
                input_atm = f90nml.read(input_atm_path)

                input_atm['coupling']['dt_atm'] = t_step

                input_atm.write(input_atm_path, force=True)

            elif model.model_type == 'mom':

                input_nml_path = os.path.join(model.work_path, 'input.nml')
                input_nml = f90nml.read(input_nml_path)

                input_nml['auscom_ice_nml']['dt_cpl'] = t_step
                input_nml['ocean_solo_nml']['dt_cpld'] = t_step

                input_nml.write(input_nml_path, force=True)
Beispiel #24
0
 def obsproc_init(self, datestart):
   '''
   Sync obsproc namelist with WRF namelist.input
   '''
   from shutil import copyfile
   from datetime import timedelta
   from datetime import datetime
   # convert to unique list
   obslist = list(set(self.obs.values()))
   # read WRF namelist in WRF work_dir
   wrf_nml = f90nml.read(os.path.join(self.config['filesystem']['wrf_run_dir'],
                                      'namelist.input'))
   for obs in obslist:
     # read obsproc namelist
     obsproc_nml = f90nml.read(os.path.join(self.obsproc_dir,
                                            'namelist.obsproc.3dvar.wrfvar-tut'))
     # create obsproc workdir
     self.create_obsproc_dir(obs[0])
     # copy observation in LITTLE_R format to obsproc_dir
     shutil.copyfile(os.path.join(
       self.config['filesystem']['obs_dir'], obs[1]),
       os.path.join(obs[0], obs[1]))
     # sync obsproc namelist variables with wrf namelist.input
     obsproc_nml['record1']['obs_gts_filename'] = obs[1]
     obsproc_nml['record8']['nesti'] = wrf_nml['domains']['i_parent_start']
     obsproc_nml['record8']['nestj'] = wrf_nml['domains']['j_parent_start']
     obsproc_nml['record8']['nestix'] = wrf_nml['domains']['e_we']
     obsproc_nml['record8']['nestjx'] = wrf_nml['domains']['e_sn']
     obsproc_nml['record8']['numc'] = wrf_nml['domains']['parent_id']
     obsproc_nml['record8']['dis'] = wrf_nml['domains']['dx']
     obsproc_nml['record8']['maxnes'] = wrf_nml['domains']['max_dom']
     # set time_analysis, time_window_min, time_window_max
     # check if both datestart and dateend are a datetime instance
     if not isinstance(datestart, datetime):
       raise TypeError("datestart must be an instance of datetime")
     obsproc_nml['record2']['time_analysis'] = datetime.strftime(datestart,
                                                         '%Y-%m-%d_%H:%M:%S')
     obsproc_nml['record2']['time_window_min'] = datetime.strftime(
       datestart - timedelta(minutes=15), '%Y-%m-%d_%H:%M:%S')
     obsproc_nml['record2']['time_window_max'] = datetime.strftime(
       datestart + timedelta(minutes=15), '%Y-%m-%d_%H:%M:%S')
     # save obsproc_nml
     utils.silentremove(os.path.join(obs[0], 'namelist.obsproc'))
     obsproc_nml.write(os.path.join(obs[0], 'namelist.obsproc'))
Beispiel #25
0
    def init_config(self):
        """Patch input.nml as a new or restart run."""

        input_fpath = os.path.join(self.work_path, 'input.nml')

        input_nml = f90nml.read(input_fpath)

        input_type = 'n' if self.expt.counter == 0 else 'r'
        input_nml['GOLD_input_nml']['input_filename'] = input_type

        f90nml.write(input_nml, input_fpath, force=True)
Beispiel #26
0
    def set_access_timestep(self, t_step):
        # TODO: Figure out some way to move this to the ACCESS driver
        # Re-read ice timestep and move this over there
        self.set_local_timestep(t_step)

        input_ice_path = os.path.join(self.work_path, 'input_ice.nml')
        input_ice = f90nml.read(input_ice_path)

        input_ice['coupling_nml']['dt_cice'] = t_step

        input_ice.write(input_ice_path, force=True)
Beispiel #27
0
    def read(self, filename, clear=False):
        """ Read input from file """
        from f90nml import read
        from ..misc import local_path
        if clear:
            self.__inputs.clear()

        filename = local_path(filename)
        dictionary = read(str(filename))
        for key, value in dictionary.items():
            setattr(self, key, value)
Beispiel #28
0
def get_max_dom():
    '''
    get maximum domain number from WRF namelist.input
    '''
    import f90nml
    from config import config
    CONFIG = config()
    CONFIG.__init__()  # load config
    wrf_nml = f90nml.read(os.path.join(CONFIG.config['filesystem']['wrf_run_dir'],
                                       'namelist.input'))
    # maximum domain number
    return wrf_nml['domains']['max_dom']
Beispiel #29
0
    def test_indent(self):
        test_nml = f90nml.read('types.nml')

        test_nml.indent = 2
        self.assert_write(test_nml, 'types_indent_2.nml')

        test_nml.indent = '\t'
        self.assert_write(test_nml, 'types_indent_tab.nml')

        self.assertRaises(ValueError, setattr, test_nml, 'indent', -4)
        self.assertRaises(ValueError, setattr, test_nml, 'indent', 'xyz')
        self.assertRaises(TypeError, setattr, test_nml, 'indent', [1, 2, 3])
Beispiel #30
0
    def test_print_group(self):
        nml = f90nml.read('types.nml')

        stdout = StringIO()
        print(nml['types_nml'], file=stdout)
        stdout.seek(0)
        source_str = stdout.read().rstrip('\n')
        stdout.close()

        target_str = repr(nml['types_nml'])

        self.assertEqual(source_str, target_str)
Beispiel #31
0
 def test_multidim(self):
     test_nml = f90nml.read('multidim.nml')
     self.assertEqual(self.multidim_nml, test_nml)
     self.assert_write(test_nml, 'multidim_target.nml')
Beispiel #32
0
del get_versions

# default parameters and cannot be changed after module load
_magiccpath, _magiccbinary = MAGICC6().original_dir, MAGICC6().original_dir

if not _config['is_windows']:
    wine_installed = subprocess.call("type wine",
                                     shell=True,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE) == 0
    if not wine_installed:
        logging.warning("Wine is not installed")

_config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                            "default_config.nml")
default_config = f90nml.read(_config_path)

# MAGICC's scenario files encode the used regions as follows.
region_codes = {
    11: ['WORLD'],
    20: ['WORLD', "OECD90", "REF", "ASIA", "ALM"],
    21: ['WORLD', "OECD90", "REF", "ASIA", "ALM"],
    31: ['WORLD', "R5OECD", "R5REF", "R5ASIA", "R5MAF", "R5LAM"],
    41: ['WORLD', "R5OECD", "R5REF", "R5ASIA", "R5MAF", "R5LAM", "BUNKERS"]
}

# Order of columns to use when writing scenario files.
_columns = [
    u'YEARS', u'FossilCO2', u'OtherCO2', u'CH4', u'N2O', u'SOx', u'CO',
    u'NMVOC', u'NOx', u'BC', u'OC', u'NH3', u'CF4', u'C2F6', u'C6F14',
    u'HFC23', u'HFC32', u'HFC43-10', u'HFC125', u'HFC134a', u'HFC143a',
Beispiel #33
0
    def test_end_comma(self):
        test_nml = f90nml.read('types.nml')
        test_nml.end_comma = True
        self.assert_write(test_nml, 'types_end_comma.nml')

        self.assertRaises(TypeError, setattr, test_nml, 'end_comma', 'xyz')
Beispiel #34
0
from datetime import datetime, timedelta
import pathlib
from typing import Union

import f90nml  # type: ignore[import]
import pytz

from pyschism.forcing.atmosphere.nws import NWS
from pyschism.forcing.atmosphere.nws.nws2 import NWS2
from pyschism.enums import Coriolis

PARAM_TEMPLATE = pathlib.Path(__file__).parent / 'param.nml.template'
PARAM_DEFAULTS = f90nml.read(PARAM_TEMPLATE)['opt']


class OptMeta(type):
    def __new__(meta, name, bases, attrs):
        for key, value in PARAM_DEFAULTS.items():
            if key not in attrs:
                if isinstance(value, list):
                    attrs[key] = len(value) * [0]
                else:
                    attrs[key] = None
        return type(name, bases, attrs)


class Dramp:
    def __set__(self, obj, dramp: Union[int, float, timedelta, None]):

        if not isinstance(dramp, (int, float, timedelta, type(None))):
            raise TypeError("Argument drampbc must be an int, float, "
Beispiel #35
0
def execute(args, job_args):
    """
    Executes a weather/fire simulation.

    :param args: a dictionary with all to start the simulationfollowing keys
    :param job_args: a the original json given the forecast

    Keys in args:
    :param grid_code: the (unique) code of the grid that is used
    :param sys_install_path: system installation directory
    :param start_utc: start time of simulation in UTC
    :param end_utc: end time of simulation in UTC
    :param workspace_path: workspace directory
    :param wps_install_path: installation directory of WPS that will be used
    :param wrf_install_path: installation directory of WRF that will be used
    :param grib_source: a string identifying a valid GRIB2 source
    :param wps_namelist_path: the path to the namelist.wps file that will be used as template
    :param wrf_namelist_path: the path to the namelist.input file that will be used as template
    :param fire_namelist_path: the path to the namelist.fire file that will be used as template
    :param wps_geog_path: the path to the geogrid data directory providing terrain/fuel data
    :param email_notification: dictionary containing keys address and events indicating when a mail should be fired off
 
    
    """

    # step 0 initialize the job state from the arguments
    js = JobState(args)

    jobdir = osp.abspath(osp.join(js.workspace_path, js.job_id))
    make_clean_dir(jobdir)

    json.dump(job_args,
              open(osp.join(jobdir, 'input.json'), 'w'),
              indent=4,
              separators=(',', ': '))
    jsub = make_job_file(js)
    json.dump(jsub, open(jsub.jobfile, 'w'), indent=4, separators=(',', ': '))

    logging.info("job %s starting [%d hours to forecast]." %
                 (js.job_id, js.fc_hrs))
    sys.stdout.flush()
    send_email(js, 'start', 'Job %s started.' % js.job_id)

    # read in all namelists
    js.wps_nml = f90nml.read(js.args['wps_namelist_path'])
    js.wrf_nml = f90nml.read(js.args['wrf_namelist_path'])
    js.fire_nml = f90nml.read(js.args['fire_namelist_path'])
    js.ems_nml = None
    if 'emissions_namelist_path' in js.args:
        js.ems_nml = f90nml.read(js.args['emissions_namelist_path'])

    # Parse and setup the domain configuration
    js.domain_conf = WPSDomainConf(js.domains)

    num_doms = len(js.domain_conf)
    js.wps_nml['share']['start_date'] = [utc_to_esmf(js.start_utc)] * num_doms
    js.wps_nml['share']['end_date'] = [utc_to_esmf(js.end_utc)] * num_doms
    js.wps_nml['share']['interval_seconds'] = 3600

    logging.info("number of domains defined is %d." % num_doms)

    # build directories in workspace
    js.wps_dir = osp.abspath(osp.join(js.workspace_path, js.job_id, 'wps'))
    js.wrf_dir = osp.abspath(osp.join(js.workspace_path, js.job_id, 'wrf'))

    #check_obj(args,'args')
    #check_obj(js,'Initial job state')

    # step 1: clone WPS and WRF directories
    logging.info("cloning WPS into %s" % js.wps_dir)
    cln = WRFCloner(js.args)
    cln.clone_wps(js.wps_dir, js.grib_source.vtables(), [])

    # step 2: process domain information and patch namelist for geogrid
    js.wps_nml['geogrid']['geog_data_path'] = js.args['wps_geog_path']
    js.domain_conf.prepare_for_geogrid(js.wps_nml, js.wrf_nml, js.wrfxpy_dir,
                                       js.wps_dir)
    f90nml.write(js.wps_nml, osp.join(js.wps_dir, 'namelist.wps'), force=True)

    # do steps 2 & 3 & 4 in parallel (two execution streams)
    #  -> GEOGRID ->
    #  -> GRIB2 download ->  UNGRIB ->

    proc_q = Queue()
    geogrid_proc = Process(target=run_geogrid, args=(js, proc_q))
    grib_proc = Process(target=retrieve_gribs_and_run_ungrib,
                        args=(js, proc_q))

    logging.info('starting GEOGRID and GRIB2/UNGRIB')
    geogrid_proc.start()
    grib_proc.start()

    # wait until both tasks are done
    logging.info('waiting until both tasks are done')
    grib_proc.join()
    geogrid_proc.join()

    if proc_q.get() != 'SUCCESS':
        return

    if proc_q.get() != 'SUCCESS':
        return

    proc_q.close()

    # step 5: execute metgrid after ensuring all grids will be processed
    js.domain_conf.prepare_for_metgrid(js.wps_nml)
    f90nml.write(js.wps_nml, osp.join(js.wps_dir, 'namelist.wps'), force=True)

    logging.info("running METGRID")
    Metgrid(js.wps_dir).execute().check_output()

    send_email(js, 'metgrid', 'Job %s - metgrid complete.' % js.job_id)
    logging.info("cloning WRF into %s" % js.wrf_dir)

    # step 6: clone wrf directory, symlink all met_em* files, make namelists
    cln.clone_wrf(js.wrf_dir, [])
    symlink_matching_files(js.wrf_dir, js.wps_dir, "met_em*")
    time_ctrl = update_time_control(js.start_utc, js.end_utc, num_doms)
    js.wrf_nml['time_control'].update(time_ctrl)
    update_namelist(js.wrf_nml, js.grib_source.namelist_keys())
    if 'ignitions' in js.args:
        update_namelist(js.wrf_nml, render_ignitions(js, num_doms))

    # if we have an emissions namelist, automatically turn on the tracers
    if js.ems_nml is not None:
        logging.debug('namelist.fire_emissions given, turning on tracers')
        f90nml.write(js.ems_nml,
                     osp.join(js.wrf_dir, 'namelist.fire_emissions'),
                     force=True)
        js.wrf_nml['dynamics']['tracer_opt'] = [2] * num_doms

    f90nml.write(js.wrf_nml,
                 osp.join(js.wrf_dir, 'namelist.input'),
                 force=True)

    f90nml.write(js.fire_nml,
                 osp.join(js.wrf_dir, 'namelist.fire'),
                 force=True)

    # step 7: execute real.exe

    logging.info("running REAL")
    # try to run Real twice as it sometimes fails the first time
    # it's not clear why this error happens
    try:
        Real(js.wrf_dir).execute().check_output()
    except Exception as e:
        logging.error('Real step failed with exception %s, retrying ...' %
                      str(e))
        Real(js.wrf_dir).execute().check_output()

    # step 7b: if requested, do fuel moisture DA
    if js.fmda is not None:
        logging.info('running fuel moisture data assimilation')
        for dom in js.fmda.domains:
            assimilate_fm10_observations(
                osp.join(wrf_dir, 'wrfinput_d%02d' % dom), None, js.fmda.token)

    # step 8: execute wrf.exe on parallel backend
    logging.info('submitting WRF job')
    send_email(js, 'wrf_submit', 'Job %s - wrf job submitted.' % js.job_id)

    js.task_id = "sim-" + js.grid_code + "-" + utc_to_esmf(js.start_utc)[:10]
    jsub.job_num = WRF(js.wrf_dir, js.qsys).submit(js.task_id, js.num_nodes,
                                                   js.ppn, js.wall_time_hrs)

    send_email(
        js, 'wrf_exec',
        'Job %s - wrf job starting now with id %s.' % (js.job_id, js.task_id))
    logging.info(
        "WRF job %s submitted with id %s, waiting for rsl.error.0000" %
        (jsub.job_num, js.task_id))

    jobfile = osp.abspath(osp.join(js.workspace_path, js.job_id, 'job.json'))
    json.dump(jsub, open(jobfile, 'w'), indent=4, separators=(',', ': '))

    process_output(js.job_id)
Beispiel #36
0
 def test_unset(self):
     test_nml = f90nml.read('unset.nml')
     self.assertEqual(self.unset_nml, test_nml)
     self.assert_write(test_nml, 'unset.nml')
Beispiel #37
0
 def test_pop_key(self):
     test_nml = f90nml.read('empty.nml')
     test_nml.pop('empty_nml')
     self.assertEqual(test_nml, f90nml.namelist.Namelist())
Beispiel #38
0
 def test_grp_repeat(self):
     test_nml = f90nml.read('grp_repeat.nml')
     self.assertEqual(self.grp_repeat_nml, test_nml)
     self.assert_write(test_nml, 'grp_repeat_target.nml')
Beispiel #39
0
 def test_comment(self):
     test_nml = f90nml.read('comment.nml')
     self.assertEqual(self.comment_nml, test_nml)
     self.assert_write(test_nml, 'comment_target.nml')
Beispiel #40
0
 def test_dollar(self):
     test_nml = f90nml.read('dollar.nml')
     self.assertEqual(self.dollar_nml, test_nml)
     self.assert_write(test_nml, 'dollar_target.nml')
Beispiel #41
0
 def test_f77(self):
     test_nml = f90nml.read('f77.nml')
     self.assertEqual(self.f77_nml, test_nml)
     self.assert_write(test_nml, 'f77_target.nml')
Beispiel #42
0
 def test_multiline_index(self):
     test_nml = f90nml.read('multiline_index.nml')
     self.assertEqual(self.multiline_nml, test_nml)
     self.assert_write(test_nml, 'multiline_index.nml')
Beispiel #43
0
 def test_ext_token(self):
     test_nml = f90nml.read('ext_token.nml')
     self.assertEqual(self.ext_token_nml, test_nml)
Beispiel #44
0
 def test_write_existing_file(self):
     tmp_fname = 'tmp.nml'
     open(tmp_fname, 'w').close()
     test_nml = f90nml.read('empty.nml')
     self.assertRaises(IOError, test_nml.write, tmp_fname)
     os.remove(tmp_fname)
Beispiel #45
0
 def test_vector(self):
     test_nml = f90nml.read('vector.nml')
     self.assertEqual(self.vector_nml, test_nml)
     self.assert_write(test_nml, 'vector_target.nml')
Beispiel #46
0
 def test_null(self):
     test_nml = f90nml.read('null.nml')
     self.assertEqual(self.null_nml, test_nml)
     self.assert_write(test_nml, 'null_target.nml')
Beispiel #47
0
 def test_types(self):
     test_nml = f90nml.read('types.nml')
     self.assertEqual(self.types_nml, test_nml)
     self.assert_write(test_nml, 'types.nml')
Beispiel #48
0
 def test_empty_nml(self):
     test_nml = f90nml.read('empty.nml')
     self.assertEqual(self.empty_nml, test_nml)
     self.assert_write(test_nml, 'empty.nml')
Beispiel #49
0
 def test_bcast(self):
     test_nml = f90nml.read('bcast.nml')
     self.assertEqual(self.bcast_nml, test_nml)
     self.assert_write(test_nml, 'bcast_target.nml')
Beispiel #50
0
    print("    USAGE: {0:s} <File1> <File2>".format(ScriptName))
    print(
        "    USAGE:     <File1> and <File2> are the paths to the two RAMSIN files being compared"
    )
    sys.exit(1)

RamsFname1 = sys.argv[1]
RamsFname2 = sys.argv[2]

print("Comparing two RAMSIN files:")
print("  File1: {0:s}".format(RamsFname1))
print("  File2: {0:s}".format(RamsFname2))
print("")

# Apply the parser to the two files
Rnml1 = f90nml.read(RamsFname1)
Rnml2 = f90nml.read(RamsFname2)

# Data is stored in python dictionary form. The first level of keys are
# the namelist sections (model_grid, model_file_info, etc.), and the
# second level of keys are the varibles within each section.

# Get the group names
Rnml1Groups = list(Rnml1.keys())
Rnml2Groups = list(Rnml2.keys())

# Find the common groups and those unique to each file groups
Only1Groups, Only2Groups, CommGroups = FindListDiffs(Rnml1Groups, Rnml2Groups)

print("Namelist groups unique to File1:")
for Group in Only1Groups:
Beispiel #51
0
 def test_dtype_case(self):
     test_nml = f90nml.read('dtype_case.nml')
     self.assertEqual(self.dtype_case_nml, test_nml)
     self.assert_write(test_nml, 'dtype_case_target.nml')
Beispiel #52
0
 def test_string_multiline(self):
     test_nml = f90nml.read('string_multiline.nml')
     self.assertEqual(self.string_multiline_nml, test_nml)
Beispiel #53
0
 def test_empty_file(self):
     test_nml = f90nml.read('empty_file')
     self.assertEqual(self.empty_file, test_nml)
Beispiel #54
0
 def test_string(self):
     test_nml = f90nml.read('string.nml')
     self.assertEqual(self.string_nml, test_nml)
     self.assert_write(test_nml, 'string_target.nml')
Beispiel #55
0
import scipy.io.netcdf as netcdf
import f90nml

plt.ion()

dir0 = '../run/'
file1 = 'state.0000000000.t001.nc'

if len(sys.argv) > 1:
    dir1 = dir0 + 'mnc_test_' + str(format(sys.argv[1])).zfill(4) + '/'

# physical parameters
gg = 9.81  # m/s^2
sbeta = 7.4e-4  # psu^-1

nml = f90nml.read(dir0 + 'data')
nmldiag = f90nml.read(dir0 + 'data.diagnostics')

dt = nml['parm03']['dumpfreq']

f1 = netcdf.netcdf_file(dir1 + file1, 'r')

tt = f1.variables['T'][:].copy()
xx = f1.variables['X'][:].copy()
zz = f1.variables['Z'][:].copy()

si_t = len(tt)
si_x = len(xx)
si_z = len(zz)

s = f1.variables['S'][:, :, :, :].copy().squeeze()
Beispiel #56
0
 def test_float(self):
     test_nml = f90nml.read('float.nml')
     self.assertEqual(self.float_nml, test_nml)
     self.assert_write(test_nml, 'float_target.nml')
Beispiel #57
0
    def setup(self):
        if not self.top_level_model:
            return

        cpl_keys = {
            'cice': ('input_ice.nml', 'coupling', 'runtime0'),
            'matm': ('input_atm.nml', 'coupling', 'truntime0')
        }

        # Keep track of this in order to set the oasis runtime.
        run_runtime = 0

        for model in self.expt.models:

            if model.model_type == 'cice' or model.model_type == 'cice5':

                # Horrible hack to make a link to o2i.nc in the
                # work/ice/RESTART directory
                f_name = 'o2i.nc'
                f_src = os.path.join(model.work_path, f_name)
                f_dst = os.path.join(model.work_restart_path, f_name)

                if os.path.isfile(f_src):
                    make_symlink(f_src, f_dst)

            if model.model_type == 'cice5':

                # Stage the supplemental input files
                if model.prior_restart_path:
                    for f_name in model.access_restarts:
                        f_src = os.path.join(model.prior_restart_path, f_name)
                        f_dst = os.path.join(model.work_input_path, f_name)

                        if os.path.isfile(f_src):
                            make_symlink(f_src, f_dst)

            if model.model_type in ('cice', 'matm'):

                # Update the supplemental OASIS namelists
                cpl_fname, cpl_group, runtime0_key = cpl_keys[model.model_type]

                cpl_fpath = os.path.join(model.work_path, cpl_fname)
                cpl_nml = f90nml.read(cpl_fpath)

                # Which calendar are we using, noleap or Gregorian.
                caltype = cpl_nml[cpl_group]['caltype']
                init_date = cal.int_to_date(cpl_nml[cpl_group]['init_date'])

                # Get time info about the beginning of this run. We're
                # interested in:
                #   1. start date of run
                #   2. total runtime of all previous runs.
                if model.prior_restart_path and not self.expt.repeat_run:

                    prior_cpl_fpath = os.path.join(model.prior_restart_path,
                                                   cpl_fname)

                    # With later versions this file exists in the prior restart
                    # path, but this was not always the case, so check, and if
                    # not there use prior output path
                    if not os.path.exists(prior_cpl_fpath):
                        print('payu: warning: {0} missing from prior restart '
                              'path; checking prior output.'.format(cpl_fname),
                              file=sys.stderr)
                        if not os.path.isdir(model.prior_output_path):
                            print('payu: error: No prior output path; '
                                  'aborting run.')
                            sys.exit(errno.ENOENT)

                        prior_cpl_fpath = os.path.join(model.prior_output_path,
                                                       cpl_fname)

                    try:
                        prior_cpl_nml = f90nml.read(prior_cpl_fpath)
                    except IOError as exc:
                        if exc.errno == errno.ENOENT:
                            print('payu: error: {0} does not exist; aborting.'
                                  ''.format(prior_cpl_fpath),
                                  file=sys.stderr)
                            sys.exit(exc.errno)
                        else:
                            raise

                    cpl_nml_grp = prior_cpl_nml[cpl_group]

                    # The total time in seconds since the beginning of
                    # the experiment.
                    total_runtime = int(cpl_nml_grp[runtime0_key] +
                                        cpl_nml_grp['runtime'])
                    run_start_date = cal.date_plus_seconds(
                        init_date, total_runtime, caltype)

                else:
                    total_runtime = 0
                    run_start_date = init_date

                # Get new runtime for this run. We get this from either the
                # 'runtime' part of the payu config, or from the namelist
                if self.expt.runtime:
                    run_runtime = cal.runtime_from_date(
                        run_start_date, self.expt.runtime['years'],
                        self.expt.runtime['months'], self.expt.runtime['days'],
                        self.expt.runtime.get('seconds', 0), caltype)
                else:
                    run_runtime = cpl_nml[cpl_group]['runtime']

                # Now write out new run start date and total runtime.
                cpl_nml[cpl_group]['inidate'] = cal.date_to_int(run_start_date)
                cpl_nml[cpl_group][runtime0_key] = total_runtime
                cpl_nml[cpl_group]['runtime'] = int(run_runtime)

                if model.model_type == 'cice':
                    if self.expt.counter and not self.expt.repeat_run:
                        cpl_nml[cpl_group]['jobnum'] = 1 + self.expt.counter
                    else:
                        cpl_nml[cpl_group]['jobnum'] = 1

                nml_work_path = os.path.join(model.work_path, cpl_fname)
                f90nml.write(cpl_nml, nml_work_path + '~')
                shutil.move(nml_work_path + '~', nml_work_path)

        # Now change the oasis runtime. This needs to be done after the others.
        for model in self.expt.models:
            if model.model_type == 'oasis':
                namcouple = os.path.join(model.work_path, 'namcouple')

                s = ''
                with open(namcouple, 'r+') as f:
                    s = f.read()
                    m = re.search(r"^[ \t]*\$RUNTIME.*?^[ \t]*(\d+)", s,
                                  re.MULTILINE | re.DOTALL)
                    assert (m is not None)
                    s = s[:m.start(1)] + str(run_runtime) + s[m.end(1):]

                with open(namcouple, 'w') as f:
                    f.write(s)
Beispiel #58
0
 def test_rowmaj_multidim(self):
     test_nml = f90nml.read('multidim.nml', row_major=True)
     self.assertEqual(self.md_rowmaj_nml, test_nml)
Beispiel #59
0
def determine_namelist_differences(
    source_namelist,
    target_namelist,
    bad_chapters=["set_stream", "mvstreamctl", "set_stream_element"],
):
    """
    Determines differences in namelists

    Parameters
    ----------
    source_namelist : str
        The "source" namelist to use. This is "yours"
    target_namelist : str
        The "target" namelist to use. This is "the other one"
    bad_chapters : list
        A list of strings with chapter names that should not be compared

    Returns
    -------
    namelist_diffs : list
        A list of strings containing diff information; to be printed later.
    """
    source_nml = f90nml.read(source_namelist)
    target_nml = f90nml.read(target_namelist)
    for chapter in bad_chapters:
        for this_nml in source_nml, target_nml:
            if chapter in this_nml:
                del this_nml[chapter]
    common_chapters, unique_source_chapters, unique_target_chapters = determine_identical_and_unique_elements(
        source_nml, target_nml)
    namelist_diffs = ["\n", os.path.basename(source_namelist)]
    namelist_diffs.append(80 * "-")
    for this_chapter in common_chapters:
        namelist_diffs.append("&" + this_chapter)
        entry_diffs = []
        common_entries, unique_source_entries, unique_target_entries = determine_identical_and_unique_elements(
            source_nml[this_chapter], target_nml[this_chapter])
        for this_entry in common_entries:
            source_nml_value = source_nml[this_chapter][this_entry]
            target_nml_value = target_nml[this_chapter][this_entry]
            if source_nml_value != target_nml_value:
                entry_diffs.append("\t\t Source: %s: %s" %
                                   (this_entry, source_nml_value))
                entry_diffs.append("\t\t Target: %s: %s" %
                                   (this_entry, target_nml_value))
        if unique_source_entries:
            entry_diffs.append("\n\t\t Unique to Source:")
            for this_entry in unique_source_entries:
                entry_diffs.append(
                    "\t\t %s: %s" %
                    (this_entry, source_nml[this_chapter][this_entry]))
        if unique_target_entries:
            entry_diffs.append("\n\t\t Unique to Target:")
            for this_entry in unique_target_entries:
                entry_diffs.append(
                    "\t\t %s: %s" %
                    (this_entry, target_nml[this_chapter][this_entry]))
        if entry_diffs:
            namelist_diffs += entry_diffs
        else:
            namelist_diffs.append("\n\t\t All entries are the same!")
        namelist_diffs.append("\\")
    for unique_chapters, nml, tag in zip(
        [unique_source_chapters, unique_target_chapters],
        [source_nml, target_nml],
        ["Source", "Target"],
    ):
        if unique_chapters:
            for chapter in unique_chapters:
                namelist_diffs.append(
                    "\n\t\t The following chapter is unique to %s" % tag)
                namelist_diffs.append("&" + chapter)
                for entry, value in nml[chapter].items():
                    namelist_diffs.append("\t\t %s: %s" % (entry, value))
    return namelist_diffs
Beispiel #60
0
 def test_no_selfpatch(self):
     patch_nml = f90nml.read('types_patch.nml')
     self.assertRaises(ValueError, f90nml.patch,
                       'types.nml', patch_nml, 'types.nml')