main()

int main	(	int	iargc,
		char *	argv[]
	)

Definition at line 811 of file sigscale.cc.

References cmdlinekeys, DDAS3::conversion_code(), DDAS3::convert_to_display_units(), Options::debrep, Options::debug, formatkey, Options::inputformat, Options::outputformat, Options::overwrite, DDAS3::report_sidiode_table(), SIGSCALE_VERSION, tracekey, TRANGE_100K, TRANGE_12K, TRANGE_24K, TRANGE_475K, and Options::verbose.

{

  // define usage information
  char usage_text[]=
  {
    SIGSCALE_VERSION "\n"
    "usage: sigscale [-v] [-o] [-itype type] [-otype type]" "\n"
    "              outfile infile [t:T] [f:F] [infile [t:T] [f:F] ... ]" "\n"
    "   or: sigscale --help|-h" "\n"
    "   or: sigscale --xhelp" "\n"
  };

  // define full help text
  char help_text[]=
  {
    "outfile      name of output file" "\n"
    "infile       name of input file" "\n"
    "             t:T select traces T, where T may be any range" "\n"
    "                 specification like \'3-4\' or \'5,6,7-12,20\'" "\n"
    "             f:F specifies an input file format differing from" "\n"
    "                 the format selected by \"-type\"" "\n"
    "\n"
    "-xhelp       print detailed information regarding file formats" "\n"
    "-v           be verbose" "\n"
    "-DEBUG       produce debug output" "\n"
    "-DEBREP      report internal scaling values for debugging" "\n"
    "-o           overwrite output" "\n"
    "-itype type  choose input file format (default: sff)" "\n"
    "-otype type  choose output file format (default: sff)" "\n"
    "\n"
    "This program is designed for auxilliary data from superconduction\n"
    "gravimeter SG056 at BFO. It uses scling relations provided by GWR\n"
    "to convert sample values to meaningful physical units."
  };

  // define commandline options
  using namespace tfxx::cmdline;
  static Declare options[]= 
  {
    // 0: print help
    {"help",arg_no,"-"},
    // 1: verbose mode
    {"v",arg_no,"-"},
    // 2: overwrite mode
    {"o",arg_no,"-"},
    // 3: input file format
    {"itype",arg_yes,"sff"},
    // 4: output file format
    {"otype",arg_yes,"sff"},
    // 5: generate debug output
    {"DEBUG",arg_no,"-"},
    // 6: output file format
    {"xhelp",arg_no,"-"},
    // 7: generate debug output
    {"DEBREP",arg_no,"-"},
    {NULL}
  };

  // file specific keys
  static const char tracekey[]="t";
  static const char formatkey[]="f";

  // define commandline argument modifier keys
  static const char* cmdlinekeys[]
    ={tracekey, formatkey, 0};

  // no arguments? print usage...
  if (iargc<2) 
  {
    cerr << usage_text << endl;
    cerr << tfxx::seitosh::repository_reference << endl;
    exit(0);
  }

  // collect options from commandline
  Commandline cmdline(iargc, argv, options);

  // help requested? print full help text...
  if (cmdline.optset(0))
  {
    cerr << usage_text << endl;
    cerr << help_text << endl;
    datrw::supported_data_types(cerr); 
    cerr << endl << tfxx::seitosh::repository_reference << endl;
    exit(0);
  }

  // help on file format details requested? 
  if (cmdline.optset(6))
  {
    cerr << usage_text << endl;
    cerr << endl;
    datrw::online_help(cerr); 
    cerr << endl << tfxx::seitosh::repository_reference << endl;
    exit(0);
  }
  // extract commandline options
  Options opt;
  opt.verbose=cmdline.optset(1);
  opt.overwrite=cmdline.optset(2);
  opt.inputformat=cmdline.string_arg(3);
  opt.outputformat=cmdline.string_arg(4);
  opt.debug=cmdline.optset(5);
  // 6 is --xhelp
  opt.debrep=cmdline.optset(7);

  /*======================================================================*/

  if (opt.debrep) {
    cout << SIGSCALE_VERSION << endl;  
    
    DDAS3::report_sidiode_table(TRANGE_12K);
    DDAS3::report_sidiode_table(TRANGE_24K);
    DDAS3::report_sidiode_table(TRANGE_100K);
    DDAS3::report_sidiode_table(TRANGE_475K);
    exit(2);
  }

  /*======================================================================*/

  if (opt.verbose)
  { cout << SIGSCALE_VERSION << endl; }

  // extract commandline arguments
  TFXX_assert(cmdline.extra(), "missing output file");
  std::string outfile=cmdline.next();
  TFXX_assert(cmdline.extra(), "missing input file");
  tfxx::cmdline::Tparsed arguments=parse_cmdline(cmdline, cmdlinekeys);
  if ((arguments.size()>1) && opt.verbose)
  {
    cout << "NOTICE: file specific information (SRCE line and file FREE)" <<
      endl
      <<    "        will be taken from first file only!" << endl;
  }

  /*======================================================================*/
  // start processing

  // open output file
  // ----------------
  if (opt.verbose) { cout << "open output file " << outfile << endl; }
  // check if output file exists and open
  if (!opt.overwrite)
  {
    std::ifstream file(outfile.c_str(),std::ios_base::in);
    TFXX_assert((!file.good()),"ERROR: output file exists!");
  }
  std::ios_base::openmode oopenmode
    =datrw::oanystream::openmode(opt.outputformat);
  std::ofstream ofs(outfile.c_str(), oopenmode);
  datrw::oanystream os(ofs, opt.outputformat, opt.debug);

  // set flag to process header of first input file
  bool firstfile=true;
  // cycle through all input files
  // -----------------------------
  tfxx::cmdline::Tparsed::const_iterator infile=arguments.begin();
  while (infile != arguments.end())
  {
    // open input file
    if (opt.verbose) { cout << "open input file " << infile->name << endl; }
    std::string inputformat=opt.inputformat;
    if (infile->haskey(formatkey)) 
    {
      inputformat=infile->value(formatkey);
    }
    std::ios_base::openmode iopenmode
      =datrw::ianystream::openmode(inputformat);
    std::ifstream ifs(infile->name.c_str(), iopenmode);
    datrw::ianystream is(ifs, inputformat);
      
    // handle file header
    // ------------------
    sff::FREE filefree;
    if (firstfile)
    {
      if (is.hasfree()) 
      { 
        sff::FREE infilefree;
        is >> infilefree;
        filefree.append("block read from first input file:");
        filefree.append(infilefree);
      }
      if (os.handlesfilefree()) { os << filefree; }
      if (is.hassrce())
      {
        sff::SRCE insrceline;
        is >> insrceline;
        if (os.handlessrce()) { os << insrceline; }
      }
    }

    // cycle through traces of input file
    // ----------------------------------
    // setup trace selection
    typedef tfxx::RangeList<int> Trangelist;
    bool doselect=infile->haskey(tracekey);
    Trangelist traceranges=
      tfxx::string::rangelist<Trangelist::Tvalue>(infile->value(tracekey));
    int itrace=0;
    while (is.good())
    {
      ++itrace;
      if ((!doselect) || traceranges.contains(itrace))
      {
        TFXX_debug(opt.debug, "main", "process trace #" << itrace );
        if (opt.verbose)
        { std::cout << "  process trace #" << itrace << ":"; }
        Tseries series;
        is >> series;

        sff::WID2 wid2;
        is >> wid2;
        TFXX_debug(opt.debug, "main", 
                   "  series and WID2 are read");
        sff::INFO info; 
        if (is.hasinfo()) 
        { 
          is >> info; 
        }

  /*----------------------------------------------------------------------*/
        // apply scaling
        ChannelDescription CD;
        SFFchannelid sid;
        sid.station=wid2.station;
        sid.channel=wid2.channel;
        sid.instrument=wid2.instype;
        sid.auxid=wid2.auxid;
        CD=channel(sid);

        std::string CCstring=DDAS3::conversion_code(CD.cc);

        aff::Iterator<Tseries> I(series);
        while (I.valid())
        {
          Tseries::Tvalue v= *I;
          *I = DDAS3::convert_to_display_units(CD.cc, v);
          ++I;
        }

  /*----------------------------------------------------------------------*/

        os << wid2;
        TFXX_debug(opt.debug, "main", 
                   "  series and WID are written");
        if (is.hasinfo()) 
        { 
          if (os.handlesinfo()) { os << info; }
        }
        if (is.hasfree() || true) 
        {
          sff::FREE tracefree;
          is >> tracefree;
          tracefree.append(SIGSCALE_VERSION);
          tracefree.append("read from file " + infile->name);
          tracefree.append("applied scaling for conversion code \"" 
                           + CCstring +"\"");
          if (os.handlestracefree()) { os << tracefree; } 
        }
        TFXX_debug(opt.debug, "main", 
                   "trace #" << itrace << " successfully processed");
        os << series;
      }
      else
      {
        TFXX_debug(opt.debug, "main", "skip trace #" << itrace );
        if (opt.verbose)
        { std::cout << "     skip trace #" << itrace << std::endl; }
        is.skipseries();
      }
    }
    
    // go to next file
    firstfile=false;
    ++infile;
  }
}

Here is the call graph for this function: