Changeset 342 in Sophya

Timestamp:

Aug 2, 1999, 3:45:52 PM (26 years ago)

Author:

ansari

Message:

archtoi 2 aout 99

Location:

trunk/Poubelle/archTOI.old

Files:

• Makefile (added)
• archeops.c (modified) (1 diff)
• archeops.h (modified) (1 diff)
• archeops_24.c (added)
• archeops_24.h (added)
• archeops_25.c (added)
• archeops_25.h (added)
• archeops_26.c (added)
• archeops_26.h (added)
• archeops_27.c (added)
• archeops_27.h (added)
• archeops_28.c (added)
• archeops_28.h (added)
• archeopsfile.cc (modified) (24 diffs)
• archeopsfile.h (modified) (9 diffs)
• archtoi.cc (added)
• archtoi.h (added)
• archtoidump.cc (added)
• archtoimain.cc (added)
• compress.c (added)
• compress.h (modified) (7 diffs)
• decompress.c (modified) (11 diffs)
• gpsparser.cc (added)
• gpsparser.h (added)
• ssthandler.cc (modified) (11 diffs)
• ssthandler.h (modified) (3 diffs)
• test.cc (modified) (4 diffs)
• toiinterpolator.cc (modified) (1 diff)
• toiinterpolator.h (modified) (2 diffs)
• toiiter.cc (modified) (18 diffs)
• toiiter.h (modified) (8 diffs)
• toisvr.cc (modified) (1 diff)
• toisvr.h (modified) (1 diff)

trunk/Poubelle/archTOI.old/archeops.c

@@ -1 @@
-//#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);
-}
-
-
-
-
-
-
-
+#include "archeops_28.c"

trunk/Poubelle/archTOI.old/archeops.h

@@ -1 @@
-
-/*======================================================================*/
-/*                                                                      */
-/*               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 linux
-#undef programme
-#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); 
-
-
-
+#include "archeops_28.h"

trunk/Poubelle/archTOI.old/archeopsfile.cc

@@ -38 +38 @@
   
   SSTHandler sstHandler;
+  GPSParser  gpsParser;
 };
 
@@ -211 +212 @@
       else if (!llastBolo) {
         llastBolo = new block_type_bolo;
+      }
+      if (llastBolo) {
         memcpy(llastBolo, lastBolo, sizeof(block_type_bolo));
       }
@@ -286 +289 @@
   fn         = x.fn;
   f = fopen(fn.c_str(), "rb");
+
+  rawMJD     = x.rawMJD;
+  startMJD   = x.startMJD;
+  utcOffset  = x.utcOffset;
 }
 
@@ -300 +307 @@
   //curBlock = oldFile.curBlock;
   //peekBlock = oldFile.peekBlock;
-  peekPos = 0;
+  if (peekPos>0) peekPos = 0;
   setUTCOffset(oldFile.utcOffset);
 }
@@ -306 +313 @@
 
 def_nom_block
+
+def_long_block
 
 bool ArcheopsFile::nextBlock() {
@@ -316 +325 @@
   
   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");
-  }
-  peekPos += longueur_block(peekBlock);
+  curPos = peekPos;
+  
+  while (true) {
+    if (peekPos+12 > fLen) return false;  // fin de fichier
+    fseek(f,peekPos,SEEK_SET);            // aller en peekPos
+    size_t read = fread(peekBlock,1,sizeof(block_type_modele),f);
+    swapEntete(peekBlock);
+    if (read < longueur_block(peekBlock) || 
+        type_block(peekBlock) < 0 || type_block(peekBlock) > 19 ||
+        longueur_block(peekBlock) != long_block[type_block(peekBlock)]) {
+      cout << "block de type/longueur invalide" << endl;
+      memset(peekBlock, 0, sizeof(block_type_modele)); // don't keep trash...
+      peekPos = searchNextBlock(peekPos);
+      if (peekPos<0) return false;
+      continue;
+    }
+    swapContent(peekBlock);
+    if (verifie_block(peekBlock) != block_correct) {
+      cout << "block invalide " << numero_block(peekBlock);
+      if (!fixBlock(peekBlock)) {
+        cout << " -- skipped" << endl;
+        peekPos += longueur_block(peekBlock);  // la longueur doit etre ok...
+        continue;
+      } else {
+        cout << " -- fixed" << endl;
+        break;
+      }
+    }
+    break; // tout semble bon pour ce bloc...
+  }
+  
+  peekPos += longueur_block(peekBlock); // on suppose que longueur OK...
   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();
-  saveCurBlock();
+  if (curBlock->debut != 0) {
+    curRawKind = curKind = type_block(curBlock);
+    postProcessBlock();
+    saveCurBlock();
+  } else {
+    curRawKind = curKind = -1;
+  }
   return true;
 }
@@ -346 +378 @@
 }
 
+bool ArcheopsFile::fixBlock(block_type_modele* blk) {
+  return false;
+}
+
+
 int  ArcheopsFile::blockKind() {
   return curKind;
@@ -363 +400 @@
   double p,f1,f2,f3;
   int pp;
+  if (!lastReglage()) return -1;
   pp=lastReglage()->reglage.horloge.periode;
   p=pp/5.;
@@ -374 +412 @@
 
 int ArcheopsFile::nEchBlock() {  // Nb d'echantillons dans un bloc
-  return lastParam()->param.n_per_block*2.;
+  return lastParam()->param.n_per_block*2;
 }
 
@@ -448 +486 @@
 }
 
+void ArcheopsFile::forceBlock(block_type_modele* blk) {
+  blockSet->setBloc(*blk);
+}
+
+#define place_paquet(i,j)        ((i/8) * 24  + j*8 + (i%8) )
+
 void ArcheopsFile::postProcessBlock() {
   switch (curKind) {
@@ -454 +498 @@
        block_type_bolo blk2;
        block_type_bolo_comprime* blk = (block_type_bolo_comprime*) &blockSet->curBlock;
+       #if version_num <= 25
        for(int j=0;j<nb_bolo_util;j++)  
-                {
-                   decompress_7_2(blk->data_bolo[j],blk2.data_bolo[j],nb_per_block*2);
+           {
+                   decompress_7_2((int4*)blk->data_bolo[j],blk2.data_bolo[j],nb_per_block*2);
+           }
+           #else
+           block_type_param* param = lastParam();
+           int jc=0;for(int j=0;j<nb_max_bolo;j++)       // jc = bolo_comprime  //   j=bolo normal
+           {
+                if( (param->param.bolo[j].bolo_code_util==bolo_normal_transmis) &&  (jc<nb_bolo_util)  )
+                        {
+                        decompress_7_2((int4 *)blk->data_bolo[jc],blk2.data_bolo[j],nb_per_block*2);
+                        jc++;
+                        }
+                else {
+                  memset(blk2.data_bolo[j], 0, nb_per_block*2*sizeof(int4));
                 }
+                }
+
+           #endif
        valide_block((block_type_modele*)&blk2,block_bolo,numero_block(blk));    
        memcpy(&blockSet->curBlock,&blk2,sizeof(blk2));
@@ -464 +524 @@
      }
      case block_sst_comprime: {  // $CHECK$ TBD
+       blockSet->setRawBloc(blockSet->curBlock);
+       block_type_sst blk2;
+       block_type_sst_comprime* blk = (block_type_sst_comprime*) &blockSet->curBlock;
+       for (int j=0; j<18; j++)
+         for (int i=0; i<nb_per_block*2; i++)
+           blk2.sst[i][j] = 0;
+
+       int jc=0;
+       for( int j=0;j<48;j++) {
+         if ((j!=0) && (j!=4)) 
+         {
+           unsigned int4 sst_vrai[nb_per_block*2];
+           decompress_4_1((int4*)blk->sst[jc],(int4*)sst_vrai,nb_per_block*2);
+           for (int k=0;k<nb_per_block*2;k++) {
+             unsigned int4 a,b0,b1,b2;
+             b2 = sst_vrai[k] & 0xf;
+             b1 = (sst_vrai[k] >> 4) & 0xf;
+             b0 = (sst_vrai[k] >> 8) & 0xf;
+                 a=place_paquet(j,0);
+                 blk2.sst[k][a/8] |= (b0 << (a%8)*4);
+                 a=place_paquet(j,1);
+                 blk2.sst[k][a/8] |= (b1 << (a%8)*4);
+                 a=place_paquet(j,2);
+                 blk2.sst[k][a/8] |= (b2 << (a%8)*4);
+           }
+           jc++;
+         }
+       }       
+       valide_block((block_type_modele*)&blk2,block_sst,numero_block(blk));     
+       memcpy(&blockSet->curBlock,&blk2,sizeof(blk2));
+       curKind = block_sst;
+       blockSet->sstHandler.ProcessBlock((block_type_sst*)&blockSet->curBlock);
+       break;
      }
      case block_sst : {
        blockSet->sstHandler.ProcessBlock((block_type_sst*)&blockSet->curBlock);
+     }
+     case block_gps : {
+       blockSet->gpsParser.ProcessBlock((block_type_gps*)&blockSet->curBlock);
      }
   }
@@ -519 +615 @@
 #endif
 
+#ifdef SWAP
 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);
+  if (lg < taille_maxi_block_archeops)
+    bswap4(((char*)blk) + lg - 4);
+}
+#else
+void ArcheopsFile::swapEntete(block_type_modele* ) {
+}
 #endif
-}
-
+
+#ifdef SWAP
 void ArcheopsFile::swapContent(block_type_modele* blk) {
-#ifdef SWAP
   int typ = type_block(blk);
 
@@ -550 +650 @@
     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]);
-  }
-  
-  }
+#if version_num<=25
+        bswap4(&b->param.bolo[i].bolo_nom[4*j]);
+#else
+        bswap4(&b->param.nom_coef[i].bolo_nom[4*j]);
 #endif
-}
-  
+  }
+  
+  }
+}
+#else
+void ArcheopsFile::swapContent(block_type_modele* ) {
+}
+#endif
+  
+long ArcheopsFile::searchNextBlock(long pos) {
+  static char* buffer = 0;
+  static int4  debswp = debut_block_mesure;
+  static int4  longmax = taille_maxi_block_archeops*20;
+  if (!buffer) {
+    buffer = new char[longmax];
+#ifdef SWAP
+    bswap4(&debswp);
+#endif
+  }
+  fseek(f,pos,SEEK_SET);
+  size_t read = fread(buffer,1,taille_maxi_block_archeops*2,f);
+  //if (read<taille_maxi_block_archeops*2) return -1;
+  for (int i=4; i<read; i+=4) {
+    if (*(int4*)(buffer+i) == debswp) {
+      cout << "trying to skip " << i << " bytes to pos="<<pos+i << endl;
+      return pos+i;
+    }
+  }
+  cout << "cannot find block start" << endl;
+  return -1;
+}
+
   
 
@@ -562 +692 @@
 static int mlen[] = {31,28,31,30,31,30,31,31,30,31,30,31};
 
+double ArcheopsFile::decodeMJD(string const& dateString) {
+  //99_04_29-15h36m22  ou  99_05_10
+  short y,m,d,hh,mm,ss;
+  char const* p = dateString.c_str();
+  char const* p2 = dateString.c_str() + dateString.length();
+  y  = atoi(p); p+=3; if (p>p2) return -1;
+  m  = atoi(p); p+=3; if (p>p2) return -1;
+  d  = atoi(p); p+=3;
+  if (p<p2) {
+  hh = atoi(p); p+=3; if (p>p2) return -1;
+  mm = atoi(p); p+=3; if (p>p2) return -1;
+  ss = atoi(p);
+  } else {
+    hh=mm=ss=0;
+  }
+
+  if (y<50) y += 100;
+  // 1. depuis 0/1/97 minuit
+  double mjd = (int) (365.25 * (y-97));
+  for (int i=0; i<m-1; i++)
+    mjd += mlen[i];
+  if (y%4 == 0 && m > 2) mjd++;
+  mjd += d;
+  mjd += hh/24. + mm/24./60. + ss/24./60./60;
+  
+  mjd += 448.5; // 0/1/97 minuit
+
+  return mjd;
+}
+
 void ArcheopsFile::computeMJD(string const& fname) {
-  //h99_04_29-15h36m22
-  short y,m,d,hh,mm,ss;
+  //telemetrie : h99_04_29-15h36m22
+  //enregistreur : ARKxxxxxx.dat, et MJD = samedi 17 juillet, 21h -> 1377.4
   char const* p = fname.c_str();
   char const* p2 = p  + fname.length()-1;
@@ -570 +730 @@
   if (*p2 == ':' || *p2 == '/') p2++;
   if (*p2 == 'h') p2++;
-  y  = atoi(p2); p2+=3;
-  m  = atoi(p2); p2+=3;
-  d  = atoi(p2); p2+=3;
-  hh = atoi(p2); p2+=3;
-  mm = atoi(p2); p2+=3;
-  ss = atoi(p2);
-  
-  if (y<50) y += 100;
-  // 1. depuis 0/1/97 minuit
-  rawMJD = (int) (365.25 * (y-97));
-  for (int i=0; i<m-1; i++)
-    rawMJD += mlen[i];
-  if (y%4 == 0 && m > 2) rawMJD++;
-  rawMJD += d;
-  rawMJD += hh/24. + mm/24./60. + ss/24./60./60;
-  
-  rawMJD += 448.5; // 0/1/97 minuit
+  if (!strncmp(p2, "ARK",3)) {
+    rawMJD = 1377.4;
+  } else {
+    rawMJD = decodeMJD(p2);
+  }
   startMJD = rawMJD - utcOffset/24.;
 }
@@ -610 +758 @@
 
 
+int ArcheopsFile::getGyroBlockNum() {
+  if (!lastGyro()) return -1;
+  return numero_block(lastGyro());
+}
+
+
 // GPS
 // $GPGGA,hhmmss.ss,ddmm.mmmm,n,dddmm.mmmm,e,q,ss,y.y,a.a,z,
@@ -621 +775 @@
 double ArcheopsFile::getGPSUTC() {  // en secondes depuis minuit UTC jour courant
   if (!lastGPS()) return -9.e99;
-  char* p = lastGPS()->gps;
-  if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
-  p += 7;
+  return blockSet->gpsParser.getUTC();
+/*  char* p = lastGPS()->gps;
+  //if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
+  //p += 7;
+  if (*p != '$') return -9.e99;
+  p += 1;
   double t;
   sscanf(p, "%lg", &t);
   int h = int(t/10000); t -= h*10000;
   int m = int(t/100);   t -= m*100;
-  return h*3600. + m*60. + t;
+  return h*3600. + m*60. + t;*/
 }
 
 double ArcheopsFile::getGPSMJD() {  // modified julian day du dernier bloc GPS, JD - 2450000
-  double t = getGPSUTC()/86400.;
+  double t = getGPSUTC()/86400. - 0.5;
   if (t<0) return t;
   if (t > (startMJD - int(startMJD))) {
@@ -643 +800 @@
 double ArcheopsFile::getGPSLat() {  // degres, +  = NORD
   if (!lastGPS()) return -9.e99;
-  char* p = lastGPS()->gps;
-  if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
+  return blockSet->gpsParser.getLatitude();
+  /*char* p = lastGPS()->gps;
+  //if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
+  if (*p!='$') return -9.e99;
   char* fence = p+80;
-  p += 7;
+  p += 1;
   while (*p != ',' && p<fence) p++;
   if (*p != ',') return -9.e99; 
@@ -658 +817 @@
   p++;
   if (*p == 'S') t = -t;
-  return t;
-}
+  return t;*/
+}
+
 
 double ArcheopsFile::getGPSLong() { // degres, +  = EST
   if (!lastGPS()) return -9.e99;
-  char* p = lastGPS()->gps;
-  if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
+  return blockSet->gpsParser.getLongitude();
+  /*char* p = lastGPS()->gps;
+  //if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
+  if (*p!='$') return -9.e99;
   char* fence = p+80;
-  p += 7;
+  p += 1;
   for (int i=0; i<3; i++) {
     while (*p != ',' && p<fence) p++;
@@ -680 +842 @@
   p++;
   if (*p == 'W') t = -t;
-  return t;
-}
-
+  return t;*/
+}
+
+double ArcheopsFile::getGPSAlt() { // meters from sea level
+  if (!lastGPS()) return -9.e99;
+  return blockSet->gpsParser.getAltitude();
+  /*char* p = lastGPS()->gps;
+  //if (strncmp(p, "$GPGGA,", 7)) return -9.e99;
+  if (*p!='$') return -9.e99;
+  char* fence = p+80;
+  p += 1;
+  for (int i=0; i<8; i++) {
+    while (*p != ',' && p<fence) p++;
+    if (*p != ',') return -9.e99; 
+    p++;
+  }
+  double t;
+  sscanf(p, "%lg", &t);
+  return t;*/
+}
+
+bool ArcheopsFile::hasGPSTime() { 
+  if (!lastGPS()) return false;
+  return blockSet->gpsParser.hasGPSTime();
+}
+
+bool ArcheopsFile::hasGPSPos() { 
+  if (!lastGPS()) return false;
+  return blockSet->gpsParser.hasPosition();
+}
+
+bool ArcheopsFile::hasGPSAlt() { 
+  if (!lastGPS()) return false;
+  return blockSet->gpsParser.hasAltitude();
+}
 
 
 // Bolo
+#define  val_DS(j,i)  (blk->data_bolo[j][i]&0x1fffff)
+
 
 long ArcheopsFile::getRawBolo(int ibolo, int imesure) {    // donnee brute, avec seulement soustraction offset
   int nb_coups,aa;  
   block_type_bolo* blk = imesure >= 0 ? lastBolo() : llastBolo();
+  //cout << "raw " << imesure << " ";
   if (imesure < 0) imesure += nEchBlock();
   if (!blk) return 0;
@@ -699 +896 @@
   
   int s = imesure % 2 ? 1 : -1;
-
-  return s*(((blk->data_bolo[ibolo][imesure]-aa)<<1)/nb_coups);
+  
+  //cout << s*(((val_DS(ibolo,imesure)-aa)<<1)/nb_coups) << "\n";
+
+  return s*(((val_DS(ibolo,imesure)-aa)<<1)/nb_coups);
 }
 
@@ -706 +905 @@
 
 double ArcheopsFile::getMuVBolo(int ibolo, int imesure) { // microvolts, filtre avec filtre carre
-  double y = (getRawBolo(ibolo, imesure-1) - getRawBolo(ibolo, imesure))/2.;
-  if (imesure%2) y=-y;
+  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_ampli(reglage->reglage.bolo[ibolo])));
+  block_type_param*   param = lastParam();
+  //cout << "muv " << imesure << " " << y << "\n";
+  return bol_micro_volt(y,(double)param->param.bolo[ibolo].bolo_gain*gain_ampli(reglage->reglage.bolo[ibolo]));
+  //return ((1e5*y)/(65536.*gain_ampli(reglage->reglage.bolo[ibolo])));
 }
 
@@ -719 +921 @@
 }
 
-
 long ArcheopsFile::getSSTSignal(int idiode, int imesure) {
   return blockSet->sstHandler.getSignal(imesure, idiode);
 }
+
+long ArcheopsFile::getSSTRawSignal(int idiode, int imesure) {
+  return blockSet->sstHandler.getRawSignal(imesure, idiode);
+}
+
+double ArcheopsFile::getSSTStarZ(int istar, int imesure) {
+  return blockSet->sstHandler.getStarZ(imesure, istar);
+}
+
+double ArcheopsFile::getSSTStarF(int istar, int imesure) {
+  return blockSet->sstHandler.getStarF(imesure, istar);
+}
+
+long ArcheopsFile::getGyro(int igyro, int imesure) {   
+  if (igyro<0 || igyro>2) return 0;
+  if (imesure<0 || imesure>= nb_per_block*2) return 0;
+  block_type_gyro* blk = lastGyro() ;
+  if (!blk) return 0;
+#if version_num<=25
+  return blk->gyros[igyro][imesure];
+#else
+  return blk->gyro[igyro][imesure];
+#endif
+}
+
+
+
 // $CHECK$ TBD
 

trunk/Poubelle/archTOI.old/archeopsfile.h

@@ -16 +16 @@
 
 #include "ssthandler.h"
