Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: Sophya/trunk/SophyaLib/NTools/datime.c@ 229

Visit:

Last change on this file since 229 was 220, checked in by ansari, 27 years ago
Creation module DPC/NTools Reza 09/04/99
File size: 33.9 KB

Line
1	#include "defs.h"
2	#include <stdlib.h>
3	#include <stdio.h>
4	#include <string.h>
5	#include <ctype.h>
6	#include <math.h>
7
8	#define DATIMEPRIVEE
9	#include "strutil.h"
10	#include "nbconst.h"
11	#include "datime.h"
12
13
14	/* Fonctions de calcule de date et temps (Heure) */
15	/*
16	++
17	Module Dates (C)
18	Lib LibsUtil
19	include datime.h
20
21	Ce groupe de fonctions permettent de manipuler des dates et heures.
22	En particulier, il est possible de calculer l'ecart (en nombre de jours
23	ou de secondes separant deux dates, ou le temps sideral correspondant
24	a une date et heure legale. Deux structures simples sont definies
25	afin de faciliter le passage des arguments entre differentes fonctions:
26	- JMA : Jour, Mois, Annee
27	- HMS : Heure, Minutes, Secondes
28
29	--
30	*/
31	/*
32	++
33	Links Voir aussi:
34	Temps Sideral, Universel (C)
35	--
36	*/
37	/*
38	++
39	Titre Quelques Macros
40	--
41	*/
42
43	/*
44	++
45	StrgtoJMA(strg, jma)
46	Decodage d'une chaine de caracteres "strg" sous forme de "12/3/97" en structure
47	JMA "jma".
48	JMAtoStrg(jma, strg)
49	Ecrit le contenu de la structure JMA "jma" sous forme de "jj/mm/aaaa" dans la chaine
50	de caracteres "strg"
51	JMAtoStrgLong(jma, strg)
52	Ecriture de date en format long , par ex : "Jeudi , 19 Juin 1997"
53	StrgtoHMS(strg, hms)
54	Decodage d'une chaine de caracteres "strg" sous forme de "hh:mm:ss 10:43:60.5"
55	en structure HMS "hms".
56	HMStoStrg(hms, strg)
57	Ecrit le contenu de la structure HMS "hms" sous forme de "hh:mm:ss" dans la chaine
58	de caracteres "strg"
59	StrtoHMS(strg, hms)
60	Decodage d'une chaine de caracteres "strg" sous forme de "hh:mm:ss 10:43:60.5"
61	en structure HMS "hms" avec gestion des signes (decodage correcte de -44:30:05.23)
62	HMStoStr(hms, strg)
63	Ecrit le contenu de la structure HMS "hms" sous forme de "hh:mm:ss" dans la chaine
64	de caracteres "strg" avec gestion des signes
65	--
66	*/
67
68	void StrtoHMS(char s,HMS h)
69	/* On ne peut pas ecrire 1:-05:-45 pas gere et debile! (mn et sec >=0.) cmv 12/8/97 */
70	{
71	int imoins, i2pt;
72	h->Heures = h->Minutes = 0; h->Secondes = 0.;
73	/* decodage de la chaine de characteres */
74	sscanf(s,"%d:%d:%lf", &(h->Heures),&(h->Minutes),&(h->Secondes));
75	/* cas du type 5:34:45.5 */
76	if( h->Heures > 0 ) return;
77	/* cas du type -5:34:45.5 */
78	if( h->Heures < 0 ) {
79	h->Minutes = -1; h->Secondes = -1.;
80	return;
81	}
82	/* Ici les Heures sont donc nulles "0:..." ou "-0:..." */
83	/* on n'a donne que l'heure nulle cas "0" ou "-0" sans ":" (idiot mais bon!) */
84	i2pt = posc(s,':');
85	if( i2pt < 0 ) return;
86	/* Ici on a au moins un ou 2 ":" */
87	/* cas du type 0:34:45.5 ou 0:0:45.5 sans signe - */
88	imoins = posc(s,'-');
89	if( imoins < 0 ) return;
90	/* cas du type -0:34:45.5 ou -0:0:45.5, le signe - n'est pas decode par sscanf */
91	if( imoins < i2pt ) { /* on a donne -0:34 ou -0:34:45.5 */
92	h->Minutes = -1; h->Secondes = -1.;
93	return;
94	}
95	/* Ici il reste les cas mal codes ou le signe "-" est n'importe ou! */
96	/* On laisse le decodage par sscanf */
97	return;
98	}
99
100
101	void HMStoStr(HMS h,char *s)
102	/* L'ecriture est forcee a h:mn:sec avec mn et sec >=0 cmv 12/8/97 */
103	{
104	double v;
105	v = HMStoH(h);
106	h = DoubletoHMS(v);
107	if( v < 0. ) {
108	h.Heures = -1; h.Minutes = -1; h.Secondes *= -1.;
109	sprintf(s,"-%02d:%02d:%04.1f", h.Heures,h.Minutes,h.Secondes);
110	} else {
111	sprintf(s,"%02d:%02d:%04.1f", h.Heures,h.Minutes,h.Secondes);
112	}
113	}
114
115	/* Nouvelle-Fonction */
116	int NbJourMois(int a, int m)
117	/* Retourne le nombre de jours dans le mois m, annee a */
118	{
119	if(a<100) a+=1900;
120	if( m<1 \|\| m>12 ) return(-1);
121	m--;
122	if(m!=1) return(NbJoMois[m]);
123	/* traitement du mois de fevrier bissextile ou non */
124	if( ((a%4==0) && (a%100!=0))
125	\|\| (a%400==0) ) return(NbJoMois[m]+1);
126	else return(NbJoMois[m]);
127	}
128
129	/* Nouvelle-Fonction */
130	long JMAtoJ(JMA jma)
131	/* Calcule le Nb. de jours ecoules depuis 0 Jan 1901 */
132	/* Si annee < 100 On considere annee = annee+1900 (1900-1999) */
133
134	{
135	long rc,nban;
136	int i;
137
138	/* Protection */
139	if ( (jma.Mois < 1) \|\| (jma.Mois > 12) ) jma.Mois = 1;
140	if ( (jma.Jour < 1) \|\| (jma.Jour > 31) ) jma.Jour = 1;
141
142	if (jma.Annee < 100) jma.Annee+=1900;
143	nban = jma.Annee - 1901;
144
145	/* Annee Normale = 365 Jours - Bissextile = 366 Jours */
146	/* 366 Jours : Divisible par 4 et non divisible par 100 (1972,1976) */
147	/* : Divisible par 400 (1900 Non-Biss. et 2000 Biss.) */
148
149	if (nban >= 0)
150	rc = nban*365 + (nban/4) - (nban/100) + ((nban+300)/400);
151	else
152	rc = nban*365 + (nban/4) - (nban/100) + ((nban-300)/400);
153
154	/* Comptabilisation du nb. des jours des mois ecoule */
155	for (i=1; i<jma.Mois; i++) rc += NbJourMois(jma.Annee, i);
156	rc += jma.Jour;
157
158	return(rc);
159	}
160
161	/* Nouvelle-Fonction */
162	JMA JtoJMA(long j)
163	/* retourne la date correspondant a j jours ecoules depuis le 0/1/1901 */
164	{
165	long i;
166	int inc,m;
167	JMA buf;
168
169	inc = (j>=0) ? 1 : -1;
170	buf.Jour = buf.Mois = 1; buf.Annee = 1901;
171
172	/* recherche de l'annee */
173	for(;;) {
174	i = j-JMAtoJ(buf);
175	if( i==0 ) return(buf);
176	if( inc*i<0 ) {
177	/* printf("...annee j=%ld scan=%ld test=%ld\n"
178	,j,JMAtoJ(buf),inci); /
179	break;
180	}
181	buf.Annee += inc;
182	}
183	if(inc>0) buf.Annee--;
184	/* printf("Annee trouvee: %d\n",buf.Annee); */
185
186	/* recherche du mois */
187	for(m=1;m<=12;m++) {
188	buf.Mois=m;
189	i = j-JMAtoJ(buf);
190	if( i==0 ) return(buf);
191	if(i<0) {
192	/* printf("...mois j=%ld scan=%ld test=%ld\n"
193	,j,JMAtoJ(buf),i); */
194	buf.Mois--;
195	break;
196	}
197	}
198	/* printf("Mois trouve: %d\n",buf.Mois); */
199
200	/* recherche du jour */
201	for(m=1;m<=31;m++) {
202	buf.Jour=m;
203	i = j-JMAtoJ(buf);
204	if( i==0 ) return(buf);
205	}
206	/* printf("Jour trouve: %d\n",buf.Jour); */
207
208	/* on a pas trouve !!! normallement impossible! */
209	printf("** JtoJMA_Erreur: date non trouvee j=%ld **\n",j);
210	buf.Jour = buf.Mois = 1; buf.Annee = 0;
211	return(buf);
212	}
213
214	/* Nouvelle-Fonction */
215	int NumJour(JMA jma)
216	/* Cette fonction calcule le numero de jour de la semaine */
217	/* (Lundi=1 .. Dimanche=7) */
218
219	{
220	int l;
221
222	/* On appelle JMAtoJ() pour avoir le nb de jours ecoule depuis 1/01/1901 */
223	/* Le premier janvier 1901 etait un Mardi (JMAtoJ = 1 , NumJour = 2) */
224	l = JMAtoJ(jma)%7 ;
225	if (l >= 0) return(l+1);
226	else return(l+8);
227	}
228
229	/* Nouvelle-Fonction */
230	JMA JsmmaatoJMA(int nj, int mm, int aa)
231
232	/* Pour "nj=kj*10+jj", calcule la date correspondant au "kj" eme
233	jour "jj" (1 .. 7 - Lundi .. Dimanche) du mois mm , annee aa
234	Si "nj" est negatif -> Dernier jour "jj". Si "kj=0", premier jour "jj".
235	Si "kj" ne peut etre atteint -> Dernier jour "jj".
236	Si annee "aa" <= 99 -> annee de 1901 - 1999 */
237
238	{
239	JMA jma;
240	int i,k;
241	int jj, kj;
242
243	kj = nj/10;
244	jj = nj%10;
245	if (kj < 0) kj = 0;
246
247	if (mm > 12) mm = 12;
248	if (mm < 1 ) mm = 1;
249	if (aa < 100) aa += 1900;
250	jma.Mois = mm;
251	jma.Annee = aa;
252
253	if (kj == 0) {
254	if (jj >= 0) { /* Premier jour du mois */
255	if (jj > 7) jj = 7;
256	if (jj < 1) jj = 1;
257	jma.Jour = 1;
258	i = NumJour(jma);
259	if (i > jj) jma.Jour = (7-i)+jj+1;
260	else jma.Jour = 1+(jj-i);
261	}
262	else { /* Dernier jour du mois */
263	jj = -jj;
264	if (jj > 7) jj = 7;
265	if (jj < 1) jj = 1;
266	jma.Jour = NbJourMois(aa,mm);
267	i = NumJour(jma);
268	if (i >= jj) jma.Jour -= (i-jj);
269	else jma.Jour -= (7+i-jj);
270	}
271	}
272	else { /* On demande le kj eme jour jj du mois */
273	if (jj > 7) jj = 7;
274	if (jj < 1) jj = 1;
275	k = 0;
276	for(i=1; i<=NbJourMois(aa,mm); i++) {
277	jma.Jour = i;
278	if (NumJour(jma) == jj) k++;
279	if (k == kj) break;
280	}
281	/* On n'a pas kj jour jj ds ce mois, on renvoie le dernier jj */
282	if (k<kj) return(JsmmaatoJMA(-jj, mm, aa));
283	}
284
285	return(jma);
286	}
287
288	JMA JApmmaatoJMA(int nj, int mm, int aa)
289	/* Pour "nj=dd*10+jj", calcule la date correspondant au jour
290	"jj" (1 .. 7 - Lundi .. Dimanche) du mois "mm" , annee "aa"
291	se trouvant apres (ou egal a) la date "dd/mm/aa" .
292	Si annee "aa" <= 99 -> annee de 1901 - 1999 */
293	{
294	int i, dd, jj;
295	JMA jma;
296
297	if (nj < 0) nj = -nj;
298	if (nj < 1) nj = 1;
299	dd = nj/10;
300	jj = nj%10;
301	for(i=1; i<=6; i++) {
302	jma = JsmmaatoJMA(jj+10*i, mm, aa);
303	if(jma.Jour >= dd) return(jma);
304	}
305	printf("JApmmaatoJMA(%d...) Erreur / Pas de jour %d >= %d/%d/%d\n", nj, jj,dd, mm, aa);
306	jma.Jour = jma.Mois = jma.Annee = 0;
307	return(jma);
308	}
309
310	/* Nouvelle-Fonction */
311	double HMStoH(HMS hms)
312
313	/* Cette fonction calcule le nb d'heures en decimales pour hms */
314	/* Heures/Minutes/Secondes peuvent etre +/- avec toutes les combi possibles */
315	{
316	return ((double)hms.Heures + ((double)hms.Minutes)/60. + hms.Secondes/3600.);
317	}
318
319
320
321	/* Nouvelle-Fonction */
322	double HMStoSec(HMS hms)
323	/* Calcul du nb de secondes pour hms */
324	/* Heures/Minutes/Secondes peuvent etre +/- avec toutes les combi possibles */
325	{
326	return ((double)hms.Heures3600. + (double)hms.Minutes60. + hms.Secondes);
327	}
328
329	/* Nouvelle-Fonction */
330	long DatetoSec(char const* date, char const* heure)
331	/* Calcul du nombre de secondes correspondant a date/heure */
332	/* a partir de l'origine 1er Janv 1990 0H00 */
333	/* Date entre 1930 - 2050 */
334	{
335	JMA jma,jma0;
336	HMS hms;
337	long dj;
338
339	StrgtoJMA(date,jma); StrgtoHMS(heure,hms);
340	StrgtoJMA("01/01/1990",jma0);
341	dj = JMAtoJ(jma) - JMAtoJ(jma0);
342	if (dj < -24000) return(-0x7FFFFFFF);
343	if (dj > 24000) return(0x7FFFFFFF);
344	return( dj360024 + (int)(HMStoSec(hms)) );
345	}
346
347	/* Nouvelle-Fonction */
348	long DatetoSecOff(char const* date, char const* heure)
349	{
350	JMA jma,jma0;
351	HMS hms, hms0;
352	long dj,tdec;
353
354	StrgtoJMA(date,jma); StrgtoHMS(heure,hms);
355	StrgtoJMA("01/01/1990",jma0); StrgtoHMS("00:00:00",hms0);
356	dj = JMAtoJ(jma) - JMAtoJ(jma0);
357	if (dj < -24000) return(-0x7FFFFFFF);
358	if (dj > 24000) return(0x7FFFFFFF);
359
360	/* H_vrai+TOff=H_leg : H_vrai-H_vrai0 = (H_leg-TOff)-(H_leg0-TOff0) */
361	tdec = 3600*(TLegOffset(jma, hms)-TLegOffset(jma0, hms0));
362
363	dj = dj360024 + (int)(HMStoSec(hms)) - tdec;
364	return(dj);
365	}
366
367	/* Nouvelle-Fonction */
368	HMS HtoHMS(double h)
369	/* Heures decimales en H , M , Sec Il y a un modulo 24 */
370	/* la sortie est telle que 0 <= heures < 24 */
371	{
372	HMS hms;
373
374	while (h < 0.) h += 24.;
375
376	hms.Heures = (int) h;
377	h = (h-hms.Heures)*60.;
378	hms.Minutes = (int) h;
379	hms.Secondes = (h-hms.Minutes)*60.;
380	hms.Heures = hms.Heures % 24;
381
382	return(hms);
383	}
384
385	/* Nouvelle-Fonction */
386	HMS DtoDMS(double h)
387	/* Degres decimaux en D , M , Sec Il y a un modulo 360 */
388	/* la sortie est telle que -180 < deg <= 180. */
389	{
390	HMS hms;
391	int sgn = 1;
392
393	while (h > 180.) h -= 360.;
394	while (h <= -180.) h += 360.;
395	if( h < 0. ) {h *= -1.; sgn = -1;}
396
397	hms.Heures = (int) h;
398	h = (h-hms.Heures)*60.;
399	hms.Minutes = (int) h;
400	hms.Secondes = (h-hms.Minutes)*60.;
401	hms.Heures = hms.Heures % 360;
402
403	if( sgn<0 ) {hms.Heures = -1; hms.Minutes = -1; hms.Secondes *= -1.;}
404	return(hms);
405	}
406
407	/* Nouvelle-Fonction */
408	HMS DoubletoHMS(double h)
409	/* Degres/Heures decimaux en D/H , M , Sec SANS modulo 360/24 */
410	{
411	HMS hms;
412
413	int sgn = 1;
414	if( h < 0. ) {h *= -1.; sgn = -1;}
415
416	hms.Heures = (int) h;
417	h = (h-hms.Heures)*60.;
418	hms.Minutes = (int) h;
419	hms.Secondes = (h-hms.Minutes)*60.;
420	hms.Heures = hms.Heures;
421
422	if( sgn<0 ) {hms.Heures = -1; hms.Minutes = -1; hms.Secondes *= -1.;}
423	return(hms);
424	}
425
426	/*
427	++
428	Titre Calcule sur dates et heures
429	--
430	*/
431
432	/*
433	++
434	int NbJourMois(int a, int m)
435	Retourne le nombre de jours dans le mois "m", annee "a".
436	long JMAtoJ(JMA jma)
437	Calcule le Nb. de jours ecoules depuis 0 Jan 1901,
438	Si annee < 100 On considere annee = annee+1900 (1900-1999)
439	JMA JtoJMA(long j)
440	Retourne la date correspondant a un nombre de jours "j"
441	ecoules depuis le 0 Jan 1901.
442	int NumJour(JMA jma)
443	Calcule le numero du jour de la semaine correspondant a la date indiquee
444	par la structure JMA "jma". (Lundi=1 .. Dimanche=7)
445	JMA JsmmaatoJMA(int nj, int mm, int aa)
446	Pour "nj=kj*10+jj", calcule la date correspondant au "kj" eme
447	jour "jj" (1 .. 7 - Lundi .. Dimanche) du mois mm , annee aa
448	Si "nj" est negatif -> Dernier jour "jj". Si "kj=0", premier jour "jj".
449	Si "kj" ne peut etre atteint -> Dernier jour "jj".
450	Si annee "aa" <= 99 -> annee de 1901 - 1999
451	JMA JApmmaatoJMA(int nj, int mm, int aa)
452	Pour "nj=dd*10+jj", calcule la date correspondant au jour
453	"jj" (1 .. 7 - Lundi .. Dimanche) du mois "mm" , annee "aa"
454	se trouvant apres (ou egal a) la date "dd/mm/aa" .
455	Si annee "aa" <= 99 -> annee de 1901 - 1999
456	double HMStoH(HMS hms)
457	Conversion en heures decimales de la structure "hms"
458	double HMStoSec(HMS hms)
459	Conversion en secondes de la structure HMS "hms"
460	HMS HtoHMS(double h)
461	Conversion heures en decimales en structure HMS
462	HMS DtoDMS(double h)
463	Conversion degres decimaux en structure HMS (deg,min,sec)
464	HMS DoubletoHMS(double h)
465	Conversion degres/heures decimaux en structure HMS (deg/heure,min,sec)
466	SANS modulo 360/24
467	long DatetoSec(char const* date, char const* heure)
468	Calcule le nombre de secondes correspondant a "date,heure"
469	a partir de l'origine 1er Janv 1990 0H00 ( Date entre 1930 - 2050 )
470	long DatetoSecOff(char const* date, char const* heure)
471	Calcule le nombre de secondes correspondant a "date,heure"
472	a partir de l'origine 1er Janv 1990 0H00 ( Date entre 1930 - 2050 )
473	en tenant compte des decalages des heures legales.
474	--
475	*/
476
477
478
479	/* Variables contenant les informations pour conversion */
480	/* Temps Legal <> TU <> Temps solaire moyen */
481
482	static double TSolMOff = 0.; /* TSol.Moyen - TU (en heures) */
483	static char SiteName[128]; /* Nom de site */
484
485	static struct
486	{
487	char fg; /* Flag (=A ou B) Type de specification */
488	int jj[2]; /* Numero ou date du jour */
489	int mm[2]; /* Mois */
490	int Off[3]; /* Decalage = TLegal - TU */
491	} TLegInfo = {'\0',{0,0},{0,0},{0,0,0}} ;
492
493	static HMS HChgH = {0,0,0.} ; /* Heure de changement d'heure */
494
495	/*
496	++
497	Module Temps Sideral, Universel (C)
498	Lib LibsUtil
499	include datime.h
500
501	Ce groupe de fonctions permet convertir differentes heures:
502	les temps local, le temps universel (TU), le temps legal (TLeg). Il est
503	aussi possible de calculer le temps sideral (TS).
504	--
505	*/
506	/*
507	++
508	Links Voir aussi:
509	Dates (C)
510	--
511	*/
512	/*
513	++
514	Titre T-Legal, TU
515	Conversion entre l'heure legale, le temps universel (TU) et le temps solaire
516	moyen
517	--
518	*/
519
520	/*
521	++
522	SetTSolMOff(double tsmoff, char *name)
523	Definit pour un site donne, le decalage T Sol. Moyen - TU (en heures) "tmsoff"
524	et le nom du site
525	PrtTSolMOff()
526	Imprime les infos definis par "SetTSolMOff()"
527	--
528	*/
529
530	/* Nouvelle-Fonction */
531	void SetTSolMOff(double tsmoff, char *name)
532
533	/* Offset T Sol. Moyen - TU (en hh:mm:ss) , Nom de site name */
534	{
535	TSolMOff = tsmoff;
536	strcpy(SiteName,name);
537	return;
538	}
539
540
541	/* Nouvelle-Fonction */
542	void PrtTSolMOff(void)
543	{
544	printf(" **Site : %s , T Sol.Moy.-TU %g (heures) \n",SiteName,TSolMOff);
545	return;
546	}
547
548	/*
549	++
550	int SetTLegOff(char* dtz, char* dhz)
551	Initialise la structure TLegInfo. L'argument *dtz peut etre
552	sous 2 forme differentes et permet de definir 3 plages
553	de temps avec 3 decalages horaires (nb entier).
554	Les dates pivots sont les jours de changement d'heure a
555	l'heure indiquee par dhz ("hh:mm:ss"), si "dhz==NULL ou
556	chaine vide, alors changement a 0 heure.
557	\| 1) dtz = "A Off1 j1/m1 Off2 j2/m2 Off3"
558	\| jx/mx Jour/Mois - Offx : Decalage TLeg - TU
559	\| pour 01/01 <= jj/mm < j1/m1 -> Off1
560	\| j1/m1 <= jj/mm < j2/m2 -> Off2
561	\| j2/m2 <= jj/mm <= 31/12 -> off3
562	\| 2) dtz = "B off1 Js1/m1 Off2 Js2/m2 Off3"
563	\| Jsx/mx Numero du jour de la semaine (Js) et numero du mois
564	\| Js = 1 .. 7 (Lundi .. Dimanche) : 1er Jour Js du mois
565	\| = -1 .. -7 Dernier jour Js du mois
566	\| = k1 .. k7 k eme jour Js du mois
567	\| 3) dtz = "C off1 Js1/m1 Off2 Js2/m2 Off3"
568	\| Jsx/mx Numero du jour de la semaine (Js) et numero du mois avec une
569	\| precision d'une date butee inferieurs
570	\| Js = ddj .. (j=1..7 Lundi .. Dimanche) : 1er Jour j du mois
571	\| apres (ou egal a) la date dd/mm
572	Retour : 0 si Ok -1 Sinon
573	void PrtTLegInfo(int aa)
574	Imprime les informations de decalage TLeg , TU - Annee "aa"
575	int TLegOffset(JMA date, HMS heure)
576	Indique le decalage (en nombre d'heures) TLeg-TU
577	--
578	*/
579
580	/* Nouvelle-Fonction */
581	int SetTLegOff(char* dtz, char* dhz)
582
583
584	{
585	int is;
586
587	HChgH.Heures = HChgH.Minutes = 0;
588	HChgH.Secondes = 0.;
589
590	if (dhz) StrgtoHMS(dhz, HChgH);
591	if ( (HChgH.Heures < 0) \|\| (HChgH.Heures > 23) )
592	{ HChgH.Heures = HChgH.Minutes = 0; HChgH.Secondes = 0.; }
593
594	is = sscanf(dtz,"%c %d %d/%d %d %d/%d %d", &(TLegInfo.fg), &(TLegInfo.Off[0]), &(TLegInfo.jj[0]), &(TLegInfo.mm[0]), &(TLegInfo.Off[1]), &(TLegInfo.jj[1]), &(TLegInfo.mm[1]), &(TLegInfo.Off[2]) );
595
596	if ( (TLegInfo.fg != 'A') && (TLegInfo.fg != 'B')
597	&& (TLegInfo.fg != 'C') ) TLegInfo.fg = '\0';
598	if (is != 8) TLegInfo.fg = '\0';
599	if (TLegInfo.fg != '\0') return(0);
600	else { printf("SetTLegOff()/Erreur %s \n", dtz); return(-1); }
601	}
602
603	/* Nouvelle-Fonction */
604	void PrtTLegInfo(int aa)
605
606	/* Cette fonction print les infos de TLegInfo */
607	{
608	int i,k,j;
609	char ForL[2][128];
610	JMA jma;
611
612	if (TLegInfo.fg == '\0') printf (" !!! TlegInfo not set or Error \n");
613
614
615	HMStoStrg(HChgH, ForL[0]);
616	printf(" ==== TLegInfo : Changement d'heure a %s \n", ForL[0]);
617	ForL[0][0] = '\0';
618	if (TLegInfo.fg == 'A')
619	{
620	printf(" ---- TLegInfo : Selection par date (Flag = A) ---- \n");
621	printf(" -> 01 Janvier - %d %s : %d heures \n",TLegInfo.jj[0], NomMo[TLegInfo.mm[0]-1], TLegInfo.Off[0]);
622	printf(" -> %d %s - %d %s : %d heures \n",TLegInfo.jj[0], NomMo[TLegInfo.mm[0]-1],TLegInfo.jj[1], NomMo[TLegInfo.mm[1]-1],TLegInfo.Off[1]);
623	printf(" -> %d %s - 31 Decembre : %d heures \n",TLegInfo.jj[1], NomMo[TLegInfo.mm[1]-1], TLegInfo.Off[2]);
624	}
625
626	if (TLegInfo.fg == 'B')
627	{
628	printf(" --- TLegInfo : Selection par Jour de semaine et mois (Flag = B) --- \n");
629	for (i=0;i<2;i++) {
630	k = TLegInfo.jj[i]/10;
631	if (k < 1) k = 1;
632	j = TLegInfo.jj[i]%10;
633	if (j < 0) j = -j;
634	if (j < 1) j = 1;
635	if (j > 7) j = 7;
636	if (TLegInfo.jj[i] < 0) sprintf(ForL[i]," Dernier %s de %s (KJ=%d)", NomJo[j-1],
637	NomMo[TLegInfo.mm[i]-1], TLegInfo.jj[i]);
638	else sprintf(ForL[i]," %d eme %s de %s (KJ=%d)", k, NomJo[j-1],
639	NomMo[TLegInfo.mm[i]-1], TLegInfo.jj[i]);
640	}
641	printf(" Butees: %s - %s \n", ForL[0], ForL[1]);
642	for (i=0;i<2;i++) {
643	jma = JsmmaatoJMA(TLegInfo.jj[i], TLegInfo.mm[i], aa);
644	JMAtoStrg(jma, ForL[i]);
645	}
646	printf(" -> 01 Janvier %d - %s : %d heures \n",aa, ForL[0], TLegInfo.Off[0]);
647	printf(" -> %s - %s : %d heures \n",ForL[0], ForL[1], TLegInfo.Off[1]);
648	printf(" -> %s - 31 Decembre %d : %d heures \n",ForL[1], aa, TLegInfo.Off[2]);
649	}
650
651	if (TLegInfo.fg == 'C')
652	{
653	printf(" --- TLegInfo : Selection par Jour de semaine >= dd et mois (Flag = C) --- \n");
654	for (i=0;i<2;i++) {
655	k = TLegInfo.jj[i]/10;
656	j = TLegInfo.jj[i]%10;
657	if (j < 0) j = -j;
658	if (j < 1) j = 1;
659	if (j > 7) j = 7;
660	sprintf(ForL[i],"1er %s apres le %d %s ", NomJo[j-1], k, NomMo[TLegInfo.mm[i]-1]);
661	}
662	printf(" Butees: %s - %s \n", ForL[0], ForL[1]);
663	for (i=0;i<2;i++) {
664	jma = JApmmaatoJMA(TLegInfo.jj[i], TLegInfo.mm[i], aa);
665	JMAtoStrg(jma, ForL[i]);
666	}
667	printf(" -> 01 Janvier %d - %s : %d heures \n",aa, ForL[0], TLegInfo.Off[0]);
668	printf(" -> %s - %s : %d heures \n",ForL[0], ForL[1], TLegInfo.Off[1]);
669	printf(" -> %s - 31 Decembre %d : %d heures \n",ForL[1], aa, TLegInfo.Off[2]);
670	}
671
672	return;
673	}
674
675
676	/* Nouvelle-Fonction */
677	int TLegOffset(JMA date, HMS heure)
678
679	/* Cette fonction calcule l'offset TLeg - TU pour la date donnee date */
680	{
681	JMA jma1,jma2;
682	long nbj1,nbj2,nbj;
683	double decj1, decj2, decj;
684	int Off;
685
686	/* On recherche l'offset correspondant a la date */
687	jma1.Annee = jma2.Annee = date.Annee;
688	if (TLegInfo.fg == 'A')
689	/* Periode defini par des dates ds les mois */
690	{
691	jma1.Mois = TLegInfo.mm[0];
692	jma1.Jour = TLegInfo.jj[0];
693	jma2.Mois = TLegInfo.mm[1];
694	jma2.Jour = TLegInfo.jj[1];
695	}
696	if (TLegInfo.fg == 'B')
697	/* Periodes definies par jour de semaine et mois */
698	{
699	jma1 = JsmmaatoJMA(TLegInfo.jj[0],TLegInfo.mm[0],date.Annee);
700	jma2 = JsmmaatoJMA(TLegInfo.jj[1],TLegInfo.mm[1],date.Annee);
701	}
702
703	if (TLegInfo.fg == 'C')
704	/* Periodes definies par jour de semaine et mois avec date inferieure */
705	{
706	jma1 = JApmmaatoJMA(TLegInfo.jj[0],TLegInfo.mm[0],date.Annee);
707	jma2 = JApmmaatoJMA(TLegInfo.jj[1],TLegInfo.mm[1],date.Annee);
708	}
709
710	nbj = JMAtoJ(date);
711	nbj1 = JMAtoJ(jma1);
712	nbj2 = JMAtoJ(jma2);
713
714	/* Les dates pivots sont les jours de changement d'heure a Heure= HChgH */
715	decj = (double)nbj + HMStoH(heure)/24.;
716	decj1 = (double)nbj1 + HMStoH(HChgH)/24.;
717	decj2 = (double)nbj2 + HMStoH(HChgH)/24.;
718
719	if ( decj < decj1 ) Off = TLegInfo.Off[0];
720	else if (decj < decj2) Off = TLegInfo.Off[1];
721	else Off = TLegInfo.Off[2];
722
723	/* Impression de debugging */
724	/*Debug-- printf (" @@@ Debug_TLegOffset (date= %d/%d/%d) : %d H. \n",date.Jour,date.Mois,date.Annee,Off);
725	printf(" @-1 %s , %d %s %d \n", NomJo[NumJour(jma1)-1], jma1.Jour, NomMo[jma1.Mois-1], jma1.Annee) ;
726	printf(" @-2 %s , %d %s %d \n", NomJo[NumJour(jma2)-1], jma2.Jour, NomMo[jma2.Mois-1], jma2.Annee) ; --*/
727
728
729	return (Off);
730	}
731
732	/*
733	++
734	HMS TLegtoTU(JMA date, HMS TLeg)
735	Conversion TLegal en TU pour une date donnée
736	HMS TUtoTLeg(JMA date, HMS TLeg)
737	Conversion TU en TLegal pour une date donnée. L'heure légale calculée
738	peut être erronnée autour des dates de changement d'heure.
739	HMS TUtoTSolM(HMS TU)
740	Conversion TU en temps solaire moyen
741	--
742	*/
743
744	/* Nouvelle-Fonction */
745	HMS TLegtoTU(JMA date, HMS hmsz)
746
747	/* Cette fonction transforme le temps legal en temps universel */
748	{
749	HMS TU;
750	int Off;
751
752	Off = TLegOffset(date, hmsz);
753	TU = hmsz;
754	TU.Heures -= Off;
755	if (TU.Heures >= 24) TU.Heures -= 24;
756	if (TU.Heures < 0) TU.Heures += 24;
757	return(TU);
758	}
759
760
761
762	/* Nouvelle-Fonction */
763	HMS TUtoTLeg(JMA date, HMS hms)
764
765	/* Cette fonction transforme le temps universel en temps legal */
766	{
767	HMS TLeg;
768	int Off;
769
770	Off = TLegOffset(date, hms); /* $CHECK$ */
771	TLeg = hms;
772	TLeg.Heures += Off;
773	TLeg.Heures = TLeg.Heures%24;
774	if (TLeg.Heures < 0) TLeg.Heures += 24;
775	return(TLeg);
776	}
777
778
779	/* Nouvelle-Fonction */
780	HMS TUtoTSolM(HMS TU)
781
782	/* Passage TU -> Temps local */
783	{
784	double t;
785	t = HMStoH(TU) + TSolMOff;
786	return(HtoHMS(t));
787	}
788
789	/*
790	++
791	Titre Temps Sideral
792	\| Jour Sideral = 86400 Sec. Sid. ( = 24 H Sid. )
793	\| Annee Solaire = 365 J 5H 48' 46" =~ 365.2422 J
794	\| Annee Solaire = 365.2422 Jours Solaire Moyen = 366.2422 Jours Sideraux
795	\| Jour Sol. Moyem = 24 H Sol. = 24 H Sid. * (366.2422 / 365.2422)
796	\| Jour Solaire Moyen = 86636.555359 Sec. Sid. = 24 H 3' 56.555359"
797	\| Heure Solaire Moyen = 3609.85647 Sec. Sid.
798	\| Sec. Sol. = 1.0027379 Sec. Sid.
799	\| Le 1er Janvier 1989 0H TU Il etait 6H 42' 30" GMT_Sideral
800	--
801	*/
802
803	/*
804	++
805	HMS TLegtoTSid(JMA date, HMS TZ)
806	Cette fonction calcule le temps sideral a partir du temps
807	legal et de la date
808	GMST_at_0h_UT(JMA date)
809	Cette fonction calcule le temps sideral moyen a greenwich a 0h UT
810	--
811	*/
812
813	/* Nouvelle-Fonction */
814	HMS TLegtoTSid(JMA date, HMS TZ)
815
816	/* Cette fonction donne le temps sideral a partir du temps legal */
817	/* et la date */
818	{
819	HMS Orgh,TU,TSid;
820	JMA Orgd;
821	int off;
822	long lj;
823	double ts,ratio;
824
825	/* Le 1er Janvier 1989 0H TU Il etait 6H 42' 30" GMT_Sideral */
826	StrgtoJMA("1/1/1989",Orgd);
827	StrgtoHMS("6:42:30",Orgh);
828
829
830
831	/* Nb de jours / Date Origine */
832	lj = JMAtoJ(date) - JMAtoJ(Orgd);
833
834	/* On calcule l'heure TU et on tient compte du decalage eventuel de + ou - 1 jour */
835	off = TLegOffset(date, TZ);
836	TU = TZ;
837	TU.Heures -= off;
838	if (TU.Heures < 0)
839	{
840	lj -= 1;
841	TU.Heures += 24;
842	}
843	if (TU.Heures >= 24)
844	{
845	lj += 1;
846	TU.Heures -= 24;
847	}
848
849
850
851	ratio = ((365.*24.) + 5. + (48. / 60.) + (46. / 3600.)) / 24.;
852	ratio = (ratio+1) / ratio ;
853
854	/* Calcul du decalage en heures du temps Sideral par rapport a */
855	/* l'origine choisie : ts */
856
857	ts = lj * (24. * (ratio - 1) );
858	ts += ( TU.Heures * ratio );
859	ts += ( ( TU.Minutes / 60. ) * ratio );
860	ts += ( (TU.Secondes / 3600. ) * ratio );
861
862	ts += HMStoH(Orgh);
863
864	/* On tient compte de l'offset du temps solaire moyen */
865	ts += TSolMOff;
866
867	TSid = HtoHMS(ts);
868	TSid.Heures = TSid.Heures % 24;
869	if (TSid.Heures < 0) TSid.Heures += 24;
870
871	return(TSid);
872	}
873
874
875	/* Nouvelle-Fonction */
876	HMS GMST_at_0h_UT (JMA date)
877
878	/* Cette fonction donne le temps sideral moyen a greenwich a 0h UT */
879	/* CMV 5/11/93 */
880	{
881	HMS Orgh, TSid;
882	JMA Orgd;
883	long lj, ejs;
884	double js, hs, hs0;
885
886	/* J H ' " sont les vraies valeurs indiscutables (cf metre etalon etc..) */
887	/* Annee Solaire = 365 J 5H 48' 45.2" =~ 365.2421898148 J */
888	/* Annee Siderale = 365 J 6H 9' 9.8" =~ 365.2563634259 J */
889	/* Le 1er Janvier 1994 0H TU Il sera 6h 41' 40.4305" GMT_Sideral */
890	StrgtoJMA("1/1/1994",Orgd);
891	StrgtoHMS("6:41:40.4305",Orgh);
892	hs0 = HMStoH(Orgh);
893
894	/* Nb de jours ecoules depuis la Date Origine */
895	lj = JMAtoJ(date) - JMAtoJ(Orgd);
896	/* printf("nombre de jours ecoules depuis 1/1/94 %d\n",lj); */
897
898	/* Nb de jours sideraux depuis la Date Origine */
899	js = (double) lj * 366.2421898148 / 365.2421898148;
900	/* Nb d'heures siderales depuis Date Origine (modulo un jour) */
901	ejs = (int) js;
902	hs = js - (double) ejs;
903	hs *= 24.;
904	hs += hs0;
905
906	TSid = HtoHMS(hs);
907	/* printf("nombre d'heures siderales depuis la reference (modulo un jour) %d %d %f\n"
908	,TSid.Heures,TSid.Minutes,TSid.Secondes); */
909
910	return(TSid);
911	}
912
913	/*
914	++
915	HMS TUtoTSid(JMA date, HMS TU)
916	Cette fonction calcule le temps sideral GMT a partir du temps
917	universel et de la date GMT.
918	int TSidtoTU(JMA date, HMS TS, HMS TU1, HMS TU2)
919	Cette fonction calcule les temps universels a partir du temps
920	sideral GMT et de la date GMT. Selon la valeur du TS, il peut y avoir
921	une ou deux possibilites pour le TU (return code).
922	--
923	*/
924
925	/* Nouvelle-Fonction */
926	HMS TUtoTSid(JMA date, HMS TU)
927
928	/* Cette fonction donne le temps sideral GMT a partir du temps universel */
929	/* et la date GMT */
930	{
931	HMS Orgh,TSid;
932	JMA Orgd;
933	long lj;
934	double ts,ratio;
935
936	/* Le 1er Janvier 1989 0H TU Il etait 6H 42' 30" GMT_Sideral */
937	StrgtoJMA("1/1/1989",Orgd);
938	StrgtoHMS("6:42:30",Orgh);
939
940	/* Nb de jours / Date Origine */
941	lj = JMAtoJ(date) - JMAtoJ(Orgd);
942
943	ratio = ((365.*24.) + 5. + (48. / 60.) + (46. / 3600.)) / 24.;
944	ratio = (ratio+1) / ratio ;
945
946	/* Calcul du decalage en heures du temps Sideral par rapport a */
947	/* l'origine choisie : ts */
948
949	ts = lj * (24. * (ratio - 1) );
950	ts += ( TU.Heures * ratio );
951	ts += ( ( TU.Minutes / 60. ) * ratio );
952	ts += ( (TU.Secondes / 3600. ) * ratio );
953
954	ts += HMStoH(Orgh);
955
956	TSid = HtoHMS(ts);
957	TSid.Heures = TSid.Heures % 24;
958	if (TSid.Heures < 0) TSid.Heures += 24;
959
960	return(TSid);
961	}
962
963	/* Nouvelle-Fonction */
964	int TSidtoTU(JMA date, HMS TS, HMS TU1, HMS TU2)
965
966	/* Cette fonction donne les temps universels a partir du temps sideral GMT */
967	/* et la date GMT */
968	{
969	int rc = 0;
970	HMS Orgh,T0;
971	double ratio,delt,deltt,jsecsid;
972	char strd[16],strh[16];
973	/* char strh1[16]; */
974
975	TU1->Heures = TU2->Heures = -1;
976	TU1->Minutes = TU2->Minutes = 0;
977	TU1->Secondes = TU2->Secondes = 0.;
978
979	ratio = ((365.*24.) + 5. + (48. / 60.) + (46. / 3600.)) / 24.;
980	ratio = (ratio / (ratio+1));
981	jsecsid = 86400./ratio;
982
983	/* temps sideral pour la date a 0h TU */
984	StrgtoHMS("00:00:00",T0);
985	Orgh = TUtoTSid(date,T0);
986	/* JMAtoStrg(date,strd); HMStoStrg(T0,strh); HMStoStrg(Orgh,strh1);
987	printf("... date=%s tu=%s -> org_ts=%s\n",strd,strh,strh1); */
988
989	/* difference de temps sideral / a 0h TU */
990	delt = HMStoSec(TS) - HMStoSec(Orgh);
991	/* printf("... ts=%f org_ts=%f en sec -> delt=%f (jsecsid=%g)\n"
992	,HMStoSec(TS),HMStoSec(Orgh),delt,jsecsid); */
993
994	if(fabs(delt)<1.e-10) delt=0.;
995	if(delt<0.) delt += 86400.;
996	if( fabs(delt-86400.)<1.e-10 ) delt = 86400. - 1.e-10;
997	if(delt<0. \|\| delt>=86400.+1.e-10) {
998	HMStoStrg(TS,strh);
999	JMAtoStrg(date,strd);
1000	printf("* BUG * TSidtoTU_erreur: delt=%g<0. (d=%s,ts=%s) *******\n"
1001	,delt,strd,strh);
1002	return(0);
1003	}
1004
1005	/* difference de temps / a 0h TU 1ere solution */
1006	/* printf("... delt=%f en sec sid",delt); */
1007	deltt = delt*ratio;
1008	*TU1 = SectoHMS(deltt);
1009	TU2 = TU1;
1010	rc++;
1011	/* HMStoStrg((*TU1),strh1);
1012	printf("... deltt=%f en sec -> TU1=%s\n",deltt,strh1); */
1013
1014	/* Y a t-il une seconde solution ? */
1015	if(delt>=jsecsid-86400.-1.e-10) return(rc);
1016	delt += 86400.;
1017	deltt = delt*ratio;
1018	*TU2 = SectoHMS(deltt);
1019	/* HMStoStrg((*TU2),strh1);
1020	printf("... deltt=%f en sec -> TU2=%s\n",deltt,strh1); */
1021	rc++;
1022
1023	return (rc);
1024	}
1025
1026	/*
1027	++
1028	void TSidSetupLaSilla()
1029	Fonction d'initialisation de conversion de temps sideral et legal
1030	pour la ESO-Silla "SetTSolMOff() , SetTLegOff()".
1031	\| Longitude = 70 deg 43.8 min ouest
1032	\| Latitude = 29 deg 15.4 min Sud
1033	\| T Sol. Moyen - TU = -4.715333 Heures
1034	\| TLegal-TU : -4 Heures de Mars a Octobre, -3 Heures sinon
1035	\| Changement le 1er dimanche >= 8/03 8/10 a midi (12:00:00)
1036	--
1037	*/
1038
1039	/* Fonction d'initialisation de calcul de temps sideral pour la Silla */
1040	void TSidSetupLaSilla()
1041	{
1042	SetTSolMOff((double)(-4.715333),"La Silla (Chili)");
1043	if (SetTLegOff("C -3 87/3 -4 87/10 -3","12:00:00") != 0)
1044	printf(" TSidSetupLaSilla / Erreur SetTLegOff \n");
1045	/* Position de l'observatoire */
1046	/* SetObsPos("La Silla (Chili)","O 70:43:48","S 29:15:24",2347); */
1047	return;
1048	}
1049
1050
1051
1052	/*
1053	++
1054	double ToJulianDay(JMA dateTU, HMS hmsTU);
1055	Calcul du jour Julien pour une date TU.
1056	Uniquement valable a partir du 15/10/1582 00:00:00.
1057	--
1058	*/
1059
1060	double ToJulianDay(JMA dateTU, HMS hmsTU)
1061	/* Cf Fundamental astronomie, Springer Verlag 2sd ed. cmv 4/12/98 */
1062	{
1063	double j_dat_0_ut;
1064	long int f,g,a;
1065	f = (dateTU.Mois>=3) ? dateTU.Annee: dateTU.Annee-1;
1066	g = (dateTU.Mois>=3) ? dateTU.Mois: dateTU.Mois+12;
1067	a = 2 - (int)((double)f/100.) + (int)((double)f/400.);
1068	/* Julian date at 0h UT */
1069	j_dat_0_ut = (int)(365.25(double)f)+(int)(30.6001(double)(g+1))+dateTU.Jour+a+1720994.5;
1070	return j_dat_0_ut + HMStoH(hmsTU)/24.;
1071	}
1072
1073	/*
1074	++
1075	int FromJulianDay(double JD,JMA* dateTU, HMS* hmsTU);
1076	Calcul de la date date et l'heure TU a partir d'un jour Julien.
1077	Retourne 0 si succes.
1078	--
1079	*/
1080
1081	int FromJulianDay(double JD,JMA* dateTU, HMS* hmsTU)
1082	/* Cf Fundamental astronomie, Springer Verlag 2sd ed. cmv 4/12/98 */
1083	{
1084	double jd,i,f,a,x,b,c,d,e,h;
1085	if(JD<0.) return 1;
1086
1087	i = JD - (int)(JD);
1088	if(i<0.5) jd = (int)(JD)-0.5; else jd = (int)(JD)+0.5;
1089
1090	i = (int)(jd+0.5);
1091	f = jd+0.5 - i;
1092	if(i<2299161.0) a = i;
1093	else {x = (int)((i-1867216.25)/36524.25); a = i+1.+x-(int)(x/4.);}
1094	b = a+1524.;
1095	c = (int)((b-122.1)/365.25);
1096	d = (int)(365.25*c);
1097	e = (int)((b-d)/30.6001);
1098
1099	x = b-d-(int)(30.6001*e)+f;
1100	dateTU->Jour = (int)(x);
1101
1102	if(e<13.5) dateTU->Mois = (int)(e-1.); else dateTU->Mois = (int)(e-13.);
1103
1104	if(dateTU->Mois>2.5) dateTU->Annee = (int)(c-4716.); else dateTU->Annee = (int)(c-4715.);
1105
1106	hmsTU->Heures = hmsTU->Minutes = 0; hmsTU->Secondes = 0.;
1107	h = (JD-ToJulianDay(dateTU,hmsTU)) * 24.;
1108	*hmsTU = HtoHMS(h);
1109
1110	return 0;
1111	}
1112
1113
1114	/*
1115	++
1116	double StrgtoDegDec(char *strg)
1117	Cette fonction renvoie la valeur decimale en heures
1118	d'un angle specifie sous forme de [-][+]dd:mm:ss.
1119	--
1120	*/
1121
1122	double StrgtoDegDec(char *strg)
1123	/* cmv 4/12/98 */
1124	{
1125	int dd,mm;
1126	float ss;
1127	char sgn;
1128	double deg;
1129
1130	dd = mm = 0;
1131	ss = 0.;
1132	sgn = *strg;
1133	if (isdigit(sgn))
1134	sscanf(strg,"%d:%d:%f",&dd,&mm,&ss);
1135	else
1136	sscanf(strg+1,"%d:%d:%f",&dd,&mm,&ss);
1137	deg = (double)(dd) + (double)(mm)/60. + (double)(ss)/3600.;
1138	if (sgn == '-') deg = (-deg);
1139	return(deg);
1140	}
1141
1142	/*
1143	++
1144	char * DegDectoStrg(double deg, char *strg)
1145	Cette fonction ecrit une valeur en degre decimal sous
1146	forme de [-]dd:mm:ss.
1147	--
1148	*/
1149
1150	char * DegDectoStrg(double deg, char *strg)
1151	/* cmv 4/12/98 */
1152	{
1153	int dd,mm;
1154	float ss;
1155	char sgn;
1156
1157	if (deg < (double)(0.))
1158	{ deg = (-deg) ; sgn = '-' ; }
1159	else sgn = '+';
1160	dd = (int)deg;
1161	deg = (deg-(double)(dd)) * (double)60.;
1162	mm = (int)deg;
1163	ss = (deg-(double)(mm)) * (double)60.;
1164	if (sgn == '-')
1165	sprintf(strg,"-%d:%d:%f",dd,mm,ss);
1166	else
1167	sprintf(strg,"%d:%d:%f",dd,mm,ss);
1168	return(strg);
1169	}
1170
1171	/*
1172	++
1173	double EccEarth(JMA dateTU)
1174	Valeur de l'eccentricite de l'orbite terrestre
1175	a la date TU ``dateTU''.
1176	--
1177	*/
1178	double EccEarth(JMA dateTU)
1179	/* Cf Fundamental astronomie, Springer Verlag 2sd ed p477 table E10. cmv 9/12/98 */
1180	{
1181	double JD,T;
1182	HMS hmsTU;
1183	hmsTU.Heures = 12; hmsTU.Minutes = 0; hmsTU.Secondes = 0.;
1184	JD = ToJulianDay(dateTU,hmsTU);
1185	/* T en siecles juliens depuis 31/12/1899 a 12h TU --> JD=2415020. */
1186	T = (JD-2415020.)/36525;
1187	return(0.0167498 - 0.00004258T - 0.000000137T*T);
1188	}
1189
1190	/*
1191	++
1192	double ObliqEarth(JMA dateTU)
1193	Valeur de l'obliquite de l'orbite terrestre
1194	a la date TU ``dateTU'' (en degres decimaux).
1195	--
1196	*/
1197	double ObliqEarth(JMA dateTU)
1198	/* Cf Fundamental astronomie, Springer Verlag 2sd ed. cmv 9/12/98 */
1199	/* le 1/1/1900 a 0h00 TU --> jd = 2415020.5 */
1200	{
1201	double jd;
1202	HMS hmsTU;
1203	hmsTU.Heures = hmsTU.Minutes = 0; hmsTU.Secondes = 0.;
1204	jd = ToJulianDay(dateTU,hmsTU) - 2415020.5;
1205	return(23.452294 - 0.00013 *jd/365.25);
1206	}
1207
1208	/*
1209	++
1210	double LongEcPerihelie(JMA dateTU)
1211	Retourne la Longitude Ecliptique du perihelie de
1212	l'orbite terrestre a la date TU ``dateTU'' (en degres decimaux).
1213	--
1214	*/
1215	double LongEcPerihelie(JMA dateTU)
1216	/* Cf Fundamental astronomie, Springer Verlag 2sd ed p477 table E10. cmv 9/12/98 */
1217	{
1218	double JD,T;
1219	HMS hmsTU;
1220	hmsTU.Heures = 12; hmsTU.Minutes = 0; hmsTU.Secondes = 0.;
1221	JD = ToJulianDay(dateTU,hmsTU);
1222	/* T en siecles juliens depuis 31/12/1899 a 12h TU --> JD=2415020. */
1223	T = (JD-2415020.)/36525;
1224	/* l = 101d 13' 07.15" + 6171.77" T + 1.823" T^2 */
1225	return(101.218652778 + 1.71438055556T + 0.000506388889T*T);
1226	}
1227
1228	/*
1229	++
1230	void EquatToEclip(double a,double d,double* l,double *b,JMA dateTU);
1231	Renvoie les coordonnees ecliptiques ``l,b'' a partir de
1232	coordonnees equatoriales ``a,d'' a la date TU ``dateTU''.
1233	La date permet de corriger la variation annuelle
1234	de l'obliquite terrestre.
1235	--
1236	*/
1237	void EquatToEclip(double a,double d,double* l,double *b,JMA dateTU)
1238	/* Cf Fundamental astronomie, Springer Verlag 2sd ed p477 table E10. cmv 9/12/98 */
1239	/* l=[0,360[, b=[-90,90] */
1240	{
1241	double e,sinb,cosb,sinl,cosl;
1242
1243	e = ObliqEarth(dateTU)*DegenRad;
1244	a = DegenRad; d = DegenRad;
1245
1246	sinb = sin(d)cos(e)-cos(d)sin(e)*sin(a);
1247	if(sinb>1.) sinb=1.; if(sinb<-1.) sinb=-1.;
1248	*b = asin(sinb);
1249	cosb = cos(*b);
1250
1251	*l = 0.;
1252	if(cosb!=0.) {
1253	sinl = (sin(d)sin(e)+cos(d)cos(e)*sin(a))/cosb;
1254	cosl = cos(d)*cos(a)/cosb;
1255	if(cosl>1.) cosl=1.; if(cosl<-1.) cosl=-1.;
1256	*l = acos(cosl);
1257	if(sinl<0.) *l += M_PI;
1258	if(l>2.M_PI) l -= 2.M_PI;
1259	}
1260
1261	*b /= DegenRad;
1262	*l /= DegenRad;
1263	}

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

Download in other formats: