/************************************************************************/
/*  Populate_Station.pc: Load station information into the NCEDC database
/************************************************************************/
/*
    Author:
	Stephane Zuzlewski
	UC Berkeley Seismological Laboratory
	stephane@seismo.berkeley.edu

    Purpose:

    Modification History:
    Date	Ver	Who	What
    ---------------------------------------------------------------------
    1998/??/??	1.0	SMZ	Initial coding.
    2000/01/15	1.0	SMZ	Added support for SOH channels.
    2000/07/25	1.0	SMZ	Added support for optional channel
				comment in DLOGFC line.
    2000/08/14	1.0	SMZ	Added support for SEED location code.
    2000/10/19	1.0	SMZ	Changed float variables to double.
    2001/01/09	1.0	SMZ	Implemented closed time intervals;
				[Ts;Te[.
    2001/08/16	1.0	SMZ	Added support for Digital board.
    2002/01/30	1.0	SMZ	Added more explicit oracle error messages.
    2002/08/12	2.0	SMZ	Added support for external channel
				and source.				*/
/************************************************************************/

#ifndef lint
static char sccsid[] = "%W% %G% %U%";
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define		CONNECT_STRING	"user/passwd@db"
#define		NOMOREROWS	1403
#define		TOOMANYROWS	-2112
#define		VERSION		"2.0"
#define		info		stdout
   
char *syntax[] = {
"%s version " VERSION " -- Load station information into the NCEDC database.",
"%s  [-h] <Station .tbl file>",
"    where:",
"	-h	    Help - prints syntax message.",
NULL };

/************************************************************************/


EXEC SQL INCLUDE sqlca.h;


typedef char asciz[20];
typedef char vc2_arr[11];

  EXEC SQL BEGIN DECLARE SECTION;
  /* User-defined type for null-terminated strings */
  EXEC SQL TYPE asciz  IS STRING(20) REFERENCE;

  /* User-defined type for a VARCHAR array element */
  EXEC SQL TYPE vc2_arr IS VARCHAR2(11) REFERENCE;

  asciz		username;
  asciz		password;

  char		user_pwd[80];
  int		i;
  int		j;
  int		k;
  char		sta[7];		/* Station code */
  char		net[9];		/* Network code */
  double	lat;		/* Latitude */
  double	lon;		/* Longitude */
  double	elev;		/* Elevation */
  double	slat;		/* Sensor latitude */
  double	slon;		/* Sensor longitude */
  double	selev;		/* Sensor elevation */
  char		test[32];	/* Test string */
  char		staname[51];	/* Station name */
  int		nb_sensor;	/* Number of sensors */
  int		nb_filamp;	/* Number of filter-amplifiers */
  int		nb_digi;	/* Number of digitizers */
  int		nb_data;	/* Number of dataloggers */
  char		s_dat[32];	/* Start date */
  char		e_dat[32];	/* End date */

  int		sensor_nb;	/* Sensor number */
  char		sensor_sn[32];	/* Sensor serial number */
  double	depth;		/* Sensor depth */
  int		nb_component;	/* Number of components */

  int		pdn;		/* Preamplifier/Digitizer number */
  char		dtyp[32];	/* Digitizer type */
  double	az;		/* Azimuth */
  double	dip;		/* Dip */
  int		pdch;		/* Preamplifier/Digitizer channel */
  char		pdtyp;		/* Preamplifier/Digitizer */

  char		preamp_sn[32];	/* Preamplifier serial number */
  int		nch;		/* Number of channels */
  int		dno;		/* Digitizer number */
  int		dch;		/* Digitizer channel number */
  int		drch;		/* Digitizer *REAL* channel number */

  char		digi_sn[32];	/* Digitizer serial number */
  int		nb_pri;		/* Number of primary channels */
  int		nb_aux;		/* Number of auxiliary channels */
  int		nb_cha;		/* Total number of channels */

  int		dln;		/* Datalogger number */
  char		dtyp[32];	/* Digitizer type */
  int		dlch;		/* Datalogger channel number */
  char		pol[32];	/* Digitizer polarity */

  char		data_sn[32];	/* Datalogger serial number */
  int		dnch;		/* Number of channels */
  char		board_type;	/* Board type */
  char		channel_type;	/* Channel type */
  char		seed_io[32];	/* SEED instrument and orientation code */
  int		nbf;		/* Number of filters */

  char		seed[32];	/* Channel/Location/External field */
  char		seed1[32];
  char		seed2[32];
  char		seedchan[4];	/* SEED channel name */
  char		location[3];	/* SEED location code */
  char		channel[4];	/* External channel name */
  char		channelsrc[9];	/* External channel source */
  double	sps;		/* Sampling rate */
  double	mrgf;		/* Master rgain frequency */
  double	ctol;		/* Clock tolerance */
  char		dtyp[32];	/* Data type */
  char		seq[32];	/* Filter sequence */
  char		dfmt[32];	/* Data format */
  char		ctyp[32];	/* Compression type */
  int		blks;		/* Block size */

  int		sensor_id;	/* Sensor identifier */
  int		filamp_id;	/* Filter-amplifier identifier */
  int		data_id;	/* Datalogger identifier */
  int		seqfil_id;	/* Sequence of filters identifier */
  int		comp_type;	/* Compression type */
  int		unit_signal;	/* Units of signal responses */
  int		unit_calib;	/* Units of calibration */

  int		digi_nb;	/* Digitizer number */
  int		digi_pchannel_nb;	/* Digitizer physical channel number */
  int		data_nb;	/* Datalogger number */
  int		data_pchannel_nb;	/* Datalogger physical channel number */
  int		filamp_nb;	/* Filter-Amplifier number */
  int		filamp_pchannel_nb;	/* Filter-Amplifier physical channel number */
  int		sensor_nb;	/* Sensor number */
  int		component_nb;	/* Component number */
  int		channel_nb;	/* Channel number */

  char		remark[31];	/* Optional comment */

  short		ind;		/* Indicator */

  EXEC SQL END DECLARE SECTION;

/************************************************************************/
/*  External variables and symbols.					*/
/************************************************************************/
char *cmdname;			/* program name from command line.	*/

long		SQLCODE;
FILE*		f_err;		/* Error File descriptor */

void		sql_error();	/* handles unrecoverable errors */

/************************************************************************/
/*  print_syntax:							*/
/*	Print the syntax description of program.			*/
/************************************************************************/
int print_syntax
   (char	*cmd,		/* program name.			*/
    char	*syntax[],	/* syntax array.			*/
    FILE	*fp)		/* FILE ptr for output.			*/
{
    int i;
    for (i=0; syntax[i] != NULL; i++) {
	fprintf (fp, syntax[i], cmd);
	fprintf (fp, "\n");
    }
    return (0);
}


/************************************************************************/
/*  Convert_Date:							*/
/*	Function to convert a julian date to a Oracle date.		*/
/************************************************************************/
char*	Convert_Date (char d[16])
{
 EXEC SQL BEGIN DECLARE SECTION;
 static char	nd[32];
 char	day[16];
 EXEC SQL END DECLARE SECTION;

 char	hour[5];
 char	year[5];
 char	sday[4];


 sprintf (year, "%.4s", d);
 sprintf (sday,  "%.3s", d+5);
 sprintf (hour, "%.4s", d+9);

 if (!strcmp (year, "2599"))
	{
	 strcpy (nd, "3000/01/01 00:00:00");

	 return (nd);
	}
 else if (!strcmp (year, "????"))
	{
	 strcpy (nd, "0001/01/01 00:00:00");

	 return (nd);
	}

 strcpy (day, d);
 day[8] = '\0';

 EXEC SQL SELECT TO_CHAR (TO_DATE (:day, 'YYYY.DDD'), 'YYYY/MM/DD HH24:MI:SS') INTO :nd FROM DUAL;

 sprintf (nd, "%.4s/%.2s/%.2s %.2s:%.2s:00", year, nd+5, nd+8, hour, hour+2);

 return (nd);
}
	


/************************************************************************/
/*  main:   main program.
/************************************************************************/
main (int argc, char* argv[])
{
 FILE*	f_station; 	/* Station file descriptor */
 char	n_station[32];	/* Station file name */
 char	line[1025]; 	/* Line information */
 char	linecm[1025];	/* Line information */
 char	header[7];	/* Header */
 int	FlagCm = 0;	/* Comment Flag */

 char	sdat[16];	/* Start date */
 char	edat[16];	/* End date */

 char	*ctmp;

 /* Variables needed for getopt. */
 extern char	*optarg;
 extern int	optind, opterr;
 int		c;
 char	*p;

 cmdname = ((p = strrchr(*argv,'/')) != NULL) ? ++p : *argv;
 /*	Parse command line options.					*/
 while ( (c = getopt(argc,argv,"h")) != -1) switch (c) {
	case '?':
	case 'h':	print_syntax(cmdname,syntax,info); exit(0); break;
	default:	fprintf (info, "Unknown option: -%c\n", c); exit(1);
 }
 /*	Skip over all options and their arguments.			*/
 argv = &(argv[optind]);
 argc -= optind;

 /* Testing parameters */
 if (argc != 1)
	{
	 print_syntax(cmdname,syntax,info);

	 exit (0);
	}

 /* Opening the station file */
 sprintf (n_station, "%s", argv[0]);
 if ((f_station = fopen (n_station, "rt")) == NULL)
	{
	 printf ("\n Error [File (%s) could not be opened].\n\n", n_station);

	 exit (0);
	}

 /* Opening the error file */
 if ((f_err = fopen ("Error.log", "w+t")) == NULL)
	{
	 printf ("\n Error [File (Error.log) could not be opened].\n\n");

	 exit (0);
	}

 /* Connect to ORACLE. */
 EXEC SQL WHENEVER SQLERROR DO sql_error();

 strcpy (user_pwd, CONNECT_STRING);

 EXEC SQL CONNECT :user_pwd;

 printf ("\n Connected to ORACLE as user: %s\n", username);


 /* Parsing station file */
 fgets (line, 1024, f_station);

 while (!feof (f_station))
	{
	 strcpy (header, "");
	 sscanf (line, "%s", header);

	 if (!strcmp (header, "SCODE"))
		{
		 /* Reading station information */
		 sscanf (line, "%*s %s %s %lf %lf %lf \"%s\"", sta, net, &lat, &lon, &elev, staname);

		 strcpy (staname, strstr (line+15, staname));
		 staname[strlen (staname) - 2] = '\0';

		 printf ("\n Station : %s\t%s\t%f\t%f\t%f\t%s", sta, net, lat, lon, elev, staname);
		}
	 else if (!strcmp (header, "STINST"))
		{
		 /* Reading instrument information */
		 sscanf (line, "%*s %d %d %d %d %s %s", &nb_sensor, &nb_filamp, &nb_digi, &nb_data, sdat, edat);

		 /* Converting dates format */
		 strcpy (s_dat, Convert_Date (sdat));
		 strcpy (e_dat, Convert_Date (edat));

		 printf ("\n Instrument : %d\t%d\t%d\t%d\t%s\t%s", nb_sensor, nb_filamp, nb_digi, nb_data, s_dat, e_dat);

		 EXEC SQL INSERT INTO Station (sta, net, lat, lon, elev, staname, nb_sensor, nb_filamp, nb_digi, nb_data, datumhor, datumver, ondate, offdate, lddate)
		 VALUES (:sta, :net, :lat, :lon, :elev, :staname, :nb_sensor, :nb_filamp, :nb_digi, :nb_data, 'WGS84', 'WGS84', :s_dat, :e_dat, SYSDATE);

		 /* Reading sensor information */
		 for (i=1;i<=nb_sensor;i++)
			{
			 fgets (line, 1024, f_station);

			 /* Reading sensor information */
			 strcpy (test, "");
			 sscanf (line, "%*s %*s %*s %*s %*s %s", test);

			 if (strlen (test) == 0)
				{
			 	 sscanf (line, "%*s %s %d %lf %d", sensor_sn, &sensor_nb, &depth, &nb_component);

				 slat  =  lat;
				 slon  =  lon;
				 selev = elev;
				}
			 else sscanf (line, "%*s %s %d %lf %lf %lf %lf %d", sensor_sn, &sensor_nb, &slat, &slon, &selev, &depth, &nb_component);

			 printf ("\n\t Sensor %d: %s\t%f\t%d", sensor_nb, sensor_sn, depth, nb_component);

			 EXEC SQL SELECT sensor_id INTO :sensor_id FROM Sensor
			 WHERE serial_nb = :sensor_sn
			 AND   :s_dat >= ondate
			 AND   :s_dat < offdate;

			 if (sqlca.sqlcode == (TOOMANYROWS))
				{
				 fprintf (f_err, "\nError: Multiple entries for sensor 'serial_nb=%s, ondate<=%s<offdate' in table Sensor.\n\n", sensor_sn, s_dat);
				}


			 if (sensor_id == 0)
				{
				 printf ("\n\n Error: Couldn't find sensor [%s:%s].\n\n", sensor_sn, s_dat);

				 EXEC SQL ROLLBACK WORK RELEASE;

				 exit (0);
				}

			 EXEC SQL INSERT INTO Station_Sensor (sta, net, sensor_nb, sensor_id, lat, lon, elev, edepth, nb_component, datumhor, datumver, ondate, offdate, lddate)
			 VALUES (:sta, :net, :sensor_nb, :sensor_id, :slat, :slon, :selev, :depth, :nb_component, 'WGS84', 'WGS84', :s_dat, :e_dat, SYSDATE);

			 for (j=1;j<=nb_component;j++)
				{
				 fgets (line, 1024, f_station);

				 /* Reading component information */
				 strcpy (test, "");
				 sscanf (line, "%*s %*s %*s %*s %*s %*s %*s %s", test);

				 if (strlen (test) == 0)
					{
					 sscanf (line, "%*s %d %d %s %lf %lf %d", &channel_nb, &pdn, dtyp, &az, &dip, &pdch);

					 if (nb_filamp != 0)
						pdtyp = 'F';
					 else	pdtyp = 'D';
					}

			 	 else	sscanf (line, "%*s %d %d %s %lf %lf %d %c", &channel_nb, &pdn, dtyp, &az, &dip, &pdch, &pdtyp);

			 	 printf ("\n\t\t Component %d: %d %s %f %f %d %c", channel_nb, pdn, dtyp, az, dip, pdch, pdtyp);

				 EXEC SQL INSERT INTO Station_Sensor_Component (sta, net, sensor_nb, component_nb, next_hard_type, next_hard_nb, next_hard_pchannel, azimuth, dip, ondate, offdate, lddate)
				 	  VALUES (:sta, :net, :sensor_nb, :channel_nb, :pdtyp, :pdn, :pdch, :az, :dip, :s_dat, :e_dat, SYSDATE);
				}
			}

		 printf ("\n");

		 /* Reading preamplifier information */
		 for (i=1;i<=nb_filamp;i++)
			{
			 fgets (line, 1024, f_station);

			 /* Reading preamplifier information */
			 sscanf (line, "%*s %s %d", preamp_sn, &nch);

			 printf ("\n\t Preamplifier %d: %s\t%d", i, preamp_sn, nch);

			 EXEC SQL SELECT filamp_id INTO :filamp_id FROM Filamp
			 WHERE serial_nb = :preamp_sn
			 AND   :s_dat >= ondate
			 AND   :s_dat < offdate;

			 if (sqlca.sqlcode == (TOOMANYROWS))
				{
				 fprintf (f_err, "\nError: Multiple entries for filter-amplifier 'serial_nb=%s, ondate<=%s<offdate' in table Filamp.\n\n", preamp_sn, s_dat);
				}

			 if (filamp_id == 0)
				{
				 printf ("\n\n Error: Couldn't find Filter-Amplifier [%s:%s].\n\n", preamp_sn, s_dat);

				 EXEC SQL ROLLBACK WORK RELEASE;

				 exit (0);
				}

			 EXEC SQL INSERT INTO Station_Filamp (sta, net, filamp_nb, filamp_id, nb_pchannel, ondate, offdate, lddate)
			 VALUES (:sta, :net, :i, :filamp_id, :nch, :s_dat, :e_dat, SYSDATE);

			 for (j=1;j<=nch;j++)
				{
				 fgets (line, 1024, f_station);

				 /* Reading channel information */
				 sscanf (line, "%*s %*s %d %d %d", &dno, &channel_nb, &dch);

				 printf ("\n\t\t Channel %d: %d\t%d", channel_nb, dno, dch);

				 EXEC SQL INSERT INTO Station_Filamp_PChannel (sta, net, filamp_nb, pchannel_nb, next_hard_type, next_hard_nb, next_hard_pchannel, ondate, offdate, lddate)
				 VALUES (:sta, :net, :i, :channel_nb, 'D', :dno, :dch, :s_dat, :e_dat, SYSDATE);
				}
			}

		 printf ("\n");

		 /* Reading digitizer information */
		 for (i=1;i<=nb_digi;i++)
			{
			 fgets (line, 1024, f_station);

			 /* Reading digitizer information */
			 sscanf (line, "%*s %s %d %d", digi_sn, &nb_pri, &nb_aux);

			 nb_cha = nb_pri + nb_aux;

			 printf ("\n\t Digitizer %d: %s\t%d\t%d", i, digi_sn, nb_pri, nb_aux);

			 EXEC SQL INSERT INTO Station_Digitizer (sta, net, digi_nb, serial_nb, nb_pri_pchannel, nb_aux_pchannel, ondate, offdate, lddate)
			 VALUES (:sta, :net, :i, :digi_sn, :nb_pri, :nb_aux, :s_dat, :e_dat, SYSDATE);

			 for (j=1;j<=nb_cha;j++)
				{
				 fgets (line, 1024, f_station);

				 /* Reading channel information */
				 strcpy (test, "");
				 sscanf (line, "%*s %*s %*s %*s %*s %*s %*s %s", test);

				 if (strlen (test) == 0)
					{
					 sscanf (line, "%*s %*s %d %s %d %d %s", &dln, dtyp, &channel_nb, &dlch, pol);

					 drch = channel_nb;

					 printf ("\n\t\t Channel %d (%d): %d\t%s\t%d\t%s", channel_nb, drch, dln, dtyp, dlch, pol);
					}
				 else
					{
					 sscanf (line, "%*s %*s %d %s %d %d %s %d", &dln, dtyp, &channel_nb, &dlch, pol, &drch);

					 printf ("\n\t\t Channel %d (%d): %d\t%s\t%d\t%s", channel_nb, drch, dln, dtyp, dlch, pol);
					}

				 EXEC SQL INSERT INTO Station_Digitizer_PChannel (sta, net, digi_nb, pchannel_nb, data_nb, data_pchannel, digi_type, digi_polarity, digi_channel, ondate, offdate, lddate)
				 VALUES (:sta, :net, :i, :channel_nb, :dln, :dlch, :dtyp, :pol, :drch, :s_dat, :e_dat, SYSDATE);
				}
			}

		 printf ("\n");

		 /* Reading datalogger information */
		 for (i=1;i<=nb_data;i++)
			{
			 fgets (line, 1024, f_station);

			 /* Reading datalogger information */
			 sscanf (line, "%*s %s %d", data_sn, &dnch);

			 printf ("\n\t Datalogger %d: %s\t%d", i, data_sn, dnch);

			 EXEC SQL SELECT data_id INTO :data_id FROM Datalogger
			 WHERE serial_nb = :data_sn
			 AND   :s_dat >= ondate
			 AND   :s_dat < offdate;

			 if (sqlca.sqlcode == (TOOMANYROWS))
				{
				 fprintf (f_err, "\nError: Multiple entries for datalogger 'serial_nb=%s, ondate<=%s<offdate' in table Datalogger.\n\n", data_sn, s_dat);
				}

			 if (data_id == 0)
				{
				 printf ("\n\n Error: Couldn't find datalogger [%s:%s].\n\n", data_sn, s_dat);

				 EXEC SQL ROLLBACK WORK RELEASE;

				 exit (0);
				}

			 EXEC SQL INSERT INTO Station_Datalogger (sta, net, data_nb, data_id, nb_pchannel, ondate, offdate, lddate)
			 VALUES (:sta, :net, :i, :data_id, :dnch, :s_dat, :e_dat, SYSDATE);

			 for (j=1;j<=dnch;j++)
				{
				 fgets (line, 1024, f_station);

			 	 /* Reading physical channel information */
				 sscanf (line, "%*s %*s %d %s %d %*s %s %d", &channel_nb, dtyp, &dlch, seed_io, &nbf);

				 /* Updating board_type & channel_type */
				 if (dlch == 0)
					channel_type = 'S';
				 else	channel_type = 'P';

				 if (!strcmp (dtyp, "DSP"))
					board_type = 'P';
				 else if (!strcmp (dtyp, "AUX"))
					board_type = 'A';
				 else if (!strcmp (dtyp, "EXT"))
					board_type = 'E';
				 else if (!strcmp (dtyp, "DIG"))
					board_type = 'D';

				 printf ("\n\t\t Physical channel %d(%c -- %c): %s\t%d\t%s\t%d", channel_nb, board_type, channel_type, dtyp, dlch, seed_io, nbf);

				 EXEC SQL INSERT INTO Station_Datalogger_PChannel (sta, net, data_nb, pchannel_nb, board_type, channel_type, seed_io, nb_lchannel, ondate, offdate, lddate)
				 VALUES (:sta, :net, :i, :channel_nb, :board_type, :channel_type, :seed_io, :nbf, :s_dat, :e_dat, SYSDATE);

				 for (k=1;k<=nbf;k++)
					{
					 fgets (line, 1024, f_station);

					 /* Reading logical channel information */
					 strcpy (remark, "");
					 sscanf (line, "%*s %*s %s %lf %lf %lf %s %s %s %s %d %s", seed, &sps, &mrgf, &ctol, dtyp, seq, dfmt, ctyp, &blks, remark);

					 if (strcmp (remark, ""))
						{
						 strcpy (remark, strstr (line, remark));

						 strcpy (remark, remark+1);
						 remark[strlen (remark) -2] = '\0';
						}

					 if (mrgf < 0)
						mrgf = (-1.)/mrgf;

					 printf ("\n\t\t\t Logical channel %d: %s %6.2f %5.2f %5.2f %s %s %s %s %d [%s]", k, seed, sps, mrgf, ctol, dtyp, seq, dfmt, ctyp, blks, remark);

					 /* Processing SEED/External channel entry */
					 if ((ctmp = strstr (seed, ":")) != NULL)
						{
						 /* Extracting SEED/External entries */
						 int	z = 0;

						 strcpy (seed2, ctmp+1);

						 while (seed[z] != ':')
							seed1[z] = seed[z++];

						 seed1[z] = '\0';

						 /* Extracting SEED channel/location information */
						 if ((ctmp = strstr (seed1, ".")) != NULL)
							{
							 z = 0;

							 strcpy (location, ctmp+1);

							 while (seed1[z] != '.')
								seedchan[z] = seed1[z++];

							 seedchan[z] = '\0';

							 if (strlen (location) == 0)
								strcpy (location, "  ");
							}
						 else
							{
							 strcpy (seedchan, seed1);
							 strcpy (location, "  ");
							}

						 /* Extracting External channel/source information */
						 ctmp = strstr (seed2, ".");
						 z = 0;

						 strcpy (channelsrc, ctmp+1);

						 while (seed2[z] != '.')
							channel[z] = seed2[z++];

						 channel[z] = '\0';
						}
					 else
						{
						 /* Extracting SEED channel/location information */
						 if ((ctmp = strstr (seed, ".")) != NULL)
							{
							 int	z = 0;

							 strcpy (location, ctmp+1);

							 while (seed[z] != '.')
								seedchan[z] = seed[z++];

							 seedchan[z] = '\0';

							 if (strlen (location) == 0)
								strcpy (location, "  ");
							}
						 else
							{
							 strcpy (seedchan, seed);
							 strcpy (location, "  ");
							}

						 strcpy (channel, seedchan);
						 strcpy (channelsrc, "SEED");
						}

					 /* Computing sequence of filters identifier */
					 seqfil_id = 0;
					 EXEC SQL SELECT seqfil_id INTO :seqfil_id FROM Filter_Sequence WHERE name = :seq;

					 if (sqlca.sqlcode == (TOOMANYROWS))
						{
						 fprintf (f_err, "\nError: Multiple entries for FIR filters sequence 'name=%s' in table Filter_Sequence.\n\n", seq);
						}

					 if (seqfil_id == 0)
						ind = -1;
					 else	ind = 0;

					 /* Computing compression type */
					 comp_type = 0;

					 if (!strcmp (ctyp, "STEIM1"))
						strcpy (ctyp, "Steim-1%");
					 else if (!strcmp (ctyp, "STEIM2"))
						strcpy (ctyp, "Steim-2%");

					 EXEC SQL SELECT id INTO :comp_type FROM D_Format WHERE name LIKE :ctyp;

					 if (sqlca.sqlcode == (TOOMANYROWS))
						{
						 fprintf (f_err, "\nError: Multiple entries for data format 'name=%s' in table D_Format.\n\n", ctyp);
						}

					 if (comp_type == 0)
						 fprintf (f_err, "\n Error: Data Format %s not found.\n\n");

					 /* Computing units of signal responses */
					 if (channel_type == 'P')
						{
						 /* Retrieving digitizer links */
	 					 EXEC SQL SELECT digi_nb, pchannel_nb INTO :digi_nb, :digi_pchannel_nb
		  			  		  FROM	 Station_Digitizer_PChannel
							  WHERE	 sta = :sta
							  AND	 net = :net
						 	  AND    ondate = :s_dat
						 	  AND	 data_nb = :i
						 	  AND	 data_pchannel = :channel_nb;

						 if (sqlca.sqlcode == (TOOMANYROWS))
							{
							 fprintf (f_err, "\nError: Multiple entries for digitizer 'sta=%s, net=%s, ondate=%s, data_nb=%d, data_pchannel=%d' in table Station_Digitizer_Pchannel.\n\n", sta, net, s_dat, i, channel_nb);
							}

						 /* Testing if filter/amplifier is present */
						 filamp_nb = 0;

						 EXEC SQL SELECT filamp_nb, pchannel_nb INTO :filamp_nb, :filamp_pchannel_nb
							  FROM	 Station_Filamp_PChannel
							  WHERE	 sta = :sta
							  AND    net = :net
							  AND    ondate = :s_dat
							  AND	 next_hard_type = 'D'
							  AND	 next_hard_nb = :digi_nb
							  AND	 next_hard_pchannel = :digi_pchannel_nb;

						 if (sqlca.sqlcode == (TOOMANYROWS))
							{
							 fprintf (f_err, "\nError: Multiple entries for filter-amplifier 'sta=%s, net=%s, ondate=%s, next_hard_type=D, next_hard_nb=%d, next_hard_pchannel=%d' in table Station_Filamp_Pchannel.\n\n", sta, net, s_dat, digi_nb, digi_pchannel_nb);
							}

						 /* Retrieving filter-amplifier and/or sensor information */
						 if (filamp_nb == 0)
							{
							 EXEC SQL SELECT sensor_nb, component_nb INTO :sensor_nb, :component_nb
								  FROM	 Station_Sensor_Component
								  WHERE	 sta = :sta
								  AND    net = :net
								  AND    ondate = :s_dat
								  AND	 next_hard_type = 'D'
								  AND	 next_hard_nb = :digi_nb
								  AND	 next_hard_pchannel = :digi_pchannel_nb;

							 if (sqlca.sqlcode == (TOOMANYROWS))
								{
								 fprintf (f_err, "\nError: Multiple entries for sensor 'sta=%s, net=%s, ondate=%s, next_hard_type=D, next_hard_nb=%d, next_hard_pchannel=%d' in table Station_Sensor_component.\n\n", sta, net, s_dat, digi_nb, digi_pchannel_nb);
								}
							}
						 else
							{
							 EXEC SQL SELECT sensor_nb, component_nb INTO :sensor_nb, :component_nb
								  FROM	 Station_Sensor_Component
								  WHERE	 sta = :sta
								  AND    net = :net
								  AND    ondate = :s_dat
								  AND	 next_hard_type = 'F'
								  AND	 next_hard_nb = :filamp_nb
								  AND	 next_hard_pchannel = :filamp_pchannel_nb;

							 if (sqlca.sqlcode == (TOOMANYROWS))
								{
								 fprintf (f_err, "\nError: Multiple entries for sensor 'sta=%s, net=%s, ondate=%s, next_hard_type=F, next_hard_nb=%d, next_hard_pchannel=%d' in table Station_Sensor_component.\n\n", sta, net, s_dat, filamp_nb, filamp_pchannel_nb);
								}
							}

						 EXEC SQL SELECT sensor_id INTO :sensor_id
							  FROM	 Station_Sensor
							  WHERE	 sta = :sta
							  AND    net = :net
							  AND    ondate = :s_dat
							  AND	 sensor_nb = :sensor_nb;

						 if (sqlca.sqlcode == (TOOMANYROWS))
							{
							 fprintf (f_err, "\nError: Multiple entries for sensor 'sta=%s, net=%s, ondate=%s, sensor_nb=%d' in table Station_Sensor.\n\n", sta, net, s_dat, sensor_nb);
							}

						 /* Computing units of signal */
						 unit_signal = 0;

						 EXEC SQL SELECT DISTINCT unit_in INTO :unit_signal FROM Response WHERE seqresp_id = (SELECT seqresp_id FROM Sensor_Component WHERE sensor_id = :sensor_id AND component_nb = :component_nb);

						 if (sqlca.sqlcode == (TOOMANYROWS))
							{
							 fprintf (f_err, "\nError: Multiple entries for FIR filters sequence 'sensor_id=%d, component_nb=%d' in table Sensor_Component.\n\n", sensor_id, component_nb);
							}

						 if (unit_signal == 0)
							{
							 printf ("\n\n Error: Couldn't find units of sensor [%d:%d:%s:%d].\n\n", sensor_nb, sensor_id, sensor_sn, component_nb);

							 EXEC SQL ROLLBACK WORK RELEASE;

							 exit (0);
							}
						}
					 else
						{
						 /* Computing units of signal */
						 unit_signal = 0;
						 EXEC SQL SELECT id INTO :unit_signal FROM D_Unit WHERE name = 'COUNTS';

						 if (sqlca.sqlcode == (TOOMANYROWS))
							{
							 fprintf (f_err, "\nError: Multiple entries for unit 'name=COUNTS' in table D_Unit.\n\n");
							}

						 if (unit_signal == 0)
							{
							 EXEC SQL SELECT uniseq.NEXTVAL INTO :unit_signal FROM DUAL;

							 EXEC SQL INSERT INTO D_Unit (id, name, description)
							 VALUES (:unit_signal, 'COUNTS', NULL);
							}
						}

					 /* Computing units of calibration */
					 unit_calib = 0;
					 EXEC SQL SELECT id INTO :unit_calib FROM D_Unit WHERE name = 'A';

					 if (sqlca.sqlcode == (TOOMANYROWS))
						{
						 fprintf (f_err, "\nError: Multiple entries for unit 'name=A' in table D_Unit.\n\n");
						}

					 if (unit_calib == 0)
						{
						 EXEC SQL SELECT uniseq.NEXTVAL INTO :unit_calib FROM DUAL;

						 EXEC SQL INSERT INTO D_Unit (id, name, description)
						 VALUES (:unit_calib, 'A', NULL);
						}

					 EXEC SQL INSERT INTO Station_Datalogger_LChannel (sta, net, data_nb, pchannel_nb, lchannel_nb, seqfil_id, seedchan, channel, channelsrc, location, rgain, rfrequency, samprate, clock_drift, flags, data_format, comp_type, unit_signal, unit_calib, block_size, ondate, offdate, remark, lddate)
					 VALUES (:sta, :net, :i, :channel_nb, :k, :seqfil_id:ind, :seedchan, :channel, :channelsrc, :location, NULL, :mrgf, :sps, :ctol, :dtyp, :dfmt, :comp_type, :unit_signal, :unit_calib, :blks, :s_dat, :e_dat, :remark, SYSDATE);
					}
				}
			}
		}


	 fgets (line, 1024, f_station);
	}


 fprintf (f_err, "\n");
 printf ("\n\n");

 /* Closing error file */
 fclose (f_err);

 /* Closing station file */
 fclose (f_station);


 /* Disconnect from the database */
 printf ("\n Disconnecting from ORACLE ...\n\n");

 EXEC SQL COMMIT WORK RELEASE;

 exit(0);
}

/************************************************************************/
/* sql_error:
/*	Handle errors. Exit on any error.
/************************************************************************/
void sql_error()
{
 char msg[512];
 size_t buf_len, msg_len;


 EXEC SQL WHENEVER SQLERROR CONTINUE;

 buf_len = sizeof(msg);
 sqlglm(msg, &buf_len, &msg_len);

 fprintf(f_err, "\nORACLE error detected:");
 fprintf(f_err, "\n%.*s \n", msg_len, msg);

 printf("\nORACLE error detected:");
 printf("\n%.*s \n", msg_len, msg);
}