File: RELATIVE:/../../../mfix.git/model/output_manager.f

1     !----------------------------------------------------------------------!
2     !                                                                      !
3     !  Subroutine: OUTPUT_MANAGER                                          !
4     !  Author: J.Musser                                   Date:            !
5     !                                                                      !
6     !  Purpose: Relocate calls to write output files (RES, SPx, VTP). This !
7     !  was done to simplify the time_march code.                           !
8     !                                                                      !
9     !----------------------------------------------------------------------!
10           SUBROUTINE OUTPUT_MANAGER(EXIT_SIGNAL, FINISHED)
11     
12     ! Global Variables:
13     !---------------------------------------------------------------------//
14     
15           use output, only: RES_TIME, RES_DT
16           use output, only: SPX_TIME, SPX_DT
17           use output, only: OUT_TIME, OUT_DT
18           use output, only: USR_TIME, USR_DT
19           use vtk, only:    VTK_TIME, VTK_DT
20     
21           use output, only: RES_BACKUP_TIME, RES_BACKUP_DT
22     
23           use output, only: DISK, DISK_TOT
24     
25           use param1, only: N_SPX
26           use param, only: DIMENSION_USR
27           use vtk, only: DIMENSION_VTK
28     
29           use run, only: TIME, DT, TSTOP
30     
31           use time_cpu, only: CPU_IO
32     
33           use compar, only: myPE, PE_IO
34     
35           use discretelement, only: DISCRETE_ELEMENT
36     
37           use vtk, only: WRITE_VTK_FILES
38           use qmom_kinetic_equation, only: QMOMK
39     
40           use param1, only: UNDEFINED
41     
42           use vtp, only: write_vtp_file
43           use machine, only: wall_time
44     
45           IMPLICIT NONE
46     
47     
48     ! Dummy Arguments:
49     !---------------------------------------------------------------------//
50     ! Flag that the the user specified batch time (plus buffer) is met.
51           LOGICAL, INTENT(IN) :: EXIT_SIGNAL
52     ! Flag that a steady state case is completed.
53           LOGICAL, INTENT(IN) :: FINISHED
54     
55     ! Local Variables:
56     !---------------------------------------------------------------------//
57     ! Loop counter and counter
58           INTEGER :: LC, IDX
59     ! Flag to write NetCDF output
60           LOGICAL :: bWRITE_NETCDF_FILES
61     ! Flag that the header (time) has not be written.
62           LOGICAL :: HDR_MSG
63     ! SPX file extensions.
64           CHARACTER(LEN=35) ::  EXT_END
65     ! Wall time at the start of IO operations.
66           DOUBLE PRECISION :: WALL_START
67     
68     !......................................................................!
69     
70     
71     ! Initialize the SPx file extension array.
72           EXT_END = '123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
73     ! Initial the header flag.
74           HDR_MSG = .TRUE.
75     
76     ! Get the current time before any IO operations begin
77           WALL_START = WALL_TIME()
78     
79     ! Create a backup copy of the RES file.
80           IF(TIME+0.1d0*DT>=RES_BACKUP_TIME) THEN
81              RES_BACKUP_TIME = NEXT_TIME(RES_BACKUP_DT)
82              CALL BACKUP_RES
83           ENDIF
84     
85     ! Write restart file, if needed
86           IF(CHECK_TIME(RES_TIME) .OR. EXIT_SIGNAL) THEN
87     
88              RES_TIME = NEXT_TIME(RES_DT)
89              CALL WRITE_RES1
90              CALL NOTIFY_USER('.RES;')
91     
92              IF(DISCRETE_ELEMENT) THEN
93                 CALL WRITE_RES0_DES
94                 CALL NOTIFY_USER('DES.RES;')
95              ENDIF
96     
97              IF(QMOMK) THEN
98                 CALL QMOMK_WRITE_RESTART
99                 CALL NOTIFY_USER('QMOMK.RES;')
100              ENDIF
101     
102           ENDIF
103     
104     ! Write SPx files, if needed
105           IDX = 0
106           bWRITE_NETCDF_FILES = .FALSE.
107     
108           DO LC=1, N_SPX
109              IF(CHECK_TIME(SPX_TIME(LC))) THEN
110                 SPX_TIME(LC) = NEXT_TIME(SPX_DT(LC))
111     
112                 CALL WRITE_SPX1(LC, 0)
113                 CALL NOTIFY_USER('SPx:',EXT_END(LC:LC))
114     
115                 DISK_TOT = DISK_TOT + DISK(LC)
116                 IDX = IDX + 1
117     
118                 bWRITE_NETCDF_FILES = .TRUE.
119              ENDIF
120           ENDDO
121           IF(IDX /=0) CALL FLUSH_LIST
122     
123     
124     ! Write standard output, if needed
125           IF(CHECK_TIME(OUT_TIME)) THEN
126              OUT_TIME = NEXT_TIME(OUT_DT)
127              CALL WRITE_OUT1
128              CALL NOTIFY_USER('.OUT;')
129           ENDIF
130     
131     ! Write special output, if needed
132           IDX = 0
133           DO LC = 1, DIMENSION_USR
134              IF(CHECK_TIME(USR_TIME(LC))) THEN
135                 USR_TIME(LC) = NEXT_TIME(USR_DT(LC))
136                 CALL WRITE_USR1 (LC)
137                 CALL NOTIFY_USER('.USR:',EXT_END(LC:LC))
138                 IDX = IDX + 1
139              ENDIF
140           ENDDO
141           IF(IDX /=0) CALL FLUSH_LIST
142     
143           CALL FLUSH_NOTIFY_USER
144     
145     ! Write vtk file, if needed
146     ! Only regular (not debug) files are written (second argument is zero)
147           IF(WRITE_VTK_FILES) THEN
148              DO LC = 1, DIMENSION_VTK
149                 IF(CHECK_TIME(VTK_TIME(LC))) THEN
150                    VTK_TIME(LC) = NEXT_TIME(VTK_DT(LC))
151                    CALL WRITE_VTU_FILE(LC,0)
152                    IF(DISCRETE_ELEMENT) CALL WRITE_VTP_FILE(LC,0)
153                 ENDIF
154              ENDDO
155           ENDIF
156     
157     ! Write NetCDF files.
158           IF(bWRITE_NETCDF_FILES) CALL WRITE_NETCDF(0,0,TIME)
159     
160     ! Add the amount of time needed for all IO operations to total.
161           CPU_IO = CPU_IO + (WALL_TIME() - WALL_START)
162     
163           RETURN
164     
165           contains
166     
167     
168     !----------------------------------------------------------------------!
169     !                                                                      !
170     !----------------------------------------------------------------------!
171           LOGICAL FUNCTION CHECK_TIME(lTIME)
172     
173           DOUBLE PRECISION, INTENT(IN) :: lTIME
174     
175           IF(DT == UNDEFINED) THEN
176              CHECK_TIME = FINISHED
177           ELSE
178              CHECK_TIME = (TIME+0.1d0*DT>=lTIME).OR.(TIME+0.1d0*DT>=TSTOP)
179           ENDIF
180     
181           RETURN
182           END FUNCTION CHECK_TIME
183     
184     
185     !----------------------------------------------------------------------!
186     !                                                                      !
187     !----------------------------------------------------------------------!
188           DOUBLE PRECISION FUNCTION NEXT_TIME(lWRITE_DT)
189     
190           DOUBLE PRECISION, INTENT(IN) :: lWRITE_DT
191     
192           IF (DT /= UNDEFINED) THEN
193              NEXT_TIME = (INT((TIME + 0.1d0*DT)/lWRITE_DT)+1)*lWRITE_DT
194           ELSE
195              NEXT_TIME = lWRITE_DT
196           ENDIF
197     
198           RETURN
199           END FUNCTION NEXT_TIME
200     
201     
202     !----------------------------------------------------------------------!
203     !                                                                      !
204     !----------------------------------------------------------------------!
205           SUBROUTINE NOTIFY_USER(MSG, EXT)
206     
207           use output, only: FULL_LOG
208           use funits, only: DMP_LOG
209           use funits, only: UNIT_LOG
210     
211           CHARACTER(len=*), INTENT(IN) :: MSG
212           CHARACTER(len=*), INTENT(IN), OPTIONAL :: EXT
213     
214     
215           LOGICAL :: SCR_LOG
216     
217           SCR_LOG = (FULL_LOG .and. myPE.eq.PE_IO)
218     
219           IF(HDR_MSG) THEN
220              IF(DMP_LOG) WRITE(UNIT_LOG, 1000, ADVANCE='NO') TIME
221              IF(SCR_LOG) WRITE(*, 1000, ADVANCE='NO') TIME
222              HDR_MSG = .FALSE.
223           ENDIF
224     
225      1000 FORMAT(' ',/' t=',F12.6,' Wrote')
226     
227           IF(.NOT.present(EXT)) THEN
228              IF(DMP_LOG) WRITE(UNIT_LOG, 1100, ADVANCE='NO') MSG
229              IF(SCR_LOG) WRITE(*, 1100, ADVANCE='NO') MSG
230           ELSE
231              IF(IDX == 0) THEN
232                 IF(DMP_LOG) WRITE(UNIT_LOG, 1110, ADVANCE='NO') MSG, EXT
233                 IF(SCR_LOG) WRITE(*, 1110, ADVANCE='NO') MSG, EXT
234              ELSE
235                 IF(DMP_LOG) WRITE(UNIT_LOG, 1120, ADVANCE='NO') EXT
236                 IF(SCR_LOG) WRITE(*, 1120, ADVANCE='NO') EXT
237              ENDIF
238           ENDIF
239     
240      1100 FORMAT(1X,A)
241      1110 FORMAT(1X,A,1x,A)
242      1120 FORMAT(',',A)
243     
244           RETURN
245           END SUBROUTINE NOTIFY_USER
246     
247     !----------------------------------------------------------------------!
248     !                                                                      !
249     !----------------------------------------------------------------------!
250           SUBROUTINE FLUSH_LIST
251     
252           use output, only: FULL_LOG
253           use funits, only: DMP_LOG
254           use funits, only: UNIT_LOG
255     
256           LOGICAL :: SCR_LOG
257     
258           SCR_LOG = (FULL_LOG .and. myPE.eq.PE_IO)
259     
260           IF(DMP_LOG) WRITE(UNIT_LOG,1000, ADVANCE='NO')
261           IF(SCR_LOG) WRITE(*,1000, ADVANCE='NO')
262     
263      1000 FORMAT(';')
264     
265           RETURN
266           END SUBROUTINE FLUSH_LIST
267     
268     
269     !----------------------------------------------------------------------!
270     !                                                                      !
271     !----------------------------------------------------------------------!
272           SUBROUTINE FLUSH_NOTIFY_USER
273     
274           use output, only: FULL_LOG
275           use funits, only: DMP_LOG
276           use funits, only: UNIT_LOG
277     
278           use time_cpu, only: TIME_START
279           use time_cpu, only: WALL_START
280     
281           use output, only: NLOG
282     
283           use run, only: TIME, NSTEP
284     
285           use discretelement, only: DISCRETE_ELEMENT, DES_CONTINUUM_COUPLED
286           use discretelement, only: DTSOLID
287           use error_manager
288           use machine, only: wall_time
289     
290           DOUBLE PRECISION :: WALL_ELAP, WALL_LEFT, WALL_NOW
291           CHARACTER(LEN=9) :: CHAR_ELAP, CHAR_LEFT
292           CHARACTER(LEN=4) :: UNIT_ELAP, UNIT_LEFT
293     
294           INTEGER :: TNITS
295           LOGICAL :: SCR_LOG
296     
297           SCR_LOG = (FULL_LOG .and. myPE.eq.PE_IO)
298     
299           IF(.NOT.HDR_MSG) THEN
300              IF(DMP_LOG) WRITE(UNIT_LOG,1000)
301              IF(SCR_LOG) WRITE(*,1000)
302           ENDIF
303     
304      1000 FORMAT(' ',/' ')
305     
306     ! Write the elapsed time and estimated remaining time
307           IF(MOD(NSTEP,NLOG) == 0) THEN
308     
309              IF(DISCRETE_ELEMENT .AND. .NOT.DES_CONTINUUM_COUPLED) THEN
310                 TNITs = CEILING(real((TSTOP-TIME)/DTSOLID))
311                 WRITE(ERR_MSG, 1100) TIME, DTSOLID, trim(iVal(TNITs))
312                 CALL FLUSH_ERR_MSG(HEADER=.FALSE., FOOTER=.FALSE., LOG=.FALSE.)
313              ENDIF
314      1100 FORMAT(/'Time: ',g12.5,3x,'DT: ',g12.5,3x,'DEM NITs: ',A)
315     
316              WALL_NOW = WALL_TIME()
317     ! Calculate the elapsed wall time.
318              WALL_ELAP = WALL_NOW - WALL_START
319              CALL GET_TUNIT(WALL_ELAP, UNIT_ELAP)
320              CHAR_ELAP=''; WRITE(CHAR_ELAP,"(F9.2)") WALL_ELAP
321              CHAR_ELAP = trim(adjustl(CHAR_ELAP))
322     ! Estimate the remaining wall time.
323              WALL_LEFT = (WALL_NOW-WALL_START)*(TSTOP-TIME)/               &
324                 max(TIME-TIME_START,1.0d-6)
325              CALL GET_TUNIT(WALL_LEFT, UNIT_LEFT)
326     
327              IF (DT /= UNDEFINED) THEN
328                 CHAR_LEFT=''; WRITE(CHAR_LEFT,"(F9.2)") WALL_LEFT
329                 CHAR_LEFT = trim(adjustl(CHAR_LEFT))
330              ELSE
331                 CHAR_LEFT = '0.0'
332                 UNIT_LEFT = 's'
333              ENDIF
334     
335     ! Notify the user of usage/remaining wall times.
336              WRITE(ERR_MSG,2000)                                           &
337                 'Elapsed:', trim(CHAR_ELAP), trim(UNIT_ELAP),              &
338                 'Est. Remaining:',trim(CHAR_LEFT), trim(UNIT_LEFT)
339              CALL FLUSH_ERR_MSG(HEADER=.FALSE., FOOTER=.FALSE.)
340           ENDIF
341     
342      2000 FORMAT('Wall Time - ',2(A,1X,A,A,4X))
343     
344     
345     
346           RETURN
347           END SUBROUTINE FLUSH_NOTIFY_USER
348     
349           END SUBROUTINE OUTPUT_MANAGER
350     
351     
352     !----------------------------------------------------------------------!
353     ! Subroutine: INIT_OUTPUT_VARS                                         !
354     ! Purpose: Initialize variables used for controling ouputs of the      !
355     ! various files.                                                       !
356     !----------------------------------------------------------------------!
357           SUBROUTINE INIT_OUTPUT_VARS
358     
359           use geometry, only: IJKMAX2
360           use machine, only: wall_time
361           use output, only: DISK, DISK_TOT
362           use output, only: ONEMEG
363           use output, only: OUT_TIME, OUT_DT
364           use output, only: RES_TIME, RES_DT
365           use output, only: SPX_TIME, SPX_DT
366           use output, only: USR_TIME, USR_DT
367           use output, only: RES_BACKUP_TIME, RES_BACKUP_DT
368           use output, only: RES_BACKUPS
369           use param, only: DIMENSION_USR
370           use param1, only: N_SPX
371           use param1, only: UNDEFINED
372           use param1, only: ZERO
373           use physprop, only: MMAX, NMAX
374           use run, only: K_EPSILON
375           use run, only: RUN_TYPE
376           use run, only: TIME, DT
377           use rxns, only: nRR
378           use scalars, only: NScalar
379           use time_cpu, only: CPU_IO
380           use time_cpu, only: TIME_START
381           use time_cpu, only: WALL_START
382           use vtk, only:    VTK_TIME, VTK_DT
383           use vtk, only: DIMENSION_VTK
384           use vtk, only: DIMENSION_VTK
385           use vtk, only: VTK_TIME, VTK_DT
386           use vtk, only: WRITE_VTK_FILES
387     
388           use param1, only:  UNDEFINED_I
389     
390           use funits, only: CREATE_DIR
391     
392           IMPLICIT NONE
393     
394     ! Disk space needed for one variable and each SPX file
395           DOUBLE PRECISION :: DISK_ONE
396     
397     ! Loop counter
398           INTEGER :: LC
399     
400     ! Initialize times for writing outputs
401           OUT_TIME = merge(TIME, UNDEFINED, OUT_DT /= UNDEFINED)
402     
403     ! Initialize the amount of time spent on IO
404           CPU_IO = 0.0d0
405     
406     ! Initialize disk space calculations
407           DISK_TOT = ZERO
408           DISK_ONE = 4.0*IJKMAX2/ONEMEG
409     
410           DISK(1) = 1.0*DISK_ONE                           ! EPg
411           DISK(2) = 2.0*DISK_ONE                           ! Pg, Ps
412           DISK(3) = 3.0*DISK_ONE                           ! Ug, Vg, Wg
413           DISK(4) = 3.0*DISK_ONE*MMAX                      ! Us, Vs, Ws
414           DISK(5) = 1.0*DISK_ONE*MMAX                      ! ROPs
415           DISK(6) = 1.0*DISK_ONE*(MMAX+1)                  ! Tg, Ts
416           DISK(7) = 1.0*DISK_ONE*(sum(NMAX(0:MMAX)))       ! Xg, Xs
417           DISK(8) = 1.0*DISK_ONE*MMAX                      ! Theta
418           DISK(9) = 1.0*DISK_ONE*NScalar                   ! User Scalars
419           DISK(10) = nRR*DISK_ONE                          ! ReactionRates
420           DISK(11) = merge(2.0*DISK_ONE, ZERO, K_EPSILON)  ! K-Epsilon
421     
422     
423     ! Initizle RES and SPX_TIME
424           IF (RUN_TYPE == 'NEW') THEN
425              RES_TIME = TIME
426              SPX_TIME(:N_SPX) = TIME
427           ELSE
428              IF (DT /= UNDEFINED) THEN
429                 RES_TIME = RES_DT *                                        &
430                    (INT((TIME + 0.1d0*DT)/RES_DT) + 1)
431                 SPX_TIME(:N_SPX) = SPX_DT(:N_SPX) *                        &
432                    (INT((TIME + 0.1d0*DT)/SPX_DT(:N_SPX)) + 1)
433              ENDIF
434           ENDIF
435     
436     ! Initizle RES_BACKUP_TIME
437           RES_BACKUP_TIME = UNDEFINED
438           IF(RES_BACKUP_DT /= UNDEFINED) RES_BACKUP_TIME =                 &
439              RES_BACKUP_DT * (INT((TIME+0.1d0*DT)/RES_BACKUP_DT)+1)
440     
441     ! Initialize USR_TIME
442           DO LC = 1, DIMENSION_USR
443              USR_TIME(LC) = UNDEFINED
444              IF (USR_DT(LC) /= UNDEFINED) THEN
445                 IF (RUN_TYPE == 'NEW') THEN
446                    USR_TIME(LC) = TIME
447                 ELSE
448                    USR_TIME(LC) = USR_DT(LC) *                             &
449                       (INT((TIME+0.1d0*DT)/USR_DT(LC))+1)
450                 ENDIF
451              ENDIF
452           ENDDO
453     
454     ! Initialize VTK_TIME
455     
456           IF(WRITE_VTK_FILES) THEN
457              DO LC = 1, DIMENSION_VTK
458                 VTK_TIME(LC) = UNDEFINED
459                 IF (VTK_DT(LC) /= UNDEFINED) THEN
460                    IF (RUN_TYPE == 'NEW'.OR.RUN_TYPE=='RESTART_2') THEN
461                       VTK_TIME(LC) = TIME
462                    ELSE
463                       VTK_TIME(LC) = VTK_DT(LC) *                          &
464                          (INT((TIME + 0.1d0*DT)/VTK_DT(LC))+1)
465                    ENDIF
466                 ENDIF
467              ENDDO
468           ENDIF
469     
470     ! Create a subdir for RES backup files.
471           IF(RES_BACKUPS /= UNDEFINED_I) CALL CREATE_DIR('BACKUP_RES')
472     
473     
474           WALL_START = WALL_TIME()
475           TIME_START = TIME
476     
477           RETURN
478           END SUBROUTINE INIT_OUTPUT_VARS
479     
480     
481     
482     !----------------------------------------------------------------------!
483     ! Subroutine: BACKUP_RES                                               !
484     ! Purpose: Shift existing RES file backup files by one index, then     !
485     ! create a copy of the current RES file.                               !
486     !----------------------------------------------------------------------!
487           SUBROUTINE BACKUP_RES
488     
489           use compar, only: myPE, PE_IO
490           use output, only: RES_BACKUPS
491           use discretelement, only: DISCRETE_ELEMENT
492     
493           IMPLICIT NONE
494     
495           CHARACTER(len=256) :: FNAME0, FNAME1
496     
497           INTEGER :: LC
498     
499           IF(myPE /= PE_IO) RETURN
500     
501     ! Shift all the existing backups by one.
502           DO LC=RES_BACKUPS,2,-1
503              CALL SET_FNAME(FNAME0,'.RES', LC-1)
504              CALL SET_FNAME(FNAME1,'.RES', LC)
505              CALL SHIFT_RES(FNAME0, FNAME1, 'mv')
506     
507              IF(DISCRETE_ELEMENT) THEN
508                 CALL SET_FNAME(FNAME0,'_DES.RES', LC-1)
509                 CALL SET_FNAME(FNAME1,'_DES.RES', LC)
510                 CALL SHIFT_RES(FNAME0, FNAME1, 'mv')
511              ENDIF
512           ENDDO
513     
514     ! Copy RES to RES1
515           CALL SET_FNAME(FNAME0, '.RES')
516           CALL SET_FNAME(FNAME1, '.RES' ,1)
517           CALL SHIFT_RES(FNAME0, FNAME1, 'cp')
518     
519           IF(DISCRETE_ELEMENT) THEN
520              CALL SET_FNAME(FNAME0, '_DES.RES')
521              CALL SET_FNAME(FNAME1, '_DES.RES' ,1)
522              CALL SHIFT_RES(FNAME0, FNAME1, 'cp')
523           ENDIF
524     
525     
526           RETURN
527     
528           contains
529     
530     !----------------------------------------------------------------------!
531     ! Subroutine: SHIFT_RES                                                !
532     ! Purpose: Shift RES(LC-1) to RES(LC)                                  !
533     !----------------------------------------------------------------------!
534           SUBROUTINE SHIFT_RES(pFN0, pFN1, ACT)
535     
536           implicit none
537     
538           CHARACTER(LEN=*), INTENT(IN) :: pFN0, pFN1, ACT
539           CHARACTER(len=1024) :: CMD
540           LOGICAL :: EXISTS
541     
542           INQUIRE(FILE=trim(pFN0),EXIST=EXISTS)
543           IF(EXISTS) THEN
544              CMD=''; WRITE(CMD,1000)trim(ACT), trim(pFN0),trim(pFN1)
545              CALL SYSTEM(trim(CMD))
546           ENDIF
547     
548      1000 FORMAT(A,1x,A,1X,A)
549     
550           RETURN
551           END SUBROUTINE SHIFT_RES
552     
553     !----------------------------------------------------------------------!
554     ! Subroutine: SET_FNAME                                                !
555     ! Purpose: Set the backup RES file name based on pINDX.                !
556     !----------------------------------------------------------------------!
557           SUBROUTINE SET_FNAME(pFNAME, pEXT, pINDX)
558     
559           use run, only: RUN_NAME
560     
561           implicit none
562     
563           CHARACTER(LEN=*), INTENT(OUT) :: pFNAME
564           CHARACTER(LEN=*), INTENT(IN) ::  pEXT
565           INTEGER, INTENT(IN), OPTIONAL :: pINDX
566     
567     ! Set the file format for backup copies
568           pFNAME=''
569           IF(.NOT.PRESENT(pINDX)) THEN
570              WRITE(pFNAME,1000) trim(RUN_NAME),pEXT
571           ELSE
572              IF(RES_BACKUPS < 10) THEN
573                 WRITE(pFNAME,1001) trim(RUN_NAME), pEXT, pINDX
574              ELSEIF(RES_BACKUPS < 100) THEN
575                 WRITE(pFNAME,1002) trim(RUN_NAME), pEXT, pINDX
576              ELSEIF(RES_BACKUPS < 1000) THEN
577                 WRITE(pFNAME,1003) trim(RUN_NAME), pEXT, pINDX
578              ELSEIF(RES_BACKUPS < 10000) THEN
579                 WRITE(pFNAME,1004) trim(RUN_NAME), pEXT, pINDX
580              ELSEIF(RES_BACKUPS < 10000) THEN
581                 WRITE(pFNAME,1005) trim(RUN_NAME), pEXT, pINDX
582              ELSE
583                 WRITE(pFNAME,1006) trim(RUN_NAME), pEXT, pINDX
584              ENDIF
585           ENDIF
586     
587      1000 FORMAT(2A)
588      1001 FORMAT('BACKUP_RES/',2A,I1.1)
589      1002 FORMAT('BACKUP_RES/',2A,I2.2)
590      1003 FORMAT('BACKUP_RES/',2A,I3.3)
591      1004 FORMAT('BACKUP_RES/',2A,I4.4)
592      1005 FORMAT('BACKUP_RES/',2A,I5.5)
593      1006 FORMAT('BACKUP_RES/',2A,I6.6)
594     
595           RETURN
596           END SUBROUTINE SET_FNAME
597     
598           END SUBROUTINE BACKUP_RES
599