Index: trunk/Poubelle/archTOI.old/archeops.c
===================================================================
--- trunk/Poubelle/archTOI.old/archeops.c	(revision 315)
+++ trunk/Poubelle/archTOI.old/archeops.c	(revision 315)
@@ -0,0 +1,653 @@
+//#include "manip.h"
+#include <stdio.h>
+#include "archeops.h"
+
+
+/**********  coefficients  pour  les  mesures  bolo    ********************************/
+/*                         toutes les puissances en pW                                */
+/*	-1-	loi de reponse thermique des bolos  avec R en ohms et T en Kelvin     */
+/*                                                                                    */
+/* 	T =  coef2  *   (   ln (  R / coef1) **  ( -1 / coef0 )                       */
+/*                                                                                    */
+/*	-2-	fuite thermique du bolo   coef 3,4                                    */
+/*                                                                                    */
+/*	Ptot =  coef3  *  ( (10*Tb) ** coef4    -    (10*Tcryo)  **  coef4 )          */
+/*                                                                                    */
+/*	-3-	calcul empirique de Pciel et de  tau	  coef  5,6                   */
+/*                                                                                    */
+/*	Pciel	=	coef5	- Pelec		coef5= I * Ai (tables xavier) 	      */
+/*	tau	=	- ln ( 1 +  Pciel / coef6 )	coef6= I * Bi (tables xavier) */
+/*                                                                                    */
+/**************************************************************************************/
+
+
+/**************************************************************************************/
+/*                                                                                    */
+/*   pour les MLPA      :  gain = 100   diviseur = 101  ou  330                       */
+/*   pour les bebodiff  :  gain = diviseur = 100Kohm / R preampli                     */
+/*   pour les bebodiff  :  la capa est corrigee d'un facteur 0.868                    */
+/*   pour les cartes modifiees : mettre diviseur=0                                    */
+/*                         et capa = la resistance de chage en Megohm                 */
+/*                                                                                    */
+/**************************************************************************************/
+
+
+/*  nom  ,  on/off  ,  0 = MLPA       , N° bolo ,  gain_pa  , capa*1000 , diviseur , coef*10000
+/*       ,  0 ou 1  ,  2..8 = BEBO    ,  hard   ,           ,  4700     ,  333     , 
+/*                     10 = Bediff    ,         ,           , 
+
+/* pour les bediff (code 10)  le n° de bolo est  N° de bebo*8  +  numero dans la bebo
+/*  soit :  1 2 3 4 5 6  ..  9 10 11 12 13 14 .. 17 18 19 20 21 22 .. etc
+
+
+/*debut_param*/
+/*----------------------------------  fenetre :  -----------------------------------*/
+
+param_bolo  parametr={24,24,36,88,18,
+
+{
+{ "v1-bedif1"  , 1,10,1 ,  200, 22000,  200, { 5000   , 123100 , 334200 } },		
+{ "v1-bedif2"  , 1,10,2 ,  200, 22000,  200, { 5000    , 12.31 , 33.42 		} },
+{ "v1-bedif3"  , 1,10,3 ,  200, 22000,  200, { 5000    , 50.0 , 14.0 		} },
+{ "v1-bedif4"  , 1,10,4 ,  200, 22000,  200,  { 5000    , 12.31 , 33.42 	} },
+{ "v1-bedif5"  , 1,10,5 , 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 	} },
+{ "v1-bedif6"  , 1,10,6 , 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 	} },
+
+{ "v1-bedif7"  , 1,10,9 , 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+{ "v1-bedif8"  , 1,10,10, 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+{ "v1-bedif9"  , 1,10,11, 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+{ "v1-bedif10" , 1,10,12, 1000, 4700, 1000,  { 5000     , 12.31 , 33.42 		 } },
+{ "v1-bedif11" , 1,10,13, 1000, 4700, 1000, { 5000     , 12.31 , 33.42 		 } },
+{ "v1-bedif12" , 1,10,14, 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+
+{ "v1-bedif13" , 1,10,17, 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+{ "v1-bedif14" , 1,10,18, 1000, 4700, 1000,  { 5000     , 12.31 , 33.42 		 } },
+{ "germanium"  , 3,10,19, 1000, 22000 ,    0,  { 5000      , 12.31 , 33.42 		 } },
+{ "therm_4k"   , 3,10,20, 1000, 1000  ,    0,  { 5000      , 12.31 , 33.42 		 } },
+{ "therm_1.6k" , 3,10,21, 1000, 1000  ,    0,  { 5000      , 12.31 , 33.42 		 } },
+{ "therm_10k"  , 3,10,22, 1000, 1000  ,    0,  { 5000     , 12.31 , 33.42 		 } },
+
+{ "v1-bedif19"  , 2,10,25 , 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+{ "v1-bedif20"  , 2,10,26, 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+{ "v1-bedif21"  , 2,10,27, 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } },
+{ "v1-bedif22"  , 2,10,28, 1000, 4700, 1000,  { 5000     , 12.31 , 33.42 		 } },
+{ "v1-bedif23"  , 2,10,29, 1000, 4700, 1000,  { 5000     , 12.31 , 33.42 		 } },
+{ "v1-bedif24"  , 2,10,30, 1000, 4700, 1000,  { 5000      , 12.31 , 33.42 		 } }
+
+}
+};
+/*fin_param*/
+
+
+
+/* bolos campagne 1998-1999	*/
+/*
+reg_NbSi.J, 1, 0, 1, 100, 4.7, 333,	.5			,519.6  , 8.286
+v1-231...L, 1, 0, 2, 100, 4.7, 333, .5   , 1.7   , 32.41 , 0.333 , 10  , 20.30  ,  11.41  		
+v1-232...N, 1, 0, 3, 100, 4.7, 333,		
+v1-237...E, 1, 0, 4, 100, 4.7, 333,
+
+reg_JamieO, 1, 0, 5, 100, 4.7, 101,
+
+V2-NbSi..H, 1, 0, 6, 100, 4.7, 101, .5   ,433.8  , 9.25
+V2-230...B, 1, 0, 7, 100, 4.7, 333, .5   , 8.26  , 26.61 , 5.10  ,  7  , 9.354   ,  1.026
+V2-205...Q, 1, 0, 8, 100, 4.7, 333,	.518 , 81    , 25.2 
+V2-208...P, 1, 0, 9, 100, 4.7, 333, .5   , 12.31 , 33.42 , 0.627 , 6.5 , 8.113   ,  2.958
+
+*/
+/*bolos campagne 1997-1998	*/
+/*
+
+v1-208...J, 1, 0, 1, 100, 4.7, 333, .5   , 12.31 , 33.42 		
+v1-232...L, 1, 0, 2, 100, 4.7, 333,		
+v1-205...N, 1, 0, 3, 100, 4.7, 333,	.518 , 81    , 25.2	
+v1-NbSi..E, 1, 0, 4, 100, 4.7, 333,	.5			,519.6  , 8.286
+Jamie....O, 1, 0, 5, 100, 4.7, 101,
+V2-NbSi..H, 1, 0, 6, 100, 4.7, 101, .5   ,433.8  , 9.25
+V2-224...B, 1, 0, 7, 100, 4.7, 333, .5   ,3.43   , 26.6
+V2-230...Q, 1, 0, 8, 100, 4.7, 333, .5   , 8.26  , 26.61
+V2-231...P, 1, 0, 9, 100, 4.7, 333, .5   , 1.7   , 32.41
+
+*/
+
+
+
+
+
+/*debut_nom_reglage*/
+/* 0->aa*/
+/* 1->bb*/
+/* 2->cc*/
+/* 3->reglage 3  */
+/* 4->reglage 4  */
+/* 5->reglage 5  */
+/* 6->reglage 6  */
+/* 7->reglage 7  */
+/*fin_nom_reglage*/
+
+
+
+
+
+
+
+reglage_bolo  reglage_standard[8]={{
+
+
+/*debut reglage 0 */
+{30,76,9,1},
+{0
+,10
+,1
+,3
+,10
+,2
+,0
+,0
+,1
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+},{
+{22,100663296}
+,{-100646890,1}
+,{-100646890,1}
+,{22,0}
+,{-100638698,1}
+,{22,253952}
+,{-100646890,1}
+,{22,0}
+,{-100646890,1}
+,{-100646890,1}
+,{22,0}
+,{235388950,221185}
+,{20,0}
+,{20,0}
+,{16406,0}
+,{24598,0}
+,{22,0}
+,{24598,0}
+},{
+{1,22,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+},{
+{0,1,9,1,0,0,0}
+,{0,1,9,1,0,0,0}
+,{0,1,9,1,0,0,0}
+,{0,1,9,1,0,0,0}
+},{0,0,0,0,0,0,0,0} 
+/*fin_reglage*/
+
+},{
+
+/*debut reglage 1 */
+{30,76,9,1},
+{0
+,10
+,1
+,3
+,10
+,2
+,0
+,0
+,1
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+,0
+},{
+{22,100663296}
+,{-100646890,1}
+,{-100646890,1}
+,{22,0}
+,{-100638698,1}
+,{22,253952}
+,{-100646890,1}
+,{22,0}
+,{-100646890,1}
+,{-100646890,1}
+,{22,0}
+,{235388950,221185}
+,{20,0}
+,{20,0}
+,{16406,0}
+,{24598,0}
+,{22,0}
+,{24598,0}
+},{
+{1,22,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+,{0,20,0,1}
+},{
+{0,1,9,1,0,0,0}
+,{0,1,9,1,0,0,0}
+,{0,1,9,1,0,0,0}
+,{0,1,9,1,0,0,0}
+},{0,0,0,0,0,0,0,0} 
+/*fin_reglage*/
+
+},{
+
+/*debut reglage 2 */
+{31,76,9,0},
+{0
+,-14
+,-31
+,-63
+,-83
+,-103
+,-122
+,127
+,1
+,97
+,14
+,-32
+,-93
+,-87
+,-72
+,-80
+,-101
+,-112
+,-113
+,-121
+},{
+{22,100663296}
+,{1040629782,204800}
+,{1040834582,221184}
+,{22,0}
+,{-100450282,2}
+,{22,253952}
+,{-100458474,2}
+,{22,0}
+,{-100442090,2}
+,{-100253674,253954}
+,{22,0}
+,{303013910,221184}
+,{20,0}
+,{20,0}
+,{9238,0}
+,{24598,301989888}
+,{22,0}
+,{24598,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+},{
+{-15,-9,-13,-38}
+,{-83,-109,-90,-68}
+,{-99,-101,-67,-61}
+,{-64,-60,-38,-19}
+,{-28,-57,-77,-75}
+,{-66,-55,-51,-68}
+},{
+{31,76,9,0,0,-35,-4643}
+,{-55,-77,-69,-55,-44,-43,-12336}
+,{-56,-85,-128,99,111,-116,-28030}
+,{105,107,101,101,106,111,31615}
+},{-102,-88,-94,-113,-126,101,73,70} 
+/*fin_reglage*/
+
+},{
+
+/*debut reglage 3 */
+{31,76,9,0},
+{0
+,-14
+,-31
+,-63
+,-83
+,-103
+,-122
+,127
+,1
+,99
+,13
+,96
+,-93
+,-87
+,-72
+,-80
+,-101
+,-112
+,-113
+,-121
+},{
+{22,100663296}
+,{1040629782,204800}
+,{1040834582,221184}
+,{22,0}
+,{-100450282,2}
+,{22,253952}
+,{-100458474,2}
+,{22,0}
+,{-100442090,2}
+,{-100253674,253954}
+,{22,0}
+,{303013910,221184}
+,{20,0}
+,{20,0}
+,{9238,0}
+,{24598,301989888}
+,{22,0}
+,{24598,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+},{
+{-15,-9,-13,-38}
+,{-83,-109,-90,-68}
+,{-99,-101,-67,-61}
+,{-64,-60,-38,-19}
+,{-28,-57,-77,-75}
+,{-66,-55,-51,-68}
+},{
+{31,76,9,0,0,-35,-4643}
+,{-55,-77,-69,-55,-44,-43,-12336}
+,{-56,-85,-128,99,111,-116,-28030}
+,{105,107,101,101,106,111,31615}
+},{-102,-88,-94,-113,-126,101,73,70} 
+/*fin_reglage*/
+
+},{
+
+/*debut reglage 4 */
+{31,76,9,0},
+{0
+,-14
+,-31
+,-63
+,-83
+,-103
+,-122
+,127
+,1
+,99
+,13
+,112
+,-93
+,-87
+,-72
+,-80
+,-101
+,-112
+,-113
+,-121
+},{
+{22,100663296}
+,{1040629782,204800}
+,{1040834582,221184}
+,{22,0}
+,{-100450282,2}
+,{22,253952}
+,{-100458474,2}
+,{22,0}
+,{-100442090,2}
+,{-100253674,253954}
+,{22,0}
+,{303013910,221184}
+,{20,0}
+,{20,0}
+,{9238,0}
+,{24598,301989888}
+,{22,0}
+,{24598,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+},{
+{-15,-9,-13,-38}
+,{-83,-109,-90,-68}
+,{-99,-101,-67,-61}
+,{-64,-60,-38,-19}
+,{-28,-57,-77,-75}
+,{-66,-55,-51,-68}
+},{
+{31,76,9,0,0,-35,-4643}
+,{-55,-77,-69,-55,-44,-43,-12336}
+,{-56,-85,-128,99,111,-116,-28030}
+,{105,107,101,101,106,111,31615}
+},{-102,-88,-94,-113,-126,101,73,70} 
+/*fin_reglage*/
+
+},{
+
+/*debut reglage 5 */
+{31,76,9,0},
+{0
+,-14
+,-31
+,-63
+,-83
+,-103
+,-122
+,127
+,1
+,97
+,14
+,-80
+,-93
+,-87
+,-72
+,-80
+,-101
+,-112
+,-113
+,-121
+},{
+{22,100663296}
+,{1040629782,204800}
+,{1040834582,221184}
+,{22,0}
+,{-100450282,2}
+,{22,253952}
+,{-100458474,2}
+,{22,0}
+,{-100442090,2}
+,{-100253674,253954}
+,{22,0}
+,{303013910,221184}
+,{20,0}
+,{20,0}
+,{9238,0}
+,{24598,301989888}
+,{22,0}
+,{24598,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+,{0,0}
+},{
+{-15,-9,-13,-38}
+,{-83,-109,-90,-68}
+,{-99,-101,-67,-61}
+,{-64,-60,-38,-19}
+,{-28,-57,-77,-75}
+,{-66,-55,-51,-68}
+},{
+{31,76,9,0,0,-35,-4643}
+,{-55,-77,-69,-55,-44,-43,-12336}
+,{-56,-85,-128,99,111,-116,-28030}
+,{105,107,101,101,106,111,31615}
+},{-102,-88,-94,-113,-126,101,73,70} 
+/*fin_reglage*/
+
+},{0
+
+/*debut reglage 6 */
+/*fin_reglage*/
+
+},{0
+
+/*debut reglage 7 */
+/*fin_reglage*/
+
+} };
+
+/* ------------------------------------   corps  des fonctions	 ------------------------------ */
+/* -------------------------------------------------------------------------------------------- */
+
+
+
+unsigned long	val_long(char x)
+{
+unsigned long a,xl;
+a=x-2;	if(x<3)  xl=x;	else	xl=((a&1) + 2)<<(a>>1);
+return(xl);
+}
+
+
+double	val_double(char x)
+{
+unsigned long a,xl;
+if(x<0) x=-x;	a=x;	if(!a)  xl=0;	else	xl=((a&1) + 2)<<(a>>1);
+if(x>0)	return(1e-4*(double)xl);	else	return(-1e-4*(double)xl);
+}
+
+int	new_val_dac(int a,char  code)
+{
+if(code&0x80)	a=(code&0x7f) <<5 ;
+else	{
+	if(code&0x40)	a+=code&0x3f;	
+	else		a-=code&0x3f;	
+	}
+return(a);
+}
+
+
+
+
+int	calcul_somme_block(block_type_modele* blk,int longueur)
+{
+int i,so=0;;
+for(i=0;i<(longueur/4-4);i++)  so^=(int)blk->mot[i];
+/* somme sur tous les mots internes	: on exclus le dbut, les codes et la fin	*/
+return((so^(so>>16))&0xffff);
+}
+
+
+
+
+void  valide_block(block_type_modele* blk,int type,int block_num)
+{
+int somme,longueur;
+def_long_block
+longueur=long_block[type];
+/*printf("valide block adresse %x  type %d  numblock %d  longueur=%d \n" */
+/* 		,(unsigned)blk,type,block_num,longueur);*/
+blk->debut		=	debut_block_mesure;
+blk->code2		=	(((long)block_num) & 0xffffff ) | ( (((long)type)<<24)&0xff000000 );
+
+blk->mot[longueur/4-4]  =	fin_block_mesure;
+somme=calcul_somme_block(blk,longueur);
+blk->code1		=	(((long)longueur)<<16)	|	somme;
+}
+
+
+/* Quand on est sur une machine swappee, on ne cherche pas a verifier */
+/* le checksum, puisqu'on a modifie les blocs, sans swapper par exemple */
+/* les chars des noms de bolometres et des chaines GPS... */
+#ifdef __alpha
+#define SWAP
+#endif
+#if defined(Linux)  || defined(linux)
+#define SWAP
+#endif
+
+int  verifie_block(block_type_modele* blk)
+{
+int type,lg,som;
+def_long_block
+if(blk->debut != debut_block_mesure)					return(block_debut_erreur);
+type=type_block(blk);		if( (type<0) ||(type>=nb_type_blocks) )	return(block_type_inconnu);	
+lg=longueur_block(blk);		if( lg != long_block[type] )		return(block_longueur_erreur);	
+if( blk->mot[(lg/4)-4]  !=	fin_block_mesure)			return(block_fin_erreur);	
+#ifndef SWAP
+som=calcul_somme_block(blk,lg); if( som!= somme_block(blk))		return(block_somme_erreur);
+#endif
+return(block_correct);
+}
+
+
+int  verifie_block_printf(block_type_modele* blk)
+{
+int type,lg,som;
+def_long_block
+def_nom_block
+if(blk->debut != debut_block_mesure)
+	{
+	printf(" erreur dans le code debut de block	 \n");
+	return(block_debut_erreur);
+	}	
+
+type=type_block(blk);
+if( (type<0) || (type>nb_type_blocks) )	
+	{
+	printf(" block de type %d  inconnu\n",type);
+	return(block_type_inconnu);
+	}
+
+lg=longueur_block(blk);
+if( lg!=long_block[type] )	
+	{
+	printf(" block type %s  erreur de longueur (nominal=%d , dans le block=%d \n"
+			,nom_block[type],long_block[type],lg);
+	return(block_longueur_erreur);
+	}
+
+som=calcul_somme_block(blk,lg);
+if( som!=somme_block(blk) )	
+	{
+	printf(" block type %s   :  erreur de somme (calculee=%d , dans le block=%d \n"
+			,nom_block[type],som,somme_block(blk) );
+	return(block_somme_erreur);
+	}
+	
+if(blk->mot[(lg/4)-4]	!= fin_block_mesure)	
+	{
+	printf(" block type %s  erreur de code fin de block : trouve %x au lieu de %x \n"
+			,nom_block[type],(int)blk->mot[(lg/4)-4],fin_block_mesure);
+	return(block_fin_erreur);
+	}
+
+return(block_correct);
+}
+
+
+
+
+
+
+
Index: trunk/Poubelle/archTOI.old/archeops.h
===================================================================
--- trunk/Poubelle/archTOI.old/archeops.h	(revision 315)
+++ trunk/Poubelle/archTOI.old/archeops.h	(revision 315)
@@ -0,0 +1,910 @@
+
+/*======================================================================*/
+/*                                                                      */
+/* 		 archeops.h  :	structure de données            	*/
+/*                                                                      */
+/*======================================================================*/
+
+#define		_archeops
+#define		version_num		24
+
+
+/*======================================================================*/
+/*                                                                      */
+/* 			historique des modifications            	*/
+/*                                                                      */
+/*                                                                      */
+/*  VERSION 24:                                                         */
+/*                                                                      */
+/*	- utilise le fichier archeops.c					*/
+/*	- nb_max_bolo=24  avec nb_bolo_util=18				*/
+/*	- change la structure du block dilution				*/
+/*									*/
+/*									*/
+/*									*/
+/*									*/
+/*======================================================================*/
+
+
+/*======================================================================*/
+/*  ---------------  parametres generaux de definition   -------------  */
+/*======================================================================*/
+
+#ifndef int4
+#ifdef __alpha
+#define int4 int
+#undef programme
+#else
+#define int4 long
+#endif
+#endif
+
+#ifdef	_planck
+#define	_archeops
+#define _trapani
+#define _sans_transputer
+#endif
+
+#ifdef	_archeops
+/*#define _test_diabolo	 relecture des blocks fabriques avec diabolo	*/
+#define _trapani		/*  configuration  prevue pour Trapani	*/
+/*#define _kiruna		  block standard prevu pour kiruna	*/ 
+#endif
+
+
+
+/*======================================================================*/
+/*  --------------	valeurs des parametres dans	-------------   */
+/*  --------------	les différentes configurations	-------------   */
+/*======================================================================*/
+/*									*/
+/*  configuration pour Trapani : 3 bebos  /  12 bolos			*/
+/*									*/
+/*  bebo1 :   voies  1  à  6	-->  bolo  1 a  6			*/
+/*  bebo2 :   voies  9  à  14	-->  bolo  7 à 12			*/
+/*									*/
+/*  bebo6 :								*/
+/*  	voies  41 42 43 44	=  carte simplifiee avec AMP01		*/
+/*  	voies  45 et 46		= chauffage pour regulation		*/    
+/*	on ecrira plus tard le stockage des donnees simplifiees		*/
+/*									*/
+/*									*/
+/*======================================================================*/
+
+/*	nb_per_block	doit etre divisible par 2						*/
+/*	nb_max_bolo	doit etre divisible par 2 pour archeops   (impair pour diabolo ?? )	*/
+/*	nb_bolo_util	doit etre divisible par 2 pour archeops   (impair pour diabolo ?? )	*/
+
+
+#ifdef	_trapani
+#define nb_max_bolo 		24	/*  nombre maxi de bolos 				*/
+#define nb_bolo_util 		18	/*  nombre de bolos réellement transmis			*/
+#define	nb_per_block		36	/*  nombre de periodes entieres dans un block		*/
+#define	nb_max_mes_per		88	/*  nb de points maxi dans une periode complete		*/
+#define	nb_photo_diodes		46	/*  nb de canaux de mesure du senseur stellaire		*/
+#endif
+
+#ifdef	_kiruna
+#define nb_max_bolo 		36	/*  nombre maxi de bolos 				*/
+#define nb_bolo_util 		32	/*  nombre de bolos réellement transmis			*/
+#define	nb_per_block		36	/*  nombre de periodes entieres dans un block		*/
+#define	nb_max_mes_per		88	/*  nb de points maxi dans une periode complete		*/
+#define	nb_photo_diodes		46	/*  nb de canaux de mesure du senseur stellaire		*/
+#endif
+
+
+#ifdef	_diabolo
+#define nb_max_bolo 		9	/*  nombre maxi de bolos 				*/
+#define nb_bolo_util 		9	/*  nombre de bolos réellement transmis			*/
+#define	nb_per_block		20	/*  nombre de periodes entieres dans un block		*/
+#define	nb_max_mes_per		128	/*  nb de points maxi dans une periode complete		*/
+#define	nb_photo_diodes		0	/*  nb de canaux de mesure du senseur stellaire		*/
+#endif
+
+#ifdef	_test_diabolo
+#define nb_max_bolo 		9	/*  nombre maxi de bolos 				*/
+#define nb_bolo_util 		9	/*  nombre de bolos réellement transmis			*/
+#define	nb_per_block		20	/*  nombre de periodes entieres dans un block		*/
+#define	nb_max_mes_per		128	/*  nb de points maxi dans une periode complete		*/
+#define	nb_photo_diodes		0	/*  nb de canaux de mesure du senseur stellaire		*/
+#endif
+
+
+#ifdef	_sans_transputer
+#define nb_byte_mot		5	/*  nombre d'octets dans un mot d'acquisition planck	*/
+#else
+#define nb_byte_mot		8	/*  nombre d'octets dans un mot d'acquisition archeops	*/
+#endif
+
+#define nb_sync			6	/*  nombre de signaux de synchro			*/
+#define	nb_element_catalog	256	/* nombre d'éléments catalog par reponse enregistreur	*/
+
+
+#ifdef	transmet_data_brute
+#define		taille_maxi_block_archeops	sizeof(block_type_data_brute)
+#else					/* 	le plus gros des différents blocks de télémesure*/
+#define		taille_maxi_block_archeops	sizeof(block_type_bolo)
+#endif
+
+#define		nombre_de_regul		4
+#define		nombre_de_voies		6
+#define 	nb_type_blocks		20	/*  nombre de type de blocks (multiple de 4)	*/
+
+
+/*======================================================================*/
+/*  -------     codes  de  controle  pour  la  transmission    -----    */
+/*=======================   télécommande      ==========================*/
+/*======================================================================*/
+
+
+/*   --------------   codes de reconnaissance des paquets de télécommande	--------------   */   
+
+#define		debut_telecommande		0x23456789
+#define		fin_telecommande		0x98765432
+
+/*   ------------ codes de direction des commandes envoyées a l'EPLD Archeops	--------------   */   
+
+#define 	tc_dir_transputer		1
+#define 	tc_dir_reset_epld		3
+
+/*  -------------  codes  des  prefix des  telecommandes traités le transputer	--------------   */
+
+#define		tc_horloge			255	/* (-1)	*/
+#define		tc_cadence1			128
+#define		tc_cadence2			129
+#define		tc_cadence3			130
+#define		tc_regul			251	/* (-5)	*/
+#define		tc_switch_dil			250
+#define		tc_dac_dil			249
+
+/*======================================================================*/
+/*	telecommande reduite  sur 18 bit				*/
+/*======================================================================*/
+
+/*______________________________________________________________________________________________*/
+/*	1er mot	:	code de debut de telecommande reduite					*/
+#define		tc_reduite			248	
+/*______________________________________________________________________________________________*/
+/*	2eme mot:	4bit:	16 codes  de direction  tc2					*/
+enum{tc2_reset_epld,tc2_bolo_dacV,tc2_bolo_dacI,tc2_bolo_dacT
+	,tc2_bolo_dacL,tc2_bolo_gain,tc2_bolo_voie,tc2_horloge
+	,tc2_regul,tc2_auto_bolo,tc2_auto_dilu,tc2_dilution};			/* 11 codes: reste 5 disponibles*/
+
+
+/*______________________________________________________________________________________________*/
+/*	3eme mot:	6bit:									*/
+
+/*	code2=dac-gain-voie  	:	numero de bolo						*/
+
+/*	code2=tc2_horloge	:								*/
+/*		soit un code defini								*/
+/*		soit le code tc3_vitesse+i avec i=0.. nb_type_block				*/
+enum{tc3_periode,tc3_nb_mesures,tc3_temp_mort,tc3_flag,tc3_vitesse};
+#define	tc3_suite	tc3_vitesse+nb_type_block
+
+
+/*	code2=tc2_regul	:									*/
+
+
+/*	code2=tc2_auto_bolo	:						*/
+
+
+/*	code2=tc2_auto_dilu	:						*/
+/* 	les valeurs des parametres d'auto_dilu ne depassent pas 128 		*/
+
+
+/*	code2=tc2_dilution	:						*/
+
+
+/*______________________________________________________________________________*/
+/*	4eme mot:	8bit:	valeur a ecrire			*/		
+
+
+/*======================================================================*/
+/*  -------     codes  de  controle  pour  la  transmission    -----    */
+/*=========================   télémesure    ============================*/
+/*======================================================================*/
+
+/*   -------   codes de reconnaissance des paquets de télémesure        */   
+
+#define		debut_block_mesure		((int4)0x45627491)
+#define		fin_block_mesure		((int4)0x83260432)
+
+
+
+
+
+/*======================================================================*/
+/*  ------------------------------------------------------------------  */
+/*  ---------  	Les  formats  des  blocks  type   ARCHEOPS   	-------	*/
+/*  ------------------------------------------------------------------  */
+/*======================================================================*/
+
+
+
+/*==============================================================================================*/
+
+/*	Le tableau est lut dans le desordre par le mac en lecture de la carte pci :		*/
+
+/*	Les entiers long sont ecrits tels quels							*/
+/*	Les short sont ecrits permuté 2 a 2 par le tansputer					*/
+/*	Les tables char sont ecrits permuté 4 / 4 par le transputer				*/
+/*	A la lecture dans le mac, tout est bon							*/
+
+
+/*  ---------  	 structures N° 0 :   parametres de mesure des bolometres        -------------	*/
+/*  -----------------------------------------------------------------------------------------	*/
+
+typedef struct	
+	{
+	char		bolo_nom[32];		/*  le nom de chaque bolometre			*/
+	int4		bolo_code_util;		/*  le code d'utilisation du bolo		*/
+	int4		bolo_bebo;		/*  le type d'acquisition:  0 pour MLPA 10 pour BEBODIFF */
+	int4		bolo_num;		/*  l'adresse hard du bolo			*/
+	int4		bolo_gain;		/*  le gain du preampli				*/
+	int4		bolo_capa;		/*  la valeur capa du modulateur		*/
+	int4 		bolo_diviseur;		/*  le diviseur de la compensation		*/
+	int4	  	coef[7];		/*  les coef pour le calcul de la température	*/
+	}
+	param_un_bolo;
+/* code_util des bolos  */
+enum{bolo_hors_service,bolo_normal_transmis,bolo_normal_non_transmis,bolo_thermo_simplifie};
+
+	
+typedef struct		/*  		table des parametres de mesure bolometre 		*/
+			/*	cette table ne change pas (en principe) en cours de mesure	*/
+	{
+	int4		numero_version;			/*  numero de version du header archeops.h	*/
+	int4		n_max_bolo;			/*  nombre maxi de bolos  (divisible par 4)	*/
+	int4		n_per_block;			/*  nombre de periodes entieres dans un block	*/
+	int4		n_max_mes_per;			/*  nb de points maxi dans une periode complete	*/
+
+	int4		nb_bolo;			/*  nombre de bolometres effectivement lut	*/
+	param_un_bolo	bolo[nb_max_bolo];
+	}
+	param_bolo;
+	
+	
+	
+	
+/*	
+	long		bolo_code_util[nb_max_bolo];	
+	char		bolo_nom[nb_max_bolo][32];	
+
+	long		bolo_bebo[nb_max_bolo];		
+	long		bolo_num[nb_max_bolo];		
+	long		bolo_gain[nb_max_bolo];		
+
+	long		bolo_capa[nb_max_bolo];		
+	long 		bolo_diviseur[nb_max_bolo];	
+	
+	long	  	coef[nb_max_bolo][7];		
+
+	long		presence_bebo;			
+	}
+	param_bolo;
+*/
+
+typedef struct				/*	La structure de transfert transputer vers mac	*/  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+
+	param_bolo	param;		/*	les parametres de mesure des bolometres		*/
+
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_param;			
+	
+
+
+
+/*  -------------------   structures N° 1 :   journal de bord        ---------------------	*/
+/*  -----------------------------------------------------------------------------------------	*/
+#define long_page	10
+typedef struct				  
+	{
+	int4		code2;		/* 	code de la ligne du journal			*/
+					/* 	code idem code2 debut de block : 		*/
+					/*  	contient un code de commande			*/
+					/*	et le numero du block lors de la télécommande	*/
+	char		mot[8];		/* 	contenu de la ligne du  journal			*/
+	}
+	ligne_journal;			
+
+
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+
+	ligne_journal	jj[long_page];	/*	block de 10 lignes de journal			*/
+
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_journal;			
+	
+
+/*  ---------   structures N° 2 :  reglage_bolo , regul etc..   --------	*/
+/*  ------------------------------------------------------------------------------------------	*/
+#define	bol_micro_volt(val,gain)	((1e7*(double)val)/(65536.*gain))
+/*  avec  gain = param.bolo_gain[bolo]*gain_ampli(reglage.bolo[bolo])				*/
+		
+
+/* gains 0 .. 15 pour MLPA  ///   gain 16..19  pour BEBO   ///   gain 20..22  pour BEDIF	*/		
+#define	def_gains	double gains_reels[32]={1,2,4,8,10,20,40,80,100,200,400,800,1000,2000,4000,8000,0.5,2.5,10,50,0.93,3.777,18.974};
+		/*			gain bediff    10->9.3    40->37.77     200->189.74		*/
+
+
+/*  les definitions suivantes s'appliquent a une variable de type    reglage.bolo[bol]		*/
+#define		gainbrut(aa)	((char)(((aa).mot1&0x1f)))		
+#define		gain_ampli(aa)	gains_reels[gainbrut(aa)]		
+#define		phase(aa)	((char)(((aa).mot1&0x60)>>5))		
+#define		comm(aa)	((char)(((aa).mot1&0x80)>>7))		
+#define		dac_V(aa)	((int)(((aa).mot1&0xfff00)>>8)	)	
+#define		dac_I(aa)	((int)(((aa).mot1&0xfff00000)>>20))		
+
+#define		voie(aa)	((char)(((aa).mot2&0xff)))		
+#define		dac_T(aa)	((int)(((aa).mot2&0xfff00)>>8))		
+#define		dac_L(aa)	((int)(((aa).mot2&0xfff00000)>>20))		
+
+/*
+#define		bolo_mot1(dacV,dacI,gainbrut,phase,comm)	((gainbrut)&0x1f) | (((phase)&3)<<5) | (((comm)&1)<<7) | (((dacV)&0xfff)<<8) | (((dacI)&0xfff)<<20) 
+#define		bolo_mot2(dacT,dacL,voie)			((voie)&0xff) 	  | (((dacT)&0xfff)<<8) | (((dacL)&0xfff)<<20)
+*/
+
+#define		bolo_mot1(dacV,dacI,gainbrut,phase,comm)	(((long)(gainbrut))&0x1f) | ((((long)(phase))&3)<<5) | ((((long)(comm))&1)<<7) | ((((long)(dacV))&0xfff)<<8) | ((((long)(dacI))&0xfff)<<20) 
+#define		bolo_mot2(dacT,dacL,voie)			(((long)(voie))&0xff) 	  | ((((long)(dacT))&0xfff)<<8) | ((((long)(dacL))&0xfff)<<20)
+
+
+typedef struct	
+	{
+	int4	mot1;		/*  dac1 = mot[11..0]; dac2=mot1[23..12]	*/
+				/*  gain = mot1[27..24]; phase = mot1[31..28];	*/
+	int4	mot2;		/*  dac3 = mot[11..0]; dac4=mot1[23..12]	*/
+				/*  voie pour reglages auto  = mot2[31..24];	*/
+	}
+	reglage_un_bolo;
+
+
+
+#ifdef programme	/***********   structure normale pour le mac   ****************/
+
+typedef struct	
+	{
+	char	periode;
+	char	nb_mesures;
+	char	temp_mort;
+	char	flag;
+	}
+	horloge;
+
+typedef struct
+	{
+	char	mode;			/*   on_off et deglitch				*/
+	char	num_bolo;		/*   numero du bolo utilisé,	*/
+	char	voie_chauf;		/*   la voie de sortie chauffage		*/
+	char	prop;			/*   zero dans prop -> chauffage=0;		*/
+	char	integ;
+	char 	deriv;
+	short	chauffage;		/* 	valeur effective du chauffage		*/	
+	}
+	regul_bolo;			/*  longueur 2 entiers long			*/
+
+typedef struct
+	{
+	char	mode;
+	char	gain;
+	char	courant;
+	char	delai;
+	}
+	auto_bolo;			/*  longueur 1 entiers long			*/
+
+typedef struct
+	{
+	char	vanne;
+	char	helium;
+	char	chauffage;
+	char	piles;
+	char	transmission;
+	char	temps_max_vanne;
+	char	xx7;
+	char	xx8;
+	}
+	auto_dilu;			/*  longueur 1 entiers long		*/
+
+
+
+#else		/***********  structure swappée pour le transputer   ****************/
+
+typedef struct	
+	{
+	char	flag;
+	char	temp_mort;
+	char	nb_mesures;
+	char	periode;
+	}
+	horloge;
+	
+
+typedef struct
+	{
+	char	prop;			/*   zero dans prop -> chauffage=0;		*/
+	char	voie_chauf;		/*   la voie de sortie chauffage		*/
+	char	num_bolo;		/*   numero du bolo utilisé,	*/
+	char	mode;			/*   on_off et deglitch				*/
+	short	chauffage;		/* 	valeur effective du chauffage		*/	
+	char 	deriv;
+	char	integ;
+	}
+	regul_bolo;			/*  longueur 2 entiers long		*/
+
+
+typedef struct
+	{
+	char	delai;
+	char	courant;
+	char	gain;
+	char	mode;
+	}
+	auto_bolo;			/*  longueur 1 entiers long		*/
+
+typedef struct
+	{
+	char	piles;
+	char	chauffage;
+	char	helium;			/* periode de mesure		*/
+	char	vanne;		
+	char	xx8;
+	char	xx7;
+	char	temps_max_vanne;
+	char	transmission;
+	}
+	auto_dilu;			/*  longueur 1 entiers long		*/
+
+
+#endif		/***********   fin des structures swappées       ****************/
+
+enum{regul_stop,regul_chauffage_null,regul_sans_deglitch,regul_avec_deglitch};
+
+#define bit_piles_5V	1
+#define bit_piles_15V	2
+#define bit_piles_auto	4
+
+enum{vanne_rien,vanne_ferme,vanne_ouvre,vanne_auto_pression,vanne_auto_pression_piles,vanne_auto_pression_piles_temps};
+enum{trans_rien,trans_normal,trans_rapide,trans_lent};
+
+
+typedef struct							/*  long en mot de 32 bit   	*/
+	{
+	horloge			horloge;			/*			1	*/
+	char			vitesse[nb_type_blocks];	/*			5	*/
+	reglage_un_bolo		bolo[nb_max_bolo]; 		/*	18 * 2	= 	36	*/
+	auto_bolo		autom[nombre_de_voies];		/*	6  * 1		6	*/								
+	regul_bolo		regul[nombre_de_regul];		/*	4  * 2	=	8	*/									
+	auto_dilu		dilu;				/*			2	*/
+	}
+	reglage_bolo;						/*	total 58		*/
+
+
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	reglage_bolo	reglage;											
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_reglage;			
+	
+/*  ---------------------   structures N° 3 :    etat de la dilution	-----------------------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+/*	int4		data_dil[50];	 data brutes de la dilution				*/
+	int4		switch_dil;
+	int4		ADC_dil[48];	/*	la lecture des 48 ADC de la carte DIL		*/
+	int4		DAC_dil[4];	/*	les 4 dac de la carte dilution			*/
+	int4		DAC_sst[4];	/*	les 4 dac de la carte sst			*/
+	int4		gyro_dil[3][nb_per_block*2];	/* les gyros a supprimer		*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_dilution;			
+
+
+/*      signification des bit lus dans switch_dil	*/
+#define	switch_EVF		0x00000080	/*	contact fin de course vanne fermee	*/
+#define	switch_EVO		0x00000040	/*	contact fin de course vanne ouverte	*/
+
+/* les bit suivants sont envoyés par telecommande et relus dans switch_dil	*/
+#define	switch_helium		0x00200000	/*  13: commande sond niveau helium	*/
+#define switch_pile_par_5	0x00100000	/*  12: mise en parallele des piles pour le 5V	*/
+#define switch_pile_par_15	0x00080000	/*  11: mise en parallele des piles pour le 15V	*/
+#define vanne_EVB		0x00008000	/*  7: commande vanne brooks	*/
+#define vanne_EVO		0x00010000	/*  8: commande vanne EVO	*/
+#define vanne_EVV		0x00020000	/*  9: commande vanne EVV	*/
+#define vanne_EVF		0x00040000	/*  10: commande vanne EVF	*/
+#define chauffage1		0x00004000	/*  6: chauffage 1	*/
+#define chauffage2		0x00002000	/*  6: chauffage 1	*/
+#define chauffage3		0x00001000	/*  6: chauffage 1	*/
+#define chauffage4		0x00000800	/*  6: chauffage 1	*/
+#define chauffage5		0x00000400	/*  6: chauffage 1	*/
+#define chauffage6		0x00000200	/*  6: chauffage 1	*/
+#define chauffage7		0x00000100	/*  0: chauffage 7	*/
+
+/*  position des mesures sur les multiplexeurs		*/
+
+enum{
+/* multiplex11..18:*/	mul11_	,mul12_	,p_haut	,p_memb	,t_h1	,t_h4	,t_h3	,t_h2	
+/* multiplex21..28:*/,	mul21_	,mul22	,p_charb,p_R4	,mul25_	,p_C3	,p_R3	,mul28	
+/* multiplex31..38:*/,	mul31_	,p_C4	,p_air	,t_a3	,t_b4	,t_b1	,t_b2	,t_a2	
+/* multiplex41..48:*/,	t_b3	,d_4He	,RP_He	,mul44	,d_3He	,j_he3	,j_he7	,j_he4	
+/* multiplex51..58:*/,	j_he5	,j_he1	,j_he8	,j_he2	,j_he6	,pirani	,mul57	,mul58	
+/* multiplex61..68:*/,	p_m18B	,p_10B	,p_m18D	,mul64	,p_p18B	,p_10T	,p_Ch	,p_p18D		
+	};
+enum{t_a1,t_a4};	/* en attendant de trouver leurs places	*/
+/* reste libres :  mul  11 - 12 - 21 - 22 - 25 - 28 - 31 - 44 - 57 - 58 - 64	*/
+
+
+
+/*  ---------------------   structures N° 4 :     gps           -------------------------------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+
+	char		gps[80];	/*      les données GPS (une chaine maxi 80 cara)	*/
+
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_gps;			
+	
+
+
+/*  ---------------------   structures N° 5 :   tous les bolos 1 periode     	---------------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	
+	short 		bol_per[nb_max_bolo][nb_max_mes_per];		
+
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_une_periode;			
+
+/*  ----------------   structures N° 6 :  signals de synchro (pour test au sol)	---------------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	char		synchro[nb_sync][nb_per_block*2];	
+
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_synchro_sol;			
+
+/*  ---------------------   structures N° 7 : block de données de pointage sol      -----------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct	  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	char		comment[1024];
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_pointage_sol;			
+
+
+
+/*  -------------   structures N° 8 :   données brutes des bolometres    ----------------------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+					/*	pour chaque bolo, un vecteur 72 points		*/
+	int4		data_bolo[nb_max_bolo][nb_per_block*2];	
+					/*	data D.S.	(en mots de 32 bits)		*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_bolo;			
+
+/*  ---------------------   structures N° 9 :   données des gyroscopes et du magnétometre	*/
+/*  -----------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+					/* chaque gyro: un vecteur tde 72 valeurs		*/
+	int4		gyros[3][nb_per_block*2];
+	int4		magneto[3];	/*	1 bit par echantillonage soit 3*32bit>72	*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_gyro;			
+
+/*  ---------------------   structures N° 10 :   données senseur stellaire	  -----------	*/
+/*  -----------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	int4		sst[nb_per_block*2][18];
+					/* chaque mesure: un paquet de 18 mots de 32 bits	*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_sst;			
+
+/*  ---------------------   structures N° 11 :    rien		          -----------		*/
+/*  -----------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type11;			
+
+/*  ---------------------   structures N° 12 :  data bolo apres compression sur 7 bit	 ------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+					/*  	nombre de mots = nb valeurs/4 +1		*/
+					/*	pour chaque bolo, un vecteur  19 mots		*/
+	int4		data_bolo[nb_bolo_util][ (nb_per_block/2) +1 ];
+
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_bolo_comprime;			
+
+/*  ---------------------   structures N° 13 :    block_type_gyro_comprime	-----------	*/
+/*  -----------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+					/*  	nombre de mots = nb valeurs/4 +1		*/
+	int4		gyro[3][ (nb_per_block/2) +1 ];
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_gyro_comprime;			
+
+/*  ---------------------   structures N° 14 :    block_type_sst_comprime	-----------	*/
+/*  -----------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+					/*	pour chaque diode, un vecteur  11 mots		*/
+	int4		sst[nb_photo_diodes] [(nb_per_block*2/7) +1 ];
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_sst_comprime;			
+
+
+
+/*  ---------------------   structures N° 15 : catalog_flash      -------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+
+typedef struct	  			/*	etat de l'enregistreur				*/
+	{
+	int4		nb_total_catalog;
+	int4		memoire_libre;
+	int4		nb_block_erreur;
+	}status_flash;
+
+typedef struct	  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	
+	int4		commande;	/*	la commande a laquelle ce catalog repond	*/
+	status_flash	status;		/*	etat de l'enregistreur				*/
+	int4		nombre;		/*							*/
+	int4		code[nb_element_catalog];	/* code type et numero			*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_catalog_flash;			
+
+
+/*  ---------------------   structures N° 16 :    cmd_flash		    -----------		*/
+/*  -----------------------------------------------------------------------------------------	*/
+typedef struct				  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	int4		commande;	/*	type de commande a l'enregistreur flash		*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_cmd_flash;			
+
+enum	{flash_catalog_auto,flash_catalog_debut,flash_catalog_fin,flash_catalog_precedent,flash_catalog_suivant
+		,flash_efface_tout1,flash_efface_tout2,flash_efface_tout3
+		,flash_efface_util1,flash_efface_util2,flash_efface_util3};
+
+
+/*  ---------------------   structures N° 17 : block brut de données ctb pour test      -------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct	  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+#ifdef	transmet_data_brute
+	char		data[nb_per_block*nb_max_mes_per*nb_byte_mot];
+#endif
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_data_brute;			
+
+/*  ---------------------   structures N° 18 : block  vide pour l'instant	      -------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct	  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_18;			
+
+/*  ---------------------   structures N° 19 : block  vide pour l'instant	      -------	*/
+/*  -------------------------------------------------------------------------------------------	*/
+typedef struct	  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	int4		fin;		/* 	code de reconnaissance de fin de block		*/
+	}
+	block_type_19;			
+
+
+
+/*  ---------   block  modele  (plus gros que tous les autres pour reservation memoire)   ----  */
+/*  -----------------------------------------------------------------------------------------	*/
+
+typedef struct				/*	La structure de transfert transputer vers mac	*/  
+	{
+	int4		debut;		/*	code de reconnaissance de debut de block	*/
+	int4		code1;		/*	code1 du block					*/
+	int4		code2;		/*	code2 du block					*/
+	int4		mot[(taille_maxi_block_archeops)/4];
+	int4		fin;		/* code de reconnaissance de fin de block		*/
+	}
+	block_type_modele;			
+
+
+
+
+
+/*==============================================================================================*/
+/*==============================================================================================*/
+/*  --------------  définitions permettant de travailler sur les blocks Archeops   -----------  */
+/*==============================================================================================*/
+/*==============================================================================================*/
+
+
+
+enum	{block_param,block_journal,block_reglage,block_dilution,
+	block_gps,block_une_periode,block_synchro_sol,block_pointage_sol,
+	block_bolo,block_gyro,block_sst,block_11,
+	block_bolo_comprime,block_gyro_comprime,block_sst_comprime,block_catalog_flash,
+	block_cmd_flash,block_data_brute,block_18,block_19};
+
+
+#define	def_nom_block	char nom_block[nb_type_blocks][32]={"block_param","block_journal","block_reglage","block_dilution",\
+					"block_gps","block_une_periode","block_synchro_sol","block_pointage_sol",\
+					"block_bolo","block_gyro","block_sst","block_11",\
+					"block_bolo_comprime","block_gyro_comprime","block_sst_comprime","block_catalog_flash",\
+					"block_cmd_flash","block_data_brute","",""};
+
+
+#define	def_long_block	int long_block[nb_type_blocks]={sizeof(block_type_param),sizeof(block_type_journal),sizeof(block_type_reglage),sizeof(block_type_dilution),\
+					sizeof(block_type_gps),sizeof(block_type_une_periode),sizeof(block_type_synchro_sol),sizeof(block_type_pointage_sol),\
+					sizeof(block_type_bolo),sizeof(block_type_gyro),sizeof(block_type_sst),sizeof(block_type11),\
+					sizeof(block_type_bolo_comprime),sizeof(block_type_gyro_comprime),sizeof(block_type_sst_comprime),sizeof(block_type_catalog_flash),\
+					sizeof(block_type_cmd_flash),sizeof(block_type_data_brute),sizeof(block_type_18),sizeof(block_type_19)};
+
+
+
+
+
+/*   le code du block contient  8  bit de type							*/
+/*				24 bit pour le numero du block(horloge locale)			*/
+/*				12 bit pour la longueur du block  (en octet)			*/
+/*				16 bit pour la somme de test de la validité du block		*/
+
+/*  les define suivants doivent etre utilisés pour tester le type des blocks et les verifier	*/
+
+
+#define longueur_block(_bk)	( (int) ((_bk)->code1>>16) 	& 0xffff )	
+#define somme_block(_bk)	( (int)  (_bk)->code1		& 0xffff )
+
+#define type_block(_bk)		( (int) ((_bk)->code2>>24)	& 0xff )
+#define numero_block(_bk)	( (int)  (_bk)->code2		& 0xffffff )
+
+/* ce define cree le mot de controle de somme des blocks et de les verifier a la reception	*/
+
+
+/*==============================================================================================*/
+/*==============================================================================================*/
+/*  -----------------  fonctions utilitaires de gestion des blocks Archeops   ----------------  */
+/*==============================================================================================*/
+/*==============================================================================================*/
+
+
+/* -------------------------------------------------------------------------------------------- */
+/* les fonctions suivantes sont des utilitaires permettant la gestion des blocks archeops	*/
+/* il faut inclure une seule fois le header archeops.h précéde de :				*/
+/*			 #define utilitaires_de_block_archeops 					*/
+/* -------------------------------------------------------------------------------------------- */
+
+
+/* ----------------------------   prototypes des fonctions	 ------------------------------ */
+/* -------------------------------------------------------------------------------------------- */
+
+
+/* 	cette fonction calcule le code de somme pour le controle de parité des blocks		*/
+
+int	calcul_somme_block(block_type_modele* blk,int longueur);
+
+
+
+
+
+/* 	cette fonction est a apeller lors de la création d'un block apres l'avoir rempli	*/
+/*	elle permet de creer tous les mots de controle du block					*/
+
+void	valide_block(block_type_modele* blk,int type,int block_num);
+
+
+
+/* 	cette fonction est a apeller pour vérifier la validité d'un block			*/
+/*	elle retourne 0 si le block est correct et sinon, un code d'erreur			*/
+/*	la seconde fonction sort les erreurs a l'ecran						*/
+
+int	verifie_block(block_type_modele* blk);
+int	verifie_block_printf(block_type_modele* blk);
+
+enum	{block_correct,block_type_inconnu,block_longueur_erreur,block_somme_erreur
+		,block_debut_erreur,block_fin_erreur};
+
+/* 	cette fonction transforme un char (sur 8 bit) en double avec une echelle logarythmique	*/
+/*	elle est en particulier utilisée pour calculer les coef de la regul			*/
+
+double	val_double(char x);
+
+/* 	cette fonction transforme un char (sur 8 bit) en entier long (echelle logarythmique)	*/
+/*	elle est en particulier utilisée pour fixer le courant sur les bolometres		*/
+
+unsigned long	val_long(char x);
+
+int	new_val_dac(int a,char  code); 
+
+
+
Index: trunk/Poubelle/archTOI.old/archeopsfile.cc
===================================================================
--- trunk/Poubelle/archTOI.old/archeopsfile.cc	(revision 310)
+++ trunk/Poubelle/archTOI.old/archeopsfile.cc	(revision 315)
@@ -1,6 +1,12 @@
 #define utilitaires_de_block_archeops
 #include "archeopsfile.h"
+extern "C" {
 #include "compress.h"
+}
 #include <iostream.h>
+
+// BlockSet is the current "state" of the file reader automate.
+// It contains the last blocks of each kind, the current block and
+// the look-ahead block.
 
 class BlockSet {
@@ -27,4 +33,9 @@
   block_type_gyro_comprime* lastGyroComp;
   block_type_sst_comprime*  lastSSTComp;
+    
+  block_type_modele         curBlock;
+  block_type_modele         peekBlock;
+  
+  SSTHandler sstHandler;
 };
 
@@ -45,4 +56,7 @@
   lastGyroComp   = NULL;
   lastSSTComp    = NULL;
+  
+  memset(&curBlock,0,sizeof(block_type_modele));
+  memset(&peekBlock,0,sizeof(block_type_modele));
 }
 
@@ -65,5 +79,7 @@
 }
 
-BlockSet::BlockSet(BlockSet const& x) {
+BlockSet::BlockSet(BlockSet const& x) 
+: sstHandler(x.sstHandler)
+{
   lastParam      = NULL;
   lastJournal    = NULL;
@@ -81,4 +97,5 @@
   lastGyroComp   = NULL;
   lastSSTComp    = NULL;
+  
   if (x.lastParam) {
     lastParam = new block_type_param;
@@ -141,4 +158,8 @@
     *lastSSTComp = *x.lastSSTComp;
   }
+  
+  memcpy(&curBlock,&x.curBlock,sizeof(block_type_modele));
+  memcpy(&peekBlock,&x.peekBlock,sizeof(block_type_modele));
+
 }
 
@@ -232,5 +253,6 @@
   fseek(f,0,SEEK_END);
   fLen = ftell(f);
-  curPos = 0;
+  curPos = -1;
+  peekPos = -1;
   curKind = -1;
   curRawKind = -1;
@@ -256,8 +278,9 @@
   }
 
-  curBlock   = x.curBlock;
+  //curBlock   = x.curBlock;
   curKind    = x.curKind;
   curRawKind = x.curRawKind;
   curPos     = x.curPos;
+  peekPos    = x.peekPos;
   fLen       = x.fLen;
   fn         = x.fn;
@@ -275,4 +298,7 @@
   delete blockSet;
   blockSet = new BlockSet(*oldFile.blockSet);
+  //curBlock = oldFile.curBlock;
+  //peekBlock = oldFile.peekBlock;
+  peekPos = 0;
   setUTCOffset(oldFile.utcOffset);
 }
@@ -282,15 +308,28 @@
 
 bool ArcheopsFile::nextBlock() {
-  //if (curPos>0) saveCurBlock();
-  //if (curPos<0) curPos = 0;
-  if (curPos+12 > fLen) return false;
-  fseek(f,curPos,SEEK_SET);
-  size_t read = fread(&curBlock,1,sizeof(curBlock),f);
-  if (read < longueur_block(&curBlock)) return false;
-  if (verifie_block(&curBlock) != block_correct) {
+  // si pas de peek, alors en lire un pour commencer...
+  if (peekPos<0) {
+    peekPos=0; if (!nextBlock()) return false;
+  }
+  block_type_modele* curBlock=currentBlock();
+  block_type_modele* peekBlock=aheadBlock();
+  
+  memcpy(curBlock, peekBlock, sizeof(block_type_modele));
+  
+  if (peekPos+12 > fLen) return false;
+  fseek(f,peekPos,SEEK_SET);
+  size_t read = fread(peekBlock,1,sizeof(block_type_modele),f);
+  swapEntete(peekBlock);
+  if (read < longueur_block(peekBlock)) return false;
+  swapContent(peekBlock);
+  if (verifie_block(peekBlock) != block_correct) {
   printf("block invalide\n"); throw ArchExc("invalid block");
   }
-  curRawKind = curKind = type_block(&curBlock);
-  curPos += longueur_block(&curBlock);
+  peekPos += longueur_block(peekBlock);
+  if (curPos < 0) {
+    curPos = 0; return true;
+  }
+  curPos += longueur_block(curBlock);
+  curRawKind = curKind = type_block(curBlock);
   //printf("block %d  :  %s \n",numero_block(&curBlock),nom_block[curKind]);
   postProcessBlock();
@@ -316,5 +355,5 @@
 
 int  ArcheopsFile::blockNum() {
-  return numero_block(&curBlock);
+  return numero_block(currentBlock());
 }
 
@@ -348,7 +387,18 @@
 
 block_type_modele*  ArcheopsFile::currentBlock() {
-  if (curPos<0) return NULL;
-  return &curBlock;
-}
+  //if (curPos<0) return NULL;
+  return &blockSet->curBlock;
+}
+
+block_type_modele*  ArcheopsFile::aheadBlock() {
+  //if (peekPos<0) return NULL;
+  return &blockSet->peekBlock;
+}
+
+bool ArcheopsFile::sameBlockNumAhead() {
+  if (curPos<0) return false;
+  return (numero_block(&blockSet->curBlock) == numero_block(&blockSet->peekBlock));
+}
+
 
 block_type_param* ArcheopsFile::lastParam() {
@@ -401,7 +451,7 @@
   switch (curKind) {
      case block_bolo_comprime: {
-       blockSet->setRawBloc(curBlock);
+       blockSet->setRawBloc(blockSet->curBlock);
        block_type_bolo blk2;
-       block_type_bolo_comprime* blk = (block_type_bolo_comprime*) &curBlock;
+       block_type_bolo_comprime* blk = (block_type_bolo_comprime*) &blockSet->curBlock;
        for(int j=0;j<nb_bolo_util;j++)	
 		{
@@ -409,17 +459,23 @@
 		}
        valide_block((block_type_modele*)&blk2,block_bolo,numero_block(blk));	
-       memcpy(&curBlock,&blk2,sizeof(blk2));
+       memcpy(&blockSet->curBlock,&blk2,sizeof(blk2));
        curKind = block_bolo;
        break;
      }
+     case block_sst_comprime: {  // $CHECK$ TBD
+     }
+     case block_sst : {
+       blockSet->sstHandler.ProcessBlock((block_type_sst*)&blockSet->curBlock);
+     }
   }
 }
 
 void ArcheopsFile::saveCurBlock() {
-  blockSet->setBloc(curBlock);
+  blockSet->setBloc(blockSet->curBlock);
 }
 
 void ArcheopsFile::pushMark() {    // push current file position, and "last" blocks`
   fposStack.push(curPos);
+  fposStack.push(peekPos);
   blockStack.push(new BlockSet(*blockSet));
 }
@@ -429,9 +485,78 @@
     delete blockSet;
     blockSet = blockStack.top();
+    blockStack.pop();
+    peekPos = fposStack.top();
+    fposStack.pop();
     curPos = fposStack.top();
-    blockStack.pop();
     fposStack.pop();
   }
 }
+
+typedef unsigned int4 uint_4;
+typedef unsigned short uint_2;
+
+static inline void bswap4(void* p)
+{
+  uint_4 tmp = *(uint_4*)p;
+  *(uint_4*)p = ((tmp >> 24) & 0x000000FF) | 
+                ((tmp >> 8)  & 0x0000FF00) |
+                ((tmp & 0x0000FF00) << 8)  |
+                ((tmp & 0x000000FF) << 24);
+}
+
+static inline void bswap2(void* p)
+{
+  uint_2 tmp = *(uint_2*)p;
+  *(uint_2*)p = ((tmp >> 8) & 0x00FF) | 
+                ((tmp & 0x00FF) << 8);
+}
+
+#ifdef __DECCXX
+#define SWAP
+#endif
+#if defined(Linux)  || defined(linux)
+#define SWAP
+#endif
+
+void ArcheopsFile::swapEntete(block_type_modele* blk) {
+#ifdef SWAP
+  bswap4(&(blk->debut));
+  bswap4(&(blk->code1));
+  bswap4(&(blk->code2));
+  long lg = longueur_block(blk);
+  bswap4(((char*)blk) + lg - 4);
+#endif
+}
+
+void ArcheopsFile::swapContent(block_type_modele* blk) {
+#ifdef SWAP
+  int typ = type_block(blk);
+
+  if (typ == block_gps) return; // char only, no swap
+  if (typ == block_une_periode) { // une_periode, des shorts
+    block_type_une_periode* b = (block_type_une_periode*) blk;
+    for (int i=0; i<nb_max_bolo; i++)
+      for (int j=0; j<nb_max_mes_per; j++)
+	bswap2(&b->bol_per[i][j]);
+    return;
+  }
+
+  for (int i=0; i<longueur_block(blk)/4-4; i++)
+    bswap4(blk->mot + i);
+  // On deswappe ce qui ne devait pas etre swappe...
+  switch (typ) {
+  case block_param: {
+    block_type_param* b = (block_type_param*) blk;
+    for (int i=0; i<nb_max_bolo; i++)
+      for (int j=0; j<8; j++)
+	bswap4(&b->param.bolo[i].bolo_nom[4*j]);
+  }
+  
+  }
+#endif
+}
+  
+  
+
 
 static int mlen[] = {31,28,31,30,31,30,31,31,30,31,30,31};
@@ -474,4 +599,15 @@
 }
 
+int ArcheopsFile::getBoloBlockNum() {
+  if (!lastBolo()) return -1;
+  return numero_block(lastBolo());
+}
+
+int ArcheopsFile::getSSTBlockNum() {
+  if (!lastSST()) return -1;
+  return numero_block(lastSST());
+}
+
+
 // GPS
 // $GPGGA,hhmmss.ss,ddmm.mmmm,n,dddmm.mmmm,e,q,ss,y.y,a.a,z,
@@ -484,7 +620,7 @@
 
 double ArcheopsFile::getGPSUTC() {  // en secondes depuis minuit UTC jour courant
-  if (!lastGPS()) return -1;
+  if (!lastGPS()) return -9.e99;
   char* p = lastGPS()->gps;
-  if (strncmp(p, "$GPGGA,", 7)) return -1;
+  if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
   p += 7;
   double t;
@@ -506,11 +642,11 @@
 
 double ArcheopsFile::getGPSLat() {  // degres, +  = NORD
-  if (!lastGPS()) return 99999;
+  if (!lastGPS()) return -9.e99;
   char* p = lastGPS()->gps;
-  if (strncmp(p, "$GPGGA,", 7)) return 99999;
+  if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
   char* fence = p+80;
   p += 7;
   while (*p != ',' && p<fence) p++;
-  if (*p != ',') return 99999; 
+  if (*p != ',') return -9.e99; 
   p++;
   double t;
@@ -519,5 +655,5 @@
   t = d + t/60;
   while (*p != ',' && p<fence) p++;
-  if (*p != ',') return 99999; 
+  if (*p != ',') return -9.e99; 
   p++;
   if (*p == 'S') t = -t;
@@ -526,12 +662,12 @@
 
 double ArcheopsFile::getGPSLong() { // degres, +  = EST
-  if (!lastGPS()) return -1;
+  if (!lastGPS()) return -9.e99;
   char* p = lastGPS()->gps;
-  if (strncmp(p, "$GPGGA,", 7)) return 99999;
+  if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
   char* fence = p+80;
   p += 7;
   for (int i=0; i<3; i++) {
     while (*p != ',' && p<fence) p++;
-    if (*p != ',') return 99999; 
+    if (*p != ',') return -9.e99; 
     p++;
   }
@@ -541,5 +677,5 @@
   t = d + t/60;
   while (*p != ',' && p<fence) p++;
-  if (*p != ',') return 99999; 
+  if (*p != ',') return -9.e99; 
   p++;
   if (*p == 'W') t = -t;
@@ -570,11 +706,21 @@
 
 double ArcheopsFile::getMuVBolo(int ibolo, int imesure) { // microvolts, filtre avec filtre carre
-  double y = (getRawBolo(ibolo, imesure-1) + getRawBolo(ibolo, imesure))/2.;
+  double y = (getRawBolo(ibolo, imesure-1) - getRawBolo(ibolo, imesure))/2.;
+  if (imesure%2) y=-y;
   block_type_reglage* reglage = lastReglage();
-  return ((1e5*y)/(65536.*gain(reglage->reglage.bolo[ibolo])));
+  return ((1e5*y)/(65536.*gain_ampli(reglage->reglage.bolo[ibolo])));
 }
 
 
 // SST, gyros...
+
+void ArcheopsFile::needSSTProcessMask(int mask) {
+  blockSet->sstHandler.NeedProcess(mask);
+}
+
+
+long ArcheopsFile::getSSTSignal(int idiode, int imesure) {
+  return blockSet->sstHandler.getSignal(imesure, idiode);
+}
 // $CHECK$ TBD
 
Index: trunk/Poubelle/archTOI.old/archeopsfile.h
===================================================================
--- trunk/Poubelle/archTOI.old/archeopsfile.h	(revision 310)
+++ trunk/Poubelle/archTOI.old/archeopsfile.h	(revision 315)
@@ -6,10 +6,14 @@
 #include <stack>
 
+
+#ifndef nb_max_bolo
 #define _archeops		//  Acquisition Archeops (avec transputer) 
 #define programme
-
 extern "C" {
 #include "archeops.h"
 }
+#endif
+
+#include "ssthandler.h"
 
 enum {
@@ -42,5 +46,5 @@
 class BlockSet;
 
-class ArchExc : public exception {
+class ArchExc {
 public:
   ArchExc(string s) : msg(s) {}
@@ -75,8 +79,10 @@
   void pushMark();    // push current file position, and "last" blocks
   void popMark();     // pops last file position and "last" blocks
-  
+    
   void grabLastBlocs(ArcheopsFile const& oldFile);
   
+  block_type_modele*  aheadBlock();   // internal buffer
   block_type_modele*  currentBlock(); // internal buffer
+  bool sameBlockNumAhead();
   
   block_type_param*         lastParam();  // saved blocks, including current
@@ -101,4 +107,5 @@
   // On travaille en MJD = JD - 2450000.0, = 9 octobre 1995 midi UTC
   // 1er juillet 1999 minuit UTC = JD 2451360.5,   MJD 1360.5 
+  // Ces fonctions travaillent sur le dernier bloc GPS 
   int getGPSBlockNum();
   double getGPSUTC();  // en secondes depuis minuit UTC
@@ -106,10 +113,14 @@
   double getGPSLat();  // degres, +  = NORD
   double getGPSLong(); // degres, +  = EST
-  
+    
   // Bolo
+  int getBoloBlockNum();
   long getRawBolo(int ibolo, int imesure);   // donnee brute, avec seulement soustraction offset
   double getMuVBolo(int ibolo, int imesure); // microvolts, filtre avec filtre carre
   
   // SST, gyros, etc
+  int getSSTBlockNum();
+  void needSSTProcessMask(int mask);
+  long getSSTSignal(int iDiode, int imesure);
   
   double getAzimut(int imesure);
@@ -119,6 +130,5 @@
   double getAlpha(int imesure);
   double getDelta(int imesure);
-  
-  
+    
 protected:
   BlockSet*                 blockSet;
@@ -128,11 +138,14 @@
   void saveCurBlock();
   void postProcessBlock();
+
+  void swapEntete(block_type_modele* blk);
+  void swapContent(block_type_modele* blk);
   
   void computeMJD(string const& fname);
-  
-  block_type_modele         curBlock;
+    
   int                       curKind;
   int                       curRawKind;
-  size_t                    curPos;
+  long                      curPos;
+  long                      peekPos;
   size_t                    fLen;
   FILE* f;
Index: trunk/Poubelle/archTOI.old/compress.h
===================================================================
--- trunk/Poubelle/archTOI.old/compress.h	(revision 310)
+++ trunk/Poubelle/archTOI.old/compress.h	(revision 315)
@@ -6,4 +6,11 @@
 /************************************************************************/
 
+#ifndef int4
+#ifdef __alpha
+#define int4 int
+#else
+#define int4 long
+#endif
+#endif
 
 
@@ -17,6 +24,6 @@
 /*	pour 	n = 72	  en sortie	19 mots = 76 octets		*/
 
-void compress_7_1(long* in,long*out,int n,int pasin);
-void decompress_7_1(long* in,long*out,int n);
+void compress_7_1(int4* in,int4*out,int n,int pasin);
+void decompress_7_1(int4* in,int4*out,int n);
 
 
@@ -29,6 +36,6 @@
 /*	pour 	n = 72	  en sortie	11 mots = 44 octets		*/
 
-void compress_4_1(long* in,long*out,int n,int pasin);
-void decompress_4_1(long* in,long*out,int n);
+void compress_4_1(int4* in,int4*out,int n,int pasin);
+void decompress_4_1(int4* in,int4*out,int n);
 
 
@@ -42,6 +49,6 @@
 
 
-void compress_3_1(long* in,long*out,int n,int pasin);
-void decompress_3_1(long* in,long*out,int n);
+void compress_3_1(int4* in,int4*out,int n,int pasin);
+void decompress_3_1(int4* in,int4*out,int n);
 
 /************************************************************************/
@@ -63,6 +70,6 @@
 
 
-void compress_7_2(long* in,long*out,int n,int pasin);
-void decompress_7_2(long* in,long*out,int n);
+void compress_7_2(int4* in,int4*out,int n,int pasin);
+void decompress_7_2(int4* in,int4*out,int n);
 
 
@@ -78,6 +85,6 @@
 
 
-void compress_4_2(long* in,long*out,int n,int pasin);
-void decompress_4_2(long* in,long*out,int n);
+void compress_4_2(int4* in,int4*out,int n,int pasin);
+void decompress_4_2(int4* in,int4*out,int n);
 
 
Index: trunk/Poubelle/archTOI.old/decompress.c
===================================================================
--- trunk/Poubelle/archTOI.old/decompress.c	(revision 310)
+++ trunk/Poubelle/archTOI.old/decompress.c	(revision 315)
@@ -8,5 +8,5 @@
 //*******************************************************************************************
 
-void  decom_3(long val,long* in,long*out,int n);
+void  decom_3(int4 val,int4* in,int4*out,int n);
 
 #define kmax_	15		/*  valeur maximum de l'exposant	*/
@@ -24,7 +24,7 @@
 
 
-void decompress_3_1(long* in,long*out,int n)
-{
-long val;
+void decompress_3_1(int4* in,int4*out,int n)
+{
+int4 val;
 val=	*in;
 decom_3(val,in+1,out,n/9);
@@ -33,8 +33,8 @@
 
 
-void  decom_3(long val,long* in,long*out,int n)
-{
-register long R;
-long ec1,ec2,ec3,ec4,ec5,ec6,ec7,ec8,ec9;
+void  decom_3(int4 val,int4* in,int4*out,int n)
+{
+register int4 R;
+int4 ec1,ec2,ec3,ec4,ec5,ec6,ec7,ec8,ec9;
 int i,k;
 
@@ -73,6 +73,6 @@
 //*******************************************************************************************
 
-void  decom_4(long val,long* in,long*out,int n);
-void  decom_4_paire(long val1,long val2,long* in,long*out,int n);
+void  decom_4(int4 val,int4* in,int4*out,int n);
+void  decom_4_paire(int4 val1,int4 val2,int4* in,int4*out,int n);
 
 #undef kmax_
@@ -96,7 +96,7 @@
 
 
-void decompress_4_1(long* in,long*out,int n)
-{
-long val1,val2;
+void decompress_4_1(int4* in,int4*out,int n)
+{
+int4 val1,val2;
 val1=	( (*in & 0xffff0000)>>16 ) & 0x0000ffff;
 val2=	( (*in & 0x0000ffff)     )  & 0x0000ffff;
@@ -108,8 +108,8 @@
 
 
-void  decom_4(long val,long* in,long*out,int n)
-{
-register long R;
-long ec1,ec2,ec3,ec4,ec5,ec6,ec7;
+void  decom_4(int4 val,int4* in,int4*out,int n)
+{
+register int4 R;
+int4 ec1,ec2,ec3,ec4,ec5,ec6,ec7;
 int i,k;
 
@@ -146,7 +146,7 @@
 
 
-void decompress_4_2(long* in,long*out,int n)
-{
-long val1,val2;
+void decompress_4_2(int4* in,int4*out,int n)
+{
+int4 val1,val2;
 val1=in[0];		val2=in[1];
 out[0]=val1;	out[1]=val2;
@@ -155,8 +155,8 @@
 
 
-void  decom_4_paire(long val1,long val2,long* in,long*out,int n)
-{
-register long R;
-long ec1,ec2,ec3,ec4,ec5,ec6,ec7;
+void  decom_4_paire(int4 val1,int4 val2,int4* in,int4*out,int n)
+{
+register int4 R;
+int4 ec1,ec2,ec3,ec4,ec5,ec6,ec7;
 int i,k;
 
@@ -213,9 +213,9 @@
 /*	4*n	==>	n+1	*/
 
-void  decom_7(long val,long* in,long*out,int n);
-
-void decompress_7_1(long* in,long*out,int n)
-{
-long val;
+void  decom_7(int4 val,int4* in,int4*out,int n);
+
+void decompress_7_1(int4* in,int4*out,int n)
+{
+int4 val;
 val=*in;
 *out=val;
@@ -229,8 +229,8 @@
 /*  la valeur val est la valeur de reference du point origine	*/
 
-void  decom_7(long val,long* in,long*out,int n)
-{
-register long R;
-long ec1,ec2,ec3,ec4;
+void  decom_7(int4 val,int4* in,int4*out,int n)
+{
+register int4 R;
+int4 ec1,ec2,ec3,ec4;
 int i,k;
 
@@ -260,9 +260,9 @@
 /********************************************************************************/
 
-void  decom_7_paire(long val1,long val2,long* in,long*out,int n);
-
-void decompress_7_2(long* in,long*out,int n)
-{
-long val1,val2;
+void  decom_7_paire(int4 val1,int4 val2,int4* in,int4*out,int n);
+
+void decompress_7_2(int4* in,int4*out,int n)
+{
+int4 val1,val2;
 val1=	( (*in & 0xffff0000)>>11 ) & 0x001fffe0;
 val2=	( (*in & 0x0000ffff)<<5 )  & 0x001fffe0;
@@ -272,8 +272,8 @@
 
 
-void  decom_7_paire(long val1,long val2,long* in,long*out,int n)
-{
-register long R;
-long ec1,ec2,ec3,ec4;
+void  decom_7_paire(int4 val1,int4 val2,int4* in,int4*out,int n)
+{
+register int4 R;
+int4 ec1,ec2,ec3,ec4;
 int i,k;
 
Index: trunk/Poubelle/archTOI.old/ssthandler.cc
===================================================================
--- trunk/Poubelle/archTOI.old/ssthandler.cc	(revision 315)
+++ trunk/Poubelle/archTOI.old/ssthandler.cc	(revision 315)
@@ -0,0 +1,166 @@
+// Prediction mouvement d'etoiles entre un tour et le suivant...
+// si TS -> TS + dT, H -> H + dT,    dT=dH
+//
+// dz   =  - cos phi sin az dH    (check sign)
+// daz  = (sin phi - cos az cotg z cos phi) dH    (check sign)
+// 
+// free parameters = period + phase
+
+#define DIODE_UNUSED_1 3
+#define DIODE_UNUSED_2 7
+
+#include <math.h>
+#include "ssthandler.h"
+
+SSTHandler::SSTHandler()
+{
+  diodeHistLength = nb_per_block*2+10;
+  diodeT = new int[diodeHistLength*nb_photo_diodes];
+  starHistLength = 300;
+  stars = new (vector<star>[starHistLength]);
+  lastBlkNum = -1;
+  
+  Has2Bars(false);
+  prcTodo=0;
+}
+
+SSTHandler::SSTHandler(SSTHandler const& x)
+{
+  diodeHistLength = x.diodeHistLength;
+  diodeT = new int[diodeHistLength*nb_photo_diodes];
+  memcpy(diodeT, x.diodeT, diodeHistLength*nb_photo_diodes);
+  starHistLength = x.starHistLength;
+  stars = new (vector<star>[starHistLength]);
+  for (int i=0; i<starHistLength; i++)
+    stars[i] = x.stars[i];
+    
+  prcTodo    = x.prcTodo;
+  has2bars   = x.has2bars;
+  elecOffset = x.elecOffset;
+  lastBlkNum = x.lastBlkNum;
+}
+
+SSTHandler& SSTHandler::operator = (SSTHandler const& x) {
+  delete[] stars;
+  delete[] diodeT; 
+  diodeHistLength = x.diodeHistLength;
+  diodeT = new int[diodeHistLength*nb_photo_diodes];
+  memcpy(diodeT, x.diodeT, diodeHistLength*nb_photo_diodes);
+  starHistLength = x.starHistLength;
+  stars = new (vector<star>[starHistLength]);
+  for (int i=0; i<starHistLength; i++)
+    stars[i] = x.stars[i];
+    
+  prcTodo    = x.prcTodo;
+  has2bars   = x.has2bars;
+  elecOffset = x.elecOffset;
+  lastBlkNum = x.lastBlkNum;
+  
+  return *this;
+}
+
+SSTHandler::~SSTHandler()
+{
+  delete[] stars;
+  delete[] diodeT; 
+}
+
+void SSTHandler::NeedProcess(int prcMask)
+{
+  prcTodo |= prcMask;
+  if (prcTodo & findAxis)   prcTodo |= findPeriod;
+  if (prcTodo & findPeriod) prcTodo |= findStars;
+  if (prcTodo & findStars)  prcTodo |= rmveOffset;
+}
+
+void SSTHandler::Has2Bars(bool has, int eo)
+{
+  has2bars = has;
+  elecOffset = eo;
+}
+
+void SSTHandler::ProcessBlock(block_type_sst* blk)
+{
+  lastBlkNum = numero_block(blk);
+  for (int i = 0; i<nb_per_block*2; i++) {
+    DecodeTMBlock(blk, i, diodeRaw[i]);
+  }
+  if (prcTodo & rmveOffset) {
+    RemoveOffset();
+  }
+  
+}
+
+
+void SSTHandler::DecodeTMBlock(block_type_sst* blk, int i, int* diod)
+{
+  int j; // 0-5 : numero du bloc de 8 diodes
+  int k; // 0-2 : indice du bloc de 4 bits (une diode = 12 bits = 3 blocs de 4 bits)
+  int l; // 0-7 : indice de la diode dans son bloc (8 diodes * 4 bits = 1 mot de 32 bits)
+  
+  // numero de la diode (0-47) = j*8+l;
+  // indice dans le bloc sst du mot de 32 bits (0-17) = j*3+k;
+  // indice dans mot de 32 bits du premier bit utile = 28-4*l;
+    
+  for (j=0; j<48; j++) diod[j] = 0;
+  
+  for (j=0; j<6; j++)
+    for (k=0; k<3; k++)
+      for (l=0; l<8; l++) {
+        long word = blk->sst[i][j*3+k];
+        word = (word >> (28-4*l)) & 0xF;
+        //printf("diode %d mot %d valeur %d\n", j*8+l, k, word);
+        diod[j*8+l] = (diod[j*8+l] << 4) + word;
+      }
+}
+
+
+void SSTHandler::RemoveOffset()
+{
+  int j0 = diodeHistLength-(nb_per_block*2);
+  
+  // Decalage vers la gauche de la taille d'un bloc
+  memcpy(diodeT, diodeT + (nb_per_block*2)*nb_photo_diodes, j0*nb_photo_diodes);
+  
+  for (int j=0; j<nb_per_block*2; j++) {
+    // suppression des positions non utilisees. 3 et 7 ?
+    for (int i=0; i<DIODE_UNUSED_1; i++)
+      diode(j+j0,i) = diodeRaw[j][i];
+    for (int i=DIODE_UNUSED_1; i<46; i++)
+      diode(j+j0,i) = diodeRaw[j][ i<DIODE_UNUSED_2-1 ? i+1 : i+2 ];
+  
+    // calcul d'un fond sur la rangee. Moyenne clippee.
+    float m = 0; float sig = 1.e10;
+    for (int k=0; k<2; k++) {
+      float s=0; float s2=0; int n=0;
+      for (int i=0; i<46; i++) {
+        if (fabs(diode(j+j0,i)-m)<3*sig+1) {
+          s += diode(j+j0,i); s2 += diode(j+j0,i)*diode(j+j0,i); n++;
+        }
+      }
+      if (n>0) {
+        m = s/n; sig = sqrt(s2/n - m*m);
+      } else {
+        m = 0; break;
+      }
+    }
+    for (int i=0; i<46; i++) 
+      diode(j+j0,i) -= m;
+  }
+}
+
+int SSTHandler::getRawSignal(int imesure, int idiode) // for last block
+{
+  if (imesure<0 || imesure>=nb_per_block*2 || idiode<0 || idiode>=48) return -99999;
+  return diodeRaw[imesure][idiode];
+}
+
+int SSTHandler::getSignal(int imesure, int idiode) // for last block
+{
+  int j0 = diodeHistLength-(nb_per_block*2);
+  if (imesure+j0<0 || imesure>=nb_per_block*2 || 
+      idiode<0 || idiode>=nb_photo_diodes) return -99999;
+  return diode(imesure+j0, idiode);
+}
+
+
Index: trunk/Poubelle/archTOI.old/ssthandler.h
===================================================================
--- trunk/Poubelle/archTOI.old/ssthandler.h	(revision 315)
+++ trunk/Poubelle/archTOI.old/ssthandler.h	(revision 315)
@@ -0,0 +1,61 @@
+#ifndef SSTHANDLER_H
+#define SSTHANDLER_H
+
+#include <vector>
+
+#ifndef nb_max_bolo
+#define _archeops		//  Acquisition Archeops (avec transputer) 
+#define programme
+extern "C" {
+#include "archeops.h"
+}
+#endif
+
+
+class SSTHandler {
+public:
+  SSTHandler();
+  SSTHandler(SSTHandler const&);
+  SSTHandler& operator = (SSTHandler const&);
+  virtual ~SSTHandler();
+  
+  enum process { rmveOffset = 1, 
+         findStars  = 2,
+         findPeriod = 4,
+         findAxis   = 8 };
+         
+  void NeedProcess(int prcMask);
+  void Has2Bars(bool, int elecOffset=0); // elecOffset : which wired together
+  void ProcessBlock(block_type_sst*);
+  
+  int  getRawSignal(int imesure, int idiode); // for last block
+  int  getSignal(int imesure, int idiode);    // for last block, imesure<0 -> history
+  long getLastBlkNum() {return lastBlkNum;}
+
+protected:
+  int   diodeRaw[nb_per_block*2][48];
+  int   diodeHistLength;
+  int*  diodeT;       //[>nb_per_block*2]*[nb_photo_diodes];
+  int   prcTodo;
+  int   starHistLength;
+  bool  has2bars;
+  int   elecOffset;
+  long  lastBlkNum;
+  
+  inline int& diode(int iSamp, int iDiod) {return diodeT[iSamp*nb_photo_diodes+iDiod];}
+  
+  struct star {
+    float z;
+    float m;
+    double t;
+  };
+
+  vector<star>* stars;
+  
+  
+  void DecodeTMBlock(block_type_sst*, int i, int* diodes); // mesure i -> diodes
+  void RemoveOffset(); // diodeRaw -> diode, avec decalage, 1 echantillon.
+  void FindStars(); // sur les 72 derniers echantillons dans diode.
+};
+
+#endif
Index: trunk/Poubelle/archTOI.old/test.cc
===================================================================
--- trunk/Poubelle/archTOI.old/test.cc	(revision 315)
+++ trunk/Poubelle/archTOI.old/test.cc	(revision 315)
@@ -0,0 +1,63 @@
+
+#include <iostream.h>
+#include <fstream.h>
+#include <iomanip.h>
+
+#include "archeopsfile.h"
+#include "toisvr.h"
+
+using namespace std;  //introduces namespace std
+
+int main()
+{	
+	TOISvr svr;
+	//svr.SetFile("h99_04_29-15h36m22");
+	svr.SetFile("/home/manip/mnt/planck/aubourg/h99_06_08-11h49m15");
+	svr.AddInfo(sampleNum);
+	svr.AddInfo(internalTime);
+	svr.AddInfo(utc);
+	//svr.AddInfo(longitude);
+	svr.AddInfo(longitude, true, true);
+	svr.AddInfo(sstSignal,0);
+	svr.AddInfo(sstSignal,10);
+	svr.AddInfo(boloTens,1);
+	svr.AddInfo(boloTens,2);
+	
+	TOIIter iter = svr.DoQuery();
+	ofstream of ("test.out");
+	while (iter.Next()) {
+	  //if (iter.getValue(4) != 0 || iter.getValue(5) !=0 )
+/*	  cout << iter.getValue(0) << " " << iter.getValue(1) << " " <<
+	    setprecision(12) << iter.getValue(2) << " " << 
+	    setprecision(7) << iter.getValue(3) << " " << 
+	    setprecision(4) << iter.getValue(4) << " " <<
+	                       iter.getValue(5) << " " << iter.getValue(6) << "\n";*/
+	  cout << iter.getTOI(sampleNum) << " " << iter.getTOI(internalTime) << " " <<
+	    setprecision(12) << iter.getTOI(utc) << " " << 
+	    setprecision(7) << iter.getTOI(longitude) << " " << 
+	    setprecision(4) << iter.getTOI(sstSignal) << " " <<
+	                       iter.getTOI(sstSignal,10) << " " << iter.getTOI(boloTens,1) << "\n";
+	  of << iter.getValue(0) << " " << iter.getValue(1) << " " <<
+	    setprecision(12) << iter.getValue(2) << " " << 
+	    setprecision(7) << iter.getValue(3) << " " << 
+	    setprecision(4) << iter.getValue(4) << " " <<
+	                       iter.getValue(5) << " " << iter.getValue(6) << "\n";
+	}
+	
+	/*
+    int nblk[20];
+    for (int i=0; i<20; i++) nblk[i] = 0;
+	cout << "opening" << endl;
+	//ArcheopsFile file("Stock:ARCHEOPS:h99_04_29-15h36m22");
+	ArcheopsFile file("h99_04_29-15h36m22");
+	cout << file.getStartMJD() << endl;
+	cout << "reading" << endl;
+	while (file.nextBlock()) {
+	  //cout << file.blockKdName() << " " << file.blockNum() << "\n";
+	  nblk[file.blockKind()]++;
+	}
+	cout << "done" << endl;
+    for (int i=0; i<20; i++) cout << i <<" " << nblk[i] << endl;
+    */
+}
+
Index: trunk/Poubelle/archTOI.old/test.cp
===================================================================
--- trunk/Poubelle/archTOI.old/test.cp	(revision 310)
+++ 	(revision )
@@ -1,42 +1,0 @@
-
-#include <iostream.h>
-#include <iomanip.h>
-
-#include "archeopsfile.h"
-#include "toisvr.h"
-
-using namespace std;  //introduces namespace std
-
-int main()
-{	
-	TOISvr svr;
-	svr.SetFile("h99_04_29-15h36m22");
-	svr.AddInfo(boloTens,0);
-	svr.AddInfo(boloTens,1);
-	svr.AddInfo(boloTens,2);
-	svr.AddInfo(boloTens,3);
-	
-	TOIIter iter = svr.DoQuery();
-	while (iter.Next()) {
-	  cout << setprecision(15) << iter.getTime() << " " << 
-	    setprecision(4) << iter.getValue(0) << " " << iter.getValue(1) << " " <<
-	                       iter.getValue(2) << " " << iter.getValue(3) << "\n";
-	}
-	
-	/*
-    int nblk[20];
-    for (int i=0; i<20; i++) nblk[i] = 0;
-	cout << "opening" << endl;
-	//ArcheopsFile file("Stock:ARCHEOPS:h99_04_29-15h36m22");
-	ArcheopsFile file("h99_04_29-15h36m22");
-	cout << file.getStartMJD() << endl;
-	cout << "reading" << endl;
-	while (file.nextBlock()) {
-	  //cout << file.blockKdName() << " " << file.blockNum() << "\n";
-	  nblk[file.blockKind()]++;
-	}
-	cout << "done" << endl;
-    for (int i=0; i<20; i++) cout << i <<" " << nblk[i] << endl;
-    */
-}
-
Index: trunk/Poubelle/archTOI.old/toiinterpolator.cc
===================================================================
--- trunk/Poubelle/archTOI.old/toiinterpolator.cc	(revision 315)
+++ trunk/Poubelle/archTOI.old/toiinterpolator.cc	(revision 315)
@@ -0,0 +1,66 @@
+#include "toiinterpolator.h"
+
+void TOIInterpolator::enterValue(double value, long sample)
+{
+  // $CHECK$ sample > back.sample
+  if (!hist.empty() && sample == hist.back().t) return; // pour eviter /0
+  hist.push_back(pair(value, sample));
+}
+
+bool TOIInterpolator::needMoreDataFor(long sample)
+{
+  if (hist.empty()) return true;
+  int xx = hist.back().t;
+  return (hist.empty() || sample > xx);
+}
+
+bool TOIInterpolator::canGet(long sample)
+{
+  return (!hist.empty() && (sample >= hist.front().t && sample <= hist.back().t));
+}
+
+double TOIInterpolator::getEValue(long sample) // can forget before sample
+{
+  if (!canGet(sample)) return -9.e99;   // user should have checked before
+  deque<pair>::iterator i = hist.begin();
+  while ((*i).t < sample) i++;
+  if ((*i).t > sample) i--;
+  double value = (*i).val;
+  if (i != hist.begin()) {
+    i--;
+    hist.erase(hist.begin(), i);
+  }
+  return value;
+}
+
+double TOIInterpolator::getIValue(long sample) // can forget before sample
+{
+  if (!canGet(sample)) return -9.e99;   // user should have checked before
+  
+  deque<pair>::iterator i = hist.begin();
+  while ((*i).t < sample) i++;
+  double value;
+  if ((*i).t == sample) {
+    value = (*i).val;
+  } else {    
+    long samp2 = (*i).t;
+    double val2 = (*i).val;
+    i--;
+    long samp1 = (*i).t;
+    double val1 = (*i).val;
+    value = val1 + (val2-val1)*(sample-samp1)/(samp2-samp1);
+  }
+  if (i != hist.begin()) {
+    i--;
+    hist.erase(hist.begin(), i);
+  }
+  return value;
+}
+
+long TOIInterpolator::nextSample(long sampleMin)
+{
+  for (deque<pair>::iterator i = hist.begin(); i<hist.end(); i++) 
+    if ((*i).t >= sampleMin) return (*i).t;
+  return -1;
+}
+
Index: trunk/Poubelle/archTOI.old/toiinterpolator.h
===================================================================
--- trunk/Poubelle/archTOI.old/toiinterpolator.h	(revision 315)
+++ trunk/Poubelle/archTOI.old/toiinterpolator.h	(revision 315)
@@ -0,0 +1,29 @@
+#ifndef TOIINTERPOLATOR_H
+#define TOIINTERPOLATOR_H
+
+#include <deque>
+
+class TOIInterpolator {
+public:
+
+  void enterValue(double value, long sample);
+  bool   needMoreDataFor(long sample);   // need more data ? (for interp)
+  bool   canGet(long sample);        // enough info ?
+  double getIValue(long sample);     // can forget before sample
+  double getEValue(long sample);     // can forget before sample
+  long   nextSample(long sampleMin); // the next true sample available
+
+protected:
+  struct pair {
+    pair(double v, long tt) : val(v), t(tt) {}
+    pair() {}
+    double val;
+    long t;
+  };
+  
+  deque<pair> hist;
+};
+
+
+#endif
+
Index: trunk/Poubelle/archTOI.old/toiiter.cc
===================================================================
--- trunk/Poubelle/archTOI.old/toiiter.cc	(revision 310)
+++ trunk/Poubelle/archTOI.old/toiiter.cc	(revision 315)
@@ -1,3 +1,4 @@
 #include "toiiter.h"
+#include "toiinterpolator.h"
 #include <dirent.h>
 
@@ -17,4 +18,9 @@
  
  tBlock0 = -1;
+ 
+ rawIter = NULL;
+ interp  = NULL;
+ lastSample = -1;
+ maxLookAhead = 1000;
 
 }
@@ -32,12 +38,32 @@
   infos = x.infos;   
 
-  file = new ArcheopsFile(*x.file);
+  if (x.file)
+    file = new ArcheopsFile(*x.file);
+  else 
+    file = NULL;
+    
+  if (x.rawIter) {
+    rawIter = new TOIIter(*x.rawIter);
+    interp = new TOIInterpolator[infos.size()];
+    for (int i=0; i<infos.size(); i++)
+      interp[i] = x.interp[i];
+  } else {
+    rawIter = NULL;
+    interp  = NULL;
+  }
+  
+  lastSample = x.lastSample;
+  maxLookAhead = x.maxLookAhead;
 }
 
 TOIIter::~TOIIter() {
   delete file;
+  delete rawIter;
+  delete[] interp;
 }
 
 void TOIIter::Init() {
+
+  // $CHECK$ a deplacer, pour gerer repertoires...
   if (directory == "") {
     file = new ArcheopsFile(fileName);
@@ -60,6 +86,6 @@
   // mieux en prenant le min de tous les delta_T.
   
-    tBlock0 = file->getStartMJD();
-#if 0
+  tBlock0 = file->getStartMJD();
+
   file->pushMark();
   if (file->lastGPS() || file->nextBlock(block_gps_mask)) {
@@ -71,8 +97,10 @@
   }
   file->popMark();
-#endif  
+
+  bool hasInterp = false;
   
   trigMask = 0;
   for (vector<info>::iterator i = infos.begin(); i != infos.end(); i++) {
+    if ((*i).interpolated) hasInterp = true;
     if ((*i).triggering) {
       switch ((*i).kind) {
@@ -86,8 +114,21 @@
           break;
         case azimut:
+          file->needSSTProcessMask(SSTHandler::findPeriod);
           trigMask |= block_sst_mask;
           break;
-        case alpha:
-        case delta:
+        case sstStarZ:
+        case sstStarF:
+          file->needSSTProcessMask(SSTHandler::findStars);
+          trigMask |= block_sst_mask;
+          break;
+        case sstSignal:
+          file->needSSTProcessMask(SSTHandler::rmveOffset);
+          trigMask |= block_sst_mask;
+          break;
+        case alphaAxis:
+        case deltaAxis:
+        case alphaBolo:
+        case deltaBolo:
+          file->needSSTProcessMask(SSTHandler::findAxis);
           trigMask |= block_sst_mask;
           break;
@@ -101,7 +142,19 @@
     imes = 0;
   }
+  
+  if (hasInterp) {
+    rawIter = new TOIIter(*this);
+    interp = new TOIInterpolator[infos.size()];
+    for (int i=0; i<infos.size(); i++) {
+      rawIter->infos[i].interpolated = false;
+    }
+    delete file; file = NULL; // on ne travaille plus sur le fichier directement...
+  }
 }
 
 bool TOIIter::NextFile() {
+  if (rawIter)
+    return rawIter->NextFile();
+    
   if (directory == "") {
     return false;
@@ -119,5 +172,31 @@
 
 bool TOIIter::Next() {
-
+  if (rawIter) {  // Delegation pour interpolation
+    // Trouve prochain sample disponible
+    for (int k=0; k<2; k++) {
+      long smp = 2147483647L;
+      for (int i=0; i<infos.size(); i++) {
+        long ss = interp[i].nextSample(lastSample+1);
+        if (ss > 0 && ss < smp) smp=ss;
+      }
+      if (smp != 2147483647L) {
+        lastSample = smp;
+        break;
+      }
+      if (!fetchAhead())  // tout le monde etait en bout de course,
+        return false;     // on lit un echantillon, ca suffit, d'ou le k<2
+    }
+    // Verifie que tous les interpolateurs ont assez de donnees pour
+    // trouver la valeur correspondante
+    for (int i=0; i<infos.size(); i++) {
+      //rif (infos[i].interpolated) 
+        while (interp[i].needMoreDataFor(lastSample) && 
+               rawIter->getSampleIndex() - lastSample < maxLookAhead)
+          if (!fetchAhead()) return false;
+    }
+    
+    // On est pret...
+    return true;
+  }
 
   // trigger sur info indexee dans bloc bolo ou bloc sst ?
@@ -129,82 +208,178 @@
   
   // soit pas d'info indexee, soit fin bloc courant...
-  
-  if (file->nextBlock(trigMask)) {
-    return true;
-  }
-  if (!NextFile()) return false;
-  return file->nextBlock(trigMask);
-}
-
- double TOIIter::getTime() {                // MJD 
+  while (1) {
+    if (file->nextBlock(trigMask)) {
+      while (file->sameBlockNumAhead()) {  // tant que meme numero de bloc, on lit
+        if (!file->nextBlock()) {          // fin de fichier ?
+          if (NextFile()) file->nextBlock();
+          else break;
+        }
+      }
+      return true;
+    }
+    if (!NextFile()) return false;
+  }
+}
+
+/* double TOIIter::getTime() {                // MJD 
    // le temps du bloc courant, en secondes
    double dt = file->blockNum() * file->perBlock();
    return tBlock0 + dt/86400. + imes*file->perEchant()/86400.;
  }
- 
- double TOIIter::getValue(int column) {
-   if (column < 0 || column >= infos.size()) return -1;
+ */
+ 
+bool TOIIter::canGetValue(int column) {
+   if (column < 0 || column >= infos.size()) return false;
+   if (rawIter) {
+       return interp[column].canGet(lastSample);
+   }
    TOIKind kind = infos[column].kind;
    int index = infos[column].index;
    switch (kind) {
+     case sampleNum:
+     case internalTime:
+     case utc:
+       return true;
+     case boloTens:
+     case boloRaw:
+       return file->lastBolo() != NULL;
+     case sstSignal:
+       return file->lastSST() != NULL;
+     case longitude:
+     case latitude:
+       return file->lastGPS() != NULL;
+     case azimut:
+     case alphaAxis:
+     case deltaAxis:
+       return (file->lastGPS() != NULL && file->lastSST() != NULL);
+   }
+   return false;
+}
+ 
+double TOIIter::getValue(int column) {
+   if (column < 0 || column >= infos.size()) return -1;
+   if (rawIter) {
+     if (infos[column].interpolated)
+       return interp[column].getIValue(lastSample);
+     else
+       return interp[column].getEValue(lastSample);
+   }
+   TOIKind kind = infos[column].kind;
+   int index = infos[column].index;
+   switch (kind) {
+     case sampleNum:
+       return file->blockNum() * file->nEchBlock() + imes;
+     case internalTime:
+       return (file->blockNum() * file->nEchBlock() + imes) * file->perEchant();
+     case utc:
+      /* printf("utc: %d %d %g %g %g\n",file->blockNum(),
+         (file->blockNum() * file->nEchBlock() + imes),
+         file->perEchant(),
+         (file->blockNum() * file->nEchBlock() + imes) * file->perEchant()/86400.,
+         tBlock0+(file->blockNum() * file->nEchBlock() + imes) * file->perEchant()/86400.); */
+       return tBlock0+(file->blockNum() * file->nEchBlock() + imes) * file->perEchant()/86400.;
      case boloTens:
        return file->getMuVBolo(index, imes);
      case boloRaw:
        return file->getRawBolo(index, imes);
+     case sstSignal:
+       return file->getSSTSignal(index, imes);
      case longitude:
        return file->getGPSLong(); // $CHECK$ TBD gerer interpolation (dans file)
      case latitude:
        return file->getGPSLat();  // $CHECK$ TBD gerer interpolation (dans file)
-      case azimut:
+     case azimut:
        return file->getAzimut(imes);
-      case alpha:
+     case alphaAxis:
        return file->getAlpha(imes);
-      case delta:
+     case deltaAxis:
        return file->getDelta(imes);
    }
    return -1;
- }
- 
- bool   TOIIter::newValue(int column) {
+}
+ 
+bool   TOIIter::newValue(int column) {
    if (column < 0 || column >= infos.size()) return false;
    TOIKind kind = infos[column].kind;
    switch (kind) {
+     case sampleNum:
+     case internalTime:
+     case utc:
+       return true;
      case boloTens:
-       return file->blockKind() == block_bolo;
+       return file->blockNum() == file->getBoloBlockNum();
      case boloRaw:
-       return file->blockKind() == block_bolo;
+       return file->blockNum() == file->getBoloBlockNum();
+     case sstSignal:
+       return file->blockNum() == file->getSSTBlockNum();
      case longitude:
-       return file->blockKind() == block_gps;
+       return file->blockNum() == file->getGPSBlockNum() && imes==0;
      case latitude:
-       return file->blockKind() == block_gps;
-      case azimut:
-       return file->blockKind() == block_sst || file->blockKind() == block_bolo;
-      case alpha:
-       return file->blockKind() == block_sst || file->blockKind() == block_bolo;
-      case delta:
-       return file->blockKind() == block_sst || file->blockKind() == block_bolo;
+       return file->blockNum() == file->getGPSBlockNum() && imes==0;
+     case azimut:
+       return true; // $CHECK$ with SSTHandler
+     case alphaAxis:
+       return true; // $CHECK$ with SSTHandler
+     case deltaAxis:
+       return true; // $CHECK$ with SSTHandler
    }
    return false;
- }
- 
- bool   TOIIter::extendValue(int column) {
-   return !newValue(column);
- }
- 
- bool   TOIIter::interpValue(int /*column*/) {
-   return false; // $CHECK$ TBD gerer interpolation
- }
- 
- TOIKind TOIIter::getKind(int column) {
+}
+ 
+bool   TOIIter::extendValue(int column) {
+   return (!infos[column].interpolated && !newValue(column));
+}
+ 
+bool   TOIIter::interpValue(int column) {
+   return (infos[column].interpolated && !newValue(column));
+}
+ 
+TOIKind TOIIter::getKind(int column) {
    if (column < 0 || column >= infos.size()) return (TOIKind)-1;
    return infos[column].kind;
- }
- 
- int TOIIter::getIndex(int column) {
+}
+ 
+int TOIIter::getIndex(int column) {
    if (column < 0 || column >= infos.size()) return (TOIKind)-1;
    return infos[column].index;
- }
+}
+
+int TOIIter::getColTOI(TOIKind kind, int index) {
+   for (int i=0; i<infos.size(); i++)
+     if (infos[i].kind == kind && infos[i].index == index)
+       return i;
+   return -1;
+}
+
+bool TOIIter::canGetTOI(TOIKind kind, int index) {
+   int col = getColTOI(kind, index);
+   if (col<0) return false;
+   return canGetValue(col);
+}
+
+double TOIIter::getTOI(TOIKind kind, int index) {
+   int col = getColTOI(kind, index);
+   if (col<0) return -9.e99;
+   return getValue(col);
+}
+
    
- int TOIIter::getSampleIndex() {
+int TOIIter::getBlockSampleIndex() {
    return imes;
- }
+}
+ 
+int TOIIter::getSampleIndex() {
+   return file->blockNum() * file->nEchBlock() + imes;
+}
+ 
+bool TOIIter::fetchAhead() { // Seulement si delegation
+  if (!rawIter) return false;
+  if (!rawIter->Next()) return false;
+  long sample = rawIter->getSampleIndex();
+  for (int i=0; i<infos.size(); i++) {
+    if (rawIter->canGetValue(i) && rawIter->newValue(i))
+      interp[i].enterValue(rawIter->getValue(i), sample);
+  }
+  return true;
+}
+
Index: trunk/Poubelle/archTOI.old/toiiter.h
===================================================================
--- trunk/Poubelle/archTOI.old/toiiter.h	(revision 310)
+++ trunk/Poubelle/archTOI.old/toiiter.h	(revision 315)
@@ -9,32 +9,45 @@
 
 enum TOIKind {
+  sampleNum,  // Numero d'echantillon (timer interne transputer)
+  internalTime, // temps transputer depuis debut manip, en secondes.
+  utc,        // UTC (en jours, MJD = JD - 2450000). index=0 : premier bloc GPS. 1: + sioux.
   boloTens,   // tension en microVolts, filtree avec filtre carre indexe par bolometre
   boloRaw,    // tension brute, non filtree indexe par bolometre
-  longitude,  // ballon
-  latitude,   // ballon
+  sstSignal,  // signal brut SST, indice = diode
+  sstStarZ,   // numero de diode d'une eventuelle etoile,   i=etoile 0..n
+  sstStarF,   // flux d'une eventuelle etoile,             -1 si moins de i+1 etoiles
+  longitude,  // position ballon
+  latitude,   // position ballon
+  tsid,       // temps sideral en secondes
   azimut,     // a preciser, reconstruit SST, magneto, autres...
-  
-  alpha,      // sur le ciel, indexe par bolometre
-  delta       // sur le ciel, indexe par bolometre
-  
+  alphaAxis,  // 
+  deltaAxis,  //
+  alphaBolo,  // sur le ciel, indexe par bolometre
+  deltaBolo   // sur le ciel, indexe par bolometre
+
 };
 
-
+class TOIInterpolator;
 
 class TOIIter {
 public:
-   TOIIter(TOIIter const&);
+   TOIIter(TOIIter const&);   // $CHECK$ prevoir operator = ?
    ~TOIIter();
    bool Next();
    
-   double getTime();                // MJD 
-   double getValue(int column);
-   bool   newValue(int column);     // a juste change ?
-   bool   extendValue(int column);  // une valeur plus ancienne, etendue ?
-   bool   interpValue(int column);  // une valeur interpolee avec valeur future ?
+   bool    canGetValue(int column);  // data is available for that...
+   double  getValue(int column);
+   bool    newValue(int column);     // a juste change ?
+   bool    extendValue(int column);  // une valeur plus ancienne, etendue ?
+   bool    interpValue(int column);  // une valeur interpolee avec valeur future ?
    TOIKind getKind(int column);
-   int     getIndex(int column);    // si plusieurs, exemple, tension bolo 2
+   int     getIndex(int column);     // si plusieurs, exemple, tension bolo 2
    
-   int    getSampleIndex();         // numero d'echantillon dans dernier bloc bolo
+   bool    canGetTOI(TOIKind kind, int index=0);
+   double  getTOI(TOIKind kind, int index=0);
+   
+   
+   int    getBlockSampleIndex();        // numero d'echantillon dans dernier bloc bolo
+   int    getSampleIndex();             // numero d'echantillon 
 
    block_type_param*         lastParam();  
@@ -78,4 +91,6 @@
    };
    
+   int getColTOI(TOIKind kind, int index=0);
+   
    long trigMask;
    
@@ -84,4 +99,13 @@
    friend class TOISvr;
    
+   // Gestion de l'interpolation, par delegation a un autre iterateur
+   TOIIter* rawIter; // iterateur sans interpolation, qui avance avec retard
+                     // en bufferisant les valeurs. S'il existe, on lui delegue
+                     // toutes les operations agissant sur le fichier.
+   TOIInterpolator* interp; // interpolateurs pour stocker les valeurs
+   long lastSample;  // last interpolated sample
+   long maxLookAhead;
+   bool fetchAhead(); // avance d'une TOI en nourrissant les interpolateurs
+   
    private:
 };
