Context Navigation

source: Sophya/trunk/SophyaExt/XephemAstroLib/dbfmt.c@ 3654

Visit:

Last change on this file since 3654 was 3654, checked in by cmv, 16 years ago
mise a niveau Xephem 3.7.4, cmv 16/07/2009
File size: 25.4 KB

Rev	Line
[1457]	1	/* code to convert between .edb format and an Obj */
	2
	3	#include <stdio.h>
	4	#include <ctype.h>
	5	#include <math.h>
	6	#include <stdlib.h>
	7	#include <string.h>
	8
	9	#include "astro.h"
	10	#include "preferences.h"
	11
	12
[2551]	13	int get_fields (char s, int delim, char fields[]);
[1457]	14
	15	#define MAXDBLINE 256 /* longest allowed db line */
	16
	17	#define FLDSEP ',' /* major field separator */
	18	#define SUBFLD '\|' /* subfield separator */
	19	#define MAXFLDS 20 /* must be more than on any expected line */
[3654]	20	#define MAXESGOOD 100 /* max earth satellite good, days */
[1457]	21
[2551]	22	static char enm (char flds[MAXFLDS]);
	23	static int crack_f (Obj op, char flds[MAXFLDS], int nf, char whynot[]);
	24	static int crack_e (Obj op, char flds[MAXFLDS], int nf, char whynot[]);
	25	static int crack_h (Obj op, char flds[MAXFLDS], int nf, char whynot[]);
	26	static int crack_p (Obj op, char flds[MAXFLDS], int nf, char whynot[]);
	27	static int crack_E (Obj op, char flds[MAXFLDS], int nf, char whynot[]);
	28	static int crack_P (Obj op, char flds[MAXFLDS], int nf, char whynot[]);
	29	static int crack_B (Obj op, char flds[MAXFLDS], int nf, char whynot[]);
	30	static int crack_name (Obj op, char flds[MAXFLDS], int nf,
	31	char nm[][MAXNM], int nnm);
	32	static void crack_year (char bp, double p);
	33	static void crack_okdates (char fld, float startok, float *endok);
	34	static int get_okdates (char lp, float sp, float *ep);
	35	static int tle_sum (char *l);
	36	static double tle_fld (char *l, int from, int thru);
	37	static double tle_expfld (char *l, int start);
	38	static void write_f (Obj *op, char lp[]);
	39	static void write_e (Obj *op, char lp[]);
	40	static void write_h (Obj *op, char lp[]);
	41	static void write_p (Obj *op, char lp[]);
	42	static void write_E (Obj *op, char lp[]);
	43	static void write_P (Obj *op, char lp[]);
	44	static void write_B (Obj *op, char lp[]);
[1457]	45
	46	/* crack the given .edb database line into op.
	47	* if ok
[2551]	48	* return number of names in nm[], or 1 if nm == NULL
[1457]	49	* else
	50	* if whynot
	51	* if not even a candidate
	52	* set whynot[0] = '\0'
	53	* else
	54	* fill whynot with reason message.
	55	* return -1
[2551]	56	* only the first name is stored in op, all names (up to nnm) are in nm[], or
	57	* ignored if nm == NULL.
[1457]	58	*/
	59	int
[2551]	60	db_crack_line (char s[], Obj *op, char nm[][MAXNM], int nnm, char whynot[])
[1457]	61	{
[2551]	62	char copy[MAXDBLINE]; /* work copy; leave s untouched */
[1457]	63	char flds[MAXFLDS]; / point to each field for easy reference */
[2551]	64	int nf;
[1457]	65	int i;
	66
[2551]	67	/* init no response */
	68	if (whynot)
	69	whynot[0] = '\0';
	70
[1457]	71	/* basic initial check */
[2551]	72	if (dbline_candidate (s) < 0)
[1457]	73	return (-1);
	74
	75	/* do all the parsing on a copy */
	76	(void) strcpy (copy, s);
	77	i = strlen(copy);
	78	if (copy[i-1] == '\n')
	79	copy[i-1] = '\0';
	80
	81	/* parse into main fields */
	82	nf = get_fields (copy, FLDSEP, flds);
	83
	84	/* need at least 2: name and type */
	85	if (nf < 2) {
	86	if (whynot)
[2551]	87	sprintf (whynot, "Bogus: %s", s);
[1457]	88	return (-1);
	89	}
	90
	91	/* switch out on type of object - the second field */
	92	switch (flds[1][0]) {
[2551]	93
	94	case 'f':
	95	if (crack_f (op, flds, nf, whynot) < 0)
[1457]	96	return (-1);
[2551]	97	break;
	98
	99	case 'e':
	100	if (crack_e (op, flds, nf, whynot) < 0)
[1457]	101	return (-1);
	102	break;
	103
[2551]	104	case 'h':
	105	if (crack_h (op, flds, nf, whynot) < 0)
[1457]	106	return (-1);
	107	break;
	108
[2551]	109	case 'p':
	110	if (crack_p (op, flds, nf, whynot) < 0)
[1457]	111	return (-1);
	112	break;
	113
[2551]	114	case 'B':
	115	if (crack_B (op, flds, nf, whynot) < 0)
[1457]	116	return (-1);
	117	break;
	118
[2551]	119	case 'E':
	120	if (crack_E (op, flds, nf, whynot) < 0)
[1457]	121	return (-1);
	122	break;
	123
	124	case 'P':
[2551]	125	if (crack_P (op, flds, nf, whynot) < 0)
	126	return (-1);
	127	break;
[1457]	128
	129	default:
	130	if (whynot)
[2551]	131	sprintf (whynot, "%s: Unknown type %c for %s", enm(flds),
	132	flds[1][0], flds[0]);
[1457]	133	return (-1);
	134	}
	135
[2551]	136	return (crack_name (op, flds, nf, nm, nnm));
[1457]	137	}
	138
[2551]	139	/* write the given Obj in .edb format to lp[].
	140	* we do _not_ include a trailing '\n'.
	141	*/
	142	void
	143	db_write_line (Obj *op, char lp[])
[1457]	144	{
[2551]	145	switch (op->o_type) {
	146	case FIXED:
	147	write_f (op, lp);
	148	break;
[1457]	149
[2551]	150	case BINARYSTAR:
	151	write_B (op, lp);
	152	break;
[1457]	153
[2551]	154	case ELLIPTICAL:
	155	write_e (op, lp);
	156	break;
[1457]	157
[2551]	158	case HYPERBOLIC:
	159	write_h (op, lp);
	160	break;
[1457]	161
[2551]	162	case PARABOLIC:
	163	write_p (op, lp);
	164	break;
	165
	166	case EARTHSAT:
	167	write_E (op, lp);
	168	break;
	169
	170	case PLANET:
	171	write_P (op, lp);
	172	break;
	173
	174	default:
	175	printf ("Unknown type for %s: %d\n", op->o_name, op->o_type);
	176	abort();
	177	}
[1457]	178	}
	179
	180	/* given 3 lines, first of which is name and next 2 are TLE, fill op.
	181	* we skip leading whitespace on all lines.
	182	* we do /not/ assume the 2 TLE lines are 0 terminated, but we do reach out into
	183	* each as far as 69 chars.
	184	* we detect nonconformance as efficiently as possible.
	185	* name ends at first '\0', '\r' or '\n'.
[3654]	186	* set startok/endok.
[1457]	187	* if ok return 0 else return -1
	188	*/
	189	int
[2551]	190	db_tle (char name, char l1, char l2, Obj op)
[1457]	191	{
	192	double ep;
	193	int i;
	194
	195	/* check for correct line numbers, macthing satellite numbers and
	196	* correct checksums.
	197	*/
	198	while (isspace(*l1))
	199	l1++;
	200	if (*l1 != '1')
	201	return (-1);
	202	while (isspace(*l2))
	203	l2++;
	204	if (*l2 != '2')
	205	return (-1);
	206	if (strncmp (l1+2, l2+2, 5))
	207	return (-1);
	208	if (tle_sum (l1) < 0)
	209	return (-1);
	210	if (tle_sum (l2) < 0)
	211	return (-1);
	212
	213	/* assume it's ok from here out */
	214
	215	/* fresh */
	216	zero_mem ((void *)op, sizeof(ObjES));
	217	op->o_type = EARTHSAT;
	218
	219	/* name, sans leading and trailing whitespace */
	220	while (isspace(*name))
	221	name++;
	222	i = strcspn (name, "\r\n");
	223	while (i > 0 && name[i-1] == ' ')
	224	--i;
	225	if (i == 0)
	226	return (-1);
	227	if (i > MAXNM-1)
	228	i = MAXNM-1;
	229	sprintf (op->o_name, "%.*s", i, name);
	230
	231	/* goodies from "line 1" */
	232	op->es_drag = (float) tle_expfld (l1, 54);
[2551]	233	op->es_decay = (float) tle_fld (l1, 34, 43);
[1457]	234	i = (int) tle_fld (l1, 19, 20);
	235	if (i < 57)
	236	i += 100;
	237	cal_mjd (1, tle_fld(l1, 21, 32), i+1900, &ep);
	238	op->es_epoch = ep;
	239
	240	/* goodies from "line 2" */
	241	op->es_n = tle_fld (l2, 53, 63);
	242	op->es_inc = (float)tle_fld (l2, 9, 16);
	243	op->es_raan = (float)tle_fld (l2, 18, 25);
	244	op->es_e = (float)(tle_fld (l2, 27, 33) * 1e-7);
	245	op->es_ap = (float)tle_fld (l2, 35, 42);
	246	op->es_M = (float)tle_fld (l2, 44, 51);
	247	op->es_orbit = (int)tle_fld (l2, 64, 68);
	248
[3654]	249	/* limit date range to decay period that changes period by 1% but
	250	* never more than MAXESGOOD.
	251	* es_n is rev/day, es_decay is (rev/day)/day
	252	*/
	253	if (fabs(op->es_decay) > 0) {
	254	double dt = 0.01*op->es_n/fabs(op->es_decay);
	255	if (dt > MAXESGOOD)
	256	dt = MAXESGOOD;
	257	op->es_startok = op->es_epoch - dt;
	258	op->es_endok = op->es_epoch + dt;
	259	}
	260
[1457]	261	/* yes! */
	262	return (0);
	263	}
	264
[2551]	265	/* return 0 if op has no date range information or what it does have brackets
	266	* now, else -1
[1457]	267	*/
[2551]	268	int
	269	dateRangeOK (Now np, Obj op)
[1457]	270	{
[2551]	271	float sp, ep;
[1457]	272
	273	switch (op->o_type) {
[2551]	274	case ELLIPTICAL:
	275	sp = &op->e_startok;
	276	ep = &op->e_endok;
[1457]	277	break;
[2551]	278	case HYPERBOLIC:
	279	sp = &op->h_startok;
	280	ep = &op->h_endok;
	281	break;
	282	case PARABOLIC:
	283	sp = &op->p_startok;
	284	ep = &op->p_endok;
	285	break;
	286	case EARTHSAT:
	287	sp = &op->es_startok;
	288	ep = &op->es_endok;
	289	break;
	290	default:
	291	return (0);
	292	}
[1457]	293
[2551]	294	if (sp <= mjd && (!ep \|\| mjd <= *ep))
	295	return (0);
	296	return (-1);
	297	}
[1457]	298
[2551]	299	/* given a null-terminated string, fill in fields[] with the starting addresses
	300	* of each field delimited by delim or '\0'.
	301	* N.B. each character matching delim is REPLACED BY '\0' IN PLACE.
	302	* N.B. 0-length fields count, so even if *s=='\0' we return 1.
	303	* return the number of fields.
	304	*/
	305	int
	306	get_fields (char s, int delim, char fields[])
	307	{
	308	int n;
	309	char c;
[1457]	310
[2551]	311	*fields = s;
	312	n = 0;
	313	do {
	314	c = *s++;
	315	if (c == delim \|\| c == '\0') {
	316	s[-1] = '\0';
	317	*++fields = s;
	318	n++;
[1457]	319	}
[2551]	320	} while (c);
[1457]	321
[2551]	322	return (n);
	323	}
[1457]	324
[2551]	325	/* return 0 if buf qualifies as a database line worthy of a cracking
	326	* attempt, else -1.
	327	*/
	328	int
	329	dbline_candidate (char *buf)
	330	{
	331	char c = buf[0];
[1457]	332
[2551]	333	return (c == '#' \|\| c == '!' \|\| isspace(c) ? -1 : 0);
	334	}
[1457]	335
[2551]	336	/* return 0 if TLE checksum is ok, else -1 */
	337	static int
	338	tle_sum (char *l)
	339	{
	340	char *lastl = l + 68;
	341	int sum;
[1457]	342
[2551]	343	for (sum = 0; l < lastl; ) {
	344	char c = *l++;
	345	if (c == '\0')
	346	return (-1);
	347	if (isdigit(c))
	348	sum += c - '0';
	349	else if (c == '-')
	350	sum++;
[1457]	351	}
	352
[2551]	353	return (*l - '0' == (sum%10) ? 0 : -1);
[1457]	354	}
	355
[2551]	356	/* extract the given columns and return value.
	357	* N.B. from and to are 1-based within l
[1457]	358	*/
[2551]	359	static double
	360	tle_fld (char *l, int from, int thru)
[1457]	361	{
[2551]	362	char buf[32];
	363
	364	sprintf (buf, "%.*s", thru-from+1, l+from-1);
	365	return (atod (buf));
	366	}
	367
	368	/* extract the exponential value starting at the given column.
	369	* N.B. start is 1-based within l
	370	*/
	371	static double
	372	tle_expfld (char *l, int start)
	373	{
	374	char buf[32];
	375	double v;
	376
	377	sprintf (buf, ".%.*s", 5, l+start);
	378	v = atod (buf) * pow (10.0, tle_fld(l, start+6, start+7));
	379	if (l[start-1] == '-')
	380	v = -v;
	381	return (v);
	382	}
	383
	384	static int
	385	crack_f (Obj op, char flds[MAXFLDS], int nf, char whynot[])
	386	{
	387	char *sflds[MAXFLDS];
[1457]	388	double tmp;
[2551]	389	int nsf;
[1457]	390
[2551]	391	if (nf < 5 \|\| nf > 7) {
	392	if (whynot)
[2653]	393	sprintf (whynot, "%s: type f needs 5-7 fields, not %d",
	394	enm(flds),nf);
[2551]	395	return (-1);
	396	}
[1457]	397
[2551]	398	zero_mem ((void *)op, sizeof(ObjF));
	399	op->o_type = FIXED;
	400
	401	nsf = get_fields(flds[1], SUBFLD, sflds);
	402	if (nsf > 1) {
	403	switch (sflds[1][0]) {
[1457]	404	case 'A': case 'B': case 'C': case 'D': case 'F': case 'G':
	405	case 'H': case 'K': case 'J': case 'L': case 'M': case 'N':
	406	case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T':
[2551]	407	case 'U': case 'V': case 'Y':
	408	op->f_class = sflds[1][0];
	409	if (op->f_class == 'B')
	410	op->f_class = 'D'; /* merge B and D since BINARYSTAR */
[1457]	411	break;
	412	default:
[2551]	413	if (whynot)
	414	sprintf (whynot, "%s: Bad f class: %c", enm(flds),
	415	sflds[1][0]);
[1457]	416	return (-1);
	417	}
[2653]	418	} else
	419	op->f_class = 'T'; /* default to star-like */
[2551]	420	if (nsf > 2) {
[1457]	421	/* fill f_spect all the way */
[2551]	422	char buf[sizeof(op->f_spect)+1];
	423	memset (buf, 0, sizeof(buf));
	424	sprintf (buf, "%.*s", (int)sizeof(op->f_spect), sflds[2]);
	425	memcpy (op->f_spect, buf, (int)sizeof(op->f_spect));
[1457]	426	}
	427
[2551]	428	nsf = get_fields(flds[2], SUBFLD, sflds);
	429	f_scansexa (sflds[0], &tmp);
	430	op->f_RA = (float) hrrad(tmp);
	431	if (nsf > 1)
	432	op->f_pmRA = (float) 1.327e-11atod(sflds[1]);/mas/yr->rad/dy*/
	433
	434	nsf = get_fields(flds[3], SUBFLD, sflds);
	435	f_scansexa (sflds[0], &tmp);
	436	op->f_dec = (float) degrad(tmp);
	437	if (nsf > 1)
	438	op->f_pmdec = (float)1.327e-11atod(sflds[1]);/mas/yr->rad/dy*/
	439	if (fabs(op->f_dec) < PI/2)
	440	op->f_pmRA /= cos (op->f_dec);
	441
	442	set_fmag (op, atod(flds[4]));
	443
	444	if (nf > 5 && flds[5][0]) {
	445	tmp = op->f_epoch;
	446	crack_year (flds[5], &tmp);
	447	op->f_epoch = (float) tmp;
	448	} else
	449	op->f_epoch = J2000; /* default */
	450
	451	if (nf > 6) {
	452	op->f_size = (float) atod(flds[6]);
	453
	454	/* optional minor axis and position angle subfields */
	455	nsf = get_fields(flds[6], SUBFLD, sflds);
	456	if (nsf == 3) {
	457	set_ratio(op, op->s_size, atod(sflds[1]));
	458	set_pa(op,degrad(atod(sflds[2])));
	459	} else {
	460	set_ratio(op,1,1); /* round */
	461	set_pa(op,0.0);
[1457]	462	}
[2551]	463	}
[1457]	464
[2551]	465	return (0);
	466	}
[1457]	467
[2551]	468	static int
	469	crack_e (Obj op, char flds[MAXFLDS], int nf, char whynot[])
	470	{
	471	if (nf != 13 && nf != 14) {
	472	if (whynot)
[2653]	473	sprintf (whynot, "%s: type e needs 13 or 14 fields, not %d",
[2551]	474	enm(flds), nf);
	475	return (-1);
	476	}
[1457]	477
[2551]	478	zero_mem ((void *)op, sizeof(ObjE));
	479	op->o_type = ELLIPTICAL;
[1457]	480
[2551]	481	op->e_inc = (float) atod (flds[2]);
	482	op->e_Om = (float) atod (flds[3]);
	483	op->e_om = (float) atod (flds[4]);
	484	op->e_a = (float) atod (flds[5]);
	485	/* retired op->e_n = (float) atod (flds[6]); */
	486	op->e_e = atod (flds[7]);
	487	op->e_M = (float) atod (flds[8]);
	488	crack_year (flds[9], &op->e_cepoch);
	489	crack_okdates (flds[9], &op->e_startok, &op->e_endok);
	490	crack_year (flds[10], &op->e_epoch);
	491
	492	/* magnitude model gk or HG(default). allow prefixes in either field */
	493	op->e_mag.whichm = flds[11][0] == 'g' ? MAG_gk : MAG_HG;
	494	if (isdigit(flds[11][0]))
	495	op->e_mag.m1 = (float) atod(&flds[11][0]);
	496	else
	497	op->e_mag.m1 = (float) atod(&flds[11][1]);
	498	if (isdigit(flds[12][0]))
	499	op->e_mag.m2 = (float) atod(&flds[12][0]);
	500	else
	501	op->e_mag.m2 = (float) atod(&flds[12][1]);
	502
	503	if (nf == 14)
	504	op->e_size = (float) atod (flds[13]);
	505
	506	return (0);
	507	}
	508
	509	static int
	510	crack_h (Obj op, char flds[MAXFLDS], int nf, char whynot[])
	511	{
	512	if (nf != 11 && nf != 12) {
	513	if (whynot)
[2653]	514	sprintf (whynot, "%s: type h needs 11 or 12 fields, not %d",
[2551]	515	enm(flds), nf);
	516	return (-1);
[1457]	517	}
	518
[2551]	519	zero_mem ((void *)op, sizeof(ObjH));
	520	op->o_type = HYPERBOLIC;
	521
	522	crack_year (flds[2], &op->h_ep);
	523	crack_okdates (flds[2], &op->h_startok, &op->h_endok);
	524	op->h_inc = (float) atod (flds[3]);
	525	op->h_Om = (float) atod (flds[4]);
	526	op->h_om = (float) atod (flds[5]);
	527	op->h_e = (float) atod (flds[6]);
	528	op->h_qp = (float) atod (flds[7]);
	529	crack_year (flds[8], &op->h_epoch);
	530	op->h_g = (float) atod (flds[9]);
	531	op->h_k = (float) atod (flds[10]);
	532
	533	if (nf == 12)
	534	op->h_size = (float) atod (flds[11]);
	535
[1457]	536	return (0);
	537	}
	538
[2551]	539	static int
	540	crack_p (Obj op, char flds[MAXFLDS], int nf, char whynot[])
[1457]	541	{
[2551]	542	if (nf != 10 && nf != 11) {
	543	if (whynot)
[2653]	544	sprintf (whynot, "%s: type p needs 10 or 11 fields, not %d",
[2551]	545	enm(flds), nf);
	546	return (-1);
	547	}
[1457]	548
[2551]	549	zero_mem ((void *)op, sizeof(ObjP));
	550	op->o_type = PARABOLIC;
[1457]	551
[2551]	552	crack_year (flds[2], &op->p_ep);
	553	crack_okdates (flds[2], &op->p_startok, &op->p_endok);
	554	op->p_inc = (float) atod (flds[3]);
	555	op->p_om = (float) atod (flds[4]);
	556	op->p_qp = (float) atod (flds[5]);
	557	op->p_Om = (float) atod (flds[6]);
	558	crack_year (flds[7], &op->p_epoch);
	559	op->p_g = (float) atod (flds[8]);
	560	op->p_k = (float) atod (flds[9]);
	561
	562	if (nf == 11)
	563	op->p_size = (float) atod (flds[10]);
	564
	565	return (0);
[1457]	566	}
	567
[2551]	568	static int
	569	crack_E (Obj op, char flds[MAXFLDS], int nf, char whynot[])
[1457]	570	{
[2551]	571	if (nf != 11 && nf != 12) {
	572	if (whynot)
[2653]	573	sprintf (whynot, "%s: type E needs 11 or 12 fields, not %d",
[2551]	574	enm(flds), nf);
	575	return (-1);
	576	}
	577
	578	zero_mem ((void *)op, sizeof(ObjES));
	579	op->o_type = EARTHSAT;
	580	crack_year (flds[2], &op->es_epoch);
	581	crack_okdates (flds[2], &op->es_startok, &op->es_endok);
	582	op->es_inc = (float) atod (flds[3]);
	583	op->es_raan = (float) atod (flds[4]);
	584	op->es_e = (float) atod (flds[5]);
	585	op->es_ap = (float) atod (flds[6]);
	586	op->es_M = (float) atod (flds[7]);
	587	op->es_n = atod (flds[8]);
	588	op->es_decay = (float) atod (flds[9]);
	589	op->es_orbit = atoi (flds[10]);
	590	if (nf == 12)
	591	op->es_drag = (float) atod (flds[11]);
	592
[3654]	593	/* if not already specified, limit date range to decay period that
	594	* changes period by 1% but never longer than MAXESGOOD.
	595	* es_n is rev/day, es_decay is (rev/day)/day
	596	*/
	597	if (op->es_startok == 0 && op->es_endok == 0 && fabs(op->es_decay) > 0){
	598	double dt = 0.01*op->es_n/fabs(op->es_decay);
	599	if (dt > MAXESGOOD)
	600	dt = MAXESGOOD;
	601	op->es_startok = op->es_epoch - dt;
	602	op->es_endok = op->es_epoch + dt;
	603	}
	604
[2551]	605	return (0);
	606	}
	607
	608	static int
	609	crack_P (Obj op, char flds[MAXFLDS], int nf, char whynot[])
	610	{
	611	Obj *bi;
	612	int nbi;
[1457]	613	int i;
	614
[2551]	615	nbi = getBuiltInObjs (&bi);
[1457]	616
[2551]	617	for (i = 0; i < nbi; i++) {
	618	Obj *bop = bi + i;
	619	if (is_type(bop,PLANETM) && !strcmp (flds[0], bop->o_name)) {
	620	memcpy ((void *)op, bop, sizeof(ObjPl));
[1457]	621	return (0);
	622	}
	623	}
	624
[2551]	625	if (whynot)
	626	sprintf (whynot, "%s: Unknown planet or moon", enm(flds));
[1457]	627	return (-1);
	628	}
	629
	630	static int
[2551]	631	crack_B (Obj op, char flds[MAXFLDS], int nf, char whynot[])
[1457]	632	{
[2551]	633	char *sflds[MAXFLDS];
	634	double tmp;
	635	int nsf;
[1457]	636
[2551]	637	if (nf != 7) {
	638	if (whynot)
	639	sprintf (whynot, "%s: B need 7 fields, not %d", enm(flds), nf);
	640	return (-1);
	641	}
	642
	643	zero_mem ((void *)op, sizeof(ObjB));
	644	op->o_type = BINARYSTAR;
	645
	646	nsf = get_fields(flds[1], SUBFLD, sflds);
	647	if (nsf > 1) {
	648	switch (sflds[1][0]) {
	649	case 'a': case 'c': case 'e': case 'x': case 'y': case 'o':
	650	case 's': case 't': case 'u': case 'v': case 'b': case 'd':
	651	case 'q': case 'r': case 'p': case 'U': case 'V': case 'Y':
	652	op->f_class = sflds[1][0];
	653	break;
	654	default:
	655	if (whynot)
	656	sprintf (whynot, "%s: Bad B class: %c", enm(flds),
	657	sflds[1][0]);
	658	return (-1);
	659	}
	660	}
	661	if (nsf > 2) {
	662	/* fill f_spect all the way */
	663	char buf[sizeof(op->f_spect)+1];
	664	memset (buf, 0, sizeof(buf));
	665	sprintf (buf, "%.*s", (int)sizeof(op->f_spect), sflds[2]);
	666	memcpy (op->f_spect, buf, (int)sizeof(op->f_spect));
	667	}
	668	if (nsf > 3) {
	669	/* fill b_2spect all the way */
	670	char buf[sizeof(op->b_2spect)+1];
	671	memset (buf, 0, sizeof(buf));
	672	sprintf (buf, "%.*s", (int)sizeof(op->b_2spect), sflds[3]);
	673	memcpy (op->b_2spect, buf, (int)sizeof(op->b_2spect));
	674	}
	675
	676	nsf = get_fields(flds[2], SUBFLD, sflds);
	677	f_scansexa (sflds[0], &tmp);
	678	op->f_RA = (float) hrrad(tmp);
	679	if (nsf > 1)
	680	op->f_pmRA = (float) 1.327e-11atod(sflds[1]);/mas/yr->rad/dy*/
	681
	682	nsf = get_fields(flds[3], SUBFLD, sflds);
	683	f_scansexa (sflds[0], &tmp);
	684	op->f_dec = (float) degrad(tmp);
	685	if (nsf > 1)
	686	op->f_pmdec = (float)1.327e-11atod(sflds[1]);/mas/yr->rad/dy*/
	687	if (fabs(op->f_dec) < PI/2)
	688	op->f_pmRA /= cos (op->f_dec);
	689
	690	nsf = get_fields(flds[4], SUBFLD, sflds);
	691	if (nsf > 0)
	692	set_fmag (op, atod(sflds[0]));
	693	if (nsf > 1)
	694	op->b_2mag = (short)floor((atod(sflds[1]))*MAGSCALE + 0.5);
	695
	696	if (flds[5][0]) {
	697	tmp = op->f_epoch;
	698	crack_year (flds[5], &tmp);
	699	op->f_epoch = (float) tmp;
	700	} else
	701	op->f_epoch = J2000; /* default */
	702
	703	nsf = get_fields(flds[6], SUBFLD, sflds);
	704	if (nsf == 7) {
	705	int l;
	706	char c;
	707
	708	op->b_bo.bo_a = atod(sflds[0]);
	709	op->b_bo.bo_i = atod(sflds[1]);
	710	op->b_bo.bo_O = atod(sflds[2]);
	711	op->b_bo.bo_e = atod(sflds[3]);
	712	op->b_bo.bo_T = atod(sflds[4]);
	713	op->b_bo.bo_o = atod(sflds[5]);
	714	op->b_bo.bo_P = atod(sflds[6]);
	715
	716	/* reject some weird entries actually seen in real lists */
	717	if (op->b_bo.bo_a <= 0) {
	718	if (whynot)
	719	sprintf (whynot, "%s: Bogus B semi major axis: %g",
	720	enm(flds), op->b_bo.bo_a);
	721	return (-1);
	722	}
	723	if (op->b_bo.bo_P <= 0) {
	724	if (whynot)
	725	sprintf (whynot, "%s: Bogus B period: %g", enm(flds),
	726	op->b_bo.bo_P);
	727	return (-1);
	728	}
	729
	730	/* scale period */
	731	l = strlen (sflds[6]);
	732	c = sflds[6][l-1];
	733	switch (c) {
	734	case 'y': case 'Y':
	735	break;
	736	case 'h': case 'H':
	737	op->b_bo.bo_P /= (24.0*365.25);
	738	break;
	739	case 'd': case 'D':
	740	op->b_bo.bo_P /= 365.25;
	741	break;
	742	default:
	743	if (c != ' ' && !isdigit(c)) {
	744	if (whynot)
	745	sprintf (whynot,"%s: B period suffix not Y, D or H: %c",
	746	enm(flds), c);
	747	return (-1);
	748	}
	749	}
	750
	751	} else if (nsf==3 \|\| nsf==6 \|\| nsf==9) {
	752	double yr;
	753	int i;
	754
	755	op->b_nbp = nsf/3;
	756	for (i = 0; i < nsf; i += 3) {
	757	tmp = 0;
	758	crack_year (sflds[i+0], &tmp);
	759	mjd_year (tmp, &yr);
	760	op->b_bp[i/3].bp_ep = (float)yr;
	761	op->b_bp[i/3].bp_sep = atod(sflds[i+1]);
	762	op->b_bp[i/3].bp_pa = degrad(atod(sflds[i+2]));
	763	}
	764	} else {
	765	if (whynot)
	766	sprintf (whynot,
[2653]	767	"%s: type B needs 3,6 or 7 subfields in field 7, not %d",
[2551]	768	enm(flds), nsf);
	769	return (-1);
	770	}
	771
	772	return (0);
[1457]	773	}
	774
[2551]	775	/* put all names in nm but load only the first into o_name */
	776	static int
	777	crack_name (Obj op, char flds[MAXFLDS], int nf, char nm[][MAXNM], int nnm)
	778	{
	779	char *sflds[MAXFLDS];
	780	int nsf;
	781	int i;
	782
	783	nsf = get_fields (flds[0], SUBFLD, sflds);
	784	for (i = 0; nm && i < nsf && i < nnm; i++) {
	785	strncpy (nm[i], sflds[i], MAXNM);
	786	nm[i][MAXNM-1] = '\0';
	787	}
	788	strncpy (op->o_name, sflds[0], MAXNM-1);
	789	return (nsf);
	790	}
	791
	792	/* simple name cracker just for error messages */
	793	static char *
	794	enm (char *flds[MAXFLDS])
	795	{
	796	char *sflds[MAXFLDS];
	797	int nsf = get_fields (flds[0], SUBFLD, sflds);
	798	return (nsf > 0 ? sflds[0] : "Unknown");
	799	}
	800
	801	/* given either a decimal year (xxxx[.xxx]) or a calendar (x/x/x) date
	802	* convert it to an mjd and store it at *p.
[1457]	803	*/
	804	static void
[2551]	805	crack_year (char bp, double p)
[1457]	806	{
	807	int m, y;
	808	double d;
	809
	810	mjd_cal (p, &m, &d, &y); / init with current */
[2551]	811	f_sscandate (bp, PREF_MDY, &m, &d, &y);
[1457]	812	cal_mjd (m, d, y, p);
	813	}
	814
[2551]	815	/* crack the startok and endok date fields found in several Obj types.
	816	* set to 0 if blank or any problems.
[1457]	817	*/
[2551]	818	static void
	819	crack_okdates (char fld, float startok, float *endok)
[1457]	820	{
[2551]	821	char *sflds[MAXFLDS];
[1457]	822	double tmp;
[2551]	823	int m, y;
	824	double d;
	825	int nsf;
[1457]	826
[2551]	827	startok = endok = 0;
	828	nsf = get_fields(fld, SUBFLD, sflds);
	829	if (nsf > 1) {
	830	d = m = y = 0;
	831	f_sscandate (sflds[1], PREF_MDY, &m, &d, &y);
	832	cal_mjd (m, d, y, &tmp);
	833	*startok = (float)tmp;
	834	if (nsf > 2) {
	835	d = m = y = 0;
	836	f_sscandate (sflds[2], PREF_MDY, &m, &d, &y);
	837	cal_mjd (m, d, y, &tmp);
	838	*endok = (float)tmp;
[1457]	839	}
[2551]	840	}
	841	}
[1457]	842
[2551]	843	/* add startok and endok to string at lp if non-zero.
	844	* return number of characters added.
	845	*/
	846	static int
	847	get_okdates (char lp, float sp, float *ep)
	848	{
	849	char *lp0 = lp;
	850
	851	if (sp \|\| ep) {
	852	*lp++ = '\|';
	853	if (*sp)
[3111]	854	lp += fs_date (lp, PREF_MDY, *sp);
[2551]	855	if (*ep) {
	856	*lp++ = '\|';
[3111]	857	lp += fs_date (lp, PREF_MDY, *ep);
[1457]	858	}
[2551]	859	}
[1457]	860
[2551]	861	return (lp - lp0);
	862	}
[1457]	863
[2551]	864	static void
	865	write_f (Obj *op, char lp[])
	866	{
	867	double tmp;
[1457]	868
[2551]	869	lp += sprintf (lp, "%s,f", op->o_name);
	870	if (op->f_class)
	871	lp += sprintf (lp, "\|%c", op->f_class);
	872	if (op->f_spect[0])
	873	lp += sprintf (lp, "\|%.*s", (int)sizeof(op->f_spect), op->f_spect);
	874	*lp++ = ',';
	875	lp += fs_sexa (lp, radhr(op->f_RA), 2, 36000);
	876	if (op->f_pmRA)
	877	lp += sprintf (lp, "\|%.6g",cos(op->f_dec)*op->f_pmRA/1.327e-11);
	878	*lp++ = ',';
	879	lp += fs_sexa (lp, raddeg(op->f_dec), 3, 3600);
	880	if (op->f_pmdec)
	881	lp += sprintf (lp, "\|%.6g", op->f_pmdec/1.327e-11);
	882	lp += sprintf (lp, ",%.2f", get_mag(op));
	883	mjd_year (op->f_epoch, &tmp);
	884	lp += sprintf (lp, ",%.6g", tmp); /* %.7g gives 2000.001 */
	885	lp += sprintf (lp, ",%.7g", op->f_size);
	886	if (op->f_size && (op->f_ratio \|\| op->f_pa))
	887	lp += sprintf (lp,"\|%g\|%g", op->f_size*get_ratio(op),
	888	raddeg(get_pa(op)));
	889	}
[1457]	890
[2551]	891	static void
	892	write_e (Obj *op, char lp[])
	893	{
	894	lp += sprintf (lp, "%s,e", op->o_name);
	895	lp += sprintf (lp, ",%.7g", op->e_inc);
	896	lp += sprintf (lp, ",%.7g", op->e_Om);
	897	lp += sprintf (lp, ",%.7g", op->e_om);
	898	lp += sprintf (lp, ",%.7g", op->e_a);
	899	lp += sprintf (lp, ",%.7g", 0.0); /* retired op->e_n */
	900	lp += sprintf (lp, ",%.7g", op->e_e);
	901	lp += sprintf (lp, ",%.7g", op->e_M);
	902	*lp++ = ',';
[3111]	903	lp += fs_date (lp, PREF_MDY, op->e_cepoch);
[2551]	904	lp += get_okdates (lp, &op->e_startok, &op->e_endok);
	905	*lp++ = ',';
[3111]	906	lp += fs_date (lp, PREF_MDY, op->e_epoch);
[2551]	907	if (op->e_mag.whichm == MAG_gk)
	908	lp += sprintf (lp, ",g%.7g", op->e_mag.m1);
	909	else if (op->e_mag.whichm == MAG_HG)
	910	lp += sprintf (lp, ",H%.7g", op->e_mag.m1);
	911	else
	912	lp += sprintf (lp, ",%.7g", op->e_mag.m1);
	913	lp += sprintf (lp, ",%.7g", op->e_mag.m2);
	914	lp += sprintf (lp, ",%.7g", op->e_size);
	915	}
	916
	917	static void
	918	write_h (Obj *op, char lp[])
	919	{
	920	lp += sprintf (lp, "%s,h", op->o_name);
	921	*lp++ = ',';
[3111]	922	lp += fs_date (lp, PREF_MDY, op->h_ep);
[2551]	923	lp += get_okdates (lp, &op->h_startok, &op->h_endok);
	924	lp += sprintf (lp, ",%.7g", op->h_inc);
	925	lp += sprintf (lp, ",%.7g", op->h_Om);
	926	lp += sprintf (lp, ",%.7g", op->h_om);
	927	lp += sprintf (lp, ",%.7g", op->h_e);
	928	lp += sprintf (lp, ",%.7g", op->h_qp);
	929	*lp++ = ',';
[3111]	930	lp += fs_date (lp, PREF_MDY, op->h_epoch);
[2551]	931	lp += sprintf (lp, ",%.7g", op->h_g);
	932	lp += sprintf (lp, ",%.7g", op->h_k);
	933	lp += sprintf (lp, ",%.7g", op->h_size);
	934	}
	935
	936	static void
	937	write_p (Obj *op, char lp[])
	938	{
	939	lp += sprintf (lp, "%s,p", op->o_name);
	940	*lp++ = ',';
[3111]	941	lp += fs_date (lp, PREF_MDY, op->p_ep);
[2551]	942	lp += get_okdates (lp, &op->p_startok, &op->p_endok);
	943	lp += sprintf (lp, ",%.7g", op->p_inc);
	944	lp += sprintf (lp, ",%.7g", op->p_om);
	945	lp += sprintf (lp, ",%.7g", op->p_qp);
	946	lp += sprintf (lp, ",%.7g", op->p_Om);
	947	*lp++ = ',';
[3111]	948	lp += fs_date (lp, PREF_MDY, op->p_epoch);
[2551]	949	lp += sprintf (lp, ",%.7g", op->p_g);
	950	lp += sprintf (lp, ",%.7g", op->p_k);
	951	lp += sprintf (lp, ",%.7g", op->p_size);
	952	}
	953
	954	static void
	955	write_E (Obj *op, char lp[])
	956	{
[3477]	957	double d;
	958	int m, y;
	959
[2551]	960	lp += sprintf (lp, "%s,E", op->o_name);
	961	*lp++ = ',';
[3477]	962	mjd_cal (op->es_epoch, &m, &d, &y); /* need more day prec than fs_date*/
	963	lp += sprintf (lp, "%d/%.12g/%d", m, d, y);
[2551]	964	lp += get_okdates (lp, &op->es_startok, &op->es_endok);
[3477]	965	lp += sprintf (lp, ",%.8g", op->es_inc);
	966	lp += sprintf (lp, ",%.8g", op->es_raan);
	967	lp += sprintf (lp, ",%.8g", op->es_e);
	968	lp += sprintf (lp, ",%.8g", op->es_ap);
	969	lp += sprintf (lp, ",%.8g", op->es_M);
	970	lp += sprintf (lp, ",%.12g", op->es_n); /* double */
	971	lp += sprintf (lp, ",%.8g", op->es_decay);
[2551]	972	lp += sprintf (lp, ",%d", op->es_orbit);
[3477]	973	lp += sprintf (lp, ",%.8g", op->es_drag);
[2551]	974	}
	975
	976	static void
	977	write_B (Obj *op, char lp[])
	978	{
	979	double tmp;
	980
	981	lp += sprintf (lp, "%s,B", op->o_name);
	982	if (op->f_class)
	983	lp += sprintf (lp, "\|%c", op->f_class);
	984	if (op->f_spect[0])
	985	lp += sprintf (lp, "\|%.*s", (int)sizeof(op->f_spect), op->f_spect);
	986	if (op->b_2spect[0])
	987	lp += sprintf (lp, "\|%.*s", (int)sizeof(op->b_2spect),op->b_2spect);
	988	*lp++ = ',';
	989	lp += fs_sexa (lp, radhr(op->f_RA), 2, 36000);
	990	if (op->f_pmRA)
	991	lp += sprintf (lp, "\|%.6g",cos(op->f_dec)*op->f_pmRA/1.327e-11);
	992	*lp++ = ',';
	993	lp += fs_sexa (lp, raddeg(op->f_dec), 3, 3600);
	994	if (op->f_pmdec)
	995	lp += sprintf (lp, "\|%.6g", op->f_pmdec/1.327e-11);
	996	lp += sprintf (lp, ",%.2f", get_mag(op));
	997	lp += sprintf (lp, "\|%.2f", op->b_2mag/MAGSCALE);
	998	mjd_year (op->f_epoch, &tmp);
	999	lp += sprintf (lp, ",%.6g", tmp); /* %.7g gives 2000.001 */
	1000	if (op->b_nbp == 0) {
	1001	lp += sprintf (lp, ",%.6g", op->b_bo.bo_a);
	1002	lp += sprintf (lp, "\|%.6g", op->b_bo.bo_i);
	1003	lp += sprintf (lp, "\|%.6g", op->b_bo.bo_O);
	1004	lp += sprintf (lp, "\|%.6g", op->b_bo.bo_e);
	1005	lp += sprintf (lp, "\|%.6g", op->b_bo.bo_T);
	1006	lp += sprintf (lp, "\|%.6g", op->b_bo.bo_o);
	1007	lp += sprintf (lp, "\|%.6gy", op->b_bo.bo_P);
	1008	} else {
	1009	int i;
	1010
	1011	for (i = 0; i < op->b_nbp; i++) {
	1012	BinPos *bp = &op->b_bp[i];
	1013	lp += sprintf (lp, "%c%.6g", i==0?',':'\|', bp->bp_ep);
	1014	lp += sprintf (lp, "\|%.6g", bp->bp_sep);
	1015	lp += sprintf (lp, "\|%.6g", raddeg(bp->bp_pa));
	1016	}
[1457]	1017	}
[2551]	1018	}
[1457]	1019
[2551]	1020	static void
	1021	write_P (Obj *op, char lp[])
	1022	{
	1023
	1024	lp += sprintf (lp, "%s,P", op->o_name);
[1457]	1025	}
	1026
	1027	/* For RCS Only -- Do Not Edit */
[3654]	1028	static char rcsid[2] = {(char )rcsid, "@(#) $RCSfile: dbfmt.c,v $ $Date: 2009-07-16 10:34:36 $ $Revision: 1.9 $ $Name: not supported by cvs2svn $"};

Note: See TracBrowser for help on using the repository browser.

Download in other formats: