/************************************************************************/
/*  Populate_SimpleSEED: Populates simplified response from a rdseed file.
/************************************************************************/
/*
    Author:
	Stephane Zuzlewski
	UC Berkeley Seismological Laboratory
	stephane@seismo.berkeley.edu

    Purpose:	Populates stages 1, 2 & 0 from a rdseed output style file
		(s option) into the IR schema.

    Modification History:
    Date	Ver	Who	What
    ---------------------------------------------------------------------
    2002/11/25	1.0	SMZ	Initial coding (Stages 1 & 0).
    2002/12/11	1.0	SMZ	Added digitizer stage (2).
/************************************************************************/

#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		VERSION		"1.0"
#define		info		stdout
#define		CALDATE		"/usr/local/bin/caldate -f \"%Y/%m/%d %H:%M:%S\""

typedef struct	{
		 char	net[9];
		 char	sta[7];
		 double	lat;
		 double	lon;
		 double	elev;
		 char	staname[51];
		 int	net_id;
		 int	word_32;
		 int	word_16;
		 char	ondate[20];
		 char	offdate[20];
		} Station_Data;

typedef struct	{
		 char	net[8];
		 char	sta[7];
		 char	seedchan[4];
		 char	location[3];
		 int	inid;
		 char	remark[31];
		 int	unit_signal;
		 int	unit_calib;
		 double	lat;
		 double	lon;
		 double	elev;
		 double	edepth;
		 double	azimuth;
		 double	dip;
		 int	format_id;
		 int	record_length;
		 double	samprate;
		 double	clock_drift;
		 char	flags[28];
		 char	ondate[20];
		 char	offdate[20];
		} Channel_Data;

typedef struct {
		char	name[255];
		int	family;
		int	nb_keys;
		char	key[255][255];
	       } Format_Data;

typedef struct {
		double	r_value;
		double	r_error;
		double	i_value;
		double	i_error;
	       } PZ;

typedef struct {
		int	unit_in;
		int	unit_out;
		double	AO;
		double	AF;
		int	nb_poles;
		int	nb_zeros;
		PZ	poles[255];
		PZ	zeros[255];
	       } PZ_Data;

typedef struct {
		double	sensitivity;
		double	frequency;
	       } Gain_Data;

typedef struct {
		int	unit_in;
		int	unit_out;
		} DC;

typedef struct {
		double	samprate;
		int	factor;
		int	offset;
		double	delay;
		double	correction;
	       } DM;
   
char *syntax[] = {
"%s version " VERSION " -- Populates simplified response from a rdseed file.",
"%s  [-h] [-v] [-p] <response file>",
"    where:",
"	-h	    Help - prints syntax message.",
"	-v	    Verbose mode.",
"	-p	    Population mode.",
NULL };

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

EXEC SQL INCLUDE sqlca.h;


EXEC SQL BEGIN DECLARE SECTION;
char	user_pwd[80];

int	id;
int	itmp;
char	stmp[255];
char	stmp2[255];
short	ind;

char	net[9];
char	sta[7];
double	lat;
double	lon;
double	elev;
char	staname[51];
int	net_id;
int	word_32;
int	word_16;
char	ondate[20];
char	offdate[20];

char	seedchan[4];
char	location[3];
int	inid;
char	remark[31];
int	unit_signal;
int	unit_calib;
double	edepth;
double	azimuth;
double	dip;
int	format_id;
int	record_length;
double	samprate;
double	clock_drift;
char	flags[28];

int	pz_key;
int	unit_in;
int	unit_out;
double	AO;
double	AF;

double	r_value;
double	r_error;
double	i_value;
double	i_error;

double	sensitivity;
double	frequency;

int	dm_key;
int	factor;
int	offset;
double	delay;
double	correction;

EXEC SQL END DECLARE SECTION;

EXEC SQL DECLARE sql_stmt    STATEMENT;

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

long      SQLCODE;

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);
}

/************************************************************************/
/*  main:   main program.
/************************************************************************/
main (int	argc, char	*argv[])
{
 int		FlagV = 0;	/* Verbose Flag */
 int		FlagP = 0;	/* Population Flag */
 FILE		*frdseed;	/* RDSEED File Descriptor */
 char		nrdseed[255];	/* RDSEED File Name */
 char		line[256];	/* Current Line */
 char		header[32];	/* Blockette Header */
 Station_Data	sdata;		/* Station Information */
 Channel_Data	cdata;		/* Channel Information */
 Format_Data	fdata;		/* Format Information */
 PZ_Data	pzdata[16];	/* Poles & Zeros Information */
 Gain_Data	gdata[64];	/* Gain Information */
 DC		dcdata[64];	/* Coefficients Information */
 DM		dmdata[64];	/* Decimation Information */
 int		Stage_Nb = 0;	/* Current Stage Number */
 FILE		*cmd_ptr;	/* Command Line File Descriptor */
 char		cmd_line[256];	/* Command Line */
 int		i;		/* Loop Variable */


 /* 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,"hvp")) != -1) switch (c) {
	case '?':
	case 'h':	print_syntax(cmdname,syntax,info); exit(0); break;
	case 'v':	FlagV = 1; break;
	case 'p':	FlagP = 1; break;
	default:	fprintf (info, "Unknown option: -%c\n", c); exit(1);
 }
 /*	Skip over all options and their arguments.			*/
 argv = &(argv[optind]);
 argc -= optind;

 if (argc != 1)
	{
	 print_syntax(cmdname,syntax,info);
	 exit(0);
	}
 else	strcpy (nrdseed, argv[0]);

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

 strcpy (user_pwd, CONNECT_STRING);

 EXEC SQL CONNECT :user_pwd;

 /* Opening RDSEED file */
 if (FlagV)
 	printf ("\n Processing file %s ...\n", nrdseed);

 if ((frdseed = fopen (nrdseed, "rt")) == NULL)
	{
	 printf ("\n Error: couldn't open file %s.\n", nrdseed);

	 exit (-1);
	}

 /* Reading RDSEED file */
 fgets (line, 255, frdseed);
 while (!feof (frdseed))
	{
	 sscanf (line, "%s", header);

	 /* Blockette 50 - Station Information */
	 if (!strcmp (header, "B050F03"))
		{
		 sscanf (line, "%*s %*s %*s %s", &sdata.sta);

		 if (FlagV)
			printf ("\n\n%s\t%s", header, sdata.sta);
		}
	 else if (!strcmp (header, "B050F04"))
		{
		 sscanf (line, "%*s %*s %lf", &sdata.lat);

		 if (FlagV)
			printf ("\n%s\t%f", header, sdata.lat);
		}
	 else if (!strcmp (header, "B050F05"))
		{
		 sscanf (line, "%*s %*s %lf", &sdata.lon);

		 if (FlagV)
			printf ("\n%s\t%f", header, sdata.lon);
		}
	 else if (!strcmp (header, "B050F06"))
		{
		 sscanf (line, "%*s %*s %lf", &sdata.elev);

		 if (FlagV)
			printf ("\n%s\t%f", header, sdata.elev);
		}
	 else if (!strcmp (header, "B050F09"))
		{
		 char tmp[32];

		 sscanf (line, "%*s %*s %s", tmp);
		 strcpy (sdata.staname, strstr (line, tmp));
		 sdata.staname[strlen (sdata.staname) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s\t%s", header, sdata.staname);
		}
	 else if (!strcmp (header, "B050F10"))
		{
		 char tmp[32];
		 char owner[255];

		 sscanf (line, "%*s %*s %*s %*s %*s %s", tmp);
		 strcpy (owner, strstr (line, tmp));
		 owner[strlen (owner) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s\t%s", header, owner);

		 if (FlagP)
			{
			 id = (-1);
			 strcpy (stmp, owner);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Abbreviation
					WHERE	description = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 EXEC SQL	SELECT	abbseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Abbreviation
						(id, description)
						VALUES (:id, :stmp);

				 sdata.net_id = id;
				}
			 else
				{
				 sdata.net_id = id;
				}

			 if (FlagV)
				printf ("\n%s\tnet_id = %d", "DB", sdata.net_id);
			}
		}
	 else if (!strcmp (header, "B050F11"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &sdata.word_32);

		 if (FlagV)
			printf ("\n%s\t%d", header, sdata.word_32);
		}
	 else if (!strcmp (header, "B050F12"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &sdata.word_16);

		 if (FlagV)
			printf ("\n%s\t%d", header, sdata.word_16);
		}
	 else if (!strcmp (header, "B050F13"))
		{
		 char	tmp[20];

		 sscanf (line, "%*s %*s %*s %s", tmp);

		 if (!strcmp (tmp, "(null)"))
			strcpy (sdata.ondate, "3000/01/01 00:00:00");
		 else
			{
			 sprintf (cmd_line , "%s %s", CALDATE, tmp);
			 if ((cmd_ptr = popen (cmd_line,"r")) == NULL)
				exit (-1);
			 if ((fgets (sdata.ondate, 255, cmd_ptr)) == NULL)
				exit (-1);
			 pclose (cmd_ptr);
			 sdata.ondate[strlen (sdata.ondate) - 1] = '\0';
			}

		 if (FlagV)
			printf ("\n%s\t%s", header, sdata.ondate);
		}
	 else if (!strcmp (header, "B050F14"))
		{
		 char	tmp[20];

		 sscanf (line, "%*s %*s %*s %s", tmp);

		 if (!strcmp (tmp, "(null)"))
			strcpy (sdata.offdate, "3000/01/01 00:00:00");
		 else
			{
			 sprintf (cmd_line , "%s %s", CALDATE, tmp);
			 if ((cmd_ptr = popen (cmd_line,"r")) == NULL)
				exit (-1);
			 if ((fgets (sdata.offdate, 255, cmd_ptr)) == NULL)
				exit (-1);
			 pclose (cmd_ptr);
			 sdata.offdate[strlen (sdata.offdate) - 1] = '\0';
			}

		 if (FlagV)
			printf ("\n%s\t%s", header, sdata.offdate);
		}
	 else if (!strcmp (header, "B050F16"))
		{
		 sscanf (line, "%*s %*s %*s %s", &sdata.net);

		 if (FlagV)
			printf ("\n%s\t%s", header, sdata.net);
		}

	 /* Blockette 52 - Channel Information */
	 else if (!strcmp (header, "B052F04"))
		{
		 sscanf (line, "%*s %*s %s", &cdata.seedchan);

		 if (FlagV)
			printf ("\n\n%s\t%s", header, cdata.seedchan);
		}
	 else if (!strcmp (header, "B052F03"))
		{
		 strcpy (cdata.location, "");
		 sscanf (line, "%*s %*s %s", &cdata.location);

		 if (strlen (cdata.location) == 0)
			strcpy (cdata.location, "  ");

		 if (FlagV)
			printf ("\n%s\t%s", header, cdata.location);
		}
	 else if (!strcmp (header, "B052F06"))
		{
		 char tmp[32];
		 char inst_type[255];

		 sscanf (line, "%*s %*s %*s %*s %s", tmp);
		 strcpy (inst_type, strstr (line, tmp));
		 inst_type[strlen (inst_type) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s\t%s", header, inst_type);

		 if (FlagP)
			{
			 id = (-1);
			 strcpy (stmp, inst_type);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Abbreviation
					WHERE	description = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 EXEC SQL	SELECT	abbseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Abbreviation
						(id, description)
						VALUES (:id, :stmp);

				 cdata.inid = id;
				}
			 else
				{
				 cdata.inid = id;
				}

			 if (FlagV)
				printf ("\n%s\tinid = %d", "DB", cdata.inid);
			}
		}
	 else if (!strcmp (header, "B052F07"))
		{
		 char tmp[32];

		 sscanf (line, "%*s %*s %s", tmp);
		 strcpy (cdata.remark, strstr (line, tmp));
		 cdata.remark[strlen (cdata.remark) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s\t%s", header, cdata.remark);
		}
	 else if (!strcmp (header, "B052F08"))
		{
		 char sig_name[127];
		 char sig_desc[127];

		 sscanf (line, "%*s %*s %*s %*s %*s %s", sig_name);
		 strcpy (sig_desc, strstr (line, sig_name) + strlen (sig_name) + 3);
		 sig_desc[strlen (sig_desc) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s\t%s [%s]", header, sig_name, sig_desc);

		 if (FlagP)
			{
			 id = (-1);
			 strcpy (stmp, sig_name);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Unit
					WHERE	name = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 strcpy (stmp2, sig_desc);

				 EXEC SQL	SELECT	uniseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Unit
						(id, name, description)
						VALUES (:id, :stmp, :stmp2);

				 cdata.unit_signal = id;
				}
			 else
				{
				 cdata.unit_signal = id;
				}

			 if (FlagV)
				printf ("\n%s\tunit_signal = %d", "DB", cdata.unit_signal);
			}
		}
	 else if (!strcmp (header, "B052F09"))
		{
		 char cal_name[127];
		 char cal_desc[127];

		 sscanf (line, "%*s %*s %*s %*s %*s %s", cal_name);
		 strcpy (cal_desc, strstr (line, cal_name) + strlen (cal_name) + 3);
		 cal_desc[strlen (cal_desc) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s\t%s [%s]", header, cal_name, cal_desc);

		 if (FlagP)
			{
			 id = (-1);
			 strcpy (stmp, cal_name);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Unit
					WHERE	name = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 strcpy (stmp2, cal_desc);

				 EXEC SQL	SELECT	uniseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Unit
						(id, name, description)
						VALUES (:id, :stmp, :stmp2);

				 cdata.unit_calib = id;
				}
			 else
				{
				 cdata.unit_calib = id;
				}

			 if (FlagV)
				printf ("\n%s\tunit_calib = %d", "DB", cdata.unit_calib);
			}
		}
	 else if (!strcmp (header, "B052F10"))
		{
		 sscanf (line, "%*s %*s %lf", &cdata.lat);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.lat);
		}
	 else if (!strcmp (header, "B052F11"))
		{
		 sscanf (line, "%*s %*s %lf", &cdata.lon);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.lon);
		}
	 else if (!strcmp (header, "B052F12"))
		{
		 sscanf (line, "%*s %*s %lf", &cdata.elev);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.elev);
		}
	 else if (!strcmp (header, "B052F13"))
		{
		 sscanf (line, "%*s %*s %*s %lf", &cdata.edepth);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.edepth);
		}
	 else if (!strcmp (header, "B052F14"))
		{
		 sscanf (line, "%*s %*s %lf", &cdata.azimuth);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.azimuth);
		}
	 else if (!strcmp (header, "B052F15"))
		{
		 sscanf (line, "%*s %*s %lf", &cdata.dip);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.dip);
		}
	 else if (!strcmp (header, "B030F03"))
		{
		 char tmp[32];

		 sscanf (line, "%*s %*s %*s %s", tmp);
		 strcpy (fdata.name, strstr (line, tmp));
		 fdata.name[strlen (fdata.name) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s\t%s", header, fdata.name);
		}
	 else if (!strcmp (header, "B030F05"))
		{
		 sscanf (line, "%*s %*s %*s %d", &fdata.family);

		 if (FlagV)
			printf ("\n%s\t%d", header, fdata.family);
		}
	 else if (!strcmp (header, "B030F06"))
		{
		 int	i;
		 char	tmp[32];

		 sscanf (line, "%*s %*s %*s %*s %d", &fdata.nb_keys);

		 if (FlagV)
			printf ("\n%s\t%d", header, fdata.nb_keys);

		 for (i=0;i<fdata.nb_keys;i++)
			{
			 fgets (line, 255, frdseed);
			 sscanf (line, "%*s %*s %*s %s", tmp);
			 strcpy (fdata.key[i], strstr (line, tmp));
			 fdata.key[i][strlen (fdata.key[i]) - 1] = '\0';

			 if (FlagV)
			 	printf ("\n%s\t%s", "B030F07", fdata.key[i]);
			}

		 if (FlagP)
			{
			 id = (-1);
			 strcpy (stmp, fdata.name);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Format
					WHERE	name = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 itmp = fdata.family;

				 EXEC SQL	SELECT	forseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Format
						(id, name, family, ms_id)
						VALUES (:id, :stmp, :itmp, 0);

				 for (i=0;i<fdata.nb_keys;i++)
					{
					 strcpy (stmp2, fdata.key[i]);
					 itmp = i+1;

					 EXEC SQL	INSERT INTO D_Format_Data
							(id, row_id, key_d)
							VALUES (:id, :itmp, :stmp2);
					}

				 cdata.format_id = id;
				}
			 else
				{
				 cdata.format_id = id;
				}

			 if (FlagV)
				printf ("\n%s\tformat_id = %d", "DB", cdata.format_id);
			}
		}
	 else if (!strcmp (header, "B052F17"))
		{
		 sscanf (line, "%*s %*s %*s %*s %*s %*s %d", &cdata.record_length);

		 if (FlagV)
			printf ("\n%s\t%d", header, cdata.record_length);
		}
	 else if (!strcmp (header, "B052F18"))
		{
		 sscanf (line, "%*s %*s %*s %lf", &cdata.samprate);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.samprate);
		}
	 else if (!strcmp (header, "B052F19"))
		{
		 sscanf (line, "%*s %*s %*s %lf", &cdata.clock_drift);

		 if (FlagV)
			printf ("\n%s\t%f", header, cdata.clock_drift);
		}
	 else if (!strcmp (header, "B052F21"))
		{
		 sscanf (line, "%*s %*s %*s %s", cdata.flags);

		 if (FlagV)
			printf ("\n%s\t%s", header, cdata.flags);
		}
	 else if (!strcmp (header, "B052F22"))
		{
		 char	tmp[20];

		 sscanf (line, "%*s %*s %*s %s", tmp);

		 if (!strcmp (tmp, "(null)"))
			strcpy (cdata.ondate, "3000/01/01 00:00:00");
		 else
			{
			 sprintf (cmd_line , "%s %s", CALDATE, tmp);
			 if ((cmd_ptr = popen (cmd_line,"r")) == NULL)
				exit (-1);
			 if ((fgets (cdata.ondate, 255, cmd_ptr)) == NULL)
				exit (-1);
			 pclose (cmd_ptr);
			 cdata.ondate[strlen (cdata.ondate) - 1] = '\0';
			}

		 if (FlagV)
			printf ("\n%s\t%s", header, cdata.ondate);
		}
	 else if (!strcmp (header, "B052F23"))
		{
		 char	tmp[20];

		 sscanf (line, "%*s %*s %*s %s", tmp);

		 if (!strcmp (tmp, "(null)"))
			strcpy (cdata.offdate, "3000/01/01 00:00:00");
		 else
			{
			 sprintf (cmd_line , "%s %s", CALDATE, tmp);
			 if ((cmd_ptr = popen (cmd_line,"r")) == NULL)
				exit (-1);
			 if ((fgets (cdata.offdate, 255, cmd_ptr)) == NULL)
				exit (-1);
			 pclose (cmd_ptr);
			 cdata.offdate[strlen (cdata.offdate) - 1] = '\0';
			}

		 if (FlagV)
			printf ("\n%s\t%s", header, cdata.offdate);
		}

	 /* Blockette 53 - Response (Poles & Zeros) Information */
	 else if (!strcmp (header, "B053F04"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &Stage_Nb);

		 if (FlagV)
			printf ("\n\n%s[%d]\t%d", header, Stage_Nb, Stage_Nb);
		}
	 else if (!strcmp (header, "B053F05"))
		{
		 char in_name[127];
		 char in_desc[127];

		 sscanf (line, "%*s %*s %*s %*s %*s %s", in_name);
		 strcpy (in_desc, strstr (line, in_name) + strlen (in_name) + 3);
		 in_desc[strlen (in_desc) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s[%d]\t%s [%s]", header, Stage_Nb, in_name, in_desc);

		 if (FlagP)
			{
			 id = (-1);
			 strcpy (stmp, in_name);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Unit
					WHERE	name = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 strcpy (stmp2, in_desc);

				 EXEC SQL	SELECT	uniseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Unit
						(id, name, description)
						VALUES (:id, :stmp, :stmp2);

				 pzdata[Stage_Nb].unit_in = id;
				}
			 else
				{
				 pzdata[Stage_Nb].unit_in = id;
				}

			 if (FlagV)
				printf ("\n%s\tunit_in = %d", "DB", pzdata[Stage_Nb].unit_in);
			}
		}
	 else if (!strcmp (header, "B053F06"))
		{
		 char out_name[127];
		 char out_desc[127];

		 sscanf (line, "%*s %*s %*s %*s %*s %s", out_name);
		 strcpy (out_desc, strstr (line, out_name) + strlen (out_name) + 3);
		 out_desc[strlen (out_desc) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s[%d]\t%s [%s]", header, Stage_Nb, out_name, out_desc);

		 if (FlagP)
			{
			 id = (-1);
			 strcpy (stmp, out_name);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Unit
					WHERE	name = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 strcpy (stmp2, out_desc);

				 EXEC SQL	SELECT	uniseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Unit
						(id, name, description)
						VALUES (:id, :stmp, :stmp2);

				 pzdata[Stage_Nb].unit_out = id;
				}
			 else
				{
				 pzdata[Stage_Nb].unit_out = id;
				}

			 if (FlagV)
				printf ("\n%s\tunit_out = %d", "DB", pzdata[Stage_Nb].unit_out);
			}
		}
	 else if (!strcmp (header, "B053F07"))
		{
		 sscanf (line, "%*s %*s %*s %*s %lf", &pzdata[Stage_Nb].AO);

		 if (FlagV)
			printf ("\n%s[%d]\t%f", header, Stage_Nb, pzdata[Stage_Nb].AO);
		}
	 else if (!strcmp (header, "B053F08"))
		{
		 sscanf (line, "%*s %*s %*s %lf", &pzdata[Stage_Nb].AF);

		 if (FlagV)
			printf ("\n%s[%d]\t%f", header, Stage_Nb, pzdata[Stage_Nb].AF);
		}
	 else if (!strcmp (header, "B053F09"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &pzdata[Stage_Nb].nb_zeros);

		 if (FlagV)
			printf ("\n%s[%d]\t%d", header, Stage_Nb, pzdata[Stage_Nb].nb_zeros);
		}
	 else if (!strcmp (header, "B053F14"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &pzdata[Stage_Nb].nb_poles);

		 if (FlagV)
			printf ("\n%s[%d]\t%d", header, Stage_Nb, pzdata[Stage_Nb].nb_poles);
		}
	 else if (!strcmp (header, "B053F10-13"))
		{
		 int	z_nb;

		 sscanf (line, "%*s %d", &z_nb);
		 sscanf (line, "%*s %*s %lf %lf %lf %lf",
				&pzdata[Stage_Nb].zeros[z_nb].r_value,
				&pzdata[Stage_Nb].zeros[z_nb].i_value,
				&pzdata[Stage_Nb].zeros[z_nb].r_error,
				&pzdata[Stage_Nb].zeros[z_nb].i_error);

		 if (FlagV)
			printf ("\n%s[%d]\t%d\t%f\t%f\t%f\t%f", header, Stage_Nb, z_nb, 
				pzdata[Stage_Nb].zeros[z_nb].r_value,
				pzdata[Stage_Nb].zeros[z_nb].i_value,
				pzdata[Stage_Nb].zeros[z_nb].r_error,
				pzdata[Stage_Nb].zeros[z_nb].i_error);
		}
	 else if (!strcmp (header, "B053F15-18"))
		{
		 int	p_nb;

		 sscanf (line, "%*s %d", &p_nb);
		 sscanf (line, "%*s %*s %lf %lf %lf %lf",
				&pzdata[Stage_Nb].poles[p_nb].r_value,
				&pzdata[Stage_Nb].poles[p_nb].i_value,
				&pzdata[Stage_Nb].poles[p_nb].r_error,
				&pzdata[Stage_Nb].poles[p_nb].i_error);

		 if (FlagV)
			printf ("\n%s[%d]\t%d\t%f\t%f\t%f\t%f", header, Stage_Nb, p_nb, 
				pzdata[Stage_Nb].poles[p_nb].r_value,
				pzdata[Stage_Nb].poles[p_nb].i_value,
				pzdata[Stage_Nb].poles[p_nb].r_error,
				pzdata[Stage_Nb].poles[p_nb].i_error);
		}

	 /* Blockette 54 - Response (Coefficients) Information */
	 else if (!strcmp (header, "B054F04"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &Stage_Nb);

		 if (FlagV)
			printf ("\n\n%s[%d]\t%d", header, Stage_Nb, Stage_Nb);
		}
	 else if (!strcmp (header, "B054F05"))
		{
		 char in_name[127];
		 char in_desc[127];

		 sscanf (line, "%*s %*s %*s %*s %*s %s", in_name);
		 strcpy (in_desc, strstr (line, in_name) + strlen (in_name) + 3);
		 in_desc[strlen (in_desc) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s[%d]\t%s [%s]", header, Stage_Nb, in_name, in_desc);

		 if ((Stage_Nb == 2) && (FlagP))
			{
			 id = (-1);
			 strcpy (stmp, in_name);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Unit
					WHERE	name = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 strcpy (stmp2, in_desc);

				 EXEC SQL	SELECT	uniseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Unit
						(id, name, description)
						VALUES (:id, :stmp, :stmp2);

				 dcdata[Stage_Nb].unit_in = id;
				}
			 else
				{
				 dcdata[Stage_Nb].unit_in = id;
				}

			 if (FlagV)
				printf ("\n%s\tunit_in = %d", "DB", dcdata[Stage_Nb].unit_in);
			}
		}
	 else if (!strcmp (header, "B054F06"))
		{
		 char out_name[127];
		 char out_desc[127];

		 sscanf (line, "%*s %*s %*s %*s %*s %s", out_name);
		 strcpy (out_desc, strstr (line, out_name) + strlen (out_name) + 3);
		 out_desc[strlen (out_desc) - 1] = '\0';

		 if (FlagV)
			printf ("\n%s[%d]\t%s [%s]", header, Stage_Nb, out_name, out_desc);

		 if ((Stage_Nb == 2) && (FlagP))
			{
			 id = (-1);
			 strcpy (stmp, out_name);

			 EXEC SQL	SELECT	id
					INTO	:id:ind
					FROM	D_Unit
					WHERE	name = :stmp;

			 if ((id == (-1)) || (ind < 0))
				{
				 strcpy (stmp2, out_desc);

				 EXEC SQL	SELECT	uniseq.NEXTVAL
						INTO	:id
						FROM	DUAL;

				 EXEC SQL	INSERT INTO D_Unit
						(id, name, description)
						VALUES (:id, :stmp, :stmp2);

				 dcdata[Stage_Nb].unit_out = id;
				}
			 else
				{
				 dcdata[Stage_Nb].unit_out = id;
				}

			 if (FlagV)
				printf ("\n%s\tunit_out = %d", "DB", dcdata[Stage_Nb].unit_out);
			}
		}

	 /* Blockette 57 - Decimation Information */
	 else if (!strcmp (header, "B057F03"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &Stage_Nb);

		 if (FlagV)
			printf ("\n\n%s[%d]\t%d", header, Stage_Nb, Stage_Nb);
		}
	 else if (!strcmp (header, "B057F04"))
		{
		 sscanf (line, "%*s %*s %*s %*s %lf", &dmdata[Stage_Nb].samprate);

		 if (FlagV)
			printf ("\n%s[%d]\t%f", header, Stage_Nb, dmdata[Stage_Nb].samprate);
		}
	 else if (!strcmp (header, "B057F05"))
		{
		 sscanf (line, "%*s %*s %*s %d", &dmdata[Stage_Nb].factor);

		 if (FlagV)
			printf ("\n%s[%d]\t%d", header, Stage_Nb, dmdata[Stage_Nb].factor);
		}
	 else if (!strcmp (header, "B057F06"))
		{
		 sscanf (line, "%*s %*s %*s %d", &dmdata[Stage_Nb].offset);

		 if (FlagV)
			printf ("\n%s[%d]\t%d", header, Stage_Nb, dmdata[Stage_Nb].offset);
		}
	 else if (!strcmp (header, "B057F07"))
		{
		 sscanf (line, "%*s %*s %*s %*s %lf", &dmdata[Stage_Nb].delay);

		 if (FlagV)
			printf ("\n%s[%d]\t%f", header, Stage_Nb, dmdata[Stage_Nb].delay);
		}
	 else if (!strcmp (header, "B057F08"))
		{
		 sscanf (line, "%*s %*s %*s %*s %lf", &dmdata[Stage_Nb].correction);

		 if (FlagV)
			printf ("\n%s[%d]\t%f", header, Stage_Nb, dmdata[Stage_Nb].correction);
		}

	 /* Blockette 58 - Gain Information */
	 else if (!strcmp (header, "B058F03"))
		{
		 sscanf (line, "%*s %*s %*s %*s %d", &Stage_Nb);

		 if (FlagV)
			printf ("\n\n%s[%d]\t%d", header, Stage_Nb, Stage_Nb);
		}
	 else if (!strcmp (header, "B058F04"))
		{
		 sscanf (line, "%*s %*s %lf", &gdata[Stage_Nb].sensitivity);

		 if (FlagV)
			printf ("\n%s[%d]\t%f", header, Stage_Nb, gdata[Stage_Nb].sensitivity);
		}
	 else if (!strcmp (header, "B058F05"))
		{
		 sscanf (line, "%*s %*s %*s %*s %lf", &gdata[Stage_Nb].frequency);

		 if (FlagV)
			printf ("\n%s[%d]\t%f", header, Stage_Nb, gdata[Stage_Nb].frequency);

		 if ((Stage_Nb == 0) && (FlagP))	/* Populating Database */
			{
			 /* Populating Station Information */
			 strcpy (net, sdata.net);
			 strcpy (sta, sdata.sta);
			 lat = sdata.lat;
			 lon = sdata.lon;
			 elev = sdata.elev;
			 strcpy (staname, sdata.staname);
			 net_id = sdata.net_id;
			 word_32 = sdata.word_32;
			 word_16 = sdata.word_16;
			 strcpy (ondate, cdata.ondate);
			 strcpy (offdate, cdata.offdate);

			 itmp = 0;
			 EXEC SQL	SELECT	COUNT(*)
					INTO	:itmp
					FROM	Station_Data
					WHERE	net = :net AND sta = :sta AND ondate = :ondate;

			 if (itmp == 0)
				{
				 EXEC SQL	INSERT INTO Station_Data
						(net, sta, ondate, lat, lon, elev, staname, net_id, word_32, word_16, offdate, lddate)
						VALUES (:net, :sta, :ondate, :lat, :lon, :elev, :staname, :net_id, :word_32, :word_16, :offdate, SYSDATE);
				}

			 /* Populating Channel Information */
			 lat = cdata.lat;
			 lon = cdata.lon;
			 elev = cdata.elev;
			 strcpy (seedchan, cdata.seedchan);
			 strcpy (location, cdata.location);
			 inid = cdata.inid;
			 strcpy (remark, cdata.remark);
			 unit_signal = cdata.unit_signal;
			 unit_calib = cdata.unit_calib;
			 edepth = cdata.edepth;
			 azimuth = cdata.azimuth;
			 dip = cdata.dip;
			 format_id = cdata.format_id;
			 record_length = cdata.record_length;
			 samprate = cdata.samprate;
			 clock_drift = cdata.clock_drift;
			 strcpy (flags, cdata.flags);

			 EXEC SQL	INSERT INTO Channel_Data
					(net, sta, seedchan, location, ondate, channel, channelsrc, inid, remark, unit_signal, unit_calib, lat, lon, elev, edepth, azimuth, dip, format_id, record_length, samprate, clock_drift, flags, offdate, lddate)
					VALUES (:net, :sta, :seedchan, :location, :ondate, :seedchan, 'SEED', :inid, :remark, :unit_signal, :unit_calib, :lat, :lon, :elev, :edepth, :azimuth, :dip, :format_id, :record_length, :samprate, :clock_drift, :flags, :offdate, SYSDATE);

			 /* Populating Stage 1 Information */
			 unit_in = pzdata[1].unit_in;
			 unit_out = pzdata[1].unit_out;
			 AO = pzdata[1].AO;
			 AF = pzdata[1].AF;

			 EXEC SQL	SELECT	pzseq.NEXTVAL
					INTO	:pz_key
					FROM	DUAL;

			 EXEC SQL	INSERT INTO Poles_Zeros
					(net, sta, seedchan, location, ondate, stage_seq, channel, channelsrc, offdate, pz_key, tf_type, unit_in, unit_out, AO, AF, lddate)
					VALUES (:net, :sta, :seedchan, :location, :ondate, 1, :seedchan, 'SEED', :offdate, :pz_key, 'A', :unit_in, :unit_out, :AO, :AF, SYSDATE);

			 EXEC SQL	INSERT INTO PZ
					(key, name, lddate)
					VALUES (:pz_key, NULL, SYSDATE);

			 for (i=0;i<pzdata[1].nb_zeros;i++)
				{
				 itmp = i + 1;
				 r_value = pzdata[1].zeros[i].r_value;
				 r_error = pzdata[1].zeros[i].r_error;
				 i_value = pzdata[1].zeros[i].i_value;
				 i_error = pzdata[1].zeros[i].i_error;

				 EXEC SQL	INSERT INTO PZ_Data
						(key, row_key, type, r_value, r_error, i_value, i_error)
						VALUES (:pz_key, :itmp, 'Z', :r_value, :r_error, :i_value, :i_error);
				}

			 for (i=0;i<pzdata[1].nb_poles;i++)
				{
				 itmp = i + pzdata[1].nb_zeros + 1;
				 r_value = pzdata[1].poles[i].r_value;
				 r_error = pzdata[1].poles[i].r_error;
				 i_value = pzdata[1].poles[i].i_value;
				 i_error = pzdata[1].poles[i].i_error;

				 EXEC SQL	INSERT INTO PZ_Data
						(key, row_key, type, r_value, r_error, i_value, i_error)
						VALUES (:pz_key, :itmp, 'P', :r_value, :r_error, :i_value, :i_error);
				}

			 sensitivity = gdata[1].sensitivity;
			 frequency = gdata[1].frequency;

			 EXEC SQL	INSERT INTO Sensitivity
					(net, sta, seedchan, location, ondate, stage_seq, channel, channelsrc, offdate, sensitivity, frequency, lddate)
					VALUES (:net, :sta, :seedchan, :location, :ondate, 1, :seedchan, 'SEED', :offdate, :sensitivity, :frequency, SYSDATE);

			 /* Populating Stage 2 Information */
			 unit_in = dcdata[2].unit_in;
			 unit_out = dcdata[2].unit_out;

			 EXEC SQL	INSERT INTO Coefficients
					(net, sta, seedchan, location, ondate, stage_seq, channel, channelsrc, offdate, dc_key, unit_in, unit_out, tf_type, lddate)
					VALUES (:net, :sta, :seedchan, :location, :ondate, 2, :seedchan, 'SEED', :offdate, NULL, :unit_in, :unit_out, 'D', SYSDATE);

			 samprate = dmdata[2].samprate;
			 factor = dmdata[2].factor;
			 offset = dmdata[2].offset;
			 delay = dmdata[2].delay;
			 correction = dmdata[2].correction;

			 EXEC SQL	SELECT	dmseq.NEXTVAL
					INTO	:dm_key
					FROM	DUAL;

			 EXEC SQL	INSERT INTO Decimation
					(net, sta, seedchan, location, ondate, stage_seq, channel, channelsrc, offdate, dm_key, lddate)
					VALUES (:net, :sta, :seedchan, :location, :ondate, 2, :seedchan, 'SEED', :offdate, :dm_key, SYSDATE);

			 EXEC SQL	INSERT INTO DM
					(key, name, samprate, factor, offset, delay, correction, lddate)
					VALUES (:dm_key, NULL, :samprate, :factor, :offset, :delay, :correction, SYSDATE);

			 sensitivity = gdata[2].sensitivity;
			 frequency = gdata[2].frequency;

			 EXEC SQL	INSERT INTO Sensitivity
					(net, sta, seedchan, location, ondate, stage_seq, channel, channelsrc, offdate, sensitivity, frequency, lddate)
					VALUES (:net, :sta, :seedchan, :location, :ondate, 2, :seedchan, 'SEED', :offdate, :sensitivity, :frequency, SYSDATE);

			 EXEC SQL COMMIT;

			 /* Populating Stage 0 Information */
			 sensitivity = gdata[0].sensitivity;
			 frequency = gdata[0].frequency;

			 EXEC SQL	INSERT INTO Sensitivity
					(net, sta, seedchan, location, ondate, stage_seq, channel, channelsrc, offdate, sensitivity, frequency, lddate)
					VALUES (:net, :sta, :seedchan, :location, :ondate, 0, :seedchan, 'SEED', :offdate, :sensitivity, :frequency, SYSDATE);

			 EXEC SQL COMMIT;

			 if (FlagV)
				printf ("\n%s\t%s.%s.%s.%s\t%s\t%s Populated", "DB", net, sta, seedchan, location, ondate, offdate);
			}
		}

	 fgets (line, 255, frdseed);
	}

 /* Closing RDSEED file */
 fclose (frdseed);

 /* Disconnect from the database. */
 EXEC SQL COMMIT WORK RELEASE;

 printf ("\n");

 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);

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

 EXEC SQL ROLLBACK WORK RELEASE;

 exit(1);
}