1 | #------------------------------------------------------------------------------# |
---|
2 | # This file is part of the PALM model system. |
---|
3 | # |
---|
4 | # PALM is free software: you can redistribute it and/or modify it under the |
---|
5 | # terms of the GNU General Public License as published by the Free Software |
---|
6 | # Foundation, either version 3 of the License, or (at your option) any later |
---|
7 | # version. |
---|
8 | # |
---|
9 | # PALM is distributed in the hope that it will be useful, but WITHOUT ANY |
---|
10 | # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR |
---|
11 | # A PARTICULAR PURPOSE. See the GNU General Public License for more details. |
---|
12 | # |
---|
13 | # You should have received a copy of the GNU General Public License along with |
---|
14 | # PALM. If not, see <http://www.gnu.org/licenses/>. |
---|
15 | # |
---|
16 | # Copyright 1997-2019 Leibniz Universitaet Hannover |
---|
17 | #------------------------------------------------------------------------------# |
---|
18 | |
---|
19 | import math |
---|
20 | from netCDF4 import Dataset |
---|
21 | import numpy as np |
---|
22 | import datetime |
---|
23 | |
---|
24 | |
---|
25 | class StaticDriver: |
---|
26 | """ This is an example script to generate static drivers for PALM. |
---|
27 | |
---|
28 | You can use it as a starting point for creating your setup specific |
---|
29 | driver. |
---|
30 | """ |
---|
31 | |
---|
32 | |
---|
33 | def __init__(self): |
---|
34 | """ Open the static driver as NetCDF4 file. Here, you have to give the |
---|
35 | full path to the static driver that shall be created. Existing file |
---|
36 | with same name is deleted. |
---|
37 | """ |
---|
38 | print('Opening file...') |
---|
39 | self.nc_file = Dataset('path/to/file.nc', 'w', format='NETCDF4') |
---|
40 | |
---|
41 | |
---|
42 | def write_global_attributes(self): |
---|
43 | """ Write global attributes to static driver. """ |
---|
44 | print("Writing global attributes...") |
---|
45 | |
---|
46 | # mandatory global attributes |
---|
47 | self.nc_file.origin_lon = 55.0 # used to initialize coriolis parameter |
---|
48 | self.nc_file.origin_lat = 0.0 # (overwrite initialization_parameters) |
---|
49 | self.nc_file.origin_time = '2000-06-21 12:00:00 +00' |
---|
50 | self.nc_file.origin_x = 308124 |
---|
51 | self.nc_file.origin_y = 6098908 |
---|
52 | self.nc_file.origin_z = 0.0 |
---|
53 | self.nc_file.rotation_angle = 0.0 |
---|
54 | |
---|
55 | # optional global attributes |
---|
56 | self.nc_file.author = 'Your Name' |
---|
57 | self.nc_file.comment = 'Miscellaneous information about the data ' \ |
---|
58 | 'or methods to produce it.' |
---|
59 | self.nc_file.creation_date = str(datetime.datetime.now()) |
---|
60 | self.nc_file.institution = 'Institut of Meteorology and Climatology,' \ |
---|
61 | 'Leibniz University Hannover' |
---|
62 | self.nc_file.history = '' |
---|
63 | self.nc_file.palm_revision = '' |
---|
64 | self.nc_file.title = 'Static driver for some arbitrary PALM setup' |
---|
65 | |
---|
66 | |
---|
67 | def define_dimensions(self): |
---|
68 | """ Set dimensions on which variables are defined. """ |
---|
69 | print("Writing dimensions...") |
---|
70 | |
---|
71 | # specify general grid parameters |
---|
72 | # these values must equal those set in the initialization_parameters |
---|
73 | self.nx = 39 |
---|
74 | self.ny = 39 |
---|
75 | self.nz = 40 |
---|
76 | dx = 50 |
---|
77 | dy = 50 |
---|
78 | dz = 50 |
---|
79 | |
---|
80 | # create soil grid (only relevant if land surface module is used) |
---|
81 | dz_soil = np.array((0.01, 0.02, 0.04, 0.06, 0.14, 0.26, 0.54, 1.86)) |
---|
82 | zsoil_fullLayers = np.zeros_like(dz_soil) |
---|
83 | zsoil_fullLayers = np.around([np.sum(dz_soil[:zs]) for zs in np.arange(1,len(dz_soil)+1)],2) |
---|
84 | zsoil_array = zsoil_fullLayers - dz_soil/2. |
---|
85 | |
---|
86 | # create plant canopy grid (only relevant of plant canopy module is used) |
---|
87 | zlad_array = np.arange(0,10,1) |
---|
88 | |
---|
89 | # mandatory dimensions |
---|
90 | self.nc_file.createDimension('x' ,self.nx+1) |
---|
91 | self.x = self.nc_file.createVariable('x', 'f8', ('x',)) |
---|
92 | self.x.units = 'm' |
---|
93 | self.x.standard_name = 'x coordinate of cell centers' |
---|
94 | self.x[:] = np.arange(0,(self.nx+1)*dx,dx) |
---|
95 | |
---|
96 | self.nc_file.createDimension('xu', self.nx) |
---|
97 | self.xu = self.nc_file.createVariable('xu', 'f8', ('xu',)) |
---|
98 | self.xu.units = 'm' |
---|
99 | self.xu.standard_name = 'x coordinate of cell edges' |
---|
100 | self.xu[:] = np.arange(dx/2.,self.nx*dx,dx) |
---|
101 | |
---|
102 | self.nc_file.createDimension('y', self.ny+1) |
---|
103 | self.y = self.nc_file.createVariable('y', 'f8', ('y',)) |
---|
104 | self.y.units = 'm' |
---|
105 | self.y.standard_name = 'y coordinate of cell centers' |
---|
106 | self.y[:] = np.arange(0,(self.ny+1)*dy,dy) |
---|
107 | |
---|
108 | self.nc_file.createDimension('yv', self.ny) |
---|
109 | self.yv = self.nc_file.createVariable('yv', 'f8', ('yv',)) |
---|
110 | self.yv.units = 'm' |
---|
111 | self.yv.standard_name = 'y coordinate of cell edges' |
---|
112 | self.yv[:] = np.arange(dy/2.,self.ny*dy,dy) |
---|
113 | |
---|
114 | # if your simulation uses a stretched vertical grid, you need to |
---|
115 | # modify the z and zw coordinates, |
---|
116 | # e.g. z_array = (...) and zw_array = (...) |
---|
117 | z_array = np.append(0, np.arange(dz/2,(self.nz+1)*dz,dz)) |
---|
118 | self.nc_file.createDimension('z',self.nz+2) |
---|
119 | self.z = self.nc_file.createVariable('z', 'f8', ('z',)) |
---|
120 | self.z.units = 'm' |
---|
121 | self.z.standard_name = 'z coordinate of cell centers' |
---|
122 | self.z[:] = z_array |
---|
123 | |
---|
124 | zw_array = np.arange(0,(self.nz+2)*dz,dz) |
---|
125 | self.nc_file.createDimension('zw', self.nz+2) |
---|
126 | self.zw = self.nc_file.createVariable('zw', 'f8', ('zw',)) |
---|
127 | self.zw.units = 'm' |
---|
128 | self.zw.standard_name = 'z coordinate of cell edges' |
---|
129 | self.zw[:] = zw_array |
---|
130 | |
---|
131 | # optional dimensions, uncomment if needed |
---|
132 | #self.nc_file.createDimension('zsoil', len(zsoil_array)) |
---|
133 | #self.zsoil = self.nc_file.createVariable('zsoil', 'f8', ('zsoil',)) |
---|
134 | #self.zsoil.positive = 'down' |
---|
135 | #self.zsoil.units = 'm' |
---|
136 | #self.zsoil.standard_name = 'depth below land' |
---|
137 | #self.zsoil[:] = zsoil_array |
---|
138 | |
---|
139 | #self.nc_file.createDimension('zlad', len(zlad_array)) |
---|
140 | #self.zlad = self.nc_file.createVariable('zlad', 'f8', ('zlad',)) |
---|
141 | #self.zlad.units = 'm' |
---|
142 | #self.zlad.standard_name = 'z coordinate of resolved plant canopy' |
---|
143 | #self.zlad[:] = zlad_array |
---|
144 | |
---|
145 | #self.nc_file.createDimension('nalbedo_pars', 3) |
---|
146 | #self.nalbedo_pars = self.nc_file.createVariable( |
---|
147 | #'nalbedo_pars', 'i1', ('nalbedo_pars',)) |
---|
148 | #self.nalbedo_pars[:] = np.arange(0,3) |
---|
149 | |
---|
150 | #self.nc_file.createDimension('nbuilding_pars', 46) |
---|
151 | #self.nbuilding_pars = self.nc_file.createVariable( |
---|
152 | #'nbuilding_pars', 'i4', ('nbuilding_pars',)) |
---|
153 | #self.nbuilding_pars[:] = np.arange(0,46) |
---|
154 | |
---|
155 | #self.nc_file.createDimension('nsoil_pars', 8) |
---|
156 | #self.nsoil_pars = self.nc_file.createVariable( |
---|
157 | #'nsoil_pars', 'i1', ('nsoil_pars',)) |
---|
158 | #self.nsoil_pars[:] = np.arange(0,8) |
---|
159 | |
---|
160 | #self.nc_file.createDimension('nsurface_fraction', 3) |
---|
161 | #self.nsurface_fraction = self.nc_file.createVariable( |
---|
162 | #'nsurface_fraction', 'i1', ('nsurface_fraction',)) |
---|
163 | #self.nsurface_fraction[:] = np.arange(0,3) |
---|
164 | |
---|
165 | #self.nc_file.createDimension('nvegetation_pars', 12) |
---|
166 | #self.nvegetation_pars = self.nc_file.createVariable( |
---|
167 | #'nvegetation_pars', 'i1', ('nvegetation_pars',)) |
---|
168 | #self.nvegetation_pars[:] = np.arange(0,12) |
---|
169 | |
---|
170 | #self.nc_file.createDimension('npavement_pars', 4) |
---|
171 | #self.npavement_pars = self.nc_file.createVariable( |
---|
172 | #'npavement_pars', 'i1', ('npavement_pars',)) |
---|
173 | #self.npavement_pars[:] = np.arange(0,4) |
---|
174 | |
---|
175 | #self.nc_file.createDimension('npavement_subsurface_pars', 2) |
---|
176 | #self.npavement_subsurface_pars = self.nc_file.createVariable( |
---|
177 | #'npavement_subsurface_pars', 'i1', ('npavement_subsurface_pars',)) |
---|
178 | #self.npavement_subsurface_pars[:] = np.arange(0,2) |
---|
179 | |
---|
180 | #self.nc_file.createDimension('nwater_pars', 6) |
---|
181 | #self.nwater_pars = self.nc_file.createVariable( |
---|
182 | #'nwater_pars', 'i1', ('nwater_pars',)) |
---|
183 | #self.nwater_pars[:] = np.arange(0,6) |
---|
184 | |
---|
185 | |
---|
186 | def add_variables(self): |
---|
187 | """ Uncomment variables below as you like. |
---|
188 | |
---|
189 | Be aware that some variables depend on others. For a description of |
---|
190 | each variable, please have a look at the documentation at |
---|
191 | palm.muk.uni-hannover.de/trac/wiki/doc/app/iofiles/pids/static |
---|
192 | |
---|
193 | An example of how you modify the variables is given below: |
---|
194 | |
---|
195 | building_2d_array = np.ones((self.ny+1,self.nx+1)) * -9999.9 |
---|
196 | south_wall, north_wall, left_wall, right_wall = 20, 25, 20, 25 |
---|
197 | building_2d_array[south_wall:north_wall,left_wall:right_wall] = 50 |
---|
198 | nc_buildings_2d = self.nc_file.createVariable( |
---|
199 | 'buildings_2d', 'f4', ('y','x'),fill_value=-9999.9) |
---|
200 | nc_buildings_2d.lod = 1 |
---|
201 | nc_buildings_2d[:,:] = building_2d_array |
---|
202 | """ |
---|
203 | print("Writing variables...") |
---|
204 | |
---|
205 | ## topography variables |
---|
206 | #nc_buildings_2d = self.nc_file.createVariable( |
---|
207 | #'buildings_2d', 'f4', ('y','x'), fill_value=-9999.9) |
---|
208 | #nc_buildings_2d.lod = 1 |
---|
209 | #nc_buildings_2d[:,:] = -9999.9 |
---|
210 | |
---|
211 | #nc_buildings_3d = self.nc_file.createVariable( |
---|
212 | #'buildings_3d', 'i1', ('z','y','x'),fill_value=-127) |
---|
213 | #nc_buildings_3d.lod = 2 |
---|
214 | #nc_buildings_3d[:,:,:] = -127 |
---|
215 | |
---|
216 | #nc_building_id = self.nc_file.createVariable( |
---|
217 | #'building_id', 'i1', ('y','x'), fill_value=-127) |
---|
218 | #nc_building_id[:,:] = -127 |
---|
219 | |
---|
220 | #nc_zt = self.nc_file.createVariable( |
---|
221 | #'zt', 'f4', ('y','x'), fill_value=-9999.9) |
---|
222 | #nc_zt.long_name = 'orography' |
---|
223 | #nc_zt.units = 'm' |
---|
224 | #nc_zt[:,:] = -9999.9 |
---|
225 | |
---|
226 | ## surface variables |
---|
227 | #nc_albedo_pars = self.nc_file.createVariable( |
---|
228 | #'albedo_pars', 'f4', ('nalbedo_pars','y','x'), fill_value=-9999.9) |
---|
229 | #nc_albedo_pars.long_name = 'albedo parameters' |
---|
230 | #nc_albedo_pars[:,:,:] = -9999.9 |
---|
231 | |
---|
232 | #nc_albedo_type = self.nc_file.createVariable( |
---|
233 | #'albedo_type', 'f4', ('y','x'), fill_value=-9999.9) |
---|
234 | #nc_albedo_type[:,:] = -9999.9 |
---|
235 | |
---|
236 | #nc_building_pars = self.nc_file.createVariable( |
---|
237 | #'building_pars', 'f4', ('nbuilding_pars','y','x'), fill_value=-9999.9) |
---|
238 | #nc_building_pars.long_name = 'building parameters' |
---|
239 | #nc_building_pars[:,:,:] = -9999.9 |
---|
240 | |
---|
241 | #nc_building_type = self.nc_file.createVariable( |
---|
242 | #'building_type', 'i1', ('y','x'), fill_value=-127) |
---|
243 | #nc_building_type[:,:] = -127 |
---|
244 | |
---|
245 | #nc_pavement_pars = self.nc_file.createVariable( |
---|
246 | #'pavement_pars', 'f4', ('npavement_pars','y','x'), fill_value=-9999.9) |
---|
247 | #nc_pavement_pars[:,:,:] = -9999.9 |
---|
248 | |
---|
249 | #nc_pavement_subsurface_pars = self.nc_file.createVariable( |
---|
250 | #'pavement_subsurface_pars', 'i1', |
---|
251 | #('npavement_subsurface_pars','zsoil','y','x'), fill_value=-9999.9) |
---|
252 | #nc_pavement_subsurface_pars[:,:,:,:] = -9999.9 |
---|
253 | |
---|
254 | #nc_pavement_type = self.nc_file.createVariable( |
---|
255 | #'pavement_type', 'i1', ('y','x'), fill_value=-127) |
---|
256 | #nc_pavement_type[:,:] = -127 |
---|
257 | |
---|
258 | #nc_soil_pars = self.nc_file.createVariable( |
---|
259 | #'soil_pars', 'f', ('nsoil_pars','zsoil','y','x'), fill_value=-9999.9) |
---|
260 | #nc_soil_pars.long_name = 'soil parameters' |
---|
261 | #nc_soil_pars.lod = 2 # if set to 1, adjust dimensions of soil_pars |
---|
262 | #nc_soil_pars[:,:,:,:] = -9999.9 |
---|
263 | |
---|
264 | #nc_soil_type = self.nc_file.createVariable( |
---|
265 | #'soil_type', 'i1', ('zsoil','y','x'), fill_value=-127) |
---|
266 | #nc_soil_type.lod = 2 # if set to 1, adjust dimensions of soil_type |
---|
267 | #nc_soil_type[:,:,:] = -127 |
---|
268 | |
---|
269 | ## required, if several surface types are defined at the same location |
---|
270 | #nc_surface_fraction = self.nc_file.createVariable( |
---|
271 | #'surface_fraction', 'f', ('nsurface_fraction','y','x'), fill_value=-9999.9) |
---|
272 | #nc_surface_fraction[0,:,:] = -9999.9 # vegetation fraction |
---|
273 | #nc_surface_fraction[1,:,:] = -9999.9 # pavement fraction |
---|
274 | #nc_surface_fraction[2,:,:] = -9999.9 # water fraction |
---|
275 | |
---|
276 | #nc_vegetation_pars = self.nc_file.createVariable( |
---|
277 | #'vegetation_pars', 'f', ('nvegetation_pars','y','x'), fill_value=-9999.9) |
---|
278 | #nc_vegetation_pars.long_name = 'vegetation parameters' |
---|
279 | #nc_vegetation_pars[:,:,:] = -9999.9 |
---|
280 | |
---|
281 | #nc_vegetation_type = self.nc_file.createVariable( |
---|
282 | #'vegetation_type', 'i1', ('y','x'), fill_value=-127) |
---|
283 | #nc_vegetation_type[:,:] = -127 |
---|
284 | |
---|
285 | #nc_street_type = self.nc_file.createVariable( |
---|
286 | #'street_type', 'i1', ('y','x'), |
---|
287 | #fill_value=-127) |
---|
288 | #nc_street_type[:,:] = -127 |
---|
289 | |
---|
290 | #nc_water_pars = self.nc_file.createVariable( |
---|
291 | #'water_pars', 'i1', ('nwater_pars','y','x'), fill_value=-9999.9) |
---|
292 | #nc_water_pars[:,:,:] = -9999.9 |
---|
293 | |
---|
294 | #nc_water_type = self.nc_file.createVariable( |
---|
295 | #'water_type', 'i1',('y','x'), fill_value=-127) |
---|
296 | #nc_water_type[:,:] = -127 |
---|
297 | |
---|
298 | ## resolved plant canopy |
---|
299 | #nc_lad = self.nc_file.createVariable( |
---|
300 | #'lad', 'f4', ('zlad','y','x'), fill_value=-9999.9) |
---|
301 | #nc_lad.long_name = 'leaf area density' |
---|
302 | #nc_lad[:,:,:] = -9999.9 |
---|
303 | |
---|
304 | #nc_root_area_dens_s = self.nc_file.createVariable( |
---|
305 | #'root_area_dens_s', 'f4', ('zsoil','y','x'), fill_value=-9999.9) |
---|
306 | #nc_root_area_dens_s.long_name = 'parameterized root area density' |
---|
307 | #nc_root_area_dens_s.units = '1/m' |
---|
308 | #nc_root_area_dens_s[:,:,:] = -9999.9 |
---|
309 | |
---|
310 | |
---|
311 | def finalize(self): |
---|
312 | """ Close file """ |
---|
313 | print("Closing file...") |
---|
314 | |
---|
315 | self.nc_file.close() |
---|
316 | |
---|
317 | |
---|
318 | if __name__ == '__main__': |
---|
319 | driver = StaticDriver() |
---|
320 | driver.write_global_attributes() |
---|
321 | driver.define_dimensions() |
---|
322 | driver.add_variables() |
---|
323 | driver.finalize() |
---|
324 | |
---|