parcel/io_output.py at master · igfuw/parcel · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#!/usr/bin/env python
from scipy.io import netcdf
import numpy as np
from parcel_common import _Chem_g_id, _Chem_a_id


def _output_bins(fout, t, micro, opts, spectra):
  for dim, dct in spectra.items():
    for bin in range(dct["nbin"]):
      if dct["drwt"] == 'wet':
        micro.diag_wet_rng(
          fout.variables[dim+"_r_wet"][bin],
          fout.variables[dim+"_r_wet"][bin] + fout.variables[dim+"_dr_wet"][bin]
        )
      elif dct["drwt"] == 'dry':
        micro.diag_dry_rng(
          fout.variables[dim+"_r_dry"][bin],
          fout.variables[dim+"_r_dry"][bin] + fout.variables[dim+"_dr_dry"][bin]
        )
      else: raise Exception("drwt should be wet or dry")

      for vm in dct["moms"]:
        if type(vm) == int:
          # calculating moments
          if dct["drwt"] == 'wet':
            micro.diag_wet_mom(vm)
          elif dct["drwt"] == 'dry':
            micro.diag_dry_mom(vm)
          else: raise Exception("drwt should be wet or dry")
          fout.variables[dim+'_m'+str(vm)][int(t), int(bin)] = np.frombuffer(micro.outbuf())
        else:
          # calculate chemistry
          micro.diag_chem(_Chem_a_id[vm])
          fout.variables[dim+'_'+vm][int(t), int(bin)] = np.frombuffer(micro.outbuf())


def _output_init(micro, opts, spectra):
  """Initialize output file for lagrangian scheme"""
  # file & dimensions
  fout = netcdf.netcdf_file(opts["outfile"], 'w')
  fout.createDimension('t', None)
  for name, dct in spectra.items():
    fout.createDimension(name, dct["nbin"])

    tmp = name + '_r_' + dct["drwt"]
    fout.createVariable(tmp, 'd', (name,))
    fout.variables[tmp].unit = "m"
    fout.variables[tmp].description = "particle wet radius (left bin edge)"

    tmp = name + '_dr_' + dct["drwt"]
    fout.createVariable(tmp, 'd', (name,))
    fout.variables[tmp].unit = "m"
    fout.variables[tmp].description = "bin width"

    if dct["lnli"] == 'log':
      from math import exp, log
      dlnr = (log(dct["rght"]) - log(dct["left"])) / dct["nbin"]
      allbins = np.exp(log(dct["left"]) + np.arange(dct["nbin"]+1) * dlnr)
      fout.variables[name+'_r_'+dct["drwt"]][:] = allbins[0:-1]
      fout.variables[name+'_dr_'+dct["drwt"]][:] = allbins[1:] - allbins[0:-1]
    elif dct["lnli"] == 'lin':
      dr = (dct["rght"] - dct["left"]) / dct["nbin"]
      fout.variables[name+'_r_'+dct["drwt"]][:] = dct["left"] + np.arange(dct["nbin"]) * dr
      fout.variables[name+'_dr_'+dct["drwt"]][:] = dr
    else: raise Exception("lnli should be log or lin")

    for vm in dct["moms"]:
      if (vm in _Chem_a_id):
        fout.createVariable(name+'_'+vm, 'd', ('t',name))
        fout.variables[name+'_'+vm].unit = 'kg of chem species dissolved in cloud droplets (kg of dry air)^-1'
      else:
        assert(type(vm)==int)
        fout.createVariable(name+'_m'+str(vm), 'd', ('t',name))
        fout.variables[name+'_m'+str(vm)].unit = 'm^'+str(vm)+' (kg of dry air)^-1'

  units = {"z"  : "m",     "t"   : "s",     "r_v"  : "kg/kg", "th_d" : "K", "rhod" : "kg/m3",
           "p"  : "Pa",    "T"   : "K",     "RH"   : "1",    "T_blk"   : "K",     "RH_blk"   : "1"
  }

  if micro.opts_init.chem_switch:
    for id_str in _Chem_g_id.keys():
      units[id_str] = "gas mixing ratio [kg / kg dry air]"
      units[id_str.replace('_g', '_a')] = "kg of chem species (both undissociated and ions) dissolved in cloud droplets (kg of dry air)^-1"

  for var_name, unit in units.items():
    fout.createVariable(var_name, 'd', ('t',))
    fout.variables[var_name].unit = unit

  if micro.opts_init.ice_switch:
    fout.createVariable("ice_mix_ratio", 'd', ('t',))
    fout.variables["ice_mix_ratio"].unit = "kg/kg"

  return fout


def _output_init_blk_1m(opts):
    """Initialize output file for bulk microphysics scheme without ice processes"""
    fout = netcdf.netcdf_file(opts["outfile"], 'w')
    fout.createDimension('t', None)

    # Basic variables with their units
    vars_units = {
        "z": ("m",),
        "t": ("s",),
        "r_v": ("kg/kg",),
        "rc": ("kg/kg",),
        "rr": ("kg/kg",),
        "th_d": ("K",),
        "rhod": ("kg/m3",),
        "p": ("Pa",),
        "T": ("K",),
        "RH": ("1",),
        "T_blk": ("K",),
        "RH_blk": ("1",)
    }

    for var, (unit,) in vars_units.items():
        fout.createVariable(var, 'd', ('t',))
        fout.variables[var].unit = unit

    return fout


def _output_init_blk_1m_ice(opts):
    """Initialize output file for bulk ice microphysics scheme"""
    fout = netcdf.netcdf_file(opts["outfile"], 'w')
    fout.createDimension('t', None)

    # Basic variables with their units
    vars_units = {
        "z": ("m",),
        "t": ("s",),
        "r_v": ("kg/kg",),
        "rc": ("kg/kg",),
        "rr": ("kg/kg",),
        "ria": ("kg/kg",),
        "rib": ("kg/kg",),
        "th_d": ("K",),
        "rhod": ("kg/m3",),
        "p": ("Pa",),
        "T": ("K",),
        "RH": ("1",),
        "T_blk": ("K",),
        "RH_blk": ("1",)
    }

    for var, (unit,) in vars_units.items():
        fout.createVariable(var, 'd', ('t',))
        fout.variables[var].unit = unit

    return fout


def _output_save(fout, state, rec):
  for var, val in state.items():
    fout.variables[var][int(rec)] = val


def _save_attrs(fout, dictnr):
  for var, val in dictnr.items():
    setattr(fout, var, val)


def _output(fout, opts, micro, state, rec, spectra):
  _output_bins(fout, rec, micro, opts, spectra)
  _output_save(fout, state, rec)