Context Navigation

fpmetbinary_mod.F90 @ 515b21c

fp9.3.1-20161214-nc4

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

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

Download in other formats:

Original Format