; PRO  AVE_POWER, dirName, listFile, PS=PS_Print, HOLD=hold, EPS=eps,  $
;                                    BATCH=batch, LOG=log,   STDEV=dev,  $
;                                                            ERROR=err
;===============================================================================
; (c) 1991 - khd c/o FU BERLIN.      A l l    r i g h t s    r e s e r v e d. ||
;            No part of this software package may be reproduced, transmitted, ||
;            transcribed,  stored in a retrieval system,   or translated into ||
;            any form by any means without the   w r i t t e n  permission of ||
;            Karl-Heinz Dittberner-FU BERLIN, Arnimallee 22, D-1000 Berlin 33 ||
;===============================================================================
; PRO:AVE_POWER.PRO                               K.-H. Dittberner -  3.FEB.1991
; V 01.7                                          P 476/29         - 27.FEB.1991
;
; IDL(V2.0)-Routine:   Mitteln verschiedener Teil-Powerspektren, die mit dem
;                      IDL-Programm RED_POWER (P476/27) berechnet worden sind.
;
;          HINWEISE:   Fuer jedes Teil-Spektrum muss eine Daten-File mit dem
;                      Namen "*.CHARS" in dem Directory "dirName" existieren.
;                      Weiterhin muss ein Verzeichnis "listFile" aller zu 
;                      mittelnden Daten-Files vorhanden sein. Ein solches Ver-
;                      zeichnis erzeugt man mit:
;                             o  DIR/BRIEF/COL=1  dirName: /OUT=listFile
;                      z.B.   o  DIR/BRIEF/COL=1  CHARS:   /OUT=TOP:TEST.LIS
;                      Dann editiert man aus der 'OUT-File' die Zeilen mit
;                      "Directory ..." und "Total of ..." heraus. Der Name
;                      des Jobs (=Titel) wird durch den Kern von "listFile"
;                      festgelegt; im Beispiel heisst der Titel also "TEST".
;                      Die Ergebnisse werden immer in einer reinen ASCII-
;                      File "job.AVE_CHARS" gespeichert; Einzelheiten dazu
;                      siehe unter Pkt.7.
;
;          KEYWORDS:
;            /BATCH  = Muss angegeben werden, wenn dieses Programm im IDL-
;                      Batch-Mode laufen soll.
;            /STDEV  = Es werden in den Plots die Standardabweichungen s 
;                      (mittlere Fehler der Einzelwerte) als punktierte 
;                      (+/-) Kurven ausgegeben; wobei
;                          Standardabweichung:   s = SQRT(S/(n-1))  
;                                         mit:   S = SUM(x^2) - n*(M^2),
;                                  Mittelwert:   M = SUM(x/n).
;            /ERROR  = Es werden in den Plots die Fehler der Mittelwerte e
;                      als punktierte (+/-) Kurven ausgegeben; wobei
;                                      Fehler:   e = s/SQRT(n).
;            /EPS    = Ausgabe der gemittelten Spektren erfolgt als Encapsulated
;                      PostScript-File unter dem Namen "job_AVEPOWER.EPS" zum
;                      Import in andere Applikationen; z.B. in den PageMaker.
;            /HOLD   = Die PostScript-File wird zunaechst nicht gedruckt. Sie
;                      steht unter dem Namen "job_AVEPOWER.PS" zur Verfuegung.
;            /LOG    = Es werden Zwischeninfos ausgegeben.
;            /PS     = Nur PostScript-Ausgabe; keine Ausgabe auf dem Grafik-
;                      Terminal.
;===============================================================================
;
; Quelle:  Do-it-yourself!      Merkposten: o  
;          C91 240                          o  
;                                           o  Titel in Teilplots per Keyword ?
; Aufruf:  z.B. AVE_POWER, "CHARS:",        o  
;                 "TOP:TEST.LIS" [, ...]    o  
;                                           o  Test: PS-Pfad, wenn Drucker Ok.
;===============================================================================
; Aenderungen: [13/2/91-khd] => V 01.2:                        (Copy => SEIDLER)
;                 - Input der Daten angepasst an RED_POWER.PRO-V01.14.
;              [19/2/91-khd] => V 01.3:              (Copy => AG GRUE + SEIDLER)
;                 - Im UP GET_FILENAMES werden nunmehr evtl. vorhandene
;                   Leerzeilen ueberlesen.
;                 - 3 x ON_ERROR,2 aktiviert.
;                 - Kommentare zugefuegt.
;                 - Fehlerausgaben verbessert.
;              [22/2/91-khd] => V 01.4:
;                 - Keyword /STDEV zur Ausgabe der Standardabweichungen s
;                   eingefuehrt.
;                 - In Pkt.3 Berechnung der Standardabweichungen ergaenzt und
;                 - unter Pkt.5 in der Ausgabe durch Overplot hinzugefuegt.
;                 - Pkt.4: Achsenbeschriftung etwas modifiziert ([Einheiten]).
;              [25/2/91-khd] => V 01.5:                        (Copy => SEIDLER)
;                 - Kommentierung ergaenzt.
;                 - Im SubTitel_1 Ausgabe von VAR DC_dev ergaenzt.
;                 - Abfrage der Ausgabeart (EPS oder PS) im Pkt.6 zugefuegt.
;                 - Pkt.7: Ausgabe der Standardabweichungen in die Ergebnisfile
;                   "job.AVE_CHARS" zugefuegt.
;                 - Pkt.8: Test zum Check offener Files zugefuegt.
;              [26/2/91-khd] => V 01.6:                         (Copy => AG KOE)
;                 - RETURN im UP GET_FILENAMES nach unten verlegt;
;                   sonst bleibt der Filekanal In offen.
;                 - Im Pkt.8 Check offener Files deaktiviert.
;              [27/2/91-khd] => V 01.7:                        (Copy => SEIDLER)
;                 - Keyword /ERROR zur Ausgabe der Fehler eingefuehrt.
;===============================================================================
; 0. Definition von Hilfs-Routinen:
;===============================================================================
;
  PRO  GET_CHARS, fileName                  ; Lesen einer Daten-File.
  ON_ERROR, 2
  COMMON   CHARS, job, time, nr, ns, nx, ny, nf_r, nf_th, $
                  f_width,  s_width, DC, p0, pr, pth, px, py
  ON_IOERROR, IO_Error
  job_time=""      &  job=""  &   time=""
  nr=0L  &  ns=0L  &  nx=0L   &   ny=0L

  OPENR, In, fileName, /GET_LUN
  READF, In, job_time
  cutlen = STRPOS(job_time, "      ")
  cutlen = LONG(cutlen(0))
  job    = STRTRIM(STRMID(job_time,0,cutlen), 2)
  time   = STRTRIM(STRMID(job_time,cutlen,cutlen+30), 2)
  READF, In, nr, ns, nx, ny
  nf_r   = LONARR(nr)     &   READF, In, nf_r
  nf_th  = LONARR(ns)     &   READF, In, nf_th
  READF, In, f_width, s_width, DC, p0
  pr     = FLTARR(nr)     &   READF, In, pr
  pth    = FLTARR(ns)     &   READF, In, pth
  px     = FLTARR(nx/2)   &   READF, In, px    &   px = [0., px]
  py     = FLTARR(ny/2)   &   READF, In, py    &   py = [0., py]
  GOTO, Ende
IO_Error:
  ON_IOERROR, NULL
  PRINT, !ERR_STRING
Ende:
  FREE_LUN, In
  END
;_______________________________________________________________________________
;
  FUNCTION  GET_FILENAMES, listFile         ; Lesen der Namen der Daten-Files.
  ON_ERROR, 2
  ON_IOERROR, IO_Error
  fileName  = ""   &   fileNames = STRARR(1)

  OPENR, In, listFile, /GET_LUN
  WHILE NOT EOF(In) DO $
        BEGIN
        READF, In, fileName
        IF (STRLEN(fileName) GT 0) THEN  fileNames = [fileNames, fileName]
  ENDWHILE
;;PRINT,  fileNames
  GOTO, Ende
IO_Error:
  ON_IOERROR, NULL
  PRINT, !ERR_STRING
Ende:
  FREE_LUN, In
  RETURN, fileNames
  END
;===============================================================================

  PRO  AVE_POWER, dirName, listFile, PS=PS_Print, HOLD=hold, EPS=eps,  $
                                     BATCH=batch, LOG=log,   STDEV=dev,  $
                                                             ERROR=err
;===============================================================================
; 1. Prolog, Variablen und Konstanten:
;===============================================================================
;
  ON_ERROR, 2                               ; Return => Ruf. Programm.
  ON_IOERROR, IO_Error

  COMMON   CHARS, job, time, nr, ns, nx, ny, nf_r, nf_th, $
                  f_width,  s_width, DC, p0, pr, pth, px, py

  rand   = 50                               ; Rand fuer (DEC-)Window in Pixel.
    w0   = 10                               ; Fuer Bezugskoo. des (DEC-)Windows.
  ok     = ""                               ; Typ-Deklaration.
  answer = ""                               ; Typ-Deklaration.
  PS_Com = ""                               ; Typ-Deklaration.
  PSres  = 2540.                            ; point/inch = ipt/inch werden von
                                            ; IDL in PostScript-Ausgaben verwen-
                                            ; det; PS-Standard = 72 point/inch !
  dirName = STRUPCASE(dirName)
;
;===============================================================================
; 2. Behandlung der Keywords (Default-Werte):
;===============================================================================
;
  IF KEYWORD_SET(eps)    AND   NOT KEYWORD_SET(PS_Print)  $
     THEN   PS_Print = 1

  IF KEYWORD_SET(PS_Print) $
     THEN   PS_Asked = 1   $
     ELSE   PS_Asked = 0

  IF KEYWORD_SET(hold)   AND   NOT KEYWORD_SET(PS_Print)  $
     THEN   PS_Print = 1

  IF KEYWORD_SET(dev)    AND   KEYWORD_SET(err)  $
     THEN   BEGIN
            dev = 1
            err = 0
  ENDIF
;
;===============================================================================
; 3. Berechnung der Mittelwerte verschiedener Teil-Powerspektren:
;===============================================================================
;
  files  = GET_FILENAMES(listFile)
  anzahl = N_ELEMENTS(files) - 1

  GET_CHARS, dirName + files(1)             ; Die 1. File dient als Referenz.
  DC_ave  = 0.0
  pr_ave  = REPLICATE(0.0, nr)
  pth_ave = REPLICATE(0.0, ns)  
  px_ave  = REPLICATE(0.0, nx/2+1)
  py_ave  = REPLICATE(0.0, ny/2+1)
  DC_sum  = 0.0
  pr_sum  = REPLICATE(0.0, nr)
  pth_sum = REPLICATE(0.0, ns)  
  px_sum  = REPLICATE(0.0, nx/2+1)
  py_sum  = REPLICATE(0.0, ny/2+1)
  r       = FINDGEN(nr) * f_width           ; x-Achse fuer pr_ave.
  th      = FINDGEN(ns) * s_width           ; x-Achse fuer pth_ave.
  x       = FLOAT([0, nx/2])                ; x-Achsenbereich fuer px_ave.
  y       = FLOAT([0, ny/2])                ; x-Achsenbereich fuer py_ave.
  nr_ref  = nr   &   ns_ref  = ns
  nx_ref  = nx   &   ny_ref  = ny
;_______________________________________________________________________________

  FOR  i=1, anzahl  DO  $                   ; Fuer alle Bilder.
       BEGIN
       datei = dirName + files(i) 
       IF KEYWORD_SET(log) THEN  PRINT, "o  Bearbeitet wird:  ", datei
       GET_CHARS, datei 

       IF (nr NE nr_ref) OR (ns NE ns_ref) OR $
          (nx NE nx_ref) OR (ny NE ny_ref) $
           THEN  BEGIN
                 PRINT, "o  nx=", nx, "   ny=", ny
                 PRINT, "o  nr=", nr, "   ns=", ns
                 MESSAGE, "File " + datei + " basiert " + $
                          "auf abweichender Pixel-Anzahl."
       ENDIF

       DC_ave  = DC_ave  + DC /anzahl
       pr_ave  = pr_ave  + pr /anzahl
       pth_ave = pth_ave + pth/anzahl
       px_ave  = px_ave  + px /anzahl
       py_ave  = py_ave  + py /anzahl

       DC_sum  = DC_sum  + DC^2
       pr_sum  = pr_sum  + pr^2
       pth_sum = pth_sum + pth^2
       px_sum  = px_sum  + px^2
       py_sum  = py_sum  + py^2
  ENDFOR
;_______________________________________________________________________________
; Berechnung der Standardabweichungen und Fehler:

       DC_sum  = DC_sum  - anzahl*(DC_ave^2)
       pr_sum  = pr_sum  - anzahl*(pr_ave^2)
       pth_sum = pth_sum - anzahl*(pth_ave^2)
       px_sum  = px_sum  - anzahl*(px_ave^2)
       py_sum  = py_sum  - anzahl*(py_ave^2)

       DC_dev  = SQRT(DC_sum /(anzahl-1))
       pr_dev  = SQRT(pr_sum /(anzahl-1))
       pth_dev = SQRT(pth_sum/(anzahl-1))
       px_dev  = SQRT(px_sum /(anzahl-1)) 
       py_dev  = SQRT(py_sum /(anzahl-1))
      err_mode = "stdev"

  IF KEYWORD_SET(err)  $
     THEN  BEGIN
           Ranzahl = SQRT(anzahl)
           DC_dev  = DC_dev /Ranzahl
           pr_dev  = pr_dev /Ranzahl
           pth_dev = pth_dev/Ranzahl
           px_dev  = px_dev /Ranzahl
           py_dev  = py_dev /Ranzahl
          err_mode = "err"
  ENDIF

  time = SYSTIME(0)                         ; Zeitpunkt der Berechnung.
;
;===============================================================================
; 4. Setzen von Parametern fuer die folgenden Ausgaben:
;===============================================================================
;
Power_Output:
  wx = 2 * nx + 3 * rand                    ; Groesse des (DEC-)Windows
  wy = 2 * ny + 3 * rand                    ; = Fenster auf dem Schirm.
;_______________________________________________________________________________

  !X.CHARSIZE =  0.9     &     !Y.CHARSIZE =  0.9
  !P.TICKLEN  = -0.03   
  !X.TICKS    =  2       &     !Y.TICKS    =  3
  !X.MINOR    =  4       &     !Y.MINOR    =  3
  Plot_Oben   =  4.5     &     Plot_Unten  =  0.5        ; Nur fuer PostScript;
  Plot_Rand   =  1.5     &     Plot_Logo   =  2.0        ; alle Zahlenangaben
  Plot_VSize  =  6.0     &     Plot_HSize  =  6.0        ; in Inches.
  Plot_Shift  =  Plot_Logo/2.
  Shift       =  FIX(Plot_Shift * PSres)
  Shift       =  STRCOMPRESS(Shift, /REMOVE)
;_______________________________________________________________________________

  listFile = STRUPCASE(listFile)
  cutLen   = STRPOS(listFile, ".")
  cutLen   = LONG(cutLen(0))
  job      = STRMID(listFile, 0, cutLen)
;;PRINT, "o  Job:  ", job

  Titel        = "Gemittelte Teil-Powerspektren " + job
  Window_Titel = "Gemittelte Teil-Powerspektren"
;_______________________________________________________________________________
                                            ; Je nach Ausgabe-Art unterschied- 
  IF KEYWORD_SET(PS_Print) $                ; lich zu setzende Parameter:
     THEN  BEGIN                            ; Bei PostScript-Ausgabe:
           x_Titel_pr  = "f  / [cycles/image]"
           x_Titel_pth = "theta  / [degree]"
           x_Titel_px  = "f!Ix!N  / [cycles/image]"
           x_Titel_py  = "f!Iy!N  / [cycles/image]"
           y_Titel_pr  = "p!Ir!N  / [dB]"
           y_Titel_pth = "p!Itheta!N  / [dB]"
           y_Titel_px  = "p!Ix!N  / [dB]"
           y_Titel_py  = "p!Iy!N  / [dB]"
           SubTitel_1  = "n!Ix!N = "   + STRCOMPRESS(nx,/REMOVE) + " pixel;" + $
                         "  n!Iy!N = " + STRCOMPRESS(ny,/REMOVE) + " pixel;" + $
                         "   0 dB: p(0,0) = " + STRCOMPRESS(DC_ave,/REMOVE)  + $
                         " +/- "              + STRCOMPRESS(DC_dev,/REMOVE)
           SubTitel_2  = "Mittelwerte von  "  + STRCOMPRESS(anzahl,/REMOVE)  + $
                         "  Powerspektren."
           ENDIF $
     ELSE  BEGIN                            ; Keine PostScript-Ausgabe:
           x_Titel_pr  = "f  / [cycles/image]"
           x_Titel_pth = "theta  / [degree]"
           x_Titel_px  = "fx  / [cycles/image]"
           x_Titel_py  = "fy  / [cycles/image]"
           y_Titel_pr  = "pr  / [dB]"
           y_Titel_pth = "ptheta  / [dB]"
           y_Titel_px  = "px  / [dB]"
           y_Titel_py  = "py  / [dB]"
           SubTitel_1  = "nx = "   + STRCOMPRESS(nx,/REMOVE) + " pixel;" + $
                         "  ny = " + STRCOMPRESS(ny,/REMOVE) + " pixel;" + $
                         "  0 dB: p(0,0) = " + STRCOMPRESS(DC_ave,/REMOVE) + $
                         " +/- "             + STRCOMPRESS(DC_dev,/REMOVE)
           ENDELSE
;
;===============================================================================
; 5. Ausgabe der berechneten Mittelwert-Funktionen:
;===============================================================================
;
  IF KEYWORD_SET(batch)  OR  (PS_Asked EQ 1)  THEN   GOTO, Do_Plot

  WINDOW, XPOS=w0,  YPOS=w0, $              ; Neues Fenster erzeugen.
          XSIZE=wx, YSIZE=wy, $
          RETAIN=2, /FREE, $
          TITLE=Window_Titel
  LOADCT, 0, /SILENT                        ; Laden der Color-Table: Lin. Grau.
;_______________________________________________________________________________

Do_Plot:
  IF KEYWORD_SET(PS_Print) $                ; Bei PostScript-Ausgabe:
     THEN BEGIN
          OldDevice = !D.NAME
          SET_PLOT, "PS", /COPY
          IF KEYWORD_SET(eps) $
             THEN  DEVICE, /ENCAPSULATED, FILENAME=job + "_AVEPOWER.EPS", $
                            XSIZE=Plot_HSize, YSIZE=Plot_VSize + Plot_Logo, $
                           /INCHES, /TIMES, /ITALIC, FONT_SIZE=10 $
             ELSE  DEVICE,  XOFFSET=Plot_Rand,  YOFFSET=Plot_Oben, $
                            XSIZE  =Plot_HSize, YSIZE  =Plot_VSize, /INCHES, $
                           /TIMES, /ITALIC, FONT_SIZE=10
  ENDIF   ;KW_S(PS_Print)
;_______________________________________________________________________________

  !P.MULTI = [0,2,2,0,1]                    ; Clear Page, 4 Plots/Plot-Region.

  IF KEYWORD_SET(eps) $
     THEN  BEGIN
           Scale  = Plot_VSize/(Plot_VSize + Plot_Logo)
           Scale  = STRCOMPRESS(Scale, /REMOVE)
           PS_Com = '0 ' + Shift + ' translate   ' + $
                    '1.0000 ' + Scale + ' scale'
           PLOT, [0,0], [1,1], /NODATA, $   ; Dummy wg. des PS-Befehls; sonst
                 XSTYLE=4, YSTYLE=4         ; erfolgt neues PS-PageSetup.
           DEVICE, OUTPUT=PS_Com            ; Direkter PostScript-Befehl.
           !P.MULTI = [4,2,2,0,1]           ; Reset => 4 Plots/Plot-Region.
  ENDIF

  PLOT, r, pr_ave, FONT=0,  $               ; 1. Plot:  power(r)
        YRANGE=[-90., 0.],  $
        XSTYLE=1, YSTYLE=1, $
        XTITLE=x_Titel_pr,  $
        YTITLE=y_Titel_pr,  $
        THICK=2.0
        IF KEYWORD_SET(dev) OR KEYWORD_SET(err)  $
           THEN  BEGIN
                 OPLOT, r, pr_ave + pr_dev, $
                        LINESTYLE=1
                 OPLOT, r, pr_ave - pr_dev, $
                        LINESTYLE=1
        ENDIF

  PLOT, th, pth_ave, FONT=0, $              ; 2. Plot:  power(theta)
        YRANGE=[-90., 0.],   $
        XSTYLE=1,  YSTYLE=1, $
        XTITLE=x_Titel_pth,  $
        YTITLE=y_Titel_pth,  $
        THICK=2.0
        IF KEYWORD_SET(dev) OR KEYWORD_SET(err)  $
           THEN  BEGIN
                 OPLOT, th, pth_ave + pth_dev, $
                        LINESTYLE=1
                 OPLOT, th, pth_ave - pth_dev, $
                        LINESTYLE=1
        ENDIF

  PLOT, px_ave, FONT=0, $                   ; 3. Plot:  power(x)
        XRANGE=x, YRANGE=[-90., 0.], $
        XSTYLE=1, YSTYLE=1, $
        XTITLE=x_Titel_px,  $
        YTITLE=y_Titel_px,  $
        THICK=2.0
        IF KEYWORD_SET(dev) OR KEYWORD_SET(err)  $
           THEN  BEGIN
                 OPLOT, px_ave + px_dev, $
                        XRANGE=x, LINESTYLE=1
                 OPLOT, px_ave - px_dev, $
                        XRANGE=x, LINESTYLE=1
        ENDIF

  PLOT, py_ave, FONT=0, $                   ; 4. Plot:  power(y)
        XRANGE=y, YRANGE=[-90., 0.], $
        XSTYLE=1, YSTYLE=1, $
        XTITLE=x_Titel_py,  $
        YTITLE=y_Titel_py,  $
        THICK=2.0
        IF KEYWORD_SET(dev) OR KEYWORD_SET(err)  $
           THEN  BEGIN
                 OPLOT, py_ave + py_dev, $
                        XRANGE=y, LINESTYLE=1
                 OPLOT, py_ave - py_dev, $
                        XRANGE=y, LINESTYLE=1
        ENDIF
;_______________________________________________________________________________

  IF KEYWORD_SET(PS_Print) $                ; Titel ueber Plot-Mitte zentriert:
     THEN   IF KEYWORD_SET(eps) $
               THEN  DEVICE, /TIMES, /BOLD, /ITALIC, FONT_SIZE=16 $
               ELSE  DEVICE, /TIMES, /BOLD, /ITALIC, FONT_SIZE=12
  XYOUTS, 0.5, 1.10, /NORM, Titel, ALIGNMENT=0.5, FONT=0
 
  IF KEYWORD_SET(PS_Print) $                ; Untertitel und Creation-Date 
     THEN   BEGIN                           ; (nur bei PostScript-Ausgabe):
            IF KEYWORD_SET(eps) $
               THEN  DEVICE, /TIMES, FONT_SIZE=12 $
               ELSE  DEVICE, /TIMES, FONT_SIZE=9
            XYOUTS, 0.5,  1.05, /NORM, "Creation-Date:  " + time, $
                                                   ALIGNMENT=0.5, FONT=0
            XYOUTS, 0.5, -0.06, /NORM, SubTitel_1, ALIGNMENT=0.5, FONT=0
            XYOUTS, 0.5, -0.10, /NORM, SubTitel_2, ALIGNMENT=0.5, FONT=0
  ENDIF
;_______________________________________________________________________________

  !P.MULTI = 0                              ; Reset => 1 Plot/Plot-Region.
;
;===============================================================================
; 6. Ausgabe der PostScript-File der gemittelten Teil-Powerspektren:
;===============================================================================
;
Do_Output:
  IF NOT PS_Asked $
     THEN BEGIN
          PS_Asked = 1
          PRINT, FORMAT='($,"o  Sollen diese Spektren ausgegeben werden ? [N]")'
          READ, ok    &    ok = STRUPCASE(ok)
          IF (ok EQ "Y") OR (ok EQ "YES") OR (ok EQ "J") OR (ok EQ "JA") $
              THEN BEGIN
                   PS_Print = 1
                   PRINT, FORMAT='($,"o  In welcher Art (EPS oder PS) ? [EPS]")'
                   READ, answer   &   answer = STRUPCASE(answer)
                   IF (answer EQ "") THEN   answer = "EPS"
                   CASE answer OF
                        "EPS":  BEGIN
                                eps = 1
                                GOTO, Power_Output       ; Am Anfang von Pkt.4.
                                END
                         "PS":  GOTO, Power_Output       ; Am Anfang von Pkt.4.
                         ELSE:  BEGIN
                                MESSAGE, "Falsche Ausgabe-Art:  "  $
                                         + answer, /CONTINUE
                                PS_Asked = 0
                                GOTO, Do_Output
                                END
                   ENDCASE
          ENDIF
  ENDIF
;_______________________________________________________________________________

  IF KEYWORD_SET(PS_Print) $
     THEN BEGIN
          IF KEYWORD_SET (eps) $
             THEN  DEVICE, /CLOSE_FILE $    ; EPS-File schliessen.
             ELSE  IF KEYWORD_SET(hold) $
                      THEN  PRINT_PLOT, job + "_AVEPOWER.PS", /NOPRINT  $
                      ELSE  PRINT_PLOT      ; PS-Ausgabe der Spektren.
          SET_PLOT, OldDevice               
  ENDIF   ;KW_S(PS_Print)
;
;===============================================================================
; 7. Ausgabe der Ergebnisse in eine Daten-File:
;===============================================================================
;
  ON_IOERROR, IO_Error
  OPENW,  Out, job + ".AVE_CHARS", /GET_LUN           ; Oeffnen der Daten-File.
  PRINTF, Out, job, "      ", time, "     ", err_mode &    PRINTF, Out, ""
  PRINTF, Out, LONG(nr), LONG(ns), nx/2+1, ny/2+1     &    PRINTF, Out, ""
  PRINTF, Out, f_width, s_width, DC_ave, DC_dev       &    PRINTF, Out, ""
  PRINTF, Out, pr_ave                                 &    PRINTF, Out, ""
  PRINTF, Out, pr_dev                                 &    PRINTF, Out, ""
  PRINTF, Out, pth_ave                                &    PRINTF, Out, ""
  PRINTF, Out, pth_dev                                &    PRINTF, Out, ""
  PRINTF, Out, px_ave                                 &    PRINTF, Out, ""
  PRINTF, Out, px_dev                                 &    PRINTF, Out, ""
  PRINTF, Out, py_ave                                 &    PRINTF, Out, ""
  PRINTF, Out, py_dev                                 &    PRINTF, Out, ""
  GOTO, Ende
;
;===============================================================================
; 8. Schluss:
;===============================================================================
;
IO_Error:
  ON_IOERROR, NULL                          ; Reset der Fehlerverzweigung.
  PRINT, !ERR_STRING
Ende:
  FREE_LUN, Out                             ; Schliessen der Daten-File.
;;IF KEYWORD_SET(log) THEN  HELP, /FILES    ; Check offener Files.
  RETURN
  END
;===============================================================================