readinput.cc

Go to the documentation of this file.

/*
 * Copyright (c) 1999-2003 Bert Kampes
 * Copyright (c) 1999-2003 Delft University of Technology, The Netherlands
 *
 * This file is part of Doris, the Delft o-o radar interferometric software.
 *
 * Doris program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Doris is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Publications that contain results produced by the Doris software should
 * contain an acknowledgment. (For example: The interferometric processing
 * was performed using the freely available Doris software package developed
 * by the Delft Institute for Earth-Oriented Space Research (DEOS), Delft
 * University of Technology, or include a reference to: Bert Kampes and
 * Stefania Usai. \"Doris: The Delft Object-oriented Radar Interferometric
 * software.\" In: proceedings 2nd ITC ORS symposium, August 1999. (cdrom)).
 *
 */
/****************************************************************
 * $Source: /users/kampes/DEVELOP/DORIS/doris/src/RCS/readinput.cc,v $
 * $Revision: 3.32 $
 * $Date: 2005/04/16 07:03:52 $
 * $Author: kampes $
 *
 * implementation of readinput.
 ****************************************************************/

#include "matrixbk.hh"
#include "constants.hh"         // global constants
#include "refsystems.hh"        // for axis ellipsoid
#include "ioroutines.hh"        // ?
#include "utilities.hh"         // ispower2
#include "conversion.hh"        // rad2deg
#include "exceptions.hh"                 // my exceptions class

#include <fstream>              // for file streams
#include <strstream>            // for file streams
#include <iomanip>              // for setprecision etc.
#include <cstring>              // for strcmp etc.
#include <cstdlib>              // exit, atoi
#include <cctype>               // isspace



// ______ displevel used in ioroutines.h, changed here ______
char WARNS[6][ONE27];           // remember 6 last warnings in WARNS
int32   beeplevel=1;            // global variable for beeping.
                                // 0:  nobeep; BEEP OFF
                                // -1: beep on error exit ; BEEP ERROR
                                // 1:  beep on error, warnings; BEEP WARNING
                                // 2:  beep on error, warnings, progress;
                                //     BEEP PROGRESS, BEEP [ON]
int32   displevel=30000;        // controls level of screen output
                                // -100 only errors
                                // 0:     warnings and errors
                                // 10000: progress, warn and err
                                // 20000: info, pro, warn and err
                                // 30000: debug, info, pro, warn, err


// ______ Checks input prototypes (see below in this file) ______
void checkgeneral     (input_gen               &generalinput, const int16 onlyprocess);
void checkreadfiles   (const input_readfiles   &readfilesinput, const int16 id);
void checkcrop        (const input_crop         &cropinput, const int16 id);
//____RaffaeleNutricato START MODIFICATION SECTION 1
void checkoversample  (const input_oversample  &oversampleinput, const int16 id);
//____RaffaeleNutricato END MODIFICATION SECTION 1
void checkporbits     (const input_pr_orbits   &porbitsinput, const int16 id);
void checkslant2h     (const input_slant2h     &slant2hinput);
void checkunwrap      (const input_unwrap      &unwrapinput);
void checkgeocode     (const input_geocode     &geocodeinput);
void checkcoarsecorr  (const input_coarsecorr  &coarsecorrinput);
void checkfine        (const input_fine        &fineinput);
void checkcoregpm     (const input_coregpm     &coregpminput);
void checkcomprefpha  (const input_comprefpha  &comprefphainput);
void checksubtrrefpha (const input_subtrrefpha &subtrrefphainput);
void checkresample    (const input_resample    &resampleinput);
void checkinterfero   (const input_interfero   &interferoinput);
void checkcoherence   (const input_coherence   &coherenceinput);
void checkcomprefdem  (const input_comprefdem  &comprefdeminput);
void checksubtrrefdem (const input_subtrrefdem &subtrrefdeminput);
void checkfiltrange   (const input_filtrange   &filtrangeinput);
void checkdinsar      (const input_dinsar      &dinsarinput);
void checkfiltphase   (const input_filtphase   &filtphaseinput);
void checkfiltazi     (const input_filtazi     &filtaziinput, const int16 id);

/****************************************************************
 *    writearg                                                  *
 * echo arg to screen if debug defined                          *
 #%// BK 13-Jul-2000                                            *
 ****************************************************************/
template <class Type>
void writearg(const Type argument)
  {
  TRACE_FUNCTION("writearg");
  DEBUG << "Read argument: " << argument;
  DEBUG.print();
  } // END writearg



/****************************************************************
 *    readinput                                                 *
 *                                                              *
 * Read and interpret                                           *
 * "inputoptionsfile" (file in variable: logfile).              *
 * Write to logfile (via "scratchreadinput")                    *
 * mandatory input is checked on presence by checksums (cs).    *
 * If there are more methods, process card switches default     *
 *  methodselector (if present) is used later to correct        *
 *  see for example unwrap methodeselector                      *
 * linecounter only used in case of errors                      *
 *                                                              *
 * input:                                                       *
 *  - struct: general input options                             *
 *  - struct: master readfiles input options                    *
 *  - struct: slave readfiles input options                     *
 *  - struct: master crop input options                         *
 *  - struct: slave crop input options                          *
 *  - ...                                                       *
 * output:                                                      *
 *  - (updated input structs)                                   *
 *  - (file copy of input)                                      *
 *                                                              *
 *    Bert Kampes, 11-Dec-1998                                  *
 ****************************************************************/
void readinput(
        input_gen         &generalinput, 
        input_ell         &ellipsinput,
        input_pr_orbits   &porbitsinput,
        input_readfiles   &m_readfilesinput,
        input_crop         &m_cropinput,
//____RaffaeleNutricato START MODIFICATION SECTION 2
        input_oversample  &m_oversample, 
//____RaffaeleNutricato END MODIFICATION SECTION 2
        input_readfiles   &s_readfilesinput,
        input_crop         &s_cropinput,
//____RaffaeleNutricato START MODIFICATION SECTION 3
        input_oversample  &s_oversample, 
//____RaffaeleNutricato END MODIFICATION SECTION 3
        input_filtazi     &filtaziinput,
        input_coarsecorr  &coarsecorrinput,
        input_fine        &fineinput,
        input_coregpm     &coregpminput,
        input_resample    &resampleinput,
        input_filtrange   &filtrangeinput,
        input_interfero   &interferoinput,
        input_coherence   &coherenceinput,
        input_comprefpha  &comprefphainput,
        input_subtrrefpha &subtrrefphainput,
        input_comprefdem  &comprefdeminput,
        input_subtrrefdem &subtrrefdeminput,
        input_filtphase   &filtphaseinput,
        input_dinsar      &dinsarinput,
        input_unwrap      &unwrapinput,
        input_slant2h     &slant2hinput,
        input_geocode     &geocodeinput)
  {
  TRACE_FUNCTION("readinput (BK 11-Dec-1998)");

  // ______ Set ids ______
  m_readfilesinput.fileid = MASTERID;
  m_cropinput.fileid      = MASTERID;
  s_readfilesinput.fileid = SLAVEID;
  s_cropinput.fileid      = SLAVEID;

  // ______ Misuse generalinput.logfile to store name: open file here! ______
  //ifstream optionsfile(generalinput.logfile, ios::in | ios::nocreate);
  ifstream optionsfile(generalinput.logfile, ios::in);
  bk_assert(optionsfile,generalinput.logfile,__FILE__,__LINE__);

  int16                 onlyprocess     = -1;        // flag for ONLYPROCESS card
  int16                 linecnt         =  0;        // counter
  char                  keyword[EIGHTY];
  char                  filename[EIGHTY];            // string for filenames
  char                  dummyline[ONE27];

  // ______ Check (multiple) occurence of cards ______
  bool                  priorscreen     = false;     // no screen card present
  bool                  priormemory     = false;     // check if present for info
  bool                  priorbatch      = false;     // check if present for info
  bool                  prioroverwrite  = false;     // check if present for info
  bool                  priorlistinput  = false;     // check if present for info
  bool                  priorrs_fileout = false;     // 


// ====== Initialization, defaults ======
  bool                  listinput  = true;      // default copy input to log
  bool                  ellipsoid  = false;     // set default if no card present
  ellipsinput.a                 = WGS84_A;              // later e2, e2b
  ellipsinput.b                 = WGS84_B;              // later e2, e2b
  strcpy(ellipsinput.name,"WGS84");                     // 

  register int32 i;
  for (i=0; i<NUMPROCESSES; i++)
    generalinput.process[i] = 0;                         // default no processing step
  generalinput.interactive      = true;                 // default interactive mode
  generalinput.overwrit         = false;                // default no overwriting
  generalinput.memory           = 20000000;             // default memory (20MB)
  strcpy(generalinput.logfile,    "log.out");           // default logfile
  strcpy(generalinput.m_resfile,  "master_result.out"); // default resultfile
  strcpy(generalinput.s_resfile,  "slave_result.out");  // default resultfile
  strcpy(generalinput.i_resfile,  "interferogram.out"); // default interf_out
  generalinput.orb_interp       = ORB_DEFAULT;          // default polyfit
  generalinput.dumpbaselineL    = 0;                    // default no dump
  generalinput.dumpbaselineP    = 0;                    // default no dump
  generalinput.preview          = 0;                    // default no preview
  generalinput.terrain_height   = 0.0;                  // above ellipsoid
  generalinput.tiepoint.x       = 0.0;                  // default none
  generalinput.tiepoint.y       = 0.0;                  // default none
  generalinput.tiepoint.z       = 0.0;                  // default none

  //m_readfilesinput.method     = readfiles_ers;        // default
  m_readfilesinput.sensor_id    = SLC_ERS;              // default
  setunspecified(m_readfilesinput.volfile);             // check later, then set default
  setunspecified(m_readfilesinput.leaderfile);          // check later, then set default
  setunspecified(m_readfilesinput.nullfile);            // check later, then set default
  setunspecified(m_readfilesinput.datfile);             // check later, then set default
  m_readfilesinput.rg_timing_error = 0.0;               // default
  m_readfilesinput.az_timing_error = 0.0;               // default
  //s_readfilesinput.sensor_id          = readfiles_ers;        // default
  s_readfilesinput.sensor_id    = SLC_ERS;              // default
  setunspecified(s_readfilesinput.volfile);             // check later, then set default
  setunspecified(s_readfilesinput.leaderfile);          // check later, then set default
  setunspecified(s_readfilesinput.nullfile);            // check later, then set default
  setunspecified(s_readfilesinput.datfile);             // check later, then set default
  s_readfilesinput.rg_timing_error = 0.0;               // default
  s_readfilesinput.az_timing_error = 0.0;               // default

  setunspecified(porbitsinput.m_orbdir);                // check later, then set default
  setunspecified(porbitsinput.s_orbdir);                // check later, then set default
  porbitsinput.timeinterval     = 1;                    // default time interval
  porbitsinput.timebefore       = 4*porbitsinput.timeinterval;   // default 4 extra datapoints
  porbitsinput.dumpmasterorbit  = -1.;                  // default no dump
  porbitsinput.dumpslaveorbit   = -1.;                  // default no dump

  strcpy(m_cropinput.idcrop,"master step01");           // default identifier
  strcpy(s_cropinput.idcrop,"slave step01");            // default identifier
  strcpy(m_cropinput.fileout1,"master.raw");            // default output filename
  strcpy(s_cropinput.fileout1,"slave.raw");             // default output filename
  m_cropinput.dbow.linelo       = 0;                    // min. line coord. initialization
  m_cropinput.dbow.linehi       = 0;                    // max. line coord. initialization
  m_cropinput.dbow.pixlo        = 0;                    // min. pixel coord. initialization
  m_cropinput.dbow.pixhi        = 0;                    // max. pixel coord. initialization
  s_cropinput.dbow.linelo       = 0;                    // min. line coord. initialization
  s_cropinput.dbow.linehi       = 0;                    // max. line coord. initialization
  s_cropinput.dbow.pixlo        = 0;                    // min. pixel coord. initialization
  s_cropinput.dbow.pixhi        = 0;                    // max. pixel coord. initialization
  m_cropinput.dbow_geo.linelo   = 0;                    // min. line coord. initialization
  m_cropinput.dbow_geo.linehi   = 0;                    // max. line coord. initialization
  m_cropinput.dbow_geo.pixlo    = 0;                    // min. pixel coord. initialization
  m_cropinput.dbow_geo.pixhi    = 0;                    // max. pixel coord. initialization
  s_cropinput.dbow_geo.linelo   = 0;                    // min. line coord. initialization
  s_cropinput.dbow_geo.linehi   = 0;                    // max. line coord. initialization
  s_cropinput.dbow_geo.pixlo    = 0;                    // min. pixel coord. initialization
  s_cropinput.dbow_geo.pixhi    = 0;                    // max. pixel coord. initialization

//____RaffaeleNutricato START MODIFICATION SECTION 4
  m_oversample.OsrRange          = 1;                    // Default for oversampling ratio in range.
  m_oversample.OsrAzimuth        = 1;                    // Default for oversampling ratio in azimuth.
  m_oversample.FilterSize        = 16;                   // Default for length of the interpolation kernel in range. 
  m_oversample.oformatflag       = FORMATCI2;            // Default for output format.
  strcpy(m_oversample.fileoutovs,"master_ovs.raw");      // Default output filename.
  s_oversample.OsrRange          = 1;                    // Default for oversampling ratio in range.
  s_oversample.OsrAzimuth        = 1;                    // Default for oversampling ratio in azimuth.
  s_oversample.FilterSize        = 16;                   // Default for length of the interpolation kernel in range. 
  s_oversample.oformatflag       = FORMATCI2;            // Default for output format.
  strcpy(s_oversample.fileoutovs,"slave_ovs.raw");       // Default output filename.
//____RaffaeleNutricato END MODIFICATION SECTION 4

  filtaziinput.oformatflag      = FORMATCR4;            // default
  filtaziinput.fftlength        = 1024;                 // default
  filtaziinput.overlap          = -1;                   // default to fftlength/8
  filtaziinput.hammingalpha     = 0.75;                 // default (slc)
  strcpy(filtaziinput.fomaster,"master.afilter");       // default
  strcpy(filtaziinput.foslave,"slave.afilter");         // default

  const int32 def_cc_nwin       = 11;                   // default #windows
  setunspecified(coarsecorrinput.ifpositions);          // check later, then set default
  coarsecorrinput.MasksizeL     = 64;                   // default correlation size
  coarsecorrinput.MasksizeP     = coarsecorrinput.MasksizeL;    // default correlation size
  coarsecorrinput.AccL          = 32;                   // default searching limit
  coarsecorrinput.AccP          = 8;                    // default searching limit
  coarsecorrinput.initoffsetL   = 0;                    // default initial offset
  coarsecorrinput.initoffsetP   = 0;                    // default initial offset

  setunspecified(fineinput.ifpositions);                // check later, then set default
  const int32 def_fc_nwin       = 101;                  // default #windows
  fineinput.MasksizeL           = 32;                   // default correlation size
  fineinput.MasksizeP           = fineinput.MasksizeL;  // default correlation size
  fineinput.AccL                = 4;                    // default searching limit
  fineinput.AccP                = fineinput.AccL;       // default searching limit
  fineinput.initoffsetL         = 0;                    // default initial offset
  fineinput.initoffsetP         = 0;                    // default initial offset
  fineinput.osfactor            = 16;                   // default oversampling factor
  fineinput.plotoffsets         = false;                // default no plotting
  fineinput.plotmagbg           = false;                // default no plotting
  fineinput.plotthreshold       = 0.4;                  // default no plotting

  coregpminput.threshold        = .4;                   // default threshold data
  coregpminput.degree           = 1;                    // default degree polynomial
  coregpminput.weightflag       = 0;                    // default no weighting of data
  coregpminput.maxiter          = 10;                   // default max. 10 outliers removed
  coregpminput.k_alpha          = 1.97;                 // critical value for outliers
  coregpminput.dumpmodel        = false;                // default no files
  coregpminput.plot             = false;                // default no plots
  coregpminput.plotmagbg        = false;                // default no plots

  filtrangeinput.method         = rf_adaptive;          // default
  filtrangeinput.terrainslope   = 0.;                   // default porbits
  filtrangeinput.fftlength      = -999;                 // set default later
  filtrangeinput.overlap        = 0;                    // default no overlap
  filtrangeinput.nlmean         = 15;                   // default
  filtrangeinput.hammingalpha   = 0.75;                 // default
  filtrangeinput.SNRthreshold   = 5.;                   // default
  filtrangeinput.oversample   = 2;                      // default
  filtrangeinput.doweightcorrel = false;                // default
  strcpy(filtrangeinput.fomaster,"master.rfilter");     // default
  strcpy(filtrangeinput.foslave,"slave.rfilter");       // default
  filtrangeinput.oformatflag    = FORMATCR4;            // default

  setunspecified(comprefphainput.ifpositions);          // check later, then set default
  const int32 def_fe_Npoints    = 501;                  // default
  const int32 def_fe_degree     = 5;                    // default

  strcpy(resampleinput.fileout,"s_resampled.raw");      // default
  resampleinput.oformatflag     = FORMATCR4;            // default
  resampleinput.dbow.linelo     = 0;                    // min. line coord. initialization
  resampleinput.dbow.linehi     = 0;                    // max. line coord. initialization
  resampleinput.dbow.pixlo      = 0;                    // min. pixel coord. initialization
  resampleinput.dbow.pixhi      = 0;                    // max. pixel coord. initialization
  resampleinput.shiftazi        = true;                 // default apply shift

  interferoinput.method         = int_oldmethod;        // default method
  setunspecified(interferoinput.focint);                // check later, then set default
  setunspecified(interferoinput.foint);                 // use later if specified
  //setunspecified(interferoinput.foflatearth);         // check later, then set default
  interferoinput.multilookL     = 5;                    // default multilookfactor
  interferoinput.multilookP     = 1;                    // default multilookfactor

  coherenceinput.method         = coh_oldmethod;        // default method
  setunspecified(coherenceinput.focoh);                 // check later, then set default
  setunspecified(coherenceinput.foccoh);                // check later, then set default
  coherenceinput.multilookL     = 10;                   // default multilookfactor
  coherenceinput.multilookP     = 2;                    // default multilookfactor
  coherenceinput.cohsizeL       = coherenceinput.multilookL;    // default windowsize. 
  coherenceinput.cohsizeP       = coherenceinput.multilookP;    // default windowsize. 

  subtrrefphainput.method       = srp_polynomial;       // default method
  strcpy(subtrrefphainput.forefpha, "refphase.raw");    // default name
  strcpy(subtrrefphainput.focint,"cint.minrefpha.raw");// default
  subtrrefphainput.multilookL   = 1;                    // default multilookfactor
  subtrrefphainput.multilookP   = 1;                    // default multilookfactor
  subtrrefphainput.dumponlyrefpha  = false;             // default not

  filtphaseinput.method         = fp_goldstein;         // default method
  filtphaseinput.alpha          = 0.2;                  // default
  // ______ 32 blocks default for goldstein, kernel as large as possible, ______
  // ______ 2Dkernel then specify ______
  filtphaseinput.blocksize      = 32;                   // default
  filtphaseinput.overlap        = 3;                    // default
  // set default later with alpha in name
  setunspecified(filtphaseinput.fofiltphase);           // check later, then set default
  setunspecified(filtphaseinput.fifiltphase);           // if specified, use it
  setunspecified(filtphaseinput.fikernel2d);            // if specified, use it
  filtphaseinput.finumlines     = 0;                    // numlines.

  strcpy(dinsarinput.fodinsar,"differentialinterf.raw");// default
  setunspecified(dinsarinput.foscaleduint);             // default no output
  // ______ set mastertopo file to same as master resfile if not specified ______
  setunspecified(dinsarinput.topomasterresfile);        // if specified, use 4 pass
  setunspecified(dinsarinput.toposlaveresfile);         // check later, mandatory
  setunspecified(dinsarinput.topointresfile);           // check later, mandatory

  setunspecified(comprefdeminput.firefdem);             // check later, mandatory
  setunspecified(comprefdeminput.fodem);                // check later, then set default
  setunspecified(comprefdeminput.fodemi);               // check later, then set default
  setunspecified(comprefdeminput.forefdemhei);          // check later, then set default
  strcpy(comprefdeminput.forefdem,"refdem.raw");        // default name
  comprefdeminput.iformatflag   = FORMATI2;             // default gtopo30
  comprefdeminput.method        = crd_trilinear;        // default method
  comprefdeminput.extradense    = 0.5;                  // default (now interpolated in l,p)
  comprefdeminput.demrows       = 6000;                 // default gtopo30
  comprefdeminput.demcols       = 4800;                 // default gtopo30
  comprefdeminput.demnodata     = -9999;                // default gtopo30
  comprefdeminput.demdeltalat   = deg2rad(0.00833333333333333333);// default gtopo30
  comprefdeminput.demdeltalon   = deg2rad(0.00833333333333333333);// default gtopo30
  comprefdeminput.demlatleftupper = deg2rad(89.995833333333333333);     // w020n90.DEM
  comprefdeminput.demlonleftupper = deg2rad(-19.995833333333333333);// w020n90.DEM

  strcpy(subtrrefdeminput.focint,"cint.minrefdem.raw"); // default name
  subtrrefdeminput.offsetL      = 0;                    // default no offset
  subtrrefdeminput.offsetP      = 0;                    // default no offset

  strcpy(unwrapinput.fouint,"unwrapped_interferogram.raw");     // default name
  strcpy(unwrapinput.foregions,"regions_unwrapped.raw");        // default name
  setunspecified(unwrapinput.seedfile);                 // check later, then set default
  unwrapinput.deltaLseed        = 100;                  // default 100 pixels;
  unwrapinput.deltaPseed        = unwrapinput.deltaLseed;       // default 100 pixels;
  setunspecified(unwrapinput.snaphu_log);// " "
  setunspecified(unwrapinput.snaphu_coh);// " "
  strcpy(unwrapinput.snaphu_mode,"TOPO");               // default TOPO
  strcpy(unwrapinput.snaphu_init,"MST");                // default method
  strcpy(unwrapinput.snaphu_verbose,"TRUE");            // default verbose
  unwrapinput.oformatflag       = FORMATHGT;

  slant2hinput.Npoints          = 200;                  // default 100 pixels;
  slant2hinput.degree1d         = 2;                    // default 2 
  slant2hinput.degree2d         = 5;                    // default 5
  slant2hinput.Nheights         = slant2hinput.degree1d+1;// minimum
  strcpy(slant2hinput.fohei,"hei.raw");                 // default
  strcpy(slant2hinput.fophi,"phi.raw");                 // default
  strcpy(slant2hinput.folam,"lam.raw");                 // default

  strcpy(geocodeinput.fophi,"geo_phi.raw");             // default name
  strcpy(geocodeinput.folam,"geo_lambda.raw");          // default name


// ====== (default) Methods ======
  const int16 def_cc_method     = cc_magfft;
  const int16 def_fc_method     = fc_magfft;
  const int16 def_fe_method     = fe_porbits;
  const int16 def_rs_method     = rs_cc4p;
  const int16 def_uw_method     = uw_method2;// snaphu, system call, see www
  const int16 def_s2h_method    = s2h_ambiguity;

// ______ To check later if default should be used ______
  coarsecorrinput.method        = def_cc_method  - 999; // default method (repair later)
  coarsecorrinput.Nwin          = def_cc_nwin    + 999; // default #windows
  fineinput.method              = def_fc_method  - 999; // default method (repair later)
  fineinput.Nwin                = def_fc_nwin    + 999; // default #windows
  unwrapinput.method            = def_uw_method  - 999; // default method (repair later)
  comprefphainput.method        = def_fe_method  - 999; // default method (repair later)
  comprefphainput.degree        = def_fe_degree  - 999; // default degree polynomial
  comprefphainput.Npoints       = def_fe_Npoints - 999; // default degree polynomial
  resampleinput.method          = def_rs_method  - 999; // default method (repair later)
  slant2hinput.method           = def_s2h_method - 999; // default method (repair later)





// ====== Process "inputoptionsfile" ======
  bool continuereading = true;
  while (continuereading)                               // read file until STOP card
    {
    linecnt++;
    optionsfile >> keyword;
    DEBUG << linecnt << ": Read keyword: " << keyword;
    DEBUG.print();
    toupper(keyword);

// *******************************************************************
// *** GENERAL
// *******************************************************************
    if (!strcmp(keyword,"COMMENT") ||
        !strcmp(keyword,"C")) 
      {
      ;                                         // comment: no action 
      }
    else if (!strncmp(keyword,"//",2) ||        // assume user comments out
             !strncmp(keyword,"#",1))           // with // or '#' as delimiter
      {                                         // but no blank after keyword
      ;                                         // comment: no action
      }
//    else if (!strncmp(keyword,'\0',1))        // empty line?
//      {                                               //
//      ;                                               // comment: no action
//      }

// **********************************************************************
    else if (!strcmp(keyword,"BEEP"))   // level of beep output 
      {                                 // /progress/[warning]/error/ON/OFF
      optionsfile >> keyword;           // argument
      //writearg((char*)keyword);
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"ERROR"))
        {
        TRACE.bellrings(0);
        DEBUG.bellrings(0);
        INFO.bellrings(0);
        PROGRESS.bellrings(0);
        WARNING.bellrings(0);
        ERROR.bellrings(1);
        beeplevel = -1;
        INFO.print("BEEP: \tbeeping enabled at level: \tERROR");
        }
      else if (!strcmp(keyword,"PROGRESS"))
        {
        TRACE.bellrings(0);
        DEBUG.bellrings(0);
        INFO.bellrings(0);
        PROGRESS.bellrings(1);
        WARNING.bellrings(2);
        ERROR.bellrings(3);
        beeplevel =  2;
        INFO.print("BEEP: \tbeeping enabled at level: \tPROGRESS");
        }
      else if (!strcmp(keyword,"WARNING"))
        {
        TRACE.bellrings(0);
        DEBUG.bellrings(0);
        INFO.bellrings(0);
        PROGRESS.bellrings(0);
        WARNING.bellrings(1);
        ERROR.bellrings(2);
        beeplevel =  1;
        INFO.print("BEEP: \tbeeping enabled at level: \tWARNING");
        }
      else if (!strcmp(keyword,"OFF"))
        {
        TRACE.bellrings(0);
        DEBUG.bellrings(0);
        INFO.bellrings(0);
        PROGRESS.bellrings(0);
        WARNING.bellrings(0);
        ERROR.bellrings(0);
        beeplevel =  0;
        INFO.print("BEEP: \tbeeping disabled");
        }
      else if (!strcmp(keyword,"ON")    ||
               !strncmp(keyword,"//",2) ||      // comment
               !strncmp(keyword,"#",1) ||       // comment
               !strcmp(keyword,'\0'))           // no keyword
//             !strcmp(keyword,""))             // no keyword
        {
        TRACE.bellrings(0);
        DEBUG.bellrings(0);
        INFO.bellrings(0);
        PROGRESS.bellrings(1);
        WARNING.bellrings(2);
        ERROR.bellrings(3);
        beeplevel =  2;
        INFO.print("BEEP: \tbeeping enabled for all levels: \tON");
        }
      else
        {
        beeplevel = 1;
        TRACE.bellrings(0);
        DEBUG.bellrings(0);
        INFO.bellrings(0);
        PROGRESS.bellrings(0);
        WARNING.bellrings(1);
        ERROR.bellrings(2);
        WARNING << "BEEP:   line " << linecnt
             << ": Argument " << keyword 
             << " not recognized."
             << " [error/warning/progress/on/off] I used WARNING.";
        WARNING.print();
        }
      } // BEEP key

// **********************************************************************
    else if (!strcmp(keyword,"SCREEN")) // level of screen output 
      {                                 // debug/info/progress/warning or error
      switch (priorscreen)
        {
        case true:
          WARNING << "SCREEN: line " << linecnt << ": stdout: "
               << " ignored due to prior occurence.";
          WARNING.print();
          break;

        default:
          priorscreen = true;
          optionsfile >> keyword;                       // argument
          writearg(keyword);
          toupper(keyword);
          if (!strcmp(keyword,"INFO"))
            {
            TRACE.doprint(0);
            DEBUG.doprint(0);
            INFO.doprint(1);
            PROGRESS.doprint(1);
            WARNING.doprint(1);
            ERROR.doprint(1);
            displevel = 20000 + displevel%10000;        // for cnt #warnings
            INFO.print("SCREEN: \tverboseness: \t\t\tINFO");
            }
          else if (!strcmp(keyword,"PROGRESS"))
            {
            TRACE.doprint(0);
            DEBUG.doprint(0);
            INFO.doprint(1);
            PROGRESS.doprint(1);
            WARNING.doprint(1);
            ERROR.doprint(1);
            displevel = 10000 + displevel%10000;        // for cnt #warnings
            INFO.print("SCREEN: \tverboseness: \t\t\tPROGRESS");
            }
          else if (!strcmp(keyword,"DEBUG"))
            {
            TRACE.doprint(0);
            DEBUG.doprint(1);
            INFO.doprint(1);
            PROGRESS.doprint(1);
            WARNING.doprint(1);
            ERROR.doprint(1);
            displevel = 30000 + displevel%10000;        // for cnt #warnings
            INFO.print("SCREEN: \tverboseness: \t\t\tDEBUG");
            }
          else if (!strcmp(keyword,"TRACE"))
            {
            TRACE.doprint(1);
            DEBUG.doprint(1);
            INFO.doprint(1);
            PROGRESS.doprint(1);
            WARNING.doprint(1);
            ERROR.doprint(1);
            }
          else if (!strcmp(keyword,"WARNING"))
            {
            TRACE.doprint(0);
            DEBUG.doprint(0);
            INFO.doprint(0);
            PROGRESS.doprint(0);
            WARNING.doprint(1);
            ERROR.doprint(1);
            displevel = 0 + displevel%10000;            // for cnt #warnings;
            INFO.print("SCREEN: \tverboseness: \t\t\tWARNING");
            }
          else if (!strcmp(keyword,"ERROR"))
            {
            TRACE.doprint(0);
            DEBUG.doprint(0);
            INFO.doprint(0);
            PROGRESS.doprint(0);
            WARNING.doprint(0);
            ERROR.doprint(1);
            displevel = -100 + displevel%10000;         // for cnt #warnings
            INFO.print("SCREEN: \tverboseness: \t\t\tERROR");
            }
          else
            {
            TRACE.doprint(0);
            DEBUG.doprint(1);
            INFO.doprint(1);
            PROGRESS.doprint(1);
            WARNING.doprint(1);
            ERROR.doprint(1);
            WARNING << "SCREEN: line " << linecnt
                 << ": Argument " << keyword 
                 << " not recognized."
                 << " [error/warning/progress/info/debug] I used DEBUG.";
            WARNING.print();
            displevel = 30000 + displevel%10000;       // for cnt #warnings
            }
        } // switch
      } // SCREEN key

// **********************************************************************
    else if (!strcmp(keyword,"MEMORY"))         // available mem in MB
      {
      switch (priormemory)
        {
        case true:
          WARNING << "MEMORY: line " << linecnt
               << ": ignored due to prior occurence.";
          WARNING.print();
          break;

        default:
          priormemory = true;
          optionsfile >> generalinput.memory;
          writearg(generalinput.memory);
          if (generalinput.memory > 10000)
            WARNING.print("MEMORY: > 10000 MB seems unlikely.");
          generalinput.memory *= 1000000;                       // in B
        } // switch
      } // MEMORY card

// **********************************************************************
    else if (!strcmp(keyword,"BATCH"))                  // overrides interactive mode
      {
      switch (priorbatch)
        {
        case true:
          WARNING << "BATCH: line: " << linecnt << ": "
               << "ignored due to prior occurence.";
          WARNING.print();
          break;
        default:
          priorbatch = true;                            // flag for occurence
          optionsfile >> keyword;                       // argument
          writearg(keyword);
          toupper(keyword);
          if (!strcmp(keyword,"OFF"))
            generalinput.interactive = true;
          else if (!strcmp(keyword,"ON")    ||
                   !strncmp(keyword,"//",2) ||          // comment
                   !strncmp(keyword,"#",1)  ||          // comment
                   !strcmp(keyword,'\0'))               // no keyword
            generalinput.interactive = false;
          else
            {
            generalinput.interactive = true;
            WARNING << "BATCH: line: " << linecnt << ": "
                 << "argument: " << keyword 
                 << " not recognized, interactive processing.";
            WARNING.print();
            }
        } // switch
      } // BATCH key

// **********************************************************************
    else if (!strcmp(keyword,"OVERWRITE")) 
      {
      switch (prioroverwrite)
        {
        case true:
          WARNING << "OVERWRITE: line: " << linecnt << ": "
               << "ignored due to prior occurence.";
          WARNING.print();
          break;
        default:
          prioroverwrite = true;                                // flag for occurence
          optionsfile >> keyword;                               // argument
          writearg(keyword);
          toupper(keyword);
          if (!strcmp(keyword,"OFF")) 
            generalinput.overwrit = false;
          else if (!strcmp(keyword,"ON")    ||
                   !strncmp(keyword,"//",2) ||          // comment
                   !strncmp(keyword,"#",1)  ||          // comment
                   !strcmp(keyword,'\0'))               // no keyword
            generalinput.overwrit = true;
          else
            {
            generalinput.overwrit=false;                    // don't overwrite files
            WARNING << "OVERWRITE: line " << linecnt 
                 << ": argument: " << keyword 
                 << " not recognized, existing files are not overwritten.";
            WARNING.print();
            }
        } // switch
      } // OVERWRITE key

// **********************************************************************
    else if (!strcmp(keyword,"LISTINPUT")) 
      {
      switch (priorlistinput)
        {
        case true:
          WARNING << "LISTINPUT: line: " << linecnt << ": "
               << "ignored due to prior occurence.";
          WARNING.print();
          break;
        default:
          priorlistinput = true;                                // flag for occurence
          optionsfile >> keyword;                               // argument
          writearg(keyword);
          toupper(keyword);
          if (!strcmp(keyword,"OFF")) 
            listinput = false;
          else if (!strcmp(keyword,"ON")    ||
                   !strncmp(keyword,"//",2) ||          // comment
                   !strncmp(keyword,"#",1)  ||          // comment
                   !strcmp(keyword,'\0'))               // no keyword
            listinput = true;
          else
            {
            listinput = true;                                   // default list input
            WARNING << "LISTINPUT: line " << linecnt 
                 << ": argument: " << keyword 
                 << " not recognized, input will be appended to logfile.";
            WARNING.print();
            }
        } // switch
      } // LISTINPUT key

// **********************************************************************
    else if (!strcmp(keyword,"ONLYPROCESS"))     // process only one step
      {
      // Read argument and set onlyprocess to value for filling
      //  the flag input array 'process[NUMPROCESSES]' after reading reset input
      //  to avoid interference with PROCESS cards (ONLYPROCESS overrides)
      //
      if (onlyprocess == -1)                             // check multiple occurences
        {
        optionsfile >> keyword;
        writearg(keyword);
        toupper(keyword);
        if      (!strcmp(keyword,"M_READFILES"))
          onlyprocess=pr_m_readfiles;
        else if (!strcmp(keyword,"M_CROP"))
          onlyprocess=pr_m_crop;
//____RaffaeleNutricato START MODIFICATION SECTION 5
        else if (!strcmp(keyword,"M_OVS"))
          onlyprocess=pr_m_oversample;
//____RaffaeleNutricato END MODIFICATION SECTION 5
        else if (!strcmp(keyword,"M_PORBITS"))
          onlyprocess=pr_m_porbits;
        else if (!strcmp(keyword,"M_FILTAZI"))
          onlyprocess=pr_m_filtazi;
        else if (!strcmp(keyword,"FILTRANGE"))
          {
          onlyprocess=pr_m_filtrange;
          onlyprocess=pr_s_filtrange;
          }
        else if (!strcmp(keyword,"M_EXTRA"))
          onlyprocess=pr_m_EXTRA;

        else if (!strcmp(keyword,"S_READFILES"))
          onlyprocess=pr_s_readfiles;
        else if (!strcmp(keyword,"S_CROP"))
          onlyprocess=pr_s_crop;
//____RaffaeleNutricato START MODIFICATION SECTION 6
        else if (!strcmp(keyword,"S_OVS"))
          onlyprocess=pr_s_oversample;
//____RaffaeleNutricato END MODIFICATION SECTION 6
        else if (!strcmp(keyword,"S_PORBITS"))
          onlyprocess=pr_s_porbits;
        else if (!strcmp(keyword,"S_FILTAZI"))
          onlyprocess=pr_s_filtazi;
        else if (!strcmp(keyword,"RESAMPLE"))
          onlyprocess=pr_s_resample;
        else if (!strcmp(keyword,"S_EXTRA"))
          onlyprocess=pr_s_EXTRA;

        else if (!strcmp(keyword,"COARSEORB"))
          onlyprocess=pr_i_coarse;
        else if (!strcmp(keyword,"COARSECORR"))
          onlyprocess=pr_i_coarse2;
        else if (!strcmp(keyword,"FINE"))
          onlyprocess=pr_i_fine;                         // see methodselector
        else if (!strcmp(keyword,"COREGPM"))
          onlyprocess=pr_i_coregpm;
        else if (!strcmp(keyword,"INTERFERO"))
          onlyprocess=pr_i_interfero;
        else if (!strcmp(keyword,"COHERENCE"))
          onlyprocess=pr_i_coherence;
        else if (!strcmp(keyword,"FILTPHASE"))
          onlyprocess=pr_i_filtphase;
        else if (!strcmp(keyword,"COMPREFPHA"))
          onlyprocess=pr_i_comprefpha;
        else if (!strcmp(keyword,"SUBTRREFPHA"))
          onlyprocess=pr_i_subtrrefpha;
        else if (!strcmp(keyword,"COMPREFDEM"))
          onlyprocess=pr_i_comprefdem;
        else if (!strcmp(keyword,"SUBTRREFDEM"))
          onlyprocess=pr_i_subtrrefdem;
        else if (!strcmp(keyword,"UNWRAP"))
          onlyprocess=pr_i_unwrap;                       // see methodselector
        else if (!strcmp(keyword,"SLANT2H"))
          onlyprocess=pr_i_slant2h;
        else if (!strcmp(keyword,"GEOCODE"))
          onlyprocess=pr_i_geocoding;
        else if (!strcmp(keyword,"DINSAR"))
          onlyprocess=pr_i_dinsar;
        else if (!strcmp(keyword,"I_EXTRA2"))
          onlyprocess=pr_i_EXTRA2;
        else
          {
          ERROR << "ONLYPROCESS: line " << linecnt << ": Argument " 
                   << keyword << " not recognized.";
          PRINT_ERROR(ERROR.get_str())
          throw(keyword_error);
          }
        INFO << "ONLYPROCESS: \tonly processing step: \t\t" << keyword;
        INFO.print();
        }
      else
        {
        WARNING << "ONLYPROCESS: more than one occurence of card, ignored line: "
                   << linecnt << ".";
        WARNING.print();

        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"PROCESS"))                 // which routine to run
      {
      if (onlyprocess+1)                                 // initialized to -1;
        {
        WARNING << "PROCESS card on line " << linecnt 
             << " ignored due to presence of ONLYPROCESS card.";
        WARNING.print();
        }
      else
        {
        optionsfile >> keyword;                         // argument
        writearg(keyword);
        toupper(keyword);
        if (!strcmp(keyword,"M_READFILES"))
          generalinput.process[pr_m_readfiles] = 1;
        else if (!strcmp(keyword,"M_CROP"))
          generalinput.process[pr_m_crop]   = 1;
//____RaffaeleNutricato START MODIFICATION SECTION 7
        else if (!strcmp(keyword,"M_OVS"))
          generalinput.process[pr_m_oversample]   = 1; 
//____RaffaeleNutricato END MODIFICATION SECTION 7
        else if (!strcmp(keyword,"M_PORBITS"))
          generalinput.process[pr_m_porbits]   = 1;
        else if (!strcmp(keyword,"M_FILTAZI"))
          generalinput.process[pr_m_filtazi]   = 1;
        else if (!strcmp(keyword,"FILTRANGE"))
          {
          generalinput.process[pr_m_filtrange] = 1;     // use for s_ as well
          generalinput.process[pr_s_filtrange] = 1;
          }
        else if (!strcmp(keyword,"M_EXTRA"))
          generalinput.process[pr_m_EXTRA] = 1;

        else if (!strcmp(keyword,"S_READFILES"))
          generalinput.process[pr_s_readfiles] = 1;
        else if (!strcmp(keyword,"S_CROP"))
          generalinput.process[pr_s_crop]   = 1;
//____RaffaeleNutricato START MODIFICATION SECTION 8
        else if (!strcmp(keyword,"S_OVS"))
          generalinput.process[pr_s_oversample]   = 1;
//____RaffaeleNutricato END MODIFICATION SECTION 8
        else if (!strcmp(keyword,"S_PORBITS"))
          generalinput.process[pr_s_porbits]   = 1;
        else if (!strcmp(keyword,"S_FILTAZI"))
          generalinput.process[pr_s_filtazi]   = 1;
        else if (!strcmp(keyword,"RESAMPLE"))
          generalinput.process[pr_s_resample]  = 1;
        else if (!strcmp(keyword,"S_EXTRA"))
          generalinput.process[pr_s_EXTRA] = 1;

        else if (!strcmp(keyword,"COARSEORB"))
          generalinput.process[pr_i_coarse]    = 1;
        else if (!strcmp(keyword,"COARSECORR"))
          generalinput.process[pr_i_coarse2]   = 1;
        else if (!strcmp(keyword,"FINE"))
          generalinput.process[pr_i_fine]      = 1;
        else if (!strcmp(keyword,"COREGPM"))
          generalinput.process[pr_i_coregpm]   = 1;
        else if (!strcmp(keyword,"COMPREFPHA"))
          generalinput.process[pr_i_comprefpha] = 1;
        else if (!strcmp(keyword,"SUBTRREFPHA"))
          generalinput.process[pr_i_subtrrefpha] = 1;
        else if (!strcmp(keyword,"COMPREFDEM"))
          generalinput.process[pr_i_comprefdem] = 1;
        else if (!strcmp(keyword,"SUBTRREFDEM"))
          generalinput.process[pr_i_subtrrefdem] = 1;
        else if (!strcmp(keyword,"INTERFERO"))
          generalinput.process[pr_i_interfero] = 1;
        else if (!strcmp(keyword,"COHERENCE"))
          generalinput.process[pr_i_coherence] = 1;
        else if (!strcmp(keyword,"FILTPHASE"))
          generalinput.process[pr_i_filtphase] = 1;
        else if (!strcmp(keyword,"UNWRAP"))
          generalinput.process[pr_i_unwrap]    = 1;
        else if (!strcmp(keyword,"SLANT2H"))
          generalinput.process[pr_i_slant2h]   = 1;
        else if (!strcmp(keyword,"GEOCODE"))
          generalinput.process[pr_i_geocoding] = 1;
        else if (!strcmp(keyword,"DINSAR"))
          generalinput.process[pr_i_dinsar] = 1;

        else if (!strcmp(keyword,"I_EXTRA2"))
          generalinput.process[pr_i_EXTRA2] = 1;
        else
          {
          ERROR << "PROCESS: line " << linecnt 
               << ": Argument " << keyword 
               << " not recognized.";
          PRINT_ERROR(ERROR.get_str())
          throw(keyword_error);
          }
        INFO << "PROCESS: \tI will process step: \t\t" << keyword;
        INFO.print();
        }
      }

// **********************************************************************
// *** NOT OK ? (not used in processing?)
    else if (!strcmp(keyword,"ELLIPSOID"))            // ref. system
      {                                               //  inputoptionsfile
      ellipsoid = true;                               // use below 
      optionsfile >> keyword >> filename;
      writearg(keyword);
      writearg(filename);
      toupper(keyword);
      if (!strcmp(keyword,"WGS84"))
        {
        ellipsinput.a = WGS84_A;
        ellipsinput.b = WGS84_B;
        strcpy(ellipsinput.name,"WGS84");
        }

      else if (!strcmp(keyword,"GRS80"))
        {
        ellipsinput.a = GRS80_A;
        ellipsinput.b = GRS80_B;
        strcpy(ellipsinput.name,"GRS80");
        }

      else if (!strcmp(keyword,"BESSEL"))
        {
        ellipsinput.a = BESSEL_A;
        ellipsinput.b = BESSEL_B;
        strcpy(ellipsinput.name,"BESSEL");
cerr << "ellips not ok yet, should helmert transform sat. data points??.\n";      
        }

      else if (isdigit(filename[0]))                      // likely to be a,b
        {
cerr << "ellips not ok yet, should helmert transform sat. data points??.\n";      
        ellipsinput.a = atof(keyword);
        ellipsinput.b = atof(filename);
        strcpy(ellipsinput.name,"User defined");

        if (ellipsinput.a<ellipsinput.b || ellipsinput.b<EPS)
          {
          ERROR << "ELLIPSOID keyword (real8A real8B): B==0 or A<B: "
               << ellipsinput.a << "<" << ellipsinput.b 
               << " at line " << linecnt << ".";
          PRINT_ERROR(ERROR.get_str())
          throw(keyword_error);
          }
        }
      else
        {
        PRINT_ERROR("unknown argument for ellipsoid card.")
        throw(keyword_error);
        }
      INFO << "ELLIPSOID: \tsemimajor=" << ellipsinput.a
           << ", semiminor=" << ellipsinput.b << "; line " << linecnt << ".";
      INFO.print();
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_RESFILE"))            // resultfile filename
      {                                               
      optionsfile >> generalinput.m_resfile;
      writearg(generalinput.m_resfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_RESFILE"))            // resultfile filename
      {                                               
      optionsfile >> generalinput.s_resfile;
      writearg(generalinput.s_resfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"LOGFILE"))              // logfile filename
      {                                               
      optionsfile >> generalinput.logfile;
      writearg(generalinput.logfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"I_RESFILE"))            // interferogram.out
      {                                               
      optionsfile >> generalinput.i_resfile;
      writearg(generalinput.i_resfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"ORB_INTERP"))           // orbit
      {                                               
      optionsfile >> keyword;                         // argument
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"POLYFIT"))
        {
        INFO.print("ORB_INTERP:  polynomial fit for interpolation");
        generalinput.orb_interp = ORB_DEFAULT;// depends on number of points
        // ___ Check second optional argument with degree ___
        optionsfile >> keyword;
        int32 degree = atoi(keyword);
        if (degree > 0)// atoi returns 0 if not convertible
          {
          generalinput.orb_interp = degree;
          INFO << "ORB_INTERP:  second argument read: degree = " << degree;
          INFO.print();
          }
        }
      else if (!strcmp(keyword,"SPLINE"))
        {
        INFO.print("ORB_INTERP:  natural cubic splines used fit interpolation");
        generalinput.orb_interp = ORB_SPLINE;// natural cubic splines
        }
      else
        {
        WARNING.print("argument ORB_INTERP not reconized, using polyfit");
        generalinput.orb_interp = ORB_DEFAULT;// depends on number of points
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"DUMPBASELINE"))         // eval on grid
      {                                               
      optionsfile >> generalinput.dumpbaselineL >> generalinput.dumpbaselineP;
      writearg(generalinput.dumpbaselineL);
      writearg(generalinput.dumpbaselineP);
      if (generalinput.dumpbaselineL==0 || generalinput.dumpbaselineP==0)
        {
        ERROR << "DUMPBASELINE: " << generalinput.dumpbaselineL
             << " " << generalinput.dumpbaselineP << " line: "
             << linecnt << ": ==0.\n";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"PREVIEW"))        // system call to cpxfiddle to get SUNraster
      {
      optionsfile >> keyword;                   // argument
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"OFF"))
        {
        generalinput.preview = 0;
        INFO.print("PREVIEW: \tOFF: generation of SUNraster files disabled.");
        }
      else if (!strcmp(keyword,"XV"))
        {
        generalinput.preview = 2;
        INFO.print("PREVIEW: \tON: generation of SUNraster files enabled + XV sytem call.");
        }
      else if (!strcmp(keyword,"ON")    ||
               !strncmp(keyword,"//",2) ||              // comment
               !strncmp(keyword,"#",1)  ||              // comment
               !strcmp(keyword,'\0'))                   // no keyword
        {
        generalinput.preview = 1;
        INFO.print("PREVIEW: \tON: generation of SUNraster files enabled.");
        }
      else
        {
        generalinput.preview = 0;
        WARNING << "PREVIEW: line: " << linecnt << ": "
             << "argument: " << keyword 
             << " not recognized, no preview generated.";
        WARNING.print();
        }
      } // PREVIEW key

// **********************************************************************
    else if (!strcmp(keyword,"HEIGHT"))               // mean height or for CROP
      {
      optionsfile >> generalinput.terrain_height;
      writearg(generalinput.terrain_height);
      }

// **********************************************************************
    else if (!strcmp(keyword,"TIEPOINT"))          // lat/lon/hei dec.degrees
      {
      optionsfile >> generalinput.tiepoint.x 
                  >> generalinput.tiepoint.y 
                  >> generalinput.tiepoint.z;
      writearg(generalinput.tiepoint.x);
      writearg(generalinput.tiepoint.y);
      writearg(generalinput.tiepoint.z);
      }

// **********************************************************************
    else if (!strcmp(keyword,"STOP"))                 // STOP interpreting input
      {
      INFO.print("STOP:   \tEncountered.");
      DEBUG << "STOP card encountered at line "
           << linecnt << endl;
      DEBUG.print();
      continuereading = false;                        // break while loop
      }


// *******************************************************************
// *** ?_READFILES
// *******************************************************************
    else if (!strcmp(keyword,"M_IN_METHOD"))         // ERS or ASAR ENVISAT
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"ERS"))
        m_readfilesinput.sensor_id=SLC_ERS;              // default ers
      else if (!strcmp(filename,"ERS-1"))             // ers
        m_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"ERS1"))              // ers
        m_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"ERS-2"))             // ers
        m_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"ERS2"))              // ers
        m_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"N1"))                // envisat
        m_readfilesinput.sensor_id=SLC_ASAR;
      else if (!strcmp(filename,"ASAR"))              // envisat
        m_readfilesinput.sensor_id=SLC_ASAR;
      else if (!strcmp(filename,"ENVISAT"))           // envisat
        m_readfilesinput.sensor_id=SLC_ASAR;
      else if (!strcmp(filename,"ATLANTIS"))          // radarsat ceos reader
        m_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RSAT"))              // radarsat
        m_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RADARSAT"))          // radarsat
        m_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RADARSAT-1"))        // radarsat
        m_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RADARSAT-2"))        // radarsat
        m_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"JERS"))              // jers
        m_readfilesinput.sensor_id=SLC_JERS;
      else if (!strcmp(filename,"J-ERS"))             // jers
        m_readfilesinput.sensor_id=SLC_JERS;
      else
        {
        ERROR << "M_IN_METHOD: method " <<  filename
             << " not known for reading input files on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_IN_VOL"))            // volumefile filename
      {                                               
      optionsfile >> m_readfilesinput.volfile;
      writearg(m_readfilesinput.volfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_IN_LEA"))            // leaderfile filename
      {                                               
      optionsfile >> m_readfilesinput.leaderfile;
      writearg(m_readfilesinput.leaderfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_IN_NULL"))           // nullfile filename
      {                                               
      optionsfile >> m_readfilesinput.nullfile;
      writearg(m_readfilesinput.nullfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_IN_DAT"))            // datafile filename
      {                                               
      optionsfile >> m_readfilesinput.datfile;
      writearg(m_readfilesinput.datfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_RG_T_ERROR"))            // timing error
      {                                               
      optionsfile >> m_readfilesinput.rg_timing_error;
      writearg(m_readfilesinput.rg_timing_error);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_AZ_T_ERROR"))            // timing error
      {                                               
      optionsfile >> m_readfilesinput.az_timing_error;
      writearg(m_readfilesinput.az_timing_error);
      }

// *******************************************************************
    else if (!strcmp(keyword,"S_IN_METHOD"))         // ERS or ASAR ENVISAT
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"ERS"))
        s_readfilesinput.sensor_id=SLC_ERS;         // default
      else if (!strcmp(filename,"ERS-1"))             // ers
        s_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"ERS1"))              // ers
        s_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"ERS-2"))             // ers
        s_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"ERS2"))              // ers
        s_readfilesinput.sensor_id=SLC_ERS;
      else if (!strcmp(filename,"N1"))                // envisat
        s_readfilesinput.sensor_id=SLC_ASAR;
      else if (!strcmp(filename,"ASAR"))              // envisat
        s_readfilesinput.sensor_id=SLC_ASAR;
      else if (!strcmp(filename,"ENVISAT"))           // envisat
        s_readfilesinput.sensor_id=SLC_ASAR;
      else if (!strcmp(filename,"ATLANTIS"))          // radarsat ceos reader
        s_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RSAT"))              // radarsat
        s_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RADARSAT"))          // radarsat
        s_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RADARSAT-1"))        // radarsat
        s_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"RADARSAT-2"))        // radarsat
        s_readfilesinput.sensor_id=SLC_RSAT;
      else if (!strcmp(filename,"JERS"))              // jers
        s_readfilesinput.sensor_id=SLC_JERS;
      else if (!strcmp(filename,"J-ERS"))             // jers
        s_readfilesinput.sensor_id=SLC_JERS;
      else
        {
        ERROR << "S_IN_METHOD: method " <<  filename
             << " not known for reading input files on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_IN_VOL"))            // volumefile filename
      {                                               
      optionsfile >> s_readfilesinput.volfile;
      writearg(s_readfilesinput.volfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_IN_LEA"))            // leaderfile filename
      {                                               
      optionsfile >> s_readfilesinput.leaderfile;
      writearg(s_readfilesinput.leaderfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_IN_DAT"))            // nullfile filename
      {                                               
      optionsfile >> s_readfilesinput.datfile;
      writearg(s_readfilesinput.datfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_IN_NULL"))           // nullfile filename
      {                                               
      optionsfile >> s_readfilesinput.nullfile;
      writearg(s_readfilesinput.nullfile);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_RG_T_ERROR"))            // timing error
      {                                               
      optionsfile >> s_readfilesinput.rg_timing_error;
      writearg(s_readfilesinput.rg_timing_error);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_AZ_T_ERROR"))            // timing error
      {                                               
      optionsfile >> s_readfilesinput.az_timing_error;
      writearg(s_readfilesinput.az_timing_error);
      }


// **********************************************************************
// *** ?_PORBITS
// **********************************************************************
    else if (!strcmp(keyword,"M_ORBDIR"))             // orbitfile filename
      {                                               
      if (specified(porbitsinput.m_orbdir))
        WARNING.print("Prior occurence of M_ORBDIR ignored.");
      optionsfile >> porbitsinput.m_orbdir;
      writearg(porbitsinput.m_orbdir);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_ORB_INTERVAL") ||      // time interval in sec
             !strcmp(keyword,"S_ORB_INTERVAL")) 
      {                                               
      optionsfile >> porbitsinput.timeinterval;
      writearg(porbitsinput.timeinterval);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_ORB_EXTRATIME") ||    // time before 1st line in sec
             !strcmp(keyword,"S_ORB_EXTRATIME")) 
      {                                               
      optionsfile >> porbitsinput.timebefore;
      writearg(porbitsinput.timebefore);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_ORB_DUMP"))           // dump orbit with dt
      {                                               
      optionsfile >> porbitsinput.dumpmasterorbit;
      writearg(porbitsinput.dumpmasterorbit);
      INFO.print("dumping master orbit to ascii file: masterorbit.dat");
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_ORBDIR"))             // orbitfile filename
      {                                               
      if (specified(porbitsinput.s_orbdir))
        WARNING.print("Prior occurence of S_ORBDIR ignored.");
      optionsfile >> porbitsinput.s_orbdir;
      writearg(porbitsinput.s_orbdir);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_ORB_DUMP"))           // dump orbit with dt
      {                                               
      optionsfile >> porbitsinput.dumpslaveorbit;
      writearg(porbitsinput.dumpslaveorbit);
      INFO.print("dumping slave orbit to ascii file: slaveorbit.dat");
      }


// *******************************************************************
// *** ?_CROP
// *******************************************************************
    else if (!strcmp(keyword,"M_CROP_ID"))          // identifier of run
      {                                               
      optionsfile >> m_cropinput.idcrop;
      writearg(m_cropinput.idcrop);
      }

// *******************************************************************   CROP
    else if (!strcmp(keyword,"S_CROP_ID"))          // identifier of run
      {                                               
      optionsfile >> s_cropinput.idcrop;
      writearg(s_cropinput.idcrop);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_CROP_IN"))              // SLC input image filename
      {                                               
      optionsfile >> m_cropinput.filein1;
      writearg(m_cropinput.filein1);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_CROP_IN"))              // SLC input image filename
      {                                               
      optionsfile >> s_cropinput.filein1;
      writearg(s_cropinput.filein1);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_CROP_OUT"))             // SLC output image filename
      {                                               
      optionsfile >> m_cropinput.fileout1;
      writearg(m_cropinput.fileout1);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_CROP_OUT"))             // SLC output image filename
      {                                               
      optionsfile >> s_cropinput.fileout1;
      writearg(s_cropinput.fileout1);
      }

// **********************************************************************
    else if (!strcmp(keyword,"M_DBOW"))               // min. line coord.
      {                                               
      optionsfile >> m_cropinput.dbow.linelo
                  >> m_cropinput.dbow.linehi
                  >> m_cropinput.dbow.pixlo
                  >> m_cropinput.dbow.pixhi;
      writearg(m_cropinput.dbow.linelo);
      writearg(m_cropinput.dbow.linehi);
      writearg(m_cropinput.dbow.pixlo);
      writearg(m_cropinput.dbow.pixhi);

// ______initial check, later checked to #lines of image______
      if (m_cropinput.dbow.linelo <= 0 || 
          m_cropinput.dbow.pixlo <= 0 ||
          m_cropinput.dbow.linelo  > m_cropinput.dbow.linehi ||
          m_cropinput.dbow.pixlo > m_cropinput.dbow.pixhi)
        {
        ERROR << "code 300: Arguments of M_DBOW card on line " << linecnt
             << " missing. [DBOW  min_line  max_line  min_pixel  max_pixel].";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_DBOW"))               // min. line coord.
      {                                               
      optionsfile >> s_cropinput.dbow.linelo
                  >> s_cropinput.dbow.linehi
                  >> s_cropinput.dbow.pixlo
                  >> s_cropinput.dbow.pixhi;
      writearg(s_cropinput.dbow.linelo);
      writearg(s_cropinput.dbow.linehi);
      writearg(s_cropinput.dbow.pixlo);
      writearg(s_cropinput.dbow.pixhi);
      // ______initial check, later checked to #lines of image______
      if (s_cropinput.dbow.linelo <= 0 || 
          s_cropinput.dbow.pixlo <= 0 ||
          s_cropinput.dbow.linelo  > s_cropinput.dbow.linehi ||
          s_cropinput.dbow.pixlo > s_cropinput.dbow.pixhi)
        {
        ERROR << "code 300: Arguments of S_DBOW card on line " << linecnt
             << " missing. [DBOW  min_line  max_line  min_pixel  max_pixel].";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    // BK 15-Dec-2003
    else if (!strcmp(keyword,"M_DBOW_GEO")) // 1e6*lat_0 [deg], lon_0, height, width [pix]
      {                                               
      // use dbow to store tmp, compute later in crop if not zero
      real8 tmp_lat_0;
      real8 tmp_lon_0;
      real8 tmp_height;
      real8 tmp_width;
      optionsfile >> tmp_lat_0 >> tmp_lon_0 >> tmp_height >> tmp_width;
      writearg(tmp_lat_0);
      writearg(tmp_lon_0);
      writearg(tmp_height);
      writearg(tmp_width);
      m_cropinput.dbow_geo.linelo = uint((360.0+tmp_lat_0)*1e6);
      m_cropinput.dbow_geo.linehi = uint((360.0+tmp_lon_0)*1e6);
      m_cropinput.dbow_geo.pixlo  = uint(tmp_height);
      m_cropinput.dbow_geo.pixhi  = uint(tmp_width);
      }

// **********************************************************************
    // BK 15-Dec-2003
    else if (!strcmp(keyword,"S_DBOW_GEO")) // 1e6*lat_0 [deg], lon_0, height, width [pix]
      {                                               
      // use dbow to store tmp, compute later in crop if not zero
      real8 tmp_lat_0;
      real8 tmp_lon_0;
      real8 tmp_height;
      real8 tmp_width;
      optionsfile >> tmp_lat_0 >> tmp_lon_0 >> tmp_height >> tmp_width;
      writearg(tmp_lat_0);
      writearg(tmp_lon_0);
      writearg(tmp_height);
      writearg(tmp_width);
      s_cropinput.dbow_geo.linelo = uint((360.0+tmp_lat_0)*1e6);
      s_cropinput.dbow_geo.linehi = uint((360.0+tmp_lon_0)*1e6);
      s_cropinput.dbow_geo.pixlo  = uint(tmp_height);
      s_cropinput.dbow_geo.pixhi  = uint(tmp_width);
      }

//____RaffaeleNutricato START MODIFICATION SECTION 9
// *******************************************************************
// *** ?_OVS
// **********************************************************************
    else if (!strcmp(keyword,"M_OVS_OUT"))             // oversampled SLC output image filename
      {                                               
      optionsfile >> m_oversample.fileoutovs;
      writearg(m_oversample.fileoutovs);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S_OVS_OUT"))             // oversampled SLC output image filename
      {                                               
      optionsfile >> s_oversample.fileoutovs;
      writearg(s_oversample.fileoutovs);
      }

// *******************************************************************
    else if (!strcmp(keyword,"M_OVS_FACT_RNG"))               // Oversampling ratio in the master range direction.
      {                                                  
      optionsfile >> m_oversample.OsrRange;               
      writearg(m_oversample.OsrRange);                    
      if (m_oversample.OsrRange < 1)
        {
        PRINT_ERROR(
        "(M_OVS_FACT_RNG < 1) Oversampling ratio must be at least 1.");
        throw(keyword_error);
        }
      }                                                  

// ********************************************************************** 
    else if (!strcmp(keyword,"S_OVS_FACT_RNG"))               // Oversampling ratio in the slave range direction.
      {                                                       
      optionsfile >> s_oversample.OsrRange;               
      writearg(s_oversample.OsrRange);                    
      if (s_oversample.OsrRange < 1)
        {
        PRINT_ERROR(
        "(S_OVS_FACT_RNG < 1) Oversampling ratio must be at least 1.");
        throw(keyword_error);
        }
      }                                                  

// *******************************************************************
    else if (!strcmp(keyword,"M_OVS_FACT_AZI"))               // Oversampling ratio in the master azimuth direction.
      {                                                  
      optionsfile >> m_oversample.OsrAzimuth;               
      writearg(m_oversample.OsrAzimuth);                    
      if (m_oversample.OsrAzimuth < 1)
        {
        PRINT_ERROR(
        "(M_OVS_FACT_AZI < 1) Oversampling ratio must be at least 1.");
        throw(keyword_error);
        }
      if (m_oversample.OsrAzimuth > 1)
        {
        PRINT_ERROR(
        "(M_OVS_FACT_AZI > 1) Not implemented yet!!!");
        throw(keyword_error);
        }
      }                                                  

// ********************************************************************** 
    else if (!strcmp(keyword,"S_OVS_FACT_AZI"))               // Oversampling ratio in the slave azimuth direction.
      {                                                       
      optionsfile >> s_oversample.OsrAzimuth;               
      writearg(s_oversample.OsrAzimuth);                    
      if (s_oversample.OsrAzimuth < 1)
        {
        PRINT_ERROR(
        "(S_OVS_FACT_AZI < 1) Oversampling ratio must be at least 1.");
        throw(keyword_error);
        }
      if (s_oversample.OsrAzimuth > 1)
        {
        PRINT_ERROR(
        "(S_OVS_FACT_AZI > 1) Not implemented yet!!!");
        throw(keyword_error);
        }
      }                                                  

// ********************************************************************** 
    else if (!strcmp(keyword,"M_OVS_KERNELSIZE"))     // Length of the interpolation kernel. 
      {                                                  
      optionsfile >> m_oversample.FilterSize;        
      writearg(m_oversample.FilterSize);             
      if (m_oversample.FilterSize < 2)
        {
        PRINT_ERROR(
        "(M_OVS_KERNELSIZE < 2) Interpolation kernel length must be > 1.");
        throw(keyword_error);
        }
      if (m_oversample.FilterSize % 2)
        {
        PRINT_ERROR(
        "(M_OVS_KERNELSIZE not even) Interpolation kernel length must be an even number.");
        throw(keyword_error);
        }
      }                                                  

// ********************************************************************** 
    else if (!strcmp(keyword,"S_OVS_KERNELSIZE"))     // Length of the interpolation kernel. 
      {                                                  
      optionsfile >> s_oversample.FilterSize;        
      writearg(s_oversample.FilterSize);             
      if (s_oversample.FilterSize < 2)
        {
        PRINT_ERROR(
        "code ???: (S_OVS_KERNELSIZE < 2) Interpolation kernel length must be > 1.");
        throw(keyword_error);
        }
      if (s_oversample.FilterSize % 2)
        {
        PRINT_ERROR(
        "code ???: (S_OVS_KERNELSIZE not even) Interpolation kernel length must be an even number.");
        throw(keyword_error);
        }
      }                                                  

// ********************************************************************** 
    else if (!strcmp(keyword,"M_OVS_OUT_FORMAT"))         // Output format [cr4] ci16, I suggest [cr4].
      {                                                  
      optionsfile >> filename;                           
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"CR4"))
        m_oversample.oformatflag = FORMATCR4;         // default
      else if (!strcmp(filename,"CI2"))
        m_oversample.oformatflag = FORMATCI2;
      else
        {  
        ERROR << "M_OVS_OUT_FORMAT: output format "
             <<  filename
             << " not known for master range oversampling. line "
             << linecnt << ".";
          PRINT_ERROR(ERROR.get_str())      
        throw(keyword_error);
        }             
      }                                                  

// ********************************************************************** 
    else if (!strcmp(keyword,"S_OVS_OUT_FORMAT"))         // Output format [cr4] ci16, I suggest [cr4].
      {                                                  
      optionsfile >> filename;                           
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"CR4"))
        s_oversample.oformatflag = FORMATCR4;         // default
      else if (!strcmp(filename,"CI2"))
        s_oversample.oformatflag = FORMATCI2;
      else
        {  
        ERROR << "S_OVS_OUT_FORMAT: output format "
             <<  filename
             << " not known for slave range oversampling. line "
             << linecnt << ".";
          PRINT_ERROR(ERROR.get_str()) 
        throw(keyword_error);
        }             
      }               
//____RaffaeleNutricato END MODIFICATION SECTION 9


// **********************************************************************
// *** AZIMUTH FILTERING
// **********************************************************************
    else if (!strcmp(keyword,"AF_BLOCKSIZE"))
      {
      optionsfile >> filtaziinput.fftlength;
      writearg(filtaziinput.fftlength);
      }

// **********************************************************************
    else if (!strcmp(keyword,"AF_HAMMING"))
      {
      optionsfile >> filtaziinput.hammingalpha;
      writearg(filtaziinput.hammingalpha);
      }

// **********************************************************************
    else if (!strcmp(keyword,"AF_OVERLAP"))
      {
      optionsfile >> filtaziinput.overlap;
      writearg(filtaziinput.overlap);
      }

// **********************************************************************
    else if (!strcmp(keyword,"AF_OUT_MASTER"))
      {
      optionsfile >> filtaziinput.fomaster;
      writearg(filtaziinput.overlap);
      }

// **********************************************************************
    else if (!strcmp(keyword,"AF_OUT_SLAVE"))
      {
      optionsfile >> filtaziinput.foslave;
      writearg(filtaziinput.overlap);
      }

// **********************************************************************
    else if (!strcmp(keyword,"AF_OUT_FORMAT"))          // output format
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"CR4"))
        filtaziinput.oformatflag = FORMATCR4;         // default
      else if (!strcmp(filename,"CI2"))
        filtaziinput.oformatflag = FORMATCI2;
      else
        {
        ERROR << "AF_OUT_FORMAT: output format "
             <<  filename
             << " not known for azimuth filtering. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }



// **********************************************************************
// *** COARSE CORR COREGISTRATION
// **********************************************************************
    else if (!strcmp(keyword,"CC_METHOD"))            // method selector coarse coreg
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"MAGFFT"))
        coarsecorrinput.method=cc_magfft;             // default
      else if (!strcmp(filename,"MAGSPACE"))
        coarsecorrinput.method=cc_magspace;
      else
        {
        ERROR << "CC_METHOD: method " <<  filename
             << " not known for coarse correlation coregistration on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CC_NWIN"))              // #windows for coarse correlation
      {                                               
      optionsfile >> coarsecorrinput.Nwin;
      writearg(coarsecorrinput.Nwin);
      if (coarsecorrinput.Nwin > 1000)
        {
        PRINT_ERROR(
        "Too many windows requested (CC_NWIN > 1000).")
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CC_IN_POS"))            // file with #windows positions
      {                                               
      optionsfile >> coarsecorrinput.ifpositions;
      writearg(coarsecorrinput.ifpositions);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CC_WINSIZE"))           // windowsize for coarse correlation
      {                                               
      optionsfile >> coarsecorrinput.MasksizeL >> coarsecorrinput.MasksizeP;
      writearg(coarsecorrinput.MasksizeL);
      writearg(coarsecorrinput.MasksizeP);
      if (coarsecorrinput.MasksizeL > 2048 || coarsecorrinput.MasksizeP > 2048)
        {
        PRINT_ERROR(
        "Too large correlation window (CC_WINSIZE > 2048).");
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CC_ACC"))               // Searchdomain for correlation
      {                                               //  coarse correlation
      optionsfile >> coarsecorrinput.AccL >> coarsecorrinput.AccP;
      writearg(coarsecorrinput.AccL);
      writearg(coarsecorrinput.AccP);
      if (coarsecorrinput.AccL > 1000 || coarsecorrinput.AccP > 1000)
        {
        PRINT_ERROR("Too large searchwindow (CC_ACC > 1000).");
        throw(keyword_error);
        }
      if (coarsecorrinput.AccL == 0 || coarsecorrinput.AccP == 0)
        {
        PRINT_ERROR("Acc = 0 ?(CC_ACC).");
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CC_INITOFF"))             // Initial offset
      {
      optionsfile >> keyword >> filename;
      writearg(keyword);
      writearg(filename);
      if (!strcmp(keyword,"ORBIT") ||                   // use value of precise orbits
          !strcmp(keyword,"orbit"))
        {
        coarsecorrinput.initoffsetL = NaN;              // flag used in main
        coarsecorrinput.initoffsetP = NaN;              // flag used in main
        INFO << "CC_INITOFF: \tInitial offsets from COARSEORB: "
             << generalinput.i_resfile;
        INFO.print();
        }
      else if (isdigit(filename[0]) || filename[0]=='-') // likely to be 2 numbers
                                                // BK19/1/00 thanks to m.goos for '-'
        {
        //coarsecorrinput.initoffsetL = atof(keyword);
        //coarsecorrinput.initoffsetP = atof(filename);
        coarsecorrinput.initoffsetL = atoi(keyword);
        coarsecorrinput.initoffsetP = atoi(filename);
        }
      else
        {
        ERROR << "CC_INITOFF: unknown input: "
             <<  keyword << ", " << filename
             << " on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
// *** FINE COREGISTRATION
// **********************************************************************
    else if (!strcmp(keyword,"FC_NWIN"))              // #windows for fine correlation
      {                                               
      optionsfile >> fineinput.Nwin;
      writearg(fineinput.Nwin);
      if (fineinput.Nwin > 10000)
        {
        PRINT_ERROR("Too many windows requested (FC_NWIN).")
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"FC_IN_POS"))            // file with #windows positions
      {                                               
      optionsfile >> fineinput.ifpositions;
      writearg(fineinput.ifpositions);
      }

// **********************************************************************
    else if (!strcmp(keyword,"FC_WINSIZE"))           // windowsize for fine correlation
      {                                               
      optionsfile >> fineinput.MasksizeL >> fineinput.MasksizeP;
      writearg(fineinput.MasksizeL);
      writearg(fineinput.MasksizeP);
      if (fineinput.MasksizeL > 1024 || fineinput.MasksizeP > 1024)
        {
        PRINT_ERROR("Too large correlation window (FC_WINSIZE).")
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"FC_ACC"))               // Searchdomain for correlation
      {                                               //  fine correlation
      optionsfile >> fineinput.AccL >> fineinput.AccP;
      writearg(fineinput.AccL);
      writearg(fineinput.AccP);
      if (fineinput.AccL > 1000 || fineinput.AccP > 1000)
        {
        PRINT_ERROR("Too large searchwindow (FC_ACC).")
        throw(keyword_error);
        }
      if (fineinput.AccL == 0 || fineinput.AccP == 0)
        {
        PRINT_ERROR("Acc = 0 ?(FC_ACC).")
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"FC_INITOFF"))             // Initial offset
      {
      optionsfile >> keyword >> filename;
      writearg(keyword);
      writearg(filename);
      if (!strcmp(keyword,"COARSECORR") ||              // use value of coarse correlation
          !strcmp(keyword,"coarsecorr"))
        {
        fineinput.initoffsetL = NaN;                    // flag used in main
        fineinput.initoffsetP = NaN;                    // flag used in main
        INFO << "FC_INITOFF: \tInitial offset from COARSECORR: "
             << generalinput.i_resfile;
        INFO.print();
        }
      else if (isdigit(filename[0]) || filename[0]=='-') // likely to be 2 numbers
                                                // BK19/1/00 thanks to M.Goos for '-'
        {
        fineinput.initoffsetL = atoi(keyword);
        fineinput.initoffsetP = atoi(filename);
        }
      else
        {
        ERROR << "FC_INITOFF: unknown input: "
             <<  keyword << ", " << filename
             << " on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"FC_METHOD"))            // method selector fine coreg
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"CMPLXFFT"))
        {
        PRINT_ERROR("CMPLXFFT not implemented in v1.0 of Doris.")
        throw(keyword_error);
        }
//        fineinput.method=fc_cmplxfft;                 // default
      else if (!strcmp(filename,"CMPLXSPACE"))
        {
        PRINT_ERROR("CMPLXSPACE not implemented in v1.0 of Doris.")
        throw(keyword_error);
        }
//        fineinput.method=fc_cmplxspace;
      else if (!strcmp(filename,"MAGFFT"))
        fineinput.method=fc_magfft;
      else if (!strcmp(filename,"MAGSPACE"))
        fineinput.method=fc_magspace;
      else if (!strcmp(filename,"OVERSAMPLE"))
        fineinput.method=fc_oversample;
      else
        {
        ERROR << "FC_METHOD: method " <<  filename
             << " not known for fine coregistration on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"FC_OSFACTOR"))          // oversampling factor
      {                                               
      optionsfile >> fineinput.osfactor;
      writearg(fineinput.osfactor);
      }

// **********************************************************************
    else if (!strcmp(keyword,"FC_PLOT"))              // plotting results
      {                                               
      fineinput.plotoffsets = true;
      optionsfile >> fineinput.plotthreshold;
      optionsfile >> filename;
      writearg(fineinput.plotthreshold);
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"BG"))
        fineinput.plotmagbg = true;
      else if (!strcmp(filename,"NOBG"))
        fineinput.plotmagbg = false;
      else if (!strcmp(filename,"ON"))          // actually not allowed...
        fineinput.plotoffsets = true;
      else if (!strcmp(filename,"OFF"))         // actually not allowed...
        fineinput.plotoffsets = false;
      else
        WARNING.print("FC_PLOT: missing argument(s). (default: 0.4 NOBG)");
      }


// **********************************************************************
// *** COMPUTATION OF COREGISTRATION PARAMETERS
// **********************************************************************
    else if (!strcmp(keyword,"CPM_THRESHOLD"))         // treshhold value
      {                                               
      optionsfile >> coregpminput.threshold;
      writearg(coregpminput.threshold);
      if (coregpminput.threshold > 1)
        {
        PRINT_ERROR("CPM_THRESHOLD: threshold > 1.")
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CPM_DEGREE"))           // degree of polynomial
      {                                               
      optionsfile >> coregpminput.degree;
      writearg(coregpminput.degree);
      if (coregpminput.degree > 4)
        WARNING.print("CPM_DEGREE: degree > 4 dangerous at edges?");
      }

// **********************************************************************
    else if (!strcmp(keyword,"CPM_WEIGHT"))           // weightmatrix
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"NONE"))
        coregpminput.weightflag = 0;          // default
      else if (!strcmp(filename,"LINEAR"))
        coregpminput.weightflag = 1;
      else if (!strcmp(filename,"QUADRATIC"))
        coregpminput.weightflag = 2;
      else
        {
        ERROR << "CPM_WEIGHT: data weighting option: "
             <<  filename
             << " not known for computation of coregistration parameters on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CPM_MAXITER"))     // max number of offsets to reject
      {                                               
      optionsfile >> coregpminput.maxiter;
      writearg(coregpminput.maxiter);
      if (coregpminput.maxiter < 0)
        {
        WARNING.print("CPM_MAXITER: max. number of points to remove < 0? (using 0)");
        coregpminput.maxiter = 0;
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CPM_K_ALPHA"))     // critical value for outlier removal
      {                                               
      optionsfile >> coregpminput.k_alpha;
      writearg(coregpminput.k_alpha);
      if (coregpminput.k_alpha < 0)
        {
        WARNING.print("CPM_K_ALPHA: critical value < 0.0?");
        coregpminput.k_alpha = 1.97;
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CPM_DUMP"))               // boolean
      {
      optionsfile >> keyword;
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"OFF")) 
        coregpminput.dumpmodel = false;
      else if (!strcmp(keyword,"ON")    ||
               !strncmp(keyword,"//",2) ||              // comment
               !strncmp(keyword,"#",1)  ||              // comment
               !strcmp(keyword,'\0'))                   // no keyword
        coregpminput.dumpmodel = true;
      else
        {
        WARNING << "CPM_DUMP: line " << linecnt 
             << ": argument: " << keyword 
             << " not recognized, no dumping to files.";
        WARNING.print();
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CPM_PLOT"))           // plotting results
      {                                               
      coregpminput.plot = true;
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"BG"))
        coregpminput.plotmagbg = true;
      else if (!strcmp(filename,"NOBG"))
        coregpminput.plotmagbg = false;
      else if (!strcmp(filename,"ON"))          // actually not allowed...
        coregpminput.plot = true;
      else if (!strcmp(filename,"OFF"))         // actually not allowed...
        coregpminput.plot = false;
      else
        WARNING.print("CPM_PLOT: missing argument. (default NOBG magnitude background)");
      }


// **********************************************************************
// *** RANGE FILTERING
// **********************************************************************
    else if (!strcmp(keyword,"RF_METHOD"))            // method range filtering
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"ADAPTIVE"))
        filtrangeinput.method = rf_adaptive;
      else if (!strcmp(filename,"PORBITS"))
        filtrangeinput.method = rf_porbits;
      else
        {
        ERROR << "RF_METHOD: method "
             <<  filename
             << " not known for range filtering. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_SLOPE"))               // terrain method porbits
      {
      optionsfile >> filtrangeinput.terrainslope;
      writearg(filtrangeinput.terrainslope);
      deg2rad(filtrangeinput.terrainslope);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_THRESHOLD"))           // threshhold value
      {
      optionsfile >> filtrangeinput.SNRthreshold;
      writearg(filtrangeinput.SNRthreshold);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_HAMMING"))             // alpha
      {
      optionsfile >> filtrangeinput.hammingalpha;
      writearg(filtrangeinput.hammingalpha);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_WEIGHTCORR"))          // boolean
      {
      optionsfile >> keyword;
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"OFF")) 
        filtrangeinput.doweightcorrel = false;
      else if (!strcmp(keyword,"ON")    ||
               !strncmp(keyword,"//",2) ||              // comment
               !strncmp(keyword,"#",1)  ||              // comment
               !strcmp(keyword,'\0'))                   // no keyword
        filtrangeinput.doweightcorrel = true;
      else
        {
        filtrangeinput.doweightcorrel = false;          // default already...
        WARNING << "RF_WEIGHTCORREL: line " << linecnt 
             << ": argument: " << keyword 
             << " not recognized, weighting correlation set to OFF.";
        WARNING.print();
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_OVERSAMPLE"))         // int
      {
      optionsfile >> filtrangeinput.oversample;
      writearg(filtrangeinput.oversample);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_NLMEAN"))              // take mean over nlmean lines
      {
      optionsfile >> filtrangeinput.nlmean;
      writearg(filtrangeinput.nlmean);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_FFTLENGTH"))           // adaptive length
      {
      optionsfile >> filtrangeinput.fftlength;
      writearg(filtrangeinput.fftlength);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_OVERLAP"))             // overlap blocks
      {
      optionsfile >> filtrangeinput.overlap;
      writearg(filtrangeinput.overlap);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_OUT_MASTER"))          // filename
      {
      optionsfile >> filtrangeinput.fomaster;
      writearg(filtrangeinput.fomaster);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_OUT_SLAVE"))           // filename
      {
      optionsfile >> filtrangeinput.foslave;
      writearg(filtrangeinput.foslave);
      }

// **********************************************************************
    else if (!strcmp(keyword,"RF_OUT_FORMAT"))          // output format
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"CR4"))
        filtrangeinput.oformatflag = FORMATCR4;         // default
      else if (!strcmp(filename,"CI2"))
        filtrangeinput.oformatflag = FORMATCI2;
      else
        {
        ERROR << "RF_OUT_FORMAT: output format "
             <<  filename
             << " not known for range filtering. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }


// **********************************************************************
// *** FLAT EARTH CORRECTION == compute reference phase since Feb-2000
// **********************************************************************
    else if (!strcmp(keyword,"FE_METHOD"))            // method selector flatearth
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"PORBITS"))
        comprefphainput.method=fe_porbits;
      else if (!strcmp(filename,"METHOD2"))
        comprefphainput.method=fe_method2;
      else
        {
        ERROR << "FE_METHOD: argument: " << filename << " not recognized.";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"FE_DEGREE"))            // degree for flat earth correction
      {                                               
      optionsfile >> comprefphainput.degree;
      writearg(comprefphainput.degree);
      }

// **********************************************************************
    else if (!strcmp(keyword,"FE_NPOINTS"))           // number of points used 
      {                                               //  for estimation of polynomial
      optionsfile >> comprefphainput.Npoints;          //  flat earth correction.
      writearg(comprefphainput.Npoints);
      }

// **********************************************************************
    else if (!strcmp(keyword,"FE_IN_POS"))            // file with #windows positions
      {                                               
      optionsfile >> comprefphainput.ifpositions;
      writearg(comprefphainput.ifpositions);
      }


// **********************************************************************
// *** RESAMPLING (SLAVE)
// **********************************************************************
    else if (!strcmp(keyword,"RS_METHOD"))            // method selector resampling
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"CC4P"))
        resampleinput.method = rs_cc4p;                       // default
      else if (!strcmp(filename,"CC6P"))
        resampleinput.method = rs_cc6p;
      else if (!strcmp(filename,"TS6P"))
        resampleinput.method = rs_ts6p;
      else if (!strcmp(filename,"TS8P"))
        resampleinput.method = rs_ts8p;
      else if (!strcmp(filename,"TS16P"))
        resampleinput.method = rs_ts16p;
      else if (!strcmp(filename,"KNAB4P"))
        resampleinput.method = rs_knab4p;
      else if (!strcmp(filename,"KNAB6P"))
        resampleinput.method = rs_knab6p;
      else if (!strcmp(filename,"KNAB8P"))
        resampleinput.method = rs_knab8p;
      else if (!strcmp(filename,"KNAB10P"))
        resampleinput.method = rs_knab10p;
      else if (!strcmp(filename,"KNAB16P"))
        resampleinput.method = rs_knab16p;
      else if (!strcmp(filename,"RECT"))
        resampleinput.method = rs_rect;
      else if (!strcmp(filename,"TRI"))
        resampleinput.method = rs_tri;
      else
        {
        ERROR << "RS_METHOD: method "
             <<  filename
             << " not known for resampling. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"RS_DBOW"))              // database output window
      {
      optionsfile >> resampleinput.dbow.linelo
                  >> resampleinput.dbow.linehi
                  >> resampleinput.dbow.pixlo
                  >> resampleinput.dbow.pixhi;
      writearg(resampleinput.dbow.linelo);
      writearg(resampleinput.dbow.linehi);
      writearg(resampleinput.dbow.pixlo);
      writearg(resampleinput.dbow.pixhi);
      if (resampleinput.dbow.linelo <= 0 || 
          resampleinput.dbow.pixlo <= 0 ||
          resampleinput.dbow.linelo  > resampleinput.dbow.linehi ||
          resampleinput.dbow.pixlo > resampleinput.dbow.pixhi)
        {
        ERROR << "code 300: Arguments of RS_DBOW card on line " << linecnt
             << " missing. [RS_DBOW  min_line  max_line  min_pixel  max_pixel].";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"RS_OUT_FILE"))           // name of output file
      {
      switch (priorrs_fileout)
        {
        case true:
          WARNING << "RS_OUT_FILE: line: " << linecnt << ": "
              << "ignored due to prior occurence.";
          WARNING.print();
          break;
        default:
          priorrs_fileout = true;
          optionsfile >> resampleinput.fileout;
          writearg(resampleinput.fileout);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"RS_OUT_FORMAT"))          // output format
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"CR4"))
        resampleinput.oformatflag = FORMATCR4;          // default
      else if (!strcmp(filename,"CI2"))
        resampleinput.oformatflag = FORMATCI2;
      else
        {
        ERROR << "RS_OUT_FORMAT: output format "
             <<  filename
             << " not known for resampling. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"RS_SHIFTAZI"))            // true: shift before rs.
      {
      optionsfile >> keyword;
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"ON"))
        resampleinput.shiftazi = true;
      else if (!strcmp(keyword,"OFF")   ||
               !strncmp(keyword,"//",2) ||              // comment
               !strncmp(keyword,"#",1)  ||              // comment
               !strcmp(keyword,'\0'))                   // no keyword
        resampleinput.shiftazi = false;
      else
        {
        resampleinput.shiftazi = true;
        WARNING << "RS_SHIFTAZI: line: " << linecnt << ": unknown argument: "
             << keyword << "; Set to ON (do shift azimuth spectrum).";
        WARNING.print();
        }
      }


// **********************************************************************
// *** COMPUTATION OF INTERFEROGRAM
// **********************************************************************
    else if (!strcmp(keyword,"INT_METHOD"))            // method selector interfero
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"OLD"))
        interferoinput.method = int_oldmethod;
      else if (!strcmp(filename,"OVERSAMPLE"))
        interferoinput.method = int_oversample;
      else
        {
        ERROR << "INT_METHOD: method "
             <<  filename
             << " not known for interfero. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"INT_OUT_INT"))           // name of output file
      {
      optionsfile >> interferoinput.foint;
      writearg(interferoinput.foint);
      }

// **********************************************************************
    else if (!strcmp(keyword,"INT_OUT_CINT"))          // name of output file
      {
      optionsfile >> interferoinput.focint;
      writearg(interferoinput.focint);
      }

// **********************************************************************
//    else if (!strcmp(keyword,"INT_OUT_FE"))         // name of output file
//      optionsfile >> interferoinput.foflatearth;

// **********************************************************************
    else if (!strcmp(keyword,"INT_MULTILOOK"))        // multilookfactors
      {
      optionsfile >> interferoinput.multilookL >> interferoinput.multilookP;
      writearg(interferoinput.multilookL);
      writearg(interferoinput.multilookP);
      }

// **********************************************************************
// *** COMPUTATION OF COHERENCE
// **********************************************************************
    else if (!strcmp(keyword,"COH_METHOD"))            // method selector coherence
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"OLD"))
        coherenceinput.method = coh_oldmethod;
      else if (!strcmp(filename,"NEW"))
        coherenceinput.method = coh_newmethod;
      else
        {
        ERROR << "COH_METHOD: method "
             <<  filename
             << " not known for coherence. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"COH_OUT_COH"))          // name of output file
      {
      optionsfile >> coherenceinput.focoh;
      writearg(coherenceinput.focoh);
      }

// **********************************************************************
    else if (!strcmp(keyword,"COH_OUT_CCOH"))          // name of output file
      {
      optionsfile >> coherenceinput.foccoh;
      writearg(coherenceinput.foccoh);
      }

// **********************************************************************
    else if (!strcmp(keyword,"COH_MULTILOOK"))        // multilookfactors
      {
      optionsfile >> coherenceinput.multilookL >> coherenceinput.multilookP;
      writearg(coherenceinput.multilookL);
      writearg(coherenceinput.multilookP);
      }

// **********************************************************************
    else if (!strcmp(keyword,"COH_WINSIZE"))          // estimator winsize
      {
      optionsfile >> coherenceinput.cohsizeL >> coherenceinput.cohsizeP;
      writearg(coherenceinput.cohsizeL);
      writearg(coherenceinput.cohsizeP);
      }

// **********************************************************************
// *** SUBTRACTION OF REFERENCE PHASE
// **********************************************************************
    else if (!strcmp(keyword,"SRP_METHOD"))           // method selector ref. phase
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"POLYNOMIAL"))
        subtrrefphainput.method = srp_polynomial;
      else if (!strcmp(filename,"EXACT"))
        subtrrefphainput.method = srp_exact;
      else
        {
        ERROR << "SRP_METHOD: method "
             <<  filename
             << " not known for subtraction of ref. phase. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"SRP_OUT_CINT"))          // name of output file
      {
      optionsfile >> subtrrefphainput.focint;
      writearg(subtrrefphainput.focint);
      }

// **********************************************************************
    else if (!strcmp(keyword,"SRP_OUT_REFPHA"))       // name of output file
      {
      optionsfile >> subtrrefphainput.forefpha;
      writearg(subtrrefphainput.forefpha);
      }

// **********************************************************************
    else if (!strcmp(keyword,"SRP_DUMPREFPHA"))      // true: dump ref.pha
      {
      optionsfile >> keyword;
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"ON"))
        subtrrefphainput.dumponlyrefpha = true;
      else if (!strcmp(keyword,"OFF")   ||
               !strncmp(keyword,"//",2) ||              // comment
               !strncmp(keyword,"#",1)  ||              // comment
               !strcmp(keyword,'\0'))                   // no keyword
        subtrrefphainput.dumponlyrefpha = false;
      else
        {
        subtrrefphainput.dumponlyrefpha = false;
        WARNING << "SRP_DUMPREFPHA: line: " << linecnt << ": unknown argument: "
             << keyword << "; Set to OFF (no dump).";
        WARNING.print();
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"SRP_MULTILOOK"))        // multilookfactors
      {
      optionsfile >> subtrrefphainput.multilookL >> keyword;
      writearg(subtrrefphainput.multilookL);
      writearg(keyword);
      if (isdigit(keyword[0]))
        subtrrefphainput.multilookP = atoi(keyword);
      else                                              // default same factor
        subtrrefphainput.multilookP = subtrrefphainput.multilookL;
      }

// **********************************************************************
// *** PHASE FILTER
// **********************************************************************
    else if (!strcmp(keyword,"PF_METHOD"))           // method selector phase filtering
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"GOLDSTEIN"))
        filtphaseinput.method = fp_goldstein;
      else if (!strcmp(filename,"SPATIALCONV"))
        filtphaseinput.method = fp_spatialconv;
      else if (!strcmp(filename,"SPECTRAL"))
        filtphaseinput.method = fp_spectral;
      else
        {
        ERROR << "PF_METHOD: method "
             <<  filename
             << " not known for phase filtering. line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"PF_OUT_FILE"))          // filename
      {
      optionsfile >> filtphaseinput.fofiltphase;
      writearg(filtphaseinput.fofiltphase);
      }

// **********************************************************************
    else if (!strcmp(keyword,"PF_IN_FILE"))           // filename
      {
      optionsfile >> filtphaseinput.fifiltphase >> filtphaseinput.finumlines;
      writearg(filtphaseinput.fifiltphase);
      writearg(filtphaseinput.finumlines);
      }

// **********************************************************************
    else if (!strcmp(keyword,"PF_BLOCKSIZE"))         // buffersize
      {
      optionsfile >> filtphaseinput.blocksize;
      writearg(filtphaseinput.blocksize);
      }

// **********************************************************************
    else if (!strcmp(keyword,"PF_ALPHA"))             // alpha
      {
      optionsfile >> filtphaseinput.alpha;
      writearg(filtphaseinput.alpha);
      }

// **********************************************************************
    else if (!strcmp(keyword,"PF_OVERLAP"))           // overlap
      {
      optionsfile >> filtphaseinput.overlap;
      writearg(filtphaseinput.overlap);
      }

// **********************************************************************
    else if (!strcmp(keyword,"PF_KERNEL"))            // conv. kernel e.g. 3 1 1 1
      {
      optionsfile >> keyword;
      const int32 sizekernel = atoi(keyword);
      writearg(sizekernel);
      if (!(isodd(sizekernel)))
        {
        PRINT_ERROR("PF_KERNEL: size must be odd! (add 0, center around midpix)")
        throw(keyword_error);
        }
      filtphaseinput.kernel.resize(1,sizekernel);
      real4 sum=0.;
      for (int32 argnum=0; argnum<sizekernel; ++argnum)
        {
        optionsfile >> keyword;
        if (!(isdigit(keyword[0])))
          WARNING.print("kernel seems to be wrong?");
        const real4 in = atof(keyword);
        writearg(in);
        filtphaseinput.kernel(0,argnum) = in;
        sum += abs(in);                                 // kernel -1 1
        }
      if (sum!=1)
        filtphaseinput.kernel /= sum;                   // normalize
      INFO << "PF_KERNEL: Input kernel normalized by: " <<  sum;
      INFO.print();
      }

// **********************************************************************
    else if (!strcmp(keyword,"PF_IN_KERNEL2D"))       // filename for ascii 2d kernel
      {
      optionsfile >> filtphaseinput.fikernel2d;
      writearg(filtphaseinput.fikernel2d);
      }

// *******************************************************************
// *** DINSAR
// *******************************************************************
    else if (!strcmp(keyword,"DI_OUT_FILE"))            // output filename
      {                                               
      optionsfile >> dinsarinput.fodinsar;
      writearg(dinsarinput.fodinsar);
      }

    else if (!strcmp(keyword,"DI_OUT_SCALED"))          // output filename
      {                                               
      optionsfile >> dinsarinput.foscaleduint;
      writearg(dinsarinput.foscaleduint);
      }

    else if (!strcmp(keyword,"DI_IN_TOPOMASTER"))       // input resultfilename
      {                                               
      optionsfile >> dinsarinput.topomasterresfile;
      writearg(dinsarinput.fodinsar);
      }

    else if (!strcmp(keyword,"DI_IN_TOPOSLAVE"))        // input resultfilename
      {                                               
      optionsfile >> dinsarinput.toposlaveresfile;
      writearg(dinsarinput.fodinsar);
      }

    else if (!strcmp(keyword,"DI_IN_TOPOINT"))          // input resultfilename
      {                                               
      optionsfile >> dinsarinput.topointresfile;
      writearg(dinsarinput.fodinsar);
      }


// **********************************************************************
// *** COMPUTATION OF REFERENCE DEM (phase)
// **********************************************************************
    else if (!strcmp(keyword,"CRD_METHOD"))          // name of output file
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"TRILINEAR") || !strcmp(filename,"TRI_LINEAR") ||
          !strcmp(filename,"TRILIN") || !strcmp(filename,"TRI_LIN"))
        comprefdeminput.method = crd_trilinear;
      else if (!strcmp(filename,"NN") || !strcmp(filename,"NEAREST") ||
               !strcmp(filename,"NEAREST_NEIGHBOR" ))
        comprefdeminput.method = crd_nearest;
      else
        {
        ERROR << "CRD_METHOD: "
             <<  filename
             << " not known (use TRILINEAR or NEAREST); line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_IN_DEM"))          // input file
      {
      optionsfile >> comprefdeminput.firefdem;
      writearg(comprefdeminput.firefdem);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_IN_FORMAT"))       //  format input file
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"R4") || !strcmp(filename,"REAL4"))
        comprefdeminput.iformatflag = FORMATR4;
      else if (!strcmp(filename,"I2") || !strcmp(filename,"SHORT"))
        comprefdeminput.iformatflag = FORMATI2; // default
      else if (!strcmp(filename,"I2_BIGENDIAN") || 
               !strcmp(filename,"SHORT_BIGENDIAN"))
        comprefdeminput.iformatflag = FORMATI2_BIGENDIAN;       // default
      else if (!strcmp(filename,"R8") || !strcmp(filename,"REAL8"))
        comprefdeminput.iformatflag = FORMATR8;
      else
        {
        ERROR << "CRD_IN_FORMAT: input format "
             <<  filename
             << " not known (R4 R8 I2 (native) SHORT_BIGENDIAN); line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_IN_SIZE"))         // nrow ncols (lat lon)
      {
      optionsfile >> comprefdeminput.demrows >> comprefdeminput.demcols;
      writearg(comprefdeminput.demrows);
      writearg(comprefdeminput.demcols);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_IN_DELTA"))        // degrees delta lat lon
      {
      optionsfile >> comprefdeminput.demdeltalat >> keyword;
      writearg(comprefdeminput.demdeltalat);
      writearg(keyword);
      if (isdigit(keyword[0]) || keyword[0]=='.')    // likely to be 2 numbers
        comprefdeminput.demdeltalon = atof(keyword);
      else // default same gridsize
        comprefdeminput.demdeltalon = comprefdeminput.demdeltalat;

      // ______ Store as radians ______
      comprefdeminput.demdeltalat = deg2rad(comprefdeminput.demdeltalat);
      comprefdeminput.demdeltalon = deg2rad(comprefdeminput.demdeltalon);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_IN_UL"))           // upperleft coordinates
      {
      optionsfile >> comprefdeminput.demlatleftupper
                  >> comprefdeminput.demlonleftupper;
      writearg(comprefdeminput.demlatleftupper);
      writearg(comprefdeminput.demlonleftupper);
      comprefdeminput.demlatleftupper = deg2rad(comprefdeminput.demlatleftupper);
      comprefdeminput.demlonleftupper = deg2rad(comprefdeminput.demlonleftupper);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_IN_NODATA"))       // flag for no data
      {
      optionsfile >> comprefdeminput.demnodata;
      writearg(comprefdeminput.demnodata);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_INCLUDE_FE"))      // true: ref.pha incl. flat earth
      {
      optionsfile >> keyword;
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"OFF"))
        comprefdeminput.includerefpha = false;
      else if (!strcmp(keyword,"ON")    ||
               !strncmp(keyword,"//",2) ||              // comment
               !strncmp(keyword,"#",1)  ||              // comment
               !strcmp(keyword,'\0'))                   // no keyword
        comprefdeminput.includerefpha = true;
      else
        {
        comprefdeminput.includerefpha = false;
        WARNING << "CRD_INCLUDE_FE: line: " << linecnt << ": unknown argument: "
             << keyword 
             << "; Set to OFF (computing pure topo phase w.r.t. flat earth).";
        WARNING.print();
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_DENSE"))              // factor
      {
      optionsfile >> comprefdeminput.extradense;
      writearg(comprefdeminput.extradense);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_OUT_DEM"))          // name of output file
      {
      optionsfile >> comprefdeminput.fodem;
      writearg(comprefdeminput.fodem);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_OUT_DEMI"))          // name of output file
      {
      optionsfile >> comprefdeminput.fodemi;
      writearg(comprefdeminput.fodemi);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_OUT_FILE"))          // name of output file
      {
      optionsfile >> comprefdeminput.forefdem;
      writearg(comprefdeminput.forefdem);
      }

// **********************************************************************
    else if (!strcmp(keyword,"CRD_OUT_DEM_LP"))        // name of output file
      {
      optionsfile >> comprefdeminput.forefdemhei;
      writearg(comprefdeminput.forefdemhei);
      }


// **********************************************************************
// *** SUBTRACTION OF REFERENCE DEM (phase)
// **********************************************************************
    else if (!strcmp(keyword,"SRD_OUT_CINT"))          // name of output file
      {
      optionsfile >> subtrrefdeminput.focint;
      writearg(subtrrefdeminput.focint);
      }

// **********************************************************************
    else if (!strcmp(keyword,"SRD_OFFSET"))          // Line Pixel
      {
      optionsfile >> subtrrefdeminput.offsetL >> subtrrefdeminput.offsetP;
      writearg(subtrrefdeminput.offsetL);
      writearg(subtrrefdeminput.offsetP);
      }

//  // **********************************************************************
//  // *** ADDITION OF REFERENCE DEM (phase)
//  // **********************************************************************
//      else if (!strcmp(keyword,"ARD_OUT_CINT"))          // name of output file
//        {
//        optionsfile >> addrefdeminput.focint;
//        }

// **********************************************************************
// *** UNWRAPPING
// **********************************************************************
    else if (!strcmp(keyword,"UW_METHOD"))  // method selector unwrapping
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"RAMON"))
        unwrapinput.method = uw_method1;
      else if (!strcmp(filename,"SNAPHU"))
        unwrapinput.method = uw_method2;//   default
      else if (!strcmp(filename,"MCF_DLR"))
        unwrapinput.method = uw_method3;
      else
        {
        ERROR << "UW_METHOD: method "
             <<  filename
             << " not known for unwrapping on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_SEEDS"))             // position of seeds
      {
      optionsfile >> filename;
      writearg(filename);
      if (isdigit(filename[0]))
        {
        unwrapinput.deltaLseed = atoi(filename);
        optionsfile >> filename;
        writearg(filename);
        if (isdigit(filename[0]))
          unwrapinput.deltaPseed = atoi(filename);
        else
          unwrapinput.deltaPseed = unwrapinput.deltaLseed;
        }
      else      // assume no numbers but filename with seeds
        {
        strcpy(unwrapinput.seedfile,filename);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_OUT_FILE"))          // filename output unwrapped int.
      {
      optionsfile >> unwrapinput.fouint;
      writearg(unwrapinput.fouint);
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_OUT_FORMAT"))       // output format
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"R4") || !strcmp(filename,"REAL4"))
        unwrapinput.oformatflag = FORMATR4;
      else if (!strcmp(filename,"CR4") || !strcmp(filename,"COMPLEXR4"))
        {
        WARNING.print("UW_OUT_FORMAT = CR4 --> Using hgt format");
        unwrapinput.oformatflag = FORMATHGT;// default
        }
      else if (!strcmp(filename,"HGT"))
        unwrapinput.oformatflag = FORMATHGT;// default
      else
        {
        unwrapinput.oformatflag = FORMATHGT;// default
        WARNING << "UW_OUT_FORMAT: output format "
             <<  filename
             << " not known (R4 or HGT, using HGT); line "
             << linecnt << ".";
        WARNING.print();
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_OUT_REGIONS"))       // filename output regions
      {
      optionsfile >> unwrapinput.foregions;
      writearg(unwrapinput.foregions);
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_SNAPHU_MODE"))       // filename output regions
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"TOPO"))
        strcpy(unwrapinput.snaphu_mode,"TOPO");        // default TOPO
      else if (!strcmp(filename,"DEFO"))
        strcpy(unwrapinput.snaphu_mode,"DEFO");
      else if (!strcmp(filename,"SMOOTH"))
        strcpy(unwrapinput.snaphu_mode,"SMOOTH");
      else if (!strcmp(filename,"NOSTATCOSTS"))
        strcpy(unwrapinput.snaphu_mode,"NOSTATCOSTS");
      else
        {
        ERROR << "UW_SNAPHU_MODE: "
             <<  filename
             << " not known for unwrapping on line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_SNAPHU_INIT"))
      {
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"MST"))
        strcpy(unwrapinput.snaphu_init,"MST");     // default mst
      else if (!strcmp(filename,"MCF"))
        strcpy(unwrapinput.snaphu_init,"MCF");
      else
        {
        WARNING << "UW_SNAPHU_INIT: "
             <<  filename
             << " not known for unwrapping on line "
             << linecnt << " (using MST).";
        WARNING.print();
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_SNAPHU_LOG"))
      {
      optionsfile >> unwrapinput.snaphu_log;
      writearg(unwrapinput.snaphu_log);
      //strcpy(unwrapinput.snaphu_log,"-l ");
      //optionsfile >> filename;
      //writearg(filename);
      //strcat(unwrapinput.snaphu_log,filename);
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_SNAPHU_COH"))
      {
      optionsfile >> unwrapinput.snaphu_coh;
      writearg(unwrapinput.snaphu_coh);
      }

// **********************************************************************
    else if (!strcmp(keyword,"UW_SNAPHU_VERBOSE"))
      {
      optionsfile >> keyword;
      writearg(keyword);
      toupper(keyword);
      if (!strcmp(keyword,"OFF"))
        strcpy(unwrapinput.snaphu_verbose,"FALSE");
      else if (!strcmp(keyword,"ON")    ||
               !strncmp(keyword,"//",2) ||              // comment
               !strncmp(keyword,"#",1)  ||              // comment
               !strcmp(keyword,'\0'))                   // no keyword
        strcpy(unwrapinput.snaphu_verbose,"TRUE");
      else
        {
        strcpy(unwrapinput.snaphu_verbose,"TRUE");
        WARNING << "UW_SNAPHU_VERBOSE: line: " 
             << linecnt << ": unknown argument: " << keyword 
             << "; Set to ON.";
        WARNING.print();
        }
      }

// **********************************************************************
// *** SLANT to HEIGHT CONVERSION
// **********************************************************************
    else if (!strcmp(keyword,"S2H_METHOD"))           // method selector slant2height
      {                                               
      optionsfile >> filename;
      writearg(filename);
      toupper(filename);
      if (!strcmp(filename,"SCHWABISCH"))
        slant2hinput.method = s2h_schwabisch;
      else if (!strcmp(filename,"AMBIGUITY"))
        slant2hinput.method = s2h_ambiguity;
      else if (!strcmp(filename,"RODRIGUEZ"))
        slant2hinput.method = s2h_rodriguez;
      else
        {
        ERROR << "S2H_METHOD: method "
             <<  filename
             << " not known for slant to height conversion, line "
             << linecnt << ".";
        PRINT_ERROR(ERROR.get_str())
        throw(keyword_error);
        }
      }

// **********************************************************************
    else if (!strcmp(keyword,"S2H_NPOINTS"))          // number of points to use
      {
      optionsfile >> slant2hinput.Npoints;
      writearg(slant2hinput.Npoints);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S2H_DEGREE1D"))         // degree of 1d polynomial
      {
      optionsfile >> slant2hinput.degree1d;
      writearg(slant2hinput.degree1d);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S2H_DEGREE2D"))          // degree of 2d polynomial
      {
      optionsfile >> slant2hinput.degree2d;
      writearg(slant2hinput.degree2d);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S2H_NHEIGHTS"))         // #heights to evaluate ref.pha
      {
      optionsfile >> slant2hinput.Nheights;
      writearg(slant2hinput.Nheights);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S2H_OUT_HEI"))          // filename output height
      {
      optionsfile >> slant2hinput.fohei;
      writearg(slant2hinput.fohei);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S2H_OUT_PHI"))          // filename output latitude
      {
      optionsfile >> slant2hinput.fophi;
      writearg(slant2hinput.fophi);
      }

// **********************************************************************
    else if (!strcmp(keyword,"S2H_OUT_LAM"))          // filename output longitude
      {
      optionsfile >> slant2hinput.folam;
      writearg(slant2hinput.folam);
      }

// **********************************************************************
// *** GEOCODING
// **********************************************************************
//      else if (!strcmp(keyword,"GEO_METHOD"))
//        {
//        optionsfile >> geocodeinput.method;
//        }

// **********************************************************************
    else if (!strcmp(keyword,"GEO_OUT_PHI"))          // output file latitude
      {
      optionsfile >> geocodeinput.fophi;
      writearg(geocodeinput.fophi);
      }

// **********************************************************************
    else if (!strcmp(keyword,"GEO_OUT_LAM"))          // output file longitude
      {
      optionsfile >> geocodeinput.folam;
      writearg(geocodeinput.folam);
      }


// **********************************************************************
// Assume wrong keyword, but if it starts with //, a c, or comment
// then continue with a warning, no blank between key and arg
// **********************************************************************
    else if (!strncmp(keyword,"COMMENT",7) ||   // assume user wanted to comment out
             !strncmp(keyword,"C",1))           // but forgot a space
      {
      WARNING << "Unknown keyword: \"" << keyword 
           << "\" at line: " << linecnt
           << ". (Interpreted as comment, ignored)";
      WARNING.print();
      }
    // ______ Really cannot make anything from your input ______
    else
      {
      ERROR << "Unknown keyword: \"" << keyword 
           << "\" at line: " << linecnt << ".";
      PRINT_ERROR(ERROR.get_str())
      throw(keyword_error);
      }
    optionsfile.getline(dummyline,ONE27,'\n');          // goto next line
    } // end while (file)






// ====== Check input/ info to screen ======
  checkgeneral(generalinput, onlyprocess);              // also repair onlyprocess
  INFO << "LISTINPUT: \tAppend input to logfile: \t" << listinput;
  INFO.print();


// ______ info ELLIPSOID card, compute and fill e2, e2b ______
  ellipsinput.ecc1st_sqr();
  ellipsinput.ecc2nd_sqr();
  INFO << "ELLIPSOID: \tEllipsoid used (orbit, output): "
       << ellipsinput.name << ".";
  INFO.print();
  INFO << "ELLIPSOID: a   = " << setw(15) << setprecision(10) << ellipsinput.a;
  INFO.print();
  INFO << "ELLIPSOID: b   = " << setw(15) << setprecision(10) << ellipsinput.b;
  INFO.print();
  INFO << "ELLIPSOID: e2  = " << ellipsinput.e2;
  INFO.print();
  INFO << "ELLIPSOID: e2' = " << ellipsinput.e2b;
  INFO.print();
  INFO.reset();


// ====== Check input of step reading info from files ======
  if (generalinput.process[pr_m_readfiles])
    checkreadfiles(m_readfilesinput, MASTERID);         // check mandatory cards

  if (generalinput.process[pr_s_readfiles])
    checkreadfiles(s_readfilesinput, SLAVEID);          // check mandatory cards


// ====== Check input of step conversion slc to raw ======
  if (generalinput.process[pr_m_crop])
    {
    checkcrop(m_cropinput, MASTERID);
    if (!strcmp(s_cropinput.fileout1,m_cropinput.fileout1))
      {
      PRINT_ERROR(
      "code 301: same name outputfile CROP_OUT for master and slave not allowed.")
      throw(keyword_error);
      }
    if (generalinput.overwrit)
      if (existed(m_cropinput.fileout1))
        {
        INFO << "OVERWRIT: file " << m_cropinput.fileout1 
             << " will be overwritten.";
        INFO.print();
        }
    }

  if (generalinput.process[pr_s_crop])
    {
    checkcrop(s_cropinput, SLAVEID);
    if (!strcmp(s_cropinput.fileout1,m_cropinput.fileout1))
      {
      PRINT_ERROR(
      "code 301: same name outputfile CROP_OUT for master and slave not allowed.")
      throw(keyword_error);
      }
    if (generalinput.overwrit)
      if (existed(s_cropinput.fileout1))
        {
        INFO << "OVERWRIT: file " << s_cropinput.fileout1 
             << " will be overwritten.";
        INFO.print();
        }
    }

//____RaffaeleNutricato START MODIFICATION SECTION 10
// ====== Check input of step oversample master======
  if (generalinput.process[pr_m_oversample])
    {
    checkoversample(m_oversample, MASTERID);
    }
// ====== Check input of step oversampling slave ======
  if (generalinput.process[pr_s_oversample])
    {
    checkoversample(s_oversample, SLAVEID);
    }
//____RaffaeleNutricato END MODIFICATION SECTION 10


// ====== Check input of step porbits ======
  if (generalinput.process[pr_m_porbits])
    checkporbits(porbitsinput, MASTERID);
  if (generalinput.process[pr_s_porbits])
    checkporbits(porbitsinput, SLAVEID);

// ====== Check input of step azimuth filtering ======
  if (generalinput.process[pr_m_filtazi] ||
      generalinput.process[pr_s_filtazi])
    {
    // ______ Set defaults ______
    if (filtaziinput.overlap == -1)
      filtaziinput.overlap = filtaziinput.fftlength/8;  // default
    // ______ Check input ______
    if (generalinput.process[pr_m_filtazi] &&
        generalinput.process[pr_s_filtazi])
      checkfiltazi(filtaziinput,MASTERID+SLAVEID);
    else if (generalinput.process[pr_m_filtazi])
      checkfiltazi(filtaziinput,MASTERID);
    else if (generalinput.process[pr_s_filtazi])
      checkfiltazi(filtaziinput,SLAVEID);
    else 
      {
      PRINT_ERROR("PANIC, this cannot be")
      throw(keyword_error);
      }
    }

// ====== Check input of step range filtering ======
  if (generalinput.process[pr_m_filtrange])
    {
    // ______ Check defaults ______
    if (filtrangeinput.fftlength==-999) // not specified
      {
      if (filtrangeinput.method==rf_adaptive)
        filtrangeinput.fftlength=64;            // default
      else if (filtrangeinput.method==rf_porbits)
        filtrangeinput.fftlength=1024;          // default
      }
    checkfiltrange(filtrangeinput);
    }

// ====== Check input of reserved EXTRA step master/slave ======
  if (generalinput.process[pr_m_EXTRA])
    {
    PRINT_ERROR("extra step master not implemented.")
    throw(keyword_error);
    }
  if (generalinput.process[pr_s_EXTRA])
    {
    PRINT_ERROR("extra step slave not implemented.")
    throw(keyword_error);
    }

// ====== Check input of step coarse (orbits) ======
// ______ no checks required. (no cards as well)
  if (generalinput.process[pr_i_coarse])
    {
    ; // do nothing
    }


// ====== Check coarse coregistration based on correlation ======
// ______ Check + repair method selector coarse correlation ______
  if (generalinput.process[pr_i_coarse2])               // correlation
    {
    if (coarsecorrinput.method == def_cc_method-999) // see at defaults, no method card used
      {
      coarsecorrinput.method = def_cc_method;           // default method
      INFO.print("Default method will be used for coarse coregistration.");
      }
    if (specified(coarsecorrinput.ifpositions))         // filename specified
      {
      if (coarsecorrinput.Nwin != def_cc_nwin+999)      // something is specified
        {
        WARNING << "CC_NWIN: \t" << coarsecorrinput.Nwin
             << " ignored due to existence of input file (CC_IN_POS) "
             << coarsecorrinput.ifpositions;
        WARNING.print();
        }
      coarsecorrinput.Nwin = filelines(coarsecorrinput.ifpositions);
      }
    else if (coarsecorrinput.Nwin == def_cc_nwin+999)   // no inputfile, default
      {
      coarsecorrinput.Nwin = def_cc_nwin;
      INFO.print("Default number of windows will be used for coarse coregistration.");
      }
    checkcoarsecorr(coarsecorrinput);
    }


// ====== Check input of step fine ======
  if (generalinput.process[pr_i_fine])
    {
    if (fineinput.method == def_fc_method-999)  // see at defaults, no method card used
      {
      fineinput.method = def_fc_method;         // default method
      INFO.print("Default method will be used for fine coregistration.");
      }
    if (specified(fineinput.ifpositions))         // filename specified
      {
      if (fineinput.Nwin != def_fc_nwin+999)    // something is specified
        {
        WARNING << "FC_NWIN: \t" << fineinput.Nwin
             << " ignored due to existence of input file (FC_IN_POS) "
             << fineinput.ifpositions;
        WARNING.print();
        }
      fineinput.Nwin = filelines(fineinput.ifpositions);
      }
    else if (fineinput.Nwin == def_fc_nwin+999) // no inputfile, default
      {
      fineinput.Nwin = def_fc_nwin;
      INFO.print("Default number of windows will be used for fine coregistration.");
      }
    checkfine(fineinput);
    }


  // ====== Check input step coregpm ======
  if (generalinput.process[pr_i_coregpm])
    {
    checkcoregpm(coregpminput);
    }

  // ====== Check + repair method selector resampling ======
  if (generalinput.process[pr_s_resample])              // request for process resample
    {
    if (resampleinput.method == def_rs_method-999)      // see at defaults, no method card used
      {
      resampleinput.method = def_rs_method;             // default method
      INFO.print("RS_METHOD: Using default.");
      }
    if (!priorrs_fileout)
      INFO.print("RS_OUT_FILE: Using default.");
    checkresample(resampleinput);
    }

  // ====== Check + repair method selector flatearth correction ======
  if (generalinput.process[pr_i_comprefpha])
    {
    if (comprefphainput.method == def_fe_method-999)     // see at defaults, no method card used
      {
      comprefphainput.method = def_fe_method;            // default method
      INFO.print("FE_METHOD: Using default.");
      }
    if (comprefphainput.Npoints == def_fe_Npoints-999)   // default applies
      {
      comprefphainput.Npoints = def_fe_Npoints;          // default value
      // INFO.print("FE_NPOINTS: Using default.");
      }
    // ______ if read from file, count number of points ______
    if (specified(comprefphainput.ifpositions))         // filename specified
      {
      INFO.print("FE_IN_POS: Using file to read positions.");
      comprefphainput.Npoints = filelines(comprefphainput.ifpositions);
      }
    if (comprefphainput.degree == def_fe_degree-999)     // default
      {
      comprefphainput.degree = def_fe_degree;            // default
      INFO.print("FE_DEGREE: Using default.");
      }
    checkcomprefpha(comprefphainput);
    }

  // ====== Check input of step interfero ======
  if (generalinput.process[pr_i_interfero])
    {
    checkinterfero(interferoinput);
    }

  // ====== Check input of SUBTRREFPHA step interferogram ======
  if (generalinput.process[pr_i_subtrrefpha])
    checksubtrrefpha(subtrrefphainput);

  // ====== Check input of COMPREFDEM step interferogram ======
  if (generalinput.process[pr_i_comprefdem])
    {
    checkcomprefdem(comprefdeminput);
    }

  // ====== Check input of SUBTRDEM step interferogram ======
  if (generalinput.process[pr_i_subtrrefdem])
    {
    checksubtrrefdem(subtrrefdeminput);
    }

  // ====== Check input of step coherence ======
  if (generalinput.process[pr_i_coherence])
    {
    checkcoherence(coherenceinput);
    }

  // ====== Check input of step phase filtering ======
  if (generalinput.process[pr_i_filtphase])
    {
    if (!specified(filtphaseinput.fofiltphase))  // not specified, use default
      {
      if (filtphaseinput.method==fp_goldstein)
        {
        char dummy127[ONE27];
        ostrstream omemfo(dummy127,ONE27);
        omemfo << "cint." << filtphaseinput.alpha << "filtered" << ends;
        strcpy(filtphaseinput.fofiltphase,dummy127);
        if (filtphaseinput.kernel.size()==0)
          {
          INFO.print("PF_KERNEL: Using default kernel [1 2 3 2 1].");
          filtphaseinput.kernel.resize(1,5);
          filtphaseinput.kernel(0,0) = 1./9.;
          filtphaseinput.kernel(0,1) = 2./9.;
          filtphaseinput.kernel(0,2) = 3./9.;
          filtphaseinput.kernel(0,3) = 2./9.;
          filtphaseinput.kernel(0,4) = 1./9.;
          }
        }
      else if (filtphaseinput.method==fp_spatialconv)
        {
        strcpy(filtphaseinput.fofiltphase,"cint.filtered");
        // ______ Set default kernel ______
        if (!specified(filtphaseinput.fikernel2d))      // no input file
          {
          if (filtphaseinput.kernel.size()==0)
            {
            INFO.print("PF_KERNEL: Using default kernel [1 1 1].");
            filtphaseinput.kernel.resize(1,3);
            filtphaseinput.kernel(0,0) = 1./3.;
            filtphaseinput.kernel(0,1) = 1./3.;
            filtphaseinput.kernel(0,2) = 1./3.;
            }
          }
        }
      else if (filtphaseinput.method==fp_spectral)
        {
        strcpy(filtphaseinput.fofiltphase,"cint.filtered");
        }
      else
        {
        PRINT_ERROR("Method filtphase not known")
        throw(keyword_error);
        }
      }
    checkfiltphase(filtphaseinput);
    }


  // ====== Check input of step unwrapping ======
  if (generalinput.process[pr_i_unwrap])                 // request for process unwrapping
    {
    if (unwrapinput.method == def_uw_method-999)        // see at defaults, no method card used
      {
      unwrapinput.method = def_uw_method;               // default method
      INFO.print("Default method will be used for unwrapping.");
      }
    checkunwrap(unwrapinput);
    }


  // ====== Check input of step slant2height ======
  if (generalinput.process[pr_i_slant2h])
    {
    if (slant2hinput.method == def_s2h_method-999)
      {
      slant2hinput.method = def_s2h_method;               // default method
      INFO.print("Default method will be used for slant2h.");
      }
    if (slant2hinput.Nheights <= slant2hinput.degree1d)
      {
      WARNING << "S2H_NHEIGHTS: \t" << slant2hinput.Nheights 
           << " is too large because S2H_DEGREE1D="
           << slant2hinput.degree1d 
           << "; set S2H_NHEIGHTS = " << slant2hinput.degree1d+1
           << " (minimum)";
      WARNING.print();
      slant2hinput.Nheights = slant2hinput.degree1d + 1;
      }
    checkslant2h(slant2hinput);
    }


  // ====== Check input of step geocoding ======
  if (generalinput.process[pr_i_geocoding])
    {
    checkgeocode(geocodeinput);
    }

  // ====== Check input of dinsar step interferogram ======
  if (generalinput.process[pr_i_dinsar])
    {
    if (!strcmp(dinsarinput.topomasterresfile,generalinput.m_resfile))
      setunspecified(dinsarinput.topomasterresfile);    // used in check...
    checkdinsar(dinsarinput);
    if (!specified(dinsarinput.topomasterresfile))
      strcpy(dinsarinput.topomasterresfile,generalinput.m_resfile);
    }

  // ====== Check input of reserved EXTRA step interferogram ======
  if (generalinput.process[pr_i_EXTRA2])
    {
    PRINT_ERROR("extra step2 interferogram not implemented.")
    throw(keyword_error);
    }



// ====== Copy input to logfile (via scratchfile, update in main) ======
//   to avoid problems with not existing file it is always opened here
  ofstream scratchreadinput("scratchreadinput", ios::out | ios::trunc);
  bk_assert(scratchreadinput,"readinput: scratchreadinput",__FILE__,__LINE__);

  if (listinput)
    {
    // ______Start writing______
    linecnt=0;
    scratchreadinput << "\n----------------------------------------------------\n"
                     << "      BEGIN: copy of input (non-interpretive).\n"
                     << "-line---keyword----argument-------------comment-----\n";
    optionsfile.seekg(0,ios::beg);
    optionsfile.getline(dummyline,ONE27,'\n');
    while (optionsfile)
      {
      linecnt++;
      scratchreadinput << setw(3) << linecnt << ": " << dummyline << endl;
      optionsfile.getline(dummyline,ONE27,'\n');
      }
    scratchreadinput << "\n----------------------------------------------------\n"
                     << "      END: copy of input.\n"
                     << "----------------------------------------------------\n\n";
    DEBUG.print("Finished writing to scratchreadinput.");
    }

// ______Tidy up______
  PROGRESS.print("Interpretation inputoptionsfile finished.");
  scratchreadinput.close();
  optionsfile.close();
  } // END READINPUT



/****************************************************************
 *    checkgeneral                                              *
 *                                                              *
 * Checks general cards.                                        *
 * Repair process card                                          *
 *                                                              *
 *    Bert Kampes, 06-Sep-1999                                  *
 ****************************************************************/
void checkgeneral(
        input_gen &generalinput,
        const int16 onlyprocess)
  {
  TRACE_FUNCTION("checkgeneral (BK 06-Sep-1999)")
  register int32 i;
  int32 cs_processcard = 0;

// ______ Repair process control if ONLYPROCESS card was present ______
  for (i=0; i<NUMPROCESSES; i++)
    cs_processcard += generalinput.process[i];
  if (onlyprocess != -1)                                     // initialized to -1;
    {
    generalinput.interactive=false;
    INFO.print("ONLYPROCESS card present, batch processing.");
    if (cs_processcard == 1)
      WARNING.print("PROCESS card ignored due to presence ONLYPROCESS card.");
    if (cs_processcard >  1)
      WARNING.print("PROCESS cards ignored due to presence ONLYPROCESS card.");
    for (i=0; i<NUMPROCESSES; i++)                      // do not process anything...
      generalinput.process[i]=0;
    generalinput.process[onlyprocess]=1;                  // exept this one.
    }

  else                                                  // check process card presence
    {
    if (cs_processcard == 0)                            // no cards
      {
      PRINT_ERROR("code 303: No (ONLY)PROCESS card present, exiting.")
      throw(keyword_error);
      }
    }

  INFO.print("\n\t*** General input cards ***");
  INFO << "MEMORY: \tAvailable to Doris [MB]: \t"
       << generalinput.memory/1e6;
  INFO.print();

  INFO << "M_RESFILE: \tResultfile for master: \t\t"
       << generalinput.m_resfile;
  INFO.print();
  INFO << "S_RESFILE: \tResultfile for slave: \t\t"
       << generalinput.s_resfile;
  INFO.print();
  INFO << "I_RESFILE: \tResultfile for products: \t"
       << generalinput.i_resfile;
  INFO.print();
  INFO << "LOGFILE: \tOut file for logging: \t\t"
       << generalinput.logfile;
  INFO.print();
  INFO << "ORB_INTERP: \tmethod selector value:\t\t"
       << generalinput.orb_interp;
  INFO.print();
  INFO << "DUMPBASELINE: evaluation grid for baseline: \t"
       << generalinput.dumpbaselineL << " lines x "
       << generalinput.dumpbaselineP << " pixels: ";
  INFO.print();
  INFO << "HEIGHT: \taverage terrain height:\t\t"
       << generalinput.terrain_height;
  INFO.print();
  INFO << "TIEPOINT: \tlat/lon/hei: "
       << generalinput.tiepoint.x << " " 
       << generalinput.tiepoint.y << " "
       << generalinput.tiepoint.z;
  INFO.print();

  if (!strcmp(generalinput.m_resfile,generalinput.s_resfile))
    {
    PRINT_ERROR("same name master and slave resultfile not allowed.")
    throw(keyword_error);
    }
  if (!strcmp(generalinput.m_resfile,generalinput.i_resfile))
    {
    PRINT_ERROR("same name master and interferogram resultfile not allowed.");
    throw(keyword_error);
    }
  if (!strcmp(generalinput.m_resfile,generalinput.logfile))
    {
    PRINT_ERROR("same name master resultfile and logfile not allowed.");
    throw(keyword_error);
    }
  if (!strcmp(generalinput.i_resfile,generalinput.logfile))
    {
    PRINT_ERROR("same name interferogram resultfile and logfile not allowed.");
    throw(keyword_error);
    }
  } // END checkgeneral


/****************************************************************
 *    checkreadfiles                                            *
 *                                                              *
 * Checks cards for step readfiles.                             *
 *                                                              *
 *    Bert Kampes, 06-Sep-1999                                  *
 ****************************************************************/
void checkreadfiles(
        const input_readfiles &readfilesinput,
        const int16 id)
  {
  TRACE_FUNCTION("checkreadfiles (BK 06-Sep-1999)")
  switch (id)
    {
    case MASTERID:
      INFO.print("\n\t*** Input for step M_READFILES (master) ***");
      INFO << "M_IN_METHOD: \tmethod selected for master: \t\t"
           << readfilesinput.sensor_id;
      INFO.print();
      INFO << "M_IN_VOL:    \tVolumefile of master: \t\t"
           << readfilesinput.volfile;
      INFO.print();
      INFO << "M_IN_LEA:    \tLeaderfile of master: \t\t"
           << readfilesinput.leaderfile;
      INFO.print();
      INFO << "M_IN_NULL:   \tNullfile of master:  \t\t"
           << readfilesinput.nullfile;
      INFO.print();
      INFO << "M_IN_DAT:    \tDatfile of master:    \t\t"
           << readfilesinput.datfile;
      INFO.print();
      if (readfilesinput.sensor_id == SLC_ERS)
        {
        if (!specified(readfilesinput.volfile))
          {
          PRINT_ERROR("M_IN_VOL not defined");
          throw(keyword_error);
          }
        if (!specified(readfilesinput.leaderfile))
          {
          PRINT_ERROR("M_IN_LEA not defined");
          throw(keyword_error);
          }
        if (!specified(readfilesinput.nullfile))
          WARNING.print("M_IN_NULL not defined");
        }
      // ___ use datfile for asar input file ___
      if (!specified(readfilesinput.datfile))
        {
        PRINT_ERROR("M_IN_DAT not defined");
        throw(keyword_error);
        }
      break;

    case SLAVEID:
      INFO.print("\n\t*** Input for step S_READFILES (slave) ***");
      INFO << "S_IN_METHOD: \tmethod selected for slave: \t\t"
           << readfilesinput.sensor_id;
      INFO.print();
      INFO << "S_IN_VOL:    \tvolumefile of slave:  \t\t"
           << readfilesinput.volfile;
      INFO.print();
      INFO << "S_IN_LEA:    \tleaderfile of slave:  \t\t"
           << readfilesinput.leaderfile;
      INFO.print();
      INFO << "S_IN_NULL:   \tnullfile of slave:   \t\t"
           << readfilesinput.nullfile;
      INFO.print();
      INFO << "S_IN_DAT:    \tdatfile of slave:     \t\t"
           << readfilesinput.datfile;
      INFO.print();
      if (readfilesinput.sensor_id == SLC_ERS)
        {
        if (!specified(readfilesinput.volfile))
          {
          PRINT_ERROR("S_IN_VOL not defined");
          throw(keyword_error);
          }
        if (!specified(readfilesinput.leaderfile))
          {
          PRINT_ERROR("S_IN_LEA not defined");
          throw(keyword_error);
          }
        if (!specified(readfilesinput.nullfile))
          WARNING.print("S_IN_NULL not defined");
        }
      // ___ use datfile for asar input file ___
      if (!specified(readfilesinput.datfile))
        {
        PRINT_ERROR("S_IN_DAT not defined");
        throw(keyword_error);
        }
      break;

    default:
      PRINT_ERROR("panic: impossible");
      throw(keyword_error);
    } // switch
  if (readfilesinput.sensor_id == SLC_ERS)
    {
    if (!strcmp(readfilesinput.volfile,readfilesinput.leaderfile))
      {
      PRINT_ERROR("same file name volume and leader file not allowed.");
      throw(keyword_error);
      }
    if (!strcmp(readfilesinput.volfile,readfilesinput.nullfile))
      {
      PRINT_ERROR("same file name volume and null file not allowed.");
      throw(keyword_error);
      }
    if (!strcmp(readfilesinput.volfile,readfilesinput.datfile))
      {
      PRINT_ERROR("same file name volume and data file not allowed.");
      throw(keyword_error);
      }
    if (!strcmp(readfilesinput.leaderfile,readfilesinput.nullfile))
      {
      PRINT_ERROR("same file name leader and null file not allowed.");
      throw(keyword_error);
      }
    if (!strcmp(readfilesinput.leaderfile,readfilesinput.datfile))
      {
      PRINT_ERROR("same file name leader and data file not allowed.");
      throw(keyword_error);
      }
    if (!strcmp(readfilesinput.nullfile,readfilesinput.datfile))
      {
      PRINT_ERROR("same file name null and data file not allowed.");
      throw(keyword_error);
      }
    }
  } // END checkreadfiles


/****************************************************************
 *    checkcrop                                                 *
 *                                                              *
 * Checks cards for step crop.                          *
 *                                                              *
 *    Bert Kampes, 06-Sep-1999                                  *
 ****************************************************************/
void checkcrop(
        const input_crop &cropinput,
        const int16 id)
  {
  TRACE_FUNCTION("checkcrop (BK 06-Sep-1999)")
  switch (id)
    {
    case MASTERID:
      INFO.print("\n\t*** Input for step M_CROP (master) ***");
      INFO << "M_IDCROP: \tidentifier master write slc data to raster format: \t"
           << cropinput.idcrop;
      INFO.print();
      INFO << "M_CROP_IN: \tslc data inputfile for master:   \t"
           << cropinput.filein1;
      INFO.print();
      INFO << "M_CROP_OUT: \traw data outputfile for master: \t"
           << cropinput.fileout1;
      INFO.print();
      INFO << "M_DBOW: \tProcessing master line "
           << cropinput.dbow.linelo << " to "
           << cropinput.dbow.linehi << ". pixel "
           << cropinput.dbow.pixlo << " to "
           << cropinput.dbow.pixhi << ".";
      INFO.print();
      if (cropinput.dbow_geo.pixhi != 0) 
        {
        INFO.print("M_DBOW_GEO: overrides M_DBOW! processing: ");
        INFO << "center latitude " << cropinput.dbow_geo.linelo/1e6-360.0 <<
                "; center longitude " << cropinput.dbow_geo.linehi/1e6-360.0 <<
                "; height, width: " << cropinput.dbow_geo.pixlo << ", " << 
                cropinput.dbow_geo.pixhi;
        INFO.print();
        }
      break;

    case SLAVEID:
      INFO.print("\n\t*** Input for step S_CROP (slave) ***");
      INFO << "S_IDCROP: \tidentifier slave write slc data to raster format: \t"
           << cropinput.idcrop;
      INFO.print();
      INFO << "S_CROP_IN: \tslc data inputfile for slave:   \t"
           << cropinput.filein1;
      INFO.print();
      INFO << "S_CROP_OUT: \traw data outputfile for slave: \t"
           << cropinput.fileout1;
      INFO.print();
      INFO << "S_DBOW: \tProcessing slave line "
           << cropinput.dbow.linelo << " to "
           << cropinput.dbow.linehi << ". pixel "
           << cropinput.dbow.pixlo << " to "
           << cropinput.dbow.pixhi << ".";
      INFO.print();
      if (cropinput.dbow_geo.pixhi != 0) 
        {
        INFO.print("S_DBOW_GEO: overrides S_DBOW! processing: ");
        INFO << "center latitude " << cropinput.dbow_geo.linelo/1e6-360.0 <<
                "; center longitude " << cropinput.dbow_geo.linehi/1e6-360.0 <<
                "; height, width: " << cropinput.dbow_geo.pixlo << ", " << 
                cropinput.dbow_geo.pixhi;
        INFO.print();
        }
      break;

    default:
      PRINT_ERROR("panic: impossible");
      throw(keyword_error);
    }
  } // END checkcrop


//____RaffaeleNutricato START MODIFICATION SECTION 11
/****************************************************************
 *    checkoversample                                           *
 *                                                              *
 * Checks cards for step oversample.                            *
 *                                                              *
 *    Raffaele Nutricato, 12-Jan-2004                           *
 ****************************************************************/
void checkoversample(
        const input_oversample  &oversampleinput,
        const int16 id)
  {
  TRACE_FUNCTION("checkoversample (Raffaele Nutricato 12-Jan-2004)")
  switch (id)
    {
    case MASTERID:
      INFO.print("\n\t*** Input for step M_OVS (master) ***");
      INFO << "M_OVS_OUT: \t\tData output file for ovs master: "
           << oversampleinput.fileoutovs; // Output file for the oversampled master
      INFO.print(); 
      INFO << "M_OVS_FACT_RNG: \tOversampling ratio in the master range direction: "   
           << oversampleinput.OsrRange;  // Oversampling ratio in the range direction.
      INFO.print(); 
      INFO << "M_OVS_FACT_AZI: \tOversampling ratio in the master azimuth direction: "   
           << oversampleinput.OsrAzimuth;  // Oversampling ratio in the azimuth direction.
      INFO.print(); 
      INFO << "M_OVS_KERNELSIZE: \tKernel length for the master oversampling: "   
           << oversampleinput.FilterSize;  // Length of the interpolation kernel in range. 
      INFO.print(); 
      INFO << "M_OVS_OUT_FORMAT: \tOutput data format for the oversampled master: " ;  
      if (oversampleinput.oformatflag==FORMATCR4)
        INFO << "complex_real4";
      if (oversampleinput.oformatflag==FORMATCI2)
        INFO << "complex_short";
      INFO.print();
      break;

    case SLAVEID:
      INFO.print("\n\t*** Input for step S_OVS (slave) ***");
      INFO << "S_OVS_OUT: \t\tData output file for ovs slave: "
           << oversampleinput.fileoutovs; // Output file for the oversampled slave
      INFO.print();
      INFO << "S_OVS_FACT_RNG: \tOversampling ratio in the slave range direction: "   
           << oversampleinput.OsrRange;  // Oversampling ratio in the range direction.
      INFO.print(); 
      INFO << "S_OVS_FACT_AZI: \tOversampling ratio in the slave azimuth direction: "   
           << oversampleinput.OsrAzimuth;  // Oversampling ratio in the azimuth direction.
      INFO.print(); 
      INFO << "S_OVS_KERNELSIZE: \tKernel length for the slave oversampling: "   
           << oversampleinput.FilterSize;  // Length of the interpolation kernel in range. 
      INFO.print(); 
      INFO << "S_OVS_OUT_FORMAT: \tOutput data format for the oversampled slave: " ;  
      if (oversampleinput.oformatflag==FORMATCR4)
        INFO << "complex_real4";
      if (oversampleinput.oformatflag==FORMATCI2)
        INFO << "complex_short";
      INFO.print();
      break;

    default:
      PRINT_ERROR("panic: impossible");
      throw(keyword_error);
    }
  } // END checkoversample

//____RaffaeleNutricato END MODIFICATION SECTION 11


/****************************************************************
 *    checkporbits                                              *
 *                                                              *
 * Checks cards for step porbits.                               *
 *                                                              *
 *    Bert Kampes, 06-Sep-1999                                  *
 ****************************************************************/
void checkporbits(
        const input_pr_orbits &porbitsinput,
        const int16 id)
  {
  TRACE_FUNCTION("checkporbits (BK 06-Sep-1999)")
  switch (id)
    {
    case MASTERID:
      INFO.print("\n\t*** Input for step M_PORBITS (master) ***");
      INFO << "M_ORBDIR: \tPrecise orbits master in: "
           << porbitsinput.m_orbdir;
      INFO.print();
      if (!specified(porbitsinput.m_orbdir))
        {
        PRINT_ERROR("M_ORBDIR: no directory specified.");
        throw(keyword_error);
        }
      break;

    case SLAVEID:
      INFO.print("\n\t*** Input for step S_PORBITS (slave) ***");
      INFO << "S_ORBDIR: \tPrecise orbits slave in: "
           << porbitsinput.s_orbdir;
      INFO.print();
      if (!specified(porbitsinput.s_orbdir))
        {
        PRINT_ERROR("S_ORBDIR: no directory specified.");
        throw(keyword_error);
        }
      break;

    default:
      PRINT_ERROR("panic: impossible");
      throw(keyword_error);
    }
  INFO << "ORB_INTERVAL: \ttime between ephemerides: \t"
       << porbitsinput.timeinterval;
  INFO.print();
  INFO << "ORB_EXTRATIME: \ttime before first, after last line: \t"
       << porbitsinput.timebefore;
  INFO.print();
  if (!porbitsinput.dumpmasterorbit<0)
    INFO.print("dumping masterorbit to file.");
  if (!porbitsinput.dumpslaveorbit<0)
    INFO.print("dumping slaveorbit to file.");
  } // END checkporbits


/****************************************************************
 *    checkslant2h                                              *
 *                                                              *
 * Checks cards for step slant2h.                               *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkslant2h(
        const input_slant2h &slant2hinput)
  {
  TRACE_FUNCTION("checkslant2h (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step SLANT2H ***");
  switch (slant2hinput.method)
    {
    case s2h_schwabisch:
      INFO.print("Method schwabisch is used for slant2height conversion.");

      INFO << "S2H_NPOINTS: \tNumber of points used in computation:   "
           << slant2hinput.Npoints;
      INFO.print();
      INFO << "S2H_DEGREE1D: \tDegree of 1d polynomial at each point: "
           << slant2hinput.degree1d;
      INFO.print();
      INFO << "S2H_DEGREE2D: \tDegree of 2d polynomial to compute     "
           << "coefficients of 1D polynomial: "
           << slant2hinput.degree2d;
      INFO.print();
      INFO << "S2H_NHEIGHTS: \t#heights evaluation ref. phase for 1d polynomial: "
           << slant2hinput.Nheights;
      INFO.print();
      break;

    case s2h_ambiguity:
      INFO.print("Method exact is used for slant2height conversion.");
      INFO << "S2H_OUT_LAM: \tData output file for lambda: "
           << slant2hinput.folam;
      INFO.print();
      INFO << "S2H_OUT_PHI: \tData output file for phi:    "
           << slant2hinput.fophi;
      INFO.print();
      if (!strcmp(slant2hinput.folam,slant2hinput.fophi))
        {
        PRINT_ERROR("Same filename S2H_OUT_LAM and S2H_OUT_PHI not allowed.");
        throw(keyword_error);
        }
      if (!strcmp(slant2hinput.fohei,slant2hinput.fophi))
        {
        PRINT_ERROR("Same filename S2H_OUT_HEI and S2H_OUT_PHI not allowed.");
        throw(keyword_error);
        }
      if (!strcmp(slant2hinput.folam,slant2hinput.fohei))
        {
        PRINT_ERROR("Same filename S2H_OUT_LAM and S2H_OUT_HEI not allowed.");
        throw(keyword_error);
        }
      break;

    case s2h_rodriguez:
      DEBUG.print("do some checks here as well.");
      break;

    default:
      PRINT_ERROR("impossible, unknown method s2h");
      throw(keyword_error);
    }

    INFO << "S2H_OUT_HEI: Data output file for height:   "
         << slant2hinput.fohei;
    INFO.print();
  } // END checkslant2h


/****************************************************************
 *    checkunwrap                                               *
 *                                                              *
 * Checks cards for step unwrap.                                *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkunwrap(
        const input_unwrap &unwrapinput)
  {
  TRACE_FUNCTION("checkunwrap (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step UNWRAP ***");
  INFO << "UW_OUT_FILE: \tOutput data file for unwrapped interferogram: "
       << unwrapinput.fouint;
  INFO.print();
  INFO << "UW_OUT_FORMAT: \tOutput data format for unwrapped interferogram: "
       << unwrapinput.oformatflag;
  INFO.print();
  switch (unwrapinput.method)
    {
    case uw_method1:
      INFO.print("Method 1 is used for unwrapping (treef_ramon unix calls).");
      INFO << "UW_SEEDS: ";
      if (isspace(unwrapinput.seedfile[0]))     // no file specified
        INFO << "Delta seed in line/pixel direction: "
             << unwrapinput.deltaLseed << " " << unwrapinput.deltaPseed;
      else
        INFO << " Input file with seeds for unwrapping: "
             << unwrapinput.seedfile;
      INFO.print();
      INFO << "UW_OUT_REGIONS: \tOutput data file with region numbers: "
           << unwrapinput.foregions;
      INFO.print();
      break;

    case uw_method2:
      INFO.print("Method 2: SNAPHU is used for unwrapping.");
      INFO.print("Please make sure snaphu is installed.  check results carefuly.");
      INFO << "UW_SNAPHU_LOG: \tOutput log file of snaphu: "
           << unwrapinput.snaphu_log;
      INFO.print();
      INFO << "UW_SNAPHU_INIT: \tinitialization method of snaphu: "
           << unwrapinput.snaphu_init;
      INFO.print();
      INFO << "UW_SNAPHU_COH: \tinput coherence file for snaphu: "
           << unwrapinput.snaphu_coh;
      INFO.print();
      INFO << "UW_SNAPHU_MODE: \tsnaphu mode: "
           << unwrapinput.snaphu_mode;
      INFO.print();
      break;

    case uw_method3:
      INFO.print("Method 3 is used for unwrapping (???).");
      PRINT_ERROR("only for delft, standalone application.");
      throw(keyword_error);
      break;

    default:
      PRINT_ERROR("probably forgot to update this, should not be possible.");
      throw(keyword_error);
    }
  } // END checkunwrap


/****************************************************************
 *    checkgeocode                                              *
 *                                                              *
 * Checks cards for step geocode.                               *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkgeocode(
        const input_geocode &geocodeinput)
  {
  TRACE_FUNCTION("checkgeocode (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step GEOCODE ***");
  INFO << "GEO_OUT_PHI: \tOutput file for latitude: \t"
       << geocodeinput.fophi;
  INFO.print();
  INFO << "GEO_OUT_PHI: \tOutput file for longitude: \t"
       << geocodeinput.folam;
  INFO.print();
  if (!strcmp(geocodeinput.fophi,geocodeinput.folam))
    {
    ERROR << "Same file name GEO_OUT_PHI and GEO_OUT_LAM not allowed.";
    PRINT_ERROR(ERROR.get_str())
    throw(keyword_error);
    }
  } // END checkgeocode



/****************************************************************
 *    checkcoarsecorr                                           *
 *                                                              *
 * Checks cards for step coarsecorr.                            *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkcoarsecorr(
        const input_coarsecorr &coarsecorrinput)
  {
  TRACE_FUNCTION("checkcoarsecorr (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step COARSE_CORR ***");
  switch (coarsecorrinput.method)
    {
    case cc_magfft:
      INFO.print("CC_METHOD: \tMAGFFT is used for coarse correlation."); break;
    case cc_magspace:
      INFO.print("CC_METHOD: \tMAGSPACE is used for coarse correlation."); break;
    default:
      PRINT_ERROR("panic.");
      throw(keyword_error);
    }
  if (specified(coarsecorrinput.ifpositions))
    {
    INFO << "CC_IN_POS: \tFile: " <<  coarsecorrinput.ifpositions 
         << " containing " << coarsecorrinput.Nwin
         << " positions is used.";
    INFO.print();
    }
  else                                          // no input file
    {
    INFO << "CC_NWIN: \tDistributing "
         <<  coarsecorrinput.Nwin 
         << " windows for coarse coregistration based on correlation.";
    INFO.print();
    }
  } // END checkcoarsecorr


/****************************************************************
 *    checkfine                                                 *
 *                                                              *
 * Checks cards for step fine.                                  *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkfine(
        const input_fine &fineinput)
  {
  TRACE_FUNCTION("checkfine (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step FINE ***");
  switch (fineinput.method)
    {
//    case fc_cmplxfft:
//      INFO.print("FC_METHOD: \tCMPLXFFT is used for fine correlation.");
//      break;
//    case fc_cmplxspace:
//      INFO.print("FC_METHOD: \tCMPLXSPACE is used for fine correlation.");
//      break;
    case fc_magfft:
      INFO.print("FC_METHOD: \tMAGFFT is used for fine correlation.");
      break;
    case fc_magspace:
      INFO.print("FC_METHOD: \tMAGSPACE is used for fine correlation.");
      break;
    case fc_oversample:
      INFO.print("FC_METHOD: \tOVERSAMPLE is used for fine correlation.");
      break;
    default:
      PRINT_ERROR("panic.");
      throw(keyword_error);
    }

  if (specified(fineinput.ifpositions))
    {
    INFO << "FC_IN_POS: File: "
         <<  fineinput.ifpositions 
         << " containing "
         << fineinput.Nwin << " positions is used.";
    INFO.print();
    }
  else                                          // no input file
    {
    INFO << "FC_NWIN: \tDistributing "
         <<  fineinput.Nwin 
         << " windows for fine coregistration.";
    INFO.print();
    }
  if (fineinput.plotoffsets)
    {
    INFO << "FC_PLOT " << fineinput.plotthreshold 
         << ": Plotting estimated offsets with correlation larger than "
         << fineinput.plotthreshold;
    INFO.print();
    }
  else
    {
    WARNING.print("It is highly recommended to use FC_PLOT to plot the computed FINE offset vectors.");
    }
  if (fineinput.plotmagbg)
    INFO.print("FC_PLOT: magnitude will be in background of plot.");

  INFO << "FC_WINSIZE: (l,p) = ("
       <<  fineinput.MasksizeL << ", "
       <<  fineinput.MasksizeP << ").";
  INFO.print();
  INFO << "FC_OSFACTOR: "
       <<  fineinput.osfactor
       <<  ". Oversampling factor for fine coregistration.";
  INFO.print();
  if (!ispower2(fineinput.osfactor))
    {
    ERROR << " no power of 2.";
    PRINT_ERROR(ERROR.get_str())
    throw(keyword_error);
    }
  } // END checkfine


/****************************************************************
 *    checkcoregpm                                              *
 *                                                              *
 * Checks cards for step coregpm.                               *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkcoregpm(
        const input_coregpm &coregpminput)
  {
  TRACE_FUNCTION("checkcoregpm (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step COREGPM ***");
  INFO << "CPM_THRESHOLD: \tThreshold correlation for model: \t"
       <<  coregpminput.threshold;
  INFO.print();
  INFO << "CPM_DEGREE: \tPolynomial for coregistration: \t"
       <<  coregpminput.degree;
  INFO.print();
  INFO << "CPM_WEIGHT: \tData weighting option: \t"
       <<  coregpminput.weightflag
       << " (0 none, 1 linear, 2 quadratic) is used in least squares.";
  INFO.print();
  INFO << "CPM_MAXITER: \tNumber of points to remove (max): \t"
       <<  coregpminput.maxiter;
  INFO.print();
  INFO << "CPM_K_ALPHA: \tCritical value for outlier test: \t"
       <<  coregpminput.k_alpha;
  INFO.print();
  if (coregpminput.dumpmodel)
    INFO.print("CPM_DUMP: dumping model to files (see INFO).");
  if (coregpminput.plot)
    INFO.print("CPM_PLOT: error vectors etc. will be plotted.");
  else
    WARNING.print("It is higly recommended to use CPM_PLOT to review the estimated model.");
  if (coregpminput.plotmagbg)
    INFO.print("CPM_PLOT: magnitude will be in background.");
  } // END checkcoregpm


/****************************************************************
 *    checkcomprefpha                                           *
 *                                                              *
 * Checks cards for step comprefpha.                            *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkcomprefpha(
        const input_comprefpha &comprefphainput)
  {
  TRACE_FUNCTION("checkcomprefpha (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step COMPREFPHA ***");
  switch (comprefphainput.method)
    {
    case fe_porbits:
      INFO.print("FE_METHOD: method for flatearth correction: PORBITS");
      // ______ Check points from file or random distributed ______
      if (specified(comprefphainput.ifpositions))
        {
        INFO << "FE_IN_POS: file: "
             <<  comprefphainput.ifpositions 
             << " containing "
             << comprefphainput.Npoints << " positions used for ref. phase estimation.";
        INFO.print();
        }
      else                                              // no input file
        {
        INFO << "FE_NPOINTS: Using " << comprefphainput.Npoints
             << " (random like) distributed points for estimation of refpha polynomial.";
        INFO.print();
        }
      if (comprefphainput.Npoints > 5000)
        WARNING.print("FE_NPOINTS: Too many points requested?");
      INFO << "FE_DEGREE: Using " << comprefphainput.degree
           << " order polynomial for flat Earth correction.";
      INFO.print();
      if (comprefphainput.degree > 10)
        WARNING.print("FE_DEGREE: degree > 10?");
      break;
    case fe_method2:
      INFO.print("FE_METHOD: method for flatearth correction: method2 :NOT IMPLEMENTED");
      break;
    default:
      PRINT_ERROR("impossible, method name is checked while reading cards.");
      throw(keyword_error);
    }
  } // END checkcomprefpha


/****************************************************************
 *    checksubtrrefpha                                          *
 *                                                              *
 * Checks cards for step subtrrefpha.                           *
 *                                                              *
 *    Bert Kampes, 09-Feb-2000                                  *
 ****************************************************************/
void checksubtrrefpha(
        const input_subtrrefpha &subtrrefphainput)
  {
  TRACE_FUNCTION("checksubtrrefpha (BK 09-Feb-2000)")
  INFO.print("\n\t*** Input for step SUBTRREFPHA ***");
  // ______ Print info ______
  switch (subtrrefphainput.method)
    {
    case srp_polynomial:
      INFO.print("SRP_METHOD: \tpolynomial: \tPolynomial from COMPREFPHA used.");
      break;
    case srp_exact:
      INFO.print("SRP_METHOD: \texact:      \treference phase computed foreach pixel.");
      break;
    default:
      PRINT_ERROR("impossible, checked above.");
      throw(keyword_error);
    }
  if (subtrrefphainput.dumponlyrefpha==false)
    {
    INFO << "SRP_OUT_CINT: \toutputfile complex interferogram: \t"
       << subtrrefphainput.focint;
    INFO.print();
    }
  INFO << "SRP_MULTILOOK: \tFactors (line pixel): \t" 
       << subtrrefphainput.multilookL << " "
       << subtrrefphainput.multilookP;
  INFO.print();
  if (subtrrefphainput.dumponlyrefpha==true)
    {
    WARNING.print("SRP_DUMPREFPHA: Only dumping reference phase, no subtraction.");
    INFO << "SRP_DUMPREFPHA: only dump refphase: "
         << subtrrefphainput.dumponlyrefpha;
    INFO.print();
    INFO << "SRP_OUT_REFPHA: Output file reference phase: "
         << subtrrefphainput.forefpha;
    INFO.print();
    }

  // ______ Check ______
  if (subtrrefphainput.multilookL > 100 || subtrrefphainput.multilookP > 100 ||
      subtrrefphainput.multilookL < 1   || subtrrefphainput.multilookP < 1 )
    WARNING.print("SRP_MULTILOOK: multilookfactor seems very high.");
  } // END checksubtrrefpha


/****************************************************************
 *    checkresample                                             *
 *                                                              *
 * Checks cards for step resample.                              *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkresample(
        const input_resample &resampleinput)
  {
  TRACE_FUNCTION("checkresample (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step RESAMPLE ***");
  INFO << "RS_OUT_FILE: \toutput filename: \t\t" 
       << resampleinput.fileout;
  INFO.print();
  INFO << "RS_OUT_FORMAT: output format: \t\t";
  switch (resampleinput.oformatflag)
    {
    case FORMATCR4:
      INFO << "complex_real4.";
      break;
    case FORMATCI2:
      INFO << "complex_short.";
      break;
    default:
      PRINT_ERROR("totally impossible, checked input.");
      throw(keyword_error);
    }
  INFO.print();
  if (resampleinput.dbow.linehi != 0 || resampleinput.dbow.pixhi != 0)
    {
    INFO << "RS_DBOW: \tOutput window: \t\t\t" 
         << resampleinput.dbow.linelo << " " 
         << resampleinput.dbow.linehi << " " 
         << resampleinput.dbow.pixlo  << " " 
         << resampleinput.dbow.pixhi ;
    INFO.print();
    }
  INFO << "RS_SHIFTAZI: \tshift azimuth spectrum: \t" 
       << resampleinput.shiftazi ;
  INFO.print();
  } // END checkresample


/****************************************************************
 *    checkinterfero                                            *
 *                                                              *
 * Checks cards for step interfero.                             *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkinterfero(
        const input_interfero &interferoinput)
  {
  TRACE_FUNCTION("checkinterfero (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step INTERFERO ***");
  bool filespecified = false;
  bool samefilename  = false;
  if (specified(interferoinput.foint))
    {
    filespecified = true;
    INFO << "INT_OUT_INT: \tOutputfile interferogram: \t"
         <<  interferoinput.foint;
    INFO.print();
    if (!(strcmp(interferoinput.foint,interferoinput.focint)))
      samefilename = true;
    }
  if (specified(interferoinput.focint))
    {
    filespecified = true;
    INFO << "INT_OUT_CINT: Outfile complex interferogram: \t"
         <<  interferoinput.focint;
    INFO.print();
    if (!(strcmp(interferoinput.focint,interferoinput.foint)))
      samefilename = true;
    }
//  if (strcmp(interferoinput.foflatearth," "))         // something is specified
//    {
//    filespecified = true;
//    INFO << "INT_OUT_FE: data outputfile reference phase: \t"
//         <<  interferoinput.foflatearth;
//    INFO.print();
//    if (!(strcmp(interferoinput.foflatearth,interferoinput.foint))  ||
//        !(strcmp(interferoinput.foflatearth,interferoinput.focint)))
//      samefilename = true;
//    }

  INFO << "INT_MULTILOOK: \tFactor (line pixel): \t"
       <<  interferoinput.multilookL << " " 
       << interferoinput.multilookP;
  INFO.print();

  if (interferoinput.multilookL > 100 || interferoinput.multilookP > 100)
    {
    PRINT_ERROR("code ???: INT_MULTILOOK: > 100.");
    throw(keyword_error);
    }
  if (interferoinput.multilookL < 1 || interferoinput.multilookP < 1)
    {
    PRINT_ERROR("code ???: INT_MULTILOOK: < 1.");
    throw(keyword_error);
    }

  if (!filespecified)
    {
    PRINT_ERROR("code ???: INT_OUT_*: at least one output file must be specified.");
    throw(keyword_error);
    }
  if (samefilename)
    {
    PRINT_ERROR("code ???: INT_OUT_*: same name output files.");
    throw(keyword_error);
    }
  } // END checkinterfero


/****************************************************************
 *    checkcoherence                                            *
 *                                                              *
 * Checks cards for step coherence.                             *
 *                                                              *
 *    Bert Kampes, 29-Sep-1999                                  *
 ****************************************************************/
void checkcoherence(
        const input_coherence &coherenceinput)
  {
  TRACE_FUNCTION("checkcoherence (BK 29-Sep-1999)")
  INFO.print("\n\t*** Input for step COHERENCE ***");
  bool filespecified = false;
  bool samefilename  = false;
  if (specified(coherenceinput.foccoh))
    {
    filespecified = true;
    INFO << "COH_OUT_CCOH: \tOutfile complex coherence: \t"
         <<  coherenceinput.foccoh;
    INFO.print();
    if (!(strcmp(coherenceinput.foccoh,coherenceinput.focoh)))
      samefilename = true;
    }

  if (specified(coherenceinput.focoh))
    {
    filespecified = true;
    INFO << "COH_OUT_COH: \tOutputfile coherence image: "
         <<  coherenceinput.focoh;
    INFO.print();
    if (!(strcmp(coherenceinput.focoh,coherenceinput.foccoh)))
      samefilename = true;
    }

  INFO << "COH_MULTILOOK: \tFactor (line pixel): \t"
       <<  coherenceinput.multilookL << " "
       << coherenceinput.multilookP;
  INFO.print();
  INFO << "COH_WINSIZE: \t window size coh. estimation (l/p): \t"
       <<  coherenceinput.cohsizeL << " " << coherenceinput.cohsizeP;
  INFO.print();

  if (coherenceinput.multilookL > 100 || coherenceinput.multilookP > 100)
    {
    PRINT_ERROR("code ???: COH_MULTILOOK: > 100.");
    throw(keyword_error);
    }
  if (coherenceinput.multilookL < 1 || coherenceinput.multilookP < 1)
    {
    PRINT_ERROR("code ???: COH_MULTILOOK: < 1.");
    throw(keyword_error);
    }
  if (coherenceinput.cohsizeL > 500 || coherenceinput.cohsizeP > 500)
    {
    PRINT_ERROR("code ???: COH_WINSIZE: > 500.");
    throw(keyword_error);
    }
  if (coherenceinput.cohsizeL < 1 || coherenceinput.cohsizeP < 1)
    {
    PRINT_ERROR("code ???: COH_WINSIZE: < 1.");
    throw(keyword_error);
    }

  if (!filespecified)
    {
    PRINT_ERROR("code ???: COH_OUT_*: at least one output file must be specified.");
    throw(keyword_error);
    }
  if (samefilename)
    {
    PRINT_ERROR("code ???: COH_OUT_*: same name output files.");
    throw(keyword_error);
    }
  } // END checkcoherence



/****************************************************************
 *    checkcomprefdem                                           *
 *                                                              *
 * Checks cards for step comprefdem.                            *
 *                                                              *
 *    Bert Kampes, 14-Feb-2000                                  *
 ****************************************************************/
void checkcomprefdem(
        const input_comprefdem &comprefdeminput)
  {
  TRACE_FUNCTION("checkcomprefdem (BK 14-Feb-2000)")
  INFO.print("\n\t*** Input for step COMPREFDEM ***");
  switch (comprefdeminput.method)
    {
    case crd_nearest:
      INFO.print("NEAREST_NEIGHBOR, use DENSE=2 or so.");
      break;
    case crd_trilinear:
      INFO.print("TRI_LINEAR; use DENSE=0.2 for speed.");
      break;
    default:
      PRINT_ERROR("totally impossible, checked input.");
      throw(keyword_error);
    }
  INFO << "CRD_IN_DEM:    \t" << comprefdeminput.firefdem;
  INFO.print();
  INFO << "CRD_OUT_FILE:  \t" << comprefdeminput.forefdem;
  INFO.print();
  if (specified(comprefdeminput.forefdemhei))
    {
    INFO << "CRD_OUT_DEM_LP: \t" << comprefdeminput.forefdemhei
       << "; output requested of DEM [m] in radar coordinates.";
    INFO.print();
    if (!strcmp(comprefdeminput.forefdem,comprefdeminput.forefdemhei))
      {
      PRINT_ERROR("CRD_OUT_FILE, CRD_OUT_DEM_LP: Same output file name.");
      throw(keyword_error);
      }
    }
  if (specified(comprefdeminput.fodem))
    {
    INFO << "CRD_OUT_DEM:   \t" << comprefdeminput.fodem
       << "; output requested of input DEM.";
    INFO.print();
    if (!strcmp(comprefdeminput.fodemi,comprefdeminput.fodem))
      {
      PRINT_ERROR("OUT_DEM, OUT_DEMI: Same output file name.");
      throw(keyword_error);
      }
    }
  if (specified(comprefdeminput.fodemi))
    {
    INFO << "CRD_OUT_DEMI:   \t" << comprefdeminput.fodemi
         << "; output requested of interpolated DEM.";
    INFO.print();
    if (!strcmp(comprefdeminput.fodemi,comprefdeminput.fodem))
      {
      PRINT_ERROR("OUT_DEM, OUT_DEMI: Same output file name.");
      throw(keyword_error);
      }
    }
  INFO << "CRD_IN_SIZE:   \t" << comprefdeminput.demrows
       << " " << comprefdeminput.demcols
       << "; number of rows (latitude), columns (lon) in DEM.";
  INFO.print();
  INFO << "CRD_IN_UL:     \t" 
       << rad2deg(comprefdeminput.demlatleftupper) << " "
       << rad2deg(comprefdeminput.demlonleftupper)
       << "; coordinates of upper left corner (first row/col).";
  INFO.print();
  INFO << "CRD_IN_DELTA:  \t"
       << rad2deg(comprefdeminput.demdeltalat) << " "
       << rad2deg(comprefdeminput.demdeltalon);
  INFO.print();
  INFO << "CRD_IN_NODATA:  \t" << comprefdeminput.demnodata
       << "; this number in DEM will be set to 0 reference phase.";
  INFO.print();
  INFO << "CRD_DENSE:      \t" << comprefdeminput.extradense
       << "; this is the factor for oversampling DEM more than minimum.";
  INFO.print();
  if (comprefdeminput.includerefpha)
    INFO << "CRD_INCLUDE_FE: \tref. dem is computed including flat earth.";
  else
    INFO << "CRD_INCLUDE_FE: \tref. dem is computed w.r.t. ellipsoid (topo only).";
  INFO.print();

  INFO << "CRD_IN_FORMAT: \tinput format DEM: \t";
  switch (comprefdeminput.iformatflag)
    {
    case FORMATR4:
      INFO << "real4.";
      break;
    case FORMATR8:
      INFO << "real8.";
      break;
    case FORMATI2:
      INFO << "signed short.";
      break;
    case FORMATI2_BIGENDIAN:
      INFO << "signed short big endian.";
      break;
    default:
      PRINT_ERROR("totally impossible, checked input.");
      throw(keyword_error);
    }
  INFO.print();



// ______ Check some things ______
  if (!existed(comprefdeminput.firefdem))
    {
    ERROR << "CRD_IN_DEM:   \t" << comprefdeminput.firefdem
         << " can not be opened.";
    PRINT_ERROR(ERROR.get_str())
    throw(keyword_error);
    }
  if (rad2deg(comprefdeminput.demdeltalat)<.0008)
    {
    WARNING << "CRD_IN_DELTA: \t" << comprefdeminput.demdeltalat
         << " seems very small (it should be in decimal degrees).";
    WARNING.print();
    }
  if (comprefdeminput.demrows<1 || comprefdeminput.demrows>10000)
    {
    WARNING << "CRD_DEM_SIZE: numrows: \t" << comprefdeminput.demrows
         << " seems to be wrong.";
    WARNING.print();
    }
  if (comprefdeminput.demcols<1 || comprefdeminput.demcols>10000)
    {
    WARNING << "CRD_DEM_SIZE: numcols: \t" << comprefdeminput.demcols
         << " seems to be wrong.";
    WARNING.print();
    }
  if (comprefdeminput.extradense>5.0)
    {
    WARNING << "CRD_DENSE:    \t" << comprefdeminput.extradense
         << " seems to be quite large.";
    WARNING.print();
    }
  if (comprefdeminput.extradense<0.2)
    {
    WARNING << "CRD_DENSE:    \t" << comprefdeminput.extradense
         << " seems too small.";
    WARNING.print();
    }
  if (rad2deg(comprefdeminput.demdeltalon)<.0008)
    {
    WARNING << "CRD_IN_DELTA: \t" << comprefdeminput.demdeltalon
         << " seems very small (it should be in decimal degrees).";
    WARNING.print();
    }
  if (rad2deg(comprefdeminput.demlatleftupper) < -90. ||
      rad2deg(comprefdeminput.demlatleftupper) >  90.   )
    {
    ERROR << "CRD_IN_LU:    \t" << rad2deg(comprefdeminput.demlatleftupper)
         << " out of range (-90:90).";
    PRINT_ERROR(ERROR.get_str())
    throw(keyword_error);
    }
  if (rad2deg(comprefdeminput.demlonleftupper) < -180. ||
      rad2deg(comprefdeminput.demlonleftupper) >  180.   )
    {
    WARNING << "CRD_IN_LU:    \t" << rad2deg(comprefdeminput.demlonleftupper)
         << " out of range (-180:180).";
    WARNING.print();
    }
  if (!strcmp(comprefdeminput.fodem,comprefdeminput.forefdem))
    {
    PRINT_ERROR("OUT_DEM, OUT_FILE: Same output file name.");
    throw(keyword_error);
    }
  if (!strcmp(comprefdeminput.firefdem,comprefdeminput.forefdem))
    {
    PRINT_ERROR("OUT_FILE, IN_DEM: Same file name.");
    throw(keyword_error);
    }
  } // END comprefdem



/****************************************************************
 *    checksubtrrefdem                                          *
 *                                                              *
 * Checks cards for step subtrrefdem.                           *
 *                                                              *
 *    Bert Kampes, 14-Feb-2000                                  *
 ****************************************************************/
void checksubtrrefdem(
        const input_subtrrefdem &subtrrefdeminput)
  {
  TRACE_FUNCTION("checksubtrrefdem (BK 14-Feb-2000)")
  INFO.print("\n\t*** Input for step SUBTRREFDEM ***");
  INFO << "SRD_OUT_CINT:   \t" << subtrrefdeminput.focint;
  INFO.print();
  INFO << "SRD_OFFSET:     \t" << subtrrefdeminput.offsetL 
       << " " << subtrrefdeminput.offsetP;
  INFO.print();
  if (abs(subtrrefdeminput.offsetL)>5) 
    WARNING.print("Apply offset in azimuth larger than 5 pixels?");
  if (abs(subtrrefdeminput.offsetP)>5) 
    WARNING.print("Apply offset in range larger than 5 pixels?");
  } // END checksubtrrefdem


/****************************************************************
 *    checkfiltrange                                            *
 * Checks cards for step filtrange.                             *
 *    Bert Kampes, 14-Feb-2000                                  *
 ****************************************************************/
void checkfiltrange(
        const input_filtrange &filtrangeinput)
  {
  TRACE_FUNCTION("checkfiltrange (BK 14-Feb-2000)")
  INFO.print("\n\t*** Input for step FILTRANGE ***");
  // ______ Give info ______
  switch (filtrangeinput.method)
    {
    case rf_adaptive:
      INFO.print("RF_METHOD:        ADAPTIVE \t(estimate fringe freq.)");
      INFO << "RF_NLMEAN:     " << filtrangeinput.nlmean;
      INFO.print();
      INFO << "RF_THRESHOLD:  " << filtrangeinput.SNRthreshold;
      INFO.print();
      INFO << "RF_OVERSAMPLE: " << filtrangeinput.oversample;
      INFO.print();
      INFO << "RF_WEIGHTCORR: " << filtrangeinput.doweightcorrel;
      INFO.print();
      INFO << "RF_OVERLAP:    " << filtrangeinput.overlap;
      INFO.print();
      if (filtrangeinput.nlmean > 51)
        WARNING.print("RF_NLMEAN:     mean over more than 51 lines (?)");
      if (filtrangeinput.SNRthreshold<1.99)
        WARNING.print("RF_THRESHOLD:  < 2");
      if (filtrangeinput.SNRthreshold>10.01)
        WARNING.print("RF_THRESHOLD:  > 10 ?");
      if (filtrangeinput.oversample<=1)
        WARNING.print("RF_OVERSAMPLE: no oversampling.");
      if (filtrangeinput.oversample>8)
        WARNING.print("RF_OVERSAMPLE: >8 ?");
      if (!ispower2(filtrangeinput.oversample))
        WARNING.print("RF_OVERSAMPLE: not power of two.");
      if (filtrangeinput.doweightcorrel==true)
        WARNING.print("RF_WEIGHTCORR: weighting, not sure it has effect.");
      if (filtrangeinput.fftlength > 1024)
        WARNING.print("RF_FFTLENGTH:  adaptive filterlength > 1024 ?");
      if (filtrangeinput.SNRthreshold<0.)
        {
        PRINT_ERROR(  "RF_THRESHOLD:  < 0.");
        throw(keyword_error);
        }
      break;
    case rf_porbits:
      INFO.print("RF_METHOD:        PORBITS  \t(based on orbits.)");
      INFO << "RF_SLOPE:      " << rad2deg(filtrangeinput.terrainslope)
           << "\t[deg] terrainslope.";
      INFO.print();
      if (filtrangeinput.fftlength < 256)
        WARNING.print("RF_FFTLENGTH:  porbits filterlength < 256 (?)");
      break;
    default:
      PRINT_ERROR("totally impossible, checked input.");
      throw(keyword_error);
    }
  // ______ Both methods cards ______
  INFO << "RF_FFTLENGTH:  " << filtrangeinput.fftlength;
  INFO.print();
  INFO << "RF_HAMMING:    " << filtrangeinput.hammingalpha;
  INFO.print();
  INFO << "RF_OUT_MASTER: " << filtrangeinput.fomaster;
  INFO.print();
  INFO << "RF_OUT_SLAVE:  " << filtrangeinput.foslave;
  INFO.print();
  INFO << "RF_OUT_FORMAT: output format: ";
  switch (filtrangeinput.oformatflag)
    {
    case FORMATCR4:
      INFO << "complex_real4.";
      break;
    case FORMATCI2:
      INFO << "complex_short.";
      break;
    default:
      PRINT_ERROR("totally impossible, checked input.");
      throw(keyword_error);
    }
  INFO.print();

  // ______ Check input ______
  if (filtrangeinput.hammingalpha>0.999)
    WARNING.print("RF_HAMMING: no hamming filtering.");
  if (existed(filtrangeinput.fomaster))
    WARNING.print("RF_OUT_MASTER: file exists.");
  if (existed(filtrangeinput.foslave))
    WARNING.print("RF_OUT_SLAVE: file exists.");
  if (!ispower2(filtrangeinput.fftlength))
    {
    PRINT_ERROR(  "RF_FFTLENGTH: not power of 2.");
    throw(keyword_error);
    }
  if (filtrangeinput.overlap >= 0.5*filtrangeinput.fftlength)
    {
    PRINT_ERROR(  "RF_OVERLAP >= 0.5*RF_FFTLENGTH");
    throw(keyword_error);
    }
  if (filtrangeinput.hammingalpha>1. || filtrangeinput.hammingalpha<0.)
    {
    PRINT_ERROR(  "RF_HAMMING: not e[0,1].");
    throw(keyword_error);
    }
  } // END checkfiltrange



/****************************************************************
 *    checkdinsar                                               *
 *                                                              *
 * Checks cards for step dinsar.                                *
 *                                                              *
 #%// BK 25-Sep-2000
 ****************************************************************/
void checkdinsar(
        const input_dinsar &dinsarinput)
  {
  TRACE_FUNCTION("checkdinsar (BK 25-Sep-2000)")
  INFO.print("\n\t*** Input for step DINSAR ***");

  if (!specified(dinsarinput.topomasterresfile))
    {
    INFO.print("Using 3 pass differential (for 4 pass, see DI_IN_TOPOMASTER card).");
    }
  else
    {
    INFO << "DI_IN_TOPOMASTER: \t" << dinsarinput.topomasterresfile
         << " (4 pass)";
    INFO.print();
    }
  INFO << "DI_IN_TOPOSLAVE: \t" << dinsarinput.toposlaveresfile;
  INFO.print();
  INFO << "DI_IN_TOPOINT:   \t" << dinsarinput.topointresfile;
  INFO.print();
  INFO << "DI_OUT_FILE:     \t" << dinsarinput.fodinsar;
  INFO.print();
  if (!specified(dinsarinput.foscaleduint))
    INFO << "DI_OUT_SCALED: \tNo (debug) output requested scaled topography interf.";
  else
    INFO << "DI_OUT_SCALED: \t" << dinsarinput.foscaleduint 
         << "; debug output requested.";
  INFO.print();
  if (!specified(dinsarinput.toposlaveresfile))
    {
    PRINT_ERROR("DI_IN_TOPOSLAVE: result file topo slave not specified.");
    throw(keyword_error);
    }
  if (!specified(dinsarinput.topointresfile))
    {
    PRINT_ERROR("DI_IN_TOPOINT: result file topo interferogram not specified.");
    throw(keyword_error);
    }
  if (!strcmp(dinsarinput.toposlaveresfile,dinsarinput.topointresfile))
    {
    PRINT_ERROR("IN_TOPOSLAVE, IN_TOPOINT: Same input file name.");
    throw(keyword_error);
    }
  } // END checkdinsar



/****************************************************************
 *    checkfiltphase                                            *
 *                                                              *
 * Checks cards for step filtphase.                             *
 *                                                              *
 #%// BK 25-Sep-2000
 ****************************************************************/
void checkfiltphase(
        const input_filtphase &filtphaseinput)
  {
  TRACE_FUNCTION("checkfiltphase (BK 25-Sep-2000)")
  INFO.print("\n\t*** Input for step FILTPHASE ***");
  if (specified(filtphaseinput.fifiltphase))
    {
    INFO << "PF_IN_FILE: \t" << filtphaseinput.fifiltphase
         << " " <<  filtphaseinput.finumlines
         << " (this cr4 file will be filtered)";
    INFO.print();
    if (!existed(filtphaseinput.fifiltphase))
      WARNING.print("Impossible? PF input file does not exist?");
    }
  INFO << "PF_OUT_FILE: \t" << filtphaseinput.fofiltphase 
       << " (output filename).";
  INFO.print();

  // ______ Method goldstein filter ______
  if (filtphaseinput.method==fp_goldstein)
    {
    INFO.print("FILTPHASE: Method goldstein.");
    INFO << "PF_ALPHA: \t" << filtphaseinput.alpha
         << " (weigthing parameter for spectrum).";
    INFO.print();
    INFO << "PF_BLOCKSIZE: " << filtphaseinput.blocksize
         << " (size of block to perform filtering on).";
    INFO.print();
    INFO << "PF_OVERLAP: \t" << filtphaseinput.overlap
         << " (half overlap between consequetive blocks).";
    INFO.print();

    // ______ Use 1d kernel to smooth amplitude, e.g. 12321 ______
    // ______ Which is normalized by me ______
    INFO << "PF_KERNEL: \t";
    for (int32 ii=0; ii<filtphaseinput.kernel.pixels(); ++ii)
      INFO << " " << filtphaseinput.kernel(0,ii);
    INFO << " (smooth |spectrum| with this).";
    INFO.print();
    if (filtphaseinput.kernel.pixels()==1)
      INFO.print("No smoothing of amplitude spectrum!");

    // ______ Check errors _____
    if (filtphaseinput.alpha<0. || filtphaseinput.alpha>1.)
      WARNING.print("PF_ALPHA not 0<a<1");
    if (filtphaseinput.blocksize>64 || filtphaseinput.blocksize<16)
      WARNING.print("PF_BLOCKSIZE very small or large?");
    if (filtphaseinput.kernel.pixels()>11)
      WARNING.print("smoothing kernel > 11:  very large?");
    if (filtphaseinput.overlap<0)
      {
      PRINT_ERROR("PF_OVERLAP < 0");
      throw(keyword_error);
      }
    if (2*filtphaseinput.overlap>filtphaseinput.blocksize)
      {
      PRINT_ERROR("2*PF_OVERLAP > PF_BLOCKSIZE");
      throw(keyword_error);
      }
    if (filtphaseinput.kernel.pixels()>filtphaseinput.blocksize)
      {
      PRINT_ERROR("smoothing kernel > PF_BLOCKSIZE");
      throw(keyword_error);
      }
    if (!ispower2(filtphaseinput.blocksize))
      {
      PRINT_ERROR("PF_BLOCKSIZE not a power of 2");
      throw(keyword_error);
      }
    }

  // ______ Method spatial convolution ______
  else if (filtphaseinput.method==fp_spatialconv)
    {
    INFO.print("FILTPHASE: Method spatial convolution.");
    if (!specified(filtphaseinput.fikernel2d))
      {
      INFO.print("Using 1d kernel for spatial convolution (no PF_IN_KERNEL2D).");
      INFO << "PF_KERNEL: used: \t";
      for (int32 ii=0; ii<filtphaseinput.kernel.pixels(); ++ii)
        INFO << " " << filtphaseinput.kernel(0,ii);
      INFO.print();
      }
    else
      {
      INFO.print("Using 2d kernel for spatial convolution.");
      INFO << "PF_IN_KERNEL2D: \t" << filtphaseinput.fikernel2d
           << " (ascii input file with 2d kernel).";
      INFO.print();
      INFO.print("PF_IN_KERNEL2D: \t(input file has 1 line header: numrows numcols scale");
      if (filtphaseinput.kernel.size()!=0)
        WARNING.print("PF_KERNEL card ignored due to card PF_IN_KERNEL2D.");
      if (!existed(filtphaseinput.fikernel2d))
        WARNING.print("PF_IN_KERNEL2D infile cannot be found.");
      }
    }
  else if (filtphaseinput.method==fp_spectral)
    {
    INFO.print("FILTPHASE: Method spectral filter with 2D kernel.");
    INFO << "PF_BLOCKSIZE: " << filtphaseinput.blocksize
         << " (size of block to perform filtering on).";
    INFO.print();
    INFO << "PF_OVERLAP: \t" << filtphaseinput.overlap
         << " (half overlap between consequetive blocks).";
    INFO.print();
    if (filtphaseinput.kernel.size()!=0)
      WARNING.print("PF_KERNEL card ignored for method spectral.");
    if (filtphaseinput.overlap<0)
      {
      PRINT_ERROR("PF_OVERLAP < 0");
      throw(keyword_error);
      }
    if (2*filtphaseinput.overlap>filtphaseinput.blocksize)
      {
      PRINT_ERROR("2*PF_OVERLAP > PF_BLOCKSIZE");
      throw(keyword_error);
      }
    if (!ispower2(filtphaseinput.blocksize))
      {
      PRINT_ERROR("PF_BLOCKSIZE not a power of 2");
      throw(keyword_error);
      }
    if (!specified(filtphaseinput.fikernel2d))
      {
      PRINT_ERROR("method spectral needs card PF_IN_KERNEL2D");
      throw(keyword_error);
      }
    }
  else
    {
    PRINT_ERROR("Method phasefiltering != {goldstein,spatialconv,spectral}.");
    throw(keyword_error);
    }
  } // END checkfiltphase


/****************************************************************
 *    checkfiltazi                                              *
 * Checks cards for step filtazi.                               *
 *    Bert Kampes, 02-Nov-2000                                  *
 ****************************************************************/
void checkfiltazi(
        const input_filtazi &filtaziinput,
        const int16 id)         // either master, slave, or m+s
  {
  TRACE_FUNCTION("checkfiltazi (BK 02-Nov-2000)")
  INFO.print("\n\t*** Input for step FILTAZI ***");
  INFO << "AF_BLOCKSIZE:   \t" << filtaziinput.fftlength;
  INFO.print();
  INFO << "AF_OVERLAP:     \t" << filtaziinput.overlap;
  INFO.print();
  INFO << "AF_HAMMING:     \t" << filtaziinput.hammingalpha;
  INFO.print();
  if (filtaziinput.oformatflag==FORMATCR4)
    INFO.print("AF_OUT_FORMAT:  \tcomplex_real4");
  else if (filtaziinput.oformatflag==FORMATCI2)
    INFO.print("AF_OUT_FORMAT:  \tcomplex_short");
  else
    {
    PRINT_ERROR("formatflag not ok for output.");
    throw(keyword_error);
    }

  if (id!=SLAVEID)
    {
    INFO << "AF_OUT_MASTER:  \t" << filtaziinput.fomaster;
    INFO.print();
    }
  if (id!=MASTERID)
    {
    INFO << "AF_OUT_SLAVE:   \t" << filtaziinput.foslave;
    INFO.print();
    }

  if (filtaziinput.fftlength<256)
    WARNING.print("AF_BLOCKSIZE < 256 (too small?)");
  if (2*filtaziinput.overlap>0.5*filtaziinput.fftlength)
    WARNING.print("2*AF_OVERLAP > .5*AF_BLOCKSIZE (very large?)");
  if (filtaziinput.hammingalpha<0 || filtaziinput.hammingalpha>1)
    {
    PRINT_ERROR("AF_HAMMING not e[0,1]");
    throw(keyword_error);
    }
  if (filtaziinput.overlap<0)
    {
    PRINT_ERROR("AF_BLOCKSIZE < 0");
    throw(keyword_error);
    }
  if (2*filtaziinput.overlap>filtaziinput.fftlength)
    {
    PRINT_ERROR("AF_BLOCKSIZE < 2*AF_BLOCKSIZE");
    throw(keyword_error);
    }
  if (!ispower2(filtaziinput.fftlength))
    {
    PRINT_ERROR("AF_BLOCKSIZE must be power of 2.");
    throw(keyword_error);
    }
  } // END checkfiltazi

---