Changeset 394 in Sophya for trunk/Poubelle

Timestamp:

Sep 1, 1999, 2:45:54 PM (26 years ago)

Author:

ansari

Message:

Integration detecteur d'etoiles DY

Location:

trunk/Poubelle/archTOI.old

Files:

• archeopsfile.cc (modified) (1 diff)
• archeopsfile.h (modified) (1 diff)
• archparam.cc (added)
• archparam.h (added)
• archtoi.cc (modified) (3 diffs)
• dyffttools.cc (added)
• dyffttools.h (added)
• fft_mayer.cc (added)
• formepulse.cc (added)
• formepulse.h (added)
• mayer_fft.h (added)
• pisteetoile.cc (added)
• pisteetoile.h (added)
• sstetoile.cc (added)
• sstetoile.h (added)
• ssthandler.cc (modified) (8 diffs)
• ssthandler.h (modified) (6 diffs)
• ssthardware.h (added)
• toiiter.cc (modified) (13 diffs)
• toiiter.h (modified) (2 diffs)
• toisvr.cc (modified) (1 diff)
• toisvr.h (modified) (1 diff)
• transfelec.cc (added)
• transfelec.h (added)
• trigtbl.h (added)

trunk/Poubelle/archTOI.old/archeopsfile.cc

@@ -884 +884 @@
 }
 
+double ArcheopsFile::getSSTStarT(int istar, int imesure) {
+  return blockSet->sstHandler.getStarTime(imesure, istar);
+}
+
+double ArcheopsFile::getNumbStar(int imesure) {
+  return blockSet->sstHandler.getNumbStar(imesure);
+}
+
 long ArcheopsFile::getGyro(int igyro, int imesure) {   
   if (igyro<0 || igyro>2) return 0;

trunk/Poubelle/archTOI.old/archeopsfile.h

@@ -138 +138 @@
   double getSSTStarZ(int iStar, int imesure);
   double getSSTStarF(int iStar, int imesure);
+  double getSSTStarT(int iStar, int imesure);
+  double getNumbStar(int imesure);
   
   int getGyroBlockNum();

trunk/Poubelle/archTOI.old/archtoi.cc

@@ -11 +11 @@
 #include "toisvr.h"
 #include "archtoi.h"
+#include "archparam.h"
 #include "asigps.h"
 
@@ -74 +75 @@
   else tsttoi(sstStarZ)
   else tsttoi(sstStarF)
+  else tsttoi(sstStarT)
   else tsttoi(gyroRaw)
   else tsttoi(gpsTime)
@@ -155 +157 @@
     double t0;
     sscanf(arg.c_str(), "%lg", &t0);
-    svr.SetMJD0(t0);
+    archParam.acq.tBlock0 = t0;
   } else if (key == "#PERECH") {
     double t0;
     sscanf(arg.c_str(), "%lg", &t0);
-    svr.SetPerEch(t0);
+    archParam.acq.perEch = t0;
   } else if (key == "#ASIGPS") {
     ASIGPS* gps = new ASIGPS(arg);

trunk/Poubelle/archTOI.old/ssthandler.cc

@@ -13 +13 @@
 #include <math.h>
 #include "ssthandler.h"
-#include <iostream.h>
+#include "pisteetoile.h"
 
 // diodpermut[i] = channel de la diode i
@@ -25 +25 @@
 
 SSTHandler::SSTHandler()
+:sstchass("SSTChassLogFile")
 {
   diodeHistLength = nb_per_block*2+10;
   diodeT = new int[diodeHistLength*nb_photo_diodes];
   starHistLength = 300;
-  stars = new (vector<star>[starHistLength]);
+
   lastBlkNum = -1;
   
   //Has2Bars(false);
   prcTodo=0;
-  seuil=100;
-}
-
-SSTHandler::SSTHandler(SSTHandler const& x)
+  
+  pPiste = NULL;
+  LastBlockSSTNb = -2;
+  noStarDet = 0;
+  
+  findStarConstruct();
+  
+}
+
+SSTHandler::SSTHandler(SSTHandler const& x) 
+:sstchass("SSTChassLogFile")
 {
   diodeHistLength = x.diodeHistLength;
@@ -43 +51 @@
   memcpy(diodeT, x.diodeT, diodeHistLength*nb_photo_diodes);
   starHistLength = x.starHistLength;
-  stars = new (vector<star>[starHistLength]);
-  for (int i=0; i<starHistLength; i++)
-    stars[i] = x.stars[i];
+    
+  prcTodo    = x.prcTodo;
+ // has2bars   = x.has2bars;
+  lastBlkNum = x.lastBlkNum;
+  
+  pPiste = NULL;
+  LastBlockSSTNb = x.LastBlockSSTNb;
+  noStarDet = x.noStarDet;
+
+  findStarConstruct();
+  for(int i=0; i<NbPhotDiodBarette; i++) {
+        *PisteBar[i]=*(x.PisteBar[i]);
+  }
+}
+
+SSTHandler& SSTHandler::operator = (SSTHandler const& x) {
+  delete[] diodeT; 
+  diodeHistLength = x.diodeHistLength;
+  diodeT = new int[diodeHistLength*nb_photo_diodes];
+  memcpy(diodeT, x.diodeT, diodeHistLength*nb_photo_diodes);
     
   prcTodo    = x.prcTodo;
@@ -51 +76 @@
  // elecOffset = x.elecOffset;
   lastBlkNum = x.lastBlkNum;
-  seuil      = x.seuil;
-}
-
-SSTHandler& SSTHandler::operator = (SSTHandler const& x) {
-  delete[] stars;
-  delete[] diodeT; 
-  diodeHistLength = x.diodeHistLength;
-  diodeT = new int[diodeHistLength*nb_photo_diodes];
-  memcpy(diodeT, x.diodeT, diodeHistLength*nb_photo_diodes);
-  starHistLength = x.starHistLength;
-  stars = new (vector<star>[starHistLength]);
-  for (int i=0; i<starHistLength; i++)
-    stars[i] = x.stars[i];
-    
-  prcTodo    = x.prcTodo;
- // has2bars   = x.has2bars;
- // elecOffset = x.elecOffset;
-  lastBlkNum = x.lastBlkNum;
-  seuil      = x.seuil;
-  
+  for(int i=0; i<NbPhotDiodBarette; i++) *PisteBar[i]=*(x.PisteBar[i]);
   return *this;
 }
 
-SSTHandler::~SSTHandler()
-{
-  delete[] stars;
+SSTHandler::~SSTHandler(){
   delete[] diodeT;
+  findStarDestruct();
 }
 
@@ -85 +90 @@
   if (prcTodo & findAxis)   prcTodo |= findPeriod;
   if (prcTodo & findPeriod) prcTodo |= findStars;
-  if (prcTodo & findStars)  prcTodo |= rmveOffset;
+  if (prcTodo & findStars)  prcTodo |= permDiode;
 }
 
@@ -96 +101 @@
   elecOffset = eo;
 }
-
-void SSTHandler::ProcessBlock(block_type_sst* blk)
-{
-  lastBlkNum = numero_block(blk);
-  for (int i = 0; i<nb_per_block*2; i++) {
-    DecodeTMBlock(blk, i, diodeRaw[i]);
-  }
-  if (prcTodo & rmveOffset) {
-    RemoveOffset();
-  }
-  if (prcTodo & findStars) {
-    FindStars();
-  }
-}
-
 
 void SSTHandler::DecodeTMBlock(block_type_sst* blk, int i, int* diod)
@@ -139 +129 @@
 
 
-void SSTHandler::RemoveOffset()
+void SSTHandler::PermutDiode()
 {
   int j0 = diodeHistLength-(nb_per_block*2);
@@ -187 +177 @@
 }
 
-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);
-          }
-        }
-      }
-    }
-  }
-
-
-}
+int SSTHandler::FindStars(block_type_sst* blk) {
+        NbStarInBlock=0;
+        LastBlockStarVec.clear();
+        
+        int NoFirstSpInBlock=FirstSplNb(blk);
+        int jd0 = diodeHistLength-NbSampleBlock;
+
+        bool FlagLBlockPerdu=false;
+        int ThisBlockNumb=numero_block(blk);
+        
+        if ((LastBlockSSTNb+1)==ThisBlockNumb) LastBlockSSTNb++;
+        else {
+                FlagLBlockPerdu=true;
+                LastBlockSSTNb=ThisBlockNumb;
+        }
+
+//      On cherche les etoiles  
+        for(int NoDiode=0;NoDiode<NbPhotDiodBarette; NoDiode++) {       
+                pPiste=PisteBar[NoDiode];
+                
+        // Traitons une diode pendant un block
+                offseDataDiod=0;
+                for (int i=0; i<NbSampleBlock; i++) Diodedata[i]=diode(jd0+i,NoDiode);
+
+                if (FlagLBlockPerdu)  {
+                        pPiste->fill(Diodedata+offseDataDiod,FirstSplNb(blk));
+                        offseDataDiod+=PhDiodTabLong;
+                }
+                else {
+                        pPiste->push(Diodedata);
+                        offseDataDiod+=Pousslong;
+                }
+                
+        // Recherchons les etoiles
+                while (true) {
+                        if (pPiste->traque()) {                         // On a trouve!
+                                LastStar=pPiste->DonneEtoile();
+/*                              double dum= LastStar.TEchan;
+                                pair<const double, SSTEtoile> unepaire=make_pair(dum,LastStar);
+                                StarHistoryMap.insert(unepaire);        
+*/
+                                StarHistoryMap[LastStar.TEchan]=LastStar;
+                                        //On empile sur la map.
+                                NbStarInBlock++;
+#ifdef SST_DEBUG                        
+                        // On écrit les pistes ayant déclénchées
+                                int NoDiodeEvt=LastStar.NoDiode;
+                                if(pPisteDump[NoDiodeEvt]->is_open())   
+                                        for(int noSamp=0; noSamp<NbSampleBlock;noSamp++)
+                                                (*pPisteDump[NoDiodeEvt])<<noStarDet<<'\t'<<NoDiode<<'\t'<<NoFirstSpInBlock+noSamp<<'\t'<<Diodedata[noSamp]<<endl;
+#endif
+                                noStarDet++;
+                        }
+                // Est-on en bout de Piste?
+                        if(offseDataDiod+Pousslong>=NbSampleBlock) break;
+                        else {
+                                pPiste->push(Diodedata+offseDataDiod);
+                                offseDataDiod+=Pousslong;
+                        }
+                }
+        }
+        
+//      On ne garde que les NbEtInSetMax dernières étoiles
+        int nbEtoileInMap=StarHistoryMap.size();
+        if(nbEtoileInMap>NbEtInMapMax) {
+                int nbErase=nbEtoileInMap-NbEtInMapMax;
+                StarHistIter StarIter=StarHistoryMap.begin();
+                for(int i=0;i<nbErase;i++){
+                        StarHistoryMap.erase(StarIter);
+                        StarIter++;
+                }
+                nbEtoileInMap-=nbErase;
+        }                       
+        
+//      On stocke les etoiles du block dans LastBlockStarVec
+        map<double,SSTEtoile>::reverse_iterator StarHistReIter= StarHistoryMap.rbegin() ;
+        for(int i=0; i<NbStarInBlock; i++, StarHistReIter++) 
+                LastBlockStarVec.push_back((*StarHistReIter).second);
+        
+//#ifdef SST_DEBUG
+        if(NbStarInBlock>0) {
+                        
+        // On écrit les étoiles detectées
+                vector<SSTEtoile>::reverse_iterator StarVecRevIter;
+                StarVecRevIter=LastBlockStarVec.rbegin();
+                for(int i=0; i<NbStarInBlock;i++,StarVecRevIter++) 
+                        (*StarVecRevIter).print(sstchass);
+        }
+                
+//#endif
+
+        return NbStarInBlock;
+}
+
+void SSTHandler::findStarConstruct() {
+        PisteBar=new PisteEtoile*[NbPhotDiodBarette];
+        for(int i=0; i<NbPhotDiodBarette; i++) PisteBar[i]=new PisteEtoile(i);
+        StarHistoryMap.clear();
+        sstchass<<LastStar.printHeader()<<endl;
+        
+#ifdef SST_DEBUG        
+        char s[32];
+        string fileName;
+//      if(pPisteDump==NULL)
+                pPisteDump= new ofstream* [NbChanDump];
+        
+        for (int pistNumb=0; pistNumb<NbChanDump; pistNumb++) {
+                sprintf(s,"%i", pistNumb);      
+                string piste=s;
+                fileName="pisteno"+piste+"dump";
+/*              
+                if ((*pPisteDump[pistNumb]).is_open()) {
+                        cerr<<"Erreur: le fichier "<<fileName<<" devrait être libre"<<endl;
+                                //On libère
+                        (*pPisteDump[pistNumb]).close();
+                        delete pPisteDump[pistNumb];
+                }
+*/                      
+                pPisteDump[pistNumb]=new ofstream(fileName.c_str(),ios::out|ios::trunc);
+                
+                if(!(*pPisteDump[pistNumb]).is_open()) {
+                        cerr<<"Warning Echec à l'ouverture du fichier: "<<fileName<<endl;
+                }
+        }
+#endif
+        return;
+}
+
+void SSTHandler::findStarDestruct() {
+        for(int i=0; i<NbPhotDiodBarette; i++) {
+                delete PisteBar[i];
+        }
+        delete[] PisteBar;
+                
+#ifdef SST_DEBUG        
+        for (int pistNumb=0; pistNumb<NbChanDump; pistNumb++) {
+                pPisteDump[pistNumb]->close();
+                delete pPisteDump[pistNumb];
+        }
+        delete  pPisteDump;
+#endif
+
+        return;
+}
+
+int SSTHandler::getNumbStar(int iSampl) {
+        StarHistIter IterLow=StarHistoryMap.lower_bound((double)iSampl);
+        StarHistIter IterHigh=StarHistoryMap.upper_bound((double)(iSampl+1.));
+        int Compteur=0;
+        while (!(IterLow==IterHigh)) {IterLow++; Compteur++;}
+        return Compteur;
+}
+
+double SSTHandler::getStarF(int iSampl, int istar){ 
+        if( (getNumbStar(iSampl)==0)||(getNumbStar(iSampl)<istar)) return -1;
+        else {
+                StarHistIter IterLow=StarHistoryMap.lower_bound((double)iSampl);
+                while(!(istar==0)) {
+                        IterLow++;
+                        istar--;
+                }
+        return (double) ((*IterLow).second).InpCurrent;
+        }
+}
+
+
+int SSTHandler::getStarZ(int iSampl, int istar) {
+        if( (getNumbStar(iSampl)==0)||(getNumbStar(iSampl)<istar)) return -1;
+        StarHistIter IterLow=StarHistoryMap.lower_bound((double)iSampl);
+        while(!(istar==0)) {
+                IterLow++;
+                istar--;
+        }
+        return ((*IterLow).second).NoDiode;
+}
+
+double SSTHandler::getStarTime(int iSampl, int istar) {
+        if( (getNumbStar(iSampl)==0)||(getNumbStar(iSampl)<istar)) return -1;
+        StarHistIter IterLow=StarHistoryMap.lower_bound((double)iSampl);
+        while(!(istar==0)) {
+                IterLow++;
+                istar--;
+        }
+        return ((*IterLow).second).TEchan;
+}
+
+int SSTHandler::FirstSplNb(block_type_sst* blk){
+        return NbSampleBlock*numero_block(blk); // BUGG A verifier
+}
+
+
+void SSTHandler::ProcessBlock(block_type_sst* blk)
+{
+  lastBlkNum = numero_block(blk);
+  for (int i = 0; i<nb_per_block*2; i++) {
+    DecodeTMBlock(blk, i, diodeRaw[i]);
+  }
+  if (prcTodo & permDiode) {
+    PermutDiode();
+  }
+  if (prcTodo & findStars) {
+    FindStars(blk);
+  }
+}
+

trunk/Poubelle/archTOI.old/ssthandler.h

@@ -5 +5 @@
 #define SSTHANDLER_H
 
+#include <math.h>
 #include <vector>
+#include <map>
 
 #ifndef nb_max_bolo
@@ -15 +17 @@
 #endif
 
+class ArcheopsFile;
+
+// Zone findStar
+#include "sstetoile.h"
+#include "pisteetoile.h"
+
+//#define SST_DEBUG
+#define NbChanDump (10)
+#define NbPhotDiodBarette (46)
+#define NbEtInMapMax    (100)
+#define SSTChassLog (true)
+#define NbSampleBlock (2*nb_per_block)
+// Fin Zone findStar
 
 class SSTHandler {
@@ -23 +38 @@
   virtual ~SSTHandler();
   
-  enum process { rmveOffset = 1, 
+  enum process { permDiode = 1, 
          findStars  = 2,
          findPeriod = 4,
@@ -33 +48 @@
   static void Has2Bars(bool, int elecOffset=0); // elecOffset : which wired together
   
+  long getLastBlkNum() {return lastBlkNum;}
   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;}
+        
+        //      Zone findStar 
+  int  getNumbStar(int iSampl); 
+                        // return number of star found in sample number iSampl  
+  int  getStarZ(int iSampl, int istar); 
+                        // return diode number of the star     
+  double getStarF(int iSampl, int istar);  
+                        // return star flux in Ampère
+  double getStarTime(int iSampl, int istar); 
+                        // return star time in this sample
 
 protected:
@@ -46 +69 @@
   int   starHistLength;
   long  lastBlkNum;
-  int   seuil;
   
+        // Is there two photoDiod Arrays and how are they connected?
   static bool  has2bars;
   static int   elecOffset;
@@ -53 +76 @@
   inline int& diode(int iSamp, int iDiod) {return diodeT[iSamp*nb_photo_diodes+iDiod];}
   
-  struct star {
-    float z;
-    float m;
-    double t;
-  };
-
-  vector<star>* stars;
-  
+  static int  diodpermut[46]; // diodpermut[i] = channel de la diode i
   
   void DecodeTMBlock(block_type_sst*, int i, int* diodes); // mesure i -> diodes
-  void RemoveOffset(); // diodeRaw -> diode, avec decalage, 1 echantillon.
-  void FindStars(); // sur les 72 derniers echantillons dans diode.
+  void PermutDiode(); // diodeRaw -> diode, avec decalage, 1 echantillon.
+  int FindStars(block_type_sst* blk);           // sur les 72 derniers echantillons dans diode.
+                                                // return nmber of star found in last block
   
-  static int  diodpermut[46]; // diodpermut[i] = channel de la diode i
+        //      Zone findStar
+  int NbStarInBlock;
+
+  PisteEtoile** PisteBar; 
+        
+#ifdef SST_DEBUG
+        ofstream** pPisteDump;
+#endif
+
+  map<double,SSTEtoile> StarHistoryMap; 
+                // On stocke les etoiles de manière ordonnée en temps
+  typedef  map<double,SSTEtoile>::iterator StarHistIter;
+  typedef  map<double,SSTEtoile>::const_iterator StarConstHistIter;
+  
+  vector<SSTEtoile> LastBlockStarVec;   
+                // Vecteur des SSTEtoile du block classees en ordre de temps decroissant.
+  //vector<SSTEtoile> reverse_iterator StarVecRevIter LastBlockStarVec.rbegin();
+  SSTEtoile LastStar;
+  PisteEtoile* pPiste;          // Piste courante d'analyse
+  int Diodedata[NbSampleBlock];
+  int offseDataDiod;
+  int LastBlockSSTNb; // Gère la disparition des blocs défectueux
+  int noStarDet;
+  int FirstSplNb(block_type_sst* blk); // Calcule l'index du premier echantillon du block analysé
+  ofstream sstchass;
+  
+  void findStarConstruct();
+  void findStarDestruct();
 };
 

trunk/Poubelle/archTOI.old/toiiter.cc

@@ -5 +5 @@
 #include "toiiter.h"
 #include "toiinterpolator.h"
+#include "archparam.h"
 #include <dirent.h>
 #include <iostream.h>
@@ -27 +28 @@
  tEnd   = 9.e99;
  
- tBlock0 = -1;
- perEch = -1;
+ //tBlock0 = -1;
+ // perEch = -1;
  // Values for Trapani 99 = default values
- tBlock0 = 1376.8358818;
- perEch = 0.005836818076;
+ //tBlock0 = 1376.8358818;
+ //perEch = 0.005836818076;
  
  trigMask = 0;
@@ -53 +54 @@
   tStart = x.tStart;
   tEnd = x.tEnd;
-  tBlock0 = x.tBlock0;
-  perEch = x.perEch;
+  //tBlock0 = x.tBlock0;
+  //perEch = x.perEch;
   trigMask = x.trigMask;
   infos = x.infos;   
@@ -180 +181 @@
   // peu plus de details sur la facon dont le GPS est lu.
   
-  if (tBlock0 < 0) {
-    tBlock0 = file->getStartMJD();
+  if (archParam.acq.tBlock0 < 0) {
+    archParam.acq.tBlock0 = file->getStartMJD();
 
     file->pushMark();
@@ -187 +188 @@
       // le temps du bloc courant, en secondes
       double dt = file->blockNum() * file->perBlock();
-      tBlock0 = file->getGPSMJD() - dt/86400.;
+      archParam.acq.tBlock0 = file->getGPSMJD() - dt/86400.;
     } else { // pas de bloc GPS...
-      tBlock0 = file->getStartMJD();
+      archParam.acq.tBlock0 = file->getStartMJD();
     }
     file->popMark();
@@ -195 +196 @@
   tStart = oldTStart;  // on restaure
   
-  if (perEch < 0)
-    perEch = file->perEchant();
+  if (archParam.acq.perEch < 0)
+    archParam.acq.perEch = file->perEchant();
 
   bool hasInterp = false;
@@ -221 +222 @@
         case sstStarZ:
         case sstStarF:
+        case sstStarT:
           file->needSSTProcessMask(SSTHandler::findStars);
           trigMask |= block_sst_mask;
           break;
         case sstDiode:
-          file->needSSTProcessMask(SSTHandler::rmveOffset);
+          file->needSSTProcessMask(SSTHandler::permDiode);
           trigMask |= block_sst_mask;
           break;
@@ -284 +286 @@
   for (set<string>::iterator i = copy.begin(); i != copy.end(); i++) {
     double smp = file1stSamp[*i];
-    double t   = tBlock0 + smp * perEch/86400.;
+    double t   = archParam.acq.tBlock0 + smp * archParam.acq.perEch/86400.;
     if (t>tEnd) {  // premier echantillon apres tEnd
      files.erase(*i);
@@ -416 +418 @@
      case sstStarZ:
      case sstStarF:
-       return (file->lastSST() != NULL) && (file->getSSTStarZ(index, imes) >= 0);
+     case sstStarT:{
+       if (file->lastSST() == NULL) return false;
+       int n = file->getNumbStar(imes);
+       return (n > 0 && imes < n);
+       }
      case gyroRaw:
        return (file->lastGyro() != NULL);
@@ -472 +478 @@
        return getSampleIndex();
      case internalTime:
-       return getSampleIndex() * perEch;
+       return getSampleIndex() * archParam.acq.perEch;
      case mjd:
        return getMJD();
@@ -487 +493 @@
      case sstStarF:
        return file->getSSTStarF(index, imes);
+     case sstStarT:
+       return file->getSSTStarT(index, imes);
      case gyroRaw:
        return file->getGyro(index, imes);
@@ -535 +543 @@
      case sstStarZ:
      case sstStarF:
+     case sstStarT:
        return file->blockNum() == file->getSSTBlockNum();
      case gyroRaw:
@@ -616 +625 @@
   if (!initDone) Init();
   int sample = getSampleIndex();
-  return tBlock0 + sample*perEch/86400.;
+  return archParam.acq.tBlock0 + sample*archParam.acq.perEch/86400.;
 }
  

trunk/Poubelle/archTOI.old/toiiter.h

@@ -25 +25 @@
   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
+  sstStarT,   // temps 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
@@ -101 +102 @@
    double tStart, tEnd;
    
-   double tBlock0;  // MJD du bloc numero zero...
-   double perEch;   // periode d''echantillonage en secondes
+   //double tBlock0;  // MJD du bloc numero zero...
+   //double perEch;   // periode d''echantillonage en secondes
    
    struct info {

trunk/Poubelle/archTOI.old/toisvr.cc

@@ -21 +21 @@
 }
 
-
-void TOISvr::SetMJD0(double t0) {
-  iter.tBlock0 = t0;
-}
-
-void TOISvr::SetPerEch(double t0) { // en secondes, periode d'echantillonnage
-  iter.perEch = t0;
-}
 
 void TOISvr::OnBoardRecorderFiles(bool x) {

trunk/Poubelle/archTOI.old/toisvr.h

@@ -17 +17 @@
   void AddFile(string);
   void OnBoardRecorderFiles(bool);
-  void SetMJD0(double);
-  void SetPerEch(double);
   void UseAuxGPS(AuxGPS* gps);