Context Navigation

read_ncdf_varget.pro @ 378

Last change on this file since 378 was 292, checked in by pinsard, 17 years ago
typo
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 24.5 KB

Line
1	;+
2	;
3	; @todo seb
4	;
5	;-
6	; le format netcdf et IDL nous permet d''aller lire uniquement la partie de
7	; tableau qui nous interesse.
8	;
9	; attention, qd il y a un shift il faut faire attention a ce que
10	; l''on fait et en particulier arriver a positionner la boite
11	; specifiee par firstx:lastx par rapport au tableau contenu dans
12	; le fichier NetCdf.
13	; pour s''y reperer voici un petit dessin
14	;
15	; dans le repere 0:jpi, avec le zoom definit par firstx:lastx
16	;
17	; 0 j key-1 key i jpi-1
18	; \|......\|........\| \|-----------\|----------------\|
19	;
20	; si on veut savoir comment c''etait avant le shift:
21	;
22	; 0 i-key jpi-key-1 jpi-key jpi-key+j jpi-1
23	; \|--------\|--------------\| \|........\|..........\|
24	;
25	; avant que l''on ajuste au zoom definit par ixminmesh,ixmaxmesh c''etait:
26	;
27	; 0 ixmin i-key jpi-key-1 jpi-key jpi-key+j jpi-1 jpidta
28	; +ixmin +ixmin +ixmin +ixmin +ixmin
29	; \|,,,,\|--------\|--------------\| \|........\|..........\|,,,,,,,,,,,\|
30	;
31	; apres il suffit de remplacer i et j par firstx ou lastx qd on
32	; ne fait pas de stride.
33	;
34	; When using stride, things are getting more complicated....
35	;
36	; 1) when must replace firstx by firstx*key_stride[0] and
37	; lastx by lastx*key_stride[0]
38	; 2) we must use jpitotal instead of jpi
39	; 3) finding the position of the offset in the right side part is
40	; tricky. look at this illustration of stride = 4 ...
41	; 0 j key-1 key i jpi-1
42	; +...+..\|+...+...+ \|--+---+---+\|--+---+---+---+-\|
43	;
44	; 0 i-key jpi-key-1 jpi-key jpi-key+j jpi-1
45	; \|--+---+---+\|--+---+---+---+-\| +...+..\|+...+...+
46	; in the ........ part, it is easy the first point is number 0 but in
47	; the --------- part the first point is number 3... The position of
48	; the first point in the is given by:
49	; (key_stride[0]-1)-((key-1) MOD key_stride[0])
50	; 4) last point...by default, the number of element read by IDL when
51	; using stride is given by n_elements/stride. However, we must read:
52	; (n_elements+stride-1)/stride or (n_elements-1)/key_stride+1
53	; for example: for n_elements between 10 and 12, with a stride of 3,
54	; we must read 4 points instead of 3...: +--+--+--+--
55	; This problem as an easy solution by using the keyword count with
56	; the appropiate value!
57	;
58	key_shift = long(testvar(var = key_shift))
59	;
60	IF n_elements(key_yreverse) EQ 0 THEN key_yreverse = 0
61	IF keyword_set(key_yreverse) THEN BEGIN
62	tmp = jpj-1-firsty
63	firsty = jpj-1-lasty
64	lasty = tmp
65	ENDIF
66	;
67	IF n_elements(key_zreverse) EQ 0 THEN key_zreverse = 0
68	IF keyword_set(key_zreverse) THEN BEGIN
69	tmp = jpk-1-firstz
70	firstz = jpk-1-lastz
71	lastz = tmp
72	ENDIF
73	;
74	IF (key_gridtype EQ 'c_u' OR key_gridtype EQ 'c_f') $
75	AND (vargrid EQ 'U' OR vargrid EQ 'F') THEN BEGIN
76	IF keyword_set(key_periodic) THEN BEGIN
77	key_shift = key_shift-1
78	ENDIF ELSE BEGIN
79	firstx = firstx+1
80	lastx = lastx+1
81	ENDELSE
82	ENDIF
83	IF (key_gridtype EQ 'c_v' OR key_gridtype EQ 'c_f') $
84	AND (vargrid EQ 'V' OR vargrid EQ 'F') THEN BEGIN
85	firsty = firsty+1
86	lasty = lasty+1
87	ENDIF
88	;
89	ixmin = ixminmesh-ixmindta
90	iymin = iyminmesh-iymindta
91	izmin = izminmesh-izmindta
92	jpitotal = long(ixmaxmesh-ixminmesh+1)
93	key = long(key_shift MOD jpitotal)
94	if key LT 0 then key = key+jpitotal
95	;
96	case 1 OF
97	;......................................................................
98	;......................................................................
99	varinq.ndims eq 2:BEGIN ;xy array
100	;......................................................................
101	;......................................................................
102	case 1 OF
103	;,,,,,,,,,,,,,,,,,,,,,,,,
104	keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
105	; on ne shift pas et il n''y a pas de stride
106	;,,,,,,,,,,,,,,,,,,,,,,,,
107	ncdf_varget,cdfid,name,res,offset=[firstx+ixmin,firsty+iymin] $
108	,count=[nx,ny]
109	END
110	;,,,,,,,,,,,,,,,,,,,,,,,,
111	keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
112	; on ne shift pas mais il y a un stride
113	;,,,,,,,,,,,,,,,,,,,,,,,,
114	ncdf_varget,cdfid,name,res,offset=[firstx*key_stride[0]+ixmin $
115	,firsty*key_stride[1]+iymin] $
116	,count=[nx,ny], stride = key_stride[0:1]
117	END
118	;,,,,,,,,,,,,,,,,,,,,,,,,
119	keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
120	; on shift mais il n''y a pas de stride
121	;,,,,,,,,,,,,,,,,,,,,,,,,
122	case 1 of
123	; --------- part, we can directly extract the array in one piece
124	firstx GE key:BEGIN
125	ncdf_varget,cdfid,name,res,offset=[ixmin-key+firstx $
126	,firsty+iymin] $
127	,count=[nx,ny]
128	END
129	; ......... part, we can directly extract the array in one piece
130	lastx LE key-1:BEGIN
131	ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+firstx $
132	,firsty+iymin] $
133	,count=[nx,ny]
134	END
135	ELSE:BEGIN ; we have to extract the array in 2 pieces...
136	; ......... part, first part...
137	ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+firstx $
138	,firsty+iymin] $
139	,count=[key-1-firstx+1,ny]
140	; --------- part, second part...
141	ncdf_varget,cdfid,name,tab2,offset=[ixmin,firsty+iymin] $
142	,count=[lastx-key+1,ny]
143	res = [temporary(tab1), temporary(tab2)]
144	END
145	ENDCASE
146	END
147	;,,,,,,,,,,,,,,,,,,,,,,,,
148	keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
149	; on shift et il y a un stride
150	;,,,,,,,,,,,,,,,,,,,,,,,,
151	case 1 OF ; case sur la facon de fire le champ
152	; --------- part, we can directly extract the array in one piece
153	firstx*key_stride[0] GE key:BEGIN
154	ncdf_varget,cdfid,name,res,offset=[ixmin $
155	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
156	+(firstx-((key-1)/key_stride[0]+1))*key_stride[0] $
157	,firsty*key_stride[1]+iymin] $
158	,count=[nx,ny], stride = key_stride[0:1]
159	END
160	; ......... part, we can directly extract the array in one piece
161	lastx*key_stride[0] LE key-1:BEGIN
162	ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
163	,firsty*key_stride[1]+iymin] $
164	,count=[nx,ny], stride = key_stride[0:1]
165	END
166	ELSE:BEGIN ; we have to extract the array in 2 pieces...
167	; ......... part, first part...
168	ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
169	,firsty*key_stride[1]+iymin] $
170	,count=[(key-firstx*key_stride[0]-1)/key_stride[0]+1,ny] $
171	, stride = key_stride[0:1]
172	; --------- part, second part...
173	ncdf_varget,cdfid,name,tab2,offset=[ixmin $
174	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
175	, firsty*key_stride[1]+iymin] $
176	,count=[nx-(key-firstx*key_stride[0]-1)/key_stride[0]-1,ny] $
177	, stride = key_stride[0:1]
178	; in one unique array...
179	res = [temporary(tab1), temporary(tab2)]
180	END
181	ENDCASE ; case sur la facon de fire le champ
182	END
183	ENDCASE ; differentes possibilites de key_shift et key_performance
184	END
185	;......................................................................
186	;......................................................................
187	varinq.ndims eq 3 AND (where(varinq.dim EQ inq.recdim))[0] EQ -1:BEGIN ;xyz array
188	;......................................................................
189	;......................................................................
190	case 1 of
191	;,,,,,,,,,,,,,,,,,,,,,,,,
192	keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
193	; on ne shift pas et il n''y a pas de stride
194	;,,,,,,,,,,,,,,,,,,,,,,,,
195	ncdf_varget,cdfid,name,res,offset=[firstx+ixmin,firsty+iymin,firstz+izmin] $
196	,count=[nx,ny,nz]
197	END
198	;,,,,,,,,,,,,,,,,,,,,,,,,
199	keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
200	; on ne shift pas mais il y a un stride
201	;,,,,,,,,,,,,,,,,,,,,,,,,
202	ncdf_varget,cdfid,name,res,offset=[firstx*key_stride[0]+ixmin $
203	,firsty*key_stride[1]+iymin $
204	,firstz*key_stride[2]+izmin] $
205	,count=[nx,ny,nz], stride = key_stride
206	END
207	;,,,,,,,,,,,,,,,,,,,,,,,,
208	keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
209	; on shift mais il n''y a pas de stride
210	;,,,,,,,,,,,,,,,,,,,,,,,,
211	case 1 of
212	firstx GE key:BEGIN ; on peut tout couper d''un coup
213	ncdf_varget,cdfid,name,res,offset=[ixmin-key+firstx $
214	,firsty+iymin $
215	,firstz+izmin] $
216	,count=[nx,ny,nz]
217	END
218	lastx LE key-1:BEGIN ; on peut tout couper d''un coup
219	ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+firstx $
220	,firsty+iymin $
221	,firstz+izmin] $
222	,count=[nx,ny,nz]
223	END
224	ELSE:BEGIN ; Le tableau est separe en 2 morceaux...
225	ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+firstx $
226	,firsty+iymin $
227	,firstz+izmin] $
228	,count=[key-1-firstx+1,ny,nz]
229	ncdf_varget,cdfid,name,tab2,offset=[ixmin $
230	,firsty+iymin $
231	,firstz+izmin] $
232	,count=[lastx-key+1,ny,nz]
233	res = [temporary(tab1), temporary(tab2)]
234	END
235	ENDCASE
236	END
237	;,,,,,,,,,,,,,,,,,,,,,,,,
238	keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
239	; on shift et il y a un stride
240	;,,,,,,,,,,,,,,,,,,,,,,,,
241	case 1 OF ; case sur la facon de fire le champ
242	firstx*key_stride[0] GE key:BEGIN ; on peut tout couper d''un coup
243	ncdf_varget,cdfid,name,res,offset=[ixmin $
244	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
245	+(firstx-((key-1)/key_stride[0]+1))*key_stride[0] $
246	,firsty*key_stride[1]+iymin $
247	,firstz*key_stride[2]+izmin] $
248	,count=[nx,ny,nz], stride = key_stride
249	END
250	lastx*key_stride[0] LE key-1:BEGIN ; on peut tout couper d''un coup
251	ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
252	,firsty*key_stride[1]+iymin $
253	,firstz*key_stride[2]+izmin] $
254	,count=[nx,ny,nz], stride = key_stride
255	END
256	ELSE:BEGIN ; le tableau est separe en 2 morceaux...
257	ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
258	,firsty*key_stride[1]+iymin $
259	,firstz*key_stride[2]+izmin] $
260	,count=[(key-firstx*key_stride[0]-1)/key_stride[0]+1,ny,nz] $
261	, stride = key_stride
262	; 2eme bout...
263	ncdf_varget,cdfid,name,tab2,offset=[ixmin $
264	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
265	,firsty*key_stride[1]+iymin $
266	,firstz*key_stride[2]+izmin] $
267	,count=[nx-(key-firstx*key_stride[0]-1)/key_stride[0]-1,ny,nz] $
268	, stride = key_stride
269	; on recolle le tout
270	res = [temporary(tab1), temporary(tab2)]
271	END
272	ENDCASE ; case sur la facon de fire le champ
273	END
274	ENDCASE ; differentes possibilites de key_shift et key_performance
275	END
276	;......................................................................
277	;......................................................................
278	varinq.ndims eq 3 AND (where(varinq.dim EQ inq.recdim))[0] NE -1:BEGIN ;xyt array
279	;......................................................................
280	;......................................................................
281	case 1 of
282	;,,,,,,,,,,,,,,,,,,,,,,,,
283	keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
284	; on ne shift pas et il n''y a pas de stride
285	;,,,,,,,,,,,,,,,,,,,,,,,,
286	ncdf_varget,cdfid,name,res,offset=[firstx+ixmin $
287	,firsty+iymin $
288	,firsttps] $
289	,count=[nx,ny,jpt]
290	END
291	;,,,,,,,,,,,,,,,,,,,,,,,,
292	keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
293	; on ne shift pas mais il y a un stride
294	;,,,,,,,,,,,,,,,,,,,,,,,,
295	ncdf_varget,cdfid,name,res,offset=[firstx*key_stride[0]+ixmin $
296	,firsty*key_stride[1]+iymin $
297	,firsttps] $
298	,count=[nx,ny,jpt], stride = [key_stride[0:1], 1]
299	END
300	;,,,,,,,,,,,,,,,,,,,,,,,,
301	keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
302	; on shift mais il n''y a pas de stride
303	;,,,,,,,,,,,,,,,,,,,,,,,,
304	case 1 of
305	; --------- part, we can directly extract the array in one piece
306	firstx GE key:BEGIN ; on peut tout couper d''un coup
307	ncdf_varget,cdfid,name,res,offset=[ixmin-key+firstx $
308	,firsty+iymin $
309	,firsttps] $
310	,count=[nx,ny,jpt]
311	END
312	; ......... part, we can directly extract the array in one piece
313	lastx LE key-1:BEGIN ; on peut tout couper d''un coup
314	ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+firstx $
315	,firsty+iymin $
316	,firsttps] $
317	,count=[nx,ny,jpt]
318	END
319	ELSE:BEGIN ; Le tableau est separe en 2 morceaux...
320	; ......... part, first part...
321	ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+firstx $
322	,firsty+iymin $
323	,firsttps] $
324	,count=[key-1-firstx+1,ny,jpt]
325	; --------- part, second part...
326	ncdf_varget,cdfid,name,tab2,offset=[ixmin $
327	,firsty+iymin $
328	,firsttps] $
329	,count=[lastx-key+1,ny,jpt]
330	res = [temporary(tab1), temporary(tab2)]
331	END
332	ENDCASE
333	END
334	;,,,,,,,,,,,,,,,,,,,,,,,,
335	keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
336	; on shift et il y a un stride
337	;,,,,,,,,,,,,,,,,,,,,,,,,
338	; --------- part, we can directly extract the array in one piece
339	case 1 OF ; case sur la facon de fire le champ
340	firstx*key_stride[0] GE key:BEGIN
341	ncdf_varget,cdfid,name,res,offset=[ixmin $
342	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
343	+( firstx-((key-1)/key_stride[0]+1) )*key_stride[0] $
344	,firsty*key_stride[1]+iymin $
345	,firsttps] $
346	,count=[nx,ny,jpt], stride = [key_stride[0:1], 1]
347	END
348	; ......... part, we can directly extract the array in one piece
349	lastx*key_stride[0] LE key-1:BEGIN
350	ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
351	,firsty*key_stride[1]+iymin $
352	,firsttps] $
353	,count=[nx,ny,jpt], stride = [key_stride[0:1], 1]
354	END
355	ELSE:BEGIN
356	; ......... part, first part...
357	ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
358	,firsty*key_stride[1]+iymin $
359	,firsttps] $
360	,count=[(key-firstx*key_stride[0]-1)/key_stride[0]+1,ny,jpt] $
361	, stride = [key_stride[0:1], 1]
362	; --------- part, second part...
363	ncdf_varget,cdfid,name,tab2,offset=[ixmin $
364	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
365	, firsty*key_stride[1]+iymin $
366	,firsttps] $
367	,count=[nx-(key-firstx*key_stride[0]-1)/key_stride[0]-1,ny,jpt] $
368	, stride = [key_stride[0:1], 1]
369	; on recolle le tout
370	res = [temporary(tab1), temporary(tab2)]
371	END
372	ENDCASE ; case sur la facon de fire le champ
373	END
374	endcase
375	END
376	;......................................................................
377	;......................................................................
378	varinq.ndims eq 4:BEGIN ;xyzt array
379	;......................................................................
380	;......................................................................
381	case 1 of
382	;,,,,,,,,,,,,,,,,,,,,,,,,
383	keyword_set(key_shift) EQ 0 AND total(key_stride) EQ 3:BEGIN
384	; on ne shift pas et il n''y a pas de stride
385	;,,,,,,,,,,,,,,,,,,,,,,,,
386	ncdf_varget,cdfid,name,res,offset=[firstx+ixmin $
387	,firsty+iymin $
388	,firstz+izmin $
389	,firsttps] $
390	,count=[nx,ny,nz,jpt]
391	END
392	;,,,,,,,,,,,,,,,,,,,,,,,,
393	keyword_set(key_shift) EQ 0 AND total(key_stride) NE 3:BEGIN
394	; on ne shift pas mais il y a un stride
395	;,,,,,,,,,,,,,,,,,,,,,,,,
396	ncdf_varget,cdfid,name,res,offset=[firstx*key_stride[0]+ixmin $
397	,firsty*key_stride[1]+iymin $
398	,firstz*key_stride[2]+izmin $
399	,firsttps] $
400	,count=[nx,ny,nz,jpt], stride = [key_stride, 1]
401	END
402	;,,,,,,,,,,,,,,,,,,,,,,,,
403	keyword_set(key_shift) NE 0 AND total(key_stride) EQ 3:BEGIN
404	; on shift mais il n''y a pas de stride
405	;,,,,,,,,,,,,,,,,,,,,,,,,
406	case 1 of
407	firstx GE key:BEGIN ; on peut tout couper d''un coup
408	ncdf_varget,cdfid,name,res,offset=[ixmin-key+firstx $
409	,firsty+iymin $
410	,firstz+izmin $
411	,firsttps] $
412	,count=[nx,ny,nz,jpt]
413	END
414	lastx LE key-1:BEGIN ; on peut tout couper d''un coup
415	ncdf_varget,cdfid,name,res,offset=[jpi-key+ixmin+firstx $
416	,firsty+iymin $
417	,firstz+izmin $
418	,firsttps] $
419	,count=[nx,ny,nz,jpt]
420	END
421	ELSE:BEGIN ; Le tableau est separe en 2 morceaux...
422	ncdf_varget,cdfid,name,tab1,offset=[jpi-key+ixmin+firstx $
423	,firsty+iymin $
424	,firstz+izmin $
425	,firsttps] $
426	,count=[key-1-firstx+1,ny,nz,jpt]
427	ncdf_varget,cdfid,name,tab2,offset=[ixmin $
428	,firsty+iymin $
429	,firstz+izmin $
430	,firsttps] $
431	,count=[lastx-key+1,ny,nz,jpt]
432	res = [temporary(tab1), temporary(tab2)]
433	END
434	ENDCASE
435	END
436	;,,,,,,,,,,,,,,,,,,,,,,,,
437	keyword_set(key_shift) NE 0 AND total(key_stride) NE 3:BEGIN
438	; on shift et il y a un stride
439	;,,,,,,,,,,,,,,,,,,,,,,,,
440	case 1 OF ; case sur la facon de fire le champ
441	firstx*key_stride[0] GE key:BEGIN ; on peut tout coupe d''un coup
442	ncdf_varget,cdfid,name,res,offset=[ixmin $
443	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
444	+(firstx-((key-1)/key_stride[0]+1))*key_stride[0] $
445	,firsty*key_stride[1]+iymin $
446	,firstz*key_stride[2]+izmin $
447	,firsttps] $
448	,count=[nx,ny,nz,jpt], stride = [key_stride, 1]
449	END
450	lastx*key_stride[0] LE key-1:BEGIN ; on peut tout coupe d''un coup
451	ncdf_varget,cdfid,name,res,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
452	,firsty*key_stride[1]+iymin $
453	,firstz*key_stride[2]+izmin $
454	,firsttps] $
455	,count=[nx,ny,nz,jpt], stride = [key_stride, 1]
456	END
457	ELSE:BEGIN ; le tableau est separe en 2 morceaux...
458	ncdf_varget,cdfid,name,tab1,offset=[jpitotal-key+ixmin+firstx*key_stride[0] $
459	,firsty*key_stride[1]+iymin $
460	,firstz*key_stride[2]+izmin $
461	,firsttps] $
462	,count=[(key-firstx*key_stride[0]-1)/key_stride[0]+1,ny,nz,jpt] $
463	, stride = [key_stride, 1]
464	; 2eme bout...
465	ncdf_varget,cdfid,name,tab2,offset=[ixmin $
466	+(key_stride[0]-1)-((key-1) MOD key_stride[0]) $
467	, firsty*key_stride[1]+iymin $
468	, firstz*key_stride[2]+izmin $
469	, firsttps] $
470	,count=[nx-(key-firstx*key_stride[0]-1)/key_stride[0]-1,ny,nz,jpt] $
471	, stride = [key_stride, 1]
472	; on recolle le tout
473	res = [temporary(tab1), temporary(tab2)]
474	END
475	ENDCASE ; case sur la facon de fire le champ
476	END
477	endcase
478	END
479	ENDCASE
480
481	; we apply reverse
482	IF keyword_set(key_yreverse) AND ny NE 1 THEN BEGIN
483	IF varinq.ndims - ((where(varinq.dim EQ inq.recdim))[0] NE -1) EQ 2 THEN $
484	res = reverse(reform(res, nx, ny, jpt, /overwrite), 2) $
485	ELSE res = reverse(reform(res, nx, ny, nz, jpt, /overwrite), 2)
486	ENDIF
487	if keyword_set(key_zreverse) AND nz NE 1 $
488	AND varinq.ndims - ((where(varinq.dim EQ inq.recdim))[0] NE -1) EQ 3 THEN $
489	res = reverse(reform(res, nx, ny, nz, jpt, /overwrite), 3)
490	;
491	IF (key_gridtype EQ 'c_u' OR key_gridtype EQ 'c_f') AND keyword_set(key_periodic) $
492	AND (strupcase(vargrid) EQ 'U' OR strupcase(vargrid) EQ 'F') THEN key_shift = key_shift+1

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

Download in other formats:

Original Format