+#include "gpsparser.h"
 
 enum {
@@ -33 +34 @@
   block_gyro_comprime_mask = 1 << block_gyro_comprime,
   block_sst_comprime_mask = 1 << block_sst_comprime,
-  block_catalog_flash_mask = 1 << block_catalog_flash,
+ // block_catalog_flash_mask = 1 << block_catalog_flash,
   block_cmd_flash_mask = 1 << block_cmd_flash,
   block_data_brute_mask = 1 << block_data_brute,
@@ -63 +64 @@
   double getStartMJD();
   
-  bool nextBlock();   // go to next block, true if block exists
+  bool nextBlock();   // go to next block, true if block exists (ie not EOF)
   bool nextBlock(long mask); // go to next block matching mask
+  bool gotValidBlock(); // current block is good
   int  blockKind();   // kind of the current bloc, enum in archeops.h
   int  blockRawKind();   // kind of the current raw bloc, enum in archeops.h
@@ -70 +72 @@
   string blockKdName();
   string blockRawKdName();
+  string filename() {return fn;}
   
   double perEchant(); // periode d'echantillonage pour le dernier bloc reglage
@@ -102 +105 @@
   block_type_sst_comprime*  lastSSTComp();
   
+  void forceBlock(block_type_modele* blk);
+  
   // Decodage des derniers blocs..
   
@@ -109 +114 @@
   // Ces fonctions travaillent sur le dernier bloc GPS 
   int getGPSBlockNum();
+  bool   hasGPSTime();
+  bool   hasGPSPos();
+  bool   hasGPSAlt();
   double getGPSUTC();  // en secondes depuis minuit UTC
   double getGPSMJD();  // modified julian day du dernier bloc GPS, JD - 2450000
   double getGPSLat();  // degres, +  = NORD
   double getGPSLong(); // degres, +  = EST
+  double getGPSAlt();  // meters from sea level
     
   // Bolo
@@ -122 +131 @@
   int getSSTBlockNum();
   void needSSTProcessMask(int mask);
+  long getSSTRawSignal(int iDiode, int imesure);
   long getSSTSignal(int iDiode, int imesure);
+  double getSSTStarZ(int iStar, int imesure);
+  double getSSTStarF(int iStar, int imesure);
+  
+  int getGyroBlockNum();
+  long getGyro(int iGyro, int imesure);
   
   double getAzimut(int imesure);
@@ -130 +145 @@
   double getAlpha(int imesure);
   double getDelta(int imesure);
+  
+  static double decodeMJD(string const& dateString); // sans tenir compte de TU-TLeg
     
 protected:
@@ -143 +160 @@
   
   void computeMJD(string const& fname);
+  
+  bool fixBlock(block_type_modele* blk);
+  long searchNextBlock(long pos);
     
   int                       curKind;

trunk/Poubelle/archTOI.old/compress.h

@@ -6 +6 @@
 /************************************************************************/
 
-#ifndef int4
-#ifdef __alpha
-#define int4 int
-#else
-#define int4 long
-#endif
-#endif
 
 
@@ -24 +17 @@
 /*      pour    n = 72    en sortie     19 mots = 76 octets             */
 
-void compress_7_1(int4* in,int4*out,int n,int pasin);
+void compress_7_1(unsigned int4* in,unsigned int4*out,int n,int pasin);
 void decompress_7_1(int4* in,int4*out,int n);
 
@@ -36 +29 @@
 /*      pour    n = 72    en sortie     11 mots = 44 octets             */
 
-void compress_4_1(int4* in,int4*out,int n,int pasin);
+void compress_4_1(unsigned int4* in,unsigned int4*out,int n,int pasin);
 void decompress_4_1(int4* in,int4*out,int n);
 
@@ -49 +42 @@
 
 
-void compress_3_1(int4* in,int4*out,int n,int pasin);
+void compress_3_1(unsigned int4* in,unsigned int4*out,int n,int pasin);
 void decompress_3_1(int4* in,int4*out,int n);
 
@@ -70 +63 @@
 
 
-void compress_7_2(int4* in,int4*out,int n,int pasin);
+void compress_7_2(unsigned int4* in,unsigned int4*out,int n,int pasin);
 void decompress_7_2(int4* in,int4*out,int n);
 
@@ -85 +78 @@
 
 
-void compress_4_2(int4* in,int4*out,int n,int pasin);
+void compress_4_2(unsigned int4* in,unsigned int4*out,int n,int pasin);
 void decompress_4_2(int4* in,int4*out,int n);
 
@@ -96 +89 @@
 /************************************************************************/
 
-/*Les valeures de la table d'entree sont consideres comme toujopurs positives   */
-/* les ecarts sont calculés signés sur 32 bit avant d'etre tronconnés           */
+/*      tous les nombres sont des entiers unsigned long pour compress                           */
+/*Les valeures de la table d'entree sont consideres comme toujours positives et sur 21 bits     */
+/*  les valeurs de reference pour le calcul des ecarts sont augmentees de ecart_bit=0x10000000  */
+/*      LES ECARTS SONT DES ENTIERS POSITIFS (ecart_bit +  valeur courante - valeur precedente) */
 
-#define shif(ec,k,q)    {while(ec>q)if(k<kmax_){k++;q<<=1;}else ec=q;while(ec<-q)if(k<kmax_){k++;q<<=1;}else ec=-q;}
-#define recup(ec,sss,k) {ec=((R>>sss)&emak_);if(ec & sgbi_ ) ec|= sign_ ; ec<<=k;}
-#define arrondi(ec,k)   ((ec &  filtre[k]) +( (ec & test[k]) <<1 ) )    
+/*  pour tous les compresseurs  */
+#define kmax_   15              /*  valeur maximum de l'exposant        */
+#define ecart_bit       0x10000000
+#define shif(ec,k,q)    {while(ec>(q|ecart_bit))if(k<kmax_){k++;q<<=1;}else ec=(q|ecart_bit);while(ec<ecart_bit-q)if(k<kmax_){k++;q<<=1;}else ec=ecart_bit-q;}
+#define arrondi(ec,k)   ((ec &  filtre[k]) +( (ec & test[k]) <<1 ) ) /* resultat sur 28 bit  */ 
+#define new_val(val,ec,k)       ((val + arrondi(ec,k))&data_mask);
 
+/* pour les decompresseurs      */
+#define recup(ec,sss,k) {ec=((R>>sss)&ecart_mask);if(ec & sgbi_ ) ec|= sign_ ; ec<<=k;}
+

trunk/Poubelle/archTOI.old/decompress.c

@@ +1 @@
+//#include <manip.h>
+#include "archeops.h"
 #include "compress.h"
 
@@ -8 +10 @@
 //*******************************************************************************************
 
+#define ecart_mask              0x7     /*      masque pour l'ecart             */              
+
 void  decom_3(int4 val,int4* in,int4*out,int n);
 
-#define kmax_   15              /*  valeur maximum de l'exposant        */
-#define kmak_   0xf             /*      masque pour l'exposant          */
-#define emak_   0x7             /*      masque pour l'ecart             */              
+#define k_mask  0xf             /*      masque pour l'exposant          */
 #define sgbi_   0x4             /*      bit de signe de l'ecart         */
 #define sign_   0xfffffff8      /*      masque de signe de l'ecart      */
@@ -42 +44 @@
         {
         R=in[i];
-        k=R&kmak_;
+        k=R&k_mask;
         recup(ec1,29,k); 
         recup(ec2,26,k); 
@@ -76 +78 @@
 void  decom_4_paire(int4 val1,int4 val2,int4* in,int4*out,int n);
 
-#undef kmax_
-#undef  kmak_
-#undef  emak_           
+#undef  ecart_mask              
+#define ecart_mask      0xf             /*      masque pour l'ecart             */              
 #undef  sgbi_
 #undef  sign_
@@ -84 +85 @@
 
 
-#define kmax_   15              /*  valeur maximum de l'exposant        */
-#define kmak_   0xf             /*      masque pour l'exposant          */
-#define emak_   0xf             /*      masque pour l'ecart             */              
+#define k_mask  0xf             /*      masque pour l'exposant          */
 #define sgbi_   0x8             /*      bit de signe de l'ecart         */
 #define sign_   0xfffffff0      /*      masque de signe de l'ecart      */
@@ -117 +116 @@
         {
         R=in[i];
-        k=R&kmak_;
+        k=R&k_mask;
         recup(ec1,28,k); 
         recup(ec2,24,k); 
@@ -164 +163 @@
         {
         R=in[i];
-        k=R&kmak_;
+        k=R&k_mask;
         recup(ec1,28,k); 
         recup(ec2,24,k); 
@@ -194 +193 @@
 //*******************************************************************************************
 
-
-#undef kmax_
-#undef  kmak_
-#undef  emak_           
 #undef  sgbi_
 #undef  sign_
 
 
-
-#define kmax_   15              /*  valeur maximum de l'exposant        */
-#define kmak_   0xf             /*      masque pour l'exposant          */
-#define emak_   0x7f            /*      masque pour l'ecart             */              
+#undef  ecart_mask              
+#define ecart_mask              0x7f            /*      masque pour l'ecart 7 bits              */              
 #define sgbi_   0x40            /*      bit de signe de l'ecart         */
 #define sign_   0xffffff80      /*      masque de signe de l'ecart      */
@@ -238 +231 @@
         {
         R=in[i];
-        k=R&kmak_;
+        k=R&k_mask;
         recup(ec1,25,k); 
         recup(ec2,18,k); 
@@ -281 +274 @@
         {
         R=in[i];
-        k=R&kmak_;
+        k=R&k_mask;
         recup(ec1,25,k); 
         recup(ec2,18,k); 
@@ -292 +285 @@
         val2+=ec4;      out[4*i+3]=val2;         
 
-/*if(i<5)  printf("in=%x  i=%d  k=%d  ec= %x %x %x %x  \n",R,i,k,ec1,ec2,ec3,ec4);      */
-
-        }
-}
-
-
+/*if(i<5)  printf("in=%x  i=%d  k=%d  ec= %x %x %x %x  \n",R,i,k,ec1,ec2,ec3,ec4);*/    
+
+        }
+}
+
+

trunk/Poubelle/archTOI.old/ssthandler.cc

@@ -7 +7 @@
 // free parameters = period + phase
 
-#define DIODE_UNUSED_1 3
-#define DIODE_UNUSED_2 7
-
 #include <math.h>
 #include "ssthandler.h"
+
+// diodpermut[i] = channel de la diode i
+int SSTHandler::diodpermut[46]=
+ { 8,24,40, 9,25,41,10,26,42,11,
+  27,43,16,32, 1,17,33, 2,18,34,
+   3,19,35,12,28,44,13,29,45,14,
+  30,46,15,31,47,20,36, 5,21,37,
+   6,22,38, 7,23,39};
+ // voies 0 et 4 non connectees, voie 1 en panne.
 
 SSTHandler::SSTHandler()
@@ -21 +27 @@
   lastBlkNum = -1;
   
-  Has2Bars(false);
+  //Has2Bars(false);
   prcTodo=0;
+  seuil=100;
+  
 }
 
@@ -36 +44 @@
     
   prcTodo    = x.prcTodo;
-  has2bars   = x.has2bars;
-  elecOffset = x.elecOffset;
+ // has2bars   = x.has2bars;
+ // elecOffset = x.elecOffset;
   lastBlkNum = x.lastBlkNum;
+  seuil      = x.seuil;
 }
 
@@ -53 +62 @@
     
   prcTodo    = x.prcTodo;
-  has2bars   = x.has2bars;
-  elecOffset = x.elecOffset;
+ // has2bars   = x.has2bars;
+ // elecOffset = x.elecOffset;
   lastBlkNum = x.lastBlkNum;
+  seuil      = x.seuil;
   
   return *this;
@@ -74 +84 @@
 }
 
+bool SSTHandler::has2bars = false;
+int  SSTHandler::elecOffset = 1;
+
 void SSTHandler::Has2Bars(bool has, int eo)
 {
@@ -89 +102 @@
     RemoveOffset();
   }
-  
+  if (prcTodo & findStars) {
+    FindStars();
+  }
 }
 
@@ -101 +116 @@
   // 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;
+  // indice dans mot de 32 bits du premier bit utile = 4*l;
     
   for (j=0; j<48; j++) diod[j] = 0;
@@ -108 +123 @@
     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);
+        int4 word = blk->sst[i][j*3+k];
+        word = (word >> (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;
       }
+
+  //for (j=0; j<48; j++) if (diod[j]>2047) diod[j] -= 4096;
+  for (j=0; j<48; j++)  diod[j] -= 2048;
+  
 }
 
@@ -124 +143 @@
   
   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 ];
-  
+    // permutation des diodes
+    for (int i=0; i<46; i++)
+      diode(j+j0,i) = diodeRaw[j][diodpermut[i]];
+  
+    /*
     // calcul d'un fond sur la rangee. Moyenne clippee.
     float m = 0; float sig = 1.e10;
@@ -147 +165 @@
     for (int i=0; i<46; i++) 
       diode(j+j0,i) -= m;
+    */
   }
 }
@@ -164 +183 @@
 }
 
-
+int SSTHandler::getStarZ(int imesure, int istar) // for last block
+{
+  int j0 = starHistLength-(nb_per_block*2);
+  if (imesure+j0<0 || imesure>=nb_per_block*2) return -99999;
+  if (istar < 0 || istar >= stars[imesure+j0].size()) return -99999;
+  return stars[imesure+j0][istar].z;
+}
+
+int SSTHandler::getStarF(int imesure, int istar) // for last block
+{
+  int j0 = starHistLength-(nb_per_block*2);
+  if (imesure+j0<0 || imesure>=nb_per_block*2) return -99999;
+  if (istar < 0 || istar >= stars[imesure+j0].size()) return -99999;
+  return stars[imesure+j0][istar].m;
+}
+
+
+void SSTHandler::FindStars()  // sur les 72 derniers echantillons dans diode.
+{
+  int js0 = starHistLength-(nb_per_block*2);
+  int jd0 = diodeHistLength-(nb_per_block*2);
+  // Decalage vers la gauche de la taille d'un bloc
+  for (int i=0; i<js0; i++) {
+    stars[i] = stars[i+(nb_per_block*2)];
+  }
+  
+  // Recherche d'etoiles
+  for (int i=0; i<(nb_per_block*2); i++) {
+    stars[js0+i].clear();
+    for (int idiode=0; idiode<46; idiode++) {
+      if (diode(jd0+i,idiode) < -seuil) {
+        if (has2bars) {
+          for (int j=-2; j>=-5; j--) {
+            if (diode(jd0+i+j,(idiode+elecOffset)%46) < -seuil) {
+              star s;
+              s.z = idiode;
+              s.m = -diode(jd0+i,idiode);
+              s.t = i; // $CHECK$ need absolute time...
+              stars[js0+i].push_back(s);
+              break;
+            } else if (idiode<45 && diode(jd0+i+j,(idiode+1+elecOffset)%46) > seuil) {
+              star s;
+              s.z = idiode+.5;
+              s.m = -diode(jd0+i,idiode);
+              s.t = i; // $CHECK$ need absolute time...
+              stars[js0+i].push_back(s);
+              break;
+            }
+          }
+        } else {
+          if (diode(jd0+i,idiode) > diode(jd0+i-1,idiode)) {
+            star s;
+            s.z = idiode;
+            s.m = -diode(jd0+i-1,idiode);
+            s.t = i; // $CHECK$ need absolute time...
+            stars[js0+i].push_back(s);
+          }
+        }
+      }
+    }
+  }
+
+
+}

trunk/Poubelle/archTOI.old/ssthandler.h

@@ -26 +26 @@
          
   void NeedProcess(int prcMask);
-  void Has2Bars(bool, int elecOffset=0); // elecOffset : which wired together
   void ProcessBlock(block_type_sst*);
+
+  static void Has2Bars(bool, int elecOffset=0); // elecOffset : which wired together
   
   int  getRawSignal(int imesure, int idiode); // for last block
   int  getSignal(int imesure, int idiode);    // for last block, imesure<0 -> history
+  int  getStarZ(int imesure, int istar);      // for last block, imesure<0 -> history
+  int  getStarF(int imesure, int istar);      // for last block, imesure<0 -> history
   long getLastBlkNum() {return lastBlkNum;}
 
@@ -39 +42 @@
   int   prcTodo;
   int   starHistLength;
-  bool  has2bars;
-  int   elecOffset;
   long  lastBlkNum;
+  int   seuil;
+  
+  static bool  has2bars;
+  static int   elecOffset;
   
   inline int& diode(int iSamp, int iDiod) {return diodeT[iSamp*nb_photo_diodes+iDiod];}
@@ -57 +62 @@
   void RemoveOffset(); // diodeRaw -> diode, avec decalage, 1 echantillon.
   void FindStars(); // sur les 72 derniers echantillons dans diode.
+  
+  static int  diodpermut[46]; // diodpermut[i] = channel de la diode i
 };
 

trunk/Poubelle/archTOI.old/test.cc

@@ -5 +5 @@
 
 #include "archeopsfile.h"
+#include "archtoi.h"
 #include "toisvr.h"
 
@@ -11 +12 @@
 int main()
 {       
+
+    ArchTOI toi("test.toi");
+    toi.run("test.data");
+    return(0);
+    
         TOISvr svr;
         //svr.SetFile("h99_04_29-15h36m22");
-        svr.SetFile("/home/manip/mnt/planck/aubourg/h99_06_08-11h49m15");
+        //svr.SetFile("Stock:ARCHEOPS:DATA:arch_24:arch-99_06_08:h99_06_08-11h49m15");
+        svr.SetFile("Stock:ARCHEOPS:DATA:arch_26:arch-99_06_28:h99_06_28-11h23m41");
+        //svr.SetFile("/home/manip/mnt/planck/aubourg/h99_06_08-11h49m15");
+        //svr.SetDirectory("Stock:ARCHEOPS:DATA:arch_24:arch-99_06_08:");
+        //svr.SetDirectory("Stock:ARCHEOPS:DATA:arch_24");
         svr.AddInfo(sampleNum);
         svr.AddInfo(internalTime);
@@ -20 +30 @@
         svr.AddInfo(longitude, true, true);
         svr.AddInfo(sstSignal,0);
-        svr.AddInfo(sstSignal,10);
+        svr.AddInfo(sstStarZ,0);
         svr.AddInfo(boloTens,1);
         svr.AddInfo(boloTens,2);
+        
+        SSTHandler::Has2Bars(true,1);
         
         TOIIter iter = svr.DoQuery();
@@ -33 +45 @@
             setprecision(4) << iter.getValue(4) << " " <<
                                iter.getValue(5) << " " << iter.getValue(6) << "\n";*/
+                              // cout << iter.getValue(5) << endl;
+                               
           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";
+            setprecision(12) << iter.getTOI(utc)       << " " << 
+            setprecision(7)  << iter.getTOI(longitude) << " " << 
+            setprecision(4)  << iter.getTOI(sstSignal) << " " <<
+                                iter.getTOI(sstStarZ)  << " " << 
+                                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";
+            setprecision(7)  << iter.getValue(3) << " " << 
+            setprecision(4)  << iter.getValue(4) << " " <<
+                                iter.getValue(5) << " " << 
+                                iter.getValue(6) << "\n";
         }
         

trunk/Poubelle/archTOI.old/toiinterpolator.cc

@@ -58 +58 @@
 }
 
+bool TOIInterpolator::isNewValue(long sample) 
+{
+  deque<pair>::iterator i = hist.begin();
+  while (i!=hist.end()) {
+    if ((*i).t == sample) return true;
+    if ((*i).t > sample) return false;
+    i++;
+  }
+  return false;
+}
+
+
 long TOIInterpolator::nextSample(long sampleMin)
 {

trunk/Poubelle/archTOI.old/toiinterpolator.h

@@ -3 +3 @@
 
 #include <deque>
+
+using namespace std;
+
 
 class TOIInterpolator {
@@ -12 +15 @@
   double getIValue(long sample);     // can forget before sample
   double getEValue(long sample);     // can forget before sample
+  bool   isNewValue(long sample);    
   long   nextSample(long sampleMin); // the next true sample available
 

trunk/Poubelle/archTOI.old/toiiter.cc

@@ -2 +2 @@
 #include "toiinterpolator.h"
 #include <dirent.h>
+#include <iostream.h>
 
 // Format bloc GPS
@@ -14 +15 @@
  fileName = "";
  
+ files.clear();
+
+ isOnBoardRecorder = false;
+   
+ imes=0;
+
  tStart = -9.e99;
- tEnd   = -9.e99;
+ tEnd   = 9.e99;
  
  tBlock0 = -1;
- 
+ perEch = -1;
+ 
+ trigMask = 0;
  rawIter = NULL;
  interp  = NULL;
  lastSample = -1;
- maxLookAhead = 1000;
+ maxLookAhead = 10000;
 
 }
@@ -30 +39 @@
   fileName = x.fileName;
   files = x.files;
-  curFile = x.curFile;
+  //  curFile = x.curFile; // $CHECK$ DANGER !!
+  curFile = files.find(*(x.curFile));
+  isOnBoardRecorder = x.isOnBoardRecorder;
   imes = x.imes;
   tStart = x.tStart;
   tEnd = x.tEnd;
   tBlock0 = x.tBlock0;
+  perEch = x.perEch;
   trigMask = x.trigMask;
   infos = x.infos;   
@@ -63 +75 @@
 }
 
+#ifdef __MWERKS__
+#define filesep ':'
+#else
+#define filesep '/'
+#endif
+
 void TOIIter::Init() {
-
-  // $CHECK$ a deplacer, pour gerer repertoires...
+ // On a soit un repertoire, soit un fichier, soit une liste de fichiers....
   if (directory == "") {
-    file = new ArcheopsFile(fileName);
-  } else {
+    if (files.empty()) {   // un seul fichier
+      file = new ArcheopsFile(fileName);
+    } else {
+      curFile = files.begin();
+      file = new ArcheopsFile((*curFile).c_str());
+    }
+  } else { // On a un repertoire a explorer
+    // On cherche soit les fichiers dans le repertoire donne, soit des fichiers
+    // dans un sous-repertoire "arch-YY_MM_DD". Les fichiers ont un nom en
+    // "hYY_MM_DD-hh_mm_ss".
+    // Pour l'enregistreur de vol, les fichiers ont un nom en ARKxxxxxx.DAT
+    if (directory[directory.length()-1] != filesep) 
+      directory += filesep;
     DIR* dir = opendir(directory.c_str());
     struct dirent* ent;
     while ((ent = readdir(dir)) != NULL) {
-      files.insert(ent->d_name);
+      // si c'est un repertoire, avec un nom de jour, il faut l'explorer...
+      if (!strncmp(ent->d_name, "arch-", 5)) {
+        double mjd = ArcheopsFile::decodeMJD(ent->d_name+5) - 2./24.; // ENTIER + .5 en temps local!
+        if (mjd >= tStart - 1. && mjd <= tEnd) {
+          string direc2 = directory + ent->d_name + filesep;
+          DIR* dir2 = opendir(direc2.c_str());
+          struct dirent* ent2;
+          while ((ent2 = readdir(dir2)) != NULL) {
+            if (*ent2->d_name == 'h') {
+              double mjd2 = ArcheopsFile::decodeMJD(ent->d_name+1) - 2./24.;
+              if (mjd2 >= tStart - 1./24. && mjd2 <= tEnd) {
+                files.insert(direc2 + ent2->d_name);
+              }
+            }
+          }
+        }
+      } else {
+        if (!isOnBoardRecorder && *ent->d_name == 'h') {
+          double mjd = ArcheopsFile::decodeMJD(ent->d_name+1) - 2./24.; // $CHECK$ UTCOffset
+          if (mjd >= tStart - 1./24. && mjd <= tEnd) {
+            files.insert(directory + ent->d_name);
+          }
+        } else if (isOnBoardRecorder) {
+          if (strncmp(ent->d_name, "ARK", 3)) continue;
+          char * sfx = ent->d_name + strlen(ent->d_name) - 4;
+          if (strcmp(sfx, ".DAT")) continue;
+          files.insert(directory + ent->d_name);
+        }
+      }
     }
     closedir(dir);
@@ -79 +135 @@
   }
 
-  if (!file->lastParam()) file->nextBlock(block_param_mask);
+  // On avance jusqu'a avoir au moins un bloc param et un bloc reglage,
+  // car on ne peut rien faire sans...
+  // Si on a des donnees de l'enregistreur de vol, pas de bloc param, et
+  // on en simule un
+  if (!file->lastParam()) {
+    if (isOnBoardRecorder) {
+      extern param_bolo  parametr;
+      block_type_param block;
+      block.param = parametr;
+      valide_block((block_type_modele*)&block, block_param, 0);
+      file->forceBlock((block_type_modele*)&block);
+    } else {
+      file->nextBlock(block_param_mask);
+    }
+  }
   if (!file->lastReglage()) file->nextBlock(block_reglage_mask);
   
   // On cherche un bloc GPS pour avoir la correspondance timestamp/UTC.
   // Pour le moment, on se fonde sur le premier bloc GPS. On pourra faire
-  // mieux en prenant le min de tous les delta_T.
-  
-  tBlock0 = file->getStartMJD();
-
-  file->pushMark();
-  if (file->lastGPS() || file->nextBlock(block_gps_mask)) {
-    // le temps du bloc courant, en secondes
-    double dt = file->blockNum() * file->perBlock();
-    tBlock0 = file->getGPSMJD() - dt/86400.;
-  } else { // pas de bloc GPS...
+  // mieux en prenant le min de tous les delta_T, a condition d'avoir un 
+  // peu plus de details sur la facon dont le GPS est lu.
+  
+  if (tBlock0 < 0) {
     tBlock0 = file->getStartMJD();
-  }
-  file->popMark();
+
+    file->pushMark();
+    if (file->lastGPS() || file->nextBlock(block_gps_mask)) {
+      // le temps du bloc courant, en secondes
+      double dt = file->blockNum() * file->perBlock();
+      tBlock0 = file->getGPSMJD() - dt/86400.;
+    } else { // pas de bloc GPS...
+      tBlock0 = file->getStartMJD();
+    }
+    file->popMark();
+  }
+  
+  if (perEch < 0)
+    perEch = file->perEchant();
 
   bool hasInterp = false;
@@ -109 +185 @@
           trigMask |= block_bolo_mask;
           break;
+        case gpsTime:
         case longitude:
         case latitude:
+        case altitude:
           trigMask |= block_gps_mask;
           break;
@@ -125 +203 @@
           file->needSSTProcessMask(SSTHandler::rmveOffset);
           trigMask |= block_sst_mask;
+          break;
+        case sstRaw:
+          trigMask |= block_sst_mask;
+          break;
+        case gyroRaw:
+          trigMask |= block_gyro_mask;
           break;
         case alphaAxis:
@@ -157 +241 @@
     return rawIter->NextFile();
     
-  if (directory == "") {
+  if (files.empty()) {
     return false;
   } else {
@@ -163 +247 @@
     curFile++;
     if (curFile == files.end()) return false;
+    cout << "opening file " << (*curFile).c_str() << endl;
     ArcheopsFile* newfile = new ArcheopsFile((*curFile).c_str());
     newfile->grabLastBlocs(*file);
@@ -242 +327 @@
        return true;
      case boloTens:
+       if (imes==0 && file->llastBolo()==NULL) return false;
+       return file->lastBolo() != NULL;
      case boloRaw:
        return file->lastBolo() != NULL;
      case sstSignal:
+     case sstRaw:
        return file->lastSST() != NULL;
+     case sstStarZ:
+     case sstStarF:
+       return (file->lastSST() != NULL) && (file->getSSTStarZ(index, imes) >= 0);
+     case gyroRaw:
+       return (file->lastGyro() != NULL);
+     case gpsTime:
+       return file->hasGPSTime();
      case longitude:
      case latitude:
-       return file->lastGPS() != NULL;
+       return file->hasGPSPos();
+     case altitude:
+       return file->hasGPSAlt();
      case azimut:
      case alphaAxis:
@@ -271 +368 @@
        return file->blockNum() * file->nEchBlock() + imes;
      case internalTime:
-       return (file->blockNum() * file->nEchBlock() + imes) * file->perEchant();
+       //return (file->blockNum() * file->nEchBlock() + imes) * file->perEchant();
+       return (file->blockNum() * file->nEchBlock() + imes) * perEch;
      case utc:
       /* printf("utc: %d %d %g %g %g\n",file->blockNum(),
@@ -278 +376 @@
          (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.;
+       //return tBlock0+(file->blockNum() * file->nEchBlock() + imes) * file->perEchant()/86400.;
+       return tBlock0+(file->blockNum() * file->nEchBlock() + imes) * perEch/86400.;
      case boloTens:
        return file->getMuVBolo(index, imes);
@@ -285 +384 @@
      case sstSignal:
        return file->getSSTSignal(index, imes);
+     case sstRaw:
+       return file->getSSTRawSignal(index, imes);
+     case sstStarZ:
+       return file->getSSTStarZ(index, imes);
+     case sstStarF:
+       return file->getSSTStarF(index, imes);
+     case gyroRaw:
+       return file->getGyro(index, imes);
+     case gpsTime:
+       return file->getGPSUTC();
      case longitude:
-       return file->getGPSLong(); // $CHECK$ TBD gerer interpolation (dans file)
+       return file->getGPSLong();
      case latitude:
-       return file->getGPSLat();  // $CHECK$ TBD gerer interpolation (dans file)
+       return file->getGPSLat();
+     case altitude:
+       return file->getGPSAlt();
      case azimut:
        return file->getAzimut(imes);
@@ -301 +412 @@
 bool   TOIIter::newValue(int column) {
    if (column < 0 || column >= infos.size()) return false;
+   if (rawIter) {
+       return interp[column].isNewValue(lastSample);
+   }
    TOIKind kind = infos[column].kind;
    switch (kind) {
@@ -311 +425 @@
      case boloRaw:
        return file->blockNum() == file->getBoloBlockNum();
+     case sstRaw:
      case sstSignal:
+     case sstStarZ:
+     case sstStarF:
        return file->blockNum() == file->getSSTBlockNum();
+     case gyroRaw:
+       return file->blockNum() == file->getGyroBlockNum();
+     case gpsTime:
+       return file->blockNum() == file->getGPSBlockNum() && imes==0;
      case longitude:
        return file->blockNum() == file->getGPSBlockNum() && imes==0;
      case latitude:
+       return file->blockNum() == file->getGPSBlockNum() && imes==0;
+     case altitude:
        return file->blockNum() == file->getGPSBlockNum() && imes==0;
      case azimut:
@@ -334 +457 @@
    return (infos[column].interpolated && !newValue(column));
 }
+
+bool TOIIter::isTrig(int column) {
+   if (column < 0 || column >= infos.size()) return false;
+   return infos[column].triggering;
+}
+
  
 TOIKind TOIIter::getKind(int column) {
@@ -370 +499 @@
  
 int TOIIter::getSampleIndex() {
-   return file->blockNum() * file->nEchBlock() + imes;
+   if (file) {
+     return file->blockNum() * file->nEchBlock() + imes;
+   } else {
+     return lastSample;
+   }
 }
  
@@ -378 +511 @@
   long sample = rawIter->getSampleIndex();
   for (int i=0; i<infos.size(); i++) {
-    if (rawIter->canGetValue(i) && rawIter->newValue(i))
+    if (rawIter->canGetValue(i) && rawIter->newValue(i)) {
       interp[i].enterValue(rawIter->getValue(i), sample);
+    }
   }
   return true;
 }
 
+block_type_param* TOIIter::lastParam() {
+  if (file) return file->lastParam(); 
+  else return rawIter->lastParam();
+}
+
+

trunk/Poubelle/archTOI.old/toiiter.h

@@ -9 +9 @@
 
 enum TOIKind {
-  sampleNum,  // Numero d'echantillon (timer interne transputer)
+  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
-  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
+  boloTemp,   // Kelvins
+  sstSignal,  // signal brut SST, indice = diode, 0-45
+  sstRaw,     // signal brut SST, indice = canal, 0-47
+  sstStarZ,   // numero de diode d''une eventuelle etoile,   i=etoile 0..n
+  sstStarF,   // flux d''une eventuelle etoile,             <0 si moins de i+1 etoiles
+  gyroRaw,    // valeur brute du gyro, index = 0,1,2
+  gpsTime,    // temps fourni par GPS
   longitude,  // position ballon
   latitude,   // position ballon
+  altitude,   // position ballon
   tsid,       // temps sideral en secondes
   azimut,     // a preciser, reconstruit SST, magneto, autres...
   alphaAxis,  // 
   deltaAxis,  //
+  alphaSst,  // 
+  deltaSst,  //
   alphaBolo,  // sur le ciel, indexe par bolometre
   deltaBolo   // sur le ciel, indexe par bolometre
-
 };
 
@@ -41 +47 @@
    bool    extendValue(int column);  // une valeur plus ancienne, etendue ?
    bool    interpValue(int column);  // une valeur interpolee avec valeur future ?
+   bool    isTrig(int column);  
    TOIKind getKind(int column);
    int     getIndex(int column);     // si plusieurs, exemple, tension bolo 2
@@ -48 +55 @@
    
    
-   int    getBlockSampleIndex();        // numero d'echantillon dans dernier bloc bolo
-   int    getSampleIndex();             // numero d'echantillon 
+   int    getBlockSampleIndex();        // numero d''echantillon dans dernier bloc bolo
+   int    getSampleIndex();             // numero d''echantillon 
 
    block_type_param*         lastParam();  
@@ -65 +72 @@
    block_type_gyro_comprime* lastGyroComp();
    block_type_sst_comprime*  lastSSTComp();
+   
+   ArcheopsFile* currentFile() {return file;}
 
 protected:
@@ -77 +86 @@
    set<string> files;  // list of files in the directory...
    set<string>::iterator curFile;
+   bool  isOnBoardRecorder;
    
    int imes;
@@ -83 +93 @@
    
    double tBlock0;  // MJD du bloc numero zero...
+   double perEch;   // periode d''echantillonage en secondes
    
    struct info {
@@ -99 +110 @@
    friend class TOISvr;
    
-   // Gestion de l'interpolation, par delegation a un autre iterateur
+   // 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
@@ -106 +117 @@
    long lastSample;  // last interpolated sample
    long maxLookAhead;
-   bool fetchAhead(); // avance d'une TOI en nourrissant les interpolateurs
+   bool fetchAhead(); // avance d''une TOI en nourrissant les interpolateurs
    
    private:

trunk/Poubelle/archTOI.old/toisvr.cc

@@ -13 +13 @@
   iter.fileName = f;
 }
+
+void TOISvr::AddFile(string f) {
+  iter.directory = "";
+  iter.files.insert(f);
+}
+
+void TOISvr::SetMJD0(double t0) {
+  iter.tBlock0 = t0;
+}
+
+
+void TOISvr::OnBoardRecorderFiles(bool x) {
+  iter.isOnBoardRecorder = x;
+}
+
   
 void TOISvr::SetTimeInterval(double tStart, double tEnd) {
-  iter.tStart = tStart;
-  iter.tEnd = tEnd;
+  if (tStart>0) iter.tStart = tStart;
+  if (tEnd>0)   iter.tEnd = tEnd;
 }
   

trunk/Poubelle/archTOI.old/toisvr.h

@@ -10 +10 @@
   void SetDirectory(string);
   void SetFile(string);
+  void AddFile(string);
+  void OnBoardRecorderFiles(bool);
+  void SetMJD0(double);
   
   void SetTimeInterval(double tStart, double tEnd);