Line data Source code
1 : !------------------------------------------------------------------------------
2 : ! Harmonized Emissions Component (HEMCO) !
3 : !------------------------------------------------------------------------------
4 : !BOP
5 : !
6 : ! !MODULE: hco_arr_mod.F90
7 : !
8 : ! !DESCRIPTION: Module HCO\_Arr\_Mod contains routines and variables to
9 : ! initialize, validate, and cleanup HEMCO data arrays. HEMCO data arrays
10 : ! can be 2D or 3D. They can be organized as single arrays or as vector
11 : ! of arrays to represent an additional dimension (time).
12 : !\\
13 : !\\
14 : ! The public data types Arr2D\_Hp and Arr3D\_Hp represent the 2D/3D arrays
15 : ! used by HEMCO. The HEMCO precision HP is defined in HCO\_Error\_Mod. There
16 : ! is also an integer 2D array (type Arr2D\_I) that can be used to store
17 : ! integer data. Additional data types can be added as needed.
18 : !\\
19 : !\\
20 : ! Data values are stored in array 'Val'. Val can be self-allocated or a
21 : ! pointer to existing data, as denoted by the Alloc flag.
22 : !\\
23 : !\\
24 : ! At the moment, the following HEMCO structures use HEMCO arrays:
25 : !\begin{itemize}
26 : !\item FileData: emission data (base emissions, scale factors, masks) stored
27 : ! in the FileData derived type. These data are read from disk as specified in
28 : ! the configuration file. See HCO\_FileData\_Mod.F90.
29 : !\item FluxArr: the HEMCO flux arrays (emissions and deposition velocities)
30 : ! stored in the HEMCO state object. See HCO\_State\_Mod.F90.
31 : !\item Grid: all grid information arrays (x midpoints, y midpoints, etc.)
32 : ! stored in the HEMCO state object.
33 : !\item ExtDat: external data required by the extensions (primarily met fields).
34 : ! See HCOX\_State\_Mod.F90.
35 : !\end{itemize}
36 : ! !INTERFACE:
37 : !
38 : MODULE HCO_Arr_Mod
39 : !
40 : ! !USES:
41 : !
42 : USE HCO_Error_Mod
43 :
44 : IMPLICIT NONE
45 : PRIVATE
46 : !
47 : ! !PUBLIC MEMBER FUNCTIONS:
48 : !
49 : PUBLIC :: HCO_ArrInit
50 : PUBLIC :: HCO_ArrAssert
51 : PUBLIC :: HCO_ArrCleanup
52 : !
53 : ! !PRIVATE MEMBER FUNCTIONS:
54 : !
55 : PRIVATE :: HCO_ArrInit_3D_Hp
56 : PRIVATE :: HCO_ArrInit_2D_Hp
57 : PRIVATE :: HCO_ArrInit_3D_Sp
58 : PRIVATE :: HCO_ArrInit_2D_Sp
59 : PRIVATE :: HCO_ArrInit_2D_I
60 : PRIVATE :: HCO_ArrVecInit_3D_Hp
61 : PRIVATE :: HCO_ArrVecInit_2D_Hp
62 : PRIVATE :: HCO_ArrVecInit_3D_Sp
63 : PRIVATE :: HCO_ArrVecInit_2D_Sp
64 : PRIVATE :: HCO_ValInit
65 : PRIVATE :: HCO_ValInit_3D_Sp
66 : PRIVATE :: HCO_ValInit_3D_Dp
67 : PRIVATE :: HCO_ValInit_2D_Sp
68 : PRIVATE :: HCO_ValInit_2D_Dp
69 : PRIVATE :: HCO_ValInit_2D_I
70 : PRIVATE :: HCO_ArrAssert_2D_Hp
71 : PRIVATE :: HCO_ArrAssert_3D_Hp
72 : PRIVATE :: HCO_ArrAssert_2D_Sp
73 : PRIVATE :: HCO_ArrAssert_3D_Sp
74 : PRIVATE :: HCO_ArrCleanup_3D_Hp
75 : PRIVATE :: HCO_ArrCleanup_2D_Hp
76 : PRIVATE :: HCO_ArrCleanup_3D_Sp
77 : PRIVATE :: HCO_ArrCleanup_2D_Sp
78 : PRIVATE :: HCO_ArrCleanup_2D_I
79 : PRIVATE :: HCO_ArrVecCleanup_3D_Hp
80 : PRIVATE :: HCO_ArrVecCleanup_2D_Hp
81 : PRIVATE :: HCO_ArrVecCleanup_3D_Sp
82 : PRIVATE :: HCO_ArrVecCleanup_2D_Sp
83 : PRIVATE :: HCO_ValCleanup_3D_Sp
84 : PRIVATE :: HCO_ValCleanup_3D_Dp
85 : PRIVATE :: HCO_ValCleanup_2D_Sp
86 : PRIVATE :: HCO_ValCleanup_2D_Dp
87 : PRIVATE :: HCO_ValCleanup_2D_I
88 : !
89 : ! !PUBLIC DATA MEMBERS:
90 : !
91 : ! 2D arrays
92 : TYPE, PUBLIC :: Arr2D_Hp
93 : REAL(hp), POINTER :: Val(:,:) ! x,y
94 : LOGICAL :: Alloc ! Allocated?
95 : END TYPE Arr2D_Hp
96 :
97 : TYPE, PUBLIC :: Arr2D_I
98 : INTEGER, POINTER :: Val(:,:) ! x,y
99 : LOGICAL :: Alloc ! Allocated?
100 : END TYPE Arr2D_I
101 :
102 : TYPE, PUBLIC :: Arr2D_Sp
103 : REAL(sp), POINTER :: Val(:,:) ! x,y
104 : LOGICAL :: Alloc ! Allocated?
105 : END TYPE Arr2D_Sp
106 :
107 : ! 3D arrays
108 : TYPE, PUBLIC :: Arr3D_Hp
109 : REAL(hp), POINTER :: Val(:,:,:) ! x,y,z
110 : LOGICAL :: Alloc ! Allocated?
111 : END TYPE Arr3D_Hp
112 :
113 : TYPE, PUBLIC :: Arr3D_Sp
114 : REAL(sp), POINTER :: Val(:,:,:) ! x,y,z
115 : LOGICAL :: Alloc ! Allocated?
116 : END TYPE Arr3D_Sp
117 : !
118 : ! !PRIVATE TYPES:
119 : !
120 : INTERFACE HCO_ArrInit
121 : MODULE PROCEDURE HCO_ArrInit_3D_Hp
122 : MODULE PROCEDURE HCO_ArrInit_2D_Hp
123 : MODULE PROCEDURE HCO_ArrInit_3D_Sp
124 : MODULE PROCEDURE HCO_ArrInit_2D_Sp
125 : MODULE PROCEDURE HCO_ArrInit_2D_I
126 : MODULE PROCEDURE HCO_ArrVecInit_3D_Hp
127 : MODULE PROCEDURE HCO_ArrVecInit_2D_Hp
128 : MODULE PROCEDURE HCO_ArrVecInit_3D_Sp
129 : MODULE PROCEDURE HCO_ArrVecInit_2D_Sp
130 : END INTERFACE HCO_ArrInit
131 :
132 : INTERFACE HCO_ValInit
133 : MODULE PROCEDURE HCO_ValInit_3D_Sp
134 : MODULE PROCEDURE HCO_ValInit_3D_Dp
135 : MODULE PROCEDURE HCO_ValInit_2D_Sp
136 : MODULE PROCEDURE HCO_ValInit_2D_Dp
137 : MODULE PROCEDURE HCO_ValInit_2D_I
138 : END INTERFACE HCO_ValInit
139 :
140 : INTERFACE HCO_ArrAssert
141 : MODULE PROCEDURE HCO_ArrAssert_2D_Hp
142 : MODULE PROCEDURE HCO_ArrAssert_3D_Hp
143 : MODULE PROCEDURE HCO_ArrAssert_2D_Sp
144 : MODULE PROCEDURE HCO_ArrAssert_3D_Sp
145 : MODULE PROCEDURE HCO_ArrAssert_2D_I
146 : END INTERFACE HCO_ArrAssert
147 :
148 : INTERFACE HCO_ArrCleanup
149 : MODULE PROCEDURE HCO_ArrCleanup_3D_Hp
150 : MODULE PROCEDURE HCO_ArrCleanup_2D_Hp
151 : MODULE PROCEDURE HCO_ArrCleanup_2D_I
152 : MODULE PROCEDURE HCO_ArrCleanup_3D_Sp
153 : MODULE PROCEDURE HCO_ArrCleanup_2D_Sp
154 : MODULE PROCEDURE HCO_ArrVecCleanup_3D_Hp
155 : MODULE PROCEDURE HCO_ArrVecCleanup_2D_Hp
156 : MODULE PROCEDURE HCO_ArrVecCleanup_3D_Sp
157 : MODULE PROCEDURE HCO_ArrVecCleanup_2D_Sp
158 : END INTERFACE HCO_ArrCleanup
159 :
160 : INTERFACE HCO_ValCleanup
161 : MODULE PROCEDURE HCO_ValCleanup_3D_Sp
162 : MODULE PROCEDURE HCO_ValCleanup_3D_Dp
163 : MODULE PROCEDURE HCO_ValCleanup_2D_Sp
164 : MODULE PROCEDURE HCO_ValCleanup_2D_Dp
165 : MODULE PROCEDURE HCO_ValCleanup_2D_I
166 : END INTERFACE HCO_ValCleanup
167 : !
168 : ! !REVISION HISTORY:
169 : ! 19 Dec 2013 - C. Keller - Initialization
170 : ! See https://github.com/geoschem/hemco for complete history
171 : !EOP
172 : !------------------------------------------------------------------------------
173 : !BOC
174 : CONTAINS
175 : !EOC
176 : !------------------------------------------------------------------------------
177 : ! Harmonized Emissions Component (HEMCO) !
178 : !------------------------------------------------------------------------------
179 : !BOP
180 : !
181 : ! !IROUTINE: HCO_ArrInit_2D_Hp
182 : !
183 : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_2D\_Hp initializes the given data
184 : ! container 2D array. nx and ny denote the array size dimensions. If nx is
185 : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
186 : ! instead.
187 : !\\
188 : !\\
189 : ! !INTERFACE:
190 : !
191 0 : SUBROUTINE HCO_ArrInit_2D_Hp( Arr, nx, ny, RC )
192 : !
193 : ! !INPUT PARAMETERS:
194 : !
195 : INTEGER, INTENT(IN) :: nx ! x-dim
196 : INTEGER, INTENT(IN) :: ny ! y-dim
197 : !
198 : ! INPUT/OUTPUT PARAMETERS:
199 : !
200 : TYPE(Arr2D_Hp), POINTER :: Arr ! Array
201 : !
202 : ! !OUTPUT PARAMETERS:
203 : !
204 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
205 : !
206 : ! !REVISION HISTORY:
207 : ! 20 Apr 2013 - C. Keller - Initial version
208 : ! See https://github.com/geoschem/hemco for complete history
209 : !EOP
210 : !------------------------------------------------------------------------------
211 : !BOC
212 : !
213 : ! !LOCAL VARIABLES:
214 : !
215 : ! Strings
216 : CHARACTER(LEN=255) :: errMsg, thisLoc
217 :
218 : ! ================================================================
219 : ! HCO_ArrInit_2D_Hp begins here
220 : ! ================================================================
221 :
222 : ! Initialize
223 0 : RC = HCO_SUCCESS
224 0 : errMsg = ''
225 0 : thisLoc = 'HCO_ArrInit_2D_Hp (HCO_ARR_MOD.F90)'
226 :
227 : ! NOTE: This may cause a memory leak
228 0 : Arr => NULL()
229 :
230 : ! Initialize the Arr object
231 : !IF ( .not. ASSOCIATED( Arr ) ) THEN
232 0 : ALLOCATE( Arr, STAT=RC )
233 0 : IF ( RC /= HCO_SUCCESS ) THEN
234 0 : errMsg = 'Could not allocate the "Arr" object!'
235 0 : CALL HCO_Error( errMsg, RC, thisLoc )
236 0 : RETURN
237 : ENDIF
238 0 : Arr%Val => NULL()
239 0 : Arr%Alloc = .FALSE.
240 : !ENDIF
241 :
242 : ! Initialize the Arr%Val array
243 0 : CALL HCO_ValInit( Arr%Val, nx, ny, Arr%Alloc, RC )
244 0 : IF ( RC /= HCO_SUCCESS ) THEN
245 0 : errMsg = 'Could not allocate the "Arr%Val" array!'
246 0 : CALL HCO_ERROR( errMsg, RC, thisLoc )
247 0 : RETURN
248 : ENDIF
249 :
250 : END SUBROUTINE HCO_ArrInit_2D_Hp
251 : !EOC
252 : !------------------------------------------------------------------------------
253 : ! Harmonized Emissions Component (HEMCO) !
254 : !------------------------------------------------------------------------------
255 : !BOP
256 : !
257 : ! !IROUTINE: HCO_ArrInit_2D_Sp
258 : !
259 : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_2D\_Sp initializes the given data
260 : ! container 2D array. nx and ny denote the array size dimensions. If nx is
261 : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
262 : ! instead.
263 : !\\
264 : !\\
265 : ! !INTERFACE:
266 : !
267 0 : SUBROUTINE HCO_ArrInit_2D_Sp( Arr, nx, ny, RC )
268 : !
269 : ! !INPUT PARAMETERS:
270 : !
271 : INTEGER, INTENT(IN) :: nx ! x-dim
272 : INTEGER, INTENT(IN) :: ny ! y-dim
273 : !
274 : ! INPUT/OUTPUT PARAMETERS:
275 : !
276 : TYPE(Arr2D_Sp), POINTER :: Arr ! Array
277 : !
278 : ! !OUTPUT PARAMETERS:
279 : !
280 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
281 : !
282 : ! !REVISION HISTORY:
283 : ! 20 Apr 2013 - C. Keller - Initial version
284 : ! See https://github.com/geoschem/hemco for complete history
285 : !EOP
286 : !------------------------------------------------------------------------------
287 : !BOC
288 : !
289 : ! !LOCAL VARIABLES:
290 : !
291 : ! Strings
292 : CHARACTER(LEN=255) :: errMsg, thisLoc
293 :
294 : ! ================================================================
295 : ! HCO_ArrInit_2D_Sp begins here
296 : ! ================================================================
297 :
298 : ! Initialize
299 0 : RC = HCO_SUCCESS
300 0 : errMsg = ''
301 0 : thisLoc = 'HCO_ArrInit_2D_Sp (HCO_ARR_MOD.F90)'
302 :
303 : ! NOTE: This may cause a memory leak
304 0 : Arr => NULL()
305 :
306 : ! Initialize the Arr object
307 : !IF ( .not. ASSOCIATED( Arr ) ) THEN
308 0 : ALLOCATE( Arr, STAT=RC )
309 0 : IF ( RC /= HCO_SUCCESS ) THEN
310 0 : errMsg = 'Could not allocate the "Arr" object!'
311 0 : CALL HCO_Error( errMsg, RC, thisLoc )
312 0 : RETURN
313 : ENDIF
314 0 : Arr%Val => NULL()
315 0 : Arr%Alloc = .FALSE.
316 : !ENDIF
317 :
318 : ! Initialize the Arr%Val array
319 0 : CALL HCO_ValInit( Arr%Val, nx, ny, Arr%Alloc, RC )
320 0 : IF ( RC /= HCO_SUCCESS ) THEN
321 0 : errMsg = 'Could not allocate the "Arr%Val" array!'
322 0 : CALL HCO_ERROR( errMsg, RC, thisLoc )
323 0 : RETURN
324 : ENDIF
325 :
326 : END SUBROUTINE HCO_ArrInit_2D_Sp
327 : !EOC
328 : !------------------------------------------------------------------------------
329 : ! Harmonized Emissions Component (HEMCO) !
330 : !------------------------------------------------------------------------------
331 : !BOP
332 : !
333 : ! !IROUTINE: HCO_ArrInit_2D_I
334 : !
335 : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_2D\_I initializes the given data
336 : ! container integer 2D array. nx and ny denote the array size dimensions.
337 : ! If nx is set to 0, no data is allocated but Val is set to a (nullified)
338 : ! pointer instead.
339 : !\\
340 : !\\
341 : ! !INTERFACE:
342 : !
343 0 : SUBROUTINE HCO_ArrInit_2D_I( Arr, nx, ny, RC )
344 : !
345 : ! !INPUT PARAMETERS:
346 : !
347 : INTEGER, INTENT(IN) :: nx ! x-dim
348 : INTEGER, INTENT(IN) :: ny ! y-dim
349 : !
350 : ! INPUT/OUTPUT PARAMETERS:
351 : !
352 : TYPE(Arr2D_I), POINTER :: Arr ! Array
353 : !
354 : ! !OUTPUT PARAMETERS:
355 : !
356 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
357 : !
358 : ! !REVISION HISTORY:
359 : ! 20 Apr 2013 - C. Keller - Initial version
360 : ! See https://github.com/geoschem/hemco for complete history
361 : !EOP
362 : !------------------------------------------------------------------------------
363 : !BOC
364 : !
365 : ! !LOCAL VARIABLES:
366 : !
367 : ! Strings
368 : CHARACTER(LEN=255) :: errMsg, thisLoc
369 :
370 : ! ================================================================
371 : ! HCO_ArrInit_2D_I begins here
372 : ! ================================================================
373 :
374 : ! Initialize
375 0 : RC = HCO_SUCCESS
376 0 : errMsg = ''
377 0 : thisLoc = 'HCO_ArrInit_2D_I (hco_arr_mod.F90)'
378 :
379 : ! NOTE: This may cause a memory leak
380 0 : Arr => NULL()
381 :
382 : ! Initialize the Arr object
383 : !IF ( .not. ASSOCIATED( Arr ) ) THEN
384 0 : ALLOCATE( Arr, STAT=RC )
385 0 : IF ( RC /= HCO_SUCCESS ) THEN
386 0 : errMsg = 'Could not allocate the "Arr" object!'
387 0 : CALL HCO_Error( errMsg, RC, thisLoc )
388 0 : RETURN
389 : ENDIF
390 0 : Arr%Val => NULL()
391 0 : Arr%Alloc = .FALSE.
392 : !ENDIF
393 :
394 : ! Initialize the Arr%Val array
395 0 : CALL HCO_ValInit( Arr%Val, nx, ny, Arr%Alloc, RC )
396 0 : IF ( RC /= HCO_SUCCESS ) THEN
397 0 : errMsg = 'Could not allocate the "Arr%Val" array!'
398 0 : CALL HCO_ERROR( errMsg, RC, thisLoc )
399 0 : RETURN
400 : ENDIF
401 :
402 : END SUBROUTINE HCO_ArrInit_2D_I
403 : !EOC
404 : !------------------------------------------------------------------------------
405 : ! Harmonized Emissions Component (HEMCO) !
406 : !------------------------------------------------------------------------------
407 : !BOP
408 : !
409 : ! !IROUTINE: HCO_ArrInit_3D_Hp
410 : !
411 : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_3D\_Hp initializes the given data
412 : ! container 3D array. nx and ny denote the array size dimensions. If nx is
413 : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
414 : ! instead.
415 : !\\
416 : !\\
417 : ! !INTERFACE:
418 : !
419 0 : SUBROUTINE HCO_ArrInit_3D_Hp( Arr, nx, ny, nz, RC )
420 : !
421 : ! !INPUT PARAMETERS:
422 : !
423 : INTEGER, INTENT(IN) :: nx ! x-dim
424 : INTEGER, INTENT(IN) :: ny ! y-dim
425 : INTEGER, INTENT(IN) :: nz ! z-dim
426 : !
427 : ! INPUT/OUTPUT PARAMETERS:
428 : !
429 : TYPE(Arr3D_Hp), POINTER :: Arr ! Array
430 : !
431 : ! !OUTPUT PARAMETERS:
432 : !
433 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
434 : !
435 : ! !REVISION HISTORY:
436 : ! 20 Apr 2013 - C. Keller - Initial version
437 : ! See https://github.com/geoschem/hemco for complete history
438 : !EOP
439 : !------------------------------------------------------------------------------
440 : !BOC
441 : !
442 : ! !LOCAL VARIABLES:
443 : !
444 : CHARACTER(LEN=255) :: errMsg, thisLoc
445 :
446 : ! ================================================================
447 : ! HCO_ArrInit_3D_Hp begins here
448 : ! ================================================================
449 :
450 : ! Initialize
451 0 : RC = HCO_SUCCESS
452 0 : errMsg = ''
453 0 : thisLoc = 'HCO_ArrInit_3D_Hp (hco_arr_mod.F90)'
454 :
455 : ! NOTE: This may cause a memory leak
456 0 : Arr => NULL()
457 :
458 : ! Initialize the Arr object
459 : !IF ( .not. ASSOCIATED( Arr ) ) THEN
460 0 : ALLOCATE( Arr, STAT=RC )
461 0 : IF ( RC /= HCO_SUCCESS ) THEN
462 0 : errMsg = 'Could not allocate the Arr object!'
463 0 : CALL HCO_Error( errMsg, RC, thisLoc )
464 0 : RETURN
465 : ENDIF
466 0 : Arr%Val => NULL()
467 0 : Arr%Alloc = .FALSE.
468 : !ENDIF
469 :
470 : ! Initialize the Arr%Val array
471 0 : CALL HCO_ValInit( Arr%Val, nx, ny, nz, Arr%Alloc, RC )
472 0 : IF ( RC /= HCO_SUCCESS ) THEN
473 0 : errMsg = 'Could not allocate the "Arr%Val" array!'
474 0 : CALL HCO_Error( errMsg, RC, thisLoc )
475 0 : RETURN
476 : ENDIF
477 :
478 : END SUBROUTINE HCO_ArrInit_3D_Hp
479 : !EOC
480 : !------------------------------------------------------------------------------
481 : ! Harmonized Emissions Component (HEMCO) !
482 : !------------------------------------------------------------------------------
483 : !BOP
484 : !
485 : ! !IROUTINE: HCO_ArrInit_3D_Sp
486 : !
487 : ! !DESCRIPTION: Subroutine HCO\_ArrInit\_3D\_Sp initializes the given data
488 : ! container 3D array. nx and ny denote the array size dimensions. If nx is
489 : ! set to 0, no data is allocated but Val is set to a (nullified) pointer
490 : ! instead.
491 : !\\
492 : !\\
493 : ! !INTERFACE:
494 : !
495 0 : SUBROUTINE HCO_ArrInit_3D_Sp( Arr, nx, ny, nz, RC )
496 : !
497 : ! !INPUT PARAMETERS:
498 : !
499 : INTEGER, INTENT(IN) :: nx ! x-dim
500 : INTEGER, INTENT(IN) :: ny ! y-dim
501 : INTEGER, INTENT(IN) :: nz ! z-dim
502 : !
503 : ! INPUT/OUTPUT PARAMETERS:
504 : !
505 : TYPE(Arr3D_Sp), POINTER :: Arr ! Array
506 : !
507 : ! !OUTPUT PARAMETERS:
508 : !
509 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
510 : !
511 : ! !REVISION HISTORY:
512 : ! 20 Apr 2013 - C. Keller - Initial version
513 : ! See https://github.com/geoschem/hemco for complete history
514 : !EOP
515 : !------------------------------------------------------------------------------
516 : !BOC
517 : !
518 : ! !LOCAL VARIABLES:
519 : !
520 : ! Scalars
521 : INTEGER :: I
522 :
523 : ! Strings
524 : CHARACTER(LEN=255) :: errMsg, thisLoc
525 :
526 : ! ================================================================
527 : ! HCO_ArrInit_3D_Sp begins here
528 : ! ================================================================
529 :
530 : ! Initialize
531 0 : RC = HCO_SUCCESS
532 0 : errMsg = ''
533 0 : thisLoc = 'HCO_ArrInit_3D_Sp (hco_arr_mod.F90)'
534 :
535 : ! NOTE: This may cause a memory leak
536 0 : Arr => NULL()
537 :
538 : ! Initialize the Arr object
539 : !IF ( .not. ASSOCIATED( Arr ) ) THEN
540 0 : ALLOCATE( Arr, STAT=RC )
541 0 : IF ( RC /= HCO_SUCCESS ) THEN
542 0 : errMsg = 'Could not allocate the Arr object!'
543 0 : CALL HCO_Error( errMsg, RC, thisLoc )
544 0 : RETURN
545 : ENDIF
546 0 : Arr%Val => NULL()
547 0 : Arr%Alloc = .FALSE.
548 : !ENDIF
549 :
550 : ! Initialize the Arr%Val array
551 0 : CALL HCO_ValInit( Arr%Val, nx, ny, nz, Arr%Alloc, RC )
552 0 : IF ( RC /= HCO_SUCCESS ) THEN
553 0 : errMsg = 'Could not allocate the "Arr%Val" array!'
554 0 : CALL HCO_Error( errMsg, RC, thisLoc )
555 0 : RETURN
556 : ENDIF
557 :
558 : END SUBROUTINE HCO_ArrInit_3D_Sp
559 : !EOC
560 : !------------------------------------------------------------------------------
561 : ! Harmonized Emissions Component (HEMCO) !
562 : !------------------------------------------------------------------------------
563 : !BOP
564 : !
565 : ! !IROUTINE: HCO_ArrVecInit_2D_Hp
566 : !
567 : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_2D\_Hp initializes the given data
568 : ! container 2D array vector. nn denotes the number of 2D arrays, and nx and ny
569 : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
570 : ! Val is set to a (nullified) pointer instead.
571 : !\\
572 : !\\
573 : ! !INTERFACE:
574 : !
575 0 : SUBROUTINE HCO_ArrVecInit_2D_Hp( ArrVec, nn, nx, ny, RC )
576 : !
577 : ! !INPUT PARAMETERS:
578 : !
579 : INTEGER, INTENT(IN) :: nn ! vector length
580 : INTEGER, INTENT(IN) :: nx ! x-dim
581 : INTEGER, INTENT(IN) :: ny ! y-dim
582 : !
583 : ! !INPUT/OUTPUT PARAMETERS:
584 : !
585 : TYPE(Arr2D_Hp), POINTER :: ArrVec(:) ! Array vector
586 : !
587 : ! !INPUT/OUTPUT PARAMETERS:
588 : !
589 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
590 : !
591 : ! !REVISION HISTORY:
592 : ! 20 Apr 2013 - C. Keller - Initial version
593 : ! See https://github.com/geoschem/hemco for complete history
594 : !EOP
595 : !------------------------------------------------------------------------------
596 : !BOC
597 : !
598 : ! !LOCAL VARIABLES:
599 : !
600 : ! Scalars
601 : INTEGER :: I
602 :
603 : ! Strings
604 : CHARACTER(LEN=255) :: errMsg, thisLoc
605 :
606 : ! ================================================================
607 : ! HCO_ArrVecInit_2D_Hp begins here
608 : ! ================================================================
609 :
610 : ! Initialize
611 0 : RC = HCO_SUCCESS
612 0 : errMsg = ''
613 0 : thisLoc = 'HCO_ArrVecInit_2D_Hp (hco_arr_mod.F90)'
614 :
615 : ! If dimension is zero, return a null pointer
616 0 : IF ( nn < 1 ) THEN
617 0 : ArrVec => NULL()
618 0 : RETURN
619 : ENDIF
620 :
621 : ! Allocate ArrVec if necessary
622 0 : IF ( .not. ASSOCIATED( ArrVec ) ) THEN
623 0 : ALLOCATE( ArrVec( nn ), STAT=RC )
624 0 : IF ( RC /= HCO_SUCCESS ) THEN
625 0 : errMsg = 'Could not allocate "ArrVec"!'
626 0 : CALL HCO_Error( errMsg, RC, thisLoc )
627 0 : RETURN
628 : ENDIF
629 : ENDIF
630 :
631 : ! Reset values in ArrVec
632 0 : DO I = 1, nn
633 0 : CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, ArrVec(I)%Alloc, RC )
634 0 : IF ( RC /= HCO_SUCCESS ) THEN
635 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
636 0 : CALL HCO_Error( errMsg, RC, thisLoc )
637 0 : RETURN
638 : ENDIF
639 : ENDDO
640 :
641 : END SUBROUTINE HCO_ArrVecInit_2D_Hp
642 : !EOC
643 : !------------------------------------------------------------------------------
644 : ! Harmonized Emissions Component (HEMCO) !
645 : !------------------------------------------------------------------------------
646 : !BOP
647 : !
648 : ! !IROUTINE: HCO_ArrVecInit_2D_Sp
649 : !
650 : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_2D\_Sp initializes the given data
651 : ! container 2D array vector. nn denotes the number of 2D arrays, and nx and ny
652 : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
653 : ! Val is set to a (nullified) pointer instead.
654 : !\\
655 : !\\
656 : ! !INTERFACE:
657 : !
658 0 : SUBROUTINE HCO_ArrVecInit_2D_Sp( ArrVec, nn, nx, ny, RC )
659 : !
660 : ! !INPUT PARAMETERS:
661 : !
662 : INTEGER, INTENT(IN) :: nn ! vector length
663 : INTEGER, INTENT(IN) :: nx ! x-dim
664 : INTEGER, INTENT(IN) :: ny ! y-dim
665 : !
666 : ! !INPUT/OUTPUT PARAMETERS:
667 : !
668 : TYPE(Arr2D_Sp), POINTER :: ArrVec(:) ! Array vector
669 : !
670 : ! !INPUT/OUTPUT PARAMETERS:
671 : !
672 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
673 : !
674 : ! !REVISION HISTORY:
675 : ! 20 Apr 2013 - C. Keller - Initial version
676 : ! See https://github.com/geoschem/hemco for complete history
677 : !EOP
678 : !------------------------------------------------------------------------------
679 : !BOC
680 : !
681 : ! !LOCAL VARIABLES:
682 : !
683 : ! Scalars
684 : INTEGER :: I
685 :
686 : ! Strings
687 : CHARACTER(LEN=255) :: errMsg, thisLoc
688 :
689 : ! ================================================================
690 : ! HCO_ArrVecInit_2D_Sp begins here
691 : ! ================================================================
692 :
693 : ! Initialize
694 0 : RC = HCO_SUCCESS
695 0 : errMsg = ''
696 0 : thisLoc = 'HCO_ArrVecInit_2D_Sp (hco_arr_mod.F90)'
697 :
698 : ! If dimension is zero, return a null pointer
699 0 : IF ( nn < 1 ) THEN
700 0 : ArrVec => NULL()
701 0 : RETURN
702 : ENDIF
703 :
704 : ! Allocate ArrVec if necessary
705 0 : IF ( .not. ASSOCIATED( ArrVec ) ) THEN
706 0 : ALLOCATE( ArrVec( nn ), STAT=RC )
707 0 : IF ( RC /= HCO_SUCCESS ) THEN
708 0 : errMsg = 'Could not allocate "ArrVec"!'
709 0 : CALL HCO_Error( errMsg, RC, thisLoc )
710 0 : RETURN
711 : ENDIF
712 : ENDIF
713 :
714 : ! Reset values in ArrVec
715 0 : DO I = 1, nn
716 0 : CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, ArrVec(I)%Alloc, RC )
717 0 : IF ( RC /= HCO_SUCCESS ) THEN
718 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
719 0 : CALL HCO_Error( errMsg, RC, thisLoc )
720 0 : RETURN
721 : ENDIF
722 : ENDDO
723 :
724 : END SUBROUTINE HCO_ArrVecInit_2D_Sp
725 : !EOC
726 : !------------------------------------------------------------------------------
727 : ! Harmonized Emissions Component (HEMCO) !
728 : !------------------------------------------------------------------------------
729 : !BOP
730 : !
731 : ! !IROUTINE: HCO_ArrVecInit_3D_Hp
732 : !
733 : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_3D\_Hp initializes the given data
734 : ! container 3D array vector. nn denotes the number of 2D arrays, and nx and ny
735 : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
736 : ! Val is set to a (nullified) pointer instead.
737 : !\\
738 : !\\
739 : ! !INTERFACE:
740 : !
741 0 : SUBROUTINE HCO_ArrVecInit_3D_Hp( ArrVec, nn, nx, ny, nz, RC )
742 : !
743 : ! !INPUT PARAMETERS:
744 : !
745 : INTEGER, INTENT(IN) :: nn ! vector length
746 : INTEGER, INTENT(IN) :: nx ! x-dim
747 : INTEGER, INTENT(IN) :: ny ! y-dim
748 : INTEGER, INTENT(IN) :: nz ! z-dim
749 : !
750 : ! !INPUT/OUTPUT PARAMETERS:
751 : !
752 : TYPE(Arr3D_Hp), POINTER :: ArrVec(:) ! Array vector
753 : !
754 : ! !INPUT/OUTPUT PARAMETERS:
755 : !
756 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
757 : !
758 : ! !REVISION HISTORY:
759 : ! 20 Apr 2013 - C. Keller - Initial version
760 : ! See https://github.com/geoschem/hemco for complete history
761 : !EOP
762 : !------------------------------------------------------------------------------
763 : !BOC
764 : !
765 : ! !LOCAL VARIABLES:
766 : !
767 : ! Scalars
768 : INTEGER :: I
769 :
770 : ! Strings
771 : CHARACTER(LEN=255) :: errMsg, thisLoc
772 :
773 : ! ================================================================
774 : ! HCO_ArrVecInit_3D_Hp begins here
775 : ! ================================================================
776 :
777 : ! Initialize
778 0 : RC = HCO_SUCCESS
779 0 : errMsg = ''
780 0 : thisLoc = 'HCO_ArrVecInit_3D_Hp (hco_arr_mod.F90)'
781 :
782 : ! If dimension is zero, return a null pointer
783 0 : IF ( nn < 1 ) THEN
784 0 : ArrVec => NULL()
785 0 : RETURN
786 : ENDIF
787 :
788 : ! Allocate ArrVec if necessary
789 0 : IF ( .not. ASSOCIATED( ArrVec ) ) THEN
790 0 : ALLOCATE( ArrVec( nn ), STAT=RC )
791 0 : IF ( RC /= HCO_SUCCESS ) THEN
792 0 : errMsg = 'Could not allocate "ArrVec"!'
793 0 : CALL HCO_Error( errMsg, RC, thisLoc )
794 0 : RETURN
795 : ENDIF
796 : ENDIF
797 :
798 : ! Reset values of ArrVec
799 0 : DO I = 1, nn
800 0 : CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, nz, ArrVec(I)%Alloc, RC )
801 0 : IF ( RC /= HCO_SUCCESS ) THEN
802 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
803 0 : CALL HCO_Error( errMsg, RC, thisLoc )
804 0 : RETURN
805 : ENDIF
806 : ENDDO
807 :
808 : END SUBROUTINE HCO_ArrVecInit_3D_Hp
809 : !EOC
810 : !------------------------------------------------------------------------------
811 : ! Harmonized Emissions Component (HEMCO) !
812 : !------------------------------------------------------------------------------
813 : !BOP
814 : !
815 : ! !IROUTINE: HCO_ArrVecInit_3D_Sp
816 : !
817 : ! !DESCRIPTION: Subroutine HCO\_ArrVecInit\_3D\_Sp initializes the given data
818 : ! container 3D array vector. nn denotes the number of 2D arrays, and nx and ny
819 : ! denote the array size dimensions. If nx is set to 0, no data is allocated but
820 : ! Val is set to a (nullified) pointer instead.
821 : !\\
822 : !\\
823 : ! !INTERFACE:
824 : !
825 0 : SUBROUTINE HCO_ArrVecInit_3D_Sp( ArrVec, nn, nx, ny, nz, RC )
826 : !
827 : ! !INPUT PARAMETERS:
828 : !
829 : INTEGER, INTENT(IN) :: nn ! vector length
830 : INTEGER, INTENT(IN) :: nx ! x-dim
831 : INTEGER, INTENT(IN) :: ny ! y-dim
832 : INTEGER, INTENT(IN) :: nz ! z-dim
833 : !
834 : ! !INPUT/OUTPUT PARAMETERS:
835 : !
836 : TYPE(Arr3D_Sp), POINTER :: ArrVec(:) ! Array vector
837 : !
838 : ! !INPUT/OUTPUT PARAMETERS:
839 : !
840 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
841 : !
842 : ! !REVISION HISTORY:
843 : ! 20 Apr 2013 - C. Keller - Initial version
844 : ! See https://github.com/geoschem/hemco for complete history
845 : !EOP
846 : !------------------------------------------------------------------------------
847 : !BOC
848 : !
849 : ! !LOCAL VARIABLES:
850 : !
851 : ! Scalars
852 : INTEGER :: I
853 :
854 : ! Strings
855 : CHARACTER(LEN=255) :: errMsg, thisLoc
856 :
857 : ! ================================================================
858 : ! HCO_ArrVecInit_3D_Sp begins here
859 : ! ================================================================
860 :
861 : ! Initialize
862 0 : RC = HCO_SUCCESS
863 0 : errMsg = ''
864 0 : thisLoc = 'HCO_ArrVecInit_3D_Sp (hco_arr_mod.F90)'
865 :
866 : ! If dimension is zero, return a null pointer
867 0 : IF ( nn < 1 ) THEN
868 0 : ArrVec => NULL()
869 0 : RETURN
870 : ENDIF
871 :
872 : ! Allocate ArrVec if necessary
873 0 : IF ( .not. ASSOCIATED( ArrVec ) ) THEN
874 0 : ALLOCATE( ArrVec( nn ), STAT=RC )
875 0 : IF ( RC /= HCO_SUCCESS ) THEN
876 0 : errMsg = 'Could not allocate "ArrVec"!'
877 0 : CALL HCO_Error( errMsg, RC, thisLoc )
878 0 : RETURN
879 : ENDIF
880 : ENDIF
881 :
882 : ! Reset values of ArrVec
883 0 : DO I = 1, nn
884 0 : CALL HCO_ValInit( ArrVec(I)%Val, nx, ny, nz, ArrVec(I)%Alloc, RC )
885 0 : IF ( RC /= HCO_SUCCESS ) THEN
886 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
887 0 : CALL HCO_Error( errMsg, RC, thisLoc )
888 0 : RETURN
889 : ENDIF
890 : ENDDO
891 :
892 : END SUBROUTINE HCO_ArrVecInit_3D_Sp
893 : !EOC
894 : !------------------------------------------------------------------------------
895 : ! Harmonized Emissions Component (HEMCO) !
896 : !------------------------------------------------------------------------------
897 : !BOP
898 : !
899 : ! !IROUTINE: HCO_ValInit_2D_Sp
900 : !
901 : ! !DESCRIPTION: Subroutine HCO\_ValInit\_2D\_Sp initializes the given data
902 : ! container 2D single precision array. nx and ny denote the array size
903 : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
904 : ! (nullified) pointer instead.
905 : !\\
906 : !\\
907 : ! !INTERFACE:
908 : !
909 0 : SUBROUTINE HCO_ValInit_2D_Sp( Val, nx, ny, Alloc, RC )
910 : !
911 : ! !INPUT PARAMETERS:
912 : !
913 : INTEGER, INTENT(IN) :: nx ! x-dim
914 : INTEGER, INTENT(IN) :: ny ! y-dim
915 : !
916 : ! !INPUT/OUTPUT PARAMETERS:
917 : !
918 : REAL(sp), POINTER :: Val(:,:) ! Array
919 : !
920 : ! !INPUT/OUTPUT PARAMETERS:
921 : !
922 : LOGICAL, INTENT(OUT) :: Alloc ! allocated?
923 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
924 : !
925 : ! !REVISION HISTORY:
926 : ! 20 Apr 2013 - C. Keller - Initial version
927 : ! See https://github.com/geoschem/hemco for complete history
928 : !EOP
929 : !------------------------------------------------------------------------------
930 : !BOC
931 : !
932 : ! !LOCAL VARIABLES:
933 : !
934 : ! Strings
935 : CHARACTER(LEN=255) :: errMsg, thisLoc
936 :
937 : ! ================================================================
938 : ! HCO_ValInit_2D_Sp begins here
939 : ! ================================================================
940 :
941 : ! Initialize
942 0 : RC = HCO_SUCCESS
943 0 : errMsg = ''
944 0 : thisLoc = 'HCO_ValInit_2D_Sp (hco_arr_mod.F90)'
945 :
946 : ! If dimensions are zero, just return a null pointer to Val
947 0 : IF ( nx == 0 .or. ny == 0 ) THEN
948 0 : Val => NULL()
949 0 : Alloc = .FALSE.
950 0 : RETURN
951 : ENDIF
952 :
953 : ! Initialize Val if dimensions are nonzero
954 0 : ALLOCATE( Val( nx, ny ), STAT=RC )
955 0 : IF ( RC /= HCO_SUCCESS ) THEN
956 0 : errMsg = 'Could not allocate Val!'
957 0 : CALL HCO_Error( errMsg, RC, thisLoc )
958 0 : RETURN
959 : ENDIF
960 0 : Val = 0.0_sp
961 0 : alloc = .TRUE.
962 :
963 : END SUBROUTINE HCO_ValInit_2D_Sp
964 : !EOC
965 : !------------------------------------------------------------------------------
966 : ! Harmonized Emissions Component (HEMCO) !
967 : !------------------------------------------------------------------------------
968 : !BOP
969 : !
970 : ! !IROUTINE: HCO_ValInit_2D_Dp
971 : !
972 : ! !DESCRIPTION: Subroutine HCO\_ValInit\_2D\_Dp initializes the given data
973 : ! container 2D double precision array. nx and ny denote the array size
974 : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
975 : ! (nullified) pointer instead.
976 : !\\
977 : !\\
978 : ! !INTERFACE:
979 : !
980 0 : SUBROUTINE HCO_ValInit_2D_Dp( Val, nx, ny, Alloc, RC )
981 : !
982 : ! !INPUT PARAMETERS:
983 : !
984 : INTEGER, INTENT(IN) :: nx ! x-dim
985 : INTEGER, INTENT(IN) :: ny ! y-dim
986 : !
987 : ! !INPUT/OUTPUT PARAMETERS:
988 : !
989 : REAL(dp), POINTER :: Val(:,:) ! Array
990 : !
991 : ! !INPUT/OUTPUT PARAMETERS:
992 : !
993 : LOGICAL, INTENT(OUT) :: Alloc ! allocated?
994 : INTEGER, INTENT(OUT) :: RC ! Success or failure?!
995 : !
996 : ! !REVISION HISTORY:
997 : ! 20 Apr 2013 - C. Keller - Initial version
998 : ! See https://github.com/geoschem/hemco for complete history
999 : !EOP
1000 : !------------------------------------------------------------------------------
1001 : !BOC
1002 : !
1003 : ! !LOCAL VARIABLES:
1004 : !
1005 : ! Strings
1006 : CHARACTER(LEN=255) :: errMsg, thisLoc
1007 :
1008 : ! ================================================================
1009 : ! HCO_ValInit_2D_Dp begins here
1010 : ! ================================================================
1011 :
1012 : ! Initialize
1013 0 : RC = HCO_SUCCESS
1014 0 : errMsg = ''
1015 0 : thisLoc = 'HCO_ValInit_2D_Dp (hco_arr_mod.F90)'
1016 :
1017 : ! If dimensions are zero, just return a null pointer to Val
1018 0 : IF ( nx == 0 .or. ny == 0 ) THEN
1019 0 : Val => NULL()
1020 0 : Alloc = .FALSE.
1021 0 : RETURN
1022 : ENDIF
1023 :
1024 : ! Initialize Val if dimensions are nonzero
1025 0 : ALLOCATE( Val( nx, ny ), STAT=RC )
1026 0 : IF ( RC /= HCO_SUCCESS ) THEN
1027 0 : errMsg = 'Could not allocate Val!'
1028 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1029 0 : RETURN
1030 : ENDIF
1031 0 : Val = 0.0_dp
1032 0 : alloc = .TRUE.
1033 :
1034 : END SUBROUTINE HCO_ValInit_2D_Dp
1035 : !EOC
1036 : !------------------------------------------------------------------------------
1037 : ! Harmonized Emissions Component (HEMCO) !
1038 : !------------------------------------------------------------------------------
1039 : !BOP
1040 : !
1041 : ! !IROUTINE: HCO_ValInit_2D_I
1042 : !
1043 : ! !DESCRIPTION: Subroutine HCO\_ValInit\_2D\_I initializes the given data
1044 : ! container 2D integer array. nx and ny denote the array size
1045 : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
1046 : ! (nullified) pointer instead.
1047 : !\\
1048 : !\\
1049 : ! !INTERFACE:
1050 : !
1051 0 : SUBROUTINE HCO_ValInit_2D_I( Val, nx, ny, alloc, RC )
1052 : !
1053 : ! !INPUT PARAMETERS:
1054 : !
1055 : INTEGER, INTENT(IN) :: nx ! x-dim
1056 : INTEGER, INTENT(IN) :: ny ! y-dim
1057 : !
1058 : ! !INPUT/OUTPUT PARAMETERS:
1059 : !
1060 : INTEGER, POINTER :: Val(:,:) ! Array
1061 : !
1062 : ! !INPUT/OUTPUT PARAMETERS:
1063 : !
1064 : LOGICAL, INTENT(OUT) :: Alloc ! allocated?
1065 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1066 : !
1067 : ! !REVISION HISTORY:
1068 : ! 20 Apr 2013 - C. Keller - Initial version
1069 : ! See https://github.com/geoschem/hemco for complete history
1070 : !EOP
1071 : !------------------------------------------------------------------------------
1072 : !BOC
1073 : !
1074 : ! !LOCAL VARIABLES:
1075 : !
1076 : ! Strings
1077 : CHARACTER(LEN=255) :: errMsg, thisLoc
1078 :
1079 : ! ================================================================
1080 : ! HCO_ValInit_2D_I begins here
1081 : ! ================================================================
1082 :
1083 : ! Initialize
1084 0 : RC = HCO_SUCCESS
1085 0 : errMsg = ''
1086 0 : thisLoc = 'HCO_ValInit_2D_I (hco_arr_mod.F90)'
1087 :
1088 : ! If dimensions are zero, just return a null pointer to Val
1089 0 : IF ( nx == 0 .or. ny == 0 ) THEN
1090 0 : Val => NULL()
1091 0 : Alloc = .FALSE.
1092 0 : RETURN
1093 : ENDIF
1094 :
1095 : ! Initialize Val if dimensions are nonzero
1096 0 : ALLOCATE( Val( nx, ny ), STAT=RC )
1097 0 : IF ( RC /= HCO_SUCCESS ) THEN
1098 0 : errMsg = 'Could not allocate Val!'
1099 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1100 0 : RETURN
1101 : ENDIF
1102 0 : Val = 0
1103 0 : alloc = .TRUE.
1104 :
1105 : END SUBROUTINE HCO_ValInit_2D_I
1106 : !EOC
1107 : !------------------------------------------------------------------------------
1108 : ! Harmonized Emissions Component (HEMCO) !
1109 : !------------------------------------------------------------------------------
1110 : !BOP
1111 : !
1112 : ! !IROUTINE: HCO_ValInit_3D_Dp
1113 : !
1114 : ! !DESCRIPTION: Subroutine HCO\_ValInit\_3D\_Dp initializes the given data
1115 : ! container 3D double precision array. nx and ny denote the array size
1116 : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
1117 : ! (nullified) pointer instead.
1118 : !\\
1119 : !\\
1120 : ! !INTERFACE:
1121 : !
1122 0 : SUBROUTINE HCO_ValInit_3D_Dp( Val, nx, ny, nz, Alloc, RC )
1123 : !
1124 : ! !INPUT PARAMETERS:
1125 : !
1126 : INTEGER, INTENT(IN) :: nx ! x-dim
1127 : INTEGER, INTENT(IN) :: ny ! y-dim
1128 : INTEGER, INTENT(IN) :: nz ! z-dim
1129 : !
1130 : ! !INPUT/OUTPUT PARAMETERS:
1131 : !
1132 : REAL(dp), POINTER :: Val(:,:,:) ! Array
1133 : !
1134 : ! !INPUT/OUTPUT PARAMETERS:
1135 : !
1136 : LOGICAL, INTENT(OUT) :: Alloc ! allocated?
1137 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1138 : !
1139 : ! !REVISION HISTORY:
1140 : ! 20 Apr 2013 - C. Keller - Initial version
1141 : ! See https://github.com/geoschem/hemco for complete history
1142 : !EOP
1143 : !------------------------------------------------------------------------------
1144 : !BOC
1145 : !
1146 : ! !LOCAL VARIABLES:
1147 : !
1148 : ! Strings
1149 : CHARACTER(LEN=255) :: errMsg, thisLoc
1150 :
1151 : ! ================================================================
1152 : ! HCO_ValInit_3D_Dp begins here
1153 : ! ================================================================
1154 :
1155 : ! Initialize
1156 0 : RC = HCO_SUCCESS
1157 0 : errMsg = ''
1158 0 : thisLoc = 'HCO_ValInit_3D_Dp (hco_arr_mod.F90)'
1159 :
1160 : ! If dimensions are zero, return a null pointer
1161 0 : IF ( nx == 0 .or. ny == 0 .or. nz == 0 ) THEN
1162 0 : Val => NULL()
1163 0 : Alloc = .FALSE.
1164 0 : RETURN
1165 : ENDIF
1166 :
1167 : ! Initialize Val if dimensions are nonzero
1168 0 : ALLOCATE( Val( nx, ny, nz ), STAT=RC )
1169 0 : IF ( RC /= HCO_SUCCESS ) THEN
1170 0 : errMsg = 'Could not allocate Val!'
1171 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1172 0 : RETURN
1173 : ENDIF
1174 0 : Val = 0.0_dp
1175 0 : alloc = .TRUE.
1176 :
1177 : END SUBROUTINE HCO_ValInit_3D_Dp
1178 : !EOC
1179 : !------------------------------------------------------------------------------
1180 : ! Harmonized Emissions Component (HEMCO) !
1181 : !------------------------------------------------------------------------------
1182 : !BOP
1183 : !
1184 : ! !IROUTINE: HCO_ValInit_3D_Sp
1185 : !
1186 : ! !DESCRIPTION: Subroutine HCO\_ValInit\_3D\_Sp initializes the given data
1187 : ! container 3D single precision array. nx and ny denote the array size
1188 : ! dimensions. If nx is set to 0, no data is allocated but Val is set to a
1189 : ! (nullified) pointer instead.
1190 : !\\
1191 : !\\
1192 : ! !INTERFACE:
1193 : !
1194 0 : SUBROUTINE HCO_ValInit_3D_Sp( Val, nx, ny, nz, Alloc, RC )
1195 : !
1196 : ! !INPUT PARAMETERS:
1197 : !
1198 : INTEGER, INTENT(IN) :: nx ! x-dim
1199 : INTEGER, INTENT(IN) :: ny ! y-dim
1200 : INTEGER, INTENT(IN) :: nz ! z-dim
1201 : !
1202 : ! !INPUT/OUTPUT PARAMETERS:
1203 : !
1204 : REAL(sp), POINTER :: Val(:,:,:) ! Array
1205 : !
1206 : ! !INPUT/OUTPUT PARAMETERS:
1207 : !
1208 : LOGICAL, INTENT(OUT) :: Alloc ! allocated?
1209 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1210 : !
1211 : ! !REVISION HISTORY:
1212 : ! 20 Apr 2013 - C. Keller - Initial version
1213 : ! See https://github.com/geoschem/hemco for complete history
1214 : !EOP
1215 : !------------------------------------------------------------------------------
1216 : !BOC
1217 : !
1218 : ! !LOCAL VARIABLES:
1219 : !
1220 : ! Strings
1221 : CHARACTER(LEN=255) :: errMsg, thisLoc
1222 :
1223 : ! ================================================================
1224 : ! HCO_ValInit_3D_Sp begins here
1225 : ! ================================================================
1226 :
1227 : ! Initialize
1228 0 : RC = HCO_SUCCESS
1229 0 : errMsg = ''
1230 0 : thisLoc = 'HCO_ValInit_3D_Sp (hco_arr_mod.F90)'
1231 :
1232 : ! If dimensions are zero, return a null pointer
1233 0 : IF ( nx == 0 .or. ny == 0 .or. nz == 0 ) THEN
1234 0 : Val => NULL()
1235 0 : Alloc = .FALSE.
1236 0 : RETURN
1237 : ENDIF
1238 :
1239 : ! Initialize Val if dimensions are nonzero
1240 0 : ALLOCATE( Val( nx, ny, nz ), STAT=RC )
1241 0 : IF ( RC /= HCO_SUCCESS ) THEN
1242 0 : errMsg = 'Could not allocate Val!'
1243 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1244 0 : RETURN
1245 : ENDIF
1246 0 : Val = 0.0_sp
1247 0 : alloc = .TRUE.
1248 :
1249 : END SUBROUTINE HCO_ValInit_3D_Sp
1250 : !EOC
1251 : !------------------------------------------------------------------------------
1252 : ! Harmonized Emissions Component (HEMCO) !
1253 : !------------------------------------------------------------------------------
1254 : !BOP
1255 : !
1256 : ! !IROUTINE: HCO_ArrAssert_3D_Hp
1257 : !
1258 : ! !DESCRIPTION: Routine HCO\_ArrAssert\_3D\_Hp makes sure that the passed
1259 : ! 3D array is allocated.
1260 : !\\
1261 : !\\
1262 : ! !INTERFACE:
1263 : !
1264 0 : SUBROUTINE HCO_ArrAssert_3D_Hp( ThisArr3D, I, J, L, RC )
1265 : !
1266 : ! !INPUT PARAMETERS:
1267 : !
1268 : INTEGER, INTENT(IN) :: I, J, L ! Array dims
1269 : !
1270 : ! !INPUT/OUTPUT PARAMETERS:
1271 : !
1272 : TYPE(Arr3D_Hp), POINTER :: ThisArr3D ! 3D array
1273 : !
1274 : ! !OUTPUT PARAMETERS:
1275 : !
1276 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1277 : !
1278 : ! !REVISION HISTORY:
1279 : ! 01 May 2013 - C. Keller - Initial version
1280 : ! See https://github.com/geoschem/hemco for complete history
1281 : !EOP
1282 : !------------------------------------------------------------------------------
1283 : !BOC
1284 : !
1285 : ! !LOCAL VARIABLES:
1286 : !
1287 : ! Strings
1288 : CHARACTER(LEN=255) :: errMsg, thisLoc
1289 :
1290 : !=====================================================================
1291 : ! HCO_ArrAssert_3D_Hp begins here!
1292 : !=====================================================================
1293 :
1294 : ! Initialize
1295 0 : RC = HCO_SUCCESS
1296 0 : errMsg = ''
1297 0 : thisLoc = 'HCO_ArrAssert_3D_Hp (hco_arr_mod.F90)'
1298 :
1299 : ! Check flux array
1300 0 : IF ( .not. ASSOCIATED ( ThisArr3D ) ) THEN
1301 0 : CALL HCO_ArrInit( ThisArr3D, I, J, L, RC )
1302 0 : IF ( RC /= HCO_SUCCESS ) THEN
1303 0 : errMsg = 'Error encountered in "HCO_ArrInit"!'
1304 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1305 0 : RETURN
1306 : ENDIF
1307 :
1308 0 : ELSE IF ( .not. ASSOCIATED ( ThisArr3D%Val ) ) THEN
1309 0 : CALL HCO_ValInit( ThisArr3D%Val, I, J, L, ThisArr3D%Alloc, RC )
1310 0 : IF ( RC /= HCO_SUCCESS ) THEN
1311 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
1312 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1313 0 : RETURN
1314 : ENDIF
1315 :
1316 : ENDIF
1317 :
1318 : END SUBROUTINE HCO_ArrAssert_3D_Hp
1319 : !EOC
1320 : !------------------------------------------------------------------------------
1321 : ! Harmonized Emissions Component (HEMCO) !
1322 : !------------------------------------------------------------------------------
1323 : !BOP
1324 : !
1325 : ! !IROUTINE: HCO_ArrAssert_3D_Sp
1326 : !
1327 : ! !DESCRIPTION: Routine HCO\_ArrAssert\_3D\_Sp makes sure that the passed
1328 : ! 3D array is allocated.
1329 : !\\
1330 : !\\
1331 : ! !INTERFACE:
1332 : !
1333 0 : SUBROUTINE HCO_ArrAssert_3D_Sp( ThisArr3D, I, J, L, RC )
1334 : !
1335 : ! !INPUT PARAMETERS:
1336 : !
1337 : INTEGER, INTENT(IN) :: I, J, L ! Array dims
1338 : !
1339 : ! !INPUT/OUTPUT PARAMETERS:
1340 : !
1341 : TYPE(Arr3D_Sp), POINTER :: ThisArr3D ! 3D array
1342 : !
1343 : ! !OUTPUT PARAMETERS:
1344 : !
1345 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1346 : !
1347 : ! !REVISION HISTORY:
1348 : ! 01 May 2013 - C. Keller - Initial version
1349 : ! See https://github.com/geoschem/hemco for complete history
1350 : !EOP
1351 : !------------------------------------------------------------------------------
1352 : !BOC
1353 : !
1354 : ! !LOCAL VARIABLES:
1355 : !
1356 : ! Strings
1357 : CHARACTER(LEN=255) :: errMsg, thisLoc
1358 :
1359 : !=====================================================================
1360 : ! HCO_ArrAssert_3D_Sp begins here!
1361 : !=====================================================================
1362 :
1363 : ! Initialize
1364 0 : RC = HCO_SUCCESS
1365 0 : errMsg = ''
1366 0 : thisLoc = 'HCO_ArrAssert_3D_Sp (hco_arr_mod.F90)'
1367 :
1368 : ! Check flux array
1369 0 : IF ( .not. ASSOCIATED ( ThisArr3D ) ) THEN
1370 0 : CALL HCO_ArrInit( ThisArr3D, I, J, L, RC )
1371 0 : IF ( RC /= HCO_SUCCESS ) THEN
1372 0 : errMsg = 'Error encountered in "HCO_ArrInit"!'
1373 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1374 0 : RETURN
1375 : ENDIF
1376 :
1377 0 : ELSE IF ( .not. ASSOCIATED ( ThisArr3D%Val ) ) THEN
1378 0 : CALL HCO_ValInit ( ThisArr3D%Val, I, J, L, ThisArr3D%Alloc, RC )
1379 0 : IF ( RC /= HCO_SUCCESS ) THEN
1380 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
1381 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1382 0 : RETURN
1383 : ENDIF
1384 :
1385 : ENDIF
1386 :
1387 : END SUBROUTINE HCO_ArrAssert_3D_Sp
1388 : !EOC
1389 : !------------------------------------------------------------------------------
1390 : ! Harmonized Emissions Component (HEMCO) !
1391 : !------------------------------------------------------------------------------
1392 : !BOP
1393 : !
1394 : ! !IROUTINE: HCO_ArrAssert_2D_Hp
1395 : !
1396 : ! !DESCRIPTION: Routine HCO\_ArrAssert\_2D\_Hp makes sure that the passed
1397 : ! 2D array is allocated.
1398 : !\\
1399 : !\\
1400 : ! !INTERFACE:
1401 : !
1402 0 : SUBROUTINE HCO_ArrAssert_2D_Hp( ThisArr2D, I, J, RC )
1403 : !
1404 : ! !INPUT PARAMETERS:
1405 : !
1406 : INTEGER, INTENT(IN) :: I, J ! Array dims
1407 : !
1408 : ! !INPUT/OUTPUT PARAMETERS:
1409 : !
1410 : TYPE(Arr2D_Hp), POINTER :: ThisArr2D ! 2D array
1411 : !
1412 : ! !OUTPUT PARAMETERS:
1413 : !
1414 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1415 : !
1416 : ! !REVISION HISTORY:
1417 : ! 01 May 2013 - C. Keller - Initial version
1418 : ! See https://github.com/geoschem/hemco for complete history
1419 : !EOP
1420 : !------------------------------------------------------------------------------
1421 : !BOC
1422 : !
1423 : ! !LOCAL VARIABLES:
1424 : !
1425 : ! Strings
1426 : CHARACTER(LEN=255) :: errMsg, thisLoc
1427 :
1428 : !=====================================================================
1429 : ! HCO_ArrAssert_2D_Hp begins here!
1430 : !=====================================================================
1431 :
1432 : ! Initialize
1433 0 : RC = HCO_SUCCESS
1434 0 : errMsg = ''
1435 0 : thisLoc = 'HCO_ArrAssert_2D_Hp (hco_arr_mod.F90)'
1436 :
1437 : ! Check flux array
1438 0 : IF ( .not. ASSOCIATED ( ThisArr2D ) ) THEN
1439 0 : CALL HCO_ArrInit( ThisArr2D, I, J, RC )
1440 0 : IF ( RC /= HCO_SUCCESS ) THEN
1441 0 : errMsg = 'Error encountered in "HCO_ArrInit"!'
1442 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1443 0 : RETURN
1444 : ENDIF
1445 :
1446 0 : ELSE IF ( .not. ASSOCIATED ( ThisArr2D%Val ) ) THEN
1447 0 : CALL HCO_ValInit( ThisArr2D%Val, I, J, ThisArr2D%Alloc, RC )
1448 0 : IF ( RC /= HCO_SUCCESS ) THEN
1449 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
1450 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1451 0 : RETURN
1452 : ENDIF
1453 :
1454 : ENDIF
1455 :
1456 : END SUBROUTINE HCO_ArrAssert_2D_Hp
1457 : !EOC
1458 : !------------------------------------------------------------------------------
1459 : ! Harmonized Emissions Component (HEMCO) !
1460 : !------------------------------------------------------------------------------
1461 : !BOP
1462 : !
1463 : ! !IROUTINE: HCO_ArrAssert_2D_Sp
1464 : !
1465 : ! !DESCRIPTION: Routine HCO\_ArrAssert\_2D\_Sp makes sure that the passed
1466 : ! 2D array is allocated.
1467 : !\\
1468 : !\\
1469 : ! !INTERFACE:
1470 : !
1471 0 : SUBROUTINE HCO_ArrAssert_2D_Sp( ThisArr2D, I, J, RC )
1472 : !
1473 : ! !INPUT PARAMETERS:
1474 : !
1475 : INTEGER, INTENT(IN) :: I, J ! Array dims
1476 : !
1477 : ! !INPUT/OUTPUT PARAMETERS:
1478 : !
1479 : TYPE(Arr2D_Sp), POINTER :: ThisArr2D ! 2D array
1480 : !
1481 : ! !OUTPUT PARAMETERS:
1482 : !
1483 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1484 : !
1485 : ! !REVISION HISTORY:
1486 : ! 01 May 2013 - C. Keller - Initial version
1487 : ! See https://github.com/geoschem/hemco for complete history
1488 : !EOP
1489 : !------------------------------------------------------------------------------
1490 : !BOC
1491 : !
1492 : ! !LOCAL VARIABLES:
1493 : !
1494 : ! Strings
1495 : CHARACTER(LEN=255) :: errMsg, thisLoc
1496 :
1497 : !=====================================================================
1498 : ! HCO_ArrAssert_2D_Sp begins here!
1499 : !=====================================================================
1500 :
1501 : ! Initialize
1502 0 : RC = HCO_SUCCESS
1503 0 : errMsg = ''
1504 0 : thisLoc = 'HCO_ArrAssert_2D_Sp (hco_arr_mod.F90)'
1505 :
1506 : ! Check flux array
1507 0 : IF ( .not. ASSOCIATED ( ThisArr2D ) ) THEN
1508 0 : CALL HCO_ArrInit( ThisArr2D, I, J, RC )
1509 0 : IF ( RC /= HCO_SUCCESS ) THEN
1510 0 : errMsg = 'Error encountered in "HCO_ArrInit"!'
1511 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1512 0 : RETURN
1513 : ENDIF
1514 :
1515 0 : ELSE IF ( .not. ASSOCIATED ( ThisArr2D%Val ) ) THEN
1516 0 : CALL HCO_ValInit ( ThisArr2D%Val, I, J, ThisArr2D%Alloc, RC )
1517 0 : IF ( RC /= HCO_SUCCESS ) THEN
1518 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
1519 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1520 0 : RETURN
1521 : ENDIF
1522 :
1523 : ENDIF
1524 :
1525 : END SUBROUTINE HCO_ArrAssert_2D_Sp
1526 : !EOC
1527 : !------------------------------------------------------------------------------
1528 : ! Harmonized Emissions Component (HEMCO) !
1529 : !------------------------------------------------------------------------------
1530 : !BOP
1531 : !
1532 : ! !IROUTINE: HCO_ArrAssert_2D_I
1533 : !
1534 : ! !DESCRIPTION: Routine HCO\_ArrAssert\_2D\_I makes sure that the passed
1535 : ! 2D array is allocated.
1536 : !\\
1537 : !\\
1538 : ! !INTERFACE:
1539 : !
1540 0 : SUBROUTINE HCO_ArrAssert_2D_I( ThisArr2D, I, J, RC )
1541 : !
1542 : ! !INPUT PARAMETERS:
1543 : !
1544 : INTEGER, INTENT(IN) :: I, J ! Array dims
1545 : !
1546 : ! !INPUT/OUTPUT PARAMETERS:
1547 : !
1548 : TYPE(Arr2D_I), POINTER :: ThisArr2D ! 2D array
1549 : !
1550 : ! !OUTPUT PARAMETERS:
1551 : !
1552 : INTEGER, INTENT(OUT) :: RC ! Success or failure?
1553 : !
1554 : ! !REVISION HISTORY:
1555 : ! 01 May 2013 - C. Keller - Initial version
1556 : ! See https://github.com/geoschem/hemco for complete history
1557 : !EOP
1558 : !------------------------------------------------------------------------------
1559 : !BOC
1560 : !
1561 : ! !LOCAL VARIABLES:
1562 : !
1563 : ! Strings
1564 : CHARACTER(LEN=255) :: errMsg, thisLoc
1565 :
1566 : !=====================================================================
1567 : ! HCO_ArrAssert_2D_I begins here!
1568 : !=====================================================================
1569 :
1570 : ! Initialize
1571 0 : RC = HCO_SUCCESS
1572 0 : errMsg = ''
1573 0 : thisLoc = 'HCO_ArrAssert_2D_I (hco_arr_mod.F90)'
1574 :
1575 : ! Check flux array
1576 0 : IF ( .not. ASSOCIATED ( ThisArr2D ) ) THEN
1577 0 : CALL HCO_ArrInit( ThisArr2D, I, J, RC )
1578 0 : IF ( RC /= HCO_SUCCESS ) THEN
1579 0 : errMsg = 'Error encountered in "HCO_ArrInit"!'
1580 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1581 0 : RETURN
1582 : ENDIF
1583 :
1584 0 : ELSE IF ( .not. ASSOCIATED ( ThisArr2D%Val ) ) THEN
1585 0 : CALL HCO_ValInit ( ThisArr2D%Val, I, J, ThisArr2D%Alloc, RC )
1586 0 : IF ( RC /= HCO_SUCCESS ) THEN
1587 0 : errMsg = 'Error encountered in "HCO_ValInit"!'
1588 0 : CALL HCO_Error( errMsg, RC, thisLoc )
1589 0 : RETURN
1590 : ENDIF
1591 :
1592 : ENDIF
1593 :
1594 : END SUBROUTINE HCO_ArrAssert_2D_I
1595 : !EOC
1596 : !------------------------------------------------------------------------------
1597 : ! Harmonized Emissions Component (HEMCO) !
1598 : !------------------------------------------------------------------------------
1599 : !BOP
1600 : !
1601 : ! !IROUTINE: HCO_ArrCleanup_2D_Hp
1602 : !
1603 : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_2D\_Hp cleans up the given
1604 : ! container 2D array.
1605 : !\\
1606 : !\\
1607 : ! !INTERFACE:
1608 : !
1609 0 : SUBROUTINE HCO_ArrCleanup_2D_Hp( Arr, DeepClean )
1610 : !
1611 : ! !INPUT PARAMETERS:
1612 : !
1613 : TYPE(Arr2D_Hp), POINTER :: Arr ! Array
1614 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate allocated array?
1615 : !
1616 : ! !REVISION HISTORY:
1617 : ! 20 Apr 2013 - C. Keller - Initial version
1618 : ! See https://github.com/geoschem/hemco for complete history
1619 : !EOP
1620 : !------------------------------------------------------------------------------
1621 : !BOC
1622 : !
1623 : ! !LOCAL VARIABLES:
1624 : !
1625 : LOGICAL :: DC
1626 :
1627 : ! ================================================================
1628 : ! HCO_ArrCleanup_2D_Hp begins here
1629 : ! ================================================================
1630 0 : IF ( ASSOCIATED( Arr ) ) THEN
1631 :
1632 : ! Optional argument handling
1633 0 : DC = .TRUE.
1634 0 : IF ( PRESENT( DeepClean ) ) DC = DeepClean
1635 :
1636 : ! Finalize Arr%Val and Arr
1637 0 : CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
1638 0 : DEALLOCATE( Arr )
1639 : ENDIF
1640 :
1641 0 : END SUBROUTINE HCO_ArrCleanup_2D_Hp
1642 : !EOC
1643 : !------------------------------------------------------------------------------
1644 : ! Harmonized Emissions Component (HEMCO) !
1645 : !------------------------------------------------------------------------------
1646 : !BOP
1647 : !
1648 : ! !IROUTINE: HCO_ArrCleanup_2D_Sp
1649 : !
1650 : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_2D\_Sp cleans up the given
1651 : ! container 2D array.
1652 : !\\
1653 : !\\
1654 : ! !INTERFACE:
1655 : !
1656 0 : SUBROUTINE HCO_ArrCleanup_2D_Sp( Arr, DeepClean )
1657 : !
1658 : ! !INPUT PARAMETERS:
1659 : !
1660 : TYPE(Arr2D_Sp), POINTER :: Arr ! Array
1661 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate allocated array?
1662 : !
1663 : ! !REVISION HISTORY:
1664 : ! 20 Apr 2013 - C. Keller - Initial version
1665 : ! See https://github.com/geoschem/hemco for complete history
1666 : !EOP
1667 : !------------------------------------------------------------------------------
1668 : !BOC
1669 : !
1670 : ! !LOCAL VARIABLES:
1671 : !
1672 : LOGICAL :: DC
1673 :
1674 : ! ================================================================
1675 : ! HCO_ArrCleanup_2D_Sp begins here
1676 : ! ================================================================
1677 0 : IF ( ASSOCIATED( Arr ) ) THEN
1678 :
1679 : ! Optional argument handling
1680 0 : DC = .TRUE.
1681 0 : IF ( PRESENT( DeepClean ) ) DC = DeepClean
1682 :
1683 : ! Finalize Arr%Val and Arr
1684 0 : CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
1685 0 : DEALLOCATE( Arr )
1686 : ENDIF
1687 :
1688 0 : END SUBROUTINE HCO_ArrCleanup_2D_Sp
1689 : !EOC
1690 : !------------------------------------------------------------------------------
1691 : ! Harmonized Emissions Component (HEMCO) !
1692 : !------------------------------------------------------------------------------
1693 : !BOP
1694 : !
1695 : ! !IROUTINE: HCO_ArrCleanup_2D_I
1696 : !
1697 : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_2D\_I cleans up the given
1698 : ! container 2D array.
1699 : !\\
1700 : !\\
1701 : ! !INTERFACE:
1702 : !
1703 0 : SUBROUTINE HCO_ArrCleanup_2D_I( Arr, DeepClean )
1704 : !
1705 : ! !INPUT PARAMETERS:
1706 : !
1707 : TYPE(Arr2D_I), POINTER :: Arr ! Array
1708 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
1709 : !
1710 : ! !REVISION HISTORY:
1711 : ! 20 Apr 2013 - C. Keller - Initial version
1712 : ! See https://github.com/geoschem/hemco for complete history
1713 : !EOP
1714 : !------------------------------------------------------------------------------
1715 : !BOC
1716 : !
1717 : ! !LOCAL VARIABLES:
1718 : !
1719 : LOGICAL :: DC
1720 :
1721 : ! ================================================================
1722 : ! HCO_ArrCleanup_2D_I begins here
1723 : ! ================================================================
1724 0 : IF ( ASSOCIATED( Arr ) ) THEN
1725 :
1726 : ! Optional argument handling
1727 0 : DC = .TRUE.
1728 0 : IF ( PRESENT( DeepClean ) ) DC = DeepClean
1729 :
1730 : ! Finalize Arr%Val and Arr
1731 0 : CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
1732 0 : DEALLOCATE( Arr )
1733 : ENDIF
1734 :
1735 0 : END SUBROUTINE HCO_ArrCleanup_2D_I
1736 : !EOC
1737 : !------------------------------------------------------------------------------
1738 : ! Harmonized Emissions Component (HEMCO) !
1739 : !------------------------------------------------------------------------------
1740 : !BOP
1741 : !
1742 : ! !IROUTINE: HCO_ArrCleanup_3D_Hp
1743 : !
1744 : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_3D\_Hp cleans up the given
1745 : ! container 3D array.
1746 : !\\
1747 : !\\
1748 : ! !INTERFACE:
1749 : !
1750 0 : SUBROUTINE HCO_ArrCleanup_3D_Hp( Arr, DeepClean )
1751 : !
1752 : ! !INPUT PARAMETERS:
1753 : !
1754 : TYPE(Arr3D_Hp), POINTER :: Arr ! Array
1755 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
1756 : !
1757 : ! !REVISION HISTORY:
1758 : ! 20 Apr 2013 - C. Keller - Initial version
1759 : ! See https://github.com/geoschem/hemco for complete history
1760 : !EOP
1761 : !------------------------------------------------------------------------------
1762 : !BOC
1763 : !
1764 : ! !LOCAL VARIABLES:
1765 : !
1766 : LOGICAL :: DC
1767 :
1768 : ! ================================================================
1769 : ! HCO_ArrCleanup_3D_Hp begins here
1770 : ! ================================================================
1771 0 : IF ( ASSOCIATED( Arr ) ) THEN
1772 :
1773 : ! Optional argument handling
1774 0 : DC = .TRUE.
1775 0 : IF ( PRESENT( DeepClean ) ) DC = DeepClean
1776 :
1777 : ! Finalize Arr%Val and Arr
1778 0 : CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
1779 0 : DEALLOCATE( Arr )
1780 : ENDIF
1781 0 : END SUBROUTINE HCO_ArrCleanup_3D_Hp
1782 : !EOC
1783 : !------------------------------------------------------------------------------
1784 : ! Harmonized Emissions Component (HEMCO) !
1785 : !------------------------------------------------------------------------------
1786 : !BOP
1787 : !
1788 : ! !IROUTINE: HCO_ArrCleanup_3D_Sp
1789 : !
1790 : ! !DESCRIPTION: Subroutine HCO\_ArrCleanup\_3D\_Sp cleans up the given
1791 : ! container 3D array.
1792 : !\\
1793 : !\\
1794 : ! !INTERFACE:
1795 : !
1796 0 : SUBROUTINE HCO_ArrCleanup_3D_Sp( Arr, DeepClean )
1797 : !
1798 : ! !INPUT PARAMETERS:
1799 : !
1800 : TYPE(Arr3D_Sp), POINTER :: Arr ! Array
1801 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
1802 : !
1803 : ! !REVISION HISTORY:
1804 : ! 20 Apr 2013 - C. Keller - Initial version
1805 : ! See https://github.com/geoschem/hemco for complete history
1806 : !EOP
1807 : !------------------------------------------------------------------------------
1808 : !BOC
1809 : !
1810 : ! !LOCAL VARIABLES:
1811 : !
1812 : LOGICAL :: DC
1813 :
1814 : ! ================================================================
1815 : ! HCO_ArrCleanup_3D_Sp begins here
1816 : ! ================================================================
1817 0 : IF ( ASSOCIATED( Arr ) ) THEN
1818 :
1819 : ! Optional argument handling
1820 0 : DC = .TRUE.
1821 0 : IF ( PRESENT( DeepClean ) ) DC = DeepClean
1822 :
1823 : ! Finalize Arr%Val and Arr
1824 0 : CALL HCO_ValCleanup( Arr%Val, Arr%Alloc, DeepClean=DC )
1825 0 : DEALLOCATE( Arr )
1826 : ENDIF
1827 :
1828 0 : END SUBROUTINE HCO_ArrCleanup_3D_Sp
1829 : !EOC
1830 : !------------------------------------------------------------------------------
1831 : ! Harmonized Emissions Component (HEMCO) !
1832 : !------------------------------------------------------------------------------
1833 : !BOP
1834 : !
1835 : ! !IROUTINE: HCO_ArrVecCleanup_2D_Hp
1836 : !
1837 : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_2D\_Hp cleans up the given
1838 : ! container 2D array vector.
1839 : !\\
1840 : !\\
1841 : ! !INTERFACE:
1842 : !
1843 0 : SUBROUTINE HCO_ArrVecCleanup_2D_Hp( ArrVec, DeepClean )
1844 : !
1845 : ! !INPUT PARAMETERS:
1846 : !
1847 : TYPE(Arr2D_Hp), POINTER :: ArrVec(:) ! Array
1848 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
1849 : !
1850 : ! !REVISION HISTORY:
1851 : ! 20 Apr 2013 - C. Keller - Initial version
1852 : ! See https://github.com/geoschem/hemco for complete history
1853 : !EOP
1854 : !------------------------------------------------------------------------------
1855 : !BOC
1856 : !
1857 : ! !LOCAL VARIABLES:
1858 : !
1859 : LOGICAL :: DC
1860 : INTEGER :: I
1861 :
1862 : ! ================================================================
1863 : ! HCO_ArrVecCleanup_2D_Hp begins here
1864 : ! ================================================================
1865 0 : IF ( ASSOCIATED( ArrVec ) ) THEN
1866 :
1867 : ! Optional argument handling
1868 0 : DC = .TRUE.
1869 0 : IF ( PRESENT(DeepClean) ) DC = DeepClean
1870 :
1871 : ! Finalize ArrVec
1872 0 : DO I = 1, SIZE(ArrVec,1)
1873 0 : CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
1874 : ENDDO
1875 0 : DEALLOCATE( ArrVec )
1876 :
1877 : ENDIF
1878 :
1879 0 : END SUBROUTINE HCO_ArrVecCleanup_2D_Hp
1880 : !EOC
1881 : !------------------------------------------------------------------------------
1882 : ! Harmonized Emissions Component (HEMCO) !
1883 : !------------------------------------------------------------------------------
1884 : !BOP
1885 : !
1886 : ! !IROUTINE: HCO_ArrVecCleanup_2D_Sp
1887 : !
1888 : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_2D\_Sp cleans up the given
1889 : ! container 2D array vector.
1890 : !\\
1891 : !\\
1892 : ! !INTERFACE:
1893 : !
1894 0 : SUBROUTINE HCO_ArrVecCleanup_2D_Sp( ArrVec, DeepClean )
1895 : !
1896 : ! !INPUT PARAMETERS:
1897 : !
1898 : TYPE(Arr2D_Sp), POINTER :: ArrVec(:) ! Array
1899 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
1900 : !
1901 : ! !REVISION HISTORY:
1902 : ! 20 Apr 2013 - C. Keller - Initial version
1903 : ! See https://github.com/geoschem/hemco for complete history
1904 : !EOP
1905 : !------------------------------------------------------------------------------
1906 : !BOC
1907 : !
1908 : ! !LOCAL VARIABLES:
1909 : !
1910 : LOGICAL :: DC
1911 : INTEGER :: I
1912 :
1913 : ! ================================================================
1914 : ! HCO_ArrVecCleanup_2D_Sp begins here
1915 : ! ================================================================
1916 0 : IF ( ASSOCIATED(ArrVec) ) THEN
1917 :
1918 : ! Optional argument handling
1919 0 : DC = .TRUE.
1920 0 : IF ( PRESENT( DeepClean) ) DC = DeepClean
1921 :
1922 : ! Finalize ArrVec
1923 0 : DO I = 1, SIZE(ArrVec,1)
1924 0 : CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
1925 : ENDDO
1926 0 : DEALLOCATE ( ArrVec )
1927 :
1928 : ENDIF
1929 :
1930 0 : END SUBROUTINE HCO_ArrVecCleanup_2D_Sp
1931 : !EOC
1932 : !------------------------------------------------------------------------------
1933 : ! Harmonized Emissions Component (HEMCO) !
1934 : !------------------------------------------------------------------------------
1935 : !BOP
1936 : !
1937 : ! !IROUTINE: HCO_ArrVecCleanup_3D_Hp
1938 : !
1939 : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_3D\_Hp cleans up the given
1940 : ! container 3D array vector.
1941 : !\\
1942 : !\\
1943 : ! !INTERFACE:
1944 : !
1945 0 : SUBROUTINE HCO_ArrVecCleanup_3D_Hp( ArrVec, DeepClean )
1946 : !
1947 : ! !INPUT PARAMETERS:
1948 : !
1949 : TYPE(Arr3D_Hp), POINTER :: ArrVec(:) ! Array
1950 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
1951 : !
1952 : ! !REVISION HISTORY:
1953 : ! 20 Apr 2013 - C. Keller - Initial version
1954 : ! See https://github.com/geoschem/hemco for complete history
1955 : !EOP
1956 : !------------------------------------------------------------------------------
1957 : !BOC
1958 : !
1959 : ! !LOCAL VARIABLES:
1960 : !
1961 : LOGICAL :: DC
1962 : INTEGER :: I
1963 :
1964 : ! ================================================================
1965 : ! HCO_ArrVecCleanup_3D_Hp begins here
1966 : ! ================================================================
1967 0 : IF ( ASSOCIATED( ArrVec ) ) THEN
1968 :
1969 : ! Optional argument handling
1970 0 : DC = .TRUE.
1971 0 : IF ( PRESENT(DeepClean) ) DC = DeepClean
1972 :
1973 : ! Finalize ArrVec
1974 0 : DO I = 1, SIZE(ArrVec,1)
1975 0 : CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
1976 : ENDDO
1977 0 : DEALLOCATE ( ArrVec )
1978 :
1979 : ENDIF
1980 :
1981 0 : END SUBROUTINE HCO_ArrVecCleanup_3D_Hp
1982 : !EOC
1983 : !------------------------------------------------------------------------------
1984 : ! Harmonized Emissions Component (HEMCO) !
1985 : !------------------------------------------------------------------------------
1986 : !BOP
1987 : !
1988 : ! !IROUTINE: HCO_ArrVecCleanup_3D_Sp
1989 : !
1990 : ! !DESCRIPTION: Subroutine HCO\_ArrVecCleanup\_3D\_Sp cleans up the given
1991 : ! container 3D array vector.
1992 : !\\
1993 : !\\
1994 : ! !INTERFACE:
1995 : !
1996 0 : SUBROUTINE HCO_ArrVecCleanup_3D_Sp( ArrVec, DeepClean )
1997 : !
1998 : ! !INPUT PARAMETERS:
1999 : !
2000 : TYPE(Arr3D_Sp), POINTER :: ArrVec(:) ! Array
2001 : LOGICAL, INTENT(IN), OPTIONAL :: DeepClean ! Deallocate array?
2002 : !
2003 : ! !REVISION HISTORY:
2004 : ! 20 Apr 2013 - C. Keller - Initial version
2005 : ! See https://github.com/geoschem/hemco for complete history
2006 : !EOP
2007 : !------------------------------------------------------------------------------
2008 : !BOC
2009 : !
2010 : ! !LOCAL VARIABLES:
2011 : !
2012 : LOGICAL :: DC
2013 : INTEGER :: I
2014 :
2015 : ! ================================================================
2016 : ! HCO_ArrVecCleanup_3D_Sp begins here
2017 : ! ================================================================
2018 0 : IF ( ASSOCIATED( ArrVec ) ) THEN
2019 :
2020 : ! Optional argument handling
2021 0 : DC = .TRUE.
2022 0 : IF ( PRESENT(DeepClean) ) DC = DeepClean
2023 :
2024 : ! Finalize ArrVec
2025 0 : DO I = 1, SIZE(ArrVec,1)
2026 0 : CALL HCO_ValCleanup( ArrVec(I)%Val, ArrVec(I)%Alloc, DC )
2027 : ENDDO
2028 0 : DEALLOCATE ( ArrVec )
2029 :
2030 : ENDIF
2031 :
2032 0 : END SUBROUTINE HCO_ArrVecCleanup_3D_Sp
2033 : !EOC
2034 : !------------------------------------------------------------------------------
2035 : ! Harmonized Emissions Component (HEMCO) !
2036 : !------------------------------------------------------------------------------
2037 : !BOP
2038 : !
2039 : ! !IROUTINE: HCO_ValCleanup_2D_Dp
2040 : !
2041 : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_2D\_Dp cleans up the given
2042 : ! container 2D array. If DeepClean is set to TRUE and the array is
2043 : ! indeed allocated (as determined by the Alloc flag), the array becomes
2044 : ! deallocated. Otherwise, it is just nullified.
2045 : !\\
2046 : !\\
2047 : ! !INTERFACE:
2048 : !
2049 0 : SUBROUTINE HCO_ValCleanup_2D_Dp( Val, Alloc, DeepClean )
2050 : !
2051 : ! !INPUT PARAMETERS:
2052 : !
2053 : LOGICAL, INTENT(IN) :: Alloc ! Allocated?
2054 : LOGICAL, INTENT(IN) :: DeepClean ! Deallocate array?
2055 : !
2056 : ! !INPUT/OUTPUT PARAMETERS:
2057 : !
2058 : REAL(dp), POINTER :: Val(:,:) ! Array
2059 : !
2060 : ! !REVISION HISTORY:
2061 : ! 20 Apr 2013 - C. Keller - Initial version
2062 : ! See https://github.com/geoschem/hemco for complete history
2063 : !EOP
2064 : !------------------------------------------------------------------------------
2065 : !BOC
2066 0 : IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
2067 0 : DEALLOCATE( Val )
2068 : ENDIF
2069 0 : Val => NULL()
2070 :
2071 0 : END SUBROUTINE HCO_ValCleanup_2D_Dp
2072 : !EOC
2073 : !------------------------------------------------------------------------------
2074 : ! Harmonized Emissions Component (HEMCO) !
2075 : !------------------------------------------------------------------------------
2076 : !BOP
2077 : !
2078 : ! !IROUTINE: HCO_ValCleanup_2D_Sp
2079 : !
2080 : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_2D\_Sp cleans up the given
2081 : ! container 2D array. If DeepClean is set to TRUE and the array is
2082 : ! indeed allocated (as determined by the Alloc flag), the array becomes
2083 : ! deallocated. Otherwise, it is just nullified.
2084 : !\\
2085 : !\\
2086 : ! !INTERFACE:
2087 : !
2088 0 : SUBROUTINE HCO_ValCleanup_2D_Sp( Val, Alloc, DeepClean )
2089 : !
2090 : ! !INPUT PARAMETERS:
2091 : !
2092 : LOGICAL, INTENT(IN) :: Alloc ! Allocated?
2093 : LOGICAL, INTENT(IN) :: DeepClean ! Deallocate array?
2094 : !
2095 : ! !INPUT/OUTPUT PARAMETERS:
2096 : !
2097 : REAL(sp), POINTER :: Val(:,:) ! Array
2098 : !
2099 : ! !REVISION HISTORY:
2100 : ! 20 Apr 2013 - C. Keller - Initial version
2101 : ! See https://github.com/geoschem/hemco for complete history
2102 : !EOP
2103 : !------------------------------------------------------------------------------
2104 : !BOC
2105 0 : IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
2106 0 : DEALLOCATE( Val )
2107 : ENDIF
2108 0 : Val => NULL()
2109 :
2110 0 : END SUBROUTINE HCO_ValCleanup_2D_Sp
2111 : !EOC
2112 : !------------------------------------------------------------------------------
2113 : ! Harmonized Emissions Component (HEMCO) !
2114 : !------------------------------------------------------------------------------
2115 : !BOP
2116 : !
2117 : ! !IROUTINE: HCO_ValCleanup_2D_I
2118 : !
2119 : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_2D\_I cleans up the given
2120 : ! container 2D array. If DeepClean is set to TRUE and the array is
2121 : ! indeed allocated (as determined by the Alloc flag), the array becomes
2122 : ! deallocated. Otherwise, it is just nullified.
2123 : !\\
2124 : !\\
2125 : ! !INTERFACE:
2126 : !
2127 0 : SUBROUTINE HCO_ValCleanup_2D_I( Val, Alloc, DeepClean )
2128 : !
2129 : ! !INPUT PARAMETERS:
2130 : !
2131 : LOGICAL, INTENT(IN) :: Alloc ! Allocated?
2132 : LOGICAL, INTENT(IN) :: DeepClean ! Deallocate array?
2133 : !
2134 : ! !INPUT/OUTPUT PARAMETERS:
2135 : !
2136 : INTEGER, POINTER :: Val(:,:) ! Array
2137 : !
2138 : ! !REVISION HISTORY:
2139 : ! 20 Apr 2013 - C. Keller - Initial version
2140 : ! See https://github.com/geoschem/hemco for complete history
2141 : !EOP
2142 : !------------------------------------------------------------------------------
2143 : !BOC
2144 0 : IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
2145 0 : DEALLOCATE( Val )
2146 : ENDIF
2147 0 : Val => NULL()
2148 :
2149 0 : END SUBROUTINE HCO_ValCleanup_2D_I
2150 : !EOC
2151 : !------------------------------------------------------------------------------
2152 : ! Harmonized Emissions Component (HEMCO) !
2153 : !------------------------------------------------------------------------------
2154 : !BOP
2155 : !
2156 : ! !IROUTINE: HCO_ValCleanup_3D_Dp
2157 : !
2158 : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_3D\_Dp cleans up the given
2159 : ! container 3D array. If DeepClean is set to TRUE and the array is
2160 : ! indeed allocated (as determined by the Alloc flag), the array becomes
2161 : ! deallocated. Otherwise, it is just nullified.
2162 : !\\
2163 : !\\
2164 : ! !INTERFACE:
2165 : !
2166 0 : SUBROUTINE HCO_ValCleanup_3D_Dp( Val, Alloc, DeepClean )
2167 : !
2168 : ! !INPUT PARAMETERS:
2169 : !
2170 : LOGICAL, INTENT(IN) :: Alloc ! Allocated?
2171 : LOGICAL, INTENT(IN) :: DeepClean ! Deallocate array?
2172 : !
2173 : ! !INPUT/OUTPUT PARAMETERS:
2174 : !
2175 : REAL(dp), POINTER :: Val(:,:,:) ! Array
2176 : !
2177 : ! !REVISION HISTORY:
2178 : ! 20 Apr 2013 - C. Keller - Initial version
2179 : ! See https://github.com/geoschem/hemco for complete history
2180 : !EOP
2181 : !------------------------------------------------------------------------------
2182 : !BOC
2183 0 : IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
2184 0 : DEALLOCATE( Val )
2185 : ENDIF
2186 0 : Val => NULL()
2187 :
2188 0 : END SUBROUTINE HCO_ValCleanup_3D_Dp
2189 : !EOC
2190 : !------------------------------------------------------------------------------
2191 : ! Harmonized Emissions Component (HEMCO) !
2192 : !------------------------------------------------------------------------------
2193 : !BOP
2194 : !
2195 : ! !IROUTINE: HCO_ValCleanup_3D_Sp
2196 : !
2197 : ! !DESCRIPTION: Subroutine HCO\_ValCleanup\_3D\_Sp cleans up the given
2198 : ! container 3D array. If DeepClean is set to TRUE and the array is
2199 : ! indeed allocated (as determined by the Alloc flag), the array becomes
2200 : ! deallocated. Otherwise, it is just nullified.
2201 : !\\
2202 : !\\
2203 : ! !INTERFACE:
2204 : !
2205 0 : SUBROUTINE HCO_ValCleanup_3D_Sp( Val, Alloc, DeepClean )
2206 : !
2207 : ! !INPUT PARAMETERS:
2208 : !
2209 : LOGICAL, INTENT(IN) :: Alloc ! Allocated?
2210 : LOGICAL, INTENT(IN) :: DeepClean ! Deallocate array?
2211 : !
2212 : ! !INPUT/OUTPUT PARAMETERS:
2213 : !
2214 : REAL(sp), POINTER :: Val(:,:,:) ! Array
2215 : !
2216 : ! !REVISION HISTORY:
2217 : ! 20 Apr 2013 - C. Keller - Initial version
2218 : ! See https://github.com/geoschem/hemco for complete history
2219 : !EOP
2220 : !------------------------------------------------------------------------------
2221 : !BOC
2222 0 : IF ( DeepClean .AND. ASSOCIATED(Val) .AND. Alloc ) THEN
2223 0 : DEALLOCATE( Val )
2224 : ENDIF
2225 0 : Val => NULL()
2226 :
2227 0 : END SUBROUTINE HCO_ValCleanup_3D_Sp
2228 : !EOC
2229 0 : END MODULE HCO_Arr_Mod
|
