Context Navigation

fpmetbinary_mod.F90.DEV @ 5f50284

fp9.3.1-20161214-nc4

Last change on this file since 5f50284 was 5f50284, checked in by Don Morton <Don.Morton@…>, 7 years ago
In fp9.3.1-20161214-nc4 branch, decoupled the NC4 FP format from raw binary (just commented that out for now) and tested successfully.
Property mode set to `100644`
File size: 144.4 KB

Line
1	MODULE fpmetbinary_mod
2
3	!*****************************************************************************
4	! *
5	! Contains data and routines for dumping and loading processed met *
6	! fields. *
7	! Authors Don Morton (Don.Morton@borealscicomp.com) *
8	! Delia Arnold (deliona.arnold@gmail.com) *
9	! *
10	! 07 Oct 2016 *
11	! *
12	! Most of the data structures from com_mod.f90 that are dumped and *
13	! loaded have a final dimension of size two, so that they may hold data *
14	! from two met files. When we dump the contents into a .fp file, we *
15	! need to specify which of the two to dump. Likewise, when we load *
16	! from a .fp file, we need to specify which of the two possible indices *
17	! to load into. *
18	! *
19	! Note that these routines need more robustness. For example, what *
20	! what happens if the filename can't be read or written. Or, what *
21	! happens if a read or write fails in any way. Right now, it's crash *
22	! city. *
23	! *
24	! Recent enhancements (07 Oct 2016) DJM: *
25	! *
26	! - file format changed so that compiled dimensions are output, and *
27	! during input these same dimensions are compared with the dimensions *
28	! compiled into the flexpart that is reading it. A discrepancy *
29	! causes abort, so that time isn't wasted reading an incompatible *
30	! file. *
31	! *
32	! - file format changed so that first item is an 8-character string *
33	! depicting the version of the preprocessed file format. *
34	! An inconsistency between a detected and expected string results *
35	! in program abort. *
36	! *
37	! * IMPORTANT * - when the format of the preprocessed output is *
38	! modified in any way, be sure to change the version string below, *
39	! PREPROC_FORMAT_VERSION_STR, so that attempts to read the output *
40	! with a different format version will cause an abort. *
41	! *
42	!*****************************************************************************
43
44	USE com_mod
45	USE conv_mod
46	USE par_mod, ONLY : nxmax, nymax, nzmax, nuvzmax, nwzmax, numclass, maxspec, &
47	& maxnests, nxmaxn, nymaxn
48
49	USE netcdf
50
51	IMPLICIT NONE
52
53	! Users may want to change these IO Unit values if they conflict with other parts
54	! of code
55	INTEGER, PARAMETER :: IOUNIT_DUMP = 33, IOUNIT_LOAD = 34, &
56	IOUNIT_TEXTOUT = 35
57
58	! When a change is made to the format of the preprocessed file, such that
59	! this routine will not be able to read a previous version, this version
60	! string should be modified
61	CHARACTER(LEN=12), PARAMETER :: PREPROC_FORMAT_VERSION_STR = 'FP_p-9.3.1'//char(0)
62
63	PRIVATE IOUNIT_DUMP, IOUNIT_LOAD, IOUNIT_TEXTOUT, fpio, &
64	& PREPROC_FORMAT_VERSION_STR
65
66
67	CONTAINS
68
69	!*****************************************************************************
70	! *
71	! Subroutines fpmetbinary_dump() and fpmetbinary_load() provide the *
72	! public interface to *
73	! this module functionality. I created the PRIVATE fpio() because I *
74	! wanted all interactions with variables to be in one place. The read *
75	! and write operations need to be done in exactly the same sequence, so *
76	! I felt like keeping them in the same routine would at least allow for *
77	! coders to more easily compare the two sequences than if they were *
78	! separate. *
79	! *
80	! As mentioned above, the dumps and loads will, for most variables, *
81	! need to refer to one of two index values for the last dimension of *
82	! the array. *
83	! *
84	!*****************************************************************************
85
86
87	SUBROUTINE fpmetbinary_dump(filename, cm_index)
88	CHARACTER(LEN=*), INTENT(IN) :: filename ! Full path for file
89	INTEGER, INTENT(IN) :: cm_index ! Index of last dimension in
90	! most com_mod variables.
91	! Should be 1 or 2
92
93	INTEGER millisecs_start, millisecs_stop, count_rate, count_max
94
95	INTEGER :: ncretval, ncid ! NetCDF func return value, file id
96
97	CALL SYSTEM_CLOCK(millisecs_start, count_rate, count_max)
98
99	! Create and open NC4 file for writing
100	PRINT *, 'Opening NC4 file...'
101	ncretval = nf90_create(filename // ".nc4", &
102	& OR(NF90_CLOBBER, NF90_HDF5), &
103	& ncid)
104
105
106	#ifdef RAWBIN
107	OPEN(IOUNIT_DUMP, file=filename, action='WRITE', status='REPLACE', form="unformatted", access="stream")
108	#endif
109
110
111
112
113
114	CALL fpio(IOUNIT_DUMP, ncid, 'DUMP', cm_index)
115
116	#ifdef RAWBIN
117	CLOSE(IOUNIT_DUMP)
118	#endif
119
120	PRINT *, 'Closing NC4 file...'
121	ncretval = nf90_close(ncid)
122
123	CALL SYSTEM_CLOCK(millisecs_stop, count_rate, count_max)
124
125	!PRINT *, 'Dump walltime secs: ', (millisecs_stop-millisecs_start)/1000.0
126	END SUBROUTINE fpmetbinary_dump
127
128	SUBROUTINE fpmetbinary_load(filename, cm_index)
129	CHARACTER(LEN=*), INTENT(IN) :: filename ! Full path for file
130	INTEGER, INTENT(IN) :: cm_index ! Index of last dimension in
131	! most com_mod variables.
132	! Should be 1 or 2
133
134	INTEGER :: ncretval, ncid ! NetCDF func return value, file id
135
136	INTEGER millisecs_start, millisecs_stop, count_rate, count_max
137
138	CALL SYSTEM_CLOCK(millisecs_start, count_rate, count_max)
139
140	PRINT *, "filename: ", filename
141	PRINT *, "Opening nc file for reading: ", filename // ".nc4"
142	ncretval = nf90_open(filename // ".nc4", NF90_NOWRITE, ncid)
143	call handle_nf90_err(ncretval)
144	PRINT *, 'OPENED NC4 FILE FOR READING...'
145
146
147
148	#ifdef RAWBIN
149	OPEN(IOUNIT_LOAD, file=filename, action='READ', status='OLD', form="unformatted", access="stream")
150	#endif
151
152	CALL fpio(IOUNIT_LOAD, ncid, 'LOAD', cm_index)
153
154	#ifdef RAWBIN
155	CLOSE(IOUNIT_LOAD)
156	#endif
157
158
159	CALL SYSTEM_CLOCK(millisecs_stop, count_rate, count_max)
160	!PRINT *, 'Load walltime secs: ', (millisecs_stop-millisecs_start)/1000.0
161	END SUBROUTINE fpmetbinary_load
162
163	SUBROUTINE fpmetbinary_zero(cm_index)
164	INTEGER, INTENT(IN) :: cm_index ! Index of last dimension in
165	! most com_mod variables.
166	! Should be 1 or 2
167
168
169	! Zeroes out, in local datastructures, the values dumped/loaded
170	! This was written primarily as a testing mechanism.
171	! DJM -- 17 February 2017 -- I don't think this routine has been used
172	! for anything in recent past. Might want to consider 86'ing it.
173	! The lines here correspond to READ and WRITE in the dump/load routines
174
175	! Scalar values
176	nx=0.0; ny=0.0; nxmin1=0.0; nymin1=0.0; nxfield=0.0
177	nuvz=0.0; nwz=0.0; nz=0.0; nmixz=0.0; nlev_ec=0.0
178	dx=0.0; dy=0.0; xlon0=0.0; ylat0=0.0; dxconst=0.0; dyconst=0.0
179
180	! Fixed fields, static in time
181	oro=0.0; excessoro=0.0; lsm=0.0; xlanduse=0.0; height=0.0
182
183	! 3d fields
184	uu(:,:,:,cm_index) = 0.0
185	vv(:,:,:,cm_index) = 0.0
186	uupol(:,:,:,cm_index) = 0.0
187	vvpol(:,:,:,cm_index) = 0.0
188	ww(:,:,:,cm_index) = 0.0
189	tt(:,:,:,cm_index) = 0.0
190	qv(:,:,:,cm_index) = 0.0
191	pv(:,:,:,cm_index) = 0.0
192	rho(:,:,:,cm_index) = 0.0
193	drhodz(:,:,:,cm_index) = 0.0
194	tth(:,:,:,cm_index) = 0.0
195	qvh(:,:,:,cm_index) = 0.0
196	pplev(:,:,:,cm_index) = 0.0
197	clouds(:,:,:,cm_index) = 0.0
198	cloudsh(:,:,cm_index) = 0.0
199
200	! 2d fields
201	ps(:,:,:,cm_index) = 0.0
202	sd(:,:,:,cm_index) = 0.0
203	msl(:,:,:,cm_index) = 0.0
204	tcc(:,:,:,cm_index) = 0.0
205	u10(:,:,:,cm_index) = 0.0
206	v10(:,:,:,cm_index) = 0.0
207	tt2(:,:,:,cm_index) = 0.0
208	td2(:,:,:,cm_index) = 0.0
209	lsprec(:,:,:,cm_index) = 0.0
210	convprec(:,:,:,cm_index) = 0.0
211	sshf(:,:,:,cm_index) = 0.0
212	ssr(:,:,:,cm_index) = 0.0
213	surfstr(:,:,:,cm_index) = 0.0
214	ustar(:,:,:,cm_index) = 0.0
215	wstar(:,:,:,cm_index) = 0.0
216	hmix(:,:,:,cm_index) = 0.0
217	tropopause(:,:,:,cm_index) = 0.0
218	oli(:,:,:,cm_index) = 0.0
219	diffk(:,:,:,cm_index) = 0.0
220	vdep(:,:,:,cm_index) = 0.0
221
222	! 1d fields
223	z0(:) = 0.0
224	akm(:) = 0.0
225	bkm(:) = 0.0
226	akz(:) = 0.0
227	bkz(:) = 0.0
228	aknew(:) = 0.0
229	bknew(:) = 0.0
230
231	! Nested, scalar values (for each nest)
232	nxn(:) = 0.0
233	nyn(:) = 0.0
234	dxn(:) = 0.0
235	dyn(:) = 0.0
236	xlon0n(:) = 0.0
237	ylat0n(:) = 0.0
238
239	! Nested fields, static in time
240	oron=0.0; excessoron=0.0; lsmn=0.0; xlandusen=0.0
241
242	! 3d nested fields
243	uun(:,:,:,cm_index,:) = 0.0
244	wwn(:,:,:,cm_index,:) = 0.0
245	ttn(:,:,:,cm_index,:) = 0.0
246	qvn(:,:,:,cm_index,:) = 0.0
247	pvn(:,:,:,cm_index,:) = 0.0
248	cloudsn(:,:,:,cm_index,:) = 0.0
249	cloudsnh(:,:,cm_index,:) = 0.0
250	rhon(:,:,:,cm_index,:) = 0.0
251	drhodzn(:,:,:,cm_index,:) = 0.0
252	tthn(:,:,:,cm_index,:) = 0.0
253	qvhn(:,:,:,cm_index,:) = 0.0
254
255	! 2d nested fields
256	psn(:,:,:,cm_index,:) = 0.0
257	sdn(:,:,:,cm_index,:) = 0.0
258	msln(:,:,:,cm_index,:) = 0.0
259	tccn(:,:,:,cm_index,:) = 0.0
260	u10n(:,:,:,cm_index,:) = 0.0
261	v10n(:,:,:,cm_index,:) = 0.0
262	tt2n(:,:,:,cm_index,:) = 0.0
263	td2n(:,:,:,cm_index,:) = 0.0
264	lsprecn(:,:,:,cm_index,:) = 0.0
265	convprecn(:,:,:,cm_index,:) = 0.0
266	sshfn(:,:,:,cm_index,:) = 0.0
267	ssrn(:,:,:,cm_index,:) = 0.0
268	surfstrn(:,:,:,cm_index,:) = 0.0
269	ustarn(:,:,:,cm_index,:) = 0.0
270	wstarn(:,:,:,cm_index,:) = 0.0
271	hmixn(:,:,:,cm_index,:) = 0.0
272	tropopausen(:,:,:,cm_index,:) = 0.0
273	olin(:,:,:,cm_index,:) = 0.0
274	diffkn(:,:,:,cm_index,:) = 0.0
275	vdepn(:,:,:,cm_index,:) = 0.0
276
277	! Auxiliary variables for nests
278	xresoln(:) = 0.0
279	yresoln(:) = 0.0
280	xln(:) = 0.0
281	yln(:) = 0.0
282	xrn(:) = 0.0
283	yrn(:) = 0.0
284
285	! Variables for polar stereographic projection
286	xglobal=.FALSE.; sglobal=.FALSE.; nglobal=.FALSE.
287	switchnorthg=0.0; switchsouthg=0.0
288	southpolemap(:) = 0.0
289	northpolemap(:) = 0.0
290
291	! Variables declared in conv_mod (convection)
292	pconv(:) = 0.0
293	phconv(:) = 0.0
294	dpr(:) = 0.0
295	pconv_hpa(:) = 0.0
296	phconv_hpa(:) = 0.0
297	ft(:) = 0.0
298	fq(:) = 0.0
299	fmass(:,:) = 0.0
300	sub(:) = 0.0
301	fmassfrac(:,:) = 0.0
302	cbaseflux(:,:) = 0.0
303	cbasefluxn(:,:,:) = 0.0
304	tconv(:) = 0.0
305	qconv(:) = 0.0
306	qsconv(:) = 0.0
307	psconv=0.0; tt2conv=0.0; td2conv=0.0
308	nconvlev=0.0; nconvtop=0.0
309
310	END SUBROUTINE fpmetbinary_zero
311
312	SUBROUTINE fpio(iounit, ncid, op, cm_index)
313	IMPLICIT NONE
314	INTEGER, INTENT(IN) :: ncid ! NetCDF file id
315	INTEGER, INTENT(IN) :: iounit
316	CHARACTER(LEN=4), INTENT(IN) :: op ! Operation - DUMP or LOAD
317	INTEGER, INTENT(IN) :: cm_index ! Index of last dimension in
318	! most com_mod variables.
319	! Should be 1 or 2
320
321
322	! Helper functions (in this module)
323	!INTEGER :: logical2integer
324	!LOGICAL :: integer2logical
325
326	INTEGER :: temp_integer ! temporary value
327	INTEGER :: ncret ! Return value from NetCDF calls
328	INTEGER :: ncvarid ! NetCDF variable ID
329
330	INTEGER :: nxmax_dimid, nymax_dimid, nzmax_dimid, nuvzmax_dimid, nwzmax_dimid, &
331	& maxspec_dimid, numclass_dimid, maxnests_dimid, nxmaxn_dimid, nymaxn_dimid, &
332	& zero_to_nzmax_dimid, zero_to_maxnests_dimid, polemap_dimid, &
333	& nconvlevmax_dimid, na_dimid
334
335
336	INTEGER, DIMENSION(1) :: dim1dids ! Dimension IDs for 1D arrays
337	INTEGER, DIMENSION(2) :: dim2dids ! Dimension IDs for 2D arrays
338	INTEGER, DIMENSION(3) :: dim3dids ! Dimension IDs for 3D arrays
339	INTEGER, DIMENSION(4) :: dim4dids ! Dimension IDs for 4D arrays
340	INTEGER, DIMENSION(5) :: dim5dids ! Dimension IDs for 5D arrays
341
342
343
344
345	! These are used when loading in dimensions from NC file
346	CHARACTER(LEN=NF90_MAX_NAME) :: nxmax_dimname, nymax_dimname, nzmax_dimname, &
347	& nuvzmax_dimname, nwzmax_dimname,&
348	& maxspec_dimname, numclass_dimname,&
349	& maxnests_dimname, nxmaxn_dimname, nymaxn_dimname, &
350	& zero_to_nzmax_dimname, zero_to_maxnests_dimname, &
351	& polemap_dimname, nconvlevmax_dimname, na_dimname
352
353	! These are temporary variables, used in the LOAD option, for
354	! comparing against the current values in FLEXPART of nxmax, nymax, ...
355	INTEGER :: temp_nxmax, temp_nymax, temp_nzmax, &
356	& temp_nuvzmax, temp_nwzmax, &
357	& temp_maxspec, temp_numclass,&
358	& temp_maxnests, temp_nxmaxn, temp_nymaxn
359
360	CHARACTER(LEN=12) :: temp_preproc_format_version_str
361
362	CHARACTER(LEN=128) :: errmesg
363
364	INTEGER, PARAMETER :: DEF_LEVEL = 3
365
366	if (op == 'DUMP') THEN
367
368
369	! Write the preprocessing format version string
370	! NEED TO FILL THIS IN FOR NC4
371
372
373	#ifdef RAWBIN
374	WRITE (iounit) PREPROC_FORMAT_VERSION_STR
375
376	#endif
377
378	! Write the compiled max dimensions from par_mod - these are
379	! not meant to be reassigned during a LOAD, but used as "header"
380	! information to provide the structure of arrays
381
382	#ifdef RAWBIN
383	WRITE (iounit) nxmax, nymax, nzmax, nuvzmax, nwzmax
384	#endif
385
386
387	ncret = nf90_def_dim(ncid, 'nxmax', nxmax, nxmax_dimid)
388	call handle_nf90_err(ncret)
389	ncret = nf90_def_dim(ncid, 'nymax', nymax, nymax_dimid)
390	call handle_nf90_err(ncret)
391	ncret = nf90_def_dim(ncid, 'nzmax', nzmax, nzmax_dimid)
392	call handle_nf90_err(ncret)
393	ncret = nf90_def_dim(ncid, 'nuvzmax', nuvzmax, nuvzmax_dimid)
394	call handle_nf90_err(ncret)
395	ncret = nf90_def_dim(ncid, 'nwzmax', nwzmax, nwzmax_dimid)
396	call handle_nf90_err(ncret)
397	ncret = nf90_def_dim(ncid, 'maxspec', maxspec, maxspec_dimid)
398	call handle_nf90_err(ncret)
399	ncret = nf90_def_dim(ncid, 'numclass', numclass, numclass_dimid)
400	call handle_nf90_err(ncret)
401
402	! There are a handful of variables indexed from 0 to n, rather than 0 to n-1,
403	! so these dimensions handle that. What a pain.
404	ncret = nf90_def_dim(ncid, 'zero_to_nzmax', nzmax+1, zero_to_nzmax_dimid)
405	call handle_nf90_err(ncret)
406	ncret = nf90_def_dim(ncid, 'zero_to_maxnests', maxnests+1, zero_to_maxnests_dimid)
407	call handle_nf90_err(ncret)
408
409	! This is for a couple of small arrays that store polar stereographic stuff
410	ncret = nf90_def_dim(ncid, 'polemap_dim', 9, polemap_dimid)
411	call handle_nf90_err(ncret)
412
413	! These two values come from conv_mod
414	ncret = nf90_def_dim(ncid, 'nconvlevmax_dim', nconvlevmax, nconvlevmax_dimid)
415	call handle_nf90_err(ncret)
416	ncret = nf90_def_dim(ncid, 'na_dim', na, na_dimid)
417	call handle_nf90_err(ncret)
418
419	! Scalar values
420
421
422	#ifdef RAWBIN
423	WRITE(iounit) nx, ny, nxmin1, nymin1, nxfield
424	WRITE(iounit) nuvz, nwz, nz, nmixz, nlev_ec
425	WRITE(iounit) dx, dy, xlon0, ylat0, dxconst, dyconst
426	#endif
427
428	ncret = nf90_def_var(ncid, 'nx', NF90_INT, ncvarid)
429	call handle_nf90_err(ncret)
430	ncret = nf90_put_var(ncid, ncvarid, nx)
431	call handle_nf90_err(ncret)
432
433	ncret = nf90_def_var(ncid, 'ny', NF90_INT, ncvarid)
434	call handle_nf90_err(ncret)
435	ncret = nf90_put_var(ncid, ncvarid, ny)
436	call handle_nf90_err(ncret)
437
438	ncret = nf90_def_var(ncid, 'nxmin1', NF90_INT, ncvarid)
439	call handle_nf90_err(ncret)
440	ncret = nf90_put_var(ncid, ncvarid, nxmin1)
441	call handle_nf90_err(ncret)
442
443	ncret = nf90_def_var(ncid, 'nymin1', NF90_INT, ncvarid)
444	call handle_nf90_err(ncret)
445	ncret = nf90_put_var(ncid, ncvarid, nymin1)
446	call handle_nf90_err(ncret)
447
448	ncret = nf90_def_var(ncid, 'nxfield', NF90_INT, ncvarid)
449	call handle_nf90_err(ncret)
450	ncret = nf90_put_var(ncid, ncvarid, nxfield)
451	call handle_nf90_err(ncret)
452
453	ncret = nf90_def_var(ncid, 'nuvz', NF90_INT, ncvarid)
454	call handle_nf90_err(ncret)
455	ncret = nf90_put_var(ncid, ncvarid, nuvz)
456	call handle_nf90_err(ncret)
457
458	ncret = nf90_def_var(ncid, 'nwz', NF90_INT, ncvarid)
459	call handle_nf90_err(ncret)
460	ncret = nf90_put_var(ncid, ncvarid, nwz)
461	call handle_nf90_err(ncret)
462
463	ncret = nf90_def_var(ncid, 'nz', NF90_INT, ncvarid)
464	call handle_nf90_err(ncret)
465	ncret = nf90_put_var(ncid, ncvarid, nz)
466	call handle_nf90_err(ncret)
467
468	ncret = nf90_def_var(ncid, 'nmixz', NF90_INT, ncvarid)
469	call handle_nf90_err(ncret)
470	ncret = nf90_put_var(ncid, ncvarid, nmixz)
471	call handle_nf90_err(ncret)
472
473	ncret = nf90_def_var(ncid, 'nlev_ec', NF90_INT, ncvarid)
474	call handle_nf90_err(ncret)
475	ncret = nf90_put_var(ncid, ncvarid, nlev_ec)
476	call handle_nf90_err(ncret)
477
478	ncret = nf90_def_var(ncid, 'dx', NF90_FLOAT, ncvarid)
479	call handle_nf90_err(ncret)
480	ncret = nf90_put_var(ncid, ncvarid, dx)
481	call handle_nf90_err(ncret)
482
483	ncret = nf90_def_var(ncid, 'dy', NF90_FLOAT, ncvarid)
484	call handle_nf90_err(ncret)
485	ncret = nf90_put_var(ncid, ncvarid, dy)
486	call handle_nf90_err(ncret)
487
488	ncret = nf90_def_var(ncid, 'xlon0', NF90_FLOAT, ncvarid)
489	call handle_nf90_err(ncret)
490	ncret = nf90_put_var(ncid, ncvarid, xlon0)
491	call handle_nf90_err(ncret)
492
493	ncret = nf90_def_var(ncid, 'ylat0', NF90_FLOAT, ncvarid)
494	call handle_nf90_err(ncret)
495	ncret = nf90_put_var(ncid, ncvarid, ylat0)
496	call handle_nf90_err(ncret)
497
498	ncret = nf90_def_var(ncid, 'dxconst', NF90_FLOAT, ncvarid)
499	call handle_nf90_err(ncret)
500	ncret = nf90_put_var(ncid, ncvarid, dxconst)
501	call handle_nf90_err(ncret)
502
503	ncret = nf90_def_var(ncid, 'dyconst', NF90_FLOAT, ncvarid)
504	call handle_nf90_err(ncret)
505	ncret = nf90_put_var(ncid, ncvarid, dyconst)
506	call handle_nf90_err(ncret)
507
508
509
510	! Fixed fields, static in time
511
512
513	#ifdef RAWBIN
514	WRITE(iounit) oro, excessoro, lsm, xlanduse, height
515	#endif
516
517	dim2dids = (/nxmax_dimid, nymax_dimid/)
518
519	ncret = nf90_def_var(ncid, 'oro', NF90_FLOAT, &
520	& dim2dids, ncvarid)
521	call handle_nf90_err(ncret)
522	ncret = nf90_def_var_deflate(ncid, ncvarid, &
523	& shuffle=0, &
524	& deflate=1, &
525	& deflate_level=DEF_LEVEL)
526	call handle_nf90_err(ncret)
527	ncret = nf90_put_var(ncid, ncvarid, &
528	& oro(0:nxmax-1, 0:nymax-1))
529	call handle_nf90_err(ncret)
530
531	ncret = nf90_def_var(ncid, 'excessoro', NF90_FLOAT, &
532	& dim2dids, ncvarid)
533	call handle_nf90_err(ncret)
534	ncret = nf90_def_var_deflate(ncid, ncvarid, &
535	& shuffle=0, &
536	& deflate=1, &
537	& deflate_level=DEF_LEVEL)
538	call handle_nf90_err(ncret)
539	ncret = nf90_put_var(ncid, ncvarid, &
540	& excessoro(0:nxmax-1, 0:nymax-1))
541	call handle_nf90_err(ncret)
542
543	ncret = nf90_def_var(ncid, 'lsm', NF90_FLOAT, &
544	& dim2dids, ncvarid)
545	call handle_nf90_err(ncret)
546	ncret = nf90_def_var_deflate(ncid, ncvarid, &
547	& shuffle=0, &
548	& deflate=1, &
549	& deflate_level=DEF_LEVEL)
550	call handle_nf90_err(ncret)
551	ncret = nf90_put_var(ncid, ncvarid, &
552	& lsm(0:nxmax-1, 0:nymax-1))
553	call handle_nf90_err(ncret)
554
555	dim3dids = (/nxmax_dimid, nymax_dimid, numclass_dimid/)
556	! numclass comes from par_mod - number of land use classes
557	ncret = nf90_def_var(ncid, 'xlanduse', NF90_FLOAT, &
558	& dim3dids, ncvarid)
559	call handle_nf90_err(ncret)
560	ncret = nf90_def_var_deflate(ncid, ncvarid, &
561	& shuffle=0, &
562	& deflate=1, &
563	& deflate_level=DEF_LEVEL)
564	call handle_nf90_err(ncret)
565	ncret = nf90_put_var(ncid, ncvarid, &
566	& xlanduse(0:nxmax-1, 0:nymax-1, 1:numclass))
567	call handle_nf90_err(ncret)
568
569	dim1dids = (/nzmax_dimid/)
570	ncret = nf90_def_var(ncid, 'height', NF90_FLOAT, &
571	& dim1dids, ncvarid)
572	call handle_nf90_err(ncret)
573	ncret = nf90_def_var_deflate(ncid, ncvarid, &
574	& shuffle=0, &
575	& deflate=1, &
576	& deflate_level=DEF_LEVEL)
577	call handle_nf90_err(ncret)
578	ncret = nf90_put_var(ncid, ncvarid, &
579	& height(1:nzmax))
580	call handle_nf90_err(ncret)
581
582
583
584
585	! 3d fields
586
587
588
589	#ifdef RAWBIN
590	WRITE(iounit) uu(:,:,:,cm_index)
591	WRITE(iounit) vv(:,:,:,cm_index)
592	WRITE(iounit) uupol(:,:,:,cm_index)
593	WRITE(iounit) vvpol(:,:,:,cm_index)
594	WRITE(iounit) ww(:,:,:,cm_index)
595	WRITE(iounit) tt(:,:,:,cm_index)
596	WRITE(iounit) qv(:,:,:,cm_index)
597	WRITE(iounit) pv(:,:,:,cm_index)
598	WRITE(iounit) rho(:,:,:,cm_index)
599	WRITE(iounit) drhodz(:,:,:,cm_index)
600	WRITE(iounit) tth(:,:,:,cm_index)
601	WRITE(iounit) qvh(:,:,:,cm_index)
602	WRITE(iounit) pplev(:,:,:,cm_index)
603	WRITE(iounit) clouds(:,:,:,cm_index)
604	WRITE(iounit) cloudsh(:,:,cm_index)
605	#endif
606
607
608
609	dim3dids = (/nxmax_dimid, nymax_dimid, nzmax_dimid/)
610
611	ncret = nf90_def_var(ncid, 'uu', NF90_FLOAT, &
612	& dim3dids, ncvarid)
613	call handle_nf90_err(ncret)
614	ncret = nf90_def_var_deflate(ncid, ncvarid, &
615	& shuffle=0, &
616	& deflate=1, &
617	& deflate_level=DEF_LEVEL)
618	call handle_nf90_err(ncret)
619	ncret = nf90_put_var(ncid, ncvarid, &
620	& uu(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
621	call handle_nf90_err(ncret)
622
623	ncret = nf90_def_var(ncid, 'vv', NF90_FLOAT, &
624	& dim3dids, ncvarid)
625	call handle_nf90_err(ncret)
626	ncret = nf90_def_var_deflate(ncid, ncvarid, &
627	& shuffle=0, &
628	& deflate=1, &
629	& deflate_level=DEF_LEVEL)
630	call handle_nf90_err(ncret)
631	ncret = nf90_put_var(ncid, ncvarid, &
632	& vv(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
633	call handle_nf90_err(ncret)
634
635	ncret = nf90_def_var(ncid, 'uupol', NF90_FLOAT, &
636	& dim3dids, ncvarid)
637	call handle_nf90_err(ncret)
638	ncret = nf90_def_var_deflate(ncid, ncvarid, &
639	& shuffle=0, &
640	& deflate=1, &
641	& deflate_level=DEF_LEVEL)
642	call handle_nf90_err(ncret)
643	ncret = nf90_put_var(ncid, ncvarid, &
644	& uupol(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
645	call handle_nf90_err(ncret)
646
647	ncret = nf90_def_var(ncid, 'vvpol', NF90_FLOAT, &
648	& dim3dids, ncvarid)
649	call handle_nf90_err(ncret)
650	ncret = nf90_def_var_deflate(ncid, ncvarid, &
651	& shuffle=0, &
652	& deflate=1, &
653	& deflate_level=DEF_LEVEL)
654	call handle_nf90_err(ncret)
655	ncret = nf90_put_var(ncid, ncvarid, &
656	& vvpol(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
657	call handle_nf90_err(ncret)
658
659	ncret = nf90_def_var(ncid, 'ww', NF90_FLOAT, &
660	& dim3dids, ncvarid)
661	call handle_nf90_err(ncret)
662	ncret = nf90_def_var_deflate(ncid, ncvarid, &
663	& shuffle=0, &
664	& deflate=1, &
665	& deflate_level=DEF_LEVEL)
666	call handle_nf90_err(ncret)
667	ncret = nf90_put_var(ncid, ncvarid, &
668	& ww(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
669	call handle_nf90_err(ncret)
670
671	ncret = nf90_def_var(ncid, 'tt', NF90_FLOAT, &
672	& dim3dids, ncvarid)
673	call handle_nf90_err(ncret)
674	ncret = nf90_def_var_deflate(ncid, ncvarid, &
675	& shuffle=0, &
676	& deflate=1, &
677	& deflate_level=DEF_LEVEL)
678	call handle_nf90_err(ncret)
679	ncret = nf90_put_var(ncid, ncvarid, &
680	& tt(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
681	call handle_nf90_err(ncret)
682
683	ncret = nf90_def_var(ncid, 'qv', NF90_FLOAT, &
684	& dim3dids, ncvarid)
685	call handle_nf90_err(ncret)
686	ncret = nf90_def_var_deflate(ncid, ncvarid, &
687	& shuffle=0, &
688	& deflate=1, &
689	& deflate_level=DEF_LEVEL)
690	call handle_nf90_err(ncret)
691	ncret = nf90_put_var(ncid, ncvarid, &
692	& qv(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
693	call handle_nf90_err(ncret)
694
695	ncret = nf90_def_var(ncid, 'pv', NF90_FLOAT, &
696	& dim3dids, ncvarid)
697	call handle_nf90_err(ncret)
698	ncret = nf90_def_var_deflate(ncid, ncvarid, &
699	& shuffle=0, &
700	& deflate=1, &
701	& deflate_level=DEF_LEVEL)
702	call handle_nf90_err(ncret)
703	ncret = nf90_put_var(ncid, ncvarid, &
704	& pv(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
705	call handle_nf90_err(ncret)
706
707	ncret = nf90_def_var(ncid, 'rho', NF90_FLOAT, &
708	& dim3dids, ncvarid)
709	call handle_nf90_err(ncret)
710	ncret = nf90_def_var_deflate(ncid, ncvarid, &
711	& shuffle=0, &
712	& deflate=1, &
713	& deflate_level=DEF_LEVEL)
714	call handle_nf90_err(ncret)
715	ncret = nf90_put_var(ncid, ncvarid, &
716	& rho(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
717	call handle_nf90_err(ncret)
718
719	ncret = nf90_def_var(ncid, 'drhodz', NF90_FLOAT, &
720	& dim3dids, ncvarid)
721	call handle_nf90_err(ncret)
722	ncret = nf90_def_var_deflate(ncid, ncvarid, &
723	& shuffle=0, &
724	& deflate=1, &
725	& deflate_level=DEF_LEVEL)
726	call handle_nf90_err(ncret)
727	ncret = nf90_put_var(ncid, ncvarid, &
728	& drhodz(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
729	call handle_nf90_err(ncret)
730
731	ncret = nf90_def_var(ncid, 'clouds', NF90_BYTE, &
732	& dim3dids, ncvarid)
733	call handle_nf90_err(ncret)
734	ncret = nf90_def_var_deflate(ncid, ncvarid, &
735	& shuffle=0, &
736	& deflate=1, &
737	& deflate_level=DEF_LEVEL)
738	call handle_nf90_err(ncret)
739	ncret = nf90_put_var(ncid, ncvarid, &
740	& clouds(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index))
741	call handle_nf90_err(ncret)
742
743
744
745	! Note the change in z dimension for the following
746	dim3dids = (/nxmax_dimid, nymax_dimid, nuvzmax_dimid/)
747
748	ncret = nf90_def_var(ncid, 'tth', NF90_FLOAT, &
749	& dim3dids, ncvarid)
750	call handle_nf90_err(ncret)
751	ncret = nf90_def_var_deflate(ncid, ncvarid, &
752	& shuffle=0, &
753	& deflate=1, &
754	& deflate_level=DEF_LEVEL)
755	call handle_nf90_err(ncret)
756	ncret = nf90_put_var(ncid, ncvarid, &
757	& tth(0:nxmax-1, 0:nymax-1, 1:nuvzmax, cm_index))
758	call handle_nf90_err(ncret)
759
760	ncret = nf90_def_var(ncid, 'qvh', NF90_FLOAT, &
761	& dim3dids, ncvarid)
762	call handle_nf90_err(ncret)
763	ncret = nf90_def_var_deflate(ncid, ncvarid, &
764	& shuffle=0, &
765	& deflate=1, &
766	& deflate_level=DEF_LEVEL)
767	call handle_nf90_err(ncret)
768	ncret = nf90_put_var(ncid, ncvarid, &
769	& qvh(0:nxmax-1, 0:nymax-1, 1:nuvzmax, cm_index))
770	call handle_nf90_err(ncret)
771
772	ncret = nf90_def_var(ncid, 'pplev', NF90_FLOAT, &
773	& dim3dids, ncvarid)
774	call handle_nf90_err(ncret)
775	ncret = nf90_def_var_deflate(ncid, ncvarid, &
776	& shuffle=0, &
777	& deflate=1, &
778	& deflate_level=DEF_LEVEL)
779	call handle_nf90_err(ncret)
780	ncret = nf90_put_var(ncid, ncvarid, &
781	& pplev(0:nxmax-1, 0:nymax-1, 1:nuvzmax, cm_index))
782	call handle_nf90_err(ncret)
783
784
785	dim2dids = (/nxmax_dimid, nymax_dimid/)
786	ncret = nf90_def_var(ncid, 'cloudsh', NF90_INT, &
787	& dim2dids, ncvarid)
788	call handle_nf90_err(ncret)
789	ncret = nf90_def_var_deflate(ncid, ncvarid, &
790	& shuffle=0, &
791	& deflate=1, &
792	& deflate_level=DEF_LEVEL)
793	call handle_nf90_err(ncret)
794	ncret = nf90_put_var(ncid, ncvarid, &
795	& cloudsh(0:nxmax-1, 0:nymax-1, cm_index))
796	call handle_nf90_err(ncret)
797
798
799
800	PRINT *, 'SUM(tt(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index)): ', &
801	& SUM(tt(0:nxmax-1,0:nymax-1,1:nzmax, cm_index))
802
803	PRINT *, 'SUM(clouds(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index)): ', &
804	& SUM(clouds(0:nxmax-1,0:nymax-1,1:nzmax, cm_index))
805
806
807
808	! 2d fields
809
810
811	#ifdef RAWBIN
812	WRITE(iounit) ps(:,:,:,cm_index)
813	WRITE(iounit) sd(:,:,:,cm_index)
814	WRITE(iounit) msl(:,:,:,cm_index)
815	WRITE(iounit) tcc(:,:,:,cm_index)
816	WRITE(iounit) u10(:,:,:,cm_index)
817	WRITE(iounit) v10(:,:,:,cm_index)
818	WRITE(iounit) tt2(:,:,:,cm_index)
819	WRITE(iounit) td2(:,:,:,cm_index)
820	WRITE(iounit) lsprec(:,:,:,cm_index)
821	WRITE(iounit) convprec(:,:,:,cm_index)
822	WRITE(iounit) sshf(:,:,:,cm_index)
823	WRITE(iounit) ssr(:,:,:,cm_index)
824	WRITE(iounit) surfstr(:,:,:,cm_index)
825	WRITE(iounit) ustar(:,:,:,cm_index)
826	WRITE(iounit) wstar(:,:,:,cm_index)
827	WRITE(iounit) hmix(:,:,:,cm_index)
828	WRITE(iounit) tropopause(:,:,:,cm_index)
829	WRITE(iounit) oli(:,:,:,cm_index)
830	WRITE(iounit) diffk(:,:,:,cm_index)
831	WRITE(iounit) vdep(:,:,:,cm_index)
832	#endif
833
834
835
836	dim2dids = (/nxmax_dimid, nymax_dimid/)
837
838	ncret = nf90_def_var(ncid, 'ps', NF90_FLOAT, &
839	& dim2dids, ncvarid)
840	call handle_nf90_err(ncret)
841	ncret = nf90_def_var_deflate(ncid, ncvarid, &
842	& shuffle=0, &
843	& deflate=1, &
844	& deflate_level=DEF_LEVEL)
845	call handle_nf90_err(ncret)
846	ncret = nf90_put_var(ncid, ncvarid, &
847	& ps(0:nxmax-1, 0:nymax-1, 1, cm_index))
848	call handle_nf90_err(ncret)
849
850	ncret = nf90_def_var(ncid, 'sd', NF90_FLOAT, &
851	& dim2dids, ncvarid)
852	call handle_nf90_err(ncret)
853	ncret = nf90_def_var_deflate(ncid, ncvarid, &
854	& shuffle=0, &
855	& deflate=1, &
856	& deflate_level=DEF_LEVEL)
857	call handle_nf90_err(ncret)
858	ncret = nf90_put_var(ncid, ncvarid, &
859	& sd(0:nxmax-1, 0:nymax-1, 1, cm_index))
860	call handle_nf90_err(ncret)
861
862	ncret = nf90_def_var(ncid, 'msl', NF90_FLOAT, &
863	& dim2dids, ncvarid)
864	call handle_nf90_err(ncret)
865	ncret = nf90_def_var_deflate(ncid, ncvarid, &
866	& shuffle=0, &
867	& deflate=1, &
868	& deflate_level=DEF_LEVEL)
869	call handle_nf90_err(ncret)
870	ncret = nf90_put_var(ncid, ncvarid, &
871	& msl(0:nxmax-1, 0:nymax-1, 1, cm_index))
872	call handle_nf90_err(ncret)
873
874	ncret = nf90_def_var(ncid, 'tcc', NF90_FLOAT, &
875	& dim2dids, ncvarid)
876	call handle_nf90_err(ncret)
877	ncret = nf90_def_var_deflate(ncid, ncvarid, &
878	& shuffle=0, &
879	& deflate=1, &
880	& deflate_level=DEF_LEVEL)
881	call handle_nf90_err(ncret)
882	ncret = nf90_put_var(ncid, ncvarid, &
883	& tcc(0:nxmax-1, 0:nymax-1, 1, cm_index))
884	call handle_nf90_err(ncret)
885
886	ncret = nf90_def_var(ncid, 'u10', NF90_FLOAT, &
887	& dim2dids, ncvarid)
888	call handle_nf90_err(ncret)
889	ncret = nf90_def_var_deflate(ncid, ncvarid, &
890	& shuffle=0, &
891	& deflate=1, &
892	& deflate_level=DEF_LEVEL)
893	call handle_nf90_err(ncret)
894	ncret = nf90_put_var(ncid, ncvarid, &
895	& u10(0:nxmax-1, 0:nymax-1, 1, cm_index))
896	call handle_nf90_err(ncret)
897
898	ncret = nf90_def_var(ncid, 'v10', NF90_FLOAT, &
899	& dim2dids, ncvarid)
900	call handle_nf90_err(ncret)
901	ncret = nf90_def_var_deflate(ncid, ncvarid, &
902	& shuffle=0, &
903	& deflate=1, &
904	& deflate_level=DEF_LEVEL)
905	call handle_nf90_err(ncret)
906	ncret = nf90_put_var(ncid, ncvarid, &
907	& v10(0:nxmax-1, 0:nymax-1, 1, cm_index))
908	call handle_nf90_err(ncret)
909
910	ncret = nf90_def_var(ncid, 'tt2', NF90_FLOAT, &
911	& dim2dids, ncvarid)
912	call handle_nf90_err(ncret)
913	ncret = nf90_def_var_deflate(ncid, ncvarid, &
914	& shuffle=0, &
915	& deflate=1, &
916	& deflate_level=DEF_LEVEL)
917	call handle_nf90_err(ncret)
918	ncret = nf90_put_var(ncid, ncvarid, &
919	& tt2(0:nxmax-1, 0:nymax-1, 1, cm_index))
920	call handle_nf90_err(ncret)
921
922	ncret = nf90_def_var(ncid, 'td2', NF90_FLOAT, &
923	& dim2dids, ncvarid)
924	call handle_nf90_err(ncret)
925	ncret = nf90_def_var_deflate(ncid, ncvarid, &
926	& shuffle=0, &
927	& deflate=1, &
928	& deflate_level=DEF_LEVEL)
929	call handle_nf90_err(ncret)
930	ncret = nf90_put_var(ncid, ncvarid, &
931	& td2(0:nxmax-1, 0:nymax-1, 1, cm_index))
932	call handle_nf90_err(ncret)
933
934	ncret = nf90_def_var(ncid, 'lsprec', NF90_FLOAT, &
935	& dim2dids, ncvarid)
936	call handle_nf90_err(ncret)
937	ncret = nf90_def_var_deflate(ncid, ncvarid, &
938	& shuffle=0, &
939	& deflate=1, &
940	& deflate_level=DEF_LEVEL)
941	call handle_nf90_err(ncret)
942	ncret = nf90_put_var(ncid, ncvarid, &
943	& lsprec(0:nxmax-1, 0:nymax-1, 1, cm_index))
944	call handle_nf90_err(ncret)
945
946	ncret = nf90_def_var(ncid, 'convprec', NF90_FLOAT, &
947	& dim2dids, ncvarid)
948	call handle_nf90_err(ncret)
949	ncret = nf90_def_var_deflate(ncid, ncvarid, &
950	& shuffle=0, &
951	& deflate=1, &
952	& deflate_level=DEF_LEVEL)
953	call handle_nf90_err(ncret)
954	ncret = nf90_put_var(ncid, ncvarid, &
955	& convprec(0:nxmax-1, 0:nymax-1, 1, cm_index))
956	call handle_nf90_err(ncret)
957
958	ncret = nf90_def_var(ncid, 'sshf', NF90_FLOAT, &
959	& dim2dids, ncvarid)
960	call handle_nf90_err(ncret)
961	ncret = nf90_def_var_deflate(ncid, ncvarid, &
962	& shuffle=0, &
963	& deflate=1, &
964	& deflate_level=DEF_LEVEL)
965	call handle_nf90_err(ncret)
966	ncret = nf90_put_var(ncid, ncvarid, &
967	& sshf(0:nxmax-1, 0:nymax-1, 1, cm_index))
968	call handle_nf90_err(ncret)
969
970	ncret = nf90_def_var(ncid, 'ssr', NF90_FLOAT, &
971	& dim2dids, ncvarid)
972	call handle_nf90_err(ncret)
973	ncret = nf90_def_var_deflate(ncid, ncvarid, &
974	& shuffle=0, &
975	& deflate=1, &
976	& deflate_level=DEF_LEVEL)
977	call handle_nf90_err(ncret)
978	ncret = nf90_put_var(ncid, ncvarid, &
979	& ssr(0:nxmax-1, 0:nymax-1, 1, cm_index))
980	call handle_nf90_err(ncret)
981
982	ncret = nf90_def_var(ncid, 'surfstr', NF90_FLOAT, &
983	& dim2dids, ncvarid)
984	call handle_nf90_err(ncret)
985	ncret = nf90_def_var_deflate(ncid, ncvarid, &
986	& shuffle=0, &
987	& deflate=1, &
988	& deflate_level=DEF_LEVEL)
989	call handle_nf90_err(ncret)
990	ncret = nf90_put_var(ncid, ncvarid, &
991	& surfstr(0:nxmax-1, 0:nymax-1, 1, cm_index))
992	call handle_nf90_err(ncret)
993
994	ncret = nf90_def_var(ncid, 'ustar', NF90_FLOAT, &
995	& dim2dids, ncvarid)
996	call handle_nf90_err(ncret)
997	ncret = nf90_def_var_deflate(ncid, ncvarid, &
998	& shuffle=0, &
999	& deflate=1, &
1000	& deflate_level=DEF_LEVEL)
1001	call handle_nf90_err(ncret)
1002	ncret = nf90_put_var(ncid, ncvarid, &
1003	& ustar(0:nxmax-1, 0:nymax-1, 1, cm_index))
1004	call handle_nf90_err(ncret)
1005
1006	ncret = nf90_def_var(ncid, 'wstar', NF90_FLOAT, &
1007	& dim2dids, ncvarid)
1008	call handle_nf90_err(ncret)
1009	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1010	& shuffle=0, &
1011	& deflate=1, &
1012	& deflate_level=DEF_LEVEL)
1013	call handle_nf90_err(ncret)
1014	ncret = nf90_put_var(ncid, ncvarid, &
1015	& wstar(0:nxmax-1, 0:nymax-1, 1, cm_index))
1016	call handle_nf90_err(ncret)
1017
1018	ncret = nf90_def_var(ncid, 'hmix', NF90_FLOAT, &
1019	& dim2dids, ncvarid)
1020	call handle_nf90_err(ncret)
1021	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1022	& shuffle=0, &
1023	& deflate=1, &
1024	& deflate_level=DEF_LEVEL)
1025	call handle_nf90_err(ncret)
1026	ncret = nf90_put_var(ncid, ncvarid, &
1027	& hmix(0:nxmax-1, 0:nymax-1, 1, cm_index))
1028	call handle_nf90_err(ncret)
1029
1030	ncret = nf90_def_var(ncid, 'tropopause', NF90_FLOAT, &
1031	& dim2dids, ncvarid)
1032	call handle_nf90_err(ncret)
1033	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1034	& shuffle=0, &
1035	& deflate=1, &
1036	& deflate_level=DEF_LEVEL)
1037	call handle_nf90_err(ncret)
1038	ncret = nf90_put_var(ncid, ncvarid, &
1039	& tropopause(0:nxmax-1, 0:nymax-1, 1, cm_index))
1040	call handle_nf90_err(ncret)
1041
1042	ncret = nf90_def_var(ncid, 'oli', NF90_FLOAT, &
1043	& dim2dids, ncvarid)
1044	call handle_nf90_err(ncret)
1045	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1046	& shuffle=0, &
1047	& deflate=1, &
1048	& deflate_level=DEF_LEVEL)
1049	call handle_nf90_err(ncret)
1050	ncret = nf90_put_var(ncid, ncvarid, &
1051	& oli(0:nxmax-1, 0:nymax-1, 1, cm_index))
1052	call handle_nf90_err(ncret)
1053
1054	ncret = nf90_def_var(ncid, 'diffk', NF90_FLOAT, &
1055	& dim2dids, ncvarid)
1056	call handle_nf90_err(ncret)
1057	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1058	& shuffle=0, &
1059	& deflate=1, &
1060	& deflate_level=DEF_LEVEL)
1061	call handle_nf90_err(ncret)
1062	ncret = nf90_put_var(ncid, ncvarid, &
1063	& diffk(0:nxmax-1, 0:nymax-1, 1, cm_index))
1064	call handle_nf90_err(ncret)
1065
1066
1067
1068	PRINT *, 'SUM(ps(0:nxmax-1, 0:nymax-1, 1, cm_index)): ', &
1069	& SUM(ps(0:nxmax-1,0:nymax-1,1, cm_index))
1070
1071	PRINT *, 'SUM(wstar(0:nxmax-1, 0:nymax-1, 1, cm_index)): ', &
1072	& SUM(wstar(0:nxmax-1,0:nymax-1,1, cm_index))
1073
1074
1075	dim3dids = (/nxmax_dimid, nymax_dimid, maxspec_dimid/)
1076
1077	ncret = nf90_def_var(ncid, 'vdep', NF90_FLOAT, &
1078	& dim3dids, ncvarid)
1079	call handle_nf90_err(ncret)
1080	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1081	& shuffle=0, &
1082	& deflate=1, &
1083	& deflate_level=DEF_LEVEL)
1084	call handle_nf90_err(ncret)
1085	ncret = nf90_put_var(ncid, ncvarid, &
1086	& vdep(0:nxmax-1, 0:nymax-1, 1:maxspec, cm_index))
1087	call handle_nf90_err(ncret)
1088
1089
1090
1091	! 1d fields
1092
1093
1094
1095	#ifdef RAWBIN
1096	WRITE(iounit) z0(:)
1097	WRITE(iounit) akm(:)
1098	WRITE(iounit) bkm(:)
1099	WRITE(iounit) akz(:)
1100	WRITE(iounit) bkz(:)
1101	WRITE(iounit) aknew(:)
1102	WRITE(iounit) bknew(:)
1103	#endif
1104
1105	dim1dids = (/numclass_dimid/)
1106
1107	ncret = nf90_def_var(ncid, 'z0', NF90_FLOAT, &
1108	& dim1dids, ncvarid)
1109	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1110	& shuffle=0, &
1111	& deflate=1, &
1112	& deflate_level=DEF_LEVEL)
1113	ncret = nf90_put_var(ncid, ncvarid, &
1114	& z0(1:numclass))
1115
1116
1117	dim1dids = (/nwzmax_dimid/)
1118
1119	ncret = nf90_def_var(ncid, 'akm', NF90_FLOAT, &
1120	& dim1dids, ncvarid)
1121	call handle_nf90_err(ncret)
1122	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1123	& shuffle=0, &
1124	& deflate=1, &
1125	& deflate_level=DEF_LEVEL)
1126	call handle_nf90_err(ncret)
1127	ncret = nf90_put_var(ncid, ncvarid, &
1128	& akm(1:nwzmax))
1129	call handle_nf90_err(ncret)
1130
1131	ncret = nf90_def_var(ncid, 'bkm', NF90_FLOAT, &
1132	& dim1dids, ncvarid)
1133	call handle_nf90_err(ncret)
1134	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1135	& shuffle=0, &
1136	& deflate=1, &
1137	& deflate_level=DEF_LEVEL)
1138	call handle_nf90_err(ncret)
1139	ncret = nf90_put_var(ncid, ncvarid, &
1140	& bkm(1:nwzmax))
1141	call handle_nf90_err(ncret)
1142
1143
1144	dim1dids = (/nuvzmax_dimid/)
1145
1146	ncret = nf90_def_var(ncid, 'akz', NF90_FLOAT, &
1147	& dim1dids, ncvarid)
1148	call handle_nf90_err(ncret)
1149	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1150	& shuffle=0, &
1151	& deflate=1, &
1152	& deflate_level=DEF_LEVEL)
1153	call handle_nf90_err(ncret)
1154	ncret = nf90_put_var(ncid, ncvarid, &
1155	& akz(1:nuvzmax))
1156	call handle_nf90_err(ncret)
1157
1158	ncret = nf90_def_var(ncid, 'bkz', NF90_FLOAT, &
1159	& dim1dids, ncvarid)
1160	call handle_nf90_err(ncret)
1161	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1162	& shuffle=0, &
1163	& deflate=1, &
1164	& deflate_level=DEF_LEVEL)
1165	call handle_nf90_err(ncret)
1166	ncret = nf90_put_var(ncid, ncvarid, &
1167	& bkz(1:nuvzmax))
1168	call handle_nf90_err(ncret)
1169
1170
1171	dim1dids = (/nzmax_dimid/)
1172
1173	ncret = nf90_def_var(ncid, 'aknew', NF90_FLOAT, &
1174	& dim1dids, ncvarid)
1175	call handle_nf90_err(ncret)
1176	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1177	& shuffle=0, &
1178	& deflate=1, &
1179	& deflate_level=DEF_LEVEL)
1180	call handle_nf90_err(ncret)
1181	ncret = nf90_put_var(ncid, ncvarid, &
1182	& aknew(1:nzmax))
1183	call handle_nf90_err(ncret)
1184
1185	ncret = nf90_def_var(ncid, 'bknew', NF90_FLOAT, &
1186	& dim1dids, ncvarid)
1187	call handle_nf90_err(ncret)
1188	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1189	& shuffle=0, &
1190	& deflate=1, &
1191	& deflate_level=DEF_LEVEL)
1192	call handle_nf90_err(ncret)
1193	ncret = nf90_put_var(ncid, ncvarid, &
1194	& bknew(1:nzmax))
1195	call handle_nf90_err(ncret)
1196
1197
1198	PRINT *, 'SUM(bknew(1:nzmax)): ', &
1199	& SUM(bknew(1:nzmax))
1200
1201
1202
1203	! Getting ready to add in nested code
1204
1205	! These are compiled max dimensions from par_mod - these are
1206	! not meant to be reassigned during a LOAD, but used as "header"
1207	! information to provide the structure of arrays
1208	ncret = nf90_def_dim(ncid, 'maxnests', maxnests, maxnests_dimid)
1209	call handle_nf90_err(ncret)
1210	ncret = nf90_def_dim(ncid, 'nxmaxn', nxmaxn, nxmaxn_dimid)
1211	call handle_nf90_err(ncret)
1212	ncret = nf90_def_dim(ncid, 'nymaxn', nymaxn, nymaxn_dimid)
1213	call handle_nf90_err(ncret)
1214
1215
1216	#ifdef RAWBIN
1217	WRITE(iounit) nxn(:)
1218	WRITE(iounit) nyn(:)
1219	WRITE(iounit) dxn(:)
1220	WRITE(iounit) dyn(:)
1221	WRITE(iounit) xlon0n(:)
1222	WRITE(iounit) ylat0n(:)
1223	#endif
1224
1225	! Nested, scalar values (for each nest)
1226
1227	dim1dids = (/maxnests_dimid/)
1228
1229	ncret = nf90_def_var(ncid, 'nxn', NF90_INT, &
1230	& dim1dids, ncvarid)
1231	call handle_nf90_err(ncret)
1232	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1233	& shuffle=0, &
1234	& deflate=1, &
1235	& deflate_level=DEF_LEVEL)
1236	call handle_nf90_err(ncret)
1237	ncret = nf90_put_var(ncid, ncvarid, &
1238	& nxn(1:maxnests))
1239	call handle_nf90_err(ncret)
1240
1241	ncret = nf90_def_var(ncid, 'nyn', NF90_INT, &
1242	& dim1dids, ncvarid)
1243	call handle_nf90_err(ncret)
1244	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1245	& shuffle=0, &
1246	& deflate=1, &
1247	& deflate_level=DEF_LEVEL)
1248	call handle_nf90_err(ncret)
1249	ncret = nf90_put_var(ncid, ncvarid, &
1250	& nyn(1:maxnests))
1251	call handle_nf90_err(ncret)
1252
1253	ncret = nf90_def_var(ncid, 'dxn', NF90_FLOAT, &
1254	& dim1dids, ncvarid)
1255	call handle_nf90_err(ncret)
1256	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1257	& shuffle=0, &
1258	& deflate=1, &
1259	& deflate_level=DEF_LEVEL)
1260	call handle_nf90_err(ncret)
1261	ncret = nf90_put_var(ncid, ncvarid, &
1262	& dxn(1:maxnests))
1263	call handle_nf90_err(ncret)
1264
1265	ncret = nf90_def_var(ncid, 'dyn', NF90_FLOAT, &
1266	& dim1dids, ncvarid)
1267	call handle_nf90_err(ncret)
1268	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1269	& shuffle=0, &
1270	& deflate=1, &
1271	& deflate_level=DEF_LEVEL)
1272	call handle_nf90_err(ncret)
1273	ncret = nf90_put_var(ncid, ncvarid, &
1274	& dyn(1:maxnests))
1275	call handle_nf90_err(ncret)
1276
1277	ncret = nf90_def_var(ncid, 'xlon0n', NF90_FLOAT, &
1278	& dim1dids, ncvarid)
1279	call handle_nf90_err(ncret)
1280	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1281	& shuffle=0, &
1282	& deflate=1, &
1283	& deflate_level=DEF_LEVEL)
1284	call handle_nf90_err(ncret)
1285	ncret = nf90_put_var(ncid, ncvarid, &
1286	& xlon0n(1:maxnests))
1287	call handle_nf90_err(ncret)
1288
1289	ncret = nf90_def_var(ncid, 'ylat0n', NF90_FLOAT, &
1290	& dim1dids, ncvarid)
1291	call handle_nf90_err(ncret)
1292	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1293	& shuffle=0, &
1294	& deflate=1, &
1295	& deflate_level=DEF_LEVEL)
1296	call handle_nf90_err(ncret)
1297	ncret = nf90_put_var(ncid, ncvarid, &
1298	& ylat0n(1:maxnests))
1299	call handle_nf90_err(ncret)
1300
1301
1302
1303
1304	! Nested fields, static over time
1305	WRITE(iounit) oron, excessoron, lsmn, xlandusen
1306
1307	dim3dids = (/nxmaxn_dimid, nymaxn_dimid, maxnests_dimid/)
1308
1309	ncret = nf90_def_var(ncid, 'oron', NF90_FLOAT, &
1310	& dim3dids, ncvarid)
1311	call handle_nf90_err(ncret)
1312	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1313	& shuffle=0, &
1314	& deflate=1, &
1315	& deflate_level=DEF_LEVEL)
1316	call handle_nf90_err(ncret)
1317	ncret = nf90_put_var(ncid, ncvarid, &
1318	& oron(0:nxmaxn-1, 0:nymaxn-1, 1:maxnests))
1319	call handle_nf90_err(ncret)
1320
1321	ncret = nf90_def_var(ncid, 'excessoron', NF90_FLOAT, &
1322	& dim3dids, ncvarid)
1323	call handle_nf90_err(ncret)
1324	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1325	& shuffle=0, &
1326	& deflate=1, &
1327	& deflate_level=DEF_LEVEL)
1328	call handle_nf90_err(ncret)
1329	ncret = nf90_put_var(ncid, ncvarid, &
1330	& excessoron(0:nxmaxn-1, 0:nymaxn-1, 1:maxnests))
1331	call handle_nf90_err(ncret)
1332
1333	ncret = nf90_def_var(ncid, 'lsmn', NF90_FLOAT, &
1334	& dim3dids, ncvarid)
1335	call handle_nf90_err(ncret)
1336	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1337	& shuffle=0, &
1338	& deflate=1, &
1339	& deflate_level=DEF_LEVEL)
1340	call handle_nf90_err(ncret)
1341	ncret = nf90_put_var(ncid, ncvarid, &
1342	& lsmn(0:nxmaxn-1, 0:nymaxn-1, 1:maxnests))
1343	call handle_nf90_err(ncret)
1344
1345	dim4dids = (/nxmaxn_dimid, nymaxn_dimid, numclass_dimid, maxnests_dimid/)
1346
1347	ncret = nf90_def_var(ncid, 'xlandusen', NF90_FLOAT, &
1348	& dim4dids, ncvarid)
1349	call handle_nf90_err(ncret)
1350	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1351	& shuffle=0, &
1352	& deflate=1, &
1353	& deflate_level=DEF_LEVEL)
1354	call handle_nf90_err(ncret)
1355	ncret = nf90_put_var(ncid, ncvarid, &
1356	& xlandusen(0:nxmaxn-1, 0:nymaxn-1, 1:numclass, 1:maxnests))
1357	call handle_nf90_err(ncret)
1358
1359	PRINT *, 'SUM(oron): ', SUM(oron)
1360
1361
1362
1363	! 3d nested fields
1364
1365
1366
1367	#ifdef RAWBIN
1368	WRITE(iounit) uun(:,:,:,cm_index,:)
1369	WRITE(iounit) vvn(:,:,:,cm_index,:)
1370	WRITE(iounit) wwn(:,:,:,cm_index,:)
1371	WRITE(iounit) ttn(:,:,:,cm_index,:)
1372	WRITE(iounit) qvn(:,:,:,cm_index,:)
1373	WRITE(iounit) pvn(:,:,:,cm_index,:)
1374	WRITE(iounit) cloudsn(:,:,:,cm_index,:)
1375	WRITE(iounit) cloudsnh(:,:,cm_index,:)
1376	WRITE(iounit) rhon(:,:,:,cm_index,:)
1377	WRITE(iounit) drhodzn(:,:,:,cm_index,:)
1378	WRITE(iounit) tthn(:,:,:,cm_index,:)
1379	WRITE(iounit) qvhn(:,:,:,cm_index,:)
1380	#endif
1381
1382	dim4dids = (/nxmaxn_dimid, nymaxn_dimid, nzmax_dimid, maxnests_dimid/)
1383
1384	ncret = nf90_def_var(ncid, 'uun', NF90_FLOAT, &
1385	& dim4dids, ncvarid)
1386	call handle_nf90_err(ncret)
1387	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1388	& shuffle=0, &
1389	& deflate=1, &
1390	& deflate_level=DEF_LEVEL)
1391	call handle_nf90_err(ncret)
1392	ncret = nf90_put_var(ncid, ncvarid, &
1393	& uun(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1394	call handle_nf90_err(ncret)
1395
1396	ncret = nf90_def_var(ncid, 'vvn', NF90_FLOAT, &
1397	& dim4dids, ncvarid)
1398	call handle_nf90_err(ncret)
1399	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1400	& shuffle=0, &
1401	& deflate=1, &
1402	& deflate_level=DEF_LEVEL)
1403	call handle_nf90_err(ncret)
1404	ncret = nf90_put_var(ncid, ncvarid, &
1405	& vvn(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1406	call handle_nf90_err(ncret)
1407
1408	ncret = nf90_def_var(ncid, 'wwn', NF90_FLOAT, &
1409	& dim4dids, ncvarid)
1410	call handle_nf90_err(ncret)
1411	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1412	& shuffle=0, &
1413	& deflate=1, &
1414	& deflate_level=DEF_LEVEL)
1415	call handle_nf90_err(ncret)
1416	ncret = nf90_put_var(ncid, ncvarid, &
1417	& wwn(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1418	call handle_nf90_err(ncret)
1419
1420	ncret = nf90_def_var(ncid, 'ttn', NF90_FLOAT, &
1421	& dim4dids, ncvarid)
1422	call handle_nf90_err(ncret)
1423	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1424	& shuffle=0, &
1425	& deflate=1, &
1426	& deflate_level=DEF_LEVEL)
1427	call handle_nf90_err(ncret)
1428	ncret = nf90_put_var(ncid, ncvarid, &
1429	& ttn(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1430	call handle_nf90_err(ncret)
1431
1432	ncret = nf90_def_var(ncid, 'qvn', NF90_FLOAT, &
1433	& dim4dids, ncvarid)
1434	call handle_nf90_err(ncret)
1435	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1436	& shuffle=0, &
1437	& deflate=1, &
1438	& deflate_level=DEF_LEVEL)
1439	call handle_nf90_err(ncret)
1440	ncret = nf90_put_var(ncid, ncvarid, &
1441	& qvn(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1442	call handle_nf90_err(ncret)
1443
1444	ncret = nf90_def_var(ncid, 'pvn', NF90_FLOAT, &
1445	& dim4dids, ncvarid)
1446	call handle_nf90_err(ncret)
1447	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1448	& shuffle=0, &
1449	& deflate=1, &
1450	& deflate_level=DEF_LEVEL)
1451	call handle_nf90_err(ncret)
1452	ncret = nf90_put_var(ncid, ncvarid, &
1453	& pvn(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1454	call handle_nf90_err(ncret)
1455
1456	ncret = nf90_def_var(ncid, 'rhon', NF90_FLOAT, &
1457	& dim4dids, ncvarid)
1458	call handle_nf90_err(ncret)
1459	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1460	& shuffle=0, &
1461	& deflate=1, &
1462	& deflate_level=DEF_LEVEL)
1463	call handle_nf90_err(ncret)
1464	ncret = nf90_put_var(ncid, ncvarid, &
1465	& rhon(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1466	call handle_nf90_err(ncret)
1467
1468	ncret = nf90_def_var(ncid, 'drhodzn', NF90_FLOAT, &
1469	& dim4dids, ncvarid)
1470	call handle_nf90_err(ncret)
1471	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1472	& shuffle=0, &
1473	& deflate=1, &
1474	& deflate_level=DEF_LEVEL)
1475	call handle_nf90_err(ncret)
1476	ncret = nf90_put_var(ncid, ncvarid, &
1477	& drhodzn(0:nxmaxn-1, 0:nymaxn-1, 1:nzmax, cm_index, 1:maxnests))
1478	call handle_nf90_err(ncret)
1479
1480
1481	! Note the new dimensions
1482	dim4dids = (/nxmaxn_dimid, nymaxn_dimid, nuvzmax_dimid, maxnests_dimid/)
1483
1484	ncret = nf90_def_var(ncid, 'tthn', NF90_FLOAT, &
1485	& dim4dids, ncvarid)
1486	call handle_nf90_err(ncret)
1487	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1488	& shuffle=0, &
1489	& deflate=1, &
1490	& deflate_level=DEF_LEVEL)
1491	call handle_nf90_err(ncret)
1492	ncret = nf90_put_var(ncid, ncvarid, &
1493	& tthn(0:nxmaxn-1, 0:nymaxn-1, 1:nuvzmax, cm_index, 1:maxnests))
1494	call handle_nf90_err(ncret)
1495
1496	ncret = nf90_def_var(ncid, 'qvhn', NF90_FLOAT, &
1497	& dim4dids, ncvarid)
1498	call handle_nf90_err(ncret)
1499	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1500	& shuffle=0, &
1501	& deflate=1, &
1502	& deflate_level=DEF_LEVEL)
1503	call handle_nf90_err(ncret)
1504	ncret = nf90_put_var(ncid, ncvarid, &
1505	& qvhn(0:nxmaxn-1, 0:nymaxn-1, 1:nuvzmax, cm_index, 1:maxnests))
1506	call handle_nf90_err(ncret)
1507
1508	! Note the new dimensions
1509	dim4dids = (/nxmaxn_dimid, nymaxn_dimid, zero_to_nzmax_dimid, maxnests_dimid/)
1510
1511	ncret = nf90_def_var(ncid, 'cloudsn', NF90_INT, &
1512	& dim4dids, ncvarid)
1513	call handle_nf90_err(ncret)
1514	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1515	& shuffle=0, &
1516	& deflate=1, &
1517	& deflate_level=DEF_LEVEL)
1518	call handle_nf90_err(ncret)
1519	ncret = nf90_put_var(ncid, ncvarid, &
1520	& cloudsn(0:nxmaxn-1, 0:nymaxn-1, 0:nzmax, cm_index, 1:maxnests))
1521	call handle_nf90_err(ncret)
1522
1523	! Note the new dimensions
1524	dim3dids = (/nxmaxn_dimid, nymaxn_dimid, maxnests_dimid/)
1525
1526	ncret = nf90_def_var(ncid, 'cloudsnh', NF90_INT, &
1527	& dim3dids, ncvarid)
1528	call handle_nf90_err(ncret)
1529	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1530	& shuffle=0, &
1531	& deflate=1, &
1532	& deflate_level=DEF_LEVEL)
1533	call handle_nf90_err(ncret)
1534	ncret = nf90_put_var(ncid, ncvarid, &
1535	& cloudsnh(0:nxmaxn-1, 0:nymaxn-1, cm_index, 1:maxnests))
1536	call handle_nf90_err(ncret)
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546	PRINT *, 'SUM(uun): ', SUM(uun(:,:,:,cm_index,:))
1547	PRINT *, 'SUM(qvhn): ', SUM(qvhn(:,:,:,cm_index,:))
1548	PRINT *, 'SUM(cloudsn): ', SUM(cloudsn(:,:,:,cm_index,:))
1549
1550
1551
1552	! 2d nested fields
1553
1554
1555	#ifdef RAWBIN
1556	WRITE(iounit) psn(:,:,:,cm_index,:)
1557	WRITE(iounit) sdn(:,:,:,cm_index,:)
1558	WRITE(iounit) msln(:,:,:,cm_index,:)
1559	WRITE(iounit) tccn(:,:,:,cm_index,:)
1560	WRITE(iounit) u10n(:,:,:,cm_index,:)
1561	WRITE(iounit) v10n(:,:,:,cm_index,:)
1562	WRITE(iounit) tt2n(:,:,:,cm_index,:)
1563	WRITE(iounit) td2n(:,:,:,cm_index,:)
1564	WRITE(iounit) lsprecn(:,:,:,cm_index,:)
1565	WRITE(iounit) convprecn(:,:,:,cm_index,:)
1566	WRITE(iounit) sshfn(:,:,:,cm_index,:)
1567	WRITE(iounit) ssrn(:,:,:,cm_index,:)
1568	WRITE(iounit) surfstrn(:,:,:,cm_index,:)
1569	WRITE(iounit) ustarn(:,:,:,cm_index,:)
1570	WRITE(iounit) wstarn(:,:,:,cm_index,:)
1571	WRITE(iounit) hmixn(:,:,:,cm_index,:)
1572	WRITE(iounit) tropopausen(:,:,:,cm_index,:)
1573	WRITE(iounit) olin(:,:,:,cm_index,:)
1574	WRITE(iounit) diffkn(:,:,:,cm_index,:)
1575	WRITE(iounit) vdepn(:,:,:,cm_index,:)
1576	#endif
1577
1578
1579	dim3dids = (/nxmaxn_dimid, nymaxn_dimid, maxnests_dimid/)
1580
1581	ncret = nf90_def_var(ncid, 'psn', NF90_FLOAT, &
1582	& dim3dids, ncvarid)
1583	call handle_nf90_err(ncret)
1584	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1585	& shuffle=0, &
1586	& deflate=1, &
1587	& deflate_level=DEF_LEVEL)
1588	call handle_nf90_err(ncret)
1589	ncret = nf90_put_var(ncid, ncvarid, &
1590	& psn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1591	call handle_nf90_err(ncret)
1592
1593	ncret = nf90_def_var(ncid, 'sdn', NF90_FLOAT, &
1594	& dim3dids, ncvarid)
1595	call handle_nf90_err(ncret)
1596	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1597	& shuffle=0, &
1598	& deflate=1, &
1599	& deflate_level=DEF_LEVEL)
1600	call handle_nf90_err(ncret)
1601	ncret = nf90_put_var(ncid, ncvarid, &
1602	& sdn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1603	call handle_nf90_err(ncret)
1604
1605	ncret = nf90_def_var(ncid, 'msln', NF90_FLOAT, &
1606	& dim3dids, ncvarid)
1607	call handle_nf90_err(ncret)
1608	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1609	& shuffle=0, &
1610	& deflate=1, &
1611	& deflate_level=DEF_LEVEL)
1612	call handle_nf90_err(ncret)
1613	ncret = nf90_put_var(ncid, ncvarid, &
1614	& msln(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1615	call handle_nf90_err(ncret)
1616
1617	ncret = nf90_def_var(ncid, 'tccn', NF90_FLOAT, &
1618	& dim3dids, ncvarid)
1619	call handle_nf90_err(ncret)
1620	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1621	& shuffle=0, &
1622	& deflate=1, &
1623	& deflate_level=DEF_LEVEL)
1624	call handle_nf90_err(ncret)
1625	ncret = nf90_put_var(ncid, ncvarid, &
1626	& tccn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1627	call handle_nf90_err(ncret)
1628
1629	ncret = nf90_def_var(ncid, 'u10n', NF90_FLOAT, &
1630	& dim3dids, ncvarid)
1631	call handle_nf90_err(ncret)
1632	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1633	& shuffle=0, &
1634	& deflate=1, &
1635	& deflate_level=DEF_LEVEL)
1636	call handle_nf90_err(ncret)
1637	ncret = nf90_put_var(ncid, ncvarid, &
1638	& u10n(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1639	call handle_nf90_err(ncret)
1640
1641	ncret = nf90_def_var(ncid, 'v10n', NF90_FLOAT, &
1642	& dim3dids, ncvarid)
1643	call handle_nf90_err(ncret)
1644	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1645	& shuffle=0, &
1646	& deflate=1, &
1647	& deflate_level=DEF_LEVEL)
1648	call handle_nf90_err(ncret)
1649	ncret = nf90_put_var(ncid, ncvarid, &
1650	& v10n(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1651	call handle_nf90_err(ncret)
1652
1653	ncret = nf90_def_var(ncid, 'tt2n', NF90_FLOAT, &
1654	& dim3dids, ncvarid)
1655	call handle_nf90_err(ncret)
1656	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1657	& shuffle=0, &
1658	& deflate=1, &
1659	& deflate_level=DEF_LEVEL)
1660	call handle_nf90_err(ncret)
1661	ncret = nf90_put_var(ncid, ncvarid, &
1662	& tt2n(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1663	call handle_nf90_err(ncret)
1664
1665	ncret = nf90_def_var(ncid, 'td2n', NF90_FLOAT, &
1666	& dim3dids, ncvarid)
1667	call handle_nf90_err(ncret)
1668	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1669	& shuffle=0, &
1670	& deflate=1, &
1671	& deflate_level=DEF_LEVEL)
1672	call handle_nf90_err(ncret)
1673	ncret = nf90_put_var(ncid, ncvarid, &
1674	& td2n(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1675	call handle_nf90_err(ncret)
1676
1677	ncret = nf90_def_var(ncid, 'lsprecn', NF90_FLOAT, &
1678	& dim3dids, ncvarid)
1679	call handle_nf90_err(ncret)
1680	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1681	& shuffle=0, &
1682	& deflate=1, &
1683	& deflate_level=DEF_LEVEL)
1684	call handle_nf90_err(ncret)
1685	ncret = nf90_put_var(ncid, ncvarid, &
1686	& lsprecn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1687	call handle_nf90_err(ncret)
1688
1689	ncret = nf90_def_var(ncid, 'convprecn', NF90_FLOAT, &
1690	& dim3dids, ncvarid)
1691	call handle_nf90_err(ncret)
1692	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1693	& shuffle=0, &
1694	& deflate=1, &
1695	& deflate_level=DEF_LEVEL)
1696	call handle_nf90_err(ncret)
1697	ncret = nf90_put_var(ncid, ncvarid, &
1698	& convprecn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1699	call handle_nf90_err(ncret)
1700
1701	ncret = nf90_def_var(ncid, 'sshfn', NF90_FLOAT, &
1702	& dim3dids, ncvarid)
1703	call handle_nf90_err(ncret)
1704	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1705	& shuffle=0, &
1706	& deflate=1, &
1707	& deflate_level=DEF_LEVEL)
1708	call handle_nf90_err(ncret)
1709	ncret = nf90_put_var(ncid, ncvarid, &
1710	& sshfn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1711	call handle_nf90_err(ncret)
1712
1713	ncret = nf90_def_var(ncid, 'ssrn', NF90_FLOAT, &
1714	& dim3dids, ncvarid)
1715	call handle_nf90_err(ncret)
1716	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1717	& shuffle=0, &
1718	& deflate=1, &
1719	& deflate_level=DEF_LEVEL)
1720	call handle_nf90_err(ncret)
1721	ncret = nf90_put_var(ncid, ncvarid, &
1722	& ssrn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1723	call handle_nf90_err(ncret)
1724
1725	ncret = nf90_def_var(ncid, 'surfstrn', NF90_FLOAT, &
1726	& dim3dids, ncvarid)
1727	call handle_nf90_err(ncret)
1728	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1729	& shuffle=0, &
1730	& deflate=1, &
1731	& deflate_level=DEF_LEVEL)
1732	call handle_nf90_err(ncret)
1733	ncret = nf90_put_var(ncid, ncvarid, &
1734	& surfstrn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1735	call handle_nf90_err(ncret)
1736
1737	ncret = nf90_def_var(ncid, 'ustarn', NF90_FLOAT, &
1738	& dim3dids, ncvarid)
1739	call handle_nf90_err(ncret)
1740	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1741	& shuffle=0, &
1742	& deflate=1, &
1743	& deflate_level=DEF_LEVEL)
1744	call handle_nf90_err(ncret)
1745	ncret = nf90_put_var(ncid, ncvarid, &
1746	& ustarn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1747	call handle_nf90_err(ncret)
1748
1749	ncret = nf90_def_var(ncid, 'wstarn', NF90_FLOAT, &
1750	& dim3dids, ncvarid)
1751	call handle_nf90_err(ncret)
1752	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1753	& shuffle=0, &
1754	& deflate=1, &
1755	& deflate_level=DEF_LEVEL)
1756	call handle_nf90_err(ncret)
1757	ncret = nf90_put_var(ncid, ncvarid, &
1758	& wstarn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1759	call handle_nf90_err(ncret)
1760
1761	ncret = nf90_def_var(ncid, 'hmixn', NF90_FLOAT, &
1762	& dim3dids, ncvarid)
1763	call handle_nf90_err(ncret)
1764	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1765	& shuffle=0, &
1766	& deflate=1, &
1767	& deflate_level=DEF_LEVEL)
1768	call handle_nf90_err(ncret)
1769	ncret = nf90_put_var(ncid, ncvarid, &
1770	& hmixn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1771	call handle_nf90_err(ncret)
1772
1773	ncret = nf90_def_var(ncid, 'tropopausen', NF90_FLOAT, &
1774	& dim3dids, ncvarid)
1775	call handle_nf90_err(ncret)
1776	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1777	& shuffle=0, &
1778	& deflate=1, &
1779	& deflate_level=DEF_LEVEL)
1780	call handle_nf90_err(ncret)
1781	ncret = nf90_put_var(ncid, ncvarid, &
1782	& tropopausen(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1783	call handle_nf90_err(ncret)
1784
1785	ncret = nf90_def_var(ncid, 'olin', NF90_FLOAT, &
1786	& dim3dids, ncvarid)
1787	call handle_nf90_err(ncret)
1788	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1789	& shuffle=0, &
1790	& deflate=1, &
1791	& deflate_level=DEF_LEVEL)
1792	call handle_nf90_err(ncret)
1793	ncret = nf90_put_var(ncid, ncvarid, &
1794	& olin(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1795	call handle_nf90_err(ncret)
1796
1797	ncret = nf90_def_var(ncid, 'diffkn', NF90_FLOAT, &
1798	& dim3dids, ncvarid)
1799	call handle_nf90_err(ncret)
1800	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1801	& shuffle=0, &
1802	& deflate=1, &
1803	& deflate_level=DEF_LEVEL)
1804	call handle_nf90_err(ncret)
1805	ncret = nf90_put_var(ncid, ncvarid, &
1806	& diffkn(0:nxmaxn-1, 0:nymaxn-1, 1, cm_index, 1:maxnests))
1807	call handle_nf90_err(ncret)
1808
1809	dim4dids = (/nxmaxn_dimid, nymaxn_dimid, maxspec_dimid, maxnests_dimid/)
1810
1811
1812
1813	ncret = nf90_def_var(ncid, 'vdepn', NF90_FLOAT, &
1814	& dim4dids, ncvarid)
1815	call handle_nf90_err(ncret)
1816	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1817	& shuffle=0, &
1818	& deflate=1, &
1819	& deflate_level=DEF_LEVEL)
1820	call handle_nf90_err(ncret)
1821	ncret = nf90_put_var(ncid, ncvarid, &
1822	& vdepn(0:nxmaxn-1, 0:nymaxn-1, 1:maxspec, cm_index, 1:maxnests))
1823	call handle_nf90_err(ncret)
1824
1825
1826
1827
1828	PRINT *, 'SUM(psn): ', SUM(psn(:,:,:,cm_index,:))
1829	PRINT *, 'SUM(surfstrn): ', SUM(surfstrn(:,:,:,cm_index,:))
1830	PRINT *, 'SUM(vdepn): ', SUM(vdepn(:,:,:,cm_index,:))
1831
1832
1833
1834
1835
1836	! Auxiliary variables for nests
1837
1838	#ifdef RAWBIN
1839	WRITE(iounit) xresoln(:)
1840	WRITE(iounit) yresoln(:)
1841	WRITE(iounit) xln(:)
1842	WRITE(iounit) yln(:)
1843	WRITE(iounit) xrn(:)
1844	WRITE(iounit) yrn(:)
1845	#endif
1846
1847
1848	dim1dids = (/zero_to_maxnests_dimid/)
1849
1850	ncret = nf90_def_var(ncid, 'xresoln', NF90_FLOAT, &
1851	& dim1dids, ncvarid)
1852	call handle_nf90_err(ncret)
1853	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1854	& shuffle=0, &
1855	& deflate=1, &
1856	& deflate_level=DEF_LEVEL)
1857	call handle_nf90_err(ncret)
1858	ncret = nf90_put_var(ncid, ncvarid, &
1859	& xresoln(0:maxnests))
1860	call handle_nf90_err(ncret)
1861
1862	ncret = nf90_def_var(ncid, 'yresoln', NF90_FLOAT, &
1863	& dim1dids, ncvarid)
1864	call handle_nf90_err(ncret)
1865	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1866	& shuffle=0, &
1867	& deflate=1, &
1868	& deflate_level=DEF_LEVEL)
1869	call handle_nf90_err(ncret)
1870	ncret = nf90_put_var(ncid, ncvarid, &
1871	& yresoln(0:maxnests))
1872	call handle_nf90_err(ncret)
1873
1874	dim1dids = (/maxnests_dimid/)
1875
1876	ncret = nf90_def_var(ncid, 'xln', NF90_FLOAT, &
1877	& dim1dids, ncvarid)
1878	call handle_nf90_err(ncret)
1879	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1880	& shuffle=0, &
1881	& deflate=1, &
1882	& deflate_level=DEF_LEVEL)
1883	call handle_nf90_err(ncret)
1884	ncret = nf90_put_var(ncid, ncvarid, &
1885	& xln(1:maxnests))
1886	call handle_nf90_err(ncret)
1887
1888	ncret = nf90_def_var(ncid, 'yln', NF90_FLOAT, &
1889	& dim1dids, ncvarid)
1890	call handle_nf90_err(ncret)
1891	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1892	& shuffle=0, &
1893	& deflate=1, &
1894	& deflate_level=DEF_LEVEL)
1895	call handle_nf90_err(ncret)
1896	ncret = nf90_put_var(ncid, ncvarid, &
1897	& yln(1:maxnests))
1898	call handle_nf90_err(ncret)
1899
1900	ncret = nf90_def_var(ncid, 'xrn', NF90_FLOAT, &
1901	& dim1dids, ncvarid)
1902	call handle_nf90_err(ncret)
1903	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1904	& shuffle=0, &
1905	& deflate=1, &
1906	& deflate_level=DEF_LEVEL)
1907	call handle_nf90_err(ncret)
1908	ncret = nf90_put_var(ncid, ncvarid, &
1909	& xrn(1:maxnests))
1910	call handle_nf90_err(ncret)
1911
1912	ncret = nf90_def_var(ncid, 'yrn', NF90_FLOAT, &
1913	& dim1dids, ncvarid)
1914	call handle_nf90_err(ncret)
1915	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1916	& shuffle=0, &
1917	& deflate=1, &
1918	& deflate_level=DEF_LEVEL)
1919	call handle_nf90_err(ncret)
1920	ncret = nf90_put_var(ncid, ncvarid, &
1921	& yrn(1:maxnests))
1922	call handle_nf90_err(ncret)
1923
1924	PRINT *, 'SUM(yresoln): ', SUM(yresoln)
1925	PRINT *, 'SUM(xrn): ', SUM(xrn)
1926
1927
1928
1929	! Variables for polar stereographic projection
1930
1931
1932
1933	#ifdef RAWBIN
1934	WRITE(iounit) xglobal, sglobal, nglobal
1935	WRITE(iounit) switchnorthg, switchsouthg
1936	WRITE(iounit) southpolemap(:)
1937	WRITE(iounit) northpolemap(:)
1938	#endif
1939
1940
1941	dim1dids = (/polemap_dimid/)
1942
1943	ncret = nf90_def_var(ncid, 'southpolemap', NF90_FLOAT, &
1944	& dim1dids, ncvarid)
1945	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1946	& shuffle=0, &
1947	& deflate=1, &
1948	& deflate_level=DEF_LEVEL)
1949	ncret = nf90_put_var(ncid, ncvarid, &
1950	& southpolemap(:))
1951
1952	ncret = nf90_def_var(ncid, 'northpolemap', NF90_FLOAT, &
1953	& dim1dids, ncvarid)
1954	ncret = nf90_def_var_deflate(ncid, ncvarid, &
1955	& shuffle=0, &
1956	& deflate=1, &
1957	& deflate_level=DEF_LEVEL)
1958	ncret = nf90_put_var(ncid, ncvarid, &
1959	& northpolemap(:))
1960
1961
1962
1963	! xglobal, sglobal, nglobal are LOGICAL vars, and need to be converted
1964	! to INTEGER for NetCDF storage
1965	ncret = nf90_def_var(ncid, 'xglobal', NF90_INT, ncvarid)
1966	call handle_nf90_err(ncret)
1967	ncret = nf90_put_var(ncid, ncvarid, logical2integer(xglobal))
1968	call handle_nf90_err(ncret)
1969
1970	ncret = nf90_def_var(ncid, 'sglobal', NF90_INT, ncvarid)
1971	call handle_nf90_err(ncret)
1972	ncret = nf90_put_var(ncid, ncvarid, logical2integer(sglobal))
1973	call handle_nf90_err(ncret)
1974
1975	ncret = nf90_def_var(ncid, 'nglobal', NF90_INT, ncvarid)
1976	call handle_nf90_err(ncret)
1977	ncret = nf90_put_var(ncid, ncvarid, logical2integer(nglobal))
1978	call handle_nf90_err(ncret)
1979
1980	ncret = nf90_def_var(ncid, 'switchnorthg', NF90_FLOAT, ncvarid)
1981	call handle_nf90_err(ncret)
1982	ncret = nf90_put_var(ncid, ncvarid, switchnorthg)
1983	call handle_nf90_err(ncret)
1984
1985	ncret = nf90_def_var(ncid, 'switchsouthg', NF90_FLOAT, ncvarid)
1986	call handle_nf90_err(ncret)
1987	ncret = nf90_put_var(ncid, ncvarid, switchsouthg)
1988	call handle_nf90_err(ncret)
1989
1990
1991
1992	PRINT *, 'SUM(northpolemap): ', SUM(northpolemap)
1993	PRINT *, 'xglobal: ', xglobal
1994	PRINT *, 'sglobal: ', sglobal
1995	PRINT *, 'nglobal: ', nglobal
1996	PRINT *, 'switchsouthg: ', switchsouthg
1997
1998	! Variables declared in conv_mod (convection)
1999
2000
2001	#ifdef RAWBIN
2002	WRITE(iounit) pconv(:)
2003	WRITE(iounit) phconv(:)
2004	WRITE(iounit) dpr(:)
2005	WRITE(iounit) pconv_hpa(:)
2006	WRITE(iounit) phconv_hpa(:)
2007	WRITE(iounit) ft(:)
2008	WRITE(iounit) fq(:)
2009	WRITE(iounit) fmass(:,:)
2010	WRITE(iounit) sub(:)
2011	WRITE(iounit) fmassfrac(:,:)
2012	WRITE(iounit) cbaseflux(:,:)
2013	WRITE(iounit) cbasefluxn(:,:,:)
2014	WRITE(iounit) tconv(:)
2015	WRITE(iounit) qconv(:)
2016	WRITE(iounit) qsconv(:)
2017	WRITE(iounit) psconv, tt2conv, td2conv
2018	WRITE(iounit) nconvlev, nconvtop
2019	#endif
2020
2021
2022	dim1dids = (/nconvlevmax_dimid/)
2023
2024	ncret = nf90_def_var(ncid, 'pconv', NF90_FLOAT, &
2025	& dim1dids, ncvarid)
2026	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2027	& shuffle=0, &
2028	& deflate=1, &
2029	& deflate_level=DEF_LEVEL)
2030	ncret = nf90_put_var(ncid, ncvarid, &
2031	& pconv(:))
2032
2033	ncret = nf90_def_var(ncid, 'dpr', NF90_FLOAT, &
2034	& dim1dids, ncvarid)
2035	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2036	& shuffle=0, &
2037	& deflate=1, &
2038	& deflate_level=DEF_LEVEL)
2039	ncret = nf90_put_var(ncid, ncvarid, &
2040	& dpr(:))
2041
2042	ncret = nf90_def_var(ncid, 'pconv_hpa', NF90_FLOAT, &
2043	& dim1dids, ncvarid)
2044	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2045	& shuffle=0, &
2046	& deflate=1, &
2047	& deflate_level=DEF_LEVEL)
2048	ncret = nf90_put_var(ncid, ncvarid, &
2049	& pconv_hpa(:))
2050
2051	ncret = nf90_def_var(ncid, 'ft', NF90_FLOAT, &
2052	& dim1dids, ncvarid)
2053	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2054	& shuffle=0, &
2055	& deflate=1, &
2056	& deflate_level=DEF_LEVEL)
2057	ncret = nf90_put_var(ncid, ncvarid, &
2058	& ft(:))
2059
2060	ncret = nf90_def_var(ncid, 'fq', NF90_FLOAT, &
2061	& dim1dids, ncvarid)
2062	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2063	& shuffle=0, &
2064	& deflate=1, &
2065	& deflate_level=DEF_LEVEL)
2066	ncret = nf90_put_var(ncid, ncvarid, &
2067	& fq(:))
2068
2069	ncret = nf90_def_var(ncid, 'sub', NF90_FLOAT, &
2070	& dim1dids, ncvarid)
2071	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2072	& shuffle=0, &
2073	& deflate=1, &
2074	& deflate_level=DEF_LEVEL)
2075	ncret = nf90_put_var(ncid, ncvarid, &
2076	& sub(:))
2077
2078	dim1dids = (/na_dimid/)
2079
2080	ncret = nf90_def_var(ncid, 'phconv', NF90_FLOAT, &
2081	& dim1dids, ncvarid)
2082	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2083	& shuffle=0, &
2084	& deflate=1, &
2085	& deflate_level=DEF_LEVEL)
2086	ncret = nf90_put_var(ncid, ncvarid, &
2087	& phconv(:))
2088
2089	ncret = nf90_def_var(ncid, 'phconv_hpa', NF90_FLOAT, &
2090	& dim1dids, ncvarid)
2091	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2092	& shuffle=0, &
2093	& deflate=1, &
2094	& deflate_level=DEF_LEVEL)
2095	ncret = nf90_put_var(ncid, ncvarid, &
2096	& phconv_hpa(:))
2097
2098	ncret = nf90_def_var(ncid, 'tconv', NF90_FLOAT, &
2099	& dim1dids, ncvarid)
2100	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2101	& shuffle=0, &
2102	& deflate=1, &
2103	& deflate_level=DEF_LEVEL)
2104	ncret = nf90_put_var(ncid, ncvarid, &
2105	& tconv(:))
2106
2107	ncret = nf90_def_var(ncid, 'qconv', NF90_FLOAT, &
2108	& dim1dids, ncvarid)
2109	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2110	& shuffle=0, &
2111	& deflate=1, &
2112	& deflate_level=DEF_LEVEL)
2113	ncret = nf90_put_var(ncid, ncvarid, &
2114	& qconv(:))
2115
2116	ncret = nf90_def_var(ncid, 'qsconv', NF90_FLOAT, &
2117	& dim1dids, ncvarid)
2118	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2119	& shuffle=0, &
2120	& deflate=1, &
2121	& deflate_level=DEF_LEVEL)
2122	ncret = nf90_put_var(ncid, ncvarid, &
2123	& qsconv(:))
2124
2125	! New dimensions
2126	dim2dids = (/nconvlevmax_dimid, nconvlevmax_dimid/)
2127
2128	ncret = nf90_def_var(ncid, 'fmass', NF90_FLOAT, &
2129	& dim2dids, ncvarid)
2130	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2131	& shuffle=0, &
2132	& deflate=1, &
2133	& deflate_level=DEF_LEVEL)
2134	ncret = nf90_put_var(ncid, ncvarid, &
2135	& fmass(:,:))
2136
2137	ncret = nf90_def_var(ncid, 'fmassfrac', NF90_FLOAT, &
2138	& dim2dids, ncvarid)
2139	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2140	& shuffle=0, &
2141	& deflate=1, &
2142	& deflate_level=DEF_LEVEL)
2143	ncret = nf90_put_var(ncid, ncvarid, &
2144	& fmassfrac(:,:))
2145
2146
2147	! New dimensions
2148	dim2dids = (/nxmax_dimid, nymax_dimid/)
2149
2150	ncret = nf90_def_var(ncid, 'cbaseflux', NF90_FLOAT, &
2151	& dim2dids, ncvarid)
2152	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2153	& shuffle=0, &
2154	& deflate=1, &
2155	& deflate_level=DEF_LEVEL)
2156	ncret = nf90_put_var(ncid, ncvarid, &
2157	& cbaseflux(0:nxmax-1,0:nymax-1))
2158
2159	! New dimensions
2160	dim3dids = (/nxmaxn_dimid, nymaxn_dimid, maxnests_dimid/)
2161
2162	ncret = nf90_def_var(ncid, 'cbasefluxn', NF90_FLOAT, &
2163	& dim3dids, ncvarid)
2164	ncret = nf90_def_var_deflate(ncid, ncvarid, &
2165	& shuffle=0, &
2166	& deflate=1, &
2167	& deflate_level=DEF_LEVEL)
2168	ncret = nf90_put_var(ncid, ncvarid, &
2169	& cbasefluxn(0:nxmaxn-1,0:nymaxn-1,1:maxnests))
2170
2171
2172	! Scalars
2173	ncret = nf90_def_var(ncid, 'psconv', NF90_FLOAT, ncvarid)
2174	call handle_nf90_err(ncret)
2175	ncret = nf90_put_var(ncid, ncvarid, psconv)
2176	call handle_nf90_err(ncret)
2177
2178	ncret = nf90_def_var(ncid, 'tt2conv', NF90_FLOAT, ncvarid)
2179	call handle_nf90_err(ncret)
2180	ncret = nf90_put_var(ncid, ncvarid, tt2conv)
2181	call handle_nf90_err(ncret)
2182
2183	ncret = nf90_def_var(ncid, 'td2conv', NF90_FLOAT, ncvarid)
2184	call handle_nf90_err(ncret)
2185	ncret = nf90_put_var(ncid, ncvarid, td2conv)
2186	call handle_nf90_err(ncret)
2187
2188	ncret = nf90_def_var(ncid, 'nconvlev', NF90_INT, ncvarid)
2189	call handle_nf90_err(ncret)
2190	ncret = nf90_put_var(ncid, ncvarid, nconvlev)
2191	call handle_nf90_err(ncret)
2192
2193	ncret = nf90_def_var(ncid, 'nconvtop', NF90_INT, ncvarid)
2194	call handle_nf90_err(ncret)
2195	ncret = nf90_put_var(ncid, ncvarid, nconvtop)
2196	call handle_nf90_err(ncret)
2197
2198	PRINT *, 'SUM(pconv): ', SUM(pconv)
2199	PRINT *, 'SUM(qconv): ', SUM(qconv)
2200	PRINT *, 'SUM(fmassfrac): ', SUM(fmassfrac)
2201	PRINT *, 'SUM(cbasefluxn): ', SUM(cbasefluxn)
2202	PRINT *, 'tt2conv: ', tt2conv
2203	PRINT *, 'nconvlev: ', nconvlev
2204
2205
2206
2207	ELSE IF (op == 'LOAD') THEN
2208
2209	! Read the preprocessed format version string and insure it
2210	! matches this version
2211
2212
2213	#ifdef RAWBIN
2214	READ (iounit) temp_preproc_format_version_str
2215	PRINT *, 'Reading preprocessed file format version: ', &
2216	& temp_preproc_format_version_str
2217
2218	IF (TRIM(temp_preproc_format_version_str) == &
2219	& TRIM(PREPROC_FORMAT_VERSION_STR)) THEN
2220	CONTINUE
2221	ELSE
2222	! PRINT *, '' GK: causes relocation truncated to fit: R_X86_64_32
2223	PRINT *, 'Inconsistent preprocessing format version'
2224	PRINT *, 'Expected Version: ', PREPROC_FORMAT_VERSION_STR
2225	PRINT *, 'Detected Version: ', temp_preproc_format_version_str
2226	! PRINT *, ''
2227	STOP
2228	END IF
2229	#endif
2230
2231
2232
2233
2234	! Read the compiled max dimensions that were dumped from par_mod
2235	! when creating the fp file, so that we can compare against
2236	! current FLEXPART dimensions - they need to be the same, or else
2237	! we abort.
2238
2239
2240
2241	#ifdef RAWBIN
2242	READ (iounit) temp_nxmax, temp_nymax, temp_nzmax, &
2243	& temp_nuvzmax, temp_nwzmax
2244	#endif
2245
2246
2247
2248
2249	PRINT *, 'GET DIMENSIONS'
2250	! Get dimensions
2251	ncret = nf90_inq_dimid(ncid, 'nxmax', nxmax_dimid)
2252	call handle_nf90_err(ncret)
2253	PRINT *, 'GOT nxmax_dimid'
2254	ncret = nf90_inquire_dimension(ncid, nxmax_dimid, nxmax_dimname, &
2255	& temp_nxmax)
2256	call handle_nf90_err(ncret)
2257	PRINT *, 'temp_nxmax: ', temp_nxmax
2258
2259	PRINT *, 'GOT temp_nxmax'
2260
2261	ncret = nf90_inq_dimid(ncid, 'nymax', nymax_dimid)
2262	call handle_nf90_err(ncret)
2263	ncret = nf90_inquire_dimension(ncid, nymax_dimid, nymax_dimname, &
2264	& temp_nymax)
2265	call handle_nf90_err(ncret)
2266	PRINT *, 'temp_nymax: ', temp_nymax
2267
2268	ncret = nf90_inq_dimid(ncid, 'nzmax', nzmax_dimid)
2269	call handle_nf90_err(ncret)
2270	ncret = nf90_inquire_dimension(ncid, nzmax_dimid, nzmax_dimname, &
2271	& temp_nzmax)
2272	call handle_nf90_err(ncret)
2273	PRINT *, 'temp_nzmax: ', temp_nzmax
2274
2275	ncret = nf90_inq_dimid(ncid, 'nuvzmax', nuvzmax_dimid)
2276	call handle_nf90_err(ncret)
2277	ncret = nf90_inquire_dimension(ncid, nuvzmax_dimid, nuvzmax_dimname, &
2278	& temp_nuvzmax)
2279	call handle_nf90_err(ncret)
2280	PRINT *, 'temp_nuvzmax: ', temp_nuvzmax
2281
2282	ncret = nf90_inq_dimid(ncid, 'nwzmax', nwzmax_dimid)
2283	call handle_nf90_err(ncret)
2284	ncret = nf90_inquire_dimension(ncid, nwzmax_dimid, nwzmax_dimname, &
2285	& temp_nwzmax)
2286	call handle_nf90_err(ncret)
2287	PRINT *, 'temp_nwzmax: ', temp_nwzmax
2288
2289	ncret = nf90_inq_dimid(ncid, 'numclass', numclass_dimid)
2290	call handle_nf90_err(ncret)
2291	ncret = nf90_inquire_dimension(ncid, numclass_dimid, numclass_dimname, &
2292	& temp_numclass)
2293	call handle_nf90_err(ncret)
2294	PRINT *, 'temp_numclass: ', temp_numclass
2295
2296	ncret = nf90_inq_dimid(ncid, 'maxspec', maxspec_dimid)
2297	call handle_nf90_err(ncret)
2298	ncret = nf90_inquire_dimension(ncid, maxspec_dimid, maxspec_dimname, &
2299	& temp_maxspec)
2300	call handle_nf90_err(ncret)
2301	PRINT *, 'temp_maxspec: ', temp_maxspec
2302
2303
2304
2305	PRINT *, 'CHECK DIMENSIONS'
2306
2307	IF ( (temp_nxmax == nxmax) .AND. (temp_nymax == nymax) .AND. &
2308	& (temp_nzmax == nzmax) .AND. &
2309	& (temp_nuvzmax == nuvzmax) .AND. &
2310	& (temp_nwzmax == nwzmax) .AND. &
2311	& (temp_numclass == numclass) .AND. &
2312	& (temp_maxspec == maxspec) ) THEN
2313	CONTINUE
2314	ELSE
2315	PRINT *, 'Incompatible dimensions between fp file and current FLEXPART!'
2316	! PRINT *, ''
2317	PRINT *, ' FP file Compiled FP'
2318	PRINT *, 'nxmax: ', temp_nxmax, ' ', nxmax
2319	PRINT *, 'nymax: ', temp_nymax, ' ', nymax
2320	PRINT *, 'nzmax: ', temp_nzmax, ' ', nzmax
2321	PRINT *, 'nuvzmax: ', temp_nuvzmax, ' ', nuvzmax
2322	PRINT *, 'nwzmax: ', temp_nwzmax, ' ', nwzmax
2323	PRINT *, 'numclass: ', temp_numclass, ' ', numclass
2324	PRINT *, 'maxspec: ', temp_maxspec, ' ', maxspec
2325	! PRINT *, ''
2326	STOP
2327	END IF
2328
2329
2330
2331
2332	! Scalar values
2333
2334
2335	#ifdef RAWBIN
2336	READ(iounit) nx, ny, nxmin1, nymin1, nxfield
2337	READ(iounit) nuvz, nwz, nz, nmixz, nlev_ec
2338	READ(iounit) dx, dy, xlon0, ylat0, dxconst, dyconst
2339	#endif
2340
2341
2342
2343
2344	PRINT *, 'GET SCALARS'
2345
2346	! Get the varid , then read into scalar variable
2347	ncret = nf90_inq_varid(ncid, 'nx', ncvarid)
2348	call handle_nf90_err(ncret)
2349	ncret = nf90_get_var(ncid, ncvarid, nx)
2350	call handle_nf90_err(ncret)
2351
2352	ncret = nf90_inq_varid(ncid, 'ny', ncvarid)
2353	call handle_nf90_err(ncret)
2354	ncret = nf90_get_var(ncid, ncvarid, ny)
2355	call handle_nf90_err(ncret)
2356
2357	ncret = nf90_inq_varid(ncid, 'nxmin1', ncvarid)
2358	call handle_nf90_err(ncret)
2359	ncret = nf90_get_var(ncid, ncvarid, nxmin1)
2360	call handle_nf90_err(ncret)
2361
2362	ncret = nf90_inq_varid(ncid, 'nymin1', ncvarid)
2363	call handle_nf90_err(ncret)
2364	ncret = nf90_get_var(ncid, ncvarid, nymin1)
2365	call handle_nf90_err(ncret)
2366
2367	ncret = nf90_inq_varid(ncid, 'nxfield', ncvarid)
2368	call handle_nf90_err(ncret)
2369	ncret = nf90_get_var(ncid, ncvarid, nxfield)
2370	call handle_nf90_err(ncret)
2371
2372	ncret = nf90_inq_varid(ncid, 'nuvz', ncvarid)
2373	call handle_nf90_err(ncret)
2374	ncret = nf90_get_var(ncid, ncvarid, nuvz)
2375	call handle_nf90_err(ncret)
2376
2377	ncret = nf90_inq_varid(ncid, 'nwz', ncvarid)
2378	call handle_nf90_err(ncret)
2379	ncret = nf90_get_var(ncid, ncvarid, nwz)
2380	call handle_nf90_err(ncret)
2381
2382	ncret = nf90_inq_varid(ncid, 'nz', ncvarid)
2383	call handle_nf90_err(ncret)
2384	ncret = nf90_get_var(ncid, ncvarid, nz)
2385	call handle_nf90_err(ncret)
2386
2387	ncret = nf90_inq_varid(ncid, 'nmixz', ncvarid)
2388	call handle_nf90_err(ncret)
2389	ncret = nf90_get_var(ncid, ncvarid, nmixz)
2390	call handle_nf90_err(ncret)
2391
2392	ncret = nf90_inq_varid(ncid, 'nlev_ec', ncvarid)
2393	call handle_nf90_err(ncret)
2394	ncret = nf90_get_var(ncid, ncvarid, nlev_ec)
2395	call handle_nf90_err(ncret)
2396
2397	ncret = nf90_inq_varid(ncid, 'dx', ncvarid)
2398	call handle_nf90_err(ncret)
2399	ncret = nf90_get_var(ncid, ncvarid, dx)
2400	call handle_nf90_err(ncret)
2401
2402	ncret = nf90_inq_varid(ncid, 'dy', ncvarid)
2403	call handle_nf90_err(ncret)
2404	ncret = nf90_get_var(ncid, ncvarid, dy)
2405	call handle_nf90_err(ncret)
2406
2407	ncret = nf90_inq_varid(ncid, 'xlon0', ncvarid)
2408	call handle_nf90_err(ncret)
2409	ncret = nf90_get_var(ncid, ncvarid, xlon0)
2410	call handle_nf90_err(ncret)
2411
2412	ncret = nf90_inq_varid(ncid, 'ylat0', ncvarid)
2413	call handle_nf90_err(ncret)
2414	ncret = nf90_get_var(ncid, ncvarid, ylat0)
2415	call handle_nf90_err(ncret)
2416
2417	ncret = nf90_inq_varid(ncid, 'dxconst', ncvarid)
2418	call handle_nf90_err(ncret)
2419	ncret = nf90_get_var(ncid, ncvarid, dxconst)
2420	call handle_nf90_err(ncret)
2421
2422	ncret = nf90_inq_varid(ncid, 'dyconst', ncvarid)
2423	call handle_nf90_err(ncret)
2424	ncret = nf90_get_var(ncid, ncvarid, dyconst)
2425	call handle_nf90_err(ncret)
2426
2427
2428
2429
2430
2431
2432	! Fixed fields, static in time
2433
2434	#ifdef RAWBIN
2435	READ(iounit) oro, excessoro, lsm, xlanduse, height
2436	#endif
2437
2438	ncret = nf90_inq_varid(ncid, 'oro', ncvarid)
2439	call handle_nf90_err(ncret)
2440	ncret = nf90_get_var(ncid, ncvarid, oro(0:nxmax-1,0:nymax-1))
2441	call handle_nf90_err(ncret)
2442
2443	ncret = nf90_inq_varid(ncid, 'excessoro', ncvarid)
2444	call handle_nf90_err(ncret)
2445	ncret = nf90_get_var(ncid, ncvarid, excessoro(0:nxmax-1,0:nymax-1))
2446	call handle_nf90_err(ncret)
2447
2448	ncret = nf90_inq_varid(ncid, 'lsm', ncvarid)
2449	call handle_nf90_err(ncret)
2450	ncret = nf90_get_var(ncid, ncvarid, lsm(0:nxmax-1,0:nymax-1))
2451	call handle_nf90_err(ncret)
2452
2453	ncret = nf90_inq_varid(ncid, 'xlanduse', ncvarid)
2454	call handle_nf90_err(ncret)
2455	ncret = nf90_get_var(ncid, ncvarid, xlanduse(0:nxmax-1,0:nymax-1, 1:numclass))
2456	call handle_nf90_err(ncret)
2457
2458	ncret = nf90_inq_varid(ncid, 'height', ncvarid)
2459	call handle_nf90_err(ncret)
2460	ncret = nf90_get_var(ncid, ncvarid, height(1:nzmax))
2461	call handle_nf90_err(ncret)
2462
2463
2464
2465
2466	! 3d fields
2467
2468
2469
2470	#ifdef RAWBIN
2471	READ(iounit) uu(:,:,:,cm_index)
2472	READ(iounit) vv(:,:,:,cm_index)
2473	READ(iounit) uupol(:,:,:,cm_index)
2474	READ(iounit) vvpol(:,:,:,cm_index)
2475	READ(iounit) ww(:,:,:,cm_index)
2476	READ(iounit) tt(:,:,:,cm_index)
2477	READ(iounit) qv(:,:,:,cm_index)
2478	READ(iounit) pv(:,:,:,cm_index)
2479	READ(iounit) rho(:,:,:,cm_index)
2480	READ(iounit) drhodz(:,:,:,cm_index)
2481	READ(iounit) tth(:,:,:,cm_index)
2482	READ(iounit) qvh(:,:,:,cm_index)
2483	READ(iounit) pplev(:,:,:,cm_index)
2484	READ(iounit) clouds(:,:,:,cm_index)
2485	READ(iounit) cloudsh(:,:,cm_index)
2486	#endif
2487
2488
2489
2490	! Get the varid and read the variable into the array
2491	ncret = nf90_inq_varid(ncid, 'uu', ncvarid)
2492	call handle_nf90_err(ncret)
2493	ncret = nf90_get_var(ncid, ncvarid, uu(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2494	call handle_nf90_err(ncret)
2495
2496	ncret = nf90_inq_varid(ncid, 'vv', ncvarid)
2497	call handle_nf90_err(ncret)
2498	ncret = nf90_get_var(ncid, ncvarid, vv(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2499	call handle_nf90_err(ncret)
2500
2501	ncret = nf90_inq_varid(ncid, 'uupol', ncvarid)
2502	call handle_nf90_err(ncret)
2503	ncret = nf90_get_var(ncid, ncvarid, uupol(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2504	call handle_nf90_err(ncret)
2505
2506	ncret = nf90_inq_varid(ncid, 'vvpol', ncvarid)
2507	call handle_nf90_err(ncret)
2508	ncret = nf90_get_var(ncid, ncvarid, vvpol(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2509	call handle_nf90_err(ncret)
2510
2511	ncret = nf90_inq_varid(ncid, 'ww', ncvarid)
2512	call handle_nf90_err(ncret)
2513	ncret = nf90_get_var(ncid, ncvarid, ww(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2514	call handle_nf90_err(ncret)
2515
2516	ncret = nf90_inq_varid(ncid, 'tt', ncvarid)
2517	call handle_nf90_err(ncret)
2518	ncret = nf90_get_var(ncid, ncvarid, tt(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2519	call handle_nf90_err(ncret)
2520
2521	ncret = nf90_inq_varid(ncid, 'qv', ncvarid)
2522	call handle_nf90_err(ncret)
2523	ncret = nf90_get_var(ncid, ncvarid, qv(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2524	call handle_nf90_err(ncret)
2525
2526	ncret = nf90_inq_varid(ncid, 'pv', ncvarid)
2527	call handle_nf90_err(ncret)
2528	ncret = nf90_get_var(ncid, ncvarid, pv(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2529	call handle_nf90_err(ncret)
2530
2531	ncret = nf90_inq_varid(ncid, 'rho', ncvarid)
2532	call handle_nf90_err(ncret)
2533	ncret = nf90_get_var(ncid, ncvarid, rho(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2534	call handle_nf90_err(ncret)
2535
2536	ncret = nf90_inq_varid(ncid, 'drhodz', ncvarid)
2537	call handle_nf90_err(ncret)
2538	ncret = nf90_get_var(ncid, ncvarid, drhodz(0:nxmax-1,0:nymax-1,1:nzmax,cm_index))
2539	call handle_nf90_err(ncret)
2540
2541	ncret = nf90_inq_varid(ncid, 'clouds', ncvarid)
2542	call handle_nf90_err(ncret)
2543	ncret = nf90_get_var(ncid, ncvarid, clouds(0:nxmax-1,0:nzmax-1,1:nzmax,cm_index))
2544	call handle_nf90_err(ncret)
2545
2546	ncret = nf90_inq_varid(ncid, 'tth', ncvarid)
2547	call handle_nf90_err(ncret)
2548	ncret = nf90_get_var(ncid, ncvarid, tth(0:nxmax-1,0:nymax-1,1:nuvzmax,cm_index))
2549	call handle_nf90_err(ncret)
2550
2551	ncret = nf90_inq_varid(ncid, 'qvh', ncvarid)
2552	call handle_nf90_err(ncret)
2553	ncret = nf90_get_var(ncid, ncvarid, qvh(0:nxmax-1,0:nymax-1,1:nuvzmax,cm_index))
2554	call handle_nf90_err(ncret)
2555
2556	ncret = nf90_inq_varid(ncid, 'pplev', ncvarid)
2557	call handle_nf90_err(ncret)
2558	ncret = nf90_get_var(ncid, ncvarid, pplev(0:nxmax-1,0:nymax-1,1:nuvzmax,cm_index))
2559	call handle_nf90_err(ncret)
2560
2561	ncret = nf90_inq_varid(ncid, 'cloudsh', ncvarid)
2562	call handle_nf90_err(ncret)
2563	ncret = nf90_get_var(ncid, ncvarid, cloudsh(0:nxmax-1,0:nymax-1,cm_index))
2564	call handle_nf90_err(ncret)
2565
2566
2567
2568
2569	PRINT *, 'SUM(tt(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index)): ', &
2570	& SUM(tt(0:nxmax-1,0:nymax-1,1:nzmax, cm_index))
2571
2572
2573	PRINT *, 'SUM(clouds(0:nxmax-1, 0:nymax-1, 1:nzmax, cm_index)): ', &
2574	& SUM(clouds(0:nxmax-1,0:nymax-1,1:nzmax, cm_index))
2575
2576
2577
2578	! 2d fields
2579
2580
2581	#ifdef RAWBIN
2582	READ(iounit) ps(:,:,:,cm_index)
2583	READ(iounit) sd(:,:,:,cm_index)
2584	READ(iounit) msl(:,:,:,cm_index)
2585	READ(iounit) tcc(:,:,:,cm_index)
2586	READ(iounit) u10(:,:,:,cm_index)
2587	READ(iounit) v10(:,:,:,cm_index)
2588	READ(iounit) tt2(:,:,:,cm_index)
2589	READ(iounit) td2(:,:,:,cm_index)
2590	READ(iounit) lsprec(:,:,:,cm_index)
2591	READ(iounit) convprec(:,:,:,cm_index)
2592	READ(iounit) sshf(:,:,:,cm_index)
2593	READ(iounit) ssr(:,:,:,cm_index)
2594	READ(iounit) surfstr(:,:,:,cm_index)
2595	READ(iounit) ustar(:,:,:,cm_index)
2596	READ(iounit) wstar(:,:,:,cm_index)
2597	READ(iounit) hmix(:,:,:,cm_index)
2598	READ(iounit) tropopause(:,:,:,cm_index)
2599	READ(iounit) oli(:,:,:,cm_index)
2600	READ(iounit) diffk(:,:,:,cm_index)
2601	READ(iounit) vdep(:,:,:,cm_index)
2602	#endif
2603
2604
2605
2606	! Get the varid and read the variable into the array
2607	ncret = nf90_inq_varid(ncid, 'ps', ncvarid)
2608	call handle_nf90_err(ncret)
2609	ncret = nf90_get_var(ncid, ncvarid, ps(0:nxmax-1,0:nymax-1,1,cm_index))
2610	call handle_nf90_err(ncret)
2611
2612	ncret = nf90_inq_varid(ncid, 'sd', ncvarid)
2613	call handle_nf90_err(ncret)
2614	ncret = nf90_get_var(ncid, ncvarid, sd(0:nxmax-1,0:nymax-1,1,cm_index))
2615	call handle_nf90_err(ncret)
2616
2617	ncret = nf90_inq_varid(ncid, 'msl', ncvarid)
2618	call handle_nf90_err(ncret)
2619	ncret = nf90_get_var(ncid, ncvarid, msl(0:nxmax-1,0:nymax-1,1,cm_index))
2620	call handle_nf90_err(ncret)
2621
2622	ncret = nf90_inq_varid(ncid, 'tcc', ncvarid)
2623	call handle_nf90_err(ncret)
2624	ncret = nf90_get_var(ncid, ncvarid, tcc(0:nxmax-1,0:nymax-1,1,cm_index))
2625	call handle_nf90_err(ncret)
2626
2627	ncret = nf90_inq_varid(ncid, 'u10', ncvarid)
2628	call handle_nf90_err(ncret)
2629	ncret = nf90_get_var(ncid, ncvarid, u10(0:nxmax-1,0:nymax-1,1,cm_index))
2630	call handle_nf90_err(ncret)
2631
2632	ncret = nf90_inq_varid(ncid, 'v10', ncvarid)
2633	call handle_nf90_err(ncret)
2634	ncret = nf90_get_var(ncid, ncvarid, v10(0:nxmax-1,0:nymax-1,1,cm_index))
2635	call handle_nf90_err(ncret)
2636
2637	ncret = nf90_inq_varid(ncid, 'tt2', ncvarid)
2638	call handle_nf90_err(ncret)
2639	ncret = nf90_get_var(ncid, ncvarid, tt2(0:nxmax-1,0:nymax-1,1,cm_index))
2640	call handle_nf90_err(ncret)
2641
2642	ncret = nf90_inq_varid(ncid, 'td2', ncvarid)
2643	call handle_nf90_err(ncret)
2644	ncret = nf90_get_var(ncid, ncvarid, td2(0:nxmax-1,0:nymax-1,1,cm_index))
2645	call handle_nf90_err(ncret)
2646
2647	ncret = nf90_inq_varid(ncid, 'lsprec', ncvarid)
2648	call handle_nf90_err(ncret)
2649	ncret = nf90_get_var(ncid, ncvarid, lsprec(0:nxmax-1,0:nymax-1,1,cm_index))
2650	call handle_nf90_err(ncret)
2651
2652	ncret = nf90_inq_varid(ncid, 'convprec', ncvarid)
2653	call handle_nf90_err(ncret)
2654	ncret = nf90_get_var(ncid, ncvarid, convprec(0:nxmax-1,0:nymax-1,1,cm_index))
2655	call handle_nf90_err(ncret)
2656
2657	ncret = nf90_inq_varid(ncid, 'sshf', ncvarid)
2658	call handle_nf90_err(ncret)
2659	ncret = nf90_get_var(ncid, ncvarid, sshf(0:nxmax-1,0:nymax-1,1,cm_index))
2660	call handle_nf90_err(ncret)
2661
2662	ncret = nf90_inq_varid(ncid, 'ssr', ncvarid)
2663	call handle_nf90_err(ncret)
2664	ncret = nf90_get_var(ncid, ncvarid, ssr(0:nxmax-1,0:nymax-1,1,cm_index))
2665	call handle_nf90_err(ncret)
2666
2667	ncret = nf90_inq_varid(ncid, 'surfstr', ncvarid)
2668	call handle_nf90_err(ncret)
2669	ncret = nf90_get_var(ncid, ncvarid, surfstr(0:nxmax-1,0:nymax-1,1,cm_index))
2670	call handle_nf90_err(ncret)
2671
2672	ncret = nf90_inq_varid(ncid, 'ustar', ncvarid)
2673	call handle_nf90_err(ncret)
2674	ncret = nf90_get_var(ncid, ncvarid, ustar(0:nxmax-1,0:nymax-1,1,cm_index))
2675	call handle_nf90_err(ncret)
2676
2677	ncret = nf90_inq_varid(ncid, 'wstar', ncvarid)
2678	call handle_nf90_err(ncret)
2679	ncret = nf90_get_var(ncid, ncvarid, wstar(0:nxmax-1,0:nymax-1,1,cm_index))
2680	call handle_nf90_err(ncret)
2681
2682	ncret = nf90_inq_varid(ncid, 'hmix', ncvarid)
2683	call handle_nf90_err(ncret)
2684	ncret = nf90_get_var(ncid, ncvarid, hmix(0:nxmax-1,0:nymax-1,1,cm_index))
2685	call handle_nf90_err(ncret)
2686
2687	ncret = nf90_inq_varid(ncid, 'tropopause', ncvarid)
2688	call handle_nf90_err(ncret)
2689	ncret = nf90_get_var(ncid, ncvarid, tropopause(0:nxmax-1,0:nymax-1,1,cm_index))
2690	call handle_nf90_err(ncret)
2691
2692	ncret = nf90_inq_varid(ncid, 'oli', ncvarid)
2693	call handle_nf90_err(ncret)
2694	ncret = nf90_get_var(ncid, ncvarid, oli(0:nxmax-1,0:nymax-1,1,cm_index))
2695	call handle_nf90_err(ncret)
2696
2697	ncret = nf90_inq_varid(ncid, 'diffk', ncvarid)
2698	call handle_nf90_err(ncret)
2699	ncret = nf90_get_var(ncid, ncvarid, diffk(0:nxmax-1,0:nymax-1,1,cm_index))
2700	call handle_nf90_err(ncret)
2701
2702
2703
2704
2705	PRINT *, 'SUM(ps(0:nxmax-1, 0:nymax-1, 1, cm_index)): ', &
2706	& SUM(ps(0:nxmax-1,0:nymax-1,1, cm_index))
2707
2708	PRINT *, 'SUM(wstar(0:nxmax-1, 0:nymax-1, 1, cm_index)): ', &
2709	& SUM(wstar(0:nxmax-1,0:nymax-1,1, cm_index))
2710
2711
2712	ncret = nf90_inq_varid(ncid, 'vdep', ncvarid)
2713	call handle_nf90_err(ncret)
2714	ncret = nf90_get_var(ncid, ncvarid, vdep(0:nxmax-1,0:nymax-1,1:maxspec, cm_index))
2715	call handle_nf90_err(ncret)
2716
2717
2718
2719
2720
2721	! 1d fields
2722
2723	#ifdef RAWBIN
2724	READ(iounit) z0(:)
2725	READ(iounit) akm(:)
2726	READ(iounit) bkm(:)
2727	READ(iounit) akz(:)
2728	READ(iounit) bkz(:)
2729	READ(iounit) aknew(:)
2730	READ(iounit) bknew(:)
2731	#endif
2732
2733	ncret = nf90_inq_varid(ncid, 'z0', ncvarid)
2734	call handle_nf90_err(ncret)
2735	ncret = nf90_get_var(ncid, ncvarid, z0(1:numclass))
2736	call handle_nf90_err(ncret)
2737
2738	ncret = nf90_inq_varid(ncid, 'akm', ncvarid)
2739	call handle_nf90_err(ncret)
2740	ncret = nf90_get_var(ncid, ncvarid, akm(1:nwzmax))
2741	call handle_nf90_err(ncret)
2742
2743	ncret = nf90_inq_varid(ncid, 'bkm', ncvarid)
2744	call handle_nf90_err(ncret)
2745	ncret = nf90_get_var(ncid, ncvarid, bkm(1:nwzmax))
2746	call handle_nf90_err(ncret)
2747
2748	ncret = nf90_inq_varid(ncid, 'akz', ncvarid)
2749	call handle_nf90_err(ncret)
2750	ncret = nf90_get_var(ncid, ncvarid, akz(1:nuvzmax))
2751	call handle_nf90_err(ncret)
2752
2753	ncret = nf90_inq_varid(ncid, 'bkz', ncvarid)
2754	call handle_nf90_err(ncret)
2755	ncret = nf90_get_var(ncid, ncvarid, bkz(1:nuvzmax))
2756	call handle_nf90_err(ncret)
2757
2758	ncret = nf90_inq_varid(ncid, 'aknew', ncvarid)
2759	call handle_nf90_err(ncret)
2760	ncret = nf90_get_var(ncid, ncvarid, aknew(1:nzmax))
2761	call handle_nf90_err(ncret)
2762
2763	ncret = nf90_inq_varid(ncid, 'bknew', ncvarid)
2764	call handle_nf90_err(ncret)
2765	ncret = nf90_get_var(ncid, ncvarid, bknew(1:nzmax))
2766	call handle_nf90_err(ncret)
2767
2768
2769
2770	PRINT *, 'SUM(bknew(1:nzmax)): ', &
2771	& SUM(bknew(1:nzmax))
2772
2773
2774
2775
2776	! Now the nested input grid variables
2777	! Get the compiled values that were written into the FP file, and
2778	! make sure they are equal to the current compiled values, to make
2779	! sure we are working with consistent arrays
2780	ncret = nf90_inq_dimid(ncid, 'maxnests', maxnests_dimid)
2781	call handle_nf90_err(ncret)
2782	ncret = nf90_inquire_dimension(ncid, maxnests_dimid, maxnests_dimname, &
2783	& temp_maxnests)
2784	call handle_nf90_err(ncret)
2785	PRINT *, 'temp_maxnests: ', temp_maxnests
2786
2787	ncret = nf90_inq_dimid(ncid, 'nxmaxn', nxmaxn_dimid)
2788	call handle_nf90_err(ncret)
2789	ncret = nf90_inquire_dimension(ncid, nxmaxn_dimid, nxmaxn_dimname, &
2790	& temp_nxmaxn)
2791	call handle_nf90_err(ncret)
2792	PRINT *, 'temp_nxmaxn: ', temp_nxmaxn
2793
2794	ncret = nf90_inq_dimid(ncid, 'nymaxn', nymaxn_dimid)
2795	call handle_nf90_err(ncret)
2796	ncret = nf90_inquire_dimension(ncid, nymaxn_dimid, nymaxn_dimname, &
2797	& temp_nymaxn)
2798	call handle_nf90_err(ncret)
2799	PRINT *, 'temp_nymaxn: ', temp_nymaxn
2800
2801	! Note that maxspec_dimid and numclass_dimid were checked above
2802
2803
2804
2805
2806	IF ( (temp_nxmaxn == nxmaxn) .AND. (temp_nymaxn == nymaxn) .AND. &
2807	& (temp_maxnests == maxnests) ) THEN
2808	CONTINUE
2809	ELSE
2810	PRINT *, 'Incompatible dimensions between fp file and current FLEXPART!'
2811	! PRINT *, ''
2812	PRINT *, ' FP file Compiled FP'
2813	PRINT *, 'nxmaxn: ', temp_nxmaxn, ' ', nxmaxn
2814	PRINT *, 'nymaxn: ', temp_nymaxn, ' ', nymaxn
2815	PRINT *, 'maxnests: ', temp_maxnests, ' ', maxnests
2816	STOP
2817	END IF
2818
2819
2820
2821	! Nested, scalar values (for each nest)
2822
2823
2824
2825
2826	#ifdef RAWBIN
2827	READ(iounit) nxn(:)
2828	READ(iounit) nyn(:)
2829	READ(iounit) dxn(:)
2830	READ(iounit) dyn(:)
2831	READ(iounit) xlon0n(:)
2832	READ(iounit) ylat0n(:)
2833	#endif
2834
2835
2836	ncret = nf90_inq_varid(ncid, 'nxn', ncvarid)
2837	call handle_nf90_err(ncret)
2838	ncret = nf90_get_var(ncid, ncvarid, nxn(1:maxnests))
2839	call handle_nf90_err(ncret)
2840
2841	ncret = nf90_inq_varid(ncid, 'nyn', ncvarid)
2842	call handle_nf90_err(ncret)
2843	ncret = nf90_get_var(ncid, ncvarid, nyn(1:maxnests))
2844	call handle_nf90_err(ncret)
2845
2846	ncret = nf90_inq_varid(ncid, 'dxn', ncvarid)
2847	call handle_nf90_err(ncret)
2848	ncret = nf90_get_var(ncid, ncvarid, dxn(1:maxnests))
2849	call handle_nf90_err(ncret)
2850
2851	ncret = nf90_inq_varid(ncid, 'dyn', ncvarid)
2852	call handle_nf90_err(ncret)
2853	ncret = nf90_get_var(ncid, ncvarid, dyn(1:maxnests))
2854	call handle_nf90_err(ncret)
2855
2856	ncret = nf90_inq_varid(ncid, 'xlon0n', ncvarid)
2857	call handle_nf90_err(ncret)
2858	ncret = nf90_get_var(ncid, ncvarid, xlon0n(1:maxnests))
2859	call handle_nf90_err(ncret)
2860
2861	ncret = nf90_inq_varid(ncid, 'ylat0n', ncvarid)
2862	call handle_nf90_err(ncret)
2863	ncret = nf90_get_var(ncid, ncvarid, ylat0n(1:maxnests))
2864	call handle_nf90_err(ncret)
2865
2866
2867
2868	! Nested fields, static over time
2869	READ(iounit) oron, excessoron, lsmn, xlandusen
2870
2871	ncret = nf90_inq_varid(ncid, 'oron', ncvarid)
2872	call handle_nf90_err(ncret)
2873	ncret = nf90_get_var(ncid, ncvarid, oron(0:nxmaxn-1,0:nymaxn-1,1:maxnests))
2874	call handle_nf90_err(ncret)
2875
2876	ncret = nf90_inq_varid(ncid, 'excessoron', ncvarid)
2877	call handle_nf90_err(ncret)
2878	ncret = nf90_get_var(ncid, ncvarid, excessoron(0:nxmaxn-1,0:nymaxn-1,1:maxnests))
2879	call handle_nf90_err(ncret)
2880
2881	ncret = nf90_inq_varid(ncid, 'lsmn', ncvarid)
2882	call handle_nf90_err(ncret)
2883	ncret = nf90_get_var(ncid, ncvarid, lsmn(0:nxmaxn-1,0:nymaxn-1,1:maxnests))
2884	call handle_nf90_err(ncret)
2885
2886	ncret = nf90_inq_varid(ncid, 'xlandusen', ncvarid)
2887	call handle_nf90_err(ncret)
2888	ncret = nf90_get_var(ncid, ncvarid, xlandusen(0:nxmaxn-1,0:nymaxn-1,1:numclass,1:maxnests))
2889	call handle_nf90_err(ncret)
2890
2891
2892	PRINT *, 'SUM(oron): ', SUM(oron)
2893
2894
2895
2896
2897	! 3d nested fields
2898
2899	#ifdef RAWBIN
2900	READ(iounit) uun(:,:,:,cm_index,:)
2901	READ(iounit) vvn(:,:,:,cm_index,:)
2902	READ(iounit) wwn(:,:,:,cm_index,:)
2903	READ(iounit) ttn(:,:,:,cm_index,:)
2904	READ(iounit) qvn(:,:,:,cm_index,:)
2905	READ(iounit) pvn(:,:,:,cm_index,:)
2906	READ(iounit) cloudsn(:,:,:,cm_index,:)
2907	READ(iounit) cloudsnh(:,:,cm_index,:)
2908	READ(iounit) rhon(:,:,:,cm_index,:)
2909	READ(iounit) drhodzn(:,:,:,cm_index,:)
2910	READ(iounit) tthn(:,:,:,cm_index,:)
2911	READ(iounit) qvhn(:,:,:,cm_index,:)
2912	#endif
2913
2914	ncret = nf90_inq_varid(ncid, 'uun', ncvarid)
2915	call handle_nf90_err(ncret)
2916	ncret = nf90_get_var(ncid, ncvarid, uun(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2917	call handle_nf90_err(ncret)
2918
2919	ncret = nf90_inq_varid(ncid, 'vvn', ncvarid)
2920	call handle_nf90_err(ncret)
2921	ncret = nf90_get_var(ncid, ncvarid, vvn(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2922	call handle_nf90_err(ncret)
2923
2924	ncret = nf90_inq_varid(ncid, 'wwn', ncvarid)
2925	call handle_nf90_err(ncret)
2926	ncret = nf90_get_var(ncid, ncvarid, wwn(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2927	call handle_nf90_err(ncret)
2928
2929	ncret = nf90_inq_varid(ncid, 'ttn', ncvarid)
2930	call handle_nf90_err(ncret)
2931	ncret = nf90_get_var(ncid, ncvarid, ttn(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2932	call handle_nf90_err(ncret)
2933
2934	ncret = nf90_inq_varid(ncid, 'qvn', ncvarid)
2935	call handle_nf90_err(ncret)
2936	ncret = nf90_get_var(ncid, ncvarid, qvn(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2937	call handle_nf90_err(ncret)
2938
2939	ncret = nf90_inq_varid(ncid, 'pvn', ncvarid)
2940	call handle_nf90_err(ncret)
2941	ncret = nf90_get_var(ncid, ncvarid, pvn(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2942	call handle_nf90_err(ncret)
2943
2944	ncret = nf90_inq_varid(ncid, 'rhon', ncvarid)
2945	call handle_nf90_err(ncret)
2946	ncret = nf90_get_var(ncid, ncvarid, rhon(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2947	call handle_nf90_err(ncret)
2948
2949	ncret = nf90_inq_varid(ncid, 'drhodzn', ncvarid)
2950	call handle_nf90_err(ncret)
2951	ncret = nf90_get_var(ncid, ncvarid, drhodzn(0:nxmaxn-1,0:nymaxn-1,1:nzmax,cm_index,1:maxnests))
2952	call handle_nf90_err(ncret)
2953
2954	ncret = nf90_inq_varid(ncid, 'tthn', ncvarid)
2955	call handle_nf90_err(ncret)
2956	ncret = nf90_get_var(ncid, ncvarid, tthn(0:nxmaxn-1,0:nymaxn-1,1:nuvzmax,cm_index,1:maxnests))
2957	call handle_nf90_err(ncret)
2958
2959	ncret = nf90_inq_varid(ncid, 'qvhn', ncvarid)
2960	call handle_nf90_err(ncret)
2961	ncret = nf90_get_var(ncid, ncvarid, qvhn(0:nxmaxn-1,0:nymaxn-1,1:nuvzmax,cm_index,1:maxnests))
2962	call handle_nf90_err(ncret)
2963
2964	ncret = nf90_inq_varid(ncid, 'cloudsn', ncvarid)
2965	call handle_nf90_err(ncret)
2966	ncret = nf90_get_var(ncid, ncvarid, cloudsn(0:nxmaxn-1,0:nymaxn-1,0:nzmax,cm_index,1:maxnests))
2967	call handle_nf90_err(ncret)
2968
2969	ncret = nf90_inq_varid(ncid, 'cloudsnh', ncvarid)
2970	call handle_nf90_err(ncret)
2971	ncret = nf90_get_var(ncid, ncvarid, cloudsnh(0:nxmaxn-1,0:nymaxn-1,cm_index,1:maxnests))
2972	call handle_nf90_err(ncret)
2973
2974
2975
2976
2977	PRINT *, 'SUM(uun): ', SUM(uun(:,:,:,cm_index,:))
2978	PRINT *, 'SUM(qvhn): ', SUM(qvhn(:,:,:,cm_index,:))
2979	PRINT *, 'SUM(cloudsn): ', SUM(cloudsn(:,:,:,cm_index,:))
2980
2981
2982
2983
2984	! 2d nested fields
2985
2986
2987	#ifdef RAWBIN
2988	READ(iounit) psn(:,:,:,cm_index,:)
2989	READ(iounit) sdn(:,:,:,cm_index,:)
2990	READ(iounit) msln(:,:,:,cm_index,:)
2991	READ(iounit) tccn(:,:,:,cm_index,:)
2992	READ(iounit) u10n(:,:,:,cm_index,:)
2993	READ(iounit) v10n(:,:,:,cm_index,:)
2994	READ(iounit) tt2n(:,:,:,cm_index,:)
2995	READ(iounit) td2n(:,:,:,cm_index,:)
2996	READ(iounit) lsprecn(:,:,:,cm_index,:)
2997	READ(iounit) convprecn(:,:,:,cm_index,:)
2998	READ(iounit) sshfn(:,:,:,cm_index,:)
2999	READ(iounit) ssrn(:,:,:,cm_index,:)
3000	READ(iounit) surfstrn(:,:,:,cm_index,:)
3001	READ(iounit) ustarn(:,:,:,cm_index,:)
3002	READ(iounit) wstarn(:,:,:,cm_index,:)
3003	READ(iounit) hmixn(:,:,:,cm_index,:)
3004	READ(iounit) tropopausen(:,:,:,cm_index,:)
3005	READ(iounit) olin(:,:,:,cm_index,:)
3006	READ(iounit) diffkn(:,:,:,cm_index,:)
3007	READ(iounit) vdepn(:,:,:,cm_index,:)
3008	#endif
3009
3010
3011	ncret = nf90_inq_varid(ncid, 'psn', ncvarid)
3012	call handle_nf90_err(ncret)
3013	ncret = nf90_get_var(ncid, ncvarid, psn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3014	call handle_nf90_err(ncret)
3015
3016	ncret = nf90_inq_varid(ncid, 'sdn', ncvarid)
3017	call handle_nf90_err(ncret)
3018	ncret = nf90_get_var(ncid, ncvarid, sdn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3019	call handle_nf90_err(ncret)
3020
3021	ncret = nf90_inq_varid(ncid, 'msln', ncvarid)
3022	call handle_nf90_err(ncret)
3023	ncret = nf90_get_var(ncid, ncvarid, msln(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3024	call handle_nf90_err(ncret)
3025
3026	ncret = nf90_inq_varid(ncid, 'tccn', ncvarid)
3027	call handle_nf90_err(ncret)
3028	ncret = nf90_get_var(ncid, ncvarid, tccn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3029	call handle_nf90_err(ncret)
3030
3031	ncret = nf90_inq_varid(ncid, 'u10n', ncvarid)
3032	call handle_nf90_err(ncret)
3033	ncret = nf90_get_var(ncid, ncvarid, u10n(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3034	call handle_nf90_err(ncret)
3035
3036	ncret = nf90_inq_varid(ncid, 'v10n', ncvarid)
3037	call handle_nf90_err(ncret)
3038	ncret = nf90_get_var(ncid, ncvarid, v10n(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3039	call handle_nf90_err(ncret)
3040
3041	ncret = nf90_inq_varid(ncid, 'tt2n', ncvarid)
3042	call handle_nf90_err(ncret)
3043	ncret = nf90_get_var(ncid, ncvarid, tt2n(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3044	call handle_nf90_err(ncret)
3045
3046	ncret = nf90_inq_varid(ncid, 'td2n', ncvarid)
3047	call handle_nf90_err(ncret)
3048	ncret = nf90_get_var(ncid, ncvarid, td2n(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3049	call handle_nf90_err(ncret)
3050
3051	ncret = nf90_inq_varid(ncid, 'lsprecn', ncvarid)
3052	call handle_nf90_err(ncret)
3053	ncret = nf90_get_var(ncid, ncvarid, lsprecn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3054	call handle_nf90_err(ncret)
3055
3056	ncret = nf90_inq_varid(ncid, 'convprecn', ncvarid)
3057	call handle_nf90_err(ncret)
3058	ncret = nf90_get_var(ncid, ncvarid, convprecn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3059	call handle_nf90_err(ncret)
3060
3061	ncret = nf90_inq_varid(ncid, 'sshfn', ncvarid)
3062	call handle_nf90_err(ncret)
3063	ncret = nf90_get_var(ncid, ncvarid, sshfn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3064	call handle_nf90_err(ncret)
3065
3066	ncret = nf90_inq_varid(ncid, 'ssrn', ncvarid)
3067	call handle_nf90_err(ncret)
3068	ncret = nf90_get_var(ncid, ncvarid, ssrn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3069	call handle_nf90_err(ncret)
3070
3071	ncret = nf90_inq_varid(ncid, 'surfstrn', ncvarid)
3072	call handle_nf90_err(ncret)
3073	ncret = nf90_get_var(ncid, ncvarid, surfstrn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3074	call handle_nf90_err(ncret)
3075
3076	ncret = nf90_inq_varid(ncid, 'ustarn', ncvarid)
3077	call handle_nf90_err(ncret)
3078	ncret = nf90_get_var(ncid, ncvarid, ustarn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3079	call handle_nf90_err(ncret)
3080
3081	ncret = nf90_inq_varid(ncid, 'wstarn', ncvarid)
3082	call handle_nf90_err(ncret)
3083	ncret = nf90_get_var(ncid, ncvarid, wstarn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3084	call handle_nf90_err(ncret)
3085
3086	ncret = nf90_inq_varid(ncid, 'hmixn', ncvarid)
3087	call handle_nf90_err(ncret)
3088	ncret = nf90_get_var(ncid, ncvarid, hmixn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3089	call handle_nf90_err(ncret)
3090
3091	ncret = nf90_inq_varid(ncid, 'tropopausen', ncvarid)
3092	call handle_nf90_err(ncret)
3093	ncret = nf90_get_var(ncid, ncvarid, tropopausen(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3094	call handle_nf90_err(ncret)
3095
3096	ncret = nf90_inq_varid(ncid, 'olin', ncvarid)
3097	call handle_nf90_err(ncret)
3098	ncret = nf90_get_var(ncid, ncvarid, olin(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3099	call handle_nf90_err(ncret)
3100
3101	ncret = nf90_inq_varid(ncid, 'diffkn', ncvarid)
3102	call handle_nf90_err(ncret)
3103	ncret = nf90_get_var(ncid, ncvarid, diffkn(0:nxmaxn-1,0:nymaxn-1,1,cm_index,1:maxnests))
3104	call handle_nf90_err(ncret)
3105
3106	ncret = nf90_inq_varid(ncid, 'vdepn', ncvarid)
3107	call handle_nf90_err(ncret)
3108	ncret = nf90_get_var(ncid, ncvarid, vdepn(0:nxmaxn-1,0:nymaxn-1,1:maxspec,cm_index,1:maxnests))
3109	call handle_nf90_err(ncret)
3110
3111
3112
3113
3114	PRINT *, 'SUM(psn): ', SUM(psn(:,:,:,cm_index,:))
3115	PRINT *, 'SUM(surfstrn): ', SUM(surfstrn(:,:,:,cm_index,:))
3116	PRINT *, 'SUM(vdepn): ', SUM(vdepn(:,:,:,cm_index,:))
3117
3118
3119
3120	! Auxiliary variables for nests
3121
3122
3123	#ifdef RAWBIN
3124	READ(iounit) xresoln(:)
3125	READ(iounit) yresoln(:)
3126	READ(iounit) xln(:)
3127	READ(iounit) yln(:)
3128	READ(iounit) xrn(:)
3129	READ(iounit) yrn(:)
3130	#endif
3131
3132
3133	ncret = nf90_inq_varid(ncid, 'xresoln', ncvarid)
3134	call handle_nf90_err(ncret)
3135	ncret = nf90_get_var(ncid, ncvarid, xresoln(0:maxnests))
3136	call handle_nf90_err(ncret)
3137
3138	ncret = nf90_inq_varid(ncid, 'yresoln', ncvarid)
3139	call handle_nf90_err(ncret)
3140	ncret = nf90_get_var(ncid, ncvarid, yresoln(0:maxnests))
3141	call handle_nf90_err(ncret)
3142
3143	ncret = nf90_inq_varid(ncid, 'xln', ncvarid)
3144	call handle_nf90_err(ncret)
3145	ncret = nf90_get_var(ncid, ncvarid, xln(1:maxnests))
3146	call handle_nf90_err(ncret)
3147
3148	ncret = nf90_inq_varid(ncid, 'yln', ncvarid)
3149	call handle_nf90_err(ncret)
3150	ncret = nf90_get_var(ncid, ncvarid, yln(1:maxnests))
3151	call handle_nf90_err(ncret)
3152
3153	ncret = nf90_inq_varid(ncid, 'xrn', ncvarid)
3154	call handle_nf90_err(ncret)
3155	ncret = nf90_get_var(ncid, ncvarid, xrn(1:maxnests))
3156	call handle_nf90_err(ncret)
3157
3158	ncret = nf90_inq_varid(ncid, 'yrn', ncvarid)
3159	call handle_nf90_err(ncret)
3160	ncret = nf90_get_var(ncid, ncvarid, yrn(1:maxnests))
3161	call handle_nf90_err(ncret)
3162
3163
3164
3165	PRINT *, 'SUM(yresoln): ', SUM(yresoln)
3166	PRINT *, 'SUM(xrn): ', SUM(xrn)
3167
3168
3169
3170	! Variables for polar stereographic projection
3171
3172
3173	#ifdef RAWBIN
3174	READ(iounit) xglobal, sglobal, nglobal
3175	READ(iounit) switchnorthg, switchsouthg
3176	READ(iounit) southpolemap(:)
3177	READ(iounit) northpolemap(:)
3178	#endif
3179
3180	ncret = nf90_inq_varid(ncid, 'southpolemap', ncvarid)
3181	call handle_nf90_err(ncret)
3182	ncret = nf90_get_var(ncid, ncvarid, southpolemap(:))
3183	call handle_nf90_err(ncret)
3184
3185	ncret = nf90_inq_varid(ncid, 'northpolemap', ncvarid)
3186	call handle_nf90_err(ncret)
3187	ncret = nf90_get_var(ncid, ncvarid, northpolemap(:))
3188	call handle_nf90_err(ncret)
3189
3190	! xglobal, sglobal, nglobal are LOGICAL vars, and need to be converted
3191	! to INTEGER for NetCDF storage
3192	ncret = nf90_inq_varid(ncid, 'xglobal', ncvarid)
3193	call handle_nf90_err(ncret)
3194	ncret = nf90_get_var(ncid, ncvarid, temp_integer)
3195	call handle_nf90_err(ncret)
3196	xglobal = integer2logical(temp_integer)
3197
3198	ncret = nf90_inq_varid(ncid, 'sglobal', ncvarid)
3199	call handle_nf90_err(ncret)
3200	ncret = nf90_get_var(ncid, ncvarid, temp_integer)
3201	call handle_nf90_err(ncret)
3202	sglobal = integer2logical(temp_integer)
3203
3204	ncret = nf90_inq_varid(ncid, 'nglobal', ncvarid)
3205	call handle_nf90_err(ncret)
3206	ncret = nf90_get_var(ncid, ncvarid, temp_integer)
3207	call handle_nf90_err(ncret)
3208	nglobal = integer2logical(temp_integer)
3209
3210	ncret = nf90_inq_varid(ncid, 'switchnorthg', ncvarid)
3211	call handle_nf90_err(ncret)
3212	ncret = nf90_get_var(ncid, ncvarid, switchnorthg)
3213	call handle_nf90_err(ncret)
3214
3215	ncret = nf90_inq_varid(ncid, 'switchsouthg', ncvarid)
3216	call handle_nf90_err(ncret)
3217	ncret = nf90_get_var(ncid, ncvarid, switchsouthg)
3218	call handle_nf90_err(ncret)
3219
3220
3221	PRINT *, 'SUM(northpolemap): ', SUM(northpolemap)
3222	PRINT *, 'xglobal: ', xglobal
3223	PRINT *, 'sglobal: ', sglobal
3224	PRINT *, 'nglobal: ', nglobal
3225	PRINT *, 'switchsouthg: ', switchsouthg
3226
3227
3228
3229
3230	! Variables declared in conv_mod (convection)
3231
3232
3233	#ifdef RAWBIN
3234	READ(iounit) pconv(:)
3235	READ(iounit) phconv(:)
3236	READ(iounit) dpr(:)
3237	READ(iounit) pconv_hpa(:)
3238	READ(iounit) phconv_hpa(:)
3239	READ(iounit) ft(:)
3240	READ(iounit) fq(:)
3241	READ(iounit) fmass(:,:)
3242	READ(iounit) sub(:)
3243	READ(iounit) fmassfrac(:,:)
3244	READ(iounit) cbaseflux(:,:)
3245	READ(iounit) cbasefluxn(:,:,:)
3246	READ(iounit) tconv(:)
3247	READ(iounit) qconv(:)
3248	READ(iounit) qsconv(:)
3249	READ(iounit) psconv, tt2conv, td2conv
3250	READ(iounit) nconvlev, nconvtop
3251	#endif
3252
3253
3254
3255	ncret = nf90_inq_varid(ncid, 'pconv', ncvarid)
3256	call handle_nf90_err(ncret)
3257	ncret = nf90_get_var(ncid, ncvarid, pconv(:))
3258	call handle_nf90_err(ncret)
3259
3260	ncret = nf90_inq_varid(ncid, 'dpr', ncvarid)
3261	call handle_nf90_err(ncret)
3262	ncret = nf90_get_var(ncid, ncvarid, dpr(:))
3263	call handle_nf90_err(ncret)
3264
3265	ncret = nf90_inq_varid(ncid, 'pconv_hpa', ncvarid)
3266	call handle_nf90_err(ncret)
3267	ncret = nf90_get_var(ncid, ncvarid, pconv_hpa(:))
3268	call handle_nf90_err(ncret)
3269
3270	ncret = nf90_inq_varid(ncid, 'ft', ncvarid)
3271	call handle_nf90_err(ncret)
3272	ncret = nf90_get_var(ncid, ncvarid, ft(:))
3273	call handle_nf90_err(ncret)
3274
3275	ncret = nf90_inq_varid(ncid, 'fq', ncvarid)
3276	call handle_nf90_err(ncret)
3277	ncret = nf90_get_var(ncid, ncvarid, fq(:))
3278	call handle_nf90_err(ncret)
3279
3280	ncret = nf90_inq_varid(ncid, 'sub', ncvarid)
3281	call handle_nf90_err(ncret)
3282	ncret = nf90_get_var(ncid, ncvarid, sub(:))
3283	call handle_nf90_err(ncret)
3284
3285	ncret = nf90_inq_varid(ncid, 'phconv', ncvarid)
3286	call handle_nf90_err(ncret)
3287	ncret = nf90_get_var(ncid, ncvarid, phconv(:))
3288	call handle_nf90_err(ncret)
3289
3290	ncret = nf90_inq_varid(ncid, 'phconv_hpa', ncvarid)
3291	call handle_nf90_err(ncret)
3292	ncret = nf90_get_var(ncid, ncvarid, phconv_hpa(:))
3293	call handle_nf90_err(ncret)
3294
3295	ncret = nf90_inq_varid(ncid, 'tconv', ncvarid)
3296	call handle_nf90_err(ncret)
3297	ncret = nf90_get_var(ncid, ncvarid, tconv(:))
3298	call handle_nf90_err(ncret)
3299
3300	ncret = nf90_inq_varid(ncid, 'qconv', ncvarid)
3301	call handle_nf90_err(ncret)
3302	ncret = nf90_get_var(ncid, ncvarid, qconv(:))
3303	call handle_nf90_err(ncret)
3304
3305	ncret = nf90_inq_varid(ncid, 'qsconv', ncvarid)
3306	call handle_nf90_err(ncret)
3307	ncret = nf90_get_var(ncid, ncvarid, qsconv(:))
3308	call handle_nf90_err(ncret)
3309
3310	ncret = nf90_inq_varid(ncid, 'fmass', ncvarid)
3311	call handle_nf90_err(ncret)
3312	ncret = nf90_get_var(ncid, ncvarid, fmass(:,:))
3313	call handle_nf90_err(ncret)
3314
3315	ncret = nf90_inq_varid(ncid, 'fmassfrac', ncvarid)
3316	call handle_nf90_err(ncret)
3317	ncret = nf90_get_var(ncid, ncvarid, fmassfrac(:,:))
3318	call handle_nf90_err(ncret)
3319
3320	ncret = nf90_inq_varid(ncid, 'cbaseflux', ncvarid)
3321	call handle_nf90_err(ncret)
3322	ncret = nf90_get_var(ncid, ncvarid, cbaseflux(0:nxmax-1,0:nymax-1))
3323	call handle_nf90_err(ncret)
3324
3325	ncret = nf90_inq_varid(ncid, 'cbasefluxn', ncvarid)
3326	call handle_nf90_err(ncret)
3327	ncret = nf90_get_var(ncid, ncvarid, cbasefluxn(0:nxmaxn-1,0:nymaxn-1,1:maxnests))
3328	call handle_nf90_err(ncret)
3329
3330	ncret = nf90_inq_varid(ncid, 'psconv', ncvarid)
3331	call handle_nf90_err(ncret)
3332	ncret = nf90_get_var(ncid, ncvarid, psconv)
3333	call handle_nf90_err(ncret)
3334
3335	ncret = nf90_inq_varid(ncid, 'tt2conv', ncvarid)
3336	call handle_nf90_err(ncret)
3337	ncret = nf90_get_var(ncid, ncvarid, tt2conv)
3338	call handle_nf90_err(ncret)
3339
3340	ncret = nf90_inq_varid(ncid, 'td2conv', ncvarid)
3341	call handle_nf90_err(ncret)
3342	ncret = nf90_get_var(ncid, ncvarid, td2conv)
3343	call handle_nf90_err(ncret)
3344
3345	ncret = nf90_inq_varid(ncid, 'nconvlev', ncvarid)
3346	call handle_nf90_err(ncret)
3347	ncret = nf90_get_var(ncid, ncvarid, nconvlev)
3348	call handle_nf90_err(ncret)
3349
3350	ncret = nf90_inq_varid(ncid, 'nconvtop', ncvarid)
3351	call handle_nf90_err(ncret)
3352	ncret = nf90_get_var(ncid, ncvarid, nconvtop)
3353	call handle_nf90_err(ncret)
3354
3355
3356
3357
3358	PRINT *, 'SUM(pconv): ', SUM(pconv)
3359	PRINT *, 'SUM(qconv): ', SUM(qconv)
3360	PRINT *, 'SUM(fmassfrac): ', SUM(fmassfrac)
3361	PRINT *, 'SUM(cbasefluxn): ', SUM(cbasefluxn)
3362	PRINT *, 'tt2conv: ', tt2conv
3363	PRINT *, 'nconvlev: ', nconvlev
3364
3365
3366
3367	ELSE
3368	STOP 'fpio(): Illegal operation'
3369
3370	ENDIF
3371	END SUBROUTINE fpio
3372
3373	SUBROUTINE fpmetbinary_filetext(filename, cm_index)
3374
3375	! This is a utility subroutine meant to be used for testing purposes.
3376	! It facilitates the text output of variables read in from the
3377	! specified .fp file. This routine will easily cause the program
3378	! to crash due memory allocation issues, particularly when you are
3379	! trying to text print 3d arrays in a single formatted statetment.
3380
3381	CHARACTER(LEN=*), INTENT(IN) :: filename
3382	INTEGER, INTENT(IN) :: cm_index ! Index of last dimension in
3383	! most com_mod variables.
3384	! Should be 1 or 2
3385
3386	!OPEN(IOUNIT_TEXTOUT, file=filename, action='WRITE', status='REPLACE', &
3387	! form="formatted", access="stream")
3388	OPEN(IOUNIT_TEXTOUT, file=filename, action='WRITE', &
3389	form="formatted", access="APPEND")
3390
3391	WRITE(IOUNIT_TEXTOUT, *) 'oro: ', oro
3392	WRITE(IOUNIT_TEXTOUT, *) 'excessoro: ', excessoro
3393	WRITE(IOUNIT_TEXTOUT, *) 'lsm: ', lsm
3394	WRITE(IOUNIT_TEXTOUT, *) 'xlanduse: ', xlanduse
3395	WRITE(IOUNIT_TEXTOUT, *) 'height: ', height
3396
3397	WRITE(IOUNIT_TEXTOUT, *) 'uu: ', uu(:,:,:,cm_index)
3398	WRITE(IOUNIT_TEXTOUT, *) 'vv: ', vv(:,:,:,cm_index)
3399	WRITE(IOUNIT_TEXTOUT, *) 'uupol: ', uupol(:,:,:,cm_index)
3400	WRITE(IOUNIT_TEXTOUT, *) 'vvpol: ', vvpol(:,:,:,cm_index)
3401	WRITE(IOUNIT_TEXTOUT, *) 'ww: ', ww(:,:,:,cm_index)
3402	WRITE(IOUNIT_TEXTOUT, *) 'tt: ', tt(:,:,:,cm_index)
3403	WRITE(IOUNIT_TEXTOUT, *) 'qv: ', qv(:,:,:,cm_index)
3404	WRITE(IOUNIT_TEXTOUT, *) 'pv: ', pv(:,:,:,cm_index)
3405	WRITE(IOUNIT_TEXTOUT, *) 'rho: ', rho(:,:,:,cm_index)
3406	WRITE(IOUNIT_TEXTOUT, *) 'drhodz: ', drhodz(:,:,:,cm_index)
3407	WRITE(IOUNIT_TEXTOUT, *) 'tth: ', tth(:,:,:,cm_index)
3408	WRITE(IOUNIT_TEXTOUT, *) 'qvh: ', qvh(:,:,:,cm_index)
3409	WRITE(IOUNIT_TEXTOUT, *) 'pplev: ', pplev(:,:,:,cm_index)
3410	WRITE(IOUNIT_TEXTOUT, *) 'clouds: ', clouds(:,:,:,cm_index)
3411	WRITE(IOUNIT_TEXTOUT, *) 'cloudsh: ', cloudsh(:,:,cm_index)
3412
3413
3414
3415
3416	CLOSE(IOUNIT_TEXTOUT)
3417	END SUBROUTINE fpmetbinary_filetext
3418
3419	subroutine handle_nf90_err(status)
3420
3421	! Custom routine for checking NF90 error status
3422	! and aborting if necessary
3423	use netcdf
3424	implicit none
3425	integer, intent (in) :: status
3426
3427	if (status /= nf90_noerr) then
3428	print *, trim(nf90_strerror(status))
3429	stop "Stopped..."
3430	endif
3431	end subroutine handle_nf90_err
3432
3433
3434	INTEGER FUNCTION logical2integer(logical_value)
3435	IMPLICIT NONE
3436
3437	! Auxiliary function to convert logical values to
3438	! integers. THIS DOES NO TYPE CHECKING!!!
3439
3440
3441	LOGICAL, INTENT(IN) :: logical_value
3442
3443	IF (logical_value .EQV. .TRUE.) THEN
3444	logical2integer = 1
3445	ELSE
3446	logical2integer = 0
3447	ENDIF
3448
3449	RETURN
3450
3451	END FUNCTION logical2integer
3452
3453
3454	LOGICAL FUNCTION integer2logical(integer_value)
3455	IMPLICIT NONE
3456
3457	! Auxiliary function to convert integer values to
3458	! logical. THIS DOES NO TYPE CHECKING!!!
3459
3460
3461	INTEGER, INTENT(IN) :: integer_value
3462
3463	IF (integer_value .EQ. 0) THEN
3464	integer2logical = .FALSE.
3465	ELSE
3466	integer2logical = .TRUE.
3467	ENDIF
3468
3469	RETURN
3470
3471	END FUNCTION integer2logical
3472
3473
3474	END MODULE fpmetbinary_mod

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format