Index: trunk/FrEROS/AnaLC/Makefile
===================================================================
--- trunk/FrEROS/AnaLC/Makefile	(revision 3308)
+++ trunk/FrEROS/AnaLC/Makefile	(revision 3308)
@@ -0,0 +1,219 @@
+#########################################################################
+## Makefile to build EROS suivi (light-curves) files reading programs 
+## These programs are linked with SOPHYA library (www.sophya.org)
+## SOPHYABASE environment variable should be defined    
+## AND  define the ANALCPATH  here 
+##         C. Magneville - R. Ansari  July 2007 
+#########################################################################
+include $(SOPHYABASE)/include/sophyamake.inc
+
+OBJ = ${ANALCPATH}/obj/
+EXE = ${ANALCPATH}/exe/
+LIB = ${ANALCPATH}/lib/
+
+#  template instanciation repository for OSF1-cxx
+CXXREP = -ptr $(OBJ)AnaLC_cxxrep/
+
+
+
+FSVLIBLIST = $(OBJ)fsvcache.o $(OBJ)filecache.o $(OBJ)fsvst.o $(OBJ)transfost.o \
+             $(OBJ)convlim.o  $(OBJ)nomfits.o  $(OBJ)nomfits2.o
+
+FSVLIBLISTXX = $(OBJ)lcproc.o 
+
+FSVINCLIST = convlim.h filecache.h fsvcache.h fsvst.h lcproc.h \
+             nomfits2.h nomfits.h swapbytes.h transfost.h
+
+
+NBSLIBLIST = $(OBJ)nbgene.o $(OBJ)filtccd.o $(OBJ)courbe_nb.o
+
+NBSINCLIST = $(FSVINCLIST) nbsread.h nbgene.h filtccd.h courbe_nb.h
+
+all : lib anafsv checkfsv chkfsv exeuser
+
+lib : fsvlib nbslib
+
+exeuser : nbsread_squel nbsread_ppf nbsread_base nbsread_bosse nbsread_db \
+          nbsread_stlist
+
+clean : cleanobj cleanlib cleanexe
+	echo 'Done: clean'
+
+cleanobj :
+	rm -rf $(OBJ)AnaLC_cxxrep/
+	rm -f $(FSVLIBLIST) $(FSVLIBLISTXX)
+	rm -f $(NBSLIBLIST) $(OBJ)nbsread.o
+
+cleanexe :
+	rm -f $(OBJ)anafsv.o           $(EXE)anafsv
+	rm -f $(OBJ)checkfsv.o         $(EXE)checkfsv
+	rm -f $(OBJ)chkfsv.o           $(EXE)chkfsv
+	rm -f $(OBJ)nbsreadu_squel.o   $(EXE)nbsread_squel
+	rm -f $(OBJ)nbsreadu_ppf.o     $(EXE)nbsread_ppf
+	rm -f $(OBJ)nbsreadu_base.o    $(EXE)nbsread_base
+	rm -f $(OBJ)nbsreadu_bosse.o   $(EXE)nbsread_bosse
+	rm -f $(OBJ)nbsreadu_db.o      $(EXE)nbsread_db
+	rm -f $(OBJ)nbsreadu_stlist.o  $(EXE)nbsread_stlist
+
+cleanlib :
+	rm -f $(LIB)libfsv.a
+	rm -f $(LIB)libfsv++.a
+	rm -f $(LIB)libnbs.a
+
+depend :
+	mkdir $(OBJ)
+	mkdir $(EXE)
+	mkdir $(LIB)
+
+########################
+fsvlib :  $(LIB)libfsv.a $(LIB)libfsv++.a
+	echo 'Done: libfsv.a libfsv++.a'
+
+$(LIB)libfsv.a : $(FSVLIBLIST)
+	$(AR) $(ARFLAGS) $@ $? 
+
+$(OBJ)fsvcache.o : fsvcache.c  $(FSVINCLIST) 
+	$(CCOMPILE) -o $(OBJ)fsvcache.o  fsvcache.c
+
+$(OBJ)filecache.o : filecache.c  $(FSVINCLIST) 
+	$(CCOMPILE) -o $(OBJ)filecache.o  filecache.c
+
+$(OBJ)fsvst.o : fsvst.c  $(FSVINCLIST) 
+	$(CCOMPILE) -o $(OBJ)fsvst.o  fsvst.c
+
+$(OBJ)transfost.o : transfost.c  $(FSVINCLIST) 
+	$(CCOMPILE) -o $(OBJ)transfost.o  transfost.c
+
+$(OBJ)convlim.o : convlim.c  $(FSVINCLIST) 
+	$(CCOMPILE) -o $(OBJ)convlim.o  convlim.c
+
+$(OBJ)nomfits.o : nomfits.c  $(FSVINCLIST) 
+	$(CCOMPILE) -o $(OBJ)nomfits.o  nomfits.c
+
+$(OBJ)nomfits2.o : nomfits2.c  $(FSVINCLIST) 
+	$(CCOMPILE) -o $(OBJ)nomfits2.o  nomfits2.c
+
+
+$(LIB)libfsv++.a : $(FSVLIBLISTXX)
+	$(AR) $(ARFLAGS) $@ $? 
+
+$(OBJ)lcproc.o : lcproc.cc  $(FSVINCLIST) lcproc.h
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)lcproc.o  lcproc.cc
+
+########################
+nbslib :  $(LIB)libnbs.a $(OBJ)nbsread.o
+	echo 'Done: libnbs.a'
+
+$(LIB)libnbs.a : $(NBSLIBLIST)
+	$(AR) $(ARFLAGS) $@ $? 
+
+$(OBJ)nbgene.o : nbgene.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbgene.o nbgene.cc
+
+$(OBJ)filtccd.o : filtccd.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)filtccd.o filtccd.cc
+
+$(OBJ)courbe_nb.o : courbe_nb.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)courbe_nb.o courbe_nb.cc
+
+########################
+$(OBJ)nbsread.o : nbsread.cc nbsread.h $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbsread.o  nbsread.cc
+
+########################
+#------------------------------
+anafsv : $(EXE)anafsv
+	echo 'Done: anafsv'
+
+$(EXE)anafsv : $(OBJ)anafsv.o $(LIB)libfsv.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)anafsv $(OBJ)anafsv.o $(LIB)libfsv.a $(LIB)libfsv++.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)anafsv.o : anafsv.cc  $(FSVINCLIST) lcproc.h
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)anafsv.o  anafsv.cc
+
+#------------------------------
+checkfsv : $(EXE)checkfsv
+	echo 'Done: checkfsv'
+
+$(EXE)checkfsv : $(OBJ)checkfsv.o $(LIB)libfsv.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)checkfsv $(OBJ)checkfsv.o $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)checkfsv.o : checkfsv.cc  $(FSVINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)checkfsv.o  checkfsv.cc
+
+#------------------------------
+chkfsv : $(EXE)chkfsv
+	echo 'Done: chkfsv'
+
+$(EXE)chkfsv : $(OBJ)chkfsv.o $(LIB)libfsv.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)chkfsv $(OBJ)chkfsv.o $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)chkfsv.o : chkfsv.cc  $(FSVINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)chkfsv.o  chkfsv.cc
+
+################################################
+#------------------------------
+nbsread_squel : $(EXE)nbsread_squel
+	echo 'done: nbsread_squel'
+
+$(EXE)nbsread_squel : $(OBJ)nbsreadu_squel.o $(OBJ)nbsread.o $(LIB)libfsv.a $(LIB)libnbs.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)nbsread_squel $(OBJ)nbsread.o $(OBJ)nbsreadu_squel.o \
+                      $(LIB)libnbs.a $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)nbsreadu_squel.o : nbsreadu_squel.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbsreadu_squel.o  nbsreadu_squel.cc
+
+#------------------------------
+nbsread_ppf : $(EXE)nbsread_ppf
+	echo 'done: nbsread_ppf'
+
+$(EXE)nbsread_ppf : $(OBJ)nbsreadu_ppf.o $(OBJ)nbsread.o $(LIB)libfsv.a $(LIB)libnbs.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)nbsread_ppf $(OBJ)nbsread.o $(OBJ)nbsreadu_ppf.o \
+                      $(LIB)libnbs.a $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)nbsreadu_ppf.o : nbsreadu_ppf.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbsreadu_ppf.o  nbsreadu_ppf.cc
+
+#------------------------------
+nbsread_base : $(EXE)nbsread_base
+	echo 'done: nbsread_base'
+
+$(EXE)nbsread_base : $(OBJ)nbsreadu_base.o $(OBJ)nbsread.o $(LIB)libfsv.a $(LIB)libnbs.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)nbsread_base $(OBJ)nbsread.o $(OBJ)nbsreadu_base.o \
+                      $(LIB)libnbs.a $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)nbsreadu_base.o : nbsreadu_base.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbsreadu_base.o  nbsreadu_base.cc
+
+#------------------------------
+nbsread_bosse : $(EXE)nbsread_bosse
+	echo 'done: nbsread_bosse'
+
+$(EXE)nbsread_bosse : $(OBJ)nbsreadu_bosse.o $(OBJ)nbsread.o $(LIB)libfsv.a $(LIB)libnbs.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)nbsread_bosse $(OBJ)nbsread.o $(OBJ)nbsreadu_bosse.o \
+                      $(LIB)libnbs.a $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)nbsreadu_bosse.o : nbsreadu_bosse.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbsreadu_bosse.o  nbsreadu_bosse.cc
+
+#------------------------------
+nbsread_db : $(EXE)nbsread_db
+	echo 'done: nbsread_db'
+
+$(EXE)nbsread_db : $(OBJ)nbsreadu_db.o $(OBJ)nbsread.o $(LIB)libfsv.a $(LIB)libnbs.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)nbsread_db $(OBJ)nbsread.o $(OBJ)nbsreadu_db.o \
+                      $(LIB)libnbs.a $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)nbsreadu_db.o : nbsreadu_db.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbsreadu_db.o  nbsreadu_db.cc
+
+#------------------------------
+nbsread_stlist : $(EXE)nbsread_stlist
+	echo 'done: nbsread_stlist'
+
+$(EXE)nbsread_stlist : $(OBJ)nbsreadu_stlist.o $(OBJ)nbsread.o $(LIB)libfsv.a $(LIB)libnbs.a
+	$(CXXLINK) $(CXXREP) -o $(EXE)nbsread_stlist $(OBJ)nbsread.o $(OBJ)nbsreadu_stlist.o \
+                      $(LIB)libnbs.a $(LIB)libfsv.a $(SOPHYAEXTSLBLIST)
+
+$(OBJ)nbsreadu_stlist.o : nbsreadu_stlist.cc $(NBSINCLIST)
+	$(CXXCOMPILE) $(CXXREP) -o $(OBJ)nbsreadu_stlist.o  nbsreadu_stlist.cc
Index: trunk/FrEROS/AnaLC/README
===================================================================
--- trunk/FrEROS/AnaLC/README	(revision 3308)
+++ trunk/FrEROS/AnaLC/README	(revision 3308)
@@ -0,0 +1,42 @@
+####################################################################
+##  EROS suivi (light-curve) reading programs with SOPHYA 
+##  (C) LAL-IN2P3/CNRS   (C) DAPNIA-SPP/CEA
+##  C. Magneville - R. Ansari    July 2007 
+####################################################################
+
+This module contains program files extracted from the EROS/PEIDA software
+and adapted to be compiled with SOPHYA (http://www.sophya.org) library 
+
+>> See http://eros.in2p3.fr 
+   follow the link to Peida or directly 
+      http://eros.web.lal.in2p3.fr/PeidaDoc/index.html
+  for a detailed description of suivi file format and EROS 
+  light curves
+    
+A/ Contents : 
+  - The EROS suivi (lightcurve) files management library : 
+     libfsv.a 
+  - Program to read a single suivi file : 
+     anafsv checkfsv chkfsv 
+  - A simple lightcurve processing class :
+    lcproc.cc -> libfsv++.a
+  - a c++ function library to analyse light-curves :
+    libnbs.a 
+  - Program to read mutiple suivi files (and multiple colors=filters) :
+     nbsread_* 
+  - An example input datacard for nbsread programs :
+     nbsread.dataccd.Exemple
+
+B/ Build :
+  B.1/ 
+  - You need to have SOPHYA library intslled (see www.sophya.org)
+  - SOPHYABASE environment variable should be defined  
+  - AND define the ANALCPATH to point to a write-accessible 
+    directory 
+  
+  B.2/  
+  # To create /obj /lib /exe in $ANALCPATH
+  csh> make depend   
+  # To build libraries and executables 
+  csh> make all 
+  
Index: trunk/FrEROS/AnaLC/anafsv.cc
===================================================================
--- trunk/FrEROS/AnaLC/anafsv.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/anafsv.cc	(revision 3308)
@@ -0,0 +1,783 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <math.h>
+#include <iostream>
+#include <typeinfo>
+
+#include "machdefs.h"
+
+#include "fmath.h"
+
+#include "fsvcache.h"
+#include "timing.h"
+
+#include "fsvst.h"
+
+#include "pexceptions.h"  // SOPHYA Exceptions
+
+#include "histats.h"  // SOPHYA HiStats module include files
+#include "sopnamsp.h"  // using SOPHYA namespace
+
+#include "machdefs.h"
+
+#include "tvector.h"
+#include "srandgen.h"
+#include "fioarr.h"
+#include "sopemtx.h"
+#include "pexceptions.h"
+#include "matharr.h"
+
+#include "sambainit.h"
+
+#include "lcproc.h"  // declaration of LightCurveProc class
+
+
+DataTable  dtclum(int numet, int nmes, TIMEINFO *tminf, MESUREU *mesu);
+DataTable dttimeinfo(int nmes, TIMEINFO *tminf);
+DataTable createdtmes(int nmes); 
+void dtmes(DataTable& dtmes, int nmes, STARINFO *sti, MESUREU *mesu);
+
+
+struct resolution
+  {
+  int nbin;
+  float xmin, xmax, dxbin;
+  int *nst, *nstr;
+  float *fmoy, *fmoyr;
+  float *dflx, *sflx, *dflxe, *sflxe;
+  };
+
+typedef struct resolution  SRESOL;
+
+
+SRESOL *resolinit(int nmes, int nbin, float xmin, float xmax);
+int resolst(SRESOL *sres, int nmes, STARINFO *sti, MESUREU *mesu);
+int resolend(SRESOL *sres, int nmes);
+
+
+
+
+/* ------------------------------------------------------------------- */
+
+
+
+char *Pgnm = "hanafsv";
+
+int main(int narg, char *arg[] )
+{
+char strg[128],*svf;
+SUIVIFIP *sfip;
+int numes1,numes2;
+int numet1, numet2, incn;
+float xmin, xmax;
+float ymin, ymax;
+
+int i,k,jt,rc,dnp,fgq;
+int  nbstar,nbmes;
+int nstar, nmes;
+
+int prtl,prfg,clfg,ntfg;
+
+int nbin;
+float minlog,maxlog;
+
+
+GLOBINFO glinf;
+STARINFO  star;
+TIMEINFO *tminf, *tmi;
+
+TIMEINFOU *tminu;
+MESURE *mes;
+MESUREU *mesu;
+
+double *TStart;
+
+SRESOL *sres;
+
+/* ...................................................  */
+
+InitTim();
+
+if (narg > 1)
+ if (strcmp(arg[1],"-h") == 0) 
+    {
+    printf("Usage: %s [-Flag] NomSuivi\n",Pgnm);
+    puts  ("  -inq : Marque une pause apres lecture TimeInfo ");
+    puts  ("  -act prfg,clfg,ntfg : Flags de controle ");
+    puts  ("  -prt prtl : Niveau d'impression (0->3)");
+    puts  ("  -his nbin,MinLog,MaxLog : Binning histo resolution");
+    puts  ("  -mes m1-m2 : Traitement des mesures m1 a m2 ");
+    puts  ("  -numet n1-n2,incn : Traitement des etoiles n1 a n2 (C1)");
+    puts  ("  -xpos min-max : Coupure min <= XPosEtoile <= max (C2)");
+    puts  ("  -ypos min-max : Coupure min <= YPosEtoile <= max (C3)");
+    puts  ("  On fait C1 & C2 & C3, Valeur par defaut = Tout");
+    puts  ("  prfg (PrintFlag) : 0 , 1= Glob+TimeInfo"); 
+    puts  ("     2= +StarInfo, 3= +MesuresU (=default), 4= +Mesures");
+    puts  ("  clfg (Flag Courbe de lumiere) : 0(=defaut),1"); 
+    puts  ("  ntfg (Bits Flag Ntuple): B0(=defaut) TimeInfo, B1 Resol, B2 Mesures\n"); 
+    return(0);
+    }
+
+/*    Decodage des arguments   */
+numes1 = 1;  numes2 = 9999999;
+numet1 = 1;  numet2 = 9999999;  incn = 1;
+xmin = -9.e19;  xmax = 9.e19;
+ymin = -9.e19;  ymax = 9.e19;
+prtl = 0;  prfg = 3;
+clfg = 0;  ntfg = 1;
+nbin = 30;
+minlog = 2.0;  maxlog = 5.0;
+fgq = 0;   /* On continue jusqu'au bout par defaut */
+
+if (narg < 2) goto PbArg;
+k = 1;
+while (*(arg[k]) == '-')      
+  {
+  if ( strcmp(arg[k],"-inq") == 0)  fgq = 1;
+  else if ( strcmp(arg[k],"-mes") == 0)
+    { if (k == narg-1)  goto PbArg;
+    sscanf(arg[k+1],"%d-%d",&numes1,&numes2);   k++; }
+  else if ( strcmp(arg[k],"-numet") == 0)
+    { if (k == narg-1)  goto PbArg;
+    sscanf(arg[k+1],"%d-%d,%d",&numet1,&numet2,&incn);   k++; }
+  else if ( strcmp(arg[k],"-xpos") == 0)
+    { if (k == narg-1)  goto PbArg;
+    sscanf(arg[k+1],"%g-%g",&xmin,&xmax);   k++; }
+  else if ( strcmp(arg[k],"-ypos") == 0)
+    { if (k == narg-1)  goto PbArg;
+    sscanf(arg[k+1],"%g-%g",&ymin,&ymax);   k++; }
+  else if ( strcmp(arg[k],"-prt") == 0)
+    { if (k == narg-1)  goto PbArg;
+    sscanf(arg[k+1],"%d",&prtl);   k++; }
+  else if ( strcmp(arg[k],"-act") == 0)
+    { if (k == narg-1)  goto PbArg;
+    sscanf(arg[k+1],"%d,%d,%d",&prfg,&clfg,&ntfg);   k++; }
+  else if ( strcmp(arg[k],"-his") == 0)
+    { if (k == narg-1)  goto PbArg;
+    sscanf(arg[k+1],"%d,%g,%g",&nbin,&minlog,&maxlog);   k++; }
+
+  if (++k >= narg)  break;
+  }
+
+if (k < narg)  goto Suite;
+PbArg:
+printf("%s_Erreur : Pb. arguments ( %s -h pour aide) \n", Pgnm, Pgnm);
+return(1);
+
+Suite:
+svf = arg[k];
+
+cout << " hanafsv: Args decoded, starting suivi processing ..." << endl;
+SophyaInit();
+sfip = NULL;  rc = 0;
+try {
+
+  POutPersist po("LCInfo.ppf");
+  POutPersist po2("TimInfo.ppf");
+  POutPersist po3("Mesu.ppf");
+
+  if ( (sfip = SuiviOpen(svf,SUOF_RO_MEM2)) == NULL )   return(5);
+  
+  nbstar = SuiviGetNbStars(sfip);
+  nbmes = SuiviGetNbMesures(sfip);
+  
+  if (numes1 < 1)  numes1 = 1;
+  if (numes2 < 1)  numes2 = 1;
+  if (numes2 > nbmes)  numes2 = nbmes;
+  if (numes2 < numes1) numes1 = numes2;
+  nmes = numes2-numes1+1;
+  if (numet1 < 1)  numet1 = 1;
+  if (numet2 < 1)  numet2 = 1;
+  if (numet2 > nbstar)  numet2 = nbstar;
+  if (numet2 < numet1) numet1 = numet2;
+  nstar = numet2 - numet1 +1;
+  
+  //--> new  tminf = (TIMEINFO *)malloc(nmes*sizeof(TIMEINFO));
+  tminf = new TIMEINFO[nmes]; 
+  //--> new  tminu = (TIMEINFOU *)malloc(nmes*sizeof(TIMEINFOU));
+  tminu = new TIMEINFOU[nmes]; 
+  //  mes = (MESURE *)malloc(nmes*sizeof(MESURE));
+  mes = new MESURE[nmes]; 
+  //--> new  mesu = (MESUREU *)malloc(nmes*sizeof(MESUREU));
+  mesu = new MESUREU[nmes]; 
+  //-> new TStart = (double *) malloc(nmes*sizeof(double));
+  TStart = new double[nmes]; 
+  if ( (tminf == NULL) || (tminu == NULL) || (mes == NULL) ||
+       (mesu == NULL) || (TStart == NULL))
+    { puts("hanafsv_Erreur : Pb allocation");  return(7); }
+
+  DataTable dtm = createdtmes(nmes);
+
+  LightCurveProc mylcp("lcproc.ppf");  // mylcp("lcproc.ppf", 512); 
+  
+  printf("\n ====> hanafsv : Lecture du fichier de suivi %s \n", svf);
+  printf("  %d <= NumMes <= %d   %d <= NumEt <= %d (mod %d)\n", 
+	 numes1, numes2, numet1, numet2, incn);
+  printf("  %g <= XPosRef <= %g  ET  %g <= YPosRef <= %g \n\n",
+	 xmin,xmax,ymin,ymax);
+  printf("PrtFg= %d (Level=%d)  ClFg= %d  NtFg= %d   Nbin,Min,MaxLog= %d %g %g \n",
+	 prfg, prtl, clfg, ntfg, nbin, minlog, maxlog);
+  
+  
+  
+  sres = NULL;
+  sres =  resolinit(nmes, nbin, minlog, maxlog);
+  if (sres == NULL)  { puts("hanafsv_Erreur : Pb resolinit !"); goto Fin; }
+  
+  
+  /*  Lecture GlobInfo   */
+  SuiviReadGlobInfo(sfip, (char *)(&glinf));
+  if (prfg > 0)  PrtGlobInfo(&glinf, prtl);
+  
+  /*  Boucle lecture mesure */
+  for(jt=0; jt<nmes; jt++)
+    {
+      tmi = tminf+jt;
+      rc = SuiviReadTimeInfo(sfip,jt+numes1,jt+numes1,(char *)tmi);
+      if (rc != 0) 
+	{ printf("hanafsv_Erreur: Pb SuiviReadTimeInfo( , %d, ...) \n", jt+numes1);
+	return(10); }
+      DecodeTim(tminf+jt, tminu+jt);
+      TStart[jt] = (double)tmi->TStart / (double)86400;
+      if (prfg > 0)  PrtTimeInfo(tmi, jt+numes1, prtl);
+      if ((tminu+jt)->FgCalib < 1)
+	{
+	  (mesu+jt)->Xi2 = -1.; 
+	  (mesu+jt)->Flux = (mesu+jt)->FluxB = 0.; 
+	  (mesu+jt)->ErrFlux = (mesu+jt)->ErrFluxB = 99999.0;
+	}
+    } // fin de boucle for(jt) - boucle de lecture des TimeInfo
+  
+  mylcp.TimeInfo(nmes, tminf);
+
+  if (ntfg&1)  { 
+    DataTable TimInf =  dttimeinfo(nmes, tminf);
+    cout << " Writing TimInf to po2 (TimInfo.ppf) ... " << endl; 
+    po2 << PPFNameTag("dttimeinfo") << TimInf ;  
+  }
+  
+  
+  if (fgq) {
+    puts("\n\n  =====> <CR> pour continuer, <q><CR> pour stop ...");
+    gets(strg); 
+    if (toupper(strg[0]) == 'Q')  return(0);
+  }
+  
+  dnp = numet2-numet1; 
+  if (dnp > 20)  dnp /= 10;
+  else dnp = 1;
+  
+  for (i=numet1; i<=numet2; i+=incn )  /*  Loop over stars in suivi file */
+    { 
+      
+      if (((i-numet1)%dnp) == 0)
+	{ sprintf(strg,"LectureStar[%d] ",i);  PrtTim(strg); }
+      
+      rc = SuiviReadStarInfo(sfip,i,(char *)(&star));
+
+      if (rc != 0)  return(10);
+      
+      if ( (star.XPos < xmin) || (star.XPos > xmax) ||
+	   (star.YPos < ymin) || (star.YPos > ymax) )   continue;
+      
+      if (prfg > 1)
+	{
+	  printf(" --------- StarInfo/Mesures Etoile [%d] ----------\n",i);
+	  PrtStarInfo(&star, i, prtl);
+	}
+      if (star.NumEt <  0)  continue;
+      if (star.FgRef == 0)  continue;
+      
+      
+      for (jt=0; jt<nmes; jt++)
+	{
+	  rc = SuiviReadMesures(sfip,i,jt+numes1,jt+numes1,
+				(char *)(mes+jt));
+	  if (rc != 0)  
+	    {
+	      printf("Erreur: Star[%d] Pb lecture Mesure[%d]  (Rc=%d) \n",
+		     i+1,jt+1,rc);
+	      return(15);    
+	    }
+	  if ((tminu+jt)->FgCalib > 0)
+	    {
+	      DecodeMes(mes+jt, mesu+jt);
+	      Calibre_F_E(mesu+jt, tminu+jt);
+	      if (prfg > 3)  PrtMesure(mes+jt, jt+numes1, prtl);
+	      if (prfg > 2)  PrtMesureU(mesu+jt, jt+numes1, prtl);
+	    }
+	  else if (prfg > 2)
+	    PrtMesure(mes+jt, jt+numes1, prtl);
+	  
+	}     /*  Fin de boucle sur les mesures   */
+
+      
+      // a star with all its measured fluxes is ready here to be processed 
+      // We process our light-curve
+      mylcp.ProcessLC(i, nmes, &star, tminf, mesu); 
+
+      if (clfg > 0){
+        DataTable LiCu = dtclum(i, nmes, tminf, mesu); 
+	char tagbuf[32];
+	sprintf(tagbuf,"cl%d",i);
+        po << PPFNameTag(tagbuf) << LiCu ;
+      }
+
+      if (ntfg&2)  
+	resolst(sres, nmes, &star, mesu);
+  
+      if (ntfg&4)  { 
+	dtmes(dtm, nmes, &star, mesu);
+      }
+     
+
+    }   /*  Fin de boucle sur les etoiles  */
+
+Fin:
+
+  cout << " Writing dtmes to file po3 Mesu.ppf  , dtm: \n" << dtm << endl;
+  po3 << PPFNameTag("dtmes") << dtm ;  
+  SuiviClose(sfip);
+
+  cout << "---- End Of Loop over stars, LightCurveProc.getDTS() : \n" << mylcp.getDTS() << endl;
+
+  if ((ntfg&2) && (sres != NULL))
+    resolend(sres,nmes);
+  rc = 0;
+}
+catch (PThrowable & pex) {
+  cerr << " hanafsv/Error - Exception catched " << (string)typeid(pex).name()
+       << " - Msg= " << pex.Msg() << endl;
+  rc = 98;
+}
+catch ( ... )
+ {
+   cerr << " hanafsv/Error - Exception ... catched " << endl;
+   rc = 99;
+}
+
+
+
+return(rc);
+}
+
+
+
+
+///////////////////////// DataTabale dtclum ///////////////////////////
+DataTable  dtclum(int numet, int nmes, TIMEINFO *tminf, MESUREU *mesu)
+{
+int idc,jt;
+
+ DataTable dt(100);
+ dt.AddFloatColumn("TStart");
+ dt.AddFloatColumn("Flux");
+ dt.AddFloatColumn("Xi2");
+ dt.AddFloatColumn("Fond");
+ dt.AddFloatColumn("ErrFlux");
+ dt.AddFloatColumn("SigX");
+ dt.AddFloatColumn("SugY");
+ dt.AddFloatColumn("Rho");
+ dt.AddFloatColumn("DelX");
+ dt.AddFloatColumn("DelY");
+ dt.AddFloatColumn("X");
+ dt.AddFloatColumn("Y");
+
+ double xnt[15];
+
+idc = numet;
+
+for(jt=0; jt<nmes; jt++)
+  { 
+  xnt[0] = tminf[jt].TStart/86400.;
+  xnt[1] = (double) mesu[jt].Flux;
+  xnt[2] = (double) mesu[jt].Xi2;
+  xnt[3] = (double) mesu[jt].Fond;
+  xnt[4] = (double) mesu[jt].ErrFlux;
+  xnt[5] = (double) tminf[jt].SigX;
+  xnt[6] = (double) tminf[jt].SigY;
+  xnt[7] = (double) tminf[jt].Rho;
+  xnt[8] = (double) tminf[jt].DelX;
+  xnt[9] = (double) tminf[jt].DelY;
+  xnt[10] = (double) mesu[jt].X ;
+  xnt[11] = (double) mesu[jt].Y ;
+  dt.AddRow(xnt);
+  }
+
+return(dt);
+}
+
+
+
+//////////////////// DataTable dttimeinfo //////////////////////////
+DataTable dttimeinfo(int nmes, TIMEINFO *tminf)
+{
+int idn,jt,i;
+
+ DataTable dt(10000);
+ dt.AddFloatColumn("NumPhoto");
+ dt.AddFloatColumn("TStart");
+ dt.AddFloatColumn("Expose");
+ dt.AddFloatColumn("Nb0kGF");
+ dt.AddFloatColumn("Nb0kPS");
+ dt.AddFloatColumn("Fond");
+ dt.AddFloatColumn("SigFond");
+ dt.AddFloatColumn("SigX");
+ dt.AddFloatColumn("SigY");
+ dt.AddFloatColumn("Rho");
+ dt.AddFloatColumn("SgX");
+ dt.AddFloatColumn("SgY");
+ dt.AddFloatColumn("DelX");
+ dt.AddFloatColumn("DelY");
+ dt.AddFloatColumn("Absorption");
+ dt.AddFloatColumn("Airmass");
+ dt.AddFloatColumn("FgCalib");
+ 
+  for(i=0; i<6; i++){
+   char calname[32];
+   sprintf(calname,"Calib%d",i);
+   dt.AddFloatColumn(calname);
+  }
+ 
+ for(i=0; i<6; i++)
+   for(int j =0; j<3;j++){
+     char name[32];
+     sprintf(name,"Resol%d%d",j,i);
+      dt.AddFloatColumn(name);
+   }
+ 
+
+ double xnt[48];
+
+ idn = 300;
+ for(i=0; i<36; i++)  xnt[i] = 0.;
+
+for(jt=0; jt<nmes; jt++)
+  {
+  xnt[0] = tminf[jt].NumPhoto;
+  xnt[1] = tminf[jt].TStart/86400.;
+  xnt[2] = tminf[jt].Expose;
+  xnt[3] = tminf[jt].NbOkGF;
+  xnt[4] = tminf[jt].NbOkPS;
+  xnt[5] = tminf[jt].Fond;
+  xnt[6] = tminf[jt].SigFond;
+
+  xnt[7] = tminf[jt].SigX;
+  xnt[8] = tminf[jt].SigY;
+  xnt[9] = tminf[jt].Rho;
+  xnt[10] = tminf[jt].SgX;
+  xnt[11] = tminf[jt].SgY;  
+  xnt[12] = tminf[jt].DelX;
+  xnt[13] = tminf[jt].DelY;
+  xnt[14] = tminf[jt].Absorption;
+  xnt[15] = tminf[jt].AirMass;
+
+  xnt[16] = tminf[jt].FgCalib;
+  for(i=0; i<6; i++) 
+    {
+    xnt[17+i] = tminf[jt].Calib[i];
+    xnt[23+i*3] = tminf[jt].Resol[0][i];
+    xnt[24+i*3] = tminf[jt].Resol[1][i]; 
+    xnt[25+i*3] = tminf[jt].Resol[2][i]; 
+    }
+  dt.AddRow(xnt);
+  }
+
+return(dt);
+}
+
+
+
+////////////////// DataTable creatdtmes ////////////////////////
+DataTable createdtmes(int nmes) 
+
+{
+
+ DataTable dt(100);
+ dt.AddFloatColumn("NumEt");
+ dt.AddFloatColumn("FluxRef");
+ dt.AddFloatColumn("XPos");
+ dt.AddFloatColumn("YPos");
+ dt.AddFloatColumn("FgRef");
+ dt.AddFloatColumn("NbVois");
+ dt.AddFloatColumn("DisMin");
+ dt.AddFloatColumn("DisM2");
+
+ if (nmes > 10) nmes = 10;
+
+ char nflux[32]; char nerrflux[32]; char nfluxb[32]; char nerrfluxb[32];
+ char nfond[32]; char nxi2[32]; char nx[32]; char ny[32]; char nsigx[32];
+ char nsigy[32]; char nflx[32]; char nfnd[32]; char nxi[32];
+
+ for (int k=0; k<nmes; k++) {
+   sprintf(nflux,"Flux%d",k); sprintf(nerrflux,"ErrFlux%d",k);
+   sprintf(nfluxb,"FluxB%d",k); sprintf(nerrfluxb,"ErrFluxB%d",k);
+   sprintf(nfond,"Fond%d",k); sprintf(nxi2,"Xi2%d",k); sprintf(nx,"X%d",k);
+   sprintf(ny,"Y%d",k); sprintf(nsigx,"SigX%d",k); sprintf(nsigy,"SigY%d",k);
+   sprintf(nflx,"Flx%d",k); sprintf(nfnd,"Fnd%d",k); sprintf(nxi,"Xi%d",k); 
+
+   dt.AddFloatColumn(nflux);
+   dt.AddFloatColumn(nerrflux);
+   dt.AddFloatColumn(nfluxb);
+   dt.AddFloatColumn(nerrfluxb);
+   dt.AddFloatColumn(nfond);
+   dt.AddFloatColumn(nxi2);
+   dt.AddFloatColumn(nx);
+   dt.AddFloatColumn(ny);
+   dt.AddFloatColumn(nsigx);
+   dt.AddFloatColumn(nsigy);
+   dt.AddFloatColumn(nflx);
+   dt.AddFloatColumn(nfnd);
+   dt.AddFloatColumn(nxi);
+ }
+ return dt;
+}
+
+void dtmes(DataTable& dt, int nmes, STARINFO *sti, MESUREU *mesu)
+{
+int idn,jt,off,sz;
+
+
+double xnt[200];
+
+
+//idn = 400;
+if (nmes > 10)  nmes=10;
+
+xnt[0] = sti->NumEt;
+xnt[1] = sti->FluxRef;
+xnt[2] = sti->XPos;
+xnt[3] = sti->YPos;
+xnt[4] = sti->FgRef;
+xnt[5] = sti->NbVois;
+xnt[6] = sti->DisMin; 
+xnt[7] = sti->DisM2;
+
+off = 7;  sz = 13;
+if (nmes > 10) nmes = 10;
+for(jt=0; jt<nmes; jt++)
+  {
+  xnt[off+sz*jt+1] = mesu[jt].Flux;
+  xnt[off+sz*jt+2] = mesu[jt].ErrFlux;
+  xnt[off+sz*jt+3] = mesu[jt].FluxB;
+  xnt[off+sz*jt+4] = mesu[jt].ErrFluxB;
+  xnt[off+sz*jt+5] = mesu[jt].Fond;
+  xnt[off+sz*jt+6] = mesu[jt].Xi2;
+  xnt[off+sz*jt+7] = mesu[jt].X;
+  xnt[off+sz*jt+8] = mesu[jt].Y;
+  xnt[off+sz*jt+9] = mesu[jt].SigX;
+  xnt[off+sz*jt+10] = mesu[jt].SigY;
+  xnt[off+sz*jt+11] = mesu[jt].Flx0;
+  xnt[off+sz*jt+12] = mesu[jt].Fnd0;
+  xnt[off+sz*jt+13] = mesu[jt].Xi20;
+  }
+ dt.AddRow(xnt);
+
+return;
+}
+
+
+
+/* Nouvelle-Fonction */
+
+SRESOL *resolinit(int nmes, int nbin, float xmin, float xmax)
+
+{
+int i,j;
+SRESOL *sres;
+
+if (nbin < 1)  return(NULL);
+if (xmax <= xmin)   return(NULL);
+
+//-> new sres = malloc(nmes*sizeof(SRESOL));
+sres = new SRESOL[nmes]; 
+if (sres == NULL)  return(NULL);
+for(i=0; i<nmes; i++)
+  {
+  sres[i].nbin = nbin;
+  sres[i].xmin = xmin;
+  sres[i].xmax = xmax;
+  sres[i].dxbin = (xmax-xmin)/(float)nbin;
+  //-> new  sres[i].nst = malloc(nbin*sizeof(int));
+  sres[i].nst = new int[nbin]; 
+  if (sres[i].nst == NULL)   break;
+  //-> new  sres[i].nstr = malloc((nbin+2)*sizeof(int));
+  sres[i].nstr = new int[nbin+2]; 
+  if (sres[i].nstr == NULL)   
+    { delete[] sres[i].nst;  break; }
+  //->new  sres[i].fmoy =  malloc(nbin*sizeof(float));
+  sres[i].fmoy =  new float[nbin]; 
+  if (sres[i].fmoy == NULL)   
+    { delete[] sres[i].nst; delete[] sres[i].nstr;  break; }
+  //->new  sres[i].fmoyr =  malloc(nbin*sizeof(float));
+  sres[i].fmoyr =  new float[nbin] ; 
+  if (sres[i].fmoyr == NULL)   
+    { delete[] sres[i].nst; delete[] sres[i].nstr; 
+    delete[] sres[i].fmoy; break; }
+  //-> new  sres[i].dflx =  malloc(nbin*sizeof(float));
+  sres[i].dflx =  new float[nbin]; 
+  if (sres[i].dflx == NULL)   
+    { delete[] sres[i].nst;  delete[] sres[i].nstr;
+    delete[] sres[i].fmoy;  delete[] sres[i].fmoyr;  break; }
+  //->new  sres[i].sflx =  malloc(nbin*sizeof(float));
+  sres[i].sflx =  new float[nbin]; 
+  if (sres[i].sflx == NULL)   
+    { delete[] sres[i].nst; delete[] sres[i].nstr; 
+      delete[] sres[i].fmoy;  delete[] sres[i].fmoyr;
+      delete[] sres[i].dflx;  break; }
+  //->new  sres[i].dflxe =  malloc(nbin*sizeof(float));
+  sres[i].dflxe =  new float[nbin]; 
+  if (sres[i].dflxe == NULL)   
+    { delete[] sres[i].nst;  delete[] sres[i].nstr; 
+    delete[] sres[i].fmoy; delete[] sres[i].fmoyr; 
+    delete[] sres[i].dflx;  delete[] sres[i].sflx;  break; }
+  //->new  sres[i].sflxe =  malloc(nbin*sizeof(float));
+  sres[i].sflxe =  new float[nbin]; 
+  if (sres[i].sflxe == NULL)   
+    { delete[] sres[i].nst;  delete[] sres[i].nstr;
+    delete[] sres[i].fmoy;  delete[] sres[i].fmoyr; 
+    delete[] sres[i].dflx;  delete[] sres[i].sflx;  
+    delete[] sres[i].dflxe;  break; }
+  }
+
+if (i != nmes)
+  {
+/* BUG REZA ???  puts("resolinit_Erreur : Pb malloc/new  %d %d \n", i, nmes); */
+  printf("resolinit_Erreur : Pb malloc  %d %d \n", i, nmes);
+  for(j=0; j<i; j++)
+    {
+    delete[] sres[j].nst; 
+    delete[] sres[j].nstr; 
+    delete[] sres[j].fmoy;
+    delete[] sres[j].fmoyr;
+    delete[] sres[j].dflx;
+    delete[] sres[j].sflx;
+    delete[] sres[j].dflxe;
+    delete[] sres[j].sflxe;    
+    }
+  delete[] sres; 
+  return(NULL);
+  }
+for(i=0; i<nmes; i++)
+  {
+  for(j=0; j<nbin; j++)
+    {
+    sres[i].nst[j] = sres[i].nstr[j] = 0 ; 
+    sres[i].fmoy[j] = sres[i].fmoyr[j] = 0. ;
+    sres[i].dflx[j] = 0. ;
+    sres[i].sflx[j] = 0. ;
+    sres[i].dflxe[j] = 0. ;
+    sres[i].sflxe[j] = 0. ;    
+    }
+  }
+
+return(sres);
+}
+
+
+/* Nouvelle-Fonction */
+
+int resolst(SRESOL *sres, int nmes, STARINFO *sti, MESUREU *mesu)
+{
+int i,j,ib;
+float err, flx, flxr;
+float xlg, dx;
+
+flxr = sti->FluxRef;
+if (flxr < 1.)  return(-1);
+xlg = (float)log10((double)flxr);
+
+for(j=0; j<nmes; j++)
+  {
+  ib = (int)((xlg-sres[j].xmin)/sres[j].dxbin);
+  if (ib < 0)  sres[j].nstr[sres[j].nbin]++;
+  if (ib >= sres[j].nbin)  sres[j].nstr[sres[j].nbin+1]++;
+  if ( (ib < 0) || (ib >= sres[j].nbin) )   continue;
+  sres[j].nstr[ib]++;
+  sres[j].fmoyr[ib] += flxr;
+  if (mesu[j].Xi2 < 0.)  continue;
+  err = mesu[j].ErrFlux;
+  flx = mesu[j].Flux;
+  if (err/flxr < 0.01)  err = 0.01*flxr;
+  /* if (fabs((double)(err/flx)) > (1./xlg))  continue; */
+  if (fabs((double)((flx-flxr)/err)) > 8.)  continue;
+  sres[j].nst[ib]++;
+  sres[j].fmoy[ib] += flx;
+  dx = flxr-flx;
+  sres[j].dflx[ib] += dx;
+  sres[j].sflx[ib] += (dx*dx);
+  dx /= err;
+  sres[j].dflxe[ib] += dx;
+  sres[j].sflxe[ib] += (dx*dx);  
+  }
+
+return(ib);
+}
+
+/* Nouvelle-Fonction */
+int resolend(SRESOL *sres, int nmes)
+
+{
+int i,j,ib,idn;
+float ns;
+float xnt[10];
+
+printf("Resolend_Info: Under/OverFlow  %d %d \n", 
+       sres[0].nstr[sres[0].nbin], sres[0].nstr[sres[0].nbin+1]);
+for(j=0; j<nmes; j++)
+  {
+  idn = 501+j;
+  for(ib=0; ib<sres[j].nbin; ib++)
+    {
+    xnt[0] = ib;   
+    xnt[1] = sres[j].xmin+ib*sres[j].dxbin; 
+    for(i=2; i<10; i++)  xnt[i] = 0.;
+    if (sres[j].nstr[ib] < 1)   goto  Fill;
+    sres[j].fmoyr[ib] /= (float)sres[j].nstr[ib];
+    xnt[8] = sres[j].nstr[ib];
+    xnt[9] = sres[j].fmoyr[ib];
+    if (sres[j].nst[ib] < 1)   goto  Fill;
+    xnt[2] = ns = sres[j].nst[ib];
+    sres[j].fmoy[ib] /= ns;
+    xnt[3] = sres[j].fmoy[ib];
+    sres[j].dflx[ib] /= ns;
+    sres[j].sflx[ib] /= ns;
+    sres[j].sflx[ib] -= sres[j].dflx[ib]*sres[j].dflx[ib];
+    if (sres[j].sflx[ib] >= 0.) 
+      sres[j].sflx[ib]  = (float)sqrt((double)sres[j].sflx[ib]);
+    xnt[4] = sres[j].dflx[ib];
+    xnt[5] = sres[j].sflx[ib];
+    sres[j].dflxe[ib] /= ns;
+    sres[j].sflxe[ib] /= ns;
+    sres[j].sflxe[ib] -= sres[j].dflxe[ib]*sres[j].dflxe[ib];
+    if (sres[j].sflxe[ib] >= 0.) 
+      sres[j].sflxe[ib]  = (float)sqrt((double)sres[j].sflxe[ib]);
+    xnt[6] = sres[j].dflxe[ib];
+    xnt[7] = sres[j].sflxe[ib];
+    Fill:
+    // --- SOPHYA NTuple fill    hfn_(&idn, xnt);
+    printf("Resol[%d,%d]  ns,nsr %d %d fm,df,sf= %g (%g) %g %g \n",j,ib, 
+           sres[j].nst[ib], sres[j].nstr[ib],
+           sres[j].fmoy[ib], sres[j].fmoyr[ib],
+           sres[j].dflx[ib], sres[j].sflx[ib]);  
+    }
+  }
+
+for(j=0; j<nmes; j++)
+  {
+  delete[] sres[j].nst; 
+  delete[] sres[j].nstr; 
+  delete[] sres[j].fmoy;
+  delete[] sres[j].fmoyr;
+  delete[] sres[j].dflx;
+  delete[] sres[j].sflx;
+  delete[] sres[j].dflxe;
+  delete[] sres[j].sflxe;    
+  }
+delete[] sres; 
+
+return (0);
+
+}
Index: trunk/FrEROS/AnaLC/checkfsv.cc
===================================================================
--- trunk/FrEROS/AnaLC/checkfsv.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/checkfsv.cc	(revision 3308)
@@ -0,0 +1,173 @@
+#include "machdefs.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+ 
+#include "fsvcache.h"
+
+#if ( IS_BIG_ENDIAN == 0 ) 
+#define SWAPDEFAUT 1
+#else
+#define SWAPDEFAUT 0
+#endif
+
+int main(int narg, char *arg[])
+{
+SUIVIFIP *sfip;
+ENTETESUIVI head;
+FILE *fip;
+char *flnm;
+int_4 newnmes,ntronq,fgr;
+char *buff;
+int_4 nmes, nstar;
+int rc;
+int jt, szbuff;
+int fgtronq;
+int fgswapdef;
+int_4 fgcorrnmes;
+int_4 newfgcorr;
+
+if (narg < 2)
+  {
+  puts(" CheckFSV_Erreur : Arguments incorrects ! (-h pour usage)");
+  exit(1);
+  }
+if (strcmp(arg[1],"-h") == 0)
+  {
+  puts("Usage: CheckFSV  NomSuivi");
+  puts("  ou   CheckFSV [-restore] NomSuivi");
+  puts("  ou   CheckFSV [-tronq nmes] NomSuivi");
+  puts("  ou   CheckFSV [-swapdefaut] NomSuivi");
+  puts("  ou   CheckFSV [-fgcorrnmes fgcorr,nmes] NomSuivi");  
+  puts("Rc=0 -> Fichier OK, RC > 0 = Nb de mesure OK");
+  puts("-restore : Tronquer le fichier au nombre de mesure OK"); 
+  puts("-tronq nmes : Tronquer le fichier au nombre de mesure nmes"); 
+  puts("-swapdef : Changer la valeur de Flg Swap a SWAPDEFAUT");
+  puts("-fgcorrnmes fgcorr,nmes : Modifie les valeurs de FgCorrupt et NbMes ds l'entete"); 
+  exit(2);
+  }
+ 
+fgswapdef = fgcorrnmes = 0;
+newfgcorr = newnmes = 0;
+ntronq = -1;
+
+if (strcmp(arg[1],"-swapdefaut") == 0) {
+  if (narg < 3) { 
+    puts(" CheckFSV_Erreur : Arguments incorrects ! (-h pour usage)");
+    exit(2); 
+  }
+  flnm = arg[2];  fgswapdef = 1;
+}
+else if (strcmp(arg[1],"-fgcorrnmes") == 0) {
+  if (narg < 4) { 
+    puts(" CheckFSV_Erreur : Arguments incorrects ! (-h pour usage)");
+    exit(2); 
+   }
+  sscanf(arg[2],"%d,%d", &newfgcorr, &newnmes);
+  flnm = arg[2];   fgcorrnmes = 1;
+}
+
+if (fgcorrnmes || fgswapdef) {
+  if ( (fip = fopen(flnm,"rb+")) == NULL )  
+    {
+    printf("CheckFSV/Erreur: Pb d'ouverture de %s \n",flnm);
+    exit(5);
+    }  
+  fseek(fip, (long)0, SEEK_SET);
+  fread(&head,sizeof(ENTETESUIVI),1,fip);
+  if (fgswapdef) {
+    printf("CheckFSV/Info: Modification Flag Swap entete suivi %s \n", flnm);
+    printf("CheckFSV/Info: FgSwap: Lu= %x ", head.Swap);
+    if (SWAPDEFAUT)  head.Swap = 0xFFFF;
+    else head.Swap = 0;
+    printf(" Ecrit= %x \n", head.Swap);
+  }
+  else {
+    printf("CheckFSV/Info: Modification FgCorrupt NbMes -  suivi %s \n", flnm);
+    printf("CheckFSV/Info: Lu - FgCorrupt=%d NMes=%d", head.FgCorrupt, head.NbMesTot);
+    head.FgCorrupt = newfgcorr; 
+    head.NbMesTot = newnmes;
+  }
+  fseek(fip, (long)0, SEEK_SET);
+  fwrite(&head,sizeof(ENTETESUIVI),1,fip);
+  fclose(fip);
+  exit(0);
+  }
+
+fgtronq = 0;
+if (strcmp(arg[1],"-restore") == 0)
+  {
+  if (narg < 3) { 
+    puts(" CheckFSV_Erreur : Arguments incorrects ! (-h pour usage)");
+    exit(2); }
+  flnm = arg[2];   fgr = SUOF_RW;   fgtronq = 1;
+  }
+else if (strcmp(arg[1],"-tronq") == 0)
+  {
+  if (narg < 4) { 
+    puts(" CheckFSV_Erreur : Arguments incorrects ! (-h pour usage)");
+    exit(2); }
+  flnm = arg[3];  ntronq = atoi(arg[2]);  fgr = SUOF_RW;  fgtronq = 1;
+  }
+else { fgr = SUOF_RO_MEM;  flnm = arg[1]; }
+
+printf("CheckFSV/Info: Verification fichier %s \n", flnm);
+
+SuiviSetPrtLevel(5);
+if ( (sfip = SuiviOpen(flnm, fgr)) == NULL)
+  { printf(" CheckFSV_Erreur: Pb d'ouverture de %s \n",flnm);
+  exit(99); }
+
+newnmes = rc = 0;
+if ((sfip->Head.NbMesTot != sfip->Head.FgCorrupt) || (sfip->Head.NbMesTot < 0)) {
+  printf("\nCheckFSV/warning: Fichier %s corrompu, NbMes=%d FgCorrupt=%d \n",
+         flnm,sfip->Head.NbMesTot,sfip->Head.FgCorrupt);
+  rc = newnmes = (sfip->Head.FgCorrupt < 0) ? -sfip->Head.FgCorrupt : sfip->Head.FgCorrupt;
+  if (!fgtronq)  goto Fin;  // Si fichier corrompu et pas de tronq prevu 
+  if ( (ntronq >= 0) && (ntronq <= newnmes) )  newnmes = ntronq;
+  if (newnmes < 0) {
+    printf("\nCheckFSV/Bug: NewNMes= %d (<0 ->Rc=98) \n", newnmes); 
+    rc = 98;  goto Fin;
+  }
+}
+if ( (newnmes < sfip->Head.NbMesTot) && fgtronq ) {
+  printf("\nCheckFSV/Info: Fichier tronque a NbMes= %d \n", newnmes); 
+  sfip->Head.FgCorrupt = sfip->Head.NbMesTot = newnmes;
+}
+
+/* On verifie qu'on sait lire toutes les TimeInfos et les mesures pour l'etoile NbStar */
+szbuff = (sfip->Head.RecSize[3] >  sfip->Head.RecSize[4]) ? 
+          sfip->Head.RecSize[3]*2 : sfip->Head.RecSize[4]*2;
+if ((buff=(char *)malloc(szbuff)) == NULL)  { 
+  printf("CheckFSV/erreur: Probleme malloc( buff) ! \n");
+  rc = 99;  goto Fin; 
+}
+nmes = SuiviGetNbMesures(sfip);
+nstar = SuiviGetNbStars(sfip);
+for(jt=1; jt<=nmes; jt++) {
+  rc = SuiviReadTimeInfo(sfip,jt,jt,buff);
+  if (rc != 0)   { 
+    printf("\nCheckFSV/warning: Fichier %s corrompu, Rc(RdTimeInfo(%d))=%d (FgCorrupt=%d) \n",
+           flnm, jt, rc, sfip->Head.FgCorrupt);
+    rc = jt;
+    break;
+  } 
+  if (nstar < 1)  continue;  
+  rc = SuiviReadMesures(sfip, nstar, jt, jt, buff);  
+  if (rc != 0)   { 
+    printf("\nCheckFSV/warning: Fichier %s corrompu, Rc(RdMesure(%d, %d))=%d (FgCorrupt=%d) \n",
+           flnm,nstar,jt,rc,sfip->Head.FgCorrupt);
+    rc = jt;
+    break;
+  }
+} 
+
+
+Fin :
+SuiviSetPrtLevel(0);
+SuiviClose(sfip);
+if (rc == 0) printf("CheckFSV/Info: Suivi %s OK RC= %d \n", flnm, rc);
+else printf("CheckFSV/Erreur: ReturnCode = %d \n", rc);
+if (rc > 99) rc = 99;
+exit(rc);
+}
Index: trunk/FrEROS/AnaLC/chkfsv.cc
===================================================================
--- trunk/FrEROS/AnaLC/chkfsv.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/chkfsv.cc	(revision 3308)
@@ -0,0 +1,151 @@
+/*
+Check if suivi is OK
+> chkfsv -e 1,99999,10 -m 1,99999,10 -p 2 -d 1001,11 s4l074l15R.suivi01
+> echo $status
+*/
+#include "sopnamsp.h"
+#include "machdefs.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <math.h>
+#include <iostream>
+#include <typeinfo>
+#include <unistd.h>
+
+#include "fsvcache.h"
+#include "fsvst.h"
+
+void usage(void)
+{
+ printf("Usage: chkfsv NomSuivi\n");
+ printf("  -e n1,n2,inc : Traitement des etoiles n1 a n2 avec increment inc\n");
+ printf("  -m m1,m2,inc : Traitement des mesures m1 a m2 avec increment inc\n");
+ printf("  -p lp : print level\n");
+ printf("  -d et,mes : debug by full printing for star et and mesure mes\n");
+ printf("Warning: number go [1,n]\n");
+}
+
+int main(int narg, char *arg[] )
+{
+ //---- Decodage des arguments
+ int lp=1, etdbg=-1, mesdbg=-1;
+ int numes1=1, numes2=9999999, incmes=1;
+ int numet1=1, numet2=9999999, incet=1;
+ if(narg<2)  {usage(); return 1;}
+ char c;
+ while((c = getopt(narg, arg, "he:m:p:d:")) != -1) {
+   switch (c) {
+   case 'e' :
+     sscanf(optarg,"%d,%d,%d",&numet1,&numet2,&incet);
+   case 'm' :
+     sscanf(optarg,"%d,%d,%d",&numes1,&numes2,&incmes);
+   case 'p' :
+     sscanf(optarg,"%d",&lp);
+     if(lp<0) lp=0;
+   case 'd' :
+     sscanf(optarg,"%d,%d",&etdbg,&mesdbg);
+   break;
+   case 'h' :
+   default:
+     usage();
+     return 1;
+   }
+ }
+ if(optind>=narg) {usage(); return 2;}
+ char svf[2048];
+ strcpy(svf,arg[optind]);
+
+ int rc = 0;
+
+ //---- Ouverture du fichier de suivi
+ SUIVIFIP *sfip = NULL;
+ if( (sfip=SuiviOpen(svf,SUOF_RO_MEM2)) == NULL ) {
+   cout<<"Error opening: "<<svf<<endl;
+   return(10);
+ }
+ if(lp>0) cout<<svf<<endl;
+ int nbstar = SuiviGetNbStars(sfip);
+ int nbmes = SuiviGetNbMesures(sfip);
+ if(lp>0) cout<<"nbstar = "<<nbstar<<" nbmes = "<<nbmes<<endl;
+
+ if(incet<=0) incet = 1;
+ if(numes1<1) numes1 = 1;
+ if(numes2<1) numes2 = 1;
+ if(numes2>nbmes) numes2 = nbmes;
+ if(numes2<numes1) numes1 = numes2;
+ if(incmes<=0) incmes = 1;
+ if (numet1<1) numet1 = 1;
+ if (numet2<1) numet2 = 1;
+ if (numet2>nbstar) numet2 = nbstar;
+ if (numet2<numet1) numet1 = numet2;
+  
+ //----  Lecture GlobInfo
+ GLOBINFO glinf;
+ if(lp>0) cout<<"Reading GlobInfo"<<endl;
+ rc = SuiviReadGlobInfo(sfip, (char *)(&glinf));
+ if(rc!=0) {
+   cout<<"Error reading GlobInfo rc="<<rc<<endl;
+   return 11;
+ } 
+ if(lp>1) {cout<<"\n>>> GLOBINFO"<<endl; PrtGlobInfo(&glinf,99);}
+  
+ //---- Lecture TimeInfo
+ TIMEINFO tminf;
+ TIMEINFOU tminfu;
+ if(lp>0) cout<<"Reading TimeInfo from "<<numes1<<" to "<<numes2<<" with inc "<<incmes<<endl;
+ for(int i=numes1;i<=numes2;i++) {
+   rc = SuiviReadTimeInfo(sfip,i,i,(char *)(&tminf));
+   if(rc!=0) {
+     cout<<"Error reading TimeInfo mes="<<i<<" rc="<<rc<<endl;
+     return 12;
+   }
+   if(mesdbg==i) {
+     cout<<"\n>>> TIMEINFO"<<endl; PrtTimeInfo(&tminf,i,99);
+     DecodeTim(&tminf,&tminfu);
+     cout<<"\n>>> TIMEINFOU"<<endl; PrtTimeInfoU(&tminfu,i,99);
+   }
+ }
+  
+ //---- Lecture StarInfo
+ STARINFO  star;
+ if(lp>0) cout<<"Reading StarInfo from "<<numet1<<" to "<<numet2<<" with inc "<<incet<<endl;
+ for(int i=numet1;i<=numet2;i+=incet) {
+   rc = SuiviReadStarInfo(sfip,i,(char *)(&star));
+   if(rc!=0) {
+     cout<<"Error reading StarInfo star="<<i<<" rc="<<rc<<endl;
+     return 13;
+   }
+   if(etdbg==i) {cout<<"\n>>> STARINFO"<<endl; PrtStarInfo(&star,i,99);}
+ }
+  
+  //---- Lecture Mesures
+  MESURE mes;
+  MESUREU mesu;
+  if(lp>0) cout<<"Reading Mesures"<<endl;
+  for(int i=numet1;i<=numet2;i+=incet) {
+    for(int j=numes1;j<=numes2;j+=incmes) {
+      rc = SuiviReadMesures(sfip,i,j,j,(char *)(&mes));
+      if(rc!=0) {
+        cout<<"Error reading Mesures star="<<i<<" mes="<<j<<" rc="<<rc<<endl;
+        return 14;
+      }
+      if(etdbg==i && mesdbg==j) {
+        cout<<"\n>>> MESURE"<<endl; PrtMesure(&mes,j,99);
+        DecodeMes(&mes,&mesu);
+        cout<<"\n>>> MESUREU"<<endl; PrtMesureU(&mesu,j,99);
+        Calibre_F_E(&mesu,&tminfu);
+        cout<<"\n>>> MESUREU apres Calib"<<endl; PrtMesureU(&mesu,j,99);
+      }
+    }
+  }
+  
+  //---- Fermeture du fichier de Suivi
+  rc = SuiviClose(sfip);
+  if(rc!=0) {
+    cout<<"Error Closing Suivi file rc="<<rc<<endl;
+    return 15;
+  }
+
+  return(rc);
+}
Index: trunk/FrEROS/AnaLC/convlim.c
===================================================================
--- trunk/FrEROS/AnaLC/convlim.c	(revision 3308)
+++ trunk/FrEROS/AnaLC/convlim.c	(revision 3308)
@@ -0,0 +1,31 @@
+/*   Fonctions de conversions avec limites   */
+/*         CMV - Juin 94  / Reza             */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "machdefs.h"
+
+#include "convlim.h"
+
+
+/* Nouvelle-Fonction */
+short LimitShort(float x)
+{ 
+float ls;
+
+ls = ( x < 32760.) ? x : 32760. ; 
+ls = ( ls < -32760.) ? -32760. : ls;
+return((short)ls);
+}
+
+/* Nouvelle-Fonction */
+unsigned short LimitUShort(float x)
+{ 
+float ls;
+
+ls = ( x < 65530.) ? x : 65530. ; 
+ls = ( ls < 0.) ? 0. : ls;
+return((unsigned short)ls);
+}
+
Index: trunk/FrEROS/AnaLC/convlim.h
===================================================================
--- trunk/FrEROS/AnaLC/convlim.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/convlim.h	(revision 3308)
@@ -0,0 +1,19 @@
+/*  Quelques fonctions de conversion float - > short */
+/*     Reza - CMV      94                            */
+
+#ifndef CONVLIM_H_SEEN
+#define CONVLIM_H_SEEN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+short LimitShort(float x);
+unsigned short LimitUShort(float x);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
Index: trunk/FrEROS/AnaLC/courbe_nb.cc
===================================================================
--- trunk/FrEROS/AnaLC/courbe_nb.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/courbe_nb.cc	(revision 3308)
@@ -0,0 +1,158 @@
+#include "machdefs.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "courbe_nb.h"
+
+/*==============================================================*/
+FILE *CreCourbe(char *str)
+/*
+Pour ouvrir le fichier COURBE_NB_FILE avec le nom "str".
+  Permet de mettre plusieurs etoiles dans le meme fichier.
+*/
+{
+if(COURBE_NB_FILE!=NULL) {
+  printf("CreCourbe_Erreur: Fichier Courbe non ferme!\n");
+  fclose(COURBE_NB_FILE);
+}
+COURBE_NB_FILE = fopen(str,"w");
+return COURBE_NB_FILE;
+}
+
+/*==============================================================*/
+FILE *CreCourbe(int et)
+{
+/*
+Pour ouvrir le fichier COURBE_NB_FILE avec le nom s"et".data
+  ex: s12.data
+*/
+char str[256];
+sprintf(str,"s%d.data",et);
+return CreCourbe(str);
+}
+
+/*==============================================================*/
+void CloseCourbe(void)
+/*
+Pour fermer le fichier COURBE_NB_FILE
+*/
+{
+if(COURBE_NB_FILE!=NULL) {
+  fprintf(COURBE_NB_FILE,"-999999.\n");
+  fclose(COURBE_NB_FILE);
+}
+COURBE_NB_FILE = NULL;
+}
+
+/*==============================================================*/
+void FillCourbe(int et,int coul
+               ,float t,float flx,float eflx,float flb,float eflb
+               ,float v0,float v1,float v2,float v3,float v4)
+/*
+Pour remplir un fichier ASCII avec des courbes de lumieres:
+ coul = couleur (1 ou 2)
+ flx  = flux calibre
+ eflx = erreur sur le flux calibre
+ flb  = flux brut
+ eflb = erreur sur le flux brut
+ v0,v1,v2,v3,v4 = ce qu'on veut pour sequence temporelle
+ - Code 1    , 2
+        coul1, coul2
+*/
+{
+if(COURBE_NB_FILE==NULL) {
+  printf("FillCourbe_Erreur: fichier non ouvert!\n");
+  return;
+}
+fprintf(COURBE_NB_FILE,"%d. %d. %f %f %f %f %f %f %f %f %f %f\n"
+       ,coul,et,t,flx,eflx,flb,eflb,v0,v1,v2,v3,v4);
+}
+
+/*==============================================================*/
+void FillBosse(int et,int coul
+              ,float fbase,float tp1,float tp2,float ts1,float ts2)
+/*
+Pour remplir la caracteristique du flux de base et des bosses:
+ coul  = couleur (1 ou 2)
+ fbase = flux de base
+ tp1   = temps de debut de la bosse principale
+ tp2   = temps de fin   de la bosse principale
+ ts1   = temps de debut de la bosse secondaire
+ ts2   = temps de fin   de la bosse secondaire
+ - Code 1000 , 2000
+        coul1, coul2
+*/
+{
+if(COURBE_NB_FILE==NULL) {
+  printf("FillBosse_Erreur: fichier non ouvert!\n");
+  return;
+}
+coul = 1000*coul;
+fprintf(COURBE_NB_FILE,"%d. %d. %f %f %f %f %f\n"
+       ,coul,et,fbase,tp1,tp2,ts1,ts2);
+}
+
+/*==============================================================*/
+void FillPacZin(int et,int coul,int mc
+               ,float fbase,float u0,float t0,float tau,float blend)
+/*
+Pour remplir la caracteristique d'un fct de paczinski:
+ coul  = couleur (1 ou 2)
+ mc    = <=0 fct fittee, >0 fct montecarlo
+ fbase = flux de base
+ u0    = parametre d'impact en Rayon d'einstein
+ t0    = temps du maximum
+ tau   = parametre de largeur
+ blend = taux de blending (=1 si pas de blending!)
+ - Code 1010 , 1011    , 2010 , 2011
+        coul1, coul1+mc, coul2, coul2+mc
+*/
+{
+if(COURBE_NB_FILE==NULL) {
+  printf("FillPacZin_Erreur: fichier non ouvert!\n");
+  return;
+}
+if(mc<=0) mc = 0; else mc = 1;
+coul = coul*1000 + 10 + mc;
+fprintf(COURBE_NB_FILE,"%d. %d. %f %f %f %f %f\n"
+       ,coul,et,fbase,u0,t0,tau,blend);
+}
+
+/*==============================================================*/
+void FillVarPer(int et,int coul,int mc
+               ,int nharm,float fbase,float per,float t0
+               ,float *pcs,float *psn)
+/*
+Pour remplir la caracteristique d'un fct periodique:
+ coul  = couleur (1 ou 2)
+ mc    = <=0 fct fittee, >0 fct montecarlo
+ nharm = nombre d'harmoniques
+ fbase = flux de base
+ per   = periode
+ t0    = temps zero
+ pcs   = tableau des "nharm" multiplicateurs des cosinus
+         Il y a donc 1 fondamental + nharm-1 harmoniques
+ psn   = tableau des "nharm" multiplicateurs des sinus
+ - Code 1020 , 1021    , 2020 , 2021
+        coul1, coul1+mc, coul2, coul2+mc
+ La fonction est:
+ f(t) = fbase
+      + Sum[pcs(i)*cos(2pi*i*(x-t0)/per) + psn(i)*sin(2pi*i*(x-t0)/per)]
+                (i varie de 1,nharm)
+*/
+{
+int i;
+if(COURBE_NB_FILE==NULL) {
+  printf("FillVarPer_Erreur: fichier non ouvert!\n");
+  return;
+}
+if(mc<=0) mc = 0; else mc = 1;
+coul = coul*1000 + 20 + mc;
+fprintf(COURBE_NB_FILE,"%d. %d. %f %f %f\n"
+       ,coul,et,fbase,per,t0);
+for(i=0;i<nharm;i++)
+  fprintf(COURBE_NB_FILE,"%d. %d. %f %f %f\n"
+         ,coul,et,(float)(i+1),pcs[i],psn[i]);
+}
+
Index: trunk/FrEROS/AnaLC/courbe_nb.h
===================================================================
--- trunk/FrEROS/AnaLC/courbe_nb.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/courbe_nb.h	(revision 3308)
@@ -0,0 +1,31 @@
+#ifndef  COURBE_NB_H_SEEN  
+#define  COURBE_NB_H_SEEN
+
+#include <stdlib.h>
+#include <stdio.h>
+
+/*
+Pour ecrire des fichiers ASCII contenant des courbes de lumieres et des
+  informations sur les bases,bosses,paczinski,periodiques,...
+- On peut SOIT creer un fichier par etoile, SOIT creer un fichier
+  contenant plusieurs etoiles en gerant l'endroit de l'appel a la creation
+  du fichier ASCII (CreCourbe) et sa fermeture (CloseCourbe).
+*/
+
+FILE *COURBE_NB_FILE;
+
+FILE *CreCourbe(int et);
+FILE *CreCourbe(char *);
+void FillCourbe(int et,int coul
+              ,float t,float flx,float eflx,float flb,float eflb
+              ,float v0,float v1,float v2,float v3,float v4);
+void CloseCourbe(void);
+void FillBosse(int et,int coul
+              ,float fbase,float tp1,float tp2,float ts1,float ts2);
+void FillPacZin(int et,int coul,int mc
+               ,float fbase,float u0,float t0,float tau,float blend);
+void FillVarPer(int et,int coul,int mc
+               ,int nharm,float fbase,float per,float t0
+               ,float *pcs,float *psn);
+
+#endif
Index: trunk/FrEROS/AnaLC/filecache.c
===================================================================
--- trunk/FrEROS/AnaLC/filecache.c	(revision 3308)
+++ trunk/FrEROS/AnaLC/filecache.c	(revision 3308)
@@ -0,0 +1,513 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "machdefs.h"
+
+#ifndef  IBMVM
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#include "filecache.h"
+
+#ifdef RFIO
+#include <shift.h>
+#endif
+
+#ifdef __mac__
+#include <stat.h>
+#endif
+
+/* 
+++ 
+  Module 	Buffered I/O (C)
+  Lib	fsv
+  include	filecache.h
+
+	Les fonctions décrites ci-dessous permettent de lire et d'écrire
+	des fichiers avec une gestion de mémoire tampon, afin d'optimiser 
+	le débit d'entrée-sortie en cas d'utilisation lourde du positionnement
+	dans le fichier (seek()). L'interface est similaire à celle des 
+	fonctions d'entrée sortie standard C ("fopen(...)", "fread(...)", ...).
+	Au moment de l'ouverture du fichier (par zfopen()),
+	une liste chainée de zones mémoire, (des pages)
+	est créé. Ces pages sont destinées a contenir une
+	image mémoire des zones accédées du fichier au moment
+	des opérations de lecture et d'écriture, réduisant
+	ainsi le nombre des accés effectifs au fichier disque.
+	La taille et le nombre de page allouées sont contrôlés par 
+	l'utilisateur.
+--
+*/
+
+static int zf_prtlev = 0;
+/* Nouvelle-Fonction */
+void zfSetPrtLevel(int lev)
+{
+zf_prtlev = lev;
+}
+
+int pgread(FILECACHE *fcp, long fr, long n, char *buff);
+int pgwrite(FILECACHE *fcp, long fr, long n, char *buff);
+
+/*
+++
+FILECACHE  *zfopen(char *flnm, char *mode, int npg, int pgsiz)
+	Ouverture du fichier "flnm", en mode lecture seule ou
+	lecture-écriture. "npg" pages de tailles "pgsiz" sont 
+	allouées pour la mémoire tampon. Les caractères "rw+"
+	peuvent être spécifié pour "mode". Si "npg <= 0",
+	les fonctions standard "fseek()", "fread()" et "fwrite()"
+	sont utilisées. 
+
+void zfclose( FILECACHE *fcp )
+	Fermeture du fichier. Il est impératif d'appeler zfclose()
+	si le fichier a été ouvert en écriture.
+
+void zfSetPrtLevel(int lev)
+	Modification du niveau d'impression pour le debug.
+	si "lev > 2" des statistiques concernant l'utilisation 
+	de la mémoire tampon sont imprimées à la fermeture du fichier.
+--
+*/ 
+
+
+
+/* Nouvelle-Fonction */ 
+FILECACHE  *zfopen(char *flnm, char *mode, int npg, int pgsiz)
+ 
+{
+FILE *fip;
+FILECACHE *fcp;
+int i,j;
+DSKPAGE  *first, *cur, *prev;
+ 
+ 
+if ( (fip=fopen(flnm,mode)) == NULL )
+  {
+  puts("zfopen_Erreur - Erreur fopen !");
+  return(NULL);
+  }
+ 
+ 
+if ( (fcp=malloc(sizeof(FILECACHE))) == NULL )
+  {
+  fclose(fip);
+  puts("zfopen_Erreur - Erreur malloc(fcp) !");
+  return(NULL);
+  }
+ 
+if ( npg < 0 )  {  npg = DEF_NPAGE ;  pgsiz = DEF_PGSIZE ; }
+ 
+fcp->fip = fip;
+
+#if defined(IBMVM)
+fcp->fidesc = -1;
+#elif defined(HPUX)
+fcp->fidesc = (int)fip->__fileH*256+(int)fip->__fileL;
+#elif defined(__MWERKS__) 
+//fcp->fidesc = (int)fip->_Handle;  // ANSI ancien
+fcp->fidesc = (int)fip->handle; // MSL
+#elif defined(Linux) 
+fcp->fidesc = (int)fip->_fileno;
+#else
+fcp->fidesc = (int)fip->_file;
+#endif
+
+fcp->fpos = 0;
+fcp->nread = fcp->nwrite = 0;
+fcp->totrd = fcp->totwr =0;
+fseek(fip,0,SEEK_END);
+fcp->fsz = ftell(fip);
+fseek(fip,0,SEEK_SET);
+ 
+fcp->rwfg = 0;
+for(i=0; i<strlen(mode); i++)
+  if ( ( *(mode+i) == 'w' ) || ( *(mode+i) == '+' ) )  fcp->rwfg = 1;
+ 
+fcp->memode = 0;
+fcp->first = fcp->last = NULL;
+fcp->pages = NULL;
+fcp->npage = fcp->pgsize = 0;
+ 
+if (npg <= 0)   return(fcp);       /*  Si pas d'option caching  */
+ 
+if (pgsiz < MIN_PGSIZE)  pgsiz = MIN_PGSIZE;
+if (npg < MIN_NPAGE)  npg = MIN_NPAGE;
+ 
+fcp->memode = 1;
+fcp->npage = npg;
+fcp->pgsize = pgsiz;
+ 
+if ( ( first = (DSKPAGE *)malloc(npg*sizeof(DSKPAGE)) ) == NULL )
+  {
+  fclose(fip);   free(fcp);
+  puts("zfopen_Erreur: Pb malloc(DSKPAGE) !");
+  return(NULL);
+  }
+
+prev = NULL;
+cur = first-1;
+for(i=0; i<npg; i++)
+  {
+  cur++;
+  cur->wrfg = 0;
+  cur->pgno = -1;
+  if ( (cur->page=malloc(pgsiz)) == NULL)
+    {
+    for(j=0; j<i; j++)
+      free((first + j)->page);
+    free(first);  free(fcp);
+    fclose(fip);
+    return(NULL);
+    }
+  memset( cur->page, pgsiz, '\0');
+  cur->next = cur+1;
+  cur->prev = prev;
+  prev = cur;
+  }
+ 
+cur->next = NULL;
+fcp->last = cur;
+fcp->first = first;
+fcp->pages = first; 
+ 
+if (zf_prtlev > 5)
+  {
+  printf("zfopen_Debug: NPage= %d , PgSize= %d \n", npg, pgsiz);
+  cur = fcp->first;
+  for (i=0; i<npg; i++)
+    {
+    printf("Pg[%d] *DskPg = %lx *page= %lx *Next= %lx \n",
+           (i+1), (unsigned long)cur, (unsigned long)cur->page, (unsigned long)cur->next);
+    cur = cur->next;
+    }
+  }
+ 
+return(fcp);
+}
+ 
+ 
+ 
+/* Nouvelle-Fonction */ 
+void zfclose( FILECACHE *fcp )
+{
+float effr,effw;
+DSKPAGE  *cur;
+int_4 pgsiz;
+long int fp;
+ 
+if (fcp == NULL)  return;
+ 
+ 
+pgsiz = fcp->pgsize;
+cur = fcp->first;
+while (cur != NULL)
+  {
+  if ( cur->wrfg && fcp->rwfg )
+    {
+    fp = cur->pgno*fcp->pgsize;
+#ifdef  IBMVM
+   fseek(fcp->fip, fp, SEEK_SET);
+   fwrite(cur->page, 1, pgsiz, fcp->fip);
+#else
+    lseek(fcp->fidesc, (off_t)fp, SEEK_SET);
+    write(fcp->fidesc, cur->page, pgsiz);
+#endif
+    fcp->nwrite ++;
+    }
+  free(cur->page);
+  cur = cur->next;
+  }
+ 
+if (zf_prtlev > 2)
+  {
+  if (fcp->nread > 0)
+  effr = (float)(fcp->totrd)/(float)(fcp->nread*pgsiz);
+  else   effr = 1.0;
+  if (fcp->nwrite > 0)
+    effw = (float)(fcp->totwr)/(float)(fcp->nwrite*pgsiz);
+  else   effw = 1.0;
+  puts(" ================= Statistiques Memoire Cache =================");
+  printf(" NPage= %d   PgSize= %d \n", fcp->npage, fcp->pgsize);
+  printf(" PgRead= %d  TotRd= %ld TotRd/PgRead= %g \n",
+         fcp->nread, fcp->totrd, effr);
+  printf(" PgWrite= %d  TotWr= %ld TotWr/PgWrite= %g \n",
+         fcp->nwrite, fcp->totwr, effw);
+  puts(" ==============================================================");
+  }
+
+/* fcp->first a tourne et ne pointe plus vers la 1ere structure des DSKPAGES* */
+free(fcp->pages);
+fclose(fcp->fip);
+free(fcp);
+ 
+return;
+ 
+}
+ 
+/*
+++
+int zfseek( FILECACHE *fcp, long int offset, int fg)
+	Positionnement dans le fichier. "fg" peut valoir
+	"SEEK_SET", "SEEK_CUR", "SEEK_END", pour 
+	un positionnement avec décalage "offset" à partir
+	du début de fichier, de la position courante, ou
+	de la fin du fichier.
+
+size_t zfread( void *buff, size_t size, size_t nitems, FILECACHE *fcp)
+	Lecture à partir de la position courante.
+
+size_t zfwrite( void *buff, size_t size, size_t nitems, FILECACHE *fcp)
+	Ecriture à partir de la position courante.
+--
+*/ 
+ 
+/* Nouvelle-Fonction */ 
+int zfseek( FILECACHE *fcp, long int offset, int fg)
+{
+long int newpos;
+ 
+if (fcp == NULL)  return(-2);
+if ( !fcp->memode )   return ( fseek(fcp->fip, offset, fg) );
+ 
+newpos = offset;
+if (fg == SEEK_SET)  newpos = offset;
+if (fg == SEEK_CUR)  newpos = fcp->fpos + offset;
+if (fg == SEEK_END)  newpos = fcp->fsz - offset;
+ 
+if ( newpos < 0 )   return(-1);
+if ( !fcp->rwfg && (newpos >= fcp->fsz) )  return(-1);
+fcp->fpos = newpos;
+return(0);
+ 
+}
+ 
+ 
+ 
+/* Nouvelle-Fonction */
+size_t zfread( void *buff, size_t size, size_t nitems, FILECACHE *fcp) 
+{
+long int m,n;
+long int fr,nr;
+ 
+ 
+if (fcp == NULL)  return(0);
+if ( !fcp->memode )   return ( fread(buff, size, nitems, fcp->fip) );
+ 
+#ifdef  DEBUG_FCACHE
+printf(" Debug_zfread pos,size,nitem= %d %d %d\n",fcp->fpos,size,nitems);
+#endif
+ 
+m = 0;  n = size*nitems;
+if ( fcp->fpos+n > fcp->fsz )  n = fcp->fsz-fcp->fpos;
+if ( n <= 0)  return(0);
+fr = fcp->fpos;
+ 
+fcp->totrd += n;   nr = n;
+ 
+while ((m < n) && (nr > 0))
+  {
+#ifdef  DEBUG_FCACHE
+  printf(" Debug_zfread_2 fr,n,m= %d %d %d\n",fr,n,m);
+#endif
+  nr = pgread(fcp,fr,(n-m), ((char *)buff)+m);
+  m += nr; fr += nr;
+  }
+ 
+fcp->fpos += m;
+ 
+return(m);
+}
+ 
+ 
+/* Nouvelle-Fonction */
+int pgread(FILECACHE *fcp, long fr, long n, char *buff)
+{
+long int pgnum, pg;
+long int off, nr;
+ 
+long int fp;
+DSKPAGE  *cur;
+ 
+pgnum = fr / fcp->pgsize;
+ 
+/*  On regarde si la page est en memoire  */
+ 
+pg = -1;
+cur = fcp->first;
+while (cur != NULL)
+  {
+  if (cur->pgno < 0)  break;
+  if (cur->pgno == pgnum)  { pg = pgnum; break; }
+  cur = cur->next;
+  }
+ 
+ 
+/*  On la lit si elle n'y est pas   */
+if ( pg < 0)
+  {
+  cur = fcp->last;
+/*   On reecrit la derniere page si necessaire  */
+  if ( cur->wrfg && fcp->rwfg )
+    {
+    fp = cur->pgno*fcp->pgsize;
+#ifdef  IBMVM
+   fseek(fcp->fip, fp, SEEK_SET);
+   fwrite(cur->page, 1, fcp->pgsize, fcp->fip);
+#else
+    lseek(fcp->fidesc, (off_t)fp, SEEK_SET);
+    write(fcp->fidesc, cur->page, fcp->pgsize);
+#endif
+    fcp->nwrite ++;
+    }
+ 
+  fp = pgnum*fcp->pgsize;
+#ifdef IBMVM
+  fseek(fcp->fip, fp, SEEK_SET);
+  fread(cur->page, 1, fcp->pgsize, fcp->fip);
+#else
+  lseek(fcp->fidesc, (off_t)fp, SEEK_SET);
+  read(fcp->fidesc, cur->page, fcp->pgsize);
+#endif
+  cur->pgno = pgnum;
+  cur->wrfg = 0;
+  fcp->nread ++;
+  }
+ 
+/*  On reordonne les pages   */
+if ( cur != fcp->first )
+  {
+  if ( cur == fcp->last )
+    { fcp->last = cur->prev;   (fcp->last)->next = NULL; }
+  else
+    { (cur->prev)->next = cur->next;   (cur->next)->prev = cur->prev; }
+ 
+  (fcp->first)->prev = cur;
+  cur->next = fcp->first;
+  cur->prev = NULL;
+  fcp->first = cur;
+  }
+ 
+/*  Copie ds buffer utilisateur  */
+off = fr - pgnum*fcp->pgsize;
+if ( (nr=fcp->pgsize-off) > n )  nr = n;
+memcpy(buff, (cur->page)+off, nr);
+ 
+return(nr);
+}
+ 
+ 
+ 
+/* Nouvelle-Fonction */
+size_t zfwrite( void *buff, size_t size, size_t nitems, FILECACHE *fcp)
+{
+long int m,n;
+long int fr,nw;
+ 
+ 
+if (fcp == NULL)  return(-1);
+if ( !fcp->rwfg )  return(-2);
+if ( !fcp->memode )   return ( fwrite(buff, size, nitems, fcp->fip) );
+ 
+ 
+m = 0;  n = size*nitems;
+if ( n <= 0)  return(0);
+ 
+fr = fcp->fpos;
+fcp->totwr += n;   nw = n;
+ 
+while ((m < n) && (nw > 0))
+  {
+  nw = pgwrite(fcp,fr,(n-m), ((char*)buff)+m);
+  m += nw; fr += nw; }
+ 
+fcp->fpos += m;
+if (fcp->fpos >= fcp->fsz)  fcp->fsz = fcp->fpos+1;
+ 
+return(m);
+}
+ 
+ 
+/* Nouvelle-Fonction */
+ 
+int pgwrite(FILECACHE *fcp, long fr, long n, char *buff)
+ 
+{
+long int pgnum, pg;
+long int off, nw;
+ 
+long int fp;
+DSKPAGE  *cur;
+ 
+pgnum = fr / fcp->pgsize;
+ 
+/*  On regarde si la page est en memoire  */
+ 
+pg = -1;
+cur = fcp->first;
+while (cur != NULL)
+  {
+  if (cur->pgno < 0)  break;
+  if ( cur->pgno == pgnum)  { pg = pgnum; break; }
+  cur = cur->next;
+  }
+ 
+ 
+/*  On la lit si elle n'y est pas   */
+if ( pg < 0)
+  {
+ 
+  cur = fcp->last;
+/*   On reecrit la derniere page si necessaire  */
+  if ( cur->wrfg && fcp->rwfg)
+    {
+    fp = cur->pgno*fcp->pgsize;
+#ifdef  IBMVM
+    fseek(fcp->fip, fp, SEEK_SET);
+    fwrite(cur->page, 1, fcp->pgsize, fcp->fip);
+#else
+    lseek(fcp->fidesc, (off_t)fp, SEEK_SET);
+    write(fcp->fidesc, cur->page, fcp->pgsize);
+#endif
+    fcp->nwrite ++;
+    }
+ 
+  fp = pgnum*fcp->pgsize;
+  if ( (fp + fcp->pgsize) >= fcp->fsz )   /* remise a zero de la page */
+    memset( cur->page, fcp->pgsize, '\0');
+#ifdef IBMVM
+  fseek(fcp->fip, fp, SEEK_SET);
+  fread(cur->page, 1, fcp->pgsize, fcp->fip);
+#else
+  lseek(fcp->fidesc, (off_t)fp, SEEK_SET);
+  read(fcp->fidesc, cur->page, fcp->pgsize);
+#endif
+  cur->pgno = pgnum;
+  cur->wrfg = 0;
+  fcp->nread ++;
+  }
+ 
+/*  On reordonne les pages   */
+if ( cur != fcp->first )
+  {
+  if ( cur == fcp->last )
+    { fcp->last = cur->prev;   (fcp->last)->next = NULL; }
+  else
+    { (cur->prev)->next = cur->next;   (cur->next)->prev = cur->prev; }
+ 
+  (fcp->first)->prev = cur;
+  cur->next = fcp->first;
+  cur->prev = NULL;
+  fcp->first = cur;
+  }
+ 
+/*  Copie ds buffer utilisateur  */
+off = fr - pgnum*fcp->pgsize;
+if ( (nw=fcp->pgsize-off) > n )  nw = n;
+memcpy((cur->page)+off, buff, nw);
+cur->wrfg = 1;
+ 
+return(nw);
+}
Index: trunk/FrEROS/AnaLC/filecache.h
===================================================================
--- trunk/FrEROS/AnaLC/filecache.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/filecache.h	(revision 3308)
@@ -0,0 +1,55 @@
+#ifndef FILECACHE_H_SEEN
+#define  FILECACHE_H_SEEN
+
+
+#include <stdio.h>
+#include "machdefs.h"
+ 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define  DEF_PGSIZE  4096
+#define  DEF_NPAGE   50
+#define  MIN_PGSIZE  512
+#define  MIN_NPAGE   10
+ 
+  
+typedef struct  dskpage
+  {
+  int wrfg;
+  char *page;
+  int_4 pgno;
+  struct dskpage *next, *prev;
+  }  DSKPAGE;
+ 
+ 
+typedef struct  filecache
+  {
+  FILE *fip;
+  int fidesc;
+  int memode, rwfg;
+  long int fpos;
+  long int fsz;
+  int_4 npage, pgsize;
+  DSKPAGE  *pages;  /* pointeur sur la zone memoire de toutes les pages */
+  DSKPAGE  *first, *last;
+  int_4 nread, nwrite;
+  long int totrd, totwr;
+  } FILECACHE ;
+ 
+ 
+FILECACHE  *zfopen(char *flnm, char *mode, int NPg, int PgSiz);
+int zfseek( FILECACHE *fcp, long int offset, int fg);
+size_t zfread( void *buff, size_t size, size_t nitems, FILECACHE *fcp);
+size_t zfwrite( void *buff, size_t size, size_t nitems, FILECACHE *fcp);
+void zfclose( FILECACHE *fcp );
+void zfSetPrtLevel(int lev);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
Index: trunk/FrEROS/AnaLC/filtccd.cc
===================================================================
--- trunk/FrEROS/AnaLC/filtccd.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/filtccd.cc	(revision 3308)
@@ -0,0 +1,1280 @@
+#include "machdefs.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "nbtri.h"
+#include "nbmath.h"
+#include "matxop.h"
+#include "filtccd.h"
+
+static int DEB_FitPan    = 0;
+static int DEB_BaseLine  = 0;
+static int DEB_Bosse     = 0;
+static int DEB_BossePaG  = 0;
+static int DEB_SigmaInt  = 0;
+static int DEB_FiltMed   = 0;
+static int DEB_FiltInt   = 0;
+
+static int Bosse_probnb  = 0;
+
+/*=========================================================================*/
+void SetDebFilt(int razer)
+{
+char *c;
+DEB_FitPan = DEB_BaseLine = DEB_Bosse = DEB_BossePaG  
+           = DEB_SigmaInt = DEB_FiltMed = DEB_FiltInt = 0;
+if( razer < 0 ) return;
+if( (c = getenv("DEB_FitPan"))   ) DEB_FitPan   = atoi(c); else DEB_FitPan   = 0;
+if( (c = getenv("DEB_BaseLine")) ) DEB_BaseLine = atoi(c); else DEB_BaseLine = 0;
+if( (c = getenv("DEB_Bosse"))    ) DEB_Bosse    = atoi(c); else DEB_Bosse    = 0;
+if( (c = getenv("DEB_BossePaG")) ) DEB_BossePaG = atoi(c); else DEB_BossePaG = 0;
+if( (c = getenv("DEB_SigmaInt")) ) DEB_SigmaInt = atoi(c); else DEB_SigmaInt = 0;
+if( (c = getenv("DEB_FiltMed"))  ) DEB_FiltMed  = atoi(c); else DEB_FiltMed  = 0;
+if( (c = getenv("DEB_FiltInt"))  ) DEB_FiltInt  = atoi(c); else DEB_FiltInt  = 0;
+}
+
+/*=========================================================================*/
+double LPacZin(double t,double *Par,double *DgDpar) 
+/*                                                  Christophe 11/02/94
+fonction de paczinski en -magnitude 2.5*log10(Paczin) au temps t
+pour U0,T0,Tau,magfond et derivees de la fonction par rapport
+aux parametres [0]=U0,[1]=T0,[2]=Tau,[3]=magfond
+*/
+{
+double Paczin,u2,su2u24,tt0tau,dadu2;
+
+tt0tau = (t-Par[1])/Par[2];
+u2 = Par[0]*Par[0] + tt0tau*tt0tau;
+su2u24 = sqrt(u2*(u2+4.));
+dadu2 = -4./su2u24/su2u24/su2u24;
+
+Paczin = (u2+2.)/su2u24;
+DgDpar[0] = DftoDm/Paczin *dadu2* 2.*Par[0];
+DgDpar[1] = DftoDm/Paczin *dadu2*(-2.*tt0tau/Par[2]);
+DgDpar[2] = DftoDm/Paczin *dadu2*(-2.*tt0tau*tt0tau/Par[2]);
+DgDpar[3] = 1.;
+
+Paczin = 2.5*log10(Paczin) + Par[3];
+return (Paczin);
+}
+
+/*=========================================================================*/
+double MPacZin(double t,double *Par,double *DgDpar) 
+/*                                                  rcecile 13/06/94
+fonction de paczinski a l'envers en -magnitude 2.5*log10(Paczin) au temps t
+pour U0,T0,Tau,magfond et derivees de la fonction par rapport
+aux parametres [0]=U0,[1]=T0,[2]=Tau,[3]=magfond
+*/
+{
+double Paczin,u2,su2u24,tt0tau,dadu2;
+
+tt0tau = (t-Par[1])/Par[2];
+u2 = Par[0]*Par[0] + tt0tau*tt0tau;
+su2u24 = sqrt(u2*(u2+4.));
+dadu2 = -4./su2u24/su2u24/su2u24;
+
+Paczin = (u2+2.)/su2u24;
+DgDpar[0] = DftoDm/Paczin *dadu2* 2.*Par[0];
+DgDpar[1] = DftoDm/Paczin *dadu2*(-2.*tt0tau/Par[2]);
+DgDpar[2] = DftoDm/Paczin *dadu2*(-2.*tt0tau*tt0tau/Par[2]);
+DgDpar[3] = 1.;
+
+Paczin = -2.5*log10(Paczin) + Par[3];
+return (Paczin);
+}
+
+/*=========================================================================*/
+double LPacZin2(double t,double *Par,double *DgDpar) 
+/*                                                  Christophe 11/02/94
+fonction de paczinski en -magnitude 2.5*log10(Paczin) au temps t
+pour 1/U0,T0,1/Tau,magfond et derivees de la fonction par rapport
+aux parametres [0]=1/U0,[1]=T0,[2]=1/Tau,[3]=magfond
+*/
+{
+double Paczin,U2,U02,tt0,tt0tau,tt0tau2,dPdU2,U24p1,sU24p1,den;
+
+tt0 = t-Par[1];
+tt0tau = tt0*Par[2];
+tt0tau2 = tt0tau*tt0tau;
+U02 = Par[0]*Par[0];
+U2 = U02/(1.+U02*tt0tau2);
+U24p1 = 1.+4*U2;  sU24p1 = sqrt(U24p1);
+den = 1.+U02*tt0tau2;  den *= den;
+dPdU2 = 4.*U2/(U24p1*sU24p1);
+
+Paczin = (1.+2.*U2)/sU24p1;
+DgDpar[0] =  DftoDm/Paczin *dPdU2* 2.*Par[0]/den;
+DgDpar[1] =  DftoDm/Paczin *dPdU2* 2.*U02*U02*Par[2]*tt0tau/den;
+DgDpar[2] = -DftoDm/Paczin *dPdU2* 2.*U02*U02*tt0*tt0tau/den;
+DgDpar[3] = 1.;
+
+Paczin = 2.5*log10(Paczin) + Par[3];
+return (Paczin);
+}
+
+/*=========================================================================*/
+double MPacZin2(double t,double *Par,double *DgDpar) 
+/*                                                  rcecile 13/06/94
+fonction de paczinski a l'envers en -magnitude 2.5*log10(Paczin) au temps t
+pour 1/U0,T0,1/Tau,magfond et derivees de la fonction par rapport
+aux parametres [0]=1/U0,[1]=T0,[2]=1/Tau,[3]=magfond
+*/
+{
+double Paczin,U2,U02,tt0,tt0tau,tt0tau2,dPdU2,U24p1,sU24p1,den;
+
+tt0 = t-Par[1];
+tt0tau = tt0*Par[2];
+tt0tau2 = tt0tau*tt0tau;
+U02 = Par[0]*Par[0];
+U2 = U02/(1.+U02*tt0tau2);
+U24p1 = 1.+4*U2;  sU24p1 = sqrt(U24p1);
+den = 1.+U02*tt0tau2;  den *= den;
+dPdU2 = 4.*U2/(U24p1*sU24p1);
+
+Paczin = (1.+2.*U2)/sU24p1;
+DgDpar[0] =  DftoDm/Paczin *dPdU2* 2.*Par[0]/den;
+DgDpar[1] =  DftoDm/Paczin *dPdU2* 2.*U02*U02*Par[2]*tt0tau/den;
+DgDpar[2] = -DftoDm/Paczin *dPdU2* 2.*U02*U02*tt0*tt0tau/den;
+DgDpar[3] = 1.;
+
+Paczin = -2.5*log10(Paczin) + Par[3];
+return (Paczin);
+}
+
+/*=========================================================================*/
+double LErrExt(double m,double *Par,double *DgDpar) 
+/* fonction des erreurs externes  --   Cecile 23/02/94 */
+{
+double errext;
+errext =exp(Par[1]*m) ;
+if ( errext < 1.e-200 ) errext = 0.;
+DgDpar[0] = errext;
+errext *= Par[0];
+DgDpar[1] = m*errext;
+DgDpar[2] = 1.;
+errext += Par[2];
+return (errext);
+}
+
+/*=========================================================================*/
+void SetBosse_probnb(int iset)
+{
+if( iset<=0 ) Bosse_probnb=0; else Bosse_probnb=1;
+}
+
+/*=========================================================================*/
+int_4 Bosse(float *mag,float *err,int_4 ndata
+         ,float mean,int_4 nptmin,float scut,int_4 nptscut
+         ,float *chi2,int_4 *npoint,float *Pchi2
+         ,int_4 *ideb,int_4 *ifin,int_4 *classB,int_4 NbossMX)
+/*                                      Christophe 10/11/93 La Silla
+**** Recherche de Bosses ****
+ENTREE:
+ mag: magnitude
+ err: erreur sur la magnitude
+ ndata: nombre de donnees
+ mean: moyenne de reference pour calculer les bosses
+ nptmin: nombre minimum de points pour valider une bosse
+ scut, nptscut: definition des conditions d'arret de la bosse:
+      Soit un point de signe oppose a plus de abs(scut*sigma)
+      Soit nptscut points a moins de abs(scut*sigma)
+      si scut<=0. la seule interruption est sur le changement de signe
+SORTIE:
+ chi2: Xi2 des bosses
+ npoint: nombre de points dans la bosse
+ Pchi2: probabilite de Xi2 des bosses
+ ideb: indice du debut de la bosse
+ ifin: indice de fin de la bosse (idem)
+ classB: tableau des indices de rangement par probabilite de Xi2 croissant
+ NbossMX: nombre maximum de bosses permis
+ Bosse: nombre de bosse trouvees
+*/
+{
+int_4 deb=DEB_Bosse;
+int_4 ipo,ifirst,j,k,npt,i1,i2,sgn,sgnsave,nbosse,np_scut,cont_bosse,pass;
+double v,av,ev,c2,sc2,pc2;
+
+ipo = sgnsave = npt = i1 = i2 = ifirst = np_scut = 0;
+nbosse = -1;
+c2 = sc2= pc2 = 0.;
+nptmin = ( nptmin <= 0 ) ? 1 : nptmin ;
+nptscut = ( nptscut <= 0 ) ? 1 : nptscut ;
+scut = ( scut <= 0. ) ? 0. : scut ;
+
+while ( ipo < ndata ) {
+  ev = err[ipo];
+  v = 0.;
+  if ( ev > 0. ) v = ( mag[ipo] - mean ) / ev;
+  av = fabs(v);
+  sgn = ( v > 0. ) ? 1 : -1 ;
+  if ( deb >= 4 ) printf("ipo=%5d sgn=%2d v=%f ev=%f\n",ipo,sgn,v,ev);
+  /* conditions d'increment de la fluctuation*/
+  cont_bosse = 1;
+  if ( sgn != sgnsave && av > scut ) cont_bosse = 0;
+  if ( cont_bosse && ev > 0. ) {
+    npt++;
+    c2 += v*v;
+    pc2 += nberfc(av/Rac2) + Log2;
+    i2 = ipo;
+    if( av < scut ) { np_scut++;} else { np_scut=0;}
+  }
+  /* conditions d'arret de la fluctuation */
+  if (   ( cont_bosse == 0  && ev>0. ) || 
+         ( np_scut>=nptscut && ev>0. ) || 
+         ( ipo == ndata-1 )                    ) {
+    /* y a t il assez de points ? */
+    if ( npt >= nptmin ) {
+      nbosse++;
+      /* on prend prob(xi2,npt)/2**(npt-1)                            */
+      if(Bosse_probnb) 
+           pc2 = (double) probnb( (float) c2,npt,&pass) + (npt-1)*Log2;
+      if ( nbosse >= NbossMX ) {
+        printf("Bosse: Trop de bosses (%d), changez dimension tableaux",nbosse);
+        exit(-1);
+      } else if ( nbosse == 0 ) {
+        classB[0] = 0;
+      } else if ( nbosse > 0 ) {
+        for ( j=0;j<nbosse;j++) 
+          if ( pc2 > fabs( (double) Pchi2[classB[j]] ) ) break;
+        for ( k=nbosse-1;k>=j;k--) classB[k+1] = classB[k];
+        classB[j] = nbosse;
+      }
+      Pchi2[nbosse] = sgnsave*pc2;
+      sc2 += sgnsave*c2;
+      chi2[nbosse] = sgnsave*c2;
+      npoint[nbosse] = npt;
+      ideb[nbosse] = i1;
+      ifin[nbosse] = i2;
+      if(deb>=3) printf("Find bosse %5d, npt=%5d lim=%5d %5d classB=%5d pc2=%.2f\n"
+                 ,nbosse,npoint[nbosse],ideb[nbosse],ifin[nbosse]
+                 ,classB[nbosse],Pchi2[nbosse]);
+    }
+    i1 = ipo;
+    npt = 1;
+    sgnsave = ( v > 0. ) ? 1 : -1;
+    c2 = v*v;
+    pc2 = nberfc(av/Rac2) + Log2;
+  }
+  ipo++;
+}
+
+nbosse++;
+if(deb) printf("Bosse: nombre de bosses trouvees=%d, somme des Pchi2=%f\n"
+              ,nbosse,sc2);
+if ( nbosse > 0 && deb ) {
+  k=3;
+  if ( deb >= 2 ) k=nbosse;
+  for (ipo=0;ipo<k;ipo++) {
+    j = classB[ipo];
+    printf("Find bosse %4d, npt=%5d lim=%5d %5d pc2=%.2f\n"
+          ,j,npoint[j],ideb[j],ifin[j],Pchi2[j]);
+  }
+}
+return(nbosse);
+}
+
+/*=========================================================================*/
+int BosseN(float *mag,float *err,int_4 ndata
+         ,float mean,float smin,int_4 nptsmin,float scut,int_4 nptscut
+         ,float *chi2,int_4 *npoint,float *Pchi2
+         ,int_4 *ideb,int_4 *ifin,int_4 *classB,int_4 NbossMX)
+/*                                      Christophe 27/12/95 Saclay
+**** Recherche de Bosses sur courbe de lumiere ****
+ENTREE:
+ mag: tableau des magnitudes
+ err: tableau des erreurs sur la magnitude (<=0 point non considere)
+ ndata: nombre de donnees dans les tableaux (mag,err)
+ mean: ligne de base par rapport a laquelle les bosses sont determinees
+ smin, nptsmin: condition de validation d une bosse:
+       nombre minimum de points au dessus (dessous)
+       de smin*err (-smin*err) pour valider une bosse
+ scut : condition de demarrage d une bosse:
+       1 point > scut (ou < -scut)
+ scut, nptscut: definition des conditions d'arret de la bosse:
+      nptscut points a moins de  scut**err si bosse positive
+      nptscut points a plus  de -scut**err si bosse negative
+      Conseil: scut = 1.
+ NbossMX: nombre maximum permis de bosses
+SORTIE:
+ chi2: tableau des Xi2 des bosses
+ npoint: tableau des nombres de points dans les bosses (du meme signe que la bosse)
+ Pchi2: tableau des probabilites de Xi2 des bosses
+ ideb: tableau des indices de debut des bosses
+ ifin: tableau des indices de fin des bosses (idem)
+ classB: tableau des indices de rangement par probabilite de Xi2 croissant
+        ex: pchi2 de la 3ieme bosse = Pchi2[classB[2]]
+ return: Bosse: nombre de bosses trouvees
+REMARQUE:
+ npoints != ifin-ideb+1 car
+           1-/ il y a des points a erreur <=0
+           2-/ les points de signes opposes
+               au signe de la bosse ne sont pas comptabilises
+         c'est le nombre de points de meme signe que la bosse dans la bosse
+         le nombre total de points dans la bossse est ifin-ideb+1
+*/
+{
+int deb=DEB_Bosse;               /* 0,1,2,3 */
+int j,k,ipo,npt=0,npt_cut=0,npt_c2_cut=0,i1=-1,i2=-1,sgn,sgnsave,nbosse,npt_valid,pass;
+double v,av,ev,c2,pc2,c2_cut,pc2_cut;
+char s;
+
+if(smin<0.) smin = 1.;
+if(nptsmin<=0) nptsmin = 1;
+if(scut<0.) scut = 1.;
+if(nptscut<=0) nptscut = 1;
+
+if(deb>=1) printf("***** BosseN ndata=%d smin=%d, %f scut=%d, %f\n"
+                 ,ndata,nptsmin,smin,nptscut,scut);
+
+if( ndata <= 1 ) return(-1);
+
+nbosse = -1;
+ipo = sgnsave = 0;
+
+for (;;) {
+  /* caracteristiques du point ipo */
+  ev = err[ipo];
+  if ( ev > 0. ) v = ( mag[ipo] - mean ) / ev; else v = 0.;
+  if ( v > 0. ) { av = v; sgn = 1; } else { av = -v; sgn = -1; }
+  if (deb>=3)
+      printf("     ipo=%5d sgn=%2d v=%f ev=%f c2=%f\n",ipo,sgn,v,ev,v*v);
+  if ( ev>0. && sgnsave==0 && av>=scut ) {
+    /* essai d'une nouvelle bosse (sgnsave==0), on demarre si > scut */
+    i1 = i2 = ipo;
+    sgnsave = sgn;
+    c2 = v*v;
+    pc2 = nberfc(av/Rac2) + Log2;
+    npt = 1;
+    if( av >= smin ) npt_valid = 1; else npt_valid = 0;
+    c2_cut = pc2_cut = 0.;
+    npt_cut = npt_c2_cut = 0;
+    if(deb>=3)
+      printf("* Dep bosse [%d] i1=%d n,c2,pc2= %d, %.3f, %.3f\n"
+            ,sgnsave,i1,npt,c2,pc2);
+  } else if( sgnsave!=0 &&
+             ( (ev>0. && sgnsave*v<scut) || ipo==ndata-1 ) ) {
+    /* c'est une possibilite de fin de bosse             */
+    /* c a d soit un point normal en position de coupure */
+    /*       soit le dernier point des tableaux          */
+    if ( ev>0. && sgnsave*v<scut ) {
+      /* point normal ou dernier point dans des conditions d arret de bosse */
+      s = '-';
+      npt_cut++;
+      if( sgn == sgnsave ) {
+        npt_c2_cut++;
+        c2_cut += v*v;
+        pc2_cut += nberfc(av/Rac2) + Log2;
+      }
+    } else if ( ev>0. && sgnsave*v>=scut ) {
+      /* c-a-d le dernier point (ipo==ndata-1)             */
+      /* avec une amplitude (grande) continuant la bosse   */
+      /* --> dans ce cas la bosse doit inclure ce point    */
+      /* et eventuellement les precedents de cette coupure */
+      s = '+';
+      npt += 1 + npt_c2_cut;
+      c2 += v*v + c2_cut;
+      pc2 += nberfc(av/Rac2) + Log2 + pc2_cut;
+      if( av >= smin ) npt_valid++;
+      i2 = ipo;
+    } else {
+      /* cas  ipo==ndata-1 et ev<=0. : point ignore */
+      s = '0';
+    }
+    if(deb>=3)
+       printf("- Fin%c ncut=%d n,c2,pc2= %d, %.3f, %.3f cut= %d, %.3f, %.3f\n"
+             ,s,npt_cut,npt,c2,pc2,npt_c2_cut,c2_cut,pc2_cut);
+    if ( npt_cut>=nptscut || ipo==ndata-1 ) {
+      /* c'est une fin de bosse */
+      if ( npt_valid >= nptsmin ) {
+        /* validation de la bosse */
+        nbosse++;
+        /* on prend prob(xi2,npt)/2**(npt-1)                            */
+      if(Bosse_probnb) 
+           pc2 = (double) probnb((float) c2,npt,&pass) + (npt-1)*Log2;
+        if ( nbosse >= NbossMX ) {
+          printf("Bosse: Trop de bosses (%d), changez dimension tableaux",nbosse);
+          return(-NbossMX);
+        } else if ( nbosse == 0 ) {
+          classB[0] = 0;
+        } else if ( nbosse > 0 ) {
+          for ( j=0;j<nbosse;j++) 
+            if ( pc2 > fabs( (double) Pchi2[classB[j]] ) ) break;
+          for ( k=nbosse-1;k>=j;k--) classB[k+1] = classB[k];
+          classB[j] = nbosse;
+        }
+        Pchi2[nbosse] = sgnsave*pc2;
+        chi2[nbosse] = sgnsave*c2;
+        npoint[nbosse] = npt;
+        ideb[nbosse] = i1;
+        ifin[nbosse] = i2;
+        if(deb>=3)
+           printf("* Bosse %d, lim=%d %d classB=%d n,c2,pc2=%d %.3f %.3f\n"
+                 ,nbosse,ideb[nbosse],ifin[nbosse],classB[nbosse]
+                 ,npoint[nbosse],chi2[nbosse],Pchi2[nbosse]);
+      } else {
+        if(deb>=3) printf("* Bosse rejetee npt=%d /%d\n",npt,nptsmin);
+      }
+      sgnsave = 0;
+      ipo = i2;
+    }
+  } else if ( ev>0. && sgnsave!=0 ) {
+    /* c'est un point normal dans la bosse */
+    npt += 1 + npt_c2_cut;
+    c2 += v*v + c2_cut;
+    pc2 += nberfc(av/Rac2) + Log2 + pc2_cut;
+    if( av >= smin ) npt_valid++;
+    i2 = ipo;
+    if(deb>=3)
+      printf("- add point i2=%d n,c2,pc2= %d, %.3f, %.3f cut= %d, %.3f, %.3f\n"
+            ,i2,npt,c2,pc2,npt_c2_cut,c2_cut,pc2_cut);
+    npt_cut = npt_c2_cut = 0;
+    c2_cut = pc2_cut = 0.;
+  } else {
+    /* point a erreur negative ou points a moins de scut sans bosse demarree */
+    if(deb>=3)
+       printf("- pas de bosse demarree (%d) ou erreur negative (%f)\n"
+             ,sgnsave,ev);
+  }
+  ipo++;
+  if(ipo >= ndata ) break;
+}
+nbosse++;
+
+if(deb>=1) {
+  printf("Bosse: nombre de bosses trouvees=%d\n",nbosse);
+  if ( nbosse>0 ) {
+    printf("********************************************************\n");
+    k=3;
+    if ( deb>=2 ) k=nbosse;
+    for (ipo=0;ipo<k;ipo++) {
+      j = classB[ipo];
+      printf("* bosse %4d, lim=%5d %5d n,c2,pc2=%d %.3f %.3f\n"
+            ,j,ideb[j],ifin[j],npoint[j],chi2[j],Pchi2[j]);
+    }
+    printf("********************************************************\n");
+  }
+}
+
+return(nbosse);
+}
+
+/*=========================================================================*/
+int_4 BossePaG(float *temps,float *mag,float *err,int_4 ndata,float mean
+            ,int_4 I1,int_4 I2,float *U0,float *T0,float *Tau)
+/*                                      Christophe 11/11/93 La Silla
+**** Recherche des parametres U0,T0,Tau d'une bosse ****
+          bosse + ou - en magnitude ou en flux
+ENTREE:
+ temps: temps
+ mag: magnitude
+ err: erreur sur la magnitude
+ ndata: nombre de donnees (si >0 mag=magnitudes, si <0 mag=flux)
+ mean: valeur de la ligne de base
+ I1: indice de depart de la bosse
+ I2: indice de fin de la bosse
+ U0: si >0 la bosse est positive, si <0 la bosse est negative
+SORTIE:
+ U0: estimation du parametre d'impact U0
+ T0: estimation du temps de minimum d'approche T0
+ Tau: estimation de la largeur Tau
+ BossePaG: retourne 0 si calcul ok, <0 sinon
+Methode:
+ Les parametres T0 et Tau sont estimes a partir de la
+ distribution en temps des points dans la bosse,
+ U0 par l'estimation de la hauteur de la gaussienne de sigma
+ calcule pour la valeur de Tau et de l'aire de la bosse.
+*/
+{
+int_4 deb=DEB_BossePaG;
+int_4 i,flu=0,bossp=1;
+float tprev,magprev;
+double v,m,s,norm,sint,hgauss,a,aa,u12,hmax;
+int ifirst;
+
+if( ndata<0 ) { flu=1; ndata *= -1;}
+if( *U0<0 ) bossp = -1;
+*U0 = *T0 = *Tau = 0.;
+if ( I2 <= I1 ) {printf("BossePaG: I1 <= I2 %d %d\n",I1,I2); return(-1);}
+if ( mean <= 0. && flu ) return(-11);
+if(deb) printf("BossePaG: de I1=%d a I2=%d n=%d mean=%g flu=%d\n"
+              ,I1,I2,ndata,mean,flu);
+
+/* Calcul de T0 et Tau */
+hmax= -1.e30;
+tprev = temps[I1]; magprev = mean; /* $CHECK$ EA  pas cool l'init de magprev */
+/* magprev peut etre une amplitude, mais pas mean !! */
+/* $CHECK$ EA si on tue le point I1, sint delire. Je rajoute ifirst */
+m = s = norm = sint = 0.;
+ifirst = 1;
+for (i=I1;i<=I2;i++) {
+  if ( err[i] <= 0. ) continue;
+  if(flu && bossp<0 && mag[i]<=0.) continue;
+  if(flu && bossp>=0) a = mag[i]/mean-1.;
+    else if(flu && bossp<0) a = 1.-mean/mag[i];
+      else a = mag[i]-mean;
+  aa = bossp*a;
+  if( aa<=0 ) continue;
+  if( aa > hmax ) hmax=aa;
+  v = temps[i];
+  m += v*aa;
+  s += v*v*aa;
+  norm += aa;
+  if ( !ifirst )
+    sint += (temps[i]-tprev)*(a+magprev)/2.;
+  else
+    ifirst = 0;
+  tprev = temps[i];
+  magprev = a;
+}
+if(norm <= 0. ) return(-2);
+sint = fabs(sint);
+m = m/norm;
+s = s/norm - m*m;
+if(s <= 0.) return(-3);
+s = sqrt(s);
+hgauss = sint / S2Pi / s;
+if (deb>=2) printf("m=%f s=%f int=%f hgauss=%f hmax=%f\n",m,s,sint,hgauss,hmax);
+
+/* T0 = moyenne */
+*T0 = m;
+
+/* U0 = hauteur de la gaussienne de sigma s */
+if(flu) a = hgauss+1.; else a = pow(10.,0.4*hgauss);
+if(a<=1. || a>= sqrt(GRAND2)) return(-4);
+*U0 = 2.*(a/sqrt(a*a-1.)-1.);
+if(deb>=2) printf("A0=%f u0^2=%f",a,*U0);
+
+/* Tau = en considerant que 2.36*s est la largeur 
+   a mi-hauteur (magnitude) de la courbe de pazcinski */
+if(flu) a = hgauss/2.+1.; else a = pow(10.,0.2*hgauss);
+if(a<1.) return(-5);
+u12 = 2*(a/sqrt(a*a-1.)-1.);
+if (deb>=2) printf(" a1/2=%f u1/2^2=%f\n",a,u12);
+v = 2.36*s/2.;
+if ( u12 <= *U0 ) return(-6);
+v = v*v/(u12-*U0);
+*Tau = sqrt(v);
+*U0 = sqrt(*U0);
+if (deb) printf("BossePaG: U0=%f, T0=%f, Tau=%f\n",*U0,*T0,*Tau);
+
+return(0);
+}
+
+/*=========================================================================*/
+float SigmaInt(float *temps,float *mag,float *err,int_4 *ndata,float nsigma)
+/*                                 Christophe 12/11/93 La Silla
+**** Calcul du sigma interne d'une courbe de lumiere ****
+ENTREE:
+ temps: temps
+ mag: magnitude
+ err: erreur sur la magnitude
+ ndata: nombre de donnees
+ nsigma: nombre de sigmas pour la coupure de la 2sd passe
+         si <=0 une seule passe
+SORTIE:
+ SigmaInt: retourne le sigma Interne ou <0 si il y a eu un probleme
+- Methode: On calcul le sigma avec la dispersion d'un point Y(t) et de la
+    prediction lineaire a partir de ses 2 voisins Y0(t) et Y1(t):
+    M = Y - Ypred = Y - (Y1 +(Y2-Y1)/(t2-t1)*(t-t1))
+    le calcul de propagation des erreurs donne:
+    SM = 2*(R^2-R+1)*SY avec SY=SY1=SY2 et R=(t-t1)/(t2-t1)  (<1.)
+    donc pour avoir SY on calcul le sigma de la quantite:
+    M et on divise le resultat par sqrt( <2*(R^2-R+1)> )
+    ce qui dans le cas ou les points sont equidistants 
+    donne comme R=1/2: SM/sqrt(3/2)
+*/
+{
+int_4 deb=DEB_SigmaInt;
+int_4 pass,passmx,i,n=0;
+float sigma;
+double m,s,fpred,R,sR;
+
+passmx = ( nsigma > 0. ) ? 2 : 1 ;
+if ( *ndata < 3 ) return(-1.);
+sigma = GRAND;
+if( nsigma <= 0. ) nsigma = 1.;
+for (pass=1;pass<=passmx;pass++) {
+  n=0;
+  m = s = sR = 0.;
+  for (i=1;i<*ndata-1;i++) {
+    if ( err[i] > 0. && err[i-1] > 0. && err[i+1] > 0. ) {
+      R = ( temps[i]  - temps[i-1] ) / ( temps[i+1]- temps[i-1] );
+      fpred = mag[i]  -  ( mag[i-1] + (mag[i+1]- mag[i-1] )*R );
+      if ( fabs(fpred) < nsigma*sigma ) {
+        m += fpred;
+        s += fpred*fpred;
+        sR += 2.*(R*R-R+1.);
+        n++;
+  } } }
+  if ( n <= 0 ) return(-2.);
+  m = m/n;
+  sR = sR/n;
+  sigma = sqrt(s/n) / sqrt(sR);
+  if ( deb ) printf("SigmaInt: pass=%d sigma=%f m=%f sR=%f npoints=%d\n"
+                   ,pass,sigma,m,sR,n);
+}
+*ndata = n;
+return(sigma);
+}
+
+/*=========================================================================*/
+int_4 FiltMed(float *mag,float *err
+	     ,float *magflt, float* errflt, int_4 ndata)
+/*                                   Christophe 13/11/93 La Silla
+**** Filtre Statistique Median a 3 points ****
+ENTREE:
+ mag: magnitude
+ err: erreur sur la magnitude
+ ndata: nombre de donnees
+SORTIE:
+ magflt: magnitude filtree
+ errflt: erreur sur la magnitude filtree
+ FiltMed: retourne 0 si ok, <0 sinon.
+*/
+{
+int deb=DEB_FiltMed;
+int j,k0,k1,k2,imin=-1,imax=-1;
+
+if ( ndata<3 ) {
+  for (k0=0;k0<ndata;k0++) 
+    { magflt[k0] = mag[k0]; errflt[k0] = err[k0];}
+  return(-1);
+}
+
+/* filtre median sur tous les points sauf le premier et le dernier */
+for (k0=1;k0<ndata-1;k0++) {
+  magflt[k0] = mag[k0]; errflt[k0] = err[k0];
+  if ( err[k0] <= 0. ) continue;
+  /*recherche du 1er point inferieur utilisable */
+  k1 = k0-1; while ( err[k1] <= 0. && k1 > 0       ) k1--;
+   /*  recherche du 1er point superieur utilisable */
+  k2 = k0+1; while ( err[k2] <= 0. && k2 < ndata-1 ) k2++;
+  if ( err[k1]<=0. || err[k2]<=0. ) continue;
+  if     ((mag[k1]-mag[k0])*(mag[k2]-mag[k0])<0.) j=k0;
+  else if((mag[k0]-mag[k1])*(mag[k2]-mag[k1])<0.) j=k1;
+  else if((mag[k1]-mag[k2])*(mag[k0]-mag[k2])<0.) j=k2;
+  else {
+    if     (mag[k0]==mag[k1]) {if(err[k0]<=err[k1]) j=k0; else j=k1;}
+    else if(mag[k1]==mag[k2]) {if(err[k1]<=err[k2]) j=k1; else j=k2;}
+    else                      {if(err[k2]< err[k0]) j=k2; else j=k0;}
+  }
+  magflt[k0] = mag[j]; errflt[k0] = err[j];
+  if( imin == -1 ) imin = k0; imax = k0;
+}
+
+/* cas du premier point */
+k0 = 0; magflt[k0] = mag[k0]; errflt[k0] = err[k0];
+if( err[k0]>0. && imin>=0 )
+  { magflt[k0] = magflt[imin]; errflt[k0] = errflt[imin];}
+
+/* cas du dernier point */
+k0 = ndata-1; magflt[k0] = mag[k0]; errflt[k0] = err[k0];
+if( err[k0]>0. && imax>=0 )
+  { magflt[k0] = magflt[imax]; errflt[k0] = errflt[imax];}
+
+/* debug? */
+if (deb>=1) {
+  printf("FiltMed:");
+  for(k0=0;k0<ndata+10;k0+=10) {
+     for(j=k0; j<k0+10 && j<ndata; j++)
+        { if(k0==j) printf("\nF "); printf(" %10.3f",mag[j]);}
+     for(j=k0; j<k0+10 && j<ndata; j++)
+        { if(k0==j) printf("\nE "); printf(" %10.3f",err[j]);}
+     for(j=k0; j<k0+10 && j<ndata; j++)
+        { if(k0==j) printf("\nFf"); printf(" %10.3f",magflt[j]);}
+     for(j=k0; j<k0+10 && j<ndata; j++)
+        { if(k0==j) printf("\nEf"); printf(" %10.3f",errflt[j]);}
+  }
+  printf("\n");
+}
+
+return(0);
+}
+
+/*=========================================================================*/
+int_4 FiltInt(float *temps,float *mag,float *err,int_4 ndata,int_4 I1,int_4 I2
+             ,float lbosse,int_4 npomin,int_4 *ideb,int_4 *ifin)
+/*                                   Christophe 15/11/93 La Silla
+**** Calcul de l'intervalle pour le fit ****
+ENTREE:
+ temps: temps
+ mag: magnitude
+ err: erreur sur la magnitude
+ ndata: nombre de donnees
+ I1: 1er indice de la bosse
+ I2: dernier indice de la bosse
+ lbosse: largeur (en unite de largeur de bosse)
+         a rajouter de part et d'autre de la bosse
+ npomin: nombre de points minimum avant/apres la bosse
+SORTIE:
+ ideb: indice du debut de l'intervalle
+ ifin: indice de fin de l'intervalle
+ FiltInt: retourne nombre de points dans l'intervalle et hors bosse,
+          <0 si probleme.
+*/
+{
+int_4 deb=DEB_FiltInt;
+int_4 i,n,ntot;
+float t1,t2;
+double dt;
+
+if ( I2 <= I1 ) {printf("FiltInt: I2 <= I1 %d %d\n",I1,I2); return(-1);}
+
+ntot = 0;
+t1 = temps[I1];
+t2 = temps[I2];
+lbosse = (lbosse<=0.) ? 1. : lbosse ;
+dt = (t2-t1)*lbosse;
+if(deb>1) printf("FiltInt: limites bosse %f %f (%f)\n",t1,t2,dt);
+t1 -= dt;
+t2 += dt;
+if(deb>1) printf("FiltInt: limites intervalle de fit %f %f\n",t1,t2);
+
+/* calcul de la borne inferieure de fit */
+n=0;
+for (i=I1;i>=0;i--) {
+  if(err[i] > 0. ) {
+    n++;
+    if( temps[i] < t1 && n > npomin ) break;
+} }
+ntot += n;
+*ideb= ( i<0 ) ? 0 : i;
+
+/* calcul de la borne superieure de fit */
+n=0;
+for (i=I2;i<ndata;i++) {
+  if(err[i] > 0. ) {
+    n++;
+    if( temps[i] > t2 && n > npomin ) break;
+} }
+ntot += n;
+*ifin= ( i>= ndata ) ? ndata-1 : i;
+
+if(deb) printf("FiltInt: limites intervalle de fit %d %d\n",*ideb,*ifin);
+
+return(ntot);
+}
+
+/*======================================================================================*/
+double chi2_exterieur(float *mag,float *err,int_4 ndata,float mean
+                     ,int_4 I1,int_4 I2,int_4 *npt)
+/*                         Cecile
+calcul du Chi2 par degre de liberte a l'exterieur de la bosse delimitee par i1 et I2
+ENTREE :
+ mag : magnitude
+ err : erreur sur la magnitude
+ ndata : nombre de donnees
+ mean : moyenne des mesures
+ I1, I2 : limites de la bosse
+SORTIE:
+ chi2_exterieur : valeur du Chi2 reduit a l'exterieur de la bosse
+*/
+{
+int_4 i;
+double chi2,d;
+
+if ( I2 <= I1 ) {printf("chi2_ext. : I2 <= I1 %d %d\n",I1,I2); return(-1.);}
+
+*npt=0;
+chi2=0.;
+
+if(I1>0) {
+  for(i=0;i<I1;i++) {
+    if( err[i] > 0.) {
+      d = (mag[i] - mean) / err[i];
+      chi2+= d*d;
+      (*npt)++;
+} } }
+
+if(I2<ndata) {
+  for(i=I2+1;i<ndata;i++) {
+    if( err[i] > 0.) {
+      d = (mag[i] - mean) / err[i];
+      chi2+= d*d;
+      (*npt)++;
+} } }
+
+return(chi2);
+}
+
+/*===================================================================*/
+double Dt_PacZin(double u0,double tau,double A)
+/* pour calculer le DT ou la paczinsky a une ampli de A */
+{
+double x;
+if( A <= 1. ) return(-1.);
+x = 2.*( A / sqrt(A*A-1.) - 1. ) - u0*u0;
+if( x <= 0. ) return(-2.);
+x = tau * sqrt(x);
+return(x);
+}
+
+/*==================================================================*/
+int_4 Most_3D2D(float *Y,float *EY,int_4 *ndata,float Ymin,float Ymax
+               ,float *Res_2D,float *Res_3D)
+/*
+Pour calculer la valeur la + probable par estimation des parametres
+  d'une distribution parabolique / polynome de degre 3
+INPUT:
+ Y: tableau des valeurs
+ EY: tableau des erreurs (<=0 point non traite)
+ ndata: nombre de valeurs
+ Ymin,Ymax: limites des valeurs a considerees pour Y
+OUTPUT:
+ ndata: nombre de valeurs utilisees pour le calcul
+ Res_2D: resultat du fit parabolique
+ Res_3D: resultat du fit polynome d'ordre 3
+ rc: validation des resultats
+       =0 : probleme
+       =1 : fit parabolique ok
+       =2 : fit polynome_ordre_3 ok
+       =3 : fit parabolique + polynome_ordre_3 ok
+*/
+{
+int i,n,Flag,lp=0;
+double xmoy,x2moy,x3moy;
+double v1,v2,VN,det;
+double M3[3][3],M2[2][2],B[3],AX[4];
+
+if(lp) printf("Most_3D2D: ndata=%d Ymin=%g Ymax=%g\n",*ndata,Ymin,Ymax);
+
+*Res_3D = 0.;
+*Res_2D = 0.;
+Flag = 0;
+
+if( *ndata<=0 || Ymax <= Ymin ) goto END;
+
+/* on recentre tout entre 0 et 1 donc Ymin=0 YMax=1 */
+VN = Ymax-Ymin;
+n = 0;
+xmoy = x2moy = x3moy = 0.;
+
+for(i=0;i<*ndata;i++)
+  {
+  if( EY[i]>0. && Y[i]>Ymin && Y[i]<Ymax )
+    {
+    v1 = (Y[i]-Ymin)/VN;
+    xmoy += v1;
+    x2moy += v1*v1;
+    x3moy += v1*v1*v1;
+    n++;
+    }
+  }
+if(n<=0) goto END;
+xmoy /= n;
+x2moy /= n;
+x3moy /= n;
+if(lp) printf("    <x>=%g <x2>=%g <x3>=%g\n",xmoy,x2moy,x3moy);
+
+/* On remplit la matrice 2x2 pour le fit parabolique */
+M2[0][0] = 1./5. -1./9.;
+M2[0][1] = M2[1][0] = M2[1][1] = 1./12.; /* = 1./4. -1./6. = 1./3. -1./4. */
+B[0] = x2moy - 1./3.;
+B[1] = xmoy - 0.5;
+det = SolveDLinSyst(&(M2[0][0]), B, AX, 2);
+if(lp) printf("Solve_2D: det=%g sol=%g %g\n",det,AX[0],AX[1]);
+if ( det != 0. ) 
+  {
+  if ( AX[0] != 0. )
+    {
+    Flag += 1;
+    *Res_2D = -AX[1]/(2.*AX[0]);
+    if(lp) printf("       s1=%g\n",*Res_2D);
+    *Res_2D = Ymin + *Res_2D*VN;
+    }
+  }
+
+/* On remplit la matrice 3x3 pour le fit polynome d'ordre 3 */
+M3[0][0] = M3[2][2] = 1./5. -1./8.;
+/* 1./12. = 1./4. -1./6. = 1./3. -1./4. = 1./6. -1./12 */
+M3[0][1] = M3[1][2] = M3[0][2] = M3[1][0] = M3[2][1] = 1./12.;
+M3[1][1] = 1./5. -1./9.;
+M3[2][0] = 1./7. -1./16.;
+B[0] = xmoy - 0.5;
+B[1] = x2moy - 1./3.;
+B[2] = x3moy - 0.25;
+det = SolveDLinSyst(&(M3[0][0]), B, AX, 3);
+if(lp) printf("Solve_3D: det=%g sol=%g %g %g\n",det,AX[0],AX[1],AX[2]);
+if ( det != 0. ) 
+  {
+  /* on cherche les 2 racines de l'annulation de la derivee */
+  det = AX[1]*AX[1] - 3.*AX[0]*AX[2];
+  if(lp) printf("       det=%g\n",det);
+  if ( det >= 0. && AX[0] != 0. )
+    {
+    xmoy =  (-AX[1] + sqrt(det))/(3.*AX[0]);
+    v1 = 6.*AX[0]*xmoy+2.*AX[1];
+    x2moy = (-AX[1] - sqrt(det))/(3.*AX[0]);
+    v2 = 6.*AX[0]*x2moy+2.*AX[1];
+    if(lp) printf("       s1=%g (%g) s2=%g (%g)\n",xmoy,v1,x2moy,v2);
+    Flag += 2;
+    *Res_3D = xmoy;
+    if(v2<0.) *Res_3D = x2moy;
+    *Res_3D = Ymin + *Res_3D*VN;
+    }
+  }
+
+
+END:
+if(lp) printf("Most_3D2D: *Res_2D=%g *Res_3D=%g Flag=%d\n"
+             ,*Res_2D,*Res_3D,Flag);
+return(Flag);
+}
+
+/*==================================================================*/
+double correlation(int_4 npts,double *x,double *y)
+{
+/*                        Cecile    Numerical Recipies p. 503
+Calcule le coefficient de correlation de x et y sur npts points
+ENTREE :
+ npts nombre de points
+ x, y tableau des valeurs
+SORTIE:
+ correlation : coefficient de correlation
+               -2 si nb de points OK < 3
+               -3 si produit des (x[i]-ax)(y[i]-ay)<=0
+*/
+int_4 i,n;
+double ax,ay,xt,yt,sxx,syy,sxy;
+n=0; ay = ax= 0.;
+for(i=0;i<npts;i++) {ax += x[i]; ay += y[i]; n++;}
+if( n<3 ) {
+  printf("correlation: moins de 3 points pour le calcul de la correlation (%d)\n",n);
+  return(-2.);
+}
+ax /= n; ay /= n;
+xt = yt = syy = sxy = sxx = 0.;
+for(i=0;i<npts;i++) {
+  xt = x[i]-ax;  yt = y[i]-ay;
+  sxx += xt*xt;  syy += yt*yt;  sxy += xt*yt;
+} 
+return( ((sxx*syy>0.) ? sxy/sqrt(sxx*syy) : -3.) );
+}
+
+/*==================================================================*/
+double CorrelatioN(int_4 nptX,float *X,float *Y,int_4* IndXvY)
+/*                                 cmv 17/4/99
+Calcule le coefficient de correlation de X[] et Y[] sur nptX points
+ENTREE :
+  nptX nombre de points dans le tableau X[]
+  X[], Y[] : tableau des valeurs a correler
+  IndXvY[] : tableau des indices de Y[] a correler a X[]
+SORTIE:  coefficient de correlation
+         -2 si nb de points OK (>3)
+         -3 si somme des (X[i]-ax)^2 ou (Y[i]-ay)^2 <=0
+EXPLICATION:
+  X[1,nptX-1], Y[....], IndXvY[1,nptX-1]
+  - le point X[i] correspond au point Y[IndXvY[i]] si IndXvY[i]>=0
+  - le point X[i] n'est pas pris en compte si IndXvY[i]<0
+*/
+{
+int_4 i,n;
+double ax,ay,xt,yt,sxx,syy,sxy;
+n=0; ay=ax=0.;
+for(i=0;i<nptX;i++) if(IndXvY[i]>=0) {ax+=X[i]; ay+=Y[IndXvY[i]]; n++;}
+if(n<3)
+  {printf("CorrelatioN: %d<3 points pour le calcul\n",n); return(-2.);}
+ax /= n; ay /= n;
+xt = yt = syy = sxy = sxx = 0.;
+for(i=0;i<nptX;i++) if(IndXvY[i]>=0)
+  { xt = X[i]-ax; yt = Y[IndXvY[i]]-ay;
+    sxx += xt*xt; syy += yt*yt;  sxy += xt*yt; }
+return( ((sxx*syy>0.) ? sxy/sqrt(sxx*syy) : -3.) );
+}
+
+/*=========================================================================*/
+int_4 MeanLine(float *mag,float *err,int_4 *ndata
+              ,int passmx,float nsigma,float *mean,float *sigma)
+/*
+Calcul de la moyenne et du sigma en plusieurs passes avec nettoyage
+ENTREE:
+ mag: magnitude
+ err: erreur sur la magnitude (Si NULL pas d'erreur)
+ ndata: nombre de donnees
+ nsigma: nombre de sigma dans lequel on calcule le mean
+ passmx: nombre de passes
+SORTIE:
+ ndata: nombre de data utilises pour calculer le most
+ mean: moyenne des donnees
+ sigma: sigma des donnees
+ MeanLine: 0 si calcul ok, <0 sinon
+*/
+{
+int_4 pass,n,i;
+double m,s2,scut,v;
+if( passmx<=0 ) passmx = 1;
+
+*mean = *sigma = 0.;
+for (pass=1;pass<=passmx;pass++) {
+  m = s2 = 0.; n=0;
+  if( pass>=2 ) scut=*sigma*nsigma; else scut=GRAND;
+  for (i=0;i<*ndata;i++) {
+    v = mag[i];
+    if(err!=NULL) if( err[i] <= 0. ) continue;
+    if( fabs(v-*mean) >= scut ) continue;
+    n++;
+    m += v;
+    s2 += v * v;
+  }
+  if ( n>0 ) {
+    m /= (double) n;
+    v = s2/n - m*m;
+    *mean = m;
+    *sigma = (v>0) ? sqrt(v) : 0.;
+  } else {
+    *mean = *sigma = 0.;
+    *ndata=n;
+    return(-1);
+  }
+  /* printf("MeanLine: pass=%d mean=%f sigma=%f n=%d\n"
+           ,pass,*mean,*sigma,n); */
+}
+return(0);
+}
+
+/*=========================================================================*/
+int_4 BaseLine(float *mag,float *err,int_4 *ndata,float nsigma
+            ,float binini,float *mean,float *sigma,float *most)
+/*                  Christophe 10/11/93 La Silla + modif 28/7/94 Saclay
+**** calcul de la ligne de base d'une etoile par maxi d'histogramme ****
+Methode: 1-/ moyenne, 2-/ moyenne tronquee,
+         3-/ maximum d'histogramme,
+         4-/ puis deuxieme passe sur histo plus lache
+ENTREE:
+ mag: magnitude
+ err: erreur sur la magnitude
+ ndata: nombre de donnees
+ nsigma: nombre de sigma dans lequel on calcule le maximum
+         si <=0, une seule passe pour la moyenne et dynamique histo = 5.
+ binini: bin minimum de la methode d'histogramme
+SORTIE:
+ ndata: nombre de data utilises pour calculer le most
+ mean: moyenne des donnees
+ sigma: sigma des donnees
+ most: maximum de probabilite
+RETURN: nombre d entrees dans le bin du maximum, <0 si echec
+*/
+{
+int_4 deb=DEB_BaseLine;
+int_4 pass,passmx,i,ib0,ib1,n=0,ibin,nbin=0,tab0mx,nbinmx=100,tab0[101];
+float mini,maxi,binw;
+double m,s2,v,vv,scut;
+double SX4,SX3,SX2,SX,S1,SYX2,SYX,SY;
+double MX33[3][3],BB[3],AX[3],det;
+
+if(deb) printf("BaseLine: n=%d nsigma=%f binini=%f\n",*ndata,nsigma,binini);
+
+/*********** D'abord une moyenne et sigma ************/
+*mean = *sigma = 0.;
+passmx = ( nsigma <= 0. ) ? 1 : 2 ;
+for (pass=1;pass<=passmx;pass++) {
+  m = s2 = 0.; n=0;
+  scut = GRAND;
+  if( pass == 2 ) scut = nsigma* *sigma;
+  for (i=0;i<*ndata;i++) {
+    v = mag[i];
+    if( err[i] <= 0. || fabs(v-*mean) >= scut ) continue;
+    n++;  m += v;  s2 += v*v;
+  }
+  if ( n >= 2 ) {
+    *mean = m / n;
+    v = s2 / n - m/n * m/n;
+    *sigma = ( v>0. ) ? sqrt(v) : 0.;
+  } else {
+    *mean = *sigma = 0.;
+    *ndata=n;
+    return(-1);
+  }
+  if(deb) printf("BaseLine: pass=%d mean=%f sigma=%f n=%d\n"
+                ,pass,*mean,*sigma,n);
+  if( *sigma == 0. ) return(-1);
+}
+
+/***** Puis une methode de maximum d'histogramme *****/
+if ( nsigma <= 0. ) nsigma = 5.;
+mini = *mean - nsigma * *sigma;
+maxi = *mean + nsigma * *sigma;
+
+for (pass=1;pass<=2;pass++) {
+
+  if( binini > 0. ) { 
+    if ( pass == 1 ) nbin = (maxi-mini)/(2.*binini) + 0.5; /* 1ere pass a 2*binini */
+    if ( pass == 2 ) nbin = (maxi-mini)/binini + 0.5;      /* 2sd  pass a   binini */
+    if ( nbin >= nbinmx ) nbin = nbinmx;
+    if ( nbin < 3 ) nbin = 3;
+  } else nbin = nbinmx;
+  binw = (maxi-mini)/nbin;
+  if(deb) printf("mini=%f maxi=%f binw=%f nbin=%d\n",mini,maxi,binw,nbin);
+
+  /*fill histogramme tab0*/
+  for (i=0;i<nbin;i++) tab0[i] = 0;
+  for (i=0;i<*ndata;i++) {
+    if( err[i] <= 0. ) continue;
+    ibin = (mag[i]-mini)/binw;
+    if( ibin >= 0 && ibin < nbin ) tab0[ibin] += 1;
+  }
+
+  /*maximum de l'histogramme tab0*/
+  ibin=0;
+  tab0mx = 0;
+  for (i=0;i<nbin;i++) if ( tab0[i] > tab0mx ) {tab0mx = tab0[i]; ibin=i;}
+  ib0 = ibin-1; ib1 = ibin+1;
+  if(ib0<0) { ib0 = 0; ib1++;}
+  if(ib1>=nbin) { ib1 = nbin-1; ib0--;}
+  if (deb>1) {
+    printf("Maximum tab0=%d (%d [%d,%d])\n",tab0mx,ibin,ib0,ib1);
+    if (deb>2) { printf("Tableau final tab0:\n");
+               for (i=0;i<nbin;i++) printf(" %d=%d",i,tab0[i]);
+               printf("\n"); }
+    }
+
+  /* calcul de la valeur maximale par fit parabole +/- 1 bin autour du maximum */
+  S1 = SY = SYX = SYX2 = SX4 = SX3 = SX2 = SX = 0.;
+  for (i=ib0;i<=ib1;i++) {
+    v = mini + (i+0.5)*binw;
+    vv = v*v;
+    m = tab0[i];
+    s2=1.;
+    S1 += s2;
+    SX += s2*v;
+    SY += s2*m;
+    SYX += s2*v*m;
+    SYX2 += s2*m*vv;
+    SX2 += s2*vv;
+    SX3 += s2*vv*v;
+    SX4 += s2*vv*vv;
+  }
+  MX33[0][0] = S1;
+  MX33[1][1] = SX2;
+  MX33[2][2] = SX4;
+  MX33[0][1] = MX33[1][0] = SX;
+  MX33[0][2] = MX33[2][0] = SX2;
+  MX33[1][2] = MX33[2][1] = SX3;
+  BB[0] = SY;
+  BB[1] = SYX;
+  BB[2] = SYX2;
+  det = SolveDLinSyst(&(MX33[0][0]), BB, AX, 3);
+  if( det == 0. ) return(-2);
+  if( AX[2] == 0. ) return(-2);
+  *most = -AX[1]/(2.*AX[2]);
+
+  if(deb)
+    printf("BaseLine: pass=%d most_probable=%f ibin=%d\n",pass,*most,ibin);
+
+  if( *most<=mini || *most >= maxi ) return(-3);
+
+  /*nouveaux parametres de l'histogramme tab0 */
+  mini   = *most-2.5*binw;
+  maxi   = *most+2.5*binw;
+
+}
+
+*ndata=n;
+return(tab0mx);
+}
+
+/*=========================================================================*/
+int BaseLineS(float *y,float *ey,int ny,int nfiltre,float *mean,float *sigma)
+/*    D'apres Alain M. + modifs + code cmv 5/5/97
+Determination de la ligne de base comme sequence de nfiltre points
+  consecutifs de dispersion minimale:
+  y : tableau des flux
+  ey : tableau des erreurs sur les flux (pt non util. si <=0)
+  ny : nombre de points
+  nfiltre : nombre de points consecutifs pour calculer le sigma
+            si <0 y est d'abord range par flux croissants
+  mean : valeur du fond de ciel retourne
+  sigma : valeur du sigma mini trouve
+  rc : nombre d essais ( si <=0 echec)
+*/
+{
+int rc=0, isort=0,i,j,npt,n;
+double s,m;
+float *ys=NULL;
+
+*mean = *sigma = -1.;
+if( ny<=1 ) return(-1);
+
+if( nfiltre<0 ) {
+  isort = 1;
+  nfiltre *= -1;
+  npt = 0;
+  ys = (float *) malloc(ny*sizeof(float));
+  if( ys==NULL ) return(-2);
+  for(i=0;i<ny;i++) if(ey[i]>0.) ys[npt++] = y[i];
+  qsort(ys,(size_t) npt,(size_t) sizeof(float),qSort_Float);
+} else { npt=ny; ys = y;}
+if( nfiltre>npt || nfiltre<=1 ) { if(isort) free(ys); return(-3);}
+
+for(i=0;i<npt-nfiltre+1;i++) {
+  if( !isort && ey[i]<=0. ) continue;
+  s = m = 0.;  n = 0;
+  for(j=i;j<npt;j++) {
+    if( !isort && ey[j]<=0. ) continue;
+    m += ys[j];  s += ys[j]*ys[j];  n++;
+    if( n<nfiltre ) continue;
+    rc++;
+    m /= (double) n;
+    s = s/n - m*m;
+    s = ( s>0. ) ? sqrt(s) : 0.;
+    if( s<*sigma || rc==1 ) { *sigma=s; *mean=m; }
+    break;
+  }
+}
+
+if(isort) free(ys);
+return(rc);
+}
+
+/*=========================================================================*/
+int BaseLineP(float *y,float *ey,int ny,int nfiltre,float *mean)
+/*    D'apres Alain M. + modifs + code cmv 5/5/97
+Determination de la ligne de base comme endroit de pente minimale
+  entre le point [i] et [i+nfiltre-1]. Ceci marche mieux avec
+  le tableau trie mais la possibilite de ne pas trier est laissee:
+  y : tableau des flux
+  ey : tableau des erreurs sur les flux (pt non util. si <=0)
+  ny : nombre de points
+  nfiltre : nombre de points pour calculer la pente
+            si <0 y est d'abord range par flux croissants
+  mean : valeur du fond de ciel retourne
+  rc : nombre d essais ( si <=0 echec)
+*/
+{
+int rc=0, isort=0,i,j,npt,n;
+float p=-1.,pmin=-1.,m;
+float *ys=NULL;
+
+*mean = -1.;
+if( ny<=1 ) return(-1);
+
+if( nfiltre<0 ) {
+  isort = 1;
+  nfiltre *= -1;
+  npt = 0;
+  ys = (float *) malloc(ny*sizeof(float));
+  if( ys==NULL ) return(-2);
+  for(i=0;i<ny;i++) if(ey[i]>0.) ys[npt++] = y[i];
+  qsort(ys,(size_t) npt,(size_t) sizeof(float),qSort_Float);
+} else { npt=ny; ys = y;}
+if( nfiltre>npt || nfiltre<=1 ) { if(isort) free(ys); return(-3);}
+
+for(i=0;i<npt-nfiltre+1;i++) {
+  if( !isort && ey[i]<=0. ) continue;
+  m = 0.;  n = 0;
+  for(j=i;j<npt;j++) {
+    if( !isort && ey[j]<=0. ) continue;
+    m += ys[j]; n++;
+    p = ys[j];
+    if( n<nfiltre ) continue;
+    rc++;
+    p = fabs(ys[i]-p);
+    if( p<pmin || rc==1 ) { pmin = p; *mean = m/n;}
+    break;
+  }
+}
+
+if(isort) free(ys);
+return(rc);
+}
Index: trunk/FrEROS/AnaLC/filtccd.h
===================================================================
--- trunk/FrEROS/AnaLC/filtccd.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/filtccd.h	(revision 3308)
@@ -0,0 +1,49 @@
+#ifndef  FILTCCD_H_SEEN  
+#define  FILTCCD_H_SEEN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void SetDebFilt(int razer);
+double LPacZin(double t,double *Par,double *DgDpar);
+double MPacZin(double t,double *Par,double *DgDpar);
+double LPacZin2(double t,double *Par,double *DgDpar);
+double MPacZin2(double t,double *Par,double *DgDpar);
+double LErrExt(double t,double *Par,double *DgDpar);
+void SetBosse_probnb(int iset);
+int_4 Bosse(float *mag,float *err,int_4 ndata
+         ,float mean,int_4 nptmin,float scut,int_4 nptscut
+         ,float *chi2,int_4 *npoint,float *Pchi2
+         ,int_4 *ideb,int_4 *ifin,int_4 *classB,int_4 NbossMX);
+int BosseN(float *mag,float *err,int_4 ndata
+         ,float mean,float smin,int_4 nptsmin,float scut,int_4 nptscut
+         ,float *chi2,int_4 *npoint,float *Pchi2
+         ,int_4 *ideb,int_4 *ifin,int_4 *classB,int_4 NbossMX);
+int_4 BossePaG(float *temps,float *mag,float *err,int_4 ndata,float mean
+            ,int_4 I1,int_4 I2,float *U0,float *T0,float *Tau);
+float SigmaInt(float *temps,float *mag,float *err,int_4 *ndata,float nsgima);
+int_4 FiltMed(float *mag,float *err
+	     ,float *magflt,float *errflt, int_4 ndata);
+int_4 FiltInt(float *temps,float *mag,float *err,int_4 ndata,int_4 I1,int_4 I2
+             ,float lbosse,int_4 npomin,int_4 *ideb,int_4 *ifin);
+double chi2_exterieur(float *mag,float *err,int_4 ndata
+                     ,float mean,int_4 I1,int_4 I2, int_4 *npt);
+double Dt_PacZin(double u0,double tau,double A);
+int_4 Most_3D2D(float *Y,float *EY,int_4 *ndata,float Ymin,float Ymax
+               ,float *Res_2D,float *Res_3D);
+double correlation(int_4 npts,double *x,double *y);
+double CorrelatioN(int_4 nptX,float *X,float *Y,int_4* IndXvY);
+int_4 MeanLine(float *mag,float *err,int_4 *ndata
+              ,int passmx,float nsigma,float *mean,float *sigma);
+int_4 BaseLine(float *mag,float *err,int_4 *ndata,float nsigma
+            ,float binini,float *mean,float *sigma,float *most);
+int BaseLineS(float *y,float *ey,int ny,int nfiltre,float *mean,float *sigma);
+int BaseLineP(float *y,float *ey,int ny,int nfiltre,float *mean);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
Index: trunk/FrEROS/AnaLC/fsvcache.c
===================================================================
--- trunk/FrEROS/AnaLC/fsvcache.c	(revision 3308)
+++ trunk/FrEROS/AnaLC/fsvcache.c	(revision 3308)
@@ -0,0 +1,1124 @@
+/*   Ce fichier contient les fonctions de creation, et de lecture */
+/*   du fichier de suivi des etoiles                              */
+/*                                      R. Ansari Mars 92         */
+ 
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "machdefs.h"
+#include "swapbytes.h"
+
+#include "fsvcache.h"
+#include "filecache.h"
+
+/*   SOPHYA V >= 2.130 , SWAPDEFAUT n'est plus defini */
+#if ( IS_BIG_ENDIAN == 0 ) 
+#define SWAPDEFAUT 1
+#else
+#define SWAPDEFAUT 0
+#endif
+
+#ifdef RFIO
+#include <shift.h>
+#endif
+ 
+/* 
+++ 
+  Module 	Gestion des Suivis (C)
+  Lib	fsv
+  include	fsvcache.h
+
+	Ce groupe de fonctions permettent de manipuler les fichiers de 
+	suivi. Les données sont stockées sous format binaire dans le
+	fichier et les fonctions de lecture/ écriture assure le 
+	changement de l'ordre des octets en fonction de l'architecture 
+	de la machine (Little Endian, Big Endian), à l'odre d'écriture des 
+	octets dans le fichier, et du format des données déclaré à la 
+	création du suivi. L'ordre d'écriture des octets dans le fichier
+	correspond à celui de la machine où a lieu la création du fichier.
+	Une description plus detaillée se trouve dans la note Peida No 1.
+--
+*/
+
+/*  declaration des fonctions privees de ce fichier  */
+ 
+#ifdef IBMVM
+#define FindSizeofRec FndSzRec
+#endif
+ 
+int_4 FindSizeofRec(char *fmt);
+void SwapSuiviEntete(ENTETESUIVI *hp);
+void SwapSuiviRecord(char* rec, char* fmt, int fmtl, int nr);
+
+static int sv_prtlev = 0;
+/* Nouvelle-Fonction */
+void SuiviSetPrtLevel(int lev)
+{
+sv_prtlev = lev;
+zfSetPrtLevel(lev);
+}
+ 
+ 
+/*
+++
+Titre	Création des fichiers de suivi 
+--
+*/
+/*
+++
+int SuiviCreate(char *filename, int typ, int rec0size, char *rec1fmt, -
+                char *rec2fmt, char *rec3fmt, char *rec4fmt, int nitem)
+
+	Cette fonction crée la structure d'entete avec 
+	la définition des formats des enregistrements (record). 
+|	filename : Nom de fichier 
+|	typ : Identificateur de type de fichier de suivi
+|	rec0size : Taille de la zone commentaire (Rec-0) en octets
+|	recifmt : (i=1..4) Format des records Rec-i (i=1..4) 
+|	nitem : facteur de groupement des mesures
+	Les formats sont spécifiés sous forme d'une chaine de caractère décrivant
+	la succession de valeurs constituant un record (Ex: "IIFFS").
+|	I ou L : entier (4 octets)
+|	S : entier (2 octets)
+|	F : Reel (4 octets)
+|	D : Double precision (8 octets)
+	Le code de retour est nul (0) en cas de succès.
+--
+*/ 
+
+/* Nouvelle-Fonction */
+int SuiviCreate(char *filename, int typ, int rec0size, char *rec1fmt,
+                char *rec2fmt, char *rec3fmt, char *rec4fmt, int nitem)
+ 
+/*  Cette fonction permet la creation d'un fichier de suivi  */
+/*  Retourne 0 si OK  -  Non-nul si probleme.                */
+/*  Arguments :                                              */
+/*     - filename : Nom de fichier.                          */
+/*     - typ : valeur stockee ds l'entete (Type)             */
+/*     - rec0size : Taille de la zone comment (Rec0) en byte */
+/*     - rec1/2/3/4fmt : Format des records type 1,2,3,4     */
+/*     Les formats sont specifies sous forme d'une chaines   */
+/*     de charactere avec le codage suivant:                 */
+/*       I S L : Entiers short int  et long int (L=I)        */
+/*       F D   : float et double                             */
+/*     - nitem : Nb de mesures / record   (def = 10)         */
+ 
+{
+ 
+int i;
+ENTETESUIVI head;
+FILE *fip;
+char fiac[80];
+ 
+ 
+if (rec0size < 0) rec0size=0;
+if (nitem <= 0)  nitem = 10;
+ 
+head.RecSize[0] = rec0size;
+head.NItem = nitem;
+head.NbMesTot = head.NbStars = (int_4)0;
+head.Swap = 0;
+head.Type = typ;
+head.FgCorrupt = 0;
+/*  Pour le Byte-Swap  */
+if (SWAPDEFAUT)  head.Swap = 0xFFFF;
+else head.Swap = 0;
+ 
+/*  Analyse des formats   */
+if ( (head.RecSize[1] = FindSizeofRec(rec1fmt)) <= 0 )
+  { printf("  SuiviCreate-Erreur ds format Rec_1 \n"); return(1); }
+if ( (head.RecSize[2] = FindSizeofRec(rec2fmt)) <= 0 )
+  { printf("  SuiviCreate-Erreur ds format Rec_2 \n"); return(2); }
+if ( (head.RecSize[3] = FindSizeofRec(rec3fmt)) <= 0 )
+  { printf("  SuiviCreate-Erreur ds format Rec_3 \n"); return(3); }
+if ( (head.RecSize[4] = FindSizeofRec(rec4fmt)) <= 0 )
+  { printf("  SuiviCreate-Erreur ds format Rec_4 \n"); return(4); }
+ 
+head.RecSize[3] *= head.NItem;
+head.RecSize[4] *= head.NItem;
+ 
+ 
+head.FmtSize[0] = 0;
+head.FmtSize[1] = strlen(rec1fmt);
+head.FmtSize[2] = strlen(rec2fmt);
+head.FmtSize[3] = strlen(rec3fmt);
+head.FmtSize[4] = strlen(rec4fmt);
+ 
+ 
+head.HSize = sizeof(ENTETESUIVI);
+for(i=0; i<5; i++)  head.HSize += head.FmtSize[i];
+head.FileSize = head.HSize;
+ 
+#ifndef IBMVM
+strcpy(fiac,"wb");
+#else
+strcpy(fiac,"wb, recfm=FS, lrecl=1024");
+#endif
+ 
+if ((fip=fopen(filename,fiac)) == NULL)
+  { printf("  SuiviCreate-Erreur ouverture fichier \n"); return(10); }
+ 
+ 
+fwrite(&head,sizeof(ENTETESUIVI),1,fip);
+fwrite(rec1fmt,1,head.FmtSize[1],fip);
+fwrite(rec2fmt,1,head.FmtSize[2],fip);
+fwrite(rec3fmt,1,head.FmtSize[3],fip);
+fwrite(rec4fmt,1,head.FmtSize[4],fip);
+ 
+fclose(fip);
+ 
+return(0);
+}
+ 
+#ifdef IBMVM
+int NPg[5]={0,50,100,150,200};
+int PgSz[5]={0,4096,8092,16184,32768};
+#else
+int NPg[5]={0,10,50,100,200};
+int PgSz[5]={0,2048,2048,4096,8092};
+#endif
+ 
+/*
+++
+Titre	Ouverture, fermeture des suivis
+	Le pointeur (l'identificateur) de fichier renvoyé par 
+	"SuiviOpen()" est le premier argument de toutes les autres 
+	fonctions "(suivifip)".
+--
+*/
+
+/*
+++
+SUIVIFIP *SuiviOpen(char * filename, int rw)
+	Ouverture du fichier en mode lecture "rw=SUOF_RO" ou 
+	lecture/ecriture "rw=SUOF_RW". L'activation de la
+	memoire cache se fait aussi a travers l'argument "rw"
+|	SUOF_RW_MEM, SUOF_RO_MEM
+|	ou MEM2 , MEM3, MEM4
+
+int SuiviClose(SUIVIFIP *suivfip)
+	fermeture du fichier de suivi. Le fichier peut être corrompu s'il est 
+	ouvert en écriture et si "SuiviClose()" n'est pas appelé.  
+
+void SuiviSetPrtLevel(int lev)
+	Modification du niveau d'impression des messages d'informations/debug
+	
+--
+*/
+
+/* Nouvelle-Fonction */ 
+SUIVIFIP *SuiviOpen(char * filename, int rw)
+ 
+/* Fonction d'ouverture de fichier de suivi pour lecture/ecriture   */
+/* Retourne un pointeur sur la structure SUIVIFIP - NULL si Pb.     */
+/*    rw : Flag d'ouverture fichier en Read/Write  SUOF_RW          */
+/*                                 ou en ReadOnly  SUOF_RO          */
+ 
+{
+SUIVIFIP *sfip;
+char *po;
+char fiac[20];
+int mopt;
+FILE *fip;
+int_4 res2;
+char* fmtspace; 
+int i,lfmt,rsz;
+ 
+if ((po=(char *)malloc(sizeof(SUIVIFIP)+strlen(filename)+1)) == NULL)
+  { printf(" SuiviOpen_Erreur : Pb malloc() \n"); return(NULL); }
+sfip = (SUIVIFIP *)(po);
+sfip->Nom = po+sizeof(SUIVIFIP);
+ 
+mopt = rw/10;
+if ( (mopt<0) || (mopt>4) )   mopt=0;
+rw = rw%10;
+ 
+if ( rw == SUOF_RW )  { strcpy(fiac,"rb+"); sfip->FgRW = SUOF_RW ; }
+else { strcpy(fiac,"rb");  sfip->FgRW = rw = SUOF_RO ; }
+ 
+#ifdef IBMVM
+strcat(fiac,"b");
+#endif
+
+/*  Lecture entete  - En cas de d'ouverture en RW, on reecrit l'entete  */
+/*  en utilisant le mot FgCorrupt qui passe a negatif -                 */
+/*  Head.FgCorrupt = Flag FileCorrupted                                 */ 
+/*  OK -> FgCorrupt == NbMesTot , Negatif -> -(Derniere mesure OK)      */
+/*  ou -99999999                  Reza 10/12/96                         */
+
+if ( (fip = fopen(filename,fiac)) == NULL )  
+  { printf("SuiviOpen_Erreur : Pb fopen(%s) \n",filename); 
+  free(po); return(NULL); }
+
+fseek(fip, (long)0, SEEK_SET);
+fread(&(sfip->Head),sizeof(ENTETESUIVI),1,fip);
+
+/*  On verifie avant tout si le fichier doit etre byte-swape  */
+if ( (sfip->Head.Swap != 0)  &&  (SWAPDEFAUT != 0) )  sfip->FgSwap = 0;
+else if ( (sfip->Head.Swap == 0)  &&  (SWAPDEFAUT == 0) )  sfip->FgSwap = 0;
+else { 
+  sfip->FgSwap = 1;
+  if (sv_prtlev > 3) printf("SuiviOpen_Warning: ByteSwap[%x,%x] de Suivi(%s) \n", 
+                           (int)SWAPDEFAUT, (int)sfip->Head.Swap, filename);
+  SwapSuiviEntete(&(sfip->Head));
+}
+
+/*  Allocation d'espace pour les formats */
+lfmt = 0;
+for(i=1;i<5;i++)  lfmt += (sfip->Head.FmtSize[i]+1);
+
+fmtspace = (char *)malloc(lfmt);
+if (fmtspace == NULL) { 
+  printf(" SuiviOpen_Erreur : Pb. malloc fmtspace \n");
+  free(po); return(NULL); }
+
+sfip->RecFmt[0] = fmtspace;
+/*  Lecture des elements de formats   */ 
+for(i=1;i<5;i++) {
+  sfip->RecFmt[i] = fmtspace;
+  if ( (rsz=sfip->Head.FmtSize[i]) <= 0)  continue;
+  fread(sfip->RecFmt[i], 1, rsz, fip);  
+  *(sfip->RecFmt[i]+rsz) = '\0';
+  fmtspace += rsz;
+  }
+ 
+res2 = sfip->Head.FgCorrupt;
+/* NbMesTot < 0 ne devrait pas arriver ! */
+if (sfip->Head.NbMesTot < 0) {
+  printf("SuiviOpen_Erreur: NMes<0 File=%s (FgCorrupt=%d NMes=%d) !?\n",
+         filename, res2, sfip->Head.NbMesTot); 
+  free(fmtspace); free(po); 
+  fclose(fip); return(NULL); 
+}
+  
+if (res2 != sfip->Head.NbMesTot)  
+  printf("SuiviOpen_Warning : file %s corrompu  (FgCorrupt=%d NMes=%d) !?\n",
+         filename, res2, sfip->Head.NbMesTot); 
+if ( (rw == SUOF_RW) && (res2 >= 0) )
+  {
+  sfip->Head.FgCorrupt = -res2;
+  if (sfip->Head.FgCorrupt == 0)  sfip->Head.FgCorrupt = -99999999;
+  if (sfip->Head.Swap)    SwapSuiviEntete(&(sfip->Head));  /* Avant ecriture */
+  fseek(fip, (long)0, SEEK_SET);
+  fwrite(&(sfip->Head),sizeof(ENTETESUIVI),1,fip);
+  if (sfip->Head.Swap)    SwapSuiviEntete(&(sfip->Head));  /* Reswap apres ecriture */
+  sfip->Head.FgCorrupt = res2;
+  }
+fclose(fip);
+
+/*   Ouverture fichier  */
+if ( (sfip->fcp = zfopen(filename,fiac,NPg[mopt],PgSz[mopt])) == NULL )
+  { printf("SuiviOpen_Erreur : Pb zfopen(%s) \n",filename); 
+  free(fmtspace); free(po); return(NULL); }
+ 
+sfip->fip = sfip->fcp->fip;  
+strcpy(sfip->Nom,filename);
+sfip->OffsetMes = sfip->Head.HSize + sfip->Head.RecSize[0] +
+                  sfip->Head.RecSize[1] +
+                  sfip->Head.NbStars*sfip->Head.RecSize[2];
+ 
+/*  Impression de debug   */
+if (sv_prtlev > 3)
+  { 
+  printf(" SuiviOpen_Debug : File= %s , TotSize,Hsize= %ld , %ld  Offset= %ld Swap=%x\n",
+    sfip->Nom,(long)sfip->Head.FileSize, (long)sfip->Head.HSize, 
+    (long)sfip->OffsetMes, (int)sfip->Head.Swap);
+  printf(" SuiviOpen_Debug : RecSize[0..4] %d %d %d %d %d\n",sfip->Head.RecSize[0],
+   sfip->Head.RecSize[1],sfip->Head.RecSize[2],sfip->Head.RecSize[3],sfip->Head.RecSize[4]);
+  printf(" SuiviOpen_Debug : FmtSize[0..4] %d %d %d %d %d\n",sfip->Head.FmtSize[0],
+   sfip->Head.FmtSize[1],sfip->Head.FmtSize[2],sfip->Head.FmtSize[3],sfip->Head.FmtSize[4]);
+  printf(" SuiviOpen_Debug : NItem,NbStars,NbMesTot %d %d %d Type=%d (FgCorrupt= %d)\n",
+    sfip->Head.NItem,sfip->Head.NbStars,sfip->Head.NbMesTot,
+    (int)sfip->Head.Type, sfip->Head.FgCorrupt);
+  } 
+ 
+ 
+return(sfip);
+}
+ 
+/*
+++
+Titre	Accès aux informations de l'entête
+	Les fonctions suivantes permettent d'accéder a certaines 
+	informations sauvegardées dans l'entête (Nb. d'étoiles, 
+	de mesures, ...)
+--
+*/
+
+/*
+++
+int_4 SuiviGetNbStars(SUIVIFIP *suivfip)
+	Retourne le nombre d'étoiles dans le fichier.
+
+int_4 SuiviGetNbMesures(SUIVIFIP *suivfip)
+	Retourne le nombre de mesures dans le fichier.
+
+int_4 SuiviGetType(SUIVIFIP *suivfip)
+	Retourne le type déclaré à la création du fichier.
+
+int_4 SuiviGetSize(SUIVIFIP *suivfip)
+	Retourne la taille actuelle du fichier de suivi.
+
+int_4 SuiviPredictSize(SUIVIFIP *suivfip, int nbst, int nbmes)
+	Retourne la taille calculée pour le fichier avec "nbst" étoiles
+	et "nbmes" mesures.
+--
+*/
+
+ 
+/* Nouvelle-Fonction */
+int_4 SuiviGetNbytStars(SUIVIFIP *suivfip)
+/*  Retourne le nombre d'item pour chaque mesure ds le fichier   */
+{  return ( suivfip->Head.RecSize[4] / suivfip->Head.NItem ) ; }
+ 
+ 
+/* Nouvelle-Fonction */
+int_4 SuiviGetNbStars(SUIVIFIP *suivfip)
+/*  Retourne le nombre d'etoiles ds le fichier   */
+{  return ( suivfip->Head.NbStars ) ; }
+ 
+/* Nouvelle-Fonction */
+int_4 SuiviGetNbMesures(SUIVIFIP *suivfip)
+/*  Retourne le nb de mesures ds le fichier   */
+{  return ( suivfip->Head.NbMesTot ) ; }
+ 
+/* Nouvelle-Fonction */
+int_4 SuiviGetType(SUIVIFIP *suivfip)
+/*  Retourne le type de fichier declare ds l'entete le fichier   */
+{  return ( suivfip->Head.Type ) ; }
+ 
+/* Nouvelle-Fonction */
+int_4 SuiviGetSize(SUIVIFIP *suivfip)
+/*  Retourne la taille actuelle du fichier de suivi */
+{  return ( suivfip->Head.FileSize ) ; }
+ 
+/* Nouvelle-Fonction */
+int_4 SuiviPredictSize(SUIVIFIP *sfip, int nbst, int nbmes)
+/*  Retourne la taille calculee pour le nb d'etoiles (nbst) et mesures (nbmes)   */
+{  
+int_4 totsz, nbm;
+totsz = sfip->Head.HSize + sfip->Head.RecSize[0] + /* Entete+zone commentaire  */
+        sfip->Head.RecSize[1] +                    /*  Zone globinfo */
+        nbst*sfip->Head.RecSize[2];                /* Les starInfos   */
+
+/*  On calcule le nombre de blocks mesures */
+nbm = nbmes / sfip->Head.NItem;  /* Les mesures sont groupees par block de NItem */
+if ((nbmes%sfip->Head.NItem) != 0)  nbm++;
+totsz += nbm*(sfip->Head.RecSize[3] + nbst*sfip->Head.RecSize[4]);
+return ( totsz ) ; 
+}
+ 
+ 
+ 
+ 
+/* Nouvelle-Fonction */
+ 
+int SuiviClose(SUIVIFIP *suivfip)
+ 
+/*   Fonction de fermeture de fichier de suivi - Cet appel est obligatoire en */
+/* cas de modification (ecriture) du fichier de suivi, avant la fin du prog.  */
+/*   Retour 0 OK  -  NonNul-> Erreur                                          */
+ 
+{
+if (suivfip == NULL)  return(1);
+ 
+/*  Ecriture entete fichier  */
+if (suivfip->FgRW == SUOF_RW)
+  {
+   if (suivfip->Head.FgCorrupt >= 0)  /*  M.A.J Flag FileCorrupted */
+    suivfip->Head.FgCorrupt = suivfip->Head.NbMesTot;
+  if (suivfip->FgSwap)   /*  On byte-swap avant ecriture */
+    SwapSuiviEntete(&(suivfip->Head));
+  if (zfseek(suivfip->fcp, (long)(0), SEEK_SET) != 0)
+    { printf(" SuiviClose_Erreur : Pb zfseek() \n"); return(10); }
+  zfwrite(&(suivfip->Head),sizeof(ENTETESUIVI),1,suivfip->fcp);
+  }
+ 
+zfclose(suivfip->fcp);
+free(suivfip->RecFmt[0]);
+free(suivfip);
+ 
+return(0);
+ 
+}
+ 
+ 
+/*
+++
+Titre	Lecture, écriture
+	Pour toutes les fonctions de lecture/ecriture, "buff"
+	 désigne le pointeur d'une zone mémoire contenant 
+	l'information à écrire ou destinée à recevoir 
+	l'information lue dans le fichier de suivi.   
+	L'argument "numet" indique le numéro d'étoile (1..NbStars),
+	et "numes" le numéro de mesure (1..NbMes).
+	Le code de retour est non nul en cas d'erreur. 
+--
+*/
+
+/*
+++
+int SuiviWriteComment(SUIVIFIP *suivfip, char *buff)
+	Ecriture de la zone commentaire.
+
+int SuiviReadComment(SUIVIFIP *suivfip, char *buff)
+	Lecture de la zone commentaire.
+
+--
+*/
+ 
+ 
+/* Nouvelle-Fonction */
+ 
+int SuiviWriteComment(SUIVIFIP *suivfip, char *buff)
+ 
+/*   Cette fonction ecrit les comment ds le fichier de suivi   */
+/*  retour 0 OK                                                */
+ 
+{
+int_4 sz;
+int rc;
+ 
+if (suivfip == NULL)  return(1);
+if (suivfip->FgRW != SUOF_RW)
+  {printf(" SuiviWriteComment_Erreur : Fichier ReadOnly \n"); return(2);}
+ 
+/*  Ecriture */
+rc = 0;
+if (zfseek(suivfip->fcp, (long)suivfip->Head.HSize, SEEK_SET) != 0)
+  { printf(" SuiviWriteComment_Erreur : Pb zfseek() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 10; }
+else if (zfwrite(buff,1,(size_t)suivfip->Head.RecSize[0],suivfip->fcp) != suivfip->Head.RecSize[0])
+  { printf(" SuiviWriteComment_Erreur : Pb zfwrite() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 11; }
+ 
+/*  M.A.J. Entete  */
+sz = suivfip->Head.HSize+suivfip->Head.RecSize[0];
+if (suivfip->Head.FileSize < sz)  suivfip->Head.FileSize = sz;
+ 
+return(rc);
+}
+ 
+ 
+ 
+ 
+/* Nouvelle-Fonction */
+ 
+int SuiviReadComment(SUIVIFIP *suivfip, char *buff)
+ 
+/*   Cette fonction lit les comment ds le fichier de suivi   */
+/*       retour 0 OK                                         */
+ 
+{
+if (suivfip == NULL)  return(1);
+if (zfseek(suivfip->fcp, (long)suivfip->Head.HSize, SEEK_SET) != 0)
+  { printf(" SuiviReadComment_Erreur : Pb zfseek() \n"); return(10); }
+zfread(buff,1,(size_t)suivfip->Head.RecSize[0],suivfip->fcp);
+return(0);
+}
+ 
+ 
+ 
+/*
+++
+int SuiviWriteGlobInfo(SUIVIFIP *suivfip, char *buff)
+	Ecriture de l'enregistrement GlobInfo.
+
+int SuiviReadGlobInfo(SUIVIFIP *suivfip, char *buff)
+	Lecture de l'enregistrement GlobInfo.
+
+--
+*/
+
+/* Nouvelle-Fonction */
+ 
+int SuiviWriteGlobInfo(SUIVIFIP *suivfip, char *buff)
+ 
+/*   Cette fonction ecrit l'enregistrement des infos globales   */
+/*  retour 0 OK                                                 */
+ 
+{
+int_4 sz;
+int rc;
+ 
+if (suivfip == NULL)  return(1);
+if (suivfip->FgRW != SUOF_RW)
+  {printf(" SuiviWriteComment_Erreur : Fichier ReadOnly \n"); return(2);}
+
+if (suivfip->FgSwap)   /*  On byte-swap avant ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[1], suivfip->Head.FmtSize[1], 1);
+/*  Ecriture */
+rc = 0;
+sz = suivfip->Head.HSize+suivfip->Head.RecSize[0];
+if (zfseek(suivfip->fcp, (long)sz, SEEK_SET) != 0)
+  { printf(" SuiviWriteGlobInfo_Erreur : Pb zfseek() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 10; }
+else if (zfwrite(buff,1,(size_t)suivfip->Head.RecSize[1],suivfip->fcp) != suivfip->Head.RecSize[1])
+  { printf(" SuiviWriteGlobInfo_Erreur : Pb zfwrite() \n"); 
+  suivfip->Head.FgCorrupt = -99999999; rc = 11; }
+
+
+if (suivfip->FgSwap)   /*  On remet dans le bon sens */
+  SwapSuiviRecord(buff, suivfip->RecFmt[1], suivfip->Head.FmtSize[1], 1);
+ 
+/*  M.A.J. Entete  */
+sz = suivfip->Head.HSize + suivfip->Head.RecSize[0] +
+                           suivfip->Head.RecSize[1];
+if (suivfip->Head.FileSize < sz)  suivfip->Head.FileSize = sz;
+ 
+return(rc);
+}
+ 
+ 
+ 
+ 
+/* Nouvelle-Fonction */
+ 
+int SuiviReadGlobInfo(SUIVIFIP *suivfip, char *buff)
+ 
+/*   Cette fonction lit l'enregistrement des infos globales   */
+/*       retour 0 OK                                          */
+ 
+{
+int_4 pos;
+if (suivfip == NULL)  return(1);
+pos = suivfip->Head.HSize+suivfip->Head.RecSize[0];
+if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+  { printf(" SuiviReadGlobInfo_Erreur : Pb zfseek() \n"); return(10); }
+zfread(buff,1,(size_t)suivfip->Head.RecSize[1],suivfip->fcp);
+if (suivfip->FgSwap)   /*  On byte-swap apres lecture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[1], suivfip->Head.FmtSize[1], 1);
+return(0);
+}
+ 
+
+/*
+++
+int SuiviWriteStarInfo(SUIVIFIP *suivfip, int_4 num, char *buff)
+	Ecriture de l'enregistrement StarInfo pour l'étoile "num"
+
+int SuiviReadStarInfo(SUIVIFIP *suivfip, int_4 num, char *buff)
+	Lecture de l'enregistrement StarInfo pour l'étoile "num"
+--
+*/
+  
+ 
+/* Nouvelle-Fonction */
+ 
+int SuiviWriteStarInfo(SUIVIFIP *suivfip, int_4 num, char *buff)
+ 
+/*   Cette fonction ecrit les infos etoiles pour l'etoile   */
+/*  numero num -  Retour 0  OK                              */
+ 
+{
+int_4 sz,pos;
+int rc;
+ 
+if (suivfip == NULL)  return(1);
+if (suivfip->FgRW != SUOF_RW)
+  {printf(" SuiviWriteStarInfo_Erreur : Fichier ReadOnly \n");  return(2);}
+if (num <= (int_4)0)
+  { printf(" SuiviWriteStarInfo_Erreur : Num (=%ld) <= 0 \n",(long)num); return(3); }
+ 
+if ( (suivfip->Head.NbMesTot > 0) && (suivfip->Head.NbStars < num) )
+  { printf(" SuiviWriteStarInfo_Erreur : Fichier contient des mesures ! \n");
+    return(4); }
+
+if (suivfip->FgSwap)   /*  On byte-swap avant ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[2], suivfip->Head.FmtSize[2], 1);
+ 
+/*  Ecriture */
+pos = suivfip->Head.HSize + suivfip->Head.RecSize[0] +
+      suivfip->Head.RecSize[1] +
+      (num-1)*suivfip->Head.RecSize[2];
+rc = 0;
+if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+  { printf(" SuiviWriteStarInfo_Erreur : Pb zfseek() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 10; }
+else if ( zfwrite(buff,1,(size_t)suivfip->Head.RecSize[2],suivfip->fcp) != suivfip->Head.RecSize[2])
+  { printf(" SuiviWriteStarInfo_Erreur : Pb zfwrite() \n"); 
+  suivfip->Head.FgCorrupt = -99999999; rc = 11; }
+
+if (suivfip->FgSwap)   /*  On remet dans le bon sens */
+  SwapSuiviRecord(buff, suivfip->RecFmt[2], suivfip->Head.FmtSize[2], 1);
+ 
+/*  M.A.J. Entete  */
+sz = pos+suivfip->Head.RecSize[2];
+if (suivfip->Head.FileSize < sz)  suivfip->Head.FileSize = sz;
+if (suivfip->Head.NbStars < num)
+  {
+  suivfip->Head.NbStars = num;
+  suivfip->OffsetMes = suivfip->Head.HSize + suivfip->Head.RecSize[0] +
+                       suivfip->Head.RecSize[1] +
+                       suivfip->Head.NbStars*suivfip->Head.RecSize[2];
+  }
+ 
+return(rc);
+}
+ 
+ 
+ 
+ 
+/* Nouvelle-Fonction */
+ 
+int SuiviReadStarInfo(SUIVIFIP *suivfip, int_4 num, char *buff)
+ 
+/*   Cette fonction lit les infos etoiles pour l'etoile   */
+/*  numero num -  Retour 0  OK                            */
+ 
+{
+int_4 pos;
+ 
+if (suivfip == NULL)  return(1);
+if ( (num <= (int_4)0) || (num > suivfip->Head.NbStars) )
+  { printf(" SuiviReadStarInfo_Erreur : Num (=%ld) out of range \n",(long)num); return(2); }
+ 
+/*  lecture */
+pos = suivfip->Head.HSize + suivfip->Head.RecSize[0] +
+      suivfip->Head.RecSize[1] +
+      (num-1)*suivfip->Head.RecSize[2];
+if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+  { printf(" SuiviReadStarInfo_Erreur : Pb zfseek() \n"); return(10); }
+zfread(buff,1,(size_t)suivfip->Head.RecSize[2],suivfip->fcp);
+
+if (suivfip->FgSwap)   /*  On byte-swap apres lecture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[2], suivfip->Head.FmtSize[2], 1);
+ 
+ 
+return(0);
+}
+ 
+/*
+++
+int SuiviAddMesure(SUIVIFIP *suivfip, char *buff)
+	Ajoute une nouvelle mesure dans le fichier. "buff" contient
+	l'information TimeInfo pour cette mesure.
+--
+*/
+  
+ 
+/* Nouvelle-Fonction */
+int SuiviAddMesure(SUIVIFIP *suivfip, char *buff)
+ 
+/*  Cette fonction rajoute une nouvelle mesure ds le fichier de suivi  */
+/*  *buff contient l'information temps de cette mesure                 */
+/*  Les mesures correspondant a ce temps doivent etre rajoute par      */
+/*  SuiviWriteMesure()                                                 */
+ 
+{
+int_4 pos,l1;
+ENTETESUIVI *head;
+int_4 itsiz;
+char bidbuf[4] = {'\0','\0','\0','\0'};
+int rc;
+ 
+if (suivfip == NULL)  return(1);
+if (suivfip->FgRW != SUOF_RW)
+  {printf(" SuiviAddMesure_Erreur : Fichier ReadOnly \n");  return(2);}
+head = &(suivfip->Head);
+ 
+/*   On verifie voir s'il faut creer de nouveaux records ?   */
+if ( (head->NbMesTot % head->NItem) == (int_4)(0) ) {
+  pos = suivfip->OffsetMes  +
+      ( (head->NbMesTot / head->NItem) + 1) *
+      ( head->RecSize[3] + (head->NbStars)*head->RecSize[4] ) - 4 ;
+  if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+    { printf(" SuiviAddMesure_Erreur : Pb zfseek() \n");
+    suivfip->Head.FgCorrupt = -99999999;  return(10); } 
+  if (zfwrite(bidbuf,1, 4, suivfip->fcp) != 4) 
+    { printf(" SuiviAddMesure_Erreur : Pb zfwrite() \n");
+    suivfip->Head.FgCorrupt = -99999999;  return(11); } 
+  head->FileSize = pos+4;       
+  }
+ 
+head->NbMesTot++;
+ 
+l1 = (head->NbMesTot-1) / head->NItem;
+pos = suivfip->OffsetMes +
+      l1 * (head->RecSize[3] +
+      head->NbStars*head->RecSize[4]);
+itsiz = head->RecSize[3] / head->NItem ;
+pos += (head->NbMesTot-1 - l1*head->NItem) * itsiz;
+
+if (suivfip->FgSwap)   /*  On byte-swap avant ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[3], suivfip->Head.FmtSize[3], 1);
+
+rc = 0; 
+if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+  { printf(" SuiviAddMesure_Erreur : Pb zfseek() \n"); 
+  suivfip->Head.FgCorrupt = -99999999; rc = 10; }
+else if (zfwrite(buff,1,(size_t)itsiz,suivfip->fcp) != itsiz)
+  { printf(" SuiviAddMesure_Erreur : Pb zfseek() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 11; }
+ 
+if (suivfip->FgSwap)   /*  On remet dans le bon sens apres ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[3], suivfip->Head.FmtSize[3], 1);
+ 
+return(rc);
+}
+ 
+ 
+/*
+++
+int SuiviWriteTimeInfo(SUIVIFIP *suivfip, int_4 numes, char *buff)
+	Ecriture de TimeInfo pour la mesure numéro "numes" (1..NbMes).
+--
+*/
+
+ 
+/* Nouvelle-Fonction */ 
+int SuiviWriteTimeInfo(SUIVIFIP *suivfip, int_4 numes, char *buff)
+ 
+/*  Cette fonction ecrit l'info temps pour la mesure numero num  */
+/*  *buff contient l'information temps - Retour 0 OK             */
+ 
+{
+int_4 pos,l1;
+ENTETESUIVI *head;
+int_4 itsiz;
+int rc;
+ 
+if (suivfip == NULL)  return(1);
+if (suivfip->FgRW != SUOF_RW)
+  {printf(" SuiviWriteTimeInfo_Erreur : Fichier ReadOnly \n");  return(2);}
+head = &(suivfip->Head);
+ 
+if ( (numes <= (int_4)0) || (numes > suivfip->Head.NbMesTot) )
+  { printf(" SuiviWriteTimeInfo_Erreur : NumMesure (=%ld) out of range \n",(long)numes);
+    return(3); }
+ 
+l1 = (numes-1) / head->NItem;
+pos = suivfip->OffsetMes +
+      l1 * ( head->RecSize[3] +
+             head->NbStars*head->RecSize[4] );
+itsiz = head->RecSize[3] / head->NItem ;
+pos += ( numes-1 - l1*head->NItem ) * itsiz;
+
+if (suivfip->FgSwap)   /*  On byte-swap avant ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[3], suivfip->Head.FmtSize[3], 1);
+rc = 0; 
+if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+  { printf(" SuiviWriteTimeInfo_Erreur : Pb zfseek() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 10; }
+if (zfwrite(buff,1,(size_t)itsiz,suivfip->fcp) != itsiz)
+  { printf(" SuiviWriteTimeInfo_Erreur : Pb zfwrite() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 11; }
+
+ 
+if (suivfip->FgSwap)   /*  On remet dans le bon sens apres ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[3], suivfip->Head.FmtSize[3], 1);
+ 
+return(rc);
+}
+ 
+ 
+ 
+/*
+++
+int SuiviWriteMesure(SUIVIFIP *suivfip, int_4 numet, int_4 nummes, char *buff)
+	Ecriture de l'infomation Mesure pour l'étoile numéro "numet" 
+	et la mesure numéro "numes" 
+--
+*/
+ 
+/* Nouvelle-Fonction */ 
+int SuiviWriteMesure(SUIVIFIP *suivfip, int_4 numet,
+                     int_4 nummes, char *buff)
+ 
+/*  Cette fonction ecrit une mesure ds le fichier de suivi    */
+/*  numet est le numero d'etoile, nummes le numero de mesure  */
+/*  *buff contient l'information mesure - Retour 0 OK         */
+ 
+{
+int_4 pos,l1;
+ENTETESUIVI *head;
+int_4 itsiz;
+int rc;
+ 
+if (suivfip == NULL)  return(1);
+if (suivfip->FgRW != SUOF_RW)
+  {printf(" SuiviWriteMesure_Erreur : Fichier ReadOnly \n");  return(2);}
+head = &(suivfip->Head);
+ 
+if ( (numet <= (int_4)0) || (numet > suivfip->Head.NbStars) )
+  { printf(" SuiviWriteMesure_Erreur : NumEtoile (=%ld) out of range \n",(long)numet);
+    return(2); }
+ 
+if ( (nummes <= (int_4)0) || (nummes > suivfip->Head.NbMesTot) )
+  { printf(" SuiviWriteMesure_Erreur : NumMesure (=%ld) out of range \n",(long)nummes);
+    return(3); }
+ 
+l1 = (nummes-1) / head->NItem;
+pos = suivfip->OffsetMes +
+      l1 * (head->RecSize[3] +
+      head->NbStars*head->RecSize[4]) +
+      head->RecSize[3] + (numet-1)*head->RecSize[4];
+itsiz = head->RecSize[4] / head->NItem ;
+pos += (nummes-1 - l1*head->NItem) * itsiz;
+
+if (suivfip->FgSwap)   /*  On byte-swap avant ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[4], suivfip->Head.FmtSize[4], 1);
+
+rc = 0; 
+if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+  { printf(" SuiviWriteMesure_Erreur : Pb zfseek() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 10; }
+else if (zfwrite(buff,1,(size_t)itsiz,suivfip->fcp) != itsiz) 
+  { printf(" SuiviWriteMesure_Erreur : Pb zfwrite() \n"); 
+  suivfip->Head.FgCorrupt = -99999999;  rc = 11; }
+
+if (suivfip->FgSwap)   /*  On remet dans le bon sens apres ecriture */
+  SwapSuiviRecord(buff, suivfip->RecFmt[4], suivfip->Head.FmtSize[4], 1);
+ 
+return(rc);
+}
+ 
+
+/*
+++
+int SuiviReadTimeInfo(SUIVIFIP *suivfip, int_4 debut, int_4 fin, char *buff)
+	Lecture des informations TimeInfo pour "debut <= mes <= fin". 
+	Attention : Des erreurs d'alignement d'accès mémoire peuvent 
+	avoir lieu en cas de lecture multiple "(fin > debut)" si la taille 
+	de la structure TimeInfo ne coincide pas avec celle de l'enregistrement
+	correspondant. 
+--
+*/
+ 
+ 
+/* Nouvelle-Fonction */ 
+int SuiviReadTimeInfo(SUIVIFIP *suivfip, int_4 debut,
+                      int_4 fin, char *buff)
+ 
+/*  Cette fonction lit l'information temps pour les mesures  */
+/*   debut <= NumMes <= fin         Retour 0  OK             */
+ 
+{
+int_4 pos,l1;
+ENTETESUIVI *head;
+int_4 itsiz;
+int_4 fr,to,nit;
+char* buff0;
+ 
+if (suivfip == NULL)  return(1);
+head = &(suivfip->Head);
+ 
+ 
+if ( (debut <= (int_4)0) || (debut > head->NbMesTot) )
+  { printf(" SuiviReadTimeInfo_Erreur : NumDebut (=%ld) out of range \n",(long)debut);
+    return(3); }
+ 
+if ( (fin <= (int_4)0) || (fin > head->NbMesTot) )
+  { printf(" SuiviReadTimeInfo_Erreur : NumFin (=%ld) out of range \n",(long)fin);
+    return(4); }
+ 
+if ( debut > fin)
+  { printf(" SuiviReadTimeInfo_Erreur : NumFin (=%ld) < NumDebut(=%ld) \n",
+           (long)fin, (long)debut);
+    return(5); }
+ 
+itsiz = head->RecSize[3] / head->NItem ;
+ 
+fr=to=debut;
+buff0 = buff;
+ 
+do {
+ 
+  l1 = (fr-1) / head->NItem;
+  to = (l1+1) * head->NItem;
+  if (to > fin)  nit = fin-fr+1;
+  else nit = to-fr+1;
+  pos = suivfip->OffsetMes +
+        l1 * (head->RecSize[3] +
+        head->NbStars*head->RecSize[4]);
+  pos += (fr-1 - l1*head->NItem) * itsiz;
+  if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+    { printf(" SuiviReadTimeInfo_Erreur : Pb zfseek() \n"); return(10); }
+  zfread(buff,(size_t)itsiz,nit,suivfip->fcp);
+  fr += nit;  buff += nit * itsiz;
+ 
+} while (fr <= fin);
+ 
+if (suivfip->FgSwap)   /*  On byte-swap apres lecture */
+  SwapSuiviRecord(buff0, suivfip->RecFmt[3], suivfip->Head.FmtSize[3], fin-debut+1);
+ 
+return(0);
+}
+ 
+ 
+ 
+ 
+/*
+++
+int SuiviReadMesures(SUIVIFIP *suivfip, int_4 numet, int_4 debut, int_4 fin, char *buff)
+	Lecture des informations Mesure pour l'étoile "numet", "debut <= mes <= fin". 
+	Attention : Des erreurs d'alignement d'accès mémoire peuvent 
+	avoir lieu en cas de lecture multiple "(fin > debut)" si la taille 
+	de la structure Mesure ne coincide pas avec celle de l'enregistrement
+	correspondant.
+--
+*/
+ 
+ 
+/* Nouvelle-Fonction */ 
+int SuiviReadMesures(SUIVIFIP *suivfip, int_4 numet,
+                     int_4 debut, int_4 fin, char *buff)
+ 
+/*  Cette fonction lit les mesures pour l'etoile numet       */
+/*   debut <= NumMes <= fin         Retour 0  OK             */
+ 
+{
+int_4 pos,l1;
+ENTETESUIVI *head;
+int_4 itsiz;
+int_4 fr,to,nit;
+char* buff0;
+ 
+if (suivfip == NULL)  return(1);
+head = &(suivfip->Head);
+ 
+if ( (numet <= (int_4)0) || (numet > head->NbStars) )
+  { printf(" SuiviReadMesures_Erreur : NumEtoile (=%ld) out of range \n", (long)numet);
+    return(2); }
+ 
+if ( (debut <= (int_4)0) || (debut > head->NbMesTot) )
+  { printf(" SuiviReadMesures_Erreur : NumDebut (=%ld) out of range \n", (long)debut);
+    return(3); }
+ 
+if ( (fin <= (int_4)0) || (fin > head->NbMesTot) )
+  { printf(" SuiviReadMesures_Erreur : NumFin (=%ld) out of range \n", (long)fin);
+    return(4); }
+ 
+if ( debut > fin)
+  { printf(" SuiviReadMesures_Erreur : NumFin (=%ld) < NumDebut(=%ld) \n", 
+           (long)fin, (long)debut);
+    return(5); }
+ 
+itsiz = head->RecSize[4] / head->NItem ;
+ 
+fr=to=debut;
+buff0 = buff;
+ 
+do {
+ 
+  l1 = (fr-1) / head->NItem;
+  to = (l1+1) * head->NItem;
+  if (to > fin)  nit = fin-fr+1;
+  else nit = to-fr+1;
+  pos = suivfip->OffsetMes +
+        l1 * (head->RecSize[3] +
+        head->NbStars*head->RecSize[4]) +
+        head->RecSize[3] + (numet-1)*head->RecSize[4];;
+  pos += (fr-1 - l1*head->NItem) * itsiz;
+  if (zfseek(suivfip->fcp, (long)pos, SEEK_SET) != 0)
+    { printf(" SuiviReadMesures_Erreur : Pb zfseek() \n"); return(10); }
+  zfread(buff,(size_t)itsiz,nit,suivfip->fcp);
+  fr += nit;  buff += nit * itsiz;
+ 
+} while (fr <= fin);
+
+if (suivfip->FgSwap)   /*  On byte-swap apres lecture */
+  SwapSuiviRecord(buff0, suivfip->RecFmt[4], suivfip->Head.FmtSize[4], fin-debut+1);
+ 
+ 
+return(0);
+}
+ 
+ 
+  
+ 
+/* Nouvelle-Fonction */
+int_4 FindSizeofRec(char *fmt)
+ 
+{
+int i;
+char c;
+int sz;
+ 
+i= sz = 0;
+while ( (*fmt) != '\0' )
+  {
+  c = toupper(*fmt);
+  switch (c)
+    {
+    case 'I' :
+      sz += sizeof(int_4); i++;
+      break;
+    case 'L' :
+      sz += sizeof(int_4); i++;
+      break;
+    case 'S' :
+      sz += sizeof(int_2); i++;
+      break;
+    case 'F' :
+      sz += sizeof(r_4); i++;
+      break;
+    case 'D' :
+      sz += sizeof(r_8); i++;
+      break;
+    default :
+      printf(" FindSizeofRec_Erreur : Code format inconnu : %c \n",c);
+      return(-1);
+      break;
+    }
+  fmt++;
+  }
+ 
+/*    printf(" FindSizeofRec_debug : N= %d , size= %d \n",i,sz);   */
+ 
+return(sz);
+}
+
+/* Nouvelle-Fonction */
+void SwapSuiviEntete(ENTETESUIVI *hp)
+{
+int i;
+Swap_Bytes4( &(hp->FileSize) );
+Swap_Bytes4( &(hp->HSize) );
+for(i=0; i<5; i++)  Swap_Bytes2( &(hp->RecSize[i]) );
+Swap_Bytes2( &(hp->NItem) );
+Swap_Bytes4( &(hp->NbStars) );
+Swap_Bytes4( &(hp->NbMesTot) );
+for(i=0; i<5; i++)  Swap_Bytes2( &(hp->FmtSize[i]) );
+Swap_Bytes2(  &(hp->Swap) );
+Swap_Bytes2(  &(hp->Type) );
+Swap_Bytes4(  &(hp->FgCorrupt) );
+}
+
+/* Nouvelle-Fonction */
+void SwapSuiviRecord(char* rec, char* fmt, int fmtl, int nr)
+{
+int i,j;
+char *pc;
+
+pc = rec;
+for( j = 0 ; j < nr ; j++ ) {
+  for ( i = 0 ; i < fmtl ; i++ ) {
+    switch( toupper(fmt[i]) )  {
+      case 'I' :  
+      case 'L' :
+        Swap_Bytes4(pc);  
+        pc += sizeof(int_4); 
+        break;
+      case 'S' :
+        Swap_Bytes2(pc);  
+        pc += sizeof(int_2); 
+        break;
+      case 'F' :
+        Swap_Bytes4(pc);  
+        pc += sizeof(r_4); 
+        break;
+      case 'D' :
+        Swap_Bytes8(pc);  
+        pc += sizeof(r_8); 
+        break;
+      default :
+        printf(" SwapSuiviRecord_Erreur : Code format inconnu : %c \n",fmt[i]);
+        break;
+    }
+  }
+}
+
+return;
+}
Index: trunk/FrEROS/AnaLC/fsvcache.h
===================================================================
--- trunk/FrEROS/AnaLC/fsvcache.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/fsvcache.h	(revision 3308)
@@ -0,0 +1,149 @@
+#ifndef FSVCACHE_H_SEEN
+#define  FSVCACHE_H_SEEN
+
+#include <stdio.h>
+#include "machdefs.h"
+
+#include "filecache.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ 
+/*    Structure du fichier de suivi :                             */
+/*           1) Entete : Structure entetesuivi                    */
+/*           2) Zone commentaire   (1 * Rec0 )                    */
+/*           3) Enregistrement Info generale fichier  (1 * Rec1)  */
+/*           4) Enregistrements info etoiles  (NbStars * Rec2)    */
+/*           5) Enregistrements mesures                           */
+/*                1 * Rec3 + NbStars * Rec4                       */
+/*                Rec3 contient le temps des mesures,             */
+/*                Rec4 contient l'info mesures                    */
+/*                Rec3 et Rec4 correspondent a un ensemble de     */
+/*                NItem mesures.                                  */
+/*           le groupe (5) peut etre repete plusieurs fois        */
+ 
+ 
+ 
+struct entetesuivi
+  {
+  int_4 FileSize;             /*  Taille totale fichier  */
+  int_4 HSize;                /*  Taille entete          */
+  uint_2 RecSize[5];          /*  Tailles Rec 0/1/2/3    */
+  uint_2 NItem;               /*  Nb de mesures / Record */
+  int_4 NbStars;              /*  Nb. total d'etoiles    */
+  int_4 NbMesTot;             /*  Nb. total de mesures   */
+  uint_2 FmtSize[5];          /*  Longueur des formats   */
+  uint_2 Swap;                /*  Sens de byte-swap      */
+  uint_2 Type;                /*  Type de suivi          */
+  int_4  FgCorrupt;           /*  test fichier corrompu  */
+  };
+ 
+typedef  struct entetesuivi  ENTETESUIVI;
+ 
+struct suivifip
+  {
+  FILE *fip;
+  FILECACHE *fcp;
+  ENTETESUIVI Head;
+  char *Nom;
+  int_4 OffsetMes;
+  int FgRW;
+  int FgSwap;
+  char* RecFmt[5];
+  };
+ 
+typedef  struct suivifip  SUIVIFIP;
+ 
+ 
+/*    Pour l'IBMVM, Je redefinis les noms  (Pb = Max 8 car)   */
+#ifdef IBMVM
+ 
+#define   SuiviCreate           SuvCreat
+#define   SuiviOpen             SuvOpen
+#define   SuiviClose            SuvClos
+#define   SuiviGetNbStars       SuvGNbSt
+#define   SuiviGetNbMesures     SuvGNMes
+#define   SuiviGetNbytstars     SuvGNByt
+#define   SuiviGetType          SuvGTyp
+#define   SuiviWriteComment     SuvWrCom
+#define   SuiviReadComment      SuvRdCom
+#define	  SuiviWriteGlobInfo    SuvWrGlI
+#define	  SuiviReadGlobInfo     SuvRdGlI
+#define   SuiviWriteStarInfo    SuvWrStI
+#define   SuiviReadStarInfo     SuvRdStI
+#define   SuiviAddMesure        SuvAdMes
+#define   SuiviWriteTimeInfo    SuvWrTmI
+#define   SuiviWriteMesure      SuvWrMes
+#define   SuiviReadTimeInfo     SuvRdTmI
+#define   SuiviReadMesures      SuvRdMes
+ 
+#endif
+ 
+ 
+/*     Flag d'ouverture fichier  Lecture / Lecture-Ecriture    */
+ 
+#define    SUOF_RO     0
+#define    SUOF_RW     1
+#define    SUOF_RO_MEM     10
+#define    SUOF_RW_MEM     11
+#define    SUOF_RO_MEM2    20
+#define    SUOF_RW_MEM2    21
+#define    SUOF_RO_MEM3    30
+#define    SUOF_RW_MEM3    31
+#define    SUOF_RO_MEM4    40
+#define    SUOF_RW_MEM4    41
+ 
+ 
+int SuiviCreate(char *filename, int typ, int rec0size, char *rec1fmt,
+                char *rec2fmt, char *rec3fmt, char *rec4fmt, int nitem);
+ 
+SUIVIFIP *SuiviOpen(char *filename, int rw);
+ 
+int SuiviClose(SUIVIFIP *suivfip);
+ 
+int_4 SuiviGetNbStars(SUIVIFIP *suivfip);
+ 
+int_4 SuiviGetNbMesures(SUIVIFIP *suivfip);
+ 
+int_4 SuiviGetNbytStars(SUIVIFIP *suivfip);
+ 
+int_4 SuiviGetType(SUIVIFIP *suivfip);
+
+int_4 SuiviGetSize(SUIVIFIP *suivfip);
+
+int_4 SuiviPredictSize(SUIVIFIP *sfip, int nbst, int nbmes);
+
+void  SuiviSetPrtLevel(int lev);
+ 
+int SuiviWriteComment(SUIVIFIP *suivfip, char *buff);
+ 
+int SuiviReadComment(SUIVIFIP *suivfip, char *buff);
+ 
+int SuiviWriteGlobInfo(SUIVIFIP *suivfip, char *buff);
+ 
+int SuiviReadGlobInfo(SUIVIFIP *suivfip, char *buff);
+ 
+int SuiviWriteStarInfo(SUIVIFIP *suivfip, int_4 num, char *buff);
+ 
+int SuiviReadStarInfo(SUIVIFIP *suivfip, int_4 num, char *buff);
+ 
+int SuiviAddMesure(SUIVIFIP *suivfip, char *buff);
+ 
+int SuiviWriteTimeInfo(SUIVIFIP *suivfip, int_4 numes, char *buff);
+ 
+int SuiviWriteMesure(SUIVIFIP *suivfip, int_4 numet,
+                     int_4 nummes, char *buff);
+ 
+int SuiviReadTimeInfo(SUIVIFIP *suivfip, int_4 debut,
+                      int_4 fin, char *buff);
+ 
+int SuiviReadMesures(SUIVIFIP *suivfip, int_4 numet,
+                     int_4 debut, int_4 fin, char *buff);
+#ifdef __cplusplus
+}
+#endif
+ 
+#endif
+
Index: trunk/FrEROS/AnaLC/fsvst.c
===================================================================
--- trunk/FrEROS/AnaLC/fsvst.c	(revision 3308)
+++ trunk/FrEROS/AnaLC/fsvst.c	(revision 3308)
@@ -0,0 +1,637 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "machdefs.h"
+#include "fmath.h"
+
+#include "convlim.h"
+#include "nomfits.h"
+#include "nomfits2.h"
+#include "datime.h"
+
+#include "fsvst.h"
+
+static float flog10(float x) { return (float)log10((double)x); }
+ 
+int COMPTE_FLUXCAL_BAD = 0;
+
+/* Nouvelle-Fonction */
+float FluxCalibre(float fluxb, int typcal, float *pcal)
+/*  Calibration relative de flux    */
+{
+float lfb,r,dlfb;
+double det;
+
+switch (typcal)
+  {
+  case 1:
+  case 10:
+    r = pcal[0]+pcal[1]*fluxb;
+    break;
+
+  case 11:
+    r = 0.;
+    if( fabsf(pcal[4]) < 1.e-19 ) {
+      if( fabsf((double) pcal[3]) < 1.e-19 ) break;
+      r = (fluxb-pcal[2])/pcal[3];
+      break;
+    }
+    lfb = pcal[0]+pcal[1]*fluxb;
+    det = pcal[3]*pcal[3]-4.*pcal[4]*(pcal[2]-fluxb);
+    if( det > 0 ) {
+      r    = (-pcal[3]+sqrt(det))/(2.*pcal[4]);
+      dlfb = (-pcal[3]-sqrt(det))/(2.*pcal[4]);
+      if( fabsf(dlfb-lfb) < fabsf(r-lfb) ) r = dlfb;
+    } else if ( det == 0. ) r = -pcal[3]/pcal[4];
+    break;
+
+  case 20:
+    lfb = (fluxb>0.1) ? flog10(fluxb) : -1.0;
+    if (lfb > pcal[2])
+      r = pcal[0]+pcal[1]*lfb;
+    else 
+      { dlfb = lfb-pcal[2]; 
+      r = pcal[0]+pcal[1]*pcal[2]+dlfb*(pcal[3]+dlfb*pcal[4]);
+      }
+    r *= fluxb;
+    break;
+
+  case 30:
+    r = pcal[0]+pcal[1]*fluxb;
+    dlfb = fluxb - pcal[2];
+    if (dlfb < 0.)  r += pcal[3]*dlfb*dlfb;
+    break;
+
+  case 40:
+    lfb = (fluxb>1.) ? flog10(fluxb) : 0.;
+    if (lfb > pcal[2])   r = pcal[0]+lfb*pcal[1];
+    else
+      { dlfb = (lfb < pcal[5]) ? (pcal[5]-pcal[2])  
+                               : (lfb-pcal[2]) ;
+      r = pcal[4]+dlfb*pcal[3]; } 
+    r *= fluxb;
+    break;
+
+  case 41:
+    lfb = (fluxb>1.) ? flog10(fluxb) : 0.;
+    lfb = (lfb > pcal[5]) ? lfb : pcal[5];
+    r = pcal[0]+lfb*pcal[1];
+    r *= fluxb;
+    break;
+
+  case 80:
+    r = pcal[0]+pcal[1]*fluxb;
+    break;
+
+  case 91:
+    r = 0.;
+    if(fluxb>=pcal[1]) {
+      /* cas des flux brillants */
+      if( pcal[4] <= 0. ) break;
+      r = (fluxb-pcal[1])/pcal[4] + pcal[0];
+    } else if(fluxb<=pcal[3]) {
+      /* cas des flux faibles */
+      if( pcal[7] <= 0. ) break;
+      r = (fluxb-pcal[3])/pcal[7] + pcal[2];
+    } else {
+      /* cas des flux moyens */
+      if( pcal[5] <= 0. ) break;
+      if( pcal[6] == 0.) {
+        /* pas de terme en x**2 */
+        r = (fluxb-pcal[3])/pcal[5] + pcal[2];
+      } else {
+        /* terme en x**2 non nul */
+        det = -4.*pcal[6]*(pcal[3]-fluxb)/(pcal[5]*pcal[5]);
+        if( fabs(det) < 0.0001 ) {
+          /* cas d'une correction x**2 petite, DL de sqrt() */
+          r = pcal[5]/(4.*pcal[6]) * det*(1.-det/4.) + pcal[2];
+        } else {
+          /* cas de la resolution normale de l'equation du 2sd */
+          det += 1.;
+          if(det<0.) break;
+          det = sqrt(det);
+          r = pcal[5]/(2.*pcal[6])*(-1.+det) + pcal[2];
+          if( r<pcal[2] || r>pcal[0] )  /* autre solution ?? */
+              r = pcal[5]/(2.*pcal[6])*(-1.-det) + pcal[2];
+	}
+      }
+    }
+    break;
+
+  default:
+    if( COMPTE_FLUXCAL_BAD < 50 )
+      printf("FluxCalibre_Erreur: Type calibration (%d) Non prevue !\n", typcal);
+    COMPTE_FLUXCAL_BAD++;
+    r = 0.;
+    break;
+  
+  }
+
+ /* printf("FluxCalibre: fluxb=%g -> %g typcal=%d pcal=%g %g %g %g %g\n"
+      ,fluxb,r,typcal,pcal[0],pcal[1],pcal[2],pcal[3],pcal[4]); */
+
+return(r);
+
+}
+
+
+/* Nouvelle-Fonction */
+float ErrCalibre(float efluxb, float fluxb,float fluxc,float *pfite)
+/*                                Christophe 1/2/95          */
+/*  Calibration de l'erreur sur le flux calibre              */
+/* efluxb = erreur sur le flux brut                          */
+/* fluxb = flux brut                                         */
+/* fluxc = flux calibre                                      */
+/* pfite = tableau des fct erreurs externes et erreurs peida */
+/* RETURN: erreur sur le flux calibre                        */
+{
+float eflux,mfr,errext,errfit;
+double ex;
+
+eflux = 0.;
+
+if(efluxb==0.) return(0.);
+if(efluxb<0.) efluxb *= -1.;
+if( fluxb==0. || fluxc==0. ) return(efluxb);
+if( fluxb<0.  || fluxc<0.  ) {
+  eflux = efluxb * fluxc / fluxb;
+  if(eflux<0.) return(-eflux); else return(eflux);
+}
+
+mfr = 2.5*flog10(fluxc);
+
+errext = 0.;
+ex = pfite[0]-pfite[1]*mfr;
+if(pfite[1]>0. && ex<80.) errext += exp(ex)+pfite[2];
+if(errext<=0.)  return (eflux);
+ex = pfite[3]-pfite[4]*mfr;
+if(pfite[4]>0. && ex<80.) errext += exp(ex);
+
+errfit = 0.;
+ex = pfite[5]-pfite[6]*mfr;
+if(pfite[6]>0. && ex<80.) errfit += exp(pfite[5]-pfite[6]*mfr)+pfite[7];
+if(errfit<=0.)  return (eflux);
+ex = pfite[8]-pfite[9]*mfr;
+if(pfite[9]>0. && ex<80.) errfit += exp(ex);
+
+eflux = efluxb * fluxc/fluxb * errext/errfit;
+
+return (eflux);
+}
+
+
+/* Nouvelle-Fonction */
+float Erreur_Ext(float fluxc,float *pfite)
+/*                                Christophe 2/6/95      */
+/*  Valeur de l'erreur externe                           */
+/* fluxc = flux calibre                                  */
+/* pfite = tableau des fct erreurs externes              */
+/* RETURN: erreur externe pour le flux calibre considere */
+{
+float errext,mfr;
+double ex;
+
+errext = 0.;
+if( fluxc<=0. ) return (errext);
+mfr = 2.5*flog10(fluxc);
+
+ex = pfite[0]-pfite[1]*mfr;
+if(pfite[1]>0. && ex<80.) errext += exp(ex)+pfite[2];
+if(errext<=0.)  return (errext);
+ex = pfite[3]-pfite[4]*mfr;
+if(pfite[4]>0. && ex<80.) errext += exp(ex);
+return (errext);
+}
+
+
+/* Nouvelle-Fonction */
+void Calibre_F_E(MESUREU *mesu,TIMEINFOU *timu)
+/*                                Christophe 1/2/95          */
+/* remplissage de flux et errflux dans MESUREU   */
+{
+int typcal;
+float efluxb,fluxb,fluxc,*pcal,*pfite;
+
+fluxb = mesu->FluxB;
+typcal = timu->FgCalib;
+pcal = &(timu->Calib[0]);
+mesu->Flux = fluxc = FluxCalibre(fluxb,typcal,pcal);
+
+efluxb = mesu->ErrFluxB;
+pfite = &(timu->PFitErr[0][0]);
+mesu->ErrFlux = ErrCalibre(efluxb,fluxb,fluxc,pfite);
+}
+
+/* Nouvelle-Fonction */
+MESUREU * DecodeMes( MESURE *mesc, MESUREU *mesu)
+
+/* Cette fonction decode les mesures de fichier de suivi type 10 */
+/* Retourne le pointeur sur la structure MESUREU fourni (mesu)   */
+
+{
+float fv;
+
+if ((mesc == NULL) || (mesu == NULL) )  return(NULL);
+
+mesu->FluxB = mesc->Flux;
+mesu->Flux = mesu->FluxB;
+mesu->Xi2 =  mesc->Xi2;
+mesu->Fond =  (float)mesc->Fond;
+fv = (mesu->FluxB >= 0.) ? mesu->FluxB : (-mesu->FluxB);
+mesu->ErrFluxB =  mesc->ErrFlux*fv/10000.;
+mesu->ErrFlux =  mesu->ErrFluxB;
+
+mesu->Flx0 = (float)mesc->Flx0*10.0;
+mesu->Fnd0 = (float)mesc->Fnd0;
+mesu->Xi20 = (mesc->Xi20 < 0) ? (float)mesc->Xi20 : 
+                         (float)mesc->Xi20/100.0 ;
+mesu->S9Pix = (float)mesc->S9Pix*9.0;
+mesu->PixMax = (float)mesc->PixMax;
+mesu->X = (float)mesc->X/20.; 
+mesu->Y = (float)mesc->Y/20.; 
+mesu->SigX = (float)mesc->SigX/200.0;
+mesu->SigY = (float)mesc->SigY/200.0;
+
+return(mesu);
+}
+
+/* Nouvelle-Fonction */
+void Mes_a_zero(MESUREU *mesu)
+
+/* Cette fonction met a zero la structure mesu   */
+{
+
+if ( mesu == NULL )  return;
+mesu->FluxB = mesu->Flux = mesu->Xi2 =  mesu->Fond = 0.;
+mesu->ErrFluxB =  mesu->ErrFlux = 0.;
+mesu->Flx0 = mesu->Fnd0 = mesu->Xi20 = 0.;
+mesu->S9Pix = mesu->PixMax = 0.;
+mesu->X = mesu->Y = mesu->SigX = mesu->SigY = 0.;
+
+return;
+}
+
+/* Nouvelle-Fonction */
+TIMEINFOU * DecodeTim( TIMEINFO *tim, TIMEINFOU *timu)
+
+/* Cette fonction decode les timeinfo de fichier de suivi type 10 */
+/* Retourne le pointeur sur la structure timeinfou fourni (timu)   */
+
+{
+int i,j;
+
+if ((tim == NULL) || (timu == NULL) )  return(NULL);
+
+timu->NumPhoto = tim->NumPhoto;
+timu->TStart = tim->TStart;
+timu->Expose = tim->Expose;
+timu->Fond = tim->Fond;
+timu->SigFond = tim->SigFond;
+timu->SigX = tim->SigX;
+timu->SigY = tim->SigY;
+timu->Rho = tim->Rho;
+timu->DelX = tim->DelX;
+timu->DelY = tim->DelY;
+timu->Absorption = tim->Absorption;
+timu->AirMass = tim->AirMass;
+timu->FgCalib = tim->FgCalib;
+for(i=0;i<8;i++) timu->Calib[i] = tim->Calib[i];
+for(i=0;i<2;i++)
+  for(j=0;j<5;j++) timu->PFitErr[i][j] = tim->PFitErr[i][j];
+timu->PSF1D = tim->PSF1D;
+timu->PSF2D = tim->PSF2D;
+
+return(timu);
+}
+
+
+
+/* Nouvelle-Fonction */
+void GlobInfoToTransf(GLOBINFO *gli, TRANSFO *t1, TRANSFO *t2)
+{
+int i,j;
+
+for(i=0; i<50; i++)  
+  t1->Polxy[0][0][i] = t2->Polxy[0][0][i]= 0.; 
+ 
+for(i=0; i<2; i++)
+  {
+  t1->Polxy[0][0][i] = gli->PolxyBR[0][i];
+  t1->Polxy[0][1][i] = gli->PolxyBR[1][i];
+  t1->Polxy[1][0][i] = gli->PolxyBR[2][i];
+
+  t2->Polxy[0][0][i] = gli->PolxyRB[0][i];
+  t2->Polxy[0][1][i] = gli->PolxyRB[1][i];
+  t2->Polxy[1][0][i] = gli->PolxyRB[2][i];
+
+  t1->largx[i] = gli->LargX[i];  
+  t1->largy[i] = gli->LargY[i];  
+  t1->midx[i]  = gli->MidX[i];  
+  t1->midy[i]  = gli->MidY[i];  
+  t1->xmin[i]  = gli->XMin[i];  
+  t1->xmax[i]  = gli->XMax[i];  
+  t1->ymin[i]  = gli->YMin[i];  
+  t1->ymax[i]  = gli->YMax[i];
+  j = (i == 0) ? 1 : 0;
+  t2->largx[j] = gli->LargX[i];  
+  t2->largy[j] = gli->LargY[i];  
+  t2->midx[j]  = gli->MidX[i];  
+  t2->midy[j]  = gli->MidY[i];  
+  t2->xmin[j]  = gli->XMin[i];  
+  t2->xmax[j]  = gli->XMax[i];  
+  t2->ymin[j]  = gli->YMin[i];  
+  t2->ymax[j]  = gli->YMax[i];
+  
+  }
+t1->DegPolxy = t2->DegPolxy = gli->DegPolTG;
+return;
+}
+
+
+/* Nouvelle-Fonction */
+void TimeInfoToTransf(TIMEINFO *tminf, TRANSFO *t1, TRANSFO *t2)
+{
+int i,j;
+
+for(i=0; i<50; i++)  
+  t1->Polxy[0][0][i] = t2->Polxy[0][0][i]= 0.; 
+ 
+for(i=0; i<2; i++)
+  {
+  t1->Polxy[0][0][i] = tminf->PolxyRC[0][i];
+  t1->Polxy[0][1][i] = tminf->PolxyRC[1][i];
+  t1->Polxy[1][0][i] = tminf->PolxyRC[2][i];
+
+  t2->Polxy[0][0][i] = tminf->PolxyCR[0][i];
+  t2->Polxy[0][1][i] = tminf->PolxyCR[1][i];
+  t2->Polxy[1][0][i] = tminf->PolxyCR[2][i];
+
+  t1->largx[i] = tminf->LargX[i];  
+  t1->largy[i] = tminf->LargY[i];  
+  t1->midx[i]  = tminf->MidX[i];  
+  t1->midy[i]  = tminf->MidY[i];  
+  t1->xmin[i]  = tminf->XMin[i];  
+  t1->xmax[i]  = tminf->XMax[i];  
+  t1->ymin[i]  = tminf->YMin[i];  
+  t1->ymax[i]  = tminf->YMax[i];
+  j = (i == 0) ? 1 : 0;
+  t2->largx[j] = tminf->LargX[i];  
+  t2->largy[j] = tminf->LargY[i];  
+  t2->midx[j]  = tminf->MidX[i];  
+  t2->midy[j]  = tminf->MidY[i];  
+  t2->xmin[j]  = tminf->XMin[i];  
+  t2->xmax[j]  = tminf->XMax[i];  
+  t2->ymin[j]  = tminf->YMin[i];  
+  t2->ymax[j]  = tminf->YMax[i];
+  
+  }
+t1->DegPolxy = t2->DegPolxy = tminf->DegPolTG;
+return;
+}
+
+
+/* Nouvelle-Fonction */
+void PrtGlobInfo (GLOBINFO *glinf, int lp)
+/* Impression de la struture GlobInfo */
+{
+int i;
+TRANSFO t1,t2;
+char strg[32], s[5];
+
+if (!glinf->NumChamp)
+  printf("GLOBINFO: (Codage EROS-1) NumCCD=%d Couleur=%d\n"
+            ,glinf->NumCCD,glinf->Couleur);
+else
+  {
+  unsigned long numchamp = glinf->NumChamp;
+  dec2zeza(numchamp, strg, 32);
+  if( strlen(strg) < 5) for(i=(int) strlen(strg); i<5; i++) strg[i] = '?';
+
+  strg[5] = ' ';
+  strg[6] = '0' + glinf->Couleur%10;
+  dec2zeza((unsigned long) glinf->Couleur/10, s, 5);
+  if(strlen(s)>0) strg[9] = s[0]; else strg[9] = '?';
+
+  strg[7] = '0' + glinf->NumCCD%10;
+  dec2zeza((unsigned long) glinf->NumCCD/10, s, 5);
+  if(strlen(s)>0) strg[8] = s[0]; else strg[8] = '?';
+
+  strg[10] = '\0';
+
+  printf("GLOBINFO: (Codage EROS-2) %s ",strg);
+  HMStoStr(HtoHMS((double)glinf->AlphaHr),strg);  
+  printf(" Alpha,Delta= %s ", strg);
+  HMStoStr(DtoDMS((double)glinf->DeltaDg),strg);
+  printf(" %s ", strg);
+  printf(" gain= %g e/ADU\n",glinf->GainCCD);
+  if (lp > 2) printf("         Codage  Champ=%d  Coul=%d  CCD=%d\n",
+                    glinf->NumChamp,glinf->Couleur,glinf->NumCCD);
+  }
+if (lp > 0)
+  {
+  printf("  IRes:");
+  for(i=0;i<4;i++) printf(" %d",glinf->IRes[i]);
+  putchar('\n');
+  printf("  FRes:");
+  for(i=0;i<2;i++) printf(" %g",glinf->FRes[i]);
+  putchar('\n');
+  }
+if (lp > 1) 
+  {
+  GlobInfoToTransf(glinf,&t1,&t2);
+  printf("  Transfo Col1->Col2\n"); PrintTransfo(&t1);
+  printf("  Transfo Col2->Col1\n"); PrintTransfo(&t2);
+  }
+
+return;
+}
+
+/* Nouvelle-Fonction */
+void PrtStarInfo (STARINFO *sti,int n,int lp)
+/* Impression de la struture StarInfo */
+{
+int i;
+
+printf("STARINFO[%d]: NumEt=%d XRef=%d X/YPos=%g %g \n",n
+      ,sti->NumEt,sti->XRef,sti->XPos,sti->YPos);
+
+if(lp>0)
+  {
+  printf("  FlxMean/Sig=%g %g FluxRef=%g FgRef=%d\n"
+        ,sti->FlxMean,sti->FlxSig,sti->FluxRef,sti->FgRef);
+  printf("  NbVois=%d Voisin=",sti->NbVois);
+  for(i=0;i<8;i++) printf(" %d",sti->Voisin[i]);
+  printf("\n");
+  printf("  DisMin,DisM2,DisM2R=%g %g %g\n"
+        ,sti->DisMin,sti->DisM2,sti->DisM2R);
+  }
+
+}
+
+
+/* Nouvelle-Fonction */
+void PrtMesure (MESURE *mes,int n,int lp)
+/* Impression de la struture Mesure */
+{
+printf("MES[%d]: Flx=%g (+/-%d) c2=%g Fnd=%d S9=%d pmx=%d\n",n
+      ,mes->Flux,mes->ErrFlux,mes->Xi2,mes->Fond,mes->S9Pix,mes->PixMax);
+
+if(lp>0)
+  printf("  Flx0=%d Fnd0=%d Xi20=%d X/Y=%d %d SigX/Y=%d %d\n"
+        ,mes->Flx0,mes->Fnd0,mes->Xi20,mes->X,mes->Y,mes->SigX,mes->SigY);
+
+}
+
+/* Nouvelle-Fonction */
+void PrtMesureU (MESUREU *mesu,int n,int lp)
+/* Impression de la struture MesureU */
+{
+printf("MESU[%d]: Flx=%g (err=%g) FlB=%g c2=%g Fd=%g S9=%g pmx=%g\n",n
+      ,mesu->Flux,mesu->ErrFlux,mesu->FluxB
+      ,mesu->Xi2,mesu->Fond,mesu->S9Pix,mesu->PixMax);
+
+if(lp>0)
+  printf("  Flx0=%g Fnd0=%g Xi20=%g X/Y=%g %g SigX/Y=%g %g\n"
+        ,mesu->Flx0,mesu->Fnd0,mesu->Xi20,mesu->X,mesu->Y,mesu->SigX,mesu->SigY);
+
+}
+
+/* Nouvelle-Fonction */
+void PrtTimeInfo (TIMEINFO *tim,int n,int lp)
+/* Impression de la struture TimeInfo */
+{
+TRANSFO t1,t2;
+float td;
+int i;
+int_4 date,t;  HMS T;  JMA J;
+char strg[32];
+
+DecodeNumPhoto(tim->NumPhoto, strg);
+
+td = (float)tim->TStart/86400.;
+printf("TimeInfo[%d]: Photo %s (%d) TStart=%d s (%g d) V=%5.2f (Rev=%d)\n",
+       n, strg, tim->NumPhoto, tim->TStart, td,  
+       (float)tim->Version/1000.,tim->Revision);
+
+if (lp < 1) 
+  printf(" .Exp=%d s SigX,Y/Rho= %6.3f %6.3f %6.3f Absor= %5.2f DelX/Y= %6.2f %6.2f\n",
+         tim->Expose, tim->SigX,tim->SigY,tim->Rho,
+         tim->Absorption,tim->DelX,tim->DelY);
+
+if(lp>=1)
+  {
+  printf(" .Exp=%d SigX,Y/Rho= %6.3f %6.3f %6.3f Absor= %5.2f AirMass= %5.2f\n",
+         tim->Expose,tim->SigX,tim->SigY,tim->Rho,
+         tim->Absorption,tim->AirMass);
+  if (lp == 1)
+    printf("  ..Cal (%d) %g %g %g DelX/Y=%6.2f %6.2f \n"
+          ,tim->FgCalib,tim->Calib[0],tim->Calib[1],tim->Calib[2]
+          ,tim->DelX,tim->DelY);
+  }
+
+if(lp>1)
+  {
+  printf("  TypPSF 1D= %d  2D= %d  SgX= %6.3f  SgY= %6.3f\n",
+         tim->PSF1D, tim->PSF2D, tim->SgX, tim->SgY); 
+  printf("  Cal (%d)",tim->FgCalib);
+  for(i=0;i<8;i++) printf(" %g",tim->Calib[i]);
+  printf("\n");
+
+  printf("  Fond=%g SFond=%g NbOkPS/GF=%d %d DelX/Y=%g %g\n"
+        ,tim->Fond,tim->SigFond,tim->NbOkPS,tim->NbOkGF
+        ,tim->DelX,tim->DelY);
+
+  printf("  PFitErr[0]=");
+  for(i=0;i<5;i++) printf("  %g",tim->PFitErr[0][i]);
+  printf("\n");
+  printf("  PFitErr[1]=");
+  for(i=0;i<5;i++) printf("  %g",tim->PFitErr[1][i]);
+  printf("\n");
+  }
+
+if(lp>2)
+  {
+  printf("  Resol[0]:");
+  for(i=0;i<6;i++) printf("  %7.4f",tim->Resol[0][i]);
+  printf("\n");
+  printf("  Resol[1]:");
+  for(i=0;i<6;i++) printf("  %7.4f",tim->Resol[1][i]);
+  printf("\n");
+  printf("  Resol[2]:");
+  for(i=0;i<6;i++) printf("  %7.4f",tim->Resol[2][i]);
+  printf("\n");
+
+    InttoDateTs((uint_4) tim->DateHeure,&date,&t);
+    StrgtoJMA("1/1/1990",J); date += JMAtoJ(J);
+    J = JtoJMA(date);
+    T = SectoHMS((double) t);
+    JMAtoStrg(J,&strg[15]);
+    HMStoStr(T,&strg[0]);
+  printf("  DateHeure: %d (%s %s)",tim->DateHeure,&strg[15],&strg[0]);
+    InttoDateTs((uint_4) tim->TSid,&date,&t);
+    T = SectoHMS((double) t);
+    HMStoStr(T,&strg[0]);
+  printf(" TSid= %d (%s)\n",tim->TSid,&strg[0]);
+    InttoDateTs((uint_4) tim->DTU,&date,&t);
+    StrgtoJMA("1/1/1990",J); date += JMAtoJ(J);
+    J = JtoJMA(date);
+    T = SectoHMS((double) t);
+    JMAtoStrg(J,&strg[15]);
+    HMStoStr(T,&strg[0]);
+  printf("  DTU:  %d (%s %s)",tim->DTU,&strg[15],&strg[0]);
+  printf("  FRes:  %g \n", tim->FRes);
+
+  printf(" ObsId=%d PxSiz=%g %g CrVal=%g %g\n",tim->ObsId
+        ,tim->PxSiz[0],tim->PxSiz[1],tim->CrVal[0],tim->CrVal[1]);
+
+  TimeInfoToTransf(tim,&t1,&t2);
+  printf("  Transfo Ref->Cur\n"); PrintTransfo(&t1);
+  printf("  Transfo Cur->Ref\n"); PrintTransfo(&t2);
+  }
+
+}
+
+/* Nouvelle-Fonction */
+void PrtTimeInfoU (TIMEINFOU *tim,int n,int lp)
+/* Impression de la struture TimeInfoU */
+{
+int i;
+float td;
+char strg[32];
+
+DecodeNumPhoto(tim->NumPhoto, strg);
+
+td = (float)tim->TStart/86400.;
+
+printf("TIMU[%d]: Photo# %d (%s)  TStart=%d (%g d) Exp=%d psf=%d,%d\n",
+       n,tim->NumPhoto,strg,tim->TStart,td,tim->Expose,tim->PSF1D,tim->PSF2D);
+
+if (lp < 1) 
+  printf(".SigX,Y/Rho= %6.3f %6.3f %6.3f Absor= %5.2f DelX/Y= %6.2f %6.2f \n",
+         tim->SigX,tim->SigY,tim->Rho,tim->Absorption,tim->DelX,tim->DelY);
+
+if(lp>=1)
+  {
+  printf(".SigX,Y/Rho= %6.3f %6.3f %6.3f Absor= %5.2f AirMass= %6.2f\n"
+        ,tim->SigX,tim->SigY,tim->Rho,tim->Absorption,tim->AirMass);
+  printf(".Fond/SFond= %g %g  DelX/Y=%6.2f %6.2f\n"
+        ,tim->Fond,tim->SigFond,tim->DelX,tim->DelY);
+  printf("  Cal (%d)",tim->FgCalib);
+  for(i=0;i<8;i++) printf(" %g",tim->Calib[i]);
+  printf("\n");
+  }
+
+if(lp>1)
+  {
+  printf("  PFitErr[0]=");
+  for(i=0;i<5;i++) printf("  %g",tim->PFitErr[0][i]);
+  printf("\n");
+  printf("  PFitErr[1]=");
+  for(i=0;i<5;i++) printf("  %g",tim->PFitErr[1][i]);
+  printf("\n");
+  }
+
+}
+
Index: trunk/FrEROS/AnaLC/fsvst.h
===================================================================
--- trunk/FrEROS/AnaLC/fsvst.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/fsvst.h	(revision 3308)
@@ -0,0 +1,157 @@
+/*   Structure du fichier de suivi type 10             */
+/*               CMV + RA  Juillet 94  La Silla        */
+
+#ifndef  FSVST_H_SEEN  
+#define  FSVST_H_SEEN  
+
+#include "machdefs.h"
+
+#include "transfost.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct GlobInfo 
+  {
+  int_4 NumCCD;
+  int_4 Couleur;
+  int_4 NumChamp;
+  int_4 IRes[4];
+  float AlphaHr;
+  float DeltaDg;
+  float GainCCD;
+  float FRes[2];
+
+  double PolxyBR[3][2];
+  double PolxyRB[3][2];
+  double LargX[2],LargY[2],MidX[2],MidY[2];
+  double XMin[2],XMax[2],YMin[2],YMax[2];
+  int_4  DegPolTG;
+
+  };
+
+typedef  struct  GlobInfo   GLOBINFO;
+
+
+struct StarInfo
+  {
+  int_4  NumEt, XRef;
+  float  FlxMean,FlxSig;
+  float  FluxRef;
+  float  XPos,YPos;
+  float  DisMin,DisM2,DisM2R;
+  uint_2 FgRef;
+  uint_2 NbVois,Voisin[8];
+  };
+
+typedef  struct  StarInfo  STARINFO;
+
+
+struct TimeInfo
+  {
+  int_4  NumPhoto;
+  int_4  TStart,Expose;
+    
+  int_4  NbOkPS,NbOkGF;
+  float  Fond,SigFond;
+
+  float  SigX,SigY,Rho;
+  float  SgX,SgY;
+
+  float  PxSiz[2], CrVal[2];
+  float  DelX,DelY;
+
+  double PolxyRC[3][2];
+  double PolxyCR[3][2];
+  double LargX[2],LargY[2],MidX[2],MidY[2];
+  double XMin[2],XMax[2],YMin[2],YMax[2];
+  int_4  DegPolTG;
+
+  float  Absorption;
+  float  AirMass;
+  
+  int_4  FgCalib;
+  float  Calib[8];
+  float  Resol[3][6];
+  float  PFitErr[2][5];
+
+  uint_2 PSF1D, PSF2D;
+  uint_2 Version, Revision;
+  int_4  DateHeure;
+  uint_2 TSid, ObsId;
+  int_4  DTU;
+  float FRes;
+  };
+
+typedef  struct  TimeInfo  TIMEINFO;
+
+struct TimeInfoU
+  {
+  int_4  NumPhoto;
+  int_4  TStart,Expose;
+  float  Fond,SigFond;
+  float  SigX,SigY,Rho;
+  float  DelX,DelY;
+  float  Absorption,AirMass;
+  int_4  FgCalib;
+  float  Calib[8];
+  float  PFitErr[2][5];
+  uint_2 PSF1D, PSF2D;
+  };
+
+typedef  struct  TimeInfoU  TIMEINFOU;
+
+struct Mesure
+  {
+  float  Flux,Xi2;
+  int_2 ErrFlux,Fond;
+  int_2 Flx0,Fnd0,Xi20;
+  int_2 S9Pix,PixMax;
+  uint_2 X,Y;
+  uint_2 SigX,SigY; 
+  };
+
+typedef struct Mesure  MESURE;
+
+struct MesureU
+  {
+  float  Flux,FluxB;
+  float  Xi2,ErrFlux,ErrFluxB;
+  float  Fond;
+  float  Flx0,Fnd0,Xi20;
+  float  S9Pix,PixMax;
+  float  X,Y;
+  float  SigX,SigY; 
+  } ;
+
+typedef struct MesureU  MESUREU;
+
+
+float FluxCalibre(float fluxb, int typcal, float *pcal);
+float ErrCalibre(float efluxb,float fluxb,float fluxc,float *pfite);
+float Erreur_Ext(float fluxc,float *pfite);
+void Calibre_F_E(MESUREU *mesu,TIMEINFOU *timu);
+MESUREU * DecodeMes( MESURE *mesc, MESUREU *mesu);
+void Mes_a_zero(MESUREU *mesu);
+TIMEINFOU * DecodeTim( TIMEINFO *time, TIMEINFOU *timeu);
+
+void GlobInfoToTransf(GLOBINFO *gli, TRANSFO *t1, TRANSFO *t2);
+void TimeInfoToTransf(TIMEINFO *tminf, TRANSFO *t1, TRANSFO *t2);
+
+void PrtGlobInfo (GLOBINFO *glinf, int lp);
+void PrtStarInfo (STARINFO *sti, int n, int lp);
+void PrtMesure (MESURE *mes, int n, int lp);
+void PrtMesureU (MESUREU *mesu, int n, int lp);
+void PrtTimeInfo (TIMEINFO *tim, int n, int lp);
+void PrtTimeInfoU (TIMEINFOU *tim, int n, int lp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
Index: trunk/FrEROS/AnaLC/lcproc.cc
===================================================================
--- trunk/FrEROS/AnaLC/lcproc.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/lcproc.cc	(revision 3308)
@@ -0,0 +1,88 @@
+#include "lcproc.h"
+
+#include "sopnamsp.h"
+
+LightCurveProc::LightCurveProc(string outppf, int dtblks, int dtblkti)
+  : dts(dtblks) , dtti(dtblkti), _outname(outppf)
+{
+  // Defining column names for the dts : One row / star 
+  dts.AddFloatColumn("NumEt");
+  dts.AddFloatColumn("FluxRef");
+  dts.AddFloatColumn("XPos");
+  dts.AddFloatColumn("YPos");
+  dts.AddFloatColumn("nmes");
+  dts.AddFloatColumn("MeanFlux");
+  dts.AddFloatColumn("SigFlux");
+
+
+  // Defining column names for the dtti : One row / exposure ( = TimeInfo_ 
+  dtti.AddFloatColumn("TStart");
+  dtti.AddFloatColumn("Expose");
+  dtti.AddFloatColumn("Fond");
+  dtti.AddFloatColumn("SigFond");
+  dtti.AddFloatColumn("SigX");
+  dtti.AddFloatColumn("SigY");
+  dtti.AddFloatColumn("Absorption");
+  dtti.AddIntegerColumn("FgBad");
+}
+
+LightCurveProc::~LightCurveProc()
+{
+  cout << " LightCurveProc::~LightCurveProc() Writing DT-Stars, DT-TimeInfo to file \n" 
+       << _outname << endl; 
+  POutPersist po(_outname); 
+  po << PPFNameTag("stardt") << dts;
+  po << PPFNameTag("timdt") << dtti;
+}  
+
+void LightCurveProc::ProcessLC(int numet, int nmes, STARINFO *sti, TIMEINFO *tminf, MESUREU *mesu)
+{
+  double xnt[20];
+  xnt[0] = sti->NumEt;
+  xnt[1] = sti->FluxRef;
+  xnt[2] = sti->XPos;
+  xnt[3] = sti->YPos;
+
+  xnt[4] = (double)nmes;
+
+  // We have to check that  fgbad has been filled
+  if (fgbad.size() < nmes) 
+    for(int kb=fgbad.size(); kb<nmes; kb++) fgbad.push_back(0);
+
+  xnt[5] = 0.; 
+  for(int jt=0; jt<nmes; jt++) { /* mesure jt=0 is the reference image */
+    if (fgbad[jt] != 0)  continue;
+    xnt[5] += mesu[jt].Flux; 
+  }                   
+  xnt[5] /= nmes;  // mean flux of the star number numet
+
+  xnt[6] = 0.; 
+  for(int jt=1; jt<nmes; jt++) {
+    if (fgbad[jt] != 0)  continue;
+    xnt[6] += (mesu[jt].Flux - xnt[5])*(mesu[jt].Flux - xnt[5]); 
+  }
+  xnt[6] = sqrt(xnt[6]/nmes); // flux dispersion of the star number numet
+
+  dts.AddRow(xnt);
+}
+
+void LightCurveProc::TimeInfo(int nmes, TIMEINFO *tminf)
+{
+  double xnt[20]; 
+  fgbad.clear();
+  for(int jt=0; jt<nmes; jt++){
+    fgbad.push_back(0);
+    if (jt == 0) fgbad[jt] = 1;  // flag mes #0 (ref) as bad 
+    if((jt==260)||(jt==647)) fgbad[jt] = 2;  // in-proper mesures
+    xnt[0] = tminf[jt].TStart/86400.;
+    xnt[1] = tminf[jt].Expose;
+    xnt[2] = tminf[jt].Fond;
+    xnt[3] = tminf[jt].SigFond;
+    xnt[4] = (double)tminf[jt].SigX;
+    xnt[5] = tminf[jt].SigY;
+    xnt[6] = tminf[jt].Absorption;
+    xnt[7] = fgbad[jt];
+    dtti.AddRow(xnt);
+  }
+}
+
Index: trunk/FrEROS/AnaLC/lcproc.h
===================================================================
--- trunk/FrEROS/AnaLC/lcproc.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/lcproc.h	(revision 3308)
@@ -0,0 +1,26 @@
+#ifndef LCPROC_H_SEEN
+#define LCPROC_H_SEEN
+
+#include "machdefs.h"  
+#include "tvector.h"
+#include "datatable.h"
+
+#include "fsvst.h"
+
+class LightCurveProc {
+public:
+  LightCurveProc(string outppf, int dtblks=128, int dtblkti=50);
+  virtual ~LightCurveProc();
+
+  void ProcessLC(int numet, int nmes, STARINFO *sti, TIMEINFO *tminf, MESUREU *mesu);
+  void TimeInfo(int nmes, TIMEINFO *tminf);
+  inline SOPHYA::DataTable& getDTS() { return dts; }
+  
+ protected:
+  SOPHYA::DataTable dts;
+  SOPHYA::DataTable dtti;
+  vector<int> fgbad;  // Flag bad exposures (mesures)
+  string _outname;
+};
+
+#endif
Index: trunk/FrEROS/AnaLC/nbgene.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbgene.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbgene.cc	(revision 3308)
@@ -0,0 +1,451 @@
+#include "machdefs.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "fsvcache.h"
+#include "nbtri.h"
+#include "nbrandom.h"
+#include "nbmath.h"
+#include "nbinteg.h"
+#include "strutil.h"
+#include "fsvst.h"
+#include "nbsread.h"
+#include "nbgene.h"
+
+/*==========================================================================*/
+int Give_Annee_Obs(int lp)
+/* retourne l'annee d'observation codee en entier du fichier de suivi utilise */
+{
+int j,anneeobs;
+double t=0.;
+anneeobs = -1;
+for(j=0;j<nmes[0];j++) {
+  t = timeu[0][j].TStart / JourSec;
+  if( t <= 0. ) continue;
+  /* confusion possible smc 93 avec debut lmc 9394 */
+  if( t > 1288. && t < 1314. ) continue;
+  if( t >  700. && t < 850.  ) {anneeobs=9192; break;}
+  if( t >  950. && t < 1200. ) {anneeobs=9293; break;}
+  if( t > 1300. && t < 1570. ) {anneeobs=9394; break;}
+  if( t > 1630. && t < 1900. ) {anneeobs=9495; break;}
+  if( t > 2300. && t < 9999. ) {anneeobs=9697; break;}
+}
+if(lp>0) printf("annee_obs = %d  (j=%d t=%f)\n",anneeobs,j,t);
+return (anneeobs);
+}
+
+/*=========================================================================*/
+float Rayon_SP_Th(float magv)
+/* Fournit le rayon de l'etoile de SP en rayons solaires
+*  en fonction de sa magnitude Vj.
+*  Formule theorique uniquement pour la sequence principale:
+*  Rstar_SP = exp(-0.22 * (magv - MagV_sol) ) avec MagV_sol = 5.1
+*/
+{
+return( (float) exp(-0.22*(magv-5.1)) );
+} 
+
+/*==========================================================================*/
+void AMPLML(int io)
+/* Generation MonteCarlo */
+{
+int i,ic,j,tf;
+float x;
+double t,tt,u2,u;
+int Nseq_tf = 3;
+unsigned short seed_16v[3];
+
+mc.TauSim = mc.TauSimI;
+mc.T0Sim = mc.T0SimI;
+mc.U0Sim = mc.U0SimI;
+mc.USim = mc.USimI;
+
+if(io == 1) {
+
+  /* initialisation des generateurs */
+  seed_16v[0]=(unsigned short) mc.iseed1;
+  seed_16v[1]=(unsigned short) mc.iseed2;
+  seed_16v[2]=(unsigned short) mc.iseed3;
+  Ini_Ranf(seed_16v,0);
+
+  mc.NGene = mc.NPoints_ampli = mc.NPoints_ampli_tf = mc.Net_ampli_tf = 0;
+
+  if(mc.montecar<=0)   return;
+  if ( mc.Taille_Finie > 2 )
+    { printf("mauvaise valeur mc.Taille_Finie %d\n",mc.Taille_Finie);
+    exit(-1); }
+  if ( mc.Blending > 2 || mc.Blending < 0 )
+    { printf("mauvaise valeur mc.Blending %d\n",mc.Blending);
+    exit(-1); }
+
+  printf("MONTECARLO %2d: seed %d %d %d\n",io,mc.iseed1,mc.iseed2,mc.iseed3);
+  printf("   Generation %d, Taille_Finie %d blending %d\n"
+        ,mc.montecar,mc.Taille_Finie,mc.Blending);
+  printf("   Nombre de generations par etoile %d\n",mc.NGenStar);
+  printf("   TauSim=%f TauMinI=%f TauMaxI=%f TireTau=%p\n"
+        ,mc.TauSimI,mc.TauMinI,mc.TauMaxI,mc.TireTau);
+  printf("   T0Sim=%f T0MinI=%f T0MaxI=%f TireT0=%p\n"
+        ,mc.T0SimI,mc.T0MinI,mc.T0MaxI,mc.TireT0);
+  printf("   U0Sim=%f U0MinI=%f U0MaxI=%f TireU0=%p\n"
+        ,mc.U0SimI,mc.U0MinI,mc.U0MaxI,mc.TireU0);
+  printf("   USim =%f UMinI =%f UMaxI =%f TireU=%p\n"
+        ,mc.USimI,mc.UMinI,mc.UMaxI,mc.TireU);
+  printf("   coupure pour taille finie a U/u0 < %f\n",mc.Usu0_Cut);
+
+  if( (mc.U0MaxI <= mc.U0MinI && mc.U0SimI <= 0. &&  mc.Taille_Finie==0 )
+   || (mc.U0MaxI <= mc.U0MinI && mc.U0SimI < 0.  &&  mc.Taille_Finie>0  ) ) {
+    printf("Mauvaises valeurs U0SimI U0MinI U0MaxI\n");
+    exit(-1);
+  }
+  if( mc.UMaxI <= mc.UMinI && mc.USimI <= 0. && mc.Taille_Finie>0 ) {
+    printf("Mauvaises valeurs USimI UMinI UMaxI\n");
+    exit(-1);
+  }
+  if( mc.TauMaxI <= mc.TauMinI && mc.TauSimI <= 0.) {
+    printf("Mauvaises valeurs TauSimI TauMinI TauMaxI\n");
+    exit(-1);
+  }
+
+} else if(io == 2) {
+
+  if( mc.T0MaxI <= mc.T0MinI && mc.T0SimI <= 0. ) {
+    mc.T0MinI_eff=TFIRST;
+    mc.T0MaxI_eff=TLAST;
+  } else {
+    mc.T0MinI_eff=mc.T0MinI;
+    mc.T0MaxI_eff=mc.T0MaxI;
+  }
+
+  if(mc.montecar<=0) return;
+
+  if( mc.Blending>0 && mc.Get_Par_Blending==0 ) {
+    printf("Vous avez demande une generation avec du Blending\n");
+    printf(" mais vous n'avez pas fourni la generation des parametres\n");
+    exit(-1);
+  }
+
+  printf("MONTECARLO %2d: ccd %6d, T0MinI_eff=%f T0MaxI_eff=%f\n"
+         ,io,ccdnum,mc.T0MinI_eff,mc.T0MaxI_eff);
+
+} else if(io == 3) {
+
+  mc.NGene++;
+
+  /* Blending preparation */
+  if( mc.Blending>0 ) mc.Get_Par_Blending();
+
+  /* Tirage aleatoire de u0 */
+  if ( mc.TireU0 != 0 ) {
+      x = drand01();
+      mc.U0Sim = mc.TireU0(x);
+  } else if(mc.U0MaxI > mc.U0MinI) {
+    mc.U0Sim= -1.;
+    while( mc.U0Sim <= 0. ) {
+      mc.U0Sim = mc.U0MinI + (mc.U0MaxI-mc.U0MinI)*drand01();
+      if(mc.U0Sim<=0.) printf("ATTENTION: U0 SIMULE A %f min=%f max=%f\n"
+                             ,mc.U0Sim,mc.U0MinI,mc.U0MaxI);
+  } }
+
+  /* generation plate de tau */
+  if ( mc.TireTau != 0 ) {
+     x = drand01();
+     mc.TauSim = mc.TireTau(x);
+  } else if ( mc.TauMaxI > mc.TauMinI ) {
+     mc.TauSim = mc.TauMinI
+               + (mc.TauMaxI-mc.TauMinI)*drand01();
+  }
+
+  /* Tirage aleatoire de t0 */
+  if ( mc.TireT0 != 0 ) {
+     x = drand01();
+     mc.T0Sim = mc.TireT0(x);
+  } else if( mc.T0MaxI_eff > mc.T0MinI_eff ) {
+     mc.T0Sim = mc.T0MinI_eff
+              + (mc.T0MaxI_eff-mc.T0MinI_eff)*drand01();
+  }
+
+  /* generation plate de U */
+  if( mc.Taille_Finie > 0 ) {
+    if ( mc.TireU != 0 ) {
+       x = drand01();
+       mc.USim = mc.TireU(x);
+    } else if ( mc.Taille_Finie>0 && mc.UMaxI > mc.UMinI ) {
+       mc.USim= mc.UMinI + (mc.UMaxI-mc.UMinI)*drand01();
+    }
+    if(mc.Taille_Finie==2) {
+      if( mc.Blending==0 ) mc.USim *= starcal.Rstar;
+      else if( mc.Blending==1 ) mc.USim *= mc.starcal1.Rstar;
+      else if( mc.Blending==2 ) mc.USim *= mc.starcal2.Rstar;
+    }
+  }
+
+  /* calcul amplification ponctuelle/taille finie (paczinsky) */
+  mc.A0MaxPt = GRAND;
+  if( mc.U0Sim > 0. ) mc.A0MaxPt = ampli_ponct(mc.U0Sim);
+  mc.A0Max = (mc.Taille_Finie && mc.USim>0.) ?
+             ampli_tf(mc.U0Sim,mc.USim,Nseq_tf) : mc.A0MaxPt;
+  if( mc.Blending>0) for(ic=0;ic<NCOULMX;ic++) {
+    if( mc.Blending == 1 )
+        mc.A0Max_blend[ic] = (mc.A0Max -1.)* mc.coeff_Arec1[ic] + 1.;
+    else if( mc.Blending == 2 )
+        mc.A0Max_blend[ic] = (mc.A0Max -1.)* mc.coeff_Arec2[ic] + 1.;
+  }
+
+  tf = 0;
+  for(ic=0;ic<NCOULMX;ic++) {
+    for(i=0;i<nmes[ic];i++) {
+      t = date[ic][i];
+      tt = (t-mc.T0Sim)/mc.TauSim;
+      u2 = mc.U0Sim*mc.U0Sim + tt*tt;
+      u = sqrt(u2);
+      ampli[ic][i] = ampli_ponct(u);
+      mc.NPoints_ampli++;
+      if( mc.Taille_Finie && t<GRAND2 && mc.USim>0. ) {
+        if( mc.USim > mc.Usu0_Cut * u ) {
+          ampli[ic][i] = ampli_tf(u,mc.USim,Nseq_tf);
+          mc.NPoints_ampli_tf++;
+          if(tf==0) { mc.Net_ampli_tf++ ; tf = 1;}
+        }
+      }
+      if(mc.Blending==1)
+             ampli[ic][i] = (ampli[ic][i] -1.)* mc.coeff_Arec1[ic] + 1.;
+        else if(mc.Blending==2)
+             ampli[ic][i] = (ampli[ic][i] -1.)* mc.coeff_Arec2[ic] + 1.;
+  } }
+
+  if(debug>1) {
+    for(ic=0;ic<NCOULMX;ic++) {
+      printf("ampli[%3d]-1 u0=%12.5g t0=%12.5g tau=%12.5g U=%12.5g:\n"
+            ,ic,mc.U0Sim,mc.T0Sim,mc.TauSim,mc.USim);
+      for(i=0;i<nmesure[ic];i++)
+        { j=indexu[ic][i]; printf(" %12.5g",ampli[ic][j]-1.);
+        if(i%10==9) printf("\n");}
+      if((nmesure[ic]-1)%10!=9) printf("\n");
+  } }
+
+} else if(io == 4) {
+
+  return;
+
+} else if(io == 5) {
+
+  if(mc.montecar<=0) return;
+
+  printf("MONTECARLO %2d: Nombre d'evenements engendres %d\n",io,mc.NGene);
+  printf("Nb de pts amplifies %d, nb de pts amplifies avec taille finie %d\n"
+        ,mc.NPoints_ampli,mc.NPoints_ampli_tf);
+  printf("Nb d'etoiles amplifiees avec taille finie %d\n"
+        ,mc.Net_ampli_tf);
+  Get_Ranf(seed_16v,0);
+  mc.iseed1 = (int_4)seed_16v[0];
+  mc.iseed2 = (int_4)seed_16v[1];
+  mc.iseed3 = (int_4)seed_16v[2];
+  printf("Aleatoire_de_fin_de_Generation %d %d %d\n"
+        ,mc.iseed1,mc.iseed2,mc.iseed3);
+
+}
+return;
+}
+
+/*==========================================================================*/
+double ampli_ponct(double u)
+/* amplification paczinsky dans le cas d'une source ponctuelle */
+{
+u *= u;
+if(u==0.) return(GRAND2);
+u = (u+2.)/sqrt(u*(u+4.));
+return (u);
+}
+
+/*==========================================================================*/
+double ampli_tf(double u, double U,int Nseq)
+/*
+Amplification paczinsky dans le cas d'une source non ponctuelle.
+  ( integration analytique partie interieure et
+    integration numerique partie exterieure )
+Integration exterieure par methode de Gauss (Higher order terms).
+  u = parametre d'impact en rayon d'Einstein en fct du temps
+  U = rayon de l'etoile projete en rayon d'Einstein
+  Nseq = nombre de pas pour l'integrale
+*/
+{
+int i,j;
+double u2,U2,lim1,lim2,dlim,A0,xc,x,nx,b,teta,Ka,z;
+int mIhoqN;
+double *IhoqNX, *IhoqNW;
+
+if( Nseq <= 0 ) Nseq = 2;
+if( u<0. || U<0. ) return(-1.);
+if( u==0. && U==0. ) return(GRAND2);
+
+mIhoqN=mIhoq9; IhoqNX=Ihoq9X; IhoqNW=Ihoq9W;
+
+u2 = u*u;
+U2 = U*U;
+
+Ka = 0.;
+lim1 = -1.;
+lim2 = 1.;
+dlim = (lim2 - lim1)/Nseq;
+
+/*** CAS 1 : u<=U (u=0 possible si U!=0) ***                */
+/* A = A0 + A1                                              */
+/* A0 = partie integrable (sum(dx,0<x<U-u))                 */
+/*    = (U-u) * sqrt((U-u)**2 + 4) / U2                     */
+/* A1 = 2*u/(Pi*U2) * sum(dx,-1<x<1)                        */
+/*    {(u2+2)/sqrt(u2+4)*acos[(u*(1+x**2)/2+U*x)/(U+x*u)]}  */
+
+if(u<=U) {
+  /* on calcule d'abord la partie analytique A0 */
+  x = (U-u);
+  A0 = x * sqrt(x*x + 4.);
+
+  /* on integre ensuite la partie numerique A1 */
+  for(j=0;j<Nseq;j++) {
+    xc = lim1 + (j+0.5)*dlim;
+    for(i=0;i<mIhoqN;i++) {
+      x = xc + IhoqNX[i]*dlim;
+      nx = U + x*u;
+      teta = acos( ( u*(1.+x*x)/2. + U*x ) /nx );
+      nx *= nx;
+      b = (nx + 2.) / sqrt(nx + 4.);
+      Ka += b * teta * IhoqNW[i];
+  } }
+  A0 += 2. * u / Pi * Ka * dlim;
+  A0 /= U2;
+}
+
+/*** CAS 2 : u>U   -->  U peut tendre vers 0 ***               */
+/* A = 2/(Pi*U) * sum(dx,-1<x<1)                               */
+/*    {(u2+2)/sqrt(u2+4)*acos[1-U2*(1-x**2)/(2*u*(u+x*U))]}    */
+/* quand U->0, la divergence (1/U) est enlevee en developpant  */
+/* acos(1-z) = sqrt(2*z)*[1+z/12+3*z2/160+...]                 */
+
+else if(u>U) {
+  for(j=0;j<Nseq;j++) {
+    xc = lim1 + (j+0.5)*dlim;
+    for(i=0;i<mIhoqN;i++) {
+      x = xc + IhoqNX[i]*dlim;
+      nx = u + x*U;
+      z = (1.-x*x) /(2.*u*nx);
+      nx *= nx;
+      b = (nx + 2.) / sqrt(nx + 4.);
+      if(U > 0.001*u) {
+        teta = acos( 1. - U2*z ) / U;
+      } else {        /* cas U-> 0 */
+        teta = sqrt(2.*z);
+        z *= U2;
+        teta *= 1. + z*(0.08333333333333 + 0.01875*z);
+      }
+      Ka += b * teta * IhoqNW[i];
+  } }
+  A0 = 2. / Pi * Ka * dlim;
+}
+
+/*** CAS IMPOSSIBLE ****/
+else {
+  printf("ampli_tf: CAS IMPOSSIBLE u=%f U=%f\n",u,U);
+  A0 = -1.;
+}
+
+return (A0);
+}
+
+/*==========================================================================*/
+double u0_ponct(double A)
+/*
+Parametre d'impact pour une amplification A
+  dans le cas d'une source ponctuelle.
+input: A = amplification
+*/
+{
+double u0;
+if(A<1.) return(-1.);
+if(A==1.) return(GRAND2);
+u0 = 2. * ( A/sqrt(A*A-1.) - 1.);
+u0 = sqrt(u0);
+return(u0);
+}
+
+/*==========================================================================*/
+double u0_tf(double A,double U,double prec,int *niter,double *Afinal)
+/*
+Parametre d'impact pour une amplification A
+  dans le cas d'une source non ponctuelle.
+input:
+  A = amplification
+  U = Rstar projete / Reinst
+  prec = precision souhaitee sur u0
+  niter = nombre maximum d'iterations permises
+output:
+  niter = nombre d'iterations utilisees (-1 si pas converge)
+  Afinal = amplification finale calculee pour u0
+  return = u0 si trouve
+           -1. si A<1.
+           -2. si A=1.
+           -3. si U<=0
+           -4. si A trop grand
+           -5. si encadrement de A non trouve
+*/
+{
+int nitermx;
+double a0=0,a1,a2,u0=0,u1,u2,test;
+
+nitermx = *niter;
+if(nitermx<=0) nitermx = 25;
+
+*Afinal = A;
+*niter = 0;
+if(A<1.)  return(-1.);
+if(A==1.) return(-2.);
+if(U<=0.) return(-3.);
+
+u1 = 0.;
+a1 = ampli_tf(u1,U,-1);
+if(a1==A) return(0.);
+/* on ne peut atteindre la valeur A */
+if(a1<A) { *Afinal = a1; return(-4.);}
+
+/* on recherche un intervalle encadrant A */
+u2 = u0_ponct(A);
+a2 = ampli_tf(u2,U,-1);
+while( a2>A && *niter<=nitermx ) {
+  /* printf("recherche inter %f (%f), %f (%f)\n",u1,a1,u2,a2); */
+  u1 = u2;
+  a1 = a2;
+  u2 *= 5.;
+  a2 = ampli_tf(u2,U,-1);
+  (*niter)++;
+}
+
+if( *niter>nitermx ) {
+  *Afinal = a2;
+  return(-5.);
+}
+  
+/* a ce niveau u1 (a1) et u2 (a2) encadrent u0 (a0) */
+test = 100.*prec;
+*niter = 0;
+while (test > prec && *niter<= nitermx ) {
+  /* printf("recherche conv %f (%f), %f (%f)\n",u1,a1,u2,a2); */
+  u0 = (u1+u2)/2.;
+  a0 = ampli_tf(u0,U,-1);
+  (*niter)++;
+  if(a0<A) {
+    u2 = u0;
+    a2 = a0;
+  } else {
+    u1 = u0;
+    a1 = a0;
+  }
+  test = fabs(a0-A);
+}
+
+if( *niter > nitermx ) *niter = -1;
+/* printf("conv atteinte %f  (%f), %f (%f)\n",u1,u2,a2); */
+*Afinal = a0;
+return(u0);
+
+}
+
Index: trunk/FrEROS/AnaLC/nbgene.h
===================================================================
--- trunk/FrEROS/AnaLC/nbgene.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbgene.h	(revision 3308)
@@ -0,0 +1,75 @@
+#ifndef  NBGENE_H_SEEN  
+#define  NBGENE_H_SEEN  
+
+  
+#ifdef __cplusplus
+
+#ifdef  FLAG_MAIN_NBSREAD
+#define  EXTERN 
+#else
+#define  EXTERN  extern
+#endif
+
+#else
+
+#define  EXTERN 
+
+#endif
+
+/* structure de definition du montecarlo */
+struct  montecarlo {
+  /* flag montecarlo et tailles finies */
+  int montecar,Taille_Finie,Blending;
+  /* initialisation aleatoire */
+  int_4 iseed1,iseed2,iseed3;
+  /* nbre engendre, nbre a engendrer par etoile */
+  int NGene,NGenStar;
+  /* nbre points amplifies, nombre points amplifies avec taille finie */
+  int NPoints_ampli,NPoints_ampli_tf,Net_ampli_tf;
+  /* ampli maxi ponctuelle, tf, coupure en amplification (apres=1.), blend */
+  float A0MaxPt,A0Max,Usu0_Cut,A0Max_blend[NCOULMX];
+  /* u0 initialisation, bornes min et max, simule */
+  float U0SimI,U0MinI,U0MaxI,U0Sim;
+  float (*TireU0)(float x);
+  /* t0 initialisation, bornes min et max, simule */
+  double T0SimI,T0MaxI,T0MinI,T0Sim;
+  double T0MaxI_eff,T0MinI_eff;
+  float (*TireT0)(float x);
+  /* tau initialisation, bornes min et max, simule (cas ponctuel) */
+  float TauSimI,TauMinI,TauMaxI,TauSim;
+  float (*TireTau)(float x);
+  /* U initialisation, bornes min et max, simule (cas ponctuel) */
+  float USimI,UMinI,UMaxI,USim;
+  float (*TireU)(float x);
+  /* cas du blending 1ere et 2sd etoiles */
+     /* fct de generation des parametres du blending */
+  void (*Get_Par_Blending)(void);
+     /* flux, coeff de blending et calib etoile principale */
+  float fmc1[NCOULMX],coeff_Arec1[NCOULMX];
+  STARCALU starcal1;
+     /* flux, coeff de blending et calib etoile secondaire */
+  float fmc2[NCOULMX],coeff_Arec2[NCOULMX];
+  STARCALU starcal2;
+     /* type (SP ou GR) des etoiles du couple blending */
+  int type1,type2;
+};
+typedef struct montecarlo MONTECARLO;
+
+EXTERN MONTECARLO mc;
+EXTERN int ANNEE_OBS;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+int Give_Annee_Obs(int lp);
+float Rayon_SP_Th(float magv);
+void AMPLML(int io);
+double ampli_ponct(double u);
+double ampli_tf(double u,double U,int Nseq);
+double u0_ponct(double A);
+double u0_tf(double A,double U,double prec,int *niter,double *Afinal);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
Index: trunk/FrEROS/AnaLC/nbsread.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbsread.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsread.cc	(revision 3308)
@@ -0,0 +1,1572 @@
+/* lecture des fichiers de suivi:     cmv 21/12/93 */
+#include "machdefs.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <signal.h>
+
+#include "fsvcache.h"
+#include "nbtri.h"
+#include "nbrandom.h"
+#include "nbmath.h"
+#include "strutil.h"
+#include "fsvst.h"
+
+// Ne pas changer l'ordre des 3 lignes suivantes!!!
+#define  FLAG_MAIN_NBSREAD
+#include "nbsread.h"
+#include "nbgene.h"
+
+void INIT_NBSR(void);
+void OPENSUIV(int ic);
+void READST(int ic);
+void READET(int ic);
+void DATCLEAN(int ic);
+void DATSORT(int ic);
+
+void SELSTAR(void);
+void GET_STAR_ID(void);
+
+int  DECODESUIVINAME(char* str);
+void DECODE_GLOBINFO(GLOBINFO *p);
+void DECODE_STARINFO(STARINFO *p, int ic);
+void DECODE_TIMEINFO(TIMEINFO *p, int ic, int imes);
+void DECODE_MESURE  (MESURE   *p, int ic, int imes);
+
+void DO_MALLOC(void);
+void DO_FREE(void);
+
+GLOBINFO     glinf;
+STARINFO     star;
+TIMEINFO     timinf;
+MESURE       mes;
+
+/* Pour catcher un CTRL-C ou des time limites */
+static struct sigaction Nbsread_Action;
+void Nbsread_SigCatchInit(void);
+void Nbsread_SigCatch(int s);
+
+void usage(int);
+void usage(int lp) {
+ printf("nbsread\n");
+ printf("  nom du fichier des fichiers de suivi\n");
+ printf("  [-h] help detaille\n");
+ printf("  [-et et1,et2,etinc]\n");
+ printf("  [-prt niv]\n");
+ printf("  [-dbg et1,et2,ccd,niv]\n");
+ printf("  [-kill mes1 mes2 mes3 ...]\n");
+ printf("  [-mc ngenstar]\n");
+ printf("  [-u0 U0MinI,U0MaxI,U0SimI]\n");
+ printf("  [-t0 T0MinI,T0MaxI,T0SimI]\n");
+ printf("  [-tau TauMinI,TauMaxI,TauSimI]\n");
+ printf("  [-tf type(1ou2),UMinI,UMaxI,USimI,Usu0_Cut]\n");
+ printf("  [-bl Blending (1ou2)]\n");
+ printf("  [-seed seed1,seed2,seed3]\n");
+ if(lp<=0) exit(-1);
+ printf("\n");
+ printf("et1,et2,etinc: on utilise les etoiles de et1 a et2 par pas de etinc\n");
+ printf("niv: niveau de print\n");
+ printf("et1,et2,ccd,niv: debug etoiles et1 a et2 ccd ccd (-1=tous) niveau niv\n");
+ printf("mes1 mes2 mes3...: mesure a ne pas considerer dans les cdl\n"); 
+ printf("ngenstar: nombre de generations montecarlo par etoile\n");
+ printf("U0MinI,U0MaxI,U0SimI: generation du parametre d impact (def=0,0,0)\n"); 
+ printf("   si U0MinI<U0MaxI on tire u0 plat entre U0MinI,U0MaxI\n"); 
+ printf("   si U0MinI>=U0MaxI u0 est fixe a U0SimI\n"); 
+ printf("TauMinI,TauMaxI,TauSimI: generation du parametre tau (def=0.01,365.)\n"); 
+ printf("   ... meme logique que u0 ...\n"); 
+ printf("T0MinI,T0MaxI,T0SimI: generation du temps du maximum (def=1,-1,-1)\n"); 
+ printf("   si T0MinI<T0MaxI on tire t0 plat entre T0MinI,T0MaxI\n"); 
+ printf("   si T0MinI>=T0MaxI ET T0SimI>0 t0 est fixe a T0SimI\n"); 
+ printf("                     ET T0SimI<0 t0 tout l intervalle du suivi (def)\n"); 
+ printf("type,UMinI,UMaxI,USimI,Usu0_Cut: pour tirage taille finie (def=0,0,0,0.001)\n");
+ printf("   type = 1 taille finie tirage plat en U = Rs(proj)/Re\n"); 
+ printf("          2 taille finie tirage plat en UC (U = UC*Rs)\n");
+ printf("   si UMinI>=UMaxI U est fixe a U0SimI\n"); 
+ printf("   si UMinI<UMaxI on tire U plat entre UMinI,UMaxI si type=1\n"); 
+ printf("                                 entre UMinI*Rs,UMaxI*Rs si type=2\n"); 
+ printf("Blending = 1 sur l'etoile la + brillante du couple\n");
+ printf("           2 sur l'etoile la - brillante du couple\n");
+ printf("Il y a possibilite de definir ses propres fct de tirage (cf nbgene.c)\n");
+ printf("seed1,seed2,seed3: initialisation des aleatoires (def=36117,51106,21478)\n");
+exit(-1);
+}
+
+/*==========================================================================*/
+int main (int narg, char *arg[])
+{
+int_4 i,ic,iet1,iet2,iet0,ietmax,ietinc=1;
+char str[NBSREAD_LSTR];
+
+printf("=====> ");
+for(i=0;i<narg;i++) printf("%s ",arg[i]);
+printf("\n");
+
+/* printf("main: narg=%d %s\n",narg,arg[0]); */
+if (narg < 2) usage(0);
+if( !strcmp(arg[1],"-h") != 0 ) usage(1);
+
+/*------------------------------------------*/
+/*-------- Initialisation variables --------*/
+/*------------------------------------------*/
+
+INIT_NBSR();
+
+/*---------------------------------------*/
+/*-------- Lecture des arguments --------*/
+/*---------------------------------------*/
+
+i=2;
+while ( i < narg ) {
+  /* printf("arg[%d] %s\n",i,arg[i]); */
+  if( !strcmp(arg[i],"-h") != 0 ) {
+    usage(1);
+  } else if( !strcmp(arg[i],"-et") != 0 ) {
+    i++;
+    sscanf(arg[i],"%d,%d,%d",&ietlim[0],&ietlim[1],&ietinc);
+    if( ietinc<=0 ) ietinc = 1;
+    printf("Etoiles traitees de %d a %d par pas de %d\n"
+          ,ietlim[0],ietlim[1],ietinc);
+  } else if( !strcmp(arg[i],"-prt") != 0 ) {
+    i++;
+    sscanf(arg[i],"%d",&ffprt);
+    printf("Niveau de print %d\n",ffprt);
+  } else if( !strcmp(arg[i],"-dbg") != 0 ) {
+    i++;
+    sscanf(arg[i],"%d,%d,%d,%d",&idebug[0],&idebug[1],&idebug[2],&idebug[3]);
+    printf("Debug de l'et %d a l'et %d ccd %d niveau %d\n"
+          ,idebug[0],idebug[1],idebug[2],idebug[3]);
+  } else if( !strcmp(arg[i],"-mc") != 0 ) {
+    i++;
+    sscanf(arg[i],"%d",&mc.NGenStar);
+    if(mc.NGenStar>0) mc.montecar=1;
+      else {mc.montecar=mc.NGenStar; mc.NGenStar=0;}
+    printf("MonteCarlo actif, %d generations par etoiles\n",mc.NGenStar);
+  } else if( !strcmp(arg[i],"-u0") != 0 ) {
+    i++;
+    sscanf(arg[i],"%f,%f,%f",&mc.U0MinI,&mc.U0MaxI,&mc.U0SimI);
+    printf("U0 generation de %g a %g ou %g\n"
+          ,mc.U0MinI,mc.U0MaxI,mc.U0SimI);
+  } else if( !strcmp(arg[i],"-tau") != 0 ) {
+    i++;
+    sscanf(arg[i],"%f,%f,%f",&mc.TauMinI,&mc.TauMaxI,&mc.TauSimI);
+    printf("Tau generation de %g a %g ou %g\n"
+          ,mc.TauMinI,mc.TauMaxI,mc.TauSimI);
+  } else if( !strcmp(arg[i],"-t0") != 0 ) {
+    i++;
+    sscanf(arg[i],"%lf,%lf,%lf",&mc.T0MinI,&mc.T0MaxI,&mc.T0SimI);
+    printf("T0 generation de %g a %g ou %g\n"
+          ,mc.T0MinI,mc.T0MaxI,mc.T0SimI);
+  } else if( !strcmp(arg[i],"-tf") != 0 ) {
+    i++;
+    sscanf(arg[i],"%d,%f,%f,%f,%f"
+          ,&mc.Taille_Finie,&mc.UMinI,&mc.UMaxI,&mc.USimI,&mc.Usu0_Cut);
+    printf("Taille finie %d generation de U %g a %g ou %g (prec=%g)\n"
+          ,mc.Taille_Finie,mc.UMinI,mc.UMaxI,mc.USimI,mc.Usu0_Cut);
+  } else if( !strcmp(arg[i],"-bl") != 0 ) {
+    i++;
+    sscanf(arg[i],"%d",&mc.Blending);
+    printf("Blending %d\n",mc.Blending);
+  } else if( !strcmp(arg[i],"-seed") != 0 ) {
+    i++;
+    sscanf(arg[i],"%d,%d,%d",&mc.iseed1,&mc.iseed2,&mc.iseed3);
+    printf("Seed %d %d %d\n",mc.iseed1,mc.iseed2,mc.iseed3);
+  } else if( !strcmp(arg[i],"-kill") != 0 ) {
+    i++;
+    while ( i<narg ) {
+      if ( arg[i][0] != '-' ) {
+        if ( nkillms<NKILLMSMX ) {
+          sscanf(arg[i],"%d",&killms[nkillms]);
+          nkillms++;
+          i++;
+        } else {
+          printf("Trop de mesures a tuer! nkillms=%d / %d\n",nkillms,NKILLMSMX);
+          exit(-1);
+        }
+      } else { i--; break;}
+    }
+    printf("Kill: %d mesures a tuer:",nkillms);
+    if(nkillms>0) for(ic=0;ic<nkillms;ic++) printf(" %d",killms[ic]);
+    printf("\n");
+  } else {
+    printf("arguments: cas non prevu: %s\n",arg[i]); usage(0);
+  }
+  i++;
+}
+ietlim[0] = ( ietlim[0] <= 0 ) ? 1 : ietlim[0] ;
+ietlim[1] = ( ietlim[1] < ietlim[0] ) ? IGRAND : ietlim[1] ;
+printf("Etoiles traitees de %d a %d\n",ietlim[0],ietlim[1]);
+
+/*----------------------------------------------------------------*/
+/*----- Lecture nom de fichier data et selection des etoiles -----*/
+/*----------------------------------------------------------------*/
+
+printf("Fichier de donnees suivi: %s\n",arg[1]);
+if( (dataccd = fopen(arg[1],"r") ) == 0 ) {
+  printf("impossible d'ouvrir .dataccd\n"); exit(-1);
+}
+
+GET_STAR_ID();
+
+/*-----------------------------------------*/
+/*-------- Initialisation generale --------*/
+/*-----------------------------------------*/
+
+/* initialisation des compteurs et des variables */
+
+numccd = nstdeb = netoiles = 0;
+
+rewind(dataccd);
+if( fgets(str,NBSREAD_LSTR,dataccd) == 0 )
+    {printf("fichier dataccd illisible\n"); exit(-1);}
+nbccd = -1;
+sscanf(str,"%d",&nbccd);
+printf("on veut traiter %d ccd\n",nbccd);
+if( nbccd <= 0 ) exit(-1);
+
+/* initialisation USER */
+
+Calibration_Absolue = 0;
+Calibration_Absolue_UParms = 0;
+UINIT();
+
+/* initialisation montecarlo */
+
+AMPLML( 1 );
+
+/* gestion des interrupts */
+
+Nbsread_SigCatchInit();
+
+/*-------------------------------------------------------*/
+/*-------- Boucle sur les CCD (ou paves Plaques) --------*/
+/*-------------------------------------------------------*/
+
+while ( fgets(str,NBSREAD_LSTR,dataccd) != 0 ) {   /* While... */
+
+strip(str,'B',' ');
+printf("%s\n",str);
+
+if ( strstr(str,"@END") == str ) break;
+
+if( strstr(str,"@CCD") == str) {
+
+  numccd++;
+  sscanf(&str[4],"%d",&ccdnum);
+  printf("Nouveau CCD: c'est le %d ieme, de numero %d\n",numccd,ccdnum);
+  szMXBYTE=0;
+  nbmsMX=0;
+  for (ic=0;ic<NCOULMX;ic++) {
+    nbfil[ic] = iet[ic] = net[ic] = nmes[ic]= 0;
+    for (i=0;i<NBFILMX;i++) nbms[ic][i] = nms1fil[ic][i] = 0;
+  }
+
+} else if( strstr(str,"@FINCCD") == str) {
+
+  for(ic=0;ic<NCOULMX;ic++) {
+    if( nbfil[ic] <= 0 ) continue;
+    /* printf("Main_Debug: lunfil[%d][0]=%ld\n",ic,lunfil[ic][0]); */
+    sztmi[ic] = lunfil[ic][0]->Head.RecSize[3] / lunfil[ic][0]->Head.NItem;
+    szmes[ic] = lunfil[ic][0]->Head.RecSize[4] / lunfil[ic][0]->Head.NItem;
+    if( szMXBYTE < sztmi[ic] ) szMXBYTE = sztmi[ic];
+    if( szMXBYTE < szmes[ic] ) szMXBYTE = szmes[ic];
+    if(ffprt>0) printf("coul=%3d sztmi=%d szmes=%d\n",ic+1,sztmi[ic],szmes[ic]);
+  }
+  if(ffprt>0) printf("szMXBYTE=%d\n",szMXBYTE);
+
+  DO_MALLOC();
+  for (ic=0;ic<NCOULMX;ic++) OPENSUIV(ic);
+  for (ic=0;ic<NCOULMX;ic++) DATCLEAN(ic);
+  for (ic=0;ic<NCOULMX;ic++) DATSORT (ic); /* fill indexu */
+  TFIRST = Tfirst[0]; TLAST  = Tlast[0];
+  for (ic=1;ic<NCOULMX;ic++) {
+    if( Tfirst[ic] != -1. && Tfirst[ic]<TFIRST ) TFIRST = Tfirst[ic];
+    if( Tlast[ic]  != -1. && Tlast[ic] >TLAST  ) TLAST  = Tlast[ic];
+  }
+  if(ffprt>0) printf("Tfirst=%.2f (1=.2%f,2=%.2f)  Tlast=%.2f (1=%.2f,2=%.2f)\n"
+                    ,TFIRST,Tfirst[0],Tfirst[1],TLAST,Tlast[0],Tlast[1]);
+  UINITCCD();
+  AMPLML( 2 );
+
+  iet1 = ( ietlim[0] > 0 ) ? ietlim[0] : 1;
+  iet2 = ( ietlim[1] > net[0] ) ? net[0] : ietlim[1];
+
+  for(iet0=iet1;iet0<=iet2; iet0+=ietinc) {   /* boucle sur les etoiles */
+
+    netoiles++;
+
+    for (ic=0;ic<NCOULMX;ic++) iet[ic]=iet0;
+
+    debug=0;
+    if( iet0>=idebug[0] && iet0<=idebug[1] && ( ccdnum==idebug[2] || idebug[2]<0) ) {
+      nstdeb++;
+      debug=idebug[3];
+    }
+    if(debug!=0) printf("\n\n************** DEBUG CCD %d ET %d LUES %d \n"
+                       ,ccdnum,iet0,netoiles);
+
+    /* lecture des starinfos */
+    for (ic=0;ic<NCOULMX;ic++) {
+      if( ic == 0 ) {   /*fichier non-composite ou couleur 1*/
+        READST(ic);
+      } else {
+        iet[ic] = staru[0].XRef;
+        READST(ic);
+      }
+    }
+
+    /* calibration absolue */
+    starcal.Mag_B= starcal.Mag_V= starcal.Mag_R
+                 = starcal.Mag_I= starcal.Rstar= -GRAND;
+    starcal.Rtype = -1;
+    if( iet[0]>0 && iet[1]>0 && Calibration_Absolue!=0 )
+      Calibration_Absolue(staru[0].FluxRef,staru[1].FluxRef,
+			  &starcal,Calibration_Absolue_UParms);
+
+    /* on saute l'etoile et la lecture des mesures ? */
+    if(starcut.Mag_B_cut>0 &&
+      (starcal.Mag_B<starcut.Mag_B_min || starcal.Mag_B>starcut.Mag_B_max) ) continue;
+    if(starcut.Mag_V_cut>0 &&
+      (starcal.Mag_V<starcut.Mag_V_min || starcal.Mag_V>starcut.Mag_V_max) ) continue;
+    if(starcut.Mag_R_cut>0 &&
+      (starcal.Mag_R<starcut.Mag_R_min || starcal.Mag_R>starcut.Mag_R_max) ) continue;
+    if(starcut.Mag_I_cut>0 &&
+      (starcal.Mag_I<starcut.Mag_I_min || starcal.Mag_I>starcut.Mag_I_max) ) continue;
+    if(starcut.Rstar_cut>0 &&
+      (starcal.Rstar<starcut.Rstar_min || starcal.Rstar>starcut.Rstar_max) ) continue;
+
+    if(starcut.Rtype_cut>0 &&
+      (starcal.Rtype<starcut.Rtype_min || starcal.Rtype>starcut.Rtype_max) ) continue;
+
+    if(starcut.Mag_BV_cut>0 &&
+      (starcal.Mag_B-starcal.Mag_V<starcut.Mag_BV_min ||
+       starcal.Mag_B-starcal.Mag_V>starcut.Mag_BV_max) ) continue;
+    if(starcut.Mag_BR_cut>0 &&
+      (starcal.Mag_B-starcal.Mag_R<starcut.Mag_BR_min ||
+       starcal.Mag_B-starcal.Mag_R>starcut.Mag_BR_max) ) continue;
+    if(starcut.Mag_VR_cut>0 &&
+      (starcal.Mag_V-starcal.Mag_R<starcut.Mag_VR_min ||
+       starcal.Mag_V-starcal.Mag_R>starcut.Mag_VR_max) ) continue;
+    if(starcut.Mag_RI_cut>0 &&
+      (starcal.Mag_R-starcal.Mag_I<starcut.Mag_RI_min ||
+       starcal.Mag_R-starcal.Mag_I>starcut.Mag_RI_max) ) continue;
+
+    /* l'etoile a t-elle ete selectionnee ? */
+    SELSTAR();
+
+    /* lecture des mesures */
+    for (ic=0;ic<NCOULMX;ic++) READET(ic);
+
+    ietmax = (mc.montecar>0 && mc.NGenStar>0) ? mc.NGenStar : 1;
+    ietgen=0;
+    while( ietgen < ietmax ) {
+      if(mc.montecar>0) AMPLML( 3 );
+      UEVT();
+      ietgen++;
+    }
+
+  }      /* fin de boucle sur les etoiles */
+
+  UENDCCD();
+
+  printf("on ferme les fichiers de suivi du ccd %d\n",ccdnum);
+  DO_FREE();
+  for(ic=0;ic<NCOULMX;ic++) {
+    printf("Couleur: %d\n",ic+1);
+    for(i=0;i<nbfil[ic];i++) {
+      printf("fichier %d\n",i);
+      SuiviClose(lunfil[ic][i]);
+  } }
+
+} else if( strstr(str,"@COUL") == str) {
+
+  sscanf(&str[5],"%d",&ic);
+  printf("Couleur: %d\n",ic);
+  ic--;
+
+} else {
+  str[strlen(str)-1] = ' ';   /*  lu par fgets() */
+  strip(str,'B',' ');
+  DECODESUIVINAME(str);
+  printf("%s\n",str);
+  strcpy(lunnam[ic][nbfil[ic]], str);
+  printf("lunnam[%d][nbfil[%d]] == lunnam[%d][%d] = %s\n"
+        ,ic,ic,ic,nbfil[ic],lunnam[ic][nbfil[ic]]);
+  if( (lunfil[ic][nbfil[ic]] = SuiviOpen(str,OpenType)) == 0 ) {
+    printf("Impossible d'ouvrir le fichier %s\n",str);
+    exit(-1);
+  }
+  /* lecture du nombre de mesures */
+  nbms[ic][nbfil[ic]] = SuiviGetNbMesures(lunfil[ic][nbfil[ic]]);
+  if(ffprt>1) printf("Ouverture lunfil[%3d][%5d] = %d mes\n"
+                    ,ic,nbfil[ic],nbms[ic][nbfil[ic]]);
+  if( nbms[ic][nbfil[ic]] > nbmsMX ) nbmsMX = nbms[ic][nbfil[ic]];
+  /* numero du 1er fichier de l'unite nbfil[ic]: va de 0->nmes */
+  nms1fil[ic][nbfil[ic]] = nmes[ic];
+  nmes[ic] += nbms[ic][nbfil[ic]];
+  nbfil[ic]++;
+
+}
+}   /* Fin du While... */
+
+UEND();
+AMPLML( 5 );
+if( StId1 != 0 ) free(StId1);
+if( StId2 != 0 ) free(StId2);
+fclose(dataccd);
+
+printf("Nombre total d'etoiles lues %d\n",netoiles);
+
+exit(0);
+}
+
+/*==========================================================================*/
+void INIT_NBSR(void)
+{
+int i;
+
+OpenType= SUOF_RO_MEM2;
+GRAND2_KILL = 5. * GRAND2;
+
+ietlim[0]= -IGRAND;
+ietlim[1]= IGRAND;
+idebug[0]=idebug[1]=idebug[2]=idebug[3]=0;
+NStId = NSelStId = FgSelSt = 0;
+StId1 = StId2 = 0;
+nkillms = 0; for(i=0;i<NKILLMSMX;i++) killms[i]=0;
+ffprt=0;
+
+starcut.Mag_B_cut  = 0;   starcut.Mag_B_min  = starcut.Mag_B_max = 0.;
+starcut.Mag_V_cut  = 0;   starcut.Mag_V_min  = starcut.Mag_V_max = 0.;
+starcut.Mag_R_cut  = 0;   starcut.Mag_R_min  = starcut.Mag_R_max = 0.;
+starcut.Mag_I_cut  = 0;   starcut.Mag_I_min  = starcut.Mag_I_max = 0.;
+starcut.Mag_BV_cut = 0;   starcut.Mag_BV_min = starcut.Mag_BV_max = 0.;
+starcut.Mag_BR_cut = 0;   starcut.Mag_BR_min = starcut.Mag_BR_max = 0.;
+starcut.Mag_VR_cut = 0;   starcut.Mag_VR_min = starcut.Mag_VR_max = 0.;
+starcut.Mag_RI_cut = 0;   starcut.Mag_RI_min = starcut.Mag_RI_max = 0.;
+starcut.Rstar_cut  = 0;   starcut.Rstar_min  = starcut.Rstar_max = 0.;
+starcut.Rtype_cut  = 0;   starcut.Rtype_min  = starcut.Rtype_max = 0;
+
+mc.montecar=0;
+mc.Taille_Finie=0;
+mc.Blending=0;
+mc.NGenStar=1;
+mc.Usu0_Cut = 0.001;
+mc.U0SimI=0.; mc.U0MinI=0.; mc.U0MaxI=0.;
+mc.TireU0 = 0;
+mc.T0SimI= -1.; mc.T0MinI=1.; mc.T0MaxI= -1.;
+mc.TauSimI=0.; mc.TauMinI=0.01; mc.TauMaxI=365.;
+mc.TireTau = 0;
+mc.USimI=0.; mc.UMinI=0.; mc.UMaxI=0.;
+mc.TireU = 0;
+mc.Get_Par_Blending = 0;
+mc.coeff_Arec1[0] = mc.coeff_Arec1[1] = 0.;
+mc.coeff_Arec2[0] = mc.coeff_Arec2[1] = 0.;
+mc.starcal1.Rstar = mc.starcal2.Rstar = 0.;
+mc.iseed1 = 36117;
+mc.iseed2 = 51106;
+mc.iseed3 = 21478;
+
+}
+
+/*==========================================================================*/
+void OPENSUIV(int ic)
+/* ic = couleur (0 a 1) */
+{
+int_4 i,j,rc;
+int_4 l, i1, i2;
+int lp;
+
+if(ffprt>0) printf("===> OPENSUIV couleur %3d\n",ic+1);
+
+if( nbfil[ic] <= 0 ) return;
+
+if(nmes[ic]>0 && ffprt>0) {
+  printf("Coul %2d nmes %5d on lit %4d fichiers, nbmsMAX %5d\n"
+        ,ic+1,nmes[ic],nbfil[ic],nbmsMX);
+  if(ffprt>1) {
+    printf("nbms:\n");
+    for(i=0;i<nbfil[ic];i++) {printf(" %6d",nbms[ic][i]); if(i%10==9) printf("\n");}
+    if((nbfil[ic]-1)%10!=9) printf("\n");
+
+    printf("nms1fil:\n");
+    for(i=0;i<nbfil[ic];i++) {printf(" %6d",nms1fil[ic][i]); if(i%10==9) printf("\n");}
+    if((nbfil[ic]-1)%10!=9) printf("\n");
+} }
+
+for(i=0;i<nbfil[ic];i++) {
+
+  l = SuiviGetType(lunfil[ic][i]);
+
+  /* type de fichier de suivi */
+  if( i==0 && ic==0 ) {
+    typsuivi=l;
+    printf("Type du fichier de Suivi: %d\n",typsuivi);
+  } else if ( typsuivi != l ) {
+    printf("couleur %3d fichier de suivi %5d mauvais type %d %d\n"
+          ,ic+1,i+1,l,typsuivi);
+    exit(-1);
+  }
+
+  /* lecture de global info */
+  if( ( rc=SuiviReadGlobInfo( lunfil[ic][i],(char *) (&glinf) ) ) != 0 ) {
+    printf("Problemes lecture global info coul %3d fichier %d, rc=%d\n",ic+1,i+1,rc);
+    exit(-1);
+  }
+  DECODE_GLOBINFO(&glinf);
+
+  //if( ffprt>3 || (ffprt>0 && i==0) ) PrtGlobInfo(&glinf,ffprt-3);
+  if( ffprt>3 || (ffprt>0 && i==0) ) PrtGlobInfo(&glinf,99);
+    
+  /* lecture du nombre d'etoiles */
+  l= SuiviGetNbStars(lunfil[ic][i]);
+  if( i==0 ) {
+    net[ic] = SuiviGetNbStars(lunfil[ic][i]);
+  } else if( l !=net[ic] ) {
+    printf("Probleme dans nombre d'etoiles coul %3d fichier %d: %d %d\n"
+          ,ic+1,i+1,l,net[ic]);
+    exit(-1);
+  }
+
+}
+
+/* REMARQUE
+   lecture de timeinfo:
+   attention: on passe par un buffer intermediaire car quand on definit
+   une structure, la longueur est un nombre entier de fois l'element
+   le plus long de la structure (ici (double)) et donc on a, pour TIMEINFO
+   sizeof(TIMEINFO)=416 au lieu de 412 effectivement ecrit 
+   Depuis la version avec gestion du Byte swap entre machine il n'est
+   plus possible de lire directement une serie de timeinfo (meme pb pour mesure),
+   il faut boucler sur toutes les photos! (debug 13/03/98 Reza)
+   Voici le commentaire exact de Reza:  
+     "On ne peut plus lire un groupe de mesure ou de timeinfo s'il faut
+      ByteSwaper et si Taille RecSuivi <> sizeof(structure)
+      il faut lire les mesures/timeinfo un a un"
+   Versions CVS ou il y avait encore la lecture par buffer:
+     nbsread.h 1.14 , nbsread.c 1.30
+*/
+
+lp = ffprt-2;
+
+if(nmes[ic]>0) {
+  for(i=0;i<nbfil[ic];i++) {
+    i2=nbms[ic][i];
+    i1=nms1fil[ic][i];
+    for(j=0;j<i2;j++) {
+      if( (rc=SuiviReadTimeInfo(lunfil[ic][i], j+1, j+1, (char *)(&timinf))) != 0 ) {
+        printf("Problemes lecture timinf info coul %3d fichier %5d, rc=%d\n"
+              ,ic+1,i+1,rc);
+        exit(-1);
+      }
+      l = j+i1;
+      DECODE_TIMEINFO(&timinf,ic,l);
+      indexu[ic][l] = 0;
+      date  [ic][l] = (double) timeu[ic][l].TStart / JourSec;
+      ampli [ic][l] = 1.;
+      meslun[ic][l] = i;
+      if( ffprt>1 ) {
+        PrtTimeInfo (&timinf,l,ffprt-2);
+        if( ffprt>5 ) PrtTimeInfoU (&timeu[ic][l],l,1);
+      }
+    }
+  }
+}
+
+/* some prints ? */
+if(nmes[ic]>0 && ffprt>0) {
+  printf("date:\n");
+  for(i=0;i<nmes[ic];i++) {printf(" %9.2f",date[ic][i]); if(i%10==9) printf("\n");}
+  if((nmes[ic]-1)%10!=9) printf("\n");
+  if(lp>=3) {
+    printf("meslun:\n");
+    for(i=0;i<nmes[ic];i++) {printf(" %9d",meslun[ic][i]); if(i%10==9) printf("\n");}
+    if((nmes[ic]-1)%10!=9) printf("\n");
+} }
+
+}
+
+/*==========================================================================*/
+void READST(int ic)
+/* ic = couleur (0 a 1) */
+{
+int_4 i,rc;
+
+staru[ic].XRef=0;
+
+if(nmes[ic]>0)
+  for(i=0;i<nmes[ic];i++) mesu[ic][i].Flux=mesu[ic][i].Fond=0.;
+
+if(debug>0) printf("READST: coul %3d et %d\n",ic+1,iet[ic]);
+
+if( iet[ic]<=0 || iet[ic]>net[ic] ) return;
+
+/*lecture de star info sur premier fichier */
+if((rc=SuiviReadStarInfo(lunfil[ic][0],iet[ic],(char *)(&star))) != 0) {
+  printf("Problemes lecture star info coul %3d etoile %d, rc=%d\n"
+        ,ic+1,iet[ic],rc);
+  exit(-1);
+}
+
+DECODE_STARINFO(&star,ic);
+
+if(debug>1) {
+  printf("starinfo: coul %3d nbfil=%5d\n",ic+1,nbfil[ic]);
+  PrtStarInfo(&staru[ic],ic,5);
+}
+
+}
+
+/*==========================================================================*/
+void READET(int ic)
+/* ic = couleur (0 a 1) */
+{
+int_4 i,j,rc;
+int_4 i1,i2;
+
+if( iet[ic]<=0 || iet[ic]>net[ic] ) return;
+if( nmes[ic]<=0 ) return;
+
+/* lecture des mesures: cf lecture expliquee pour timeinfo */
+for(i=0;i<nbfil[ic];i++) {
+  if(debug>1) printf("    Fichier %5d nbms %5d\n",i,nbms[ic][i]);
+  i2=nbms[ic][i];
+  i1=nms1fil[ic][i];
+  for(j=0;j<i2;j++) {
+    if((rc=SuiviReadMesures(lunfil[ic][i],iet[ic],j+1,j+1,(char *)(&mes))) != 0) {
+      printf("Problemes lecture mes coul %3d etoile %d lim %5d %5d, rc=%d\n"
+            ,ic+1,iet[ic],i1,i2,rc);
+      exit(-1);
+    }
+    DECODE_MESURE(&mes,ic,j+i1);
+    if(debug>5) PrtMesure(&mes,j+i1,5);
+  }
+}
+
+
+if(debug>3) {
+  if(debug>4) for(i=0;i<nmes[ic];i++) PrtMesureU(&mesu[ic][i],i,5);
+  printf("\nmesu.Flux couleur=%d:\n",ic);
+  for(i=0;i<nmesure[ic];i++) {
+    j=indexu[ic][i];
+    printf(" %12.5g",mesu[ic][j].Flux);
+    if(i%10==9 || i==nmesure[ic]-1) printf("\n");
+  }
+  if(debug>4) {
+    printf("mesu.ErrFlux couleur=%d:\n",ic);
+    for(i=0;i<nmesure[ic];i++) {
+       j=indexu[ic][i]; printf(" %12.5g",mesu[ic][j].ErrFlux);
+       if(i%10==9 || i==nmesure[ic]-1) printf("\n");
+     }
+    printf("mesu.FluxB couleur=%d:\n",ic);
+    for(i=0;i<nmesure[ic];i++) {
+       j=indexu[ic][i]; printf(" %12.5g",mesu[ic][j].FluxB);
+       if(i%10==9 || i==nmesure[ic]-1) printf("\n");
+    }
+  }
+}
+
+}
+
+/*==========================================================================*/
+void DATCLEAN(int ic)
+/* ic = couleur (0 a 1) */
+{
+int_4 i,j,k;
+double d1,d2;
+
+if(ffprt>0) printf("=====> DATCLEAN coul=%3d ccd %5d\n",ic+1,ccdnum);
+
+if(nmes[ic]<=0) return;
+
+/* on tue selon les criteres utilisateur */
+UDATCLEAN(ic+1);
+/* a ce niveau les dates=GRAND2_KILL ne doivent absolument plus servir */
+
+/* on tue les mesures 'n' pour chaque fichier de suivi */
+if( nbfil[ic] > 0 ) {
+  for(i=0;i<nbfil[ic];i++) {
+    if( nbms[ic][i]<= 0 ) continue;
+    for(j=0;j<nbms[ic][i];j++) {
+      if( date[ic][nms1fil[ic][i]+j] >= GRAND2_KILL) continue;
+      for(k=0;k<nkillms;k++) if ( j+1 == killms[k] ) {
+        if(ffprt>1)
+          printf(" Kill: mesure %6d (seq=%6d) du fichier suivi %4d\n"
+                         ,j,nms1fil[ic][i]+j,i);
+        date[ic][nms1fil[ic][i]+j] = GRAND2;
+      }
+    }
+  }
+}
+
+
+/* on tue les temps en double et on prend le dernier */
+if( nmes[ic]>1 ) {
+  for(i=0;i<nmes[ic]-1;i++) {
+    d1=date[ic][i];
+    if( d1 >= GRAND2 ) continue;
+    for(j=i+1;j<nmes[ic];j++) {
+      d2=date[ic][j];
+      if( d2 >= GRAND2 ) continue;
+      if( fabs(d1-d2) < (double) 0.00000001 ) {
+        if(ffprt>1)
+          printf(" Kill: %5d t=%f car dupliquee avec %5d t=%f soit %f\n"
+                ,i,d1,j,d2,fabs(d1-d2));
+        date[ic][i] = GRAND2;
+        break;
+      }
+    }
+  }
+}
+
+}
+
+/*==========================================================================*/
+void DATSORT(int ic)
+/* ic = couleur (0 a 1) */
+{
+int_4 i,j;
+
+if(ffprt>0) printf("DATSORT: coul %3d ccd %5d\n",ic+1,ccdnum);
+
+nmesure[ic]=0;
+Tfirst[ic] = Tlast[ic] = -1.;
+
+if(nmes[ic]<=0) return;
+
+tri_double (date[ic],indexu[ic],nmes[ic]);
+
+for(i=0;i<nmes[ic];i++) if(date[ic][i]<GRAND2) nmesure[ic]++;
+
+if(nmesure[ic]>0) {
+  Tfirst[ic]=date[ic][indexu[ic][0]];
+  Tlast[ic]=date[ic][indexu[ic][nmesure[ic]-1]];
+}
+
+if(ffprt>0) {
+  printf("coul %3d nmesure %6d nmes %6d Tint %.3f %.3f\n"
+                  ,ic+1,nmesure[ic],nmes[ic],Tfirst[ic],Tlast[ic]);
+  if(ffprt>1) {
+    printf("date:\n");
+    for(i=0;i<nmes[ic];i++)
+      {
+      j=indexu[ic][i];
+      if(date[ic][j]<GRAND2) printf(" %9.2f",date[ic][j]);
+        else printf(" %9.2f",-1.);
+      if(i%10==9) printf("\n");
+      }
+    if((nmes[ic]-1)%10!=9) printf("\n");
+  
+    printf("timeu.NumPhoto:\n");
+    for(i=0;i<nmes[ic];i++) {
+       j=indexu[ic][i]; printf(" %9d",timeu[ic][j].NumPhoto); if(i%10==9) printf("\n");}
+    if((nmes[ic]-1)%10!=9) printf("\n");
+
+    if(ffprt>2) {
+      printf("indexu:\n");
+      for(i=0;i<nmes[ic];i++) {
+         printf(" %9d",indexu[ic][i]); if(i%10==9) printf("\n");}
+      if((nmes[ic]-1)%10!=9) printf("\n");
+} } }
+
+}
+
+/*==========================================================================*/
+int DECODESUIVINAME(char* str)
+/*
+Pour decoder les noms des variables d'environnement dans une chaine de characteres
+- La chaine "str" est mofifiee (et doit donc etre modifiable)
+- Variable d'environnement = /home/.../toto/ ou /home/.../toto (avec ou sans / final)
+- La chaine "str" peut etre:
+  $AAA ${AAA} $(AAA) $AAA/blabla ${AAA}/blabla $(AAA)/blabla /.../$AAA/... etc...
+  Le cas ${AAA}blabla $(AAA)blabla n'est pas traite (/ impose en fin de nom de variable)
+- Retourne: -1 si echec, 0 si pas de variable a decoder, sinon nombre de variables decodees
+*/
+{
+char *str1,*vnam,*cenv;
+int ls=0,lce,rc=0,i,ip,jp;
+
+ls = strlen(str);
+/* Pas de $ ou chaine trop courte */
+if(posc(str,'$')<0 || ls<1) return rc;
+str1 = (char *) malloc((NBSREAD_LSTR+5)*sizeof(char));
+vnam = (char *) malloc(NBSREAD_LSTR*sizeof(char));
+
+i= ip = rc = 0;
+while( i<ls ) {
+  if(str[i] == ' ') {               /* on vire les blancs */
+    i++;
+  } else if(str[i] == '/') {        /* on vire les doubles "/" */
+    if(str1[ip]=='/') i++; else {str1[ip] = str[i]; ip++; i++;}
+  } else if(str[i] != '$') {        /* pas de variable d'environnement */
+    str1[ip] = str[i]; ip++; i++;
+  } else {                          /* variable d'environnement */
+    jp = 0;
+    while( i<ls ) {
+      if(str[i]=='/') {i++; break;}
+      else if(str[i]=='$'||str[i]=='{'||str[i]=='}'||str[i]=='('||str[i]==')')  i++;
+      else {vnam[jp]=str[i]; jp++; i++;}
+    }
+    vnam[jp] = '\0';
+    if( (cenv=getenv(vnam)) == NULL )
+      {printf("variable inconnue=%s.\n",vnam); free(str1); free(vnam); return -1;}
+    lce = strlen(cenv);
+    rc++;
+    if(lce>0) {
+      jp = 0;
+      while( jp<lce ) {
+        /* on evite TOTO=/home/toto/ et blabla/$TOTO -> blabla//home/toto */
+        if(ip>0) if(jp==0 && cenv[jp]=='/' && str1[ip-1]=='/') {jp++; continue;}
+        str1[ip] = cenv[jp]; ip++; jp++;
+      }
+      /* on evite TOTO=/home/toto/ et $TOTO/blabla -> /home/toto//blabla */
+      if(cenv[lce-1]!='/') {str1[ip] = '/'; ip++;}
+    }
+  }
+}
+str1[ip] = '\0';
+strcpy(str,str1);
+
+free(str1); free(vnam);
+return rc;
+}
+
+/*==========================================================================*/
+void DECODE_GLOBINFO(GLOBINFO *p)
+{
+globu = *p;
+}
+
+/*==========================================================================*/
+void DECODE_TIMEINFO(TIMEINFO *p, int ic, int imes)
+/* ic = couleur (0 a 1), imes = mesure (0 a nmes-1) */
+{
+DecodeTim( p , &timeu[ic][imes]);
+}
+
+/*==========================================================================*/
+void DECODE_STARINFO(STARINFO *p, int ic)
+/* ic = couleur (0 a 1) */
+{
+staru[ic] = *p;
+}
+
+/*==========================================================================*/
+void DECODE_MESURE(MESURE *p, int ic, int imes)
+/* ic = couleur (0 a 1), imes = mesure (0 a nmes-1) */
+{
+if(date[ic][imes]<GRAND2_KILL) {
+  DecodeMes( p , &mesu[ic][imes] );
+  Calibre_F_E( &mesu[ic][imes], &timeu[ic][imes]);
+} else {
+  Mes_a_zero(&mesu[ic][imes]);
+}
+}
+
+/*==========================================================================*/
+void DO_MALLOC(void)
+{
+int n,ic;
+size_t ll,sof, sofM, sofT;
+
+if(ffprt>1)
+  printf("DO_MALLOC: nbmsMX=%d  szMXBYTE=%d\n",nbmsMX,szMXBYTE);
+
+for(ic=0;ic<NCOULMX;ic++) {          /* BOUCLE SUR LES COULEURS */
+
+  n = (nmes[ic] > 0) ? nmes[ic] : 1;
+
+  sofT = sizeof(TIMEINFOU);
+  ll= n * sofT;
+  if(ffprt>0)
+    printf("timeu: allocation de %5d unites de %d bytes soit %d\n"
+          ,n,(int)sofT,(int)ll);
+  if( ( timeu[ic] = (TIMEINFOU *) malloc(ll) ) == 0 ) {
+    printf("impossible d'allouer *timeu par malloc coul %3d\n",ic+1);
+    exit(-1);
+  }
+
+  sofM = sizeof(MESUREU);
+  ll= n * sofM;
+  if(ffprt>0)
+    printf("mesu: allocation de %5d unites de %d bytes soit %d\n"
+          ,n,(int)sofM,(int)ll);
+  if( (mesu[ic] = (MESUREU *) malloc(ll) ) == 0 ) {
+    printf("impossible d'allouer *mesu par malloc coul %3d\n",ic+1);
+    exit(-1);
+  }
+
+  sof = sizeof(int_4);
+  ll= n * sof;
+  if(ffprt>0)
+    printf("indexu: allocation de %5d unites de %d bytes soit %d\n"
+          ,n,(int)sof,(int)ll);
+  if( (indexu[ic] = (int_4 *) malloc(ll) ) == 0 ) {
+    printf("impossible d'allouer *indexu par malloc coul %3d\n",ic+1);
+    exit(-1);
+  }
+
+  sof = sizeof(unsigned short);
+  ll= n * sof;
+  if(ffprt>0)
+    printf("meslun: allocation de %5d unites de %d bytes soit %d\n"
+          ,n,(int)sof,(int)ll);
+  if( (meslun[ic] = (unsigned short *) malloc(ll) ) == 0 ) {
+    printf("impossible d'allouer *meslun par malloc coul %3d\n",ic+1);
+    exit(-1);
+  }
+
+  sof = sizeof(double);
+  ll= n * sof;
+  if(ffprt>0)
+    printf("date: allocation de %5d unites de %d bytes soit %d\n"
+          ,n,(int)sof,(int)ll);
+  if( (date[ic] = (double *) malloc(ll) ) == 0 ) {
+    printf("impossible d'allouer *date par malloc coul %3d\n",ic+1);
+    exit(-1);
+  }
+
+  sof = sizeof(float);
+  ll= n * sof;
+  if(ffprt>0)
+    printf("ampli: allocation de %5d unites de %d bytes soit %d\n"
+          ,n,(int)sof,(int)ll);
+  if( (ampli[ic] = (float *) malloc(ll) ) == 0 ) {
+    printf("impossible d'allouer *ampli par malloc coul %3d\n",ic+1);
+    exit(-1);
+  }
+
+}             /* BOUCLE SUR LES COULEURS */
+
+}
+
+/*==========================================================================*/
+void DO_FREE(void)
+{
+int ic;
+for(ic=0;ic<NCOULMX;ic++) {
+  free(timeu[ic]);
+  free(mesu[ic]);
+  free(indexu[ic]);
+  free(date[ic]);
+  free(ampli[ic]);
+}
+}
+
+/*==========================================================================*/
+int read_timeinfo(int ic,int imes,TIMEINFO *tim)
+/*
+Lecture de timeinfo pour la couleur ic (0->1), mesure imes (0->nmes[ic]-1)
+  return 0 si OK, <0 si problemes
+*/
+{
+int rc,ifil,ime;
+
+if ( imes<0 || imes>=nmes[ic] ) return(-1);
+ifil = meslun[ic][imes];
+if ( ifil<0 || ifil>=nbfil[ic] ) return(-2);
+ime = imes-nms1fil[ic][ifil];
+if ( ime<0 || ime>=nbms[ic][ifil] ) return(-3);
+
+rc=SuiviReadTimeInfo(lunfil[ic][ifil], ime+1, ime+1, (char *)(tim));
+if( rc != 0 ) {
+  printf("read_timeinfo: problemes lecture timinf info coul %3d fichier %5d, rc=%d\n"
+        ,ic+1,imes+1,rc);
+  return(-4);
+}
+
+/*
+printf("ic=%2d imes=%5d ifil=%4d ime=%5d NumPhoto=%d TStart=%d Expose=%d\n"
+      ,ic,imes,ifil,ime,tim->NumPhoto,tim->TStart,tim->Expose);
+printf("          Calib=%f %f sig=%f %f %f\n"
+      ,tim->Calib[0][0],tim->Calib[0][1],tim->SigX,tim->SigY,tim->Rho);
+*/
+
+return(0);
+}
+
+/*==========================================================================*/
+void SELSTAR(void)
+/* selection de l etoile courante ? */
+{
+int i;
+FgSelSt = 0;
+if( NSelStId <= 0 || NStId <= 0 || StId1 == 0 || StId2 == 0 ) return;
+for(i=0;i<NSelStId;i++)
+  if( StId1[i]<=iet[0] && iet[0]<=StId2[i] ) {FgSelSt = iet[0]; break;}
+}
+
+/*==========================================================================*/
+void GET_STAR_ID(void)
+/*
+Lecture du fichier dataccd pour identifier les cartes de selection des etoiles.
+*/
+{
+char str[NBSREAD_LSTR];
+int nallmin = 50, l;
+
+NStId = NSelStId = FgSelSt = 0;
+if( StId1 != 0 ) { free(StId1); StId1 = 0;}
+if( StId2 != 0 ) { free(StId2); StId2 = 0;}
+
+StId1 = (int *)malloc(nallmin*sizeof(int));
+StId2 = (int *)malloc(nallmin*sizeof(int));
+if( StId1==0 || StId2==0 ) {
+  printf("GET_STAR_ID: Impossible d allouer StId1/2 pour la premiere fois %d\n"
+        ,nallmin);
+  return;
+} else NStId = nallmin;
+
+rewind(dataccd);
+while ( fgets(str,NBSREAD_LSTR,dataccd) != 0 ) {
+  strip(str,'B',' ');
+  if ( strstr(str,"@SELET") != str ) continue;
+  if( NSelStId >= NStId ) {
+    l = NStId + nallmin;
+    StId1 = (int *)realloc(StId1,l*sizeof(int));
+    StId2 = (int *)realloc(StId2,l*sizeof(int));
+    if( StId1==0 || StId2==0 ) {
+      printf("GET_STAR_ID: Impossible de re-allouer %d pour StId1/2\n",l);
+      return;
+    } else {
+      NStId = l;
+      /* printf("GET_STAR_ID: reallocation de %d pour StId1/2 reussie\n",NStId); */
+    }
+  }
+  StId1[NSelStId]=StId2[NSelStId]=-1;
+  sscanf(&str[6],"%d %d",&StId1[NSelStId],&StId2[NSelStId]);
+  if( StId2[NSelStId]<StId1[NSelStId] ) StId2[NSelStId]=StId1[NSelStId];
+  NSelStId++;
+}
+
+if(ffprt>0) {
+  printf("GET_STAR_ID: %d selections d etoiles (lim=%d)\n",NSelStId,NStId);
+  if(ffprt>5)
+    for(l=0;l<NSelStId;l++) {
+      printf("    sel[%d]   et %d",l+1,StId1[l]);
+      if( StId1[l]!=StId2[l] ) printf("  a %d\n",StId2[l]);
+        else printf("\n");
+    }
+}
+
+}
+
+/*==========================================================================*/
+void Nbsread_SigCatchInit(void)
+{
+int rc;
+#ifdef OSF1
+Nbsread_Action.sa_mask = 0;
+Nbsread_Action.sa_flags = SA_RESTART;
+#endif
+#ifdef HPUX
+memset( &(Nbsread_Action.sa_mask), 0, sizeof(sigset_t) ); 
+Nbsread_Action.sa_flags = 0;
+#endif
+#ifdef Linux
+memset( &(Nbsread_Action.sa_mask), 0, sizeof(sigset_t) ); 
+Nbsread_Action.sa_flags = 0;
+#endif
+Nbsread_Action.sa_handler = Nbsread_SigCatch;
+
+if( (rc=sigaction(SIGINT, &Nbsread_Action, NULL)) != 0 )
+  printf("Nbsread_SigCatchInit_Error: signal SIGINT=%d rc=%d\n",SIGINT,rc);
+if( (rc=sigaction(SIGUSR1, &Nbsread_Action, NULL)) != 0 )
+  printf("Nbsread_SigCatchInit_Error: signal SIGUSR1=%d rc=%d\n",SIGUSR1,rc);
+if( (rc=sigaction(SIGUSR2, &Nbsread_Action, NULL)) != 0 )
+  printf("Nbsread_SigCatchInit_Error: signal SIGUSR2=%d rc=%d\n",SIGUSR2,rc);
+}
+
+/*==========================================================================*/
+void Nbsread_SigCatch(int s)
+{
+switch(s) {
+  case SIGINT :
+    printf("\n\nNbsread_SigCatch: signal SIGINT=%d catched\n\n",s);
+    break;
+  case SIGUSR1 :
+    printf("n\nNbsread_SigCatch: signal SIGUSR1=%d catched\n\n",s);
+    break;
+  case SIGUSR2 :
+    printf("n\nNbsread_SigCatch: signal SIGUSR2=%d catched\n\n",s);
+    break;
+  default :
+    printf("n\nNbsread_SigCatch: signal 1=%d catched et non traite\n\n",s);
+    break;
+}
+printf("UENDCCD is called\n");
+UENDCCD();
+printf("UEND is called\n");
+UEND();
+printf("exit is called\n");
+exit(-1);
+}
+
+
+/*************************************************************************/
+/*************************************************************************/
+/*******************  Commentaire nbsread et nbgene **********************/
+/*************************************************************************/
+/*************************************************************************/
+/* 
+++ 
+  Module	nbsread (C et C++)
+  Lib	libnbsread++.a et libnbsread.a
+  include	nbsread.h nbgene.h
+|
+	*- nbsread*
+	
+	C'est un programme qui permet de lire des fichiers de suivi
+	pour 2 couleurs associees. Il fournit des points d'entrees permettant
+	a l'utilisateur de piloter une analyse sans devoir s'occuper de
+	la machinerie relative a la lecture de fichiers de suivis.
+|   nbsread  nbsread.dataccd.Exemple
+	Les noms des fichiers de suivi a lire doivent etre mis dans un fichier
+	dont un descriptif est donne dans le fichier
+	`AnaSuiv/nbsread.dataccd.Exemple'. La lecture de plusieurs fichiers
+	de suivi pour plusieurs CCD dans 2 couleurs est permise.
+	Ce fichier permet aussi de selectionner des etoiles par leur
+	numero ou un intervalle de numeros, le programme renvoie `FgSelSt'
+	non nulle si l'etoile a ete selectionnee par les datacards.
+|
+	*- Structure des donnees*
+	
+	Le programme lit les etoiles les unes apres les autres.
+	Pour chaque etoile il remplit diverses structure ou tableau
+	de structures permettant l'analyse de sa courbe de lumiere
+	(la description des structures se trouve dans `fsvst.h'):
+|  EXTERN GLOBINFO globu : decodage de GLOBINFO
+|  EXTERN STARINFO staru[NCOULMX] : decodage de STARINFO
+|  EXTERN int_4 nmes[NCOULMX] : nombre de mesures pour le CCD courant
+|                               et les couleurs 0 et 1
+|  EXTERN TIMEINFOU *timeu[NCOULMX] : tableau de structures TIMEINFOU
+|  EXTERN MESUREU *mesu[NCOULMX] : tableau de structures MESUREU
+|  EXTERN double *date[NCOULMX] : tableau des dates en jours
+|  EXTERN float *ampli[NCOULMX] : tableau des amplifications montecarlo
+|  EXTERN int_4 nmesure[NCOULMX] : nombre de mesure valides
+|                                  pour le CCD courant
+|  EXTERN int_4 *indexu[NCOULMX] : tableau des images valides
+|                                  rangees chronologiquement
+|  EXTERN STARCALU starcal : strucure de magnitude absolue
+|  EXTERN STARCUTU starcut : structure de coupure sur les magnitudes
+|                            et les couleurs (permet de ne pas lire
+|                            certaines etoiles pour gagner du temps)
+
+	Les tableaux de structures ont `nmes[0] / nmes[1]' elements correspondant
+	au nombre total d'images pour les couleurs 0 et 1 dans les fichiers
+	de suivi d'un CCD.
+|
+	*- Les points d'entree utilisateurs et structure de nbsread*
+	
+	Ce sont les routine commencant par la lettre `U...()'
+	ayant un nom en majuscule.
+
+|  Initialisation du job {
+|
+|    void UINIT(void);  <*********** USER
+|    Initialisation montecarlo
+|
+|    Boucle sur les CCD a lire {
+|
+|      ---> Lecture de GLOBINFO et de TIMEINFOU pour un CCD
+|      void UDATCLEAN(int coul);  <*********** USER
+|      Classement des images valides par dates croissantes
+|      void UINITCCD(void);  <*********** USER 
+|      Initialisation montecarlo pour le CCD courant
+|
+|      Boucle sur les etoiles a lire {
+|
+|        ---> lecture de MESUREU
+|        Calcul des magnitudes absolues
+|        Coupure sur les magnitudes absolues et la couleur des etoiles
+|        Generation montecarlo pour chaque etoile
+|          (eventuellement plusieurs generation sur la meme etoile)
+|        void UEVT(void);   <*********** USER
+|
+|      } Fin de la boucle sur les etoiles
+|
+|      void UENDCCD(void);  <*********** USER
+|
+|    } Fin de la boucle sur les CCD
+|
+|    void UEND(void);  <*********** USER
+|    Fin du montecarlo, impression des statistiques des generations
+|
+|  } Fin du job
+|
+	*- void UINIT(void)*
+	
+	Tout ce qui ne doit etre fait qu'une fois par job
+	definitions de parametres generaux, ouverture hbook etc...
+|
+	*- UDATCLEAN(int icoul)*
+	
+	Permet de tuer des images
+	Si date[icoul][imes] est mise a `GRAND2' l'image correspondante
+	ne sera pas prise en compte dans la sequence en temps.
+	Si date[icoul][imes] est mise a `GRAND2_KILL', l'image correspondante
+	ne sera ni decodee ni prise en compte (structure `MESUREU' mis a zero).
+	Ceci permet d'eliminer des images ou il y a eu des erreurs de codage
+	qui conduisent a un core dump.
+|
+	*- Classement et elimination des images*
+	
+	Les images sont ensuite rangees chronologiquement en ne tenant pas
+	compte des images tuees. Pour les images ayant la meme date, seules
+	celles de plus grand indice sont prises en compte.
+	Le tableau `indexu[icoul][]' est fournit: il contient les indices des images
+	valides rangees chronologiquement et sans doublons. L'indice de indexu
+	varie de `0 a nmesure[icoul]' valeur qui represente le nombre d'images
+	utilisables pour l'analyse.
+	Par exemple, l'indice de la 5ieme image valide de la couleur bleue (reference
+	secondaire) est:
+|   j = indexu[1][5];
+	et l'acces au flux brut est donne par:
+|   fb = mesu[1][j].FluxB;
+	Toutes les images sont encore accessibles directement, par exemple
+	le flux brut de la 7ieme image (la 7ieme des fichiers de suivi
+	sans aucun choix ni classement chronologique) est, pour la reference
+	primaire (couleur rouge):
+|   fb = mesu[0][7].FluxB;
+|
+	*- UINITCCD(void)*
+	
+	C'est un point d'entree a la fin de l'initialisation
+	du CCD courant. A ce niveau toutes les informations de `TIMEINFOU',
+	les notions d'images valides et le classement chronologique sont
+	connus. Les variables `TFIRST' et `TLAST' representent respectivement
+	la valeur de `date[][]' la plus petit et la plus grande pour les images
+	valides. A ce niveau peuvent etre faites des initialisation montecarlo
+	propres a un CCD.
+|
+	*- Calcul des magnitudes absolues*
+		
+	Par defaut, il n'y a pas
+	de calcul de magnitudes absolues. L'utilisateur peut fournir une
+	routine de prototype:
+|   void mycalib(float,float,STARCALU *);
+	puis la connecter (dans `UINIT' ou `UINITCCD') au prototype:
+|   void (*Calibration_Absolue)(float,float,STARCALU *, void*);
+	en ecrivant: `Calibration_Absolue = mycalib;'.
+	Cette routine sera appelee automatiquement pour chaque etoile
+	avec les arguments:
+|   Calibration_Absolue(staru[0].FluxRef,staru[1].FluxRef,&starcal,uparms);
+	et remplira la structure `starcal'. Dand sa propre routine,
+	l'utilisateur peut remplir des magnitudes `B,V,R,I' ainsi
+	que le type de l'etoile (`SP=1 ou GR=2 ou indefini=0') et
+	son rayon en unites de rayon solaire. Le remplissage de
+	toutes ces valeurs n'est pas obligatoire, il depend de ce qui
+	doit etre fait apres, soit par l'utilisateur dans son analyse,
+	soit par la simulation montecarlo (l'effet de taille finie par
+	exemple a besoin du rayon de l'etoile).
+	Pour passer des parametres supplementaires a la fonction,
+	il faut initialiser le pointeur par l'assignation:
+|   Calibration_Absolue_UParms = &user_data_block
+	et l'adresse sera passee comme 4eme argument de Calibration_Absolue.
+	`user_data_block' doit etre declaree comme variable `globale'
+	dans le fichier ou comme variable `static' dans la routine
+	ou est faite l'assignation.
+|
+	*- Coupure sur les magnitudes absolues et la couleur des etoiles*
+	
+	Pour des raisons de rapidite, l'utilisateur peut couper sur la
+	magnitude absolue ou la couleur de l'etoile en remplissant la
+	structure `starcut'. Le temps de lecture de l'etoile est
+	economise, et le point d'entree `UEVT()' n'est pas appele.
+|
+	*- Generation montecarlo pour chaque etoile*
+	
+        L'effet de microlentille est simule sur chaque etoile
+	(ou plusieurs fois par etoile). Une description detaillee des
+	possibilites de simulation est donnee plus loin.
+|
+	*- UEVT(void)*
+	
+	C'est l'endroit ou l'utilisateur met le code
+	d'analyse et de traitement des courbes de lumieres. A ce niveau
+	les etoiles selectionnees dans le fichier datacard par une carte
+	`@SELET' sont identifier par le flag `FgSelSt>0'. Les variables
+	de niveau d'impression, debug, etc... sont accessibles:
+|  iet[NCOULMX] : numero de l'etoile (ref ou ref sec)
+|  FgSelSt : flag de selection
+|  idebug[4] : niveau de debug [iet1,iet2,ccd,niveau de debug]
+|  ffprt : niveau d'impression
+|  etc...
+|
+	*- void UENDCCD(void)*
+		
+	Point d'entree a la fin du traitement
+	d'un CCD. Il permet de fermer ou d'imprimer toute structure
+	relative a un CCD.
+|	
+	*- void UEND(void)*
+		
+	Point d'entree a la fin du job. C'est l'endroit
+	pour desallouer les tableaux et pour imprimer les conclusions du job
+|
+	*- Arguments de l'executable*
+	
+|     [-h] :  help tres tres detaille
+|     [-et et1,et2,etinc] :  numeros des etoiles a traiter
+|     [-prt niv] :  niveau de print
+|     [-dbg et1,et2,ccd,niv] : debug de certaine etoiles/ccd
+|     [-kill mes1 mes2 mes3 ...] : pour tuer les images mes1...
+	-kill permet de tuer les images mes1,mes2,mes3,... de `chaque'
+	fichier de suivi pour un CCD et une couleur. C'est particulierement
+	utile si, par exemple, la premiere image de chaque fichier de suivi
+	est l'images de reference: on s'en debarasse en indiquant:
+|  -kill 1
+|
+	Pour les arguments de nbsread, conformenent aux conventions prises
+	pour les routines de lecture de fichiers de suivi,
+	les numeros d'etoiles et d'images vont de `1 a nmes[]'
+	(et non pas de `0 a nmes[]-1').
+|
+	*- Comment creer ses propres routines utilisateur*
+	
+	Il faut ecrire un fichier dans lequel sont definies
+	les point d'entree utilisateurs:
+        `UINIT(), UDATCLEAN(int), UINITCCD(), UEVT(), UENDCCD() et UEND()'.
+	Le nom du fichier doit obligatoirement s'appeler
+|  nbsreadu_myroutine.cc  (meme si on compile en C)
+|  nbsreaduF_myroutine.f  pour la partie Fortran (si il y a des hbook)
+	myroutine est un nom choisi librement par l'utilisateur.
+	La compilation et le link s'effectue en executant:
+|  make -f Makeus++ nbsread_myroutine   (si on travaille en C++)
+|  make -f Makeus   nbsread_myroutine   (si on travaille en C  )
+	Un exemple detaille a ete sauve dans la base CVS:
+|  nbsreadu_squel.cc , nbsreaduF_squel.f
+	Pour l'executer et regarder ses impressions,
+	copiez `nbsreadu_squel.cc' et `nbsreaduF_squel.f' dans un de
+	vos repertoires, et recuperez dans la base CVS `AnaSuiv/Makeus++'
+	(ou `AnaSuiv/Makeus' si vous voulez compiler et linker en C).
+	Compilez et linkez:
+|  make -f Makeus++ nbsread_squel
+|  (ou make -f Makeus nbsread_squel)
+	Creez un fichier `fichier.dataccd' contenant des fichiers de suivi.
+	Executez `nbsreadu_squel' en tapant la ligne de commande suivante:
+|  nbsreadu_squel fichier.dataccd -prt 1 \
+|          -mc 2 -u0 0.01,0.5 -t0 1,-1,-1 -tau 2,10,-1 -tf 2,0,2 -bl 1
+	(cette procedure est egalement decrite aussi dans `nbsreadu_squel.cc')
+|
+	*- Initialisation du montecarlo et generation*
+	
+	L'initialisatuon peut etre effectuee, soit par arguments de
+	l'executable:
+|     [-mc ngenstar]
+|     [-u0 U0MinI,U0MaxI,U0SimI]
+|     [-t0 T0MinI,T0MaxI,T0SimI]
+|     [-tau TauMinI,TauMaxI,TauSimI]
+|     [-tf type(1ou2),UMinI,UMaxI,USimI,Usu0_Cut]
+|     [-bl Blending (1ou2)]
+|     [-seed seed1,seed2,seed3]
+	soit en remplissant directement la structure `MONTECARLO mc' dans
+        UINIT() et eventuellement UINITCCD() pour l'initialisation du `t0'.
+	`nbsread -h' donne un help online tres detaille sur la facon de piloter
+	la generation. La description des variables de la structure `mc'
+	se trouve dans le fichier `nbgene.h'.
+	La description des possibilites du montecarlo est donnee
+	ci-apres en fonction des variables de la structure `mc':
+
+| ----- CHOIX DU TYPE DE SIMULATION -----
+| mc.Taille_Finie = 0 : generation taille ponctuelle
+|                   1 :            taille finie tirage plat en U = Rs(proj)/Re
+|                   2 :            taille finie tirage plat en UC (U = UC*Rs)
+| mc.Blending = 1 : simulation du "blending" sur l'etoile principale (la + brillante)
+|               2 : simulation du "blending" sur l'etoile cachee (la - brillante)
+| 
+| ----- GENERATION PLATE -----
+| si max<=min
+|   - TauSim=TauSimI Tau du phenomene
+|   - T0Sim=T0SimI   instant du maximum si T0SimI>0
+|   - U0Sim=U0SimI   parametre d'impact (en Re) si U0SimI>0
+|   - USim=USimI     projection rayon etoile dans plan naine (en Re) si USimI>0
+| si max>min
+|   - TauSim est engendre avec une loi plate entre TauMinI ET TauMaxI
+|   - T0Sim  est engendre avec une loi plate entre T0MinI  ET T0MaxI
+|            si T0MaxI<T0MinI et T0SimI<0 on prend plat sur toute la periode
+|   - U0Sim  est engendre avec une loi plate entre U0MinI  ET U0MaxI
+|   - USim   est engendre avec une loi plate entre UMinI ET UMaxI si mc.Taille_Finie=1
+|                                      entre UMinI*Rs ET UMaxI*Rs si mc.Taille_Finie=2
+| 
+| ----- GENERATION SELON UNE LOI DETERMINEE PAR L'UTILISATEUR -----
+| l'utilisateur peut fournir la loi de tirage aleatoire pour u0,tau et u:
+|   - mc.TireU0(float), mc.TireT0(float), mc.TireTau(float) et 
+|        mc.TireU(float) sont 3 pointeurs sur des fonctions 
+|        "float (*TireU0)(float alea)"
+|        Il sont initialises a 0 dans nbsread.c
+|   - mise en oeuvre (ex: pour le tirage de tau plat en log):
+|     1-/ dans nbsreadu.c, l'utilisateur ecrit les routines de tirage
+|         ( alea est uniformement distribue entre [0.,1.[ )
+|       float my_tiretau(float alea)
+|         {
+|         float tau;
+|         tau = log(mc.TauMinI)
+|             + alea * ( log(mc.TauMaxI) - log(mc.TauMinI) );
+|         return( (float) exp( (double) tau ) );
+|         }
+|      2-/ dans UINIT (par exemple)
+|         mc.TireTau = my_tiretau;
+
+	Evidemment dans l'hypothese d'un tirage avec effet de taille finie
+	le rayon de l'etoile (starcal.Rstar) doit etre rempli
+	dans la calibration absolue donnee par l'utilisateur.
+
+	Pour une generation avec effet de blending, l'utilisateur doit
+	une routine de simulation de l'effet de blending et la connecter
+	au prototype mc.Get_Par_Blending dans UINIT() ou UINITCCD().
+|  mc.Get_Par_Blending = my_blending_gene
+
+	Pour une simulation avec effet de blending sur l'etoile la plus
+	brillante du couple, il faut remplir
+|  mc.coeff_Arec1[ic] pour les 2 couleurs (ic=0,1)
+	Arec est le coefficient de blending:
+|  Ampli(blend) = (Ampli-1.)*Arec +1
+
+	Pour une simulation avec effet de blending sur l'etoile la moins
+	brillante du couple, il faut remplir
+|  mc.coeff_Arec2[ic] pour les 2 couleurs (ic=0,1)
+
+	Pour une simulation avec effet de blending sur l'etoile la plus
+	brillante du couple et avec effet de taille finie, il faut remplir
+|  mc.coeff_Arec1[ic] pour les 2 couleurs (ic=0,1)
+|  mc.starcal1.Rstar :   rayon de l'etoile la plus brillante
+
+	Pour une simulation avec effet de blending sur l'etoile la moins
+	brillante du couple et avec effet de taille finie, il faut remplir
+|  mc.coeff_Arec2[ic] pour les 2 couleurs (ic=0,1)
+|  mc.starcal2.Rstar :   rayon de l'etoile la moins brillante
+|
+	*- Initialisation des aleatoires*
+	
+	Le generateur utilise est "drand48" standard unix.
+	Il est prevu 3 variables permettant d'initialiser le generateur:
+|  mc.iseed1, mc.iseed2, mc.iseed3
+	A la fin du job l'etat des graines est automatiquement imprime
+	et permet de redemarrer un autre job pour la suite de la
+	sequence d'aleatoires.
+|
+	*- Exemple de fichier datacard*
+	
+	 Cf AnaSuiv/nbsread.dataccd.Exemple
+|4                  nombre de CCD a traiter
+|@CCD 03            numero du 1er CCD a traiter
+|@COUL 1            numero de la couleur de reference
+|/home/suivi/file1_coul1_ccd03.suivi
+|/home/suivi/file2_coul1_ccd03.suivi
+|@COUL 2            numero de la couleur secondaire (facultatif)
+|/home/suivi/file1_coul2_ccd03.suivi
+|/home/suivi/file2_coul2_ccd03.suivi
+|/home/suivi/file3_coul2_ccd03.suivi
+|@FINCCD            carte de fin de CCD
+|@CCD 01            numero du 2sd CCD a traiter
+|@COUL 1            numero de la couleur de reference
+|/home/suivi/file1_coul1_ccd01.suivi
+|/home/suivi/file2_coul1_ccd01.suivi
+|@COUL 2            numero de la couleur secondaire (facultatif)
+|/home/suivi/file1_coul2_ccd01.suivi
+|@FINCCD            carte de fin de CCD
+|@CCD 05            numero du 3ieme CCD a traiter
+|@COUL 1            numero de la couleur de reference
+|/home/suivi/file1_coul1_ccd05.suivi
+|/home/suivi/file2_coul1_ccd05.suivi
+|/home/suivi/file3_coul1_ccd05.suivi
+|/home/suivi/file4_coul1_ccd05.suivi
+|@COUL 2            numero de la couleur secondaire (facultatif)
+|/home/suivi/file1_coul2_ccd05.suivi
+|/home/suivi/file2_coul2_ccd05.suivi
+|/home/suivi/file3_coul2_ccd05.suivi
+|@FINCCD            carte de fin de CCD
+|@CCD 07            numero du 4ieme CCD a traiter
+|@COUL 1            numero de la couleur de reference
+|/home/suivi/file1_coul1_ccd07.suivi
+|/home/suivi/file2_coul1_ccd07.suivi
+|/home/suivi/file3_coul1_ccd07.suivi
+|@FINCCD            carte de fin de CCD
+|@END               carte de fin de fichier datacard
+|
+|.... liste d etoiles a selectionner: FgSelSt != 0 dans nbsread.h
+|@SELET 1001
+|@SELET 1234
+|@SELET 2032 2050
+|@SELET 5044
+|@SELET 10001 10100
+|@SELET 6022
+
+	A l'exception de la 1ere carte et des noms de fichiers de suivi
+	toute carte valide commence par un caractere @.
+	Il est fournit un moyen de selectionner des etoiles dans le
+	fichier datacard et de les identifier dans `UEVT()'.
+	grace au flag `FgSelSt'.
+|  @SELET 1001        selection de l'etoile 1001 (attention et=[1,...])
+|  @SELET 1001 2001   selection des etoiles de 1001 a 2001 inclusif
+|
+	*- Commentaire sur les structures des fichers de suivi et de nbsread*
+	
+	Dans le fichier de suivi sont codees les structures:
+|     GLOBINFO STARINFO MESURE TIMEINFO
+	La description des diverses structures et variables qu'elles
+	contiennent se trouve dans `fsvst.h'.
+	Pour gagner de la place, certaines d'entre elles (`TIMEINFO,MESURE')
+	ont des variables codees de facon non triviale dans les mots
+	de 16 bits. A la relecture du fichier de suivi, `nbsread'
+	decode automatiquement les variables pour les ranger en clair
+	dans des structures utilisateurs (dont le nom se termine par un `U').
+	Notamment la structure `MESUREU' decode la structure `MESURE' et
+	renvoit le flux et les erreurs calibrees et tenant compte des
+	informations codees dans la structure `TIMEINFO'.
+|     TIMEINFO  -> TIMEINFOU (qui ne contient qu'une partie des infos)
+|     MESURE    -> MESUREU
+	Les routines de decodage sont dans fsvst.h mais ne doivent
+	en pratique pas etre utilisees directement par
+	l'utilisateur de `nbsread':
+|     TIMEINFOU * DecodeTim( TIMEINFO *time, TIMEINFOU *timeu);
+|     MESUREU * DecodeMes( MESURE *mesc, MESUREU *mesu);
+|
+	*- Routines pratiques utilisables dans nbsread*
+	
+|  int read_timeinfo(int ic,int imes,TIMEINFO *tim)
+	Comme `TIMEINFOU' ne contient qu'une partie des informations
+	de la structure `TIMEINFO' du fichier de suivi, il peut etre pratique
+	de pouvoir recuprer `TIMEINFO'. `read_timeinfo' permet de
+	recuperer `TIMEINFO' pour la couleur `ic (0,1)' et la mesure
+	`imes (0,nmes[ic]-1)'.
+|    void PrtGlobInfo (GLOBINFO *glinf, int lp);
+|    void PrtStarInfo (STARINFO *sti, int n, int lp);
+|    void PrtMesure (MESURE *mes, int n, int lp);
+|    void PrtMesureU (MESUREU *mesu, int n, int lp);
+|    void PrtTimeInfo (TIMEINFO *tim, int n, int lp);
+|    void PrtTimeInfoU (TIMEINFOU *tim, int n, int lp);
+	Ces routines permettent d'imprimer les diverses structures
+	d'un fichiers de suivi. Elles sont dans `fsvst.h'
+|
+	*- Routines de travail avec les transformations*
+	
+	Elles permettent, par exemple, de calculer les coordonnees
+	sur l'image courante a partir des coordonnees de references de STARINFO.
+	Les rputines se trouvent dans `fsvst.h' et `transfost.h'.
+|    void GlobInfoToTransf(GLOBINFO *gli, TRANSFO *t1, TRANSFO *t2);
+|    void TimeInfoToTransf(&timloc,&t1,&t2);
+|    void CordTransf(double xS, double yS, double *xD, double *yD, 
+|                    TRANSFO *transf)
+	Voici un exemple d'utilisation a mettre dans `UEVT()' pour l'etoile
+	courante.
+|   TIMEINFO timloc;
+|   TRANSFO t1,t2;
+|   double Xcur[2],Ycur[2],x,y;
+|   for(ic=0;ic<NCOULMX;ic++) {
+|     for(k=0;k<nmes[ic];k++) {
+|       read_timeinfo(ic,k,&timloc);
+|       TimeInfoToTransf(&timloc,&t1,&t2);
+|       -- des coordonnees de reference vers les courantes
+|       x = staru[ic].XPos; y = staru[ic].YPos;
+|       CordTransf(x,y,&Xcur[ic],&Ycur[ic],&t1);
+|       PrintTransfo(&t1);
+|       PrintTransfo(&t2);
+|       -- des coordonnees courantes vers celles de reference
+|       CordTransf(Xcur[ic],Ycur[ic],&x,&y,&t2);
+|     }
+|   }
+
+--
+*/
Index: trunk/FrEROS/AnaLC/nbsread.dataccd.Exemple
===================================================================
--- trunk/FrEROS/AnaLC/nbsread.dataccd.Exemple	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsread.dataccd.Exemple	(revision 3308)
@@ -0,0 +1,43 @@
+4                  nombre de CCD a traiter (obligatoire 1ere carte)
+@CCD 03            numero du 1er CCD a traiter
+@COUL 1            numero de la couleur de reference
+/home/suivi/file1_coul1_ccd03.suivi
+$SUIVI/file2_coul1_ccd03.suivi
+@COUL 2            numero de la couleur secondaire (facultatif)
+/home/suivi/file1_coul2_ccd03.suivi
+$SUIVI/file2_coul2_ccd03.suivi
+/home/suivi/file3_coul2_ccd03.suivi
+@FINCCD            carte de fin de CCD
+@CCD 01            numero du 2sd CCD a traiter
+@COUL 1            numero de la couleur de reference
+/home/suivi/file1_coul1_ccd01.suivi
+$SUIVI/file2_coul1_ccd01.suivi
+@COUL 2            numero de la couleur secondaire (facultatif)
+/home/suivi/file1_coul2_ccd01.suivi
+@FINCCD            carte de fin de CCD
+@CCD 05            numero du 3ieme CCD a traiter
+@COUL 1            numero de la couleur de reference
+/home/suivi/file1_coul1_ccd05.suivi
+$SUIVI/file2_coul1_ccd05.suivi
+/home/suivi/file3_coul1_ccd05.suivi
+/home/suivi/file4_coul1_ccd05.suivi
+@COUL 2            numero de la couleur secondaire (facultatif)
+/home/suivi/file1_coul2_ccd05.suivi
+$SUIVI/file2_coul2_ccd05.suivi
+/home/suivi/file3_coul2_ccd05.suivi
+@FINCCD            carte de fin de CCD
+@CCD 07            numero du 4ieme CCD a traiter
+@COUL 1            numero de la couleur de reference
+/home/suivi/file1_coul1_ccd07.suivi
+$SUIVI/file2_coul1_ccd07.suivi
+/home/suivi/file3_coul1_ccd07.suivi
+@FINCCD            carte de fin de CCD
+@END               carte de fin de fichier datacard
+
+.... liste d etoiles a selectionner: FgSelSt != 0 dans nbsread.h
+@SELET 1001
+@SELET 1234
+@SELET 2032 2050
+@SELET 5044
+@SELET 10001 10100
+@SELET 6022
Index: trunk/FrEROS/AnaLC/nbsread.h
===================================================================
--- trunk/FrEROS/AnaLC/nbsread.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsread.h	(revision 3308)
@@ -0,0 +1,104 @@
+#ifndef  NBSREAD_H_SEEN  
+#define  NBSREAD_H_SEEN
+  
+#ifdef __cplusplus
+
+#ifdef  FLAG_MAIN_NBSREAD
+#undef   EXTERN
+#define  EXTERN 
+#else
+#undef   EXTERN
+#define  EXTERN  extern
+#endif
+
+#else
+
+#undef   EXTERN
+#define  EXTERN 
+
+#endif
+
+#define NCOULMX ((int_4) (2))
+#define NBFILMX ((int_4) (60))
+#define NBSREAD_LSTR 512
+#define NKILLMSMX 100
+
+#include <stdio.h>
+#include "fsvcache.h"
+
+/* valeurs de control */
+
+EXTERN double GRAND2_KILL;
+
+EXTERN FILE *dataccd;
+
+EXTERN int_4 typsuivi;
+EXTERN int_4 sztmi[NCOULMX], szmes[NCOULMX], szMXBYTE;
+
+EXTERN int killms[NKILLMSMX],nkillms;
+EXTERN int_4 nbccd,numccd,ccdnum;
+
+EXTERN int_4 nbfil[NCOULMX],nbms[NCOULMX][NBFILMX],nms1fil[NCOULMX][NBFILMX],nbmsMX;
+EXTERN SUIVIFIP *lunfil[NCOULMX][NBFILMX];
+EXTERN char lunnam[NCOULMX][NBFILMX][NBSREAD_LSTR];
+
+EXTERN int_4 nmes[NCOULMX],nmesure[NCOULMX];
+
+EXTERN int_4 ietlim[NCOULMX],iet[NCOULMX],net[NCOULMX],netoiles,ietgen;
+
+EXTERN int_4 OpenType;
+EXTERN int_4 debug,idebug[4],nstdeb,ffprt;
+
+EXTERN int NStId, NSelStId, FgSelSt, *StId1, *StId2;
+
+EXTERN double Tfirst[NCOULMX], Tlast[NCOULMX], TFIRST, TLAST;
+
+struct starcal_u {
+  float Mag_B,Mag_R,Mag_V,Mag_I; /* magnitudes absolues Bj,Vj,Rc,Ic */
+  float Rstar;                   /* rayon de l'etoile */
+  int   Rtype;                   /* type d'etoile 0=indeter 1=SP 2=GR*/
+};
+typedef struct starcal_u STARCALU;
+
+struct starcut_u {
+  int Mag_B_cut;  float Mag_B_min,Mag_B_max;
+  int Mag_V_cut;  float Mag_V_min,Mag_V_max;
+  int Mag_R_cut;  float Mag_R_min,Mag_R_max;
+  int Mag_I_cut;  float Mag_I_min,Mag_I_max;
+  int Mag_BV_cut; float Mag_BV_min,Mag_BV_max;
+  int Mag_BR_cut; float Mag_BR_min,Mag_BR_max;
+  int Mag_VR_cut; float Mag_VR_min,Mag_VR_max;
+  int Mag_RI_cut; float Mag_RI_min,Mag_RI_max;
+  int Rstar_cut;  float Rstar_min,Rstar_max;
+  int Rtype_cut;  int Rtype_min,Rtype_max;
+};
+typedef struct starcut_u STARCUTU;
+
+EXTERN STARCALU            starcal;
+EXTERN STARCUTU            starcut;
+EXTERN GLOBINFO            globu;
+EXTERN STARINFO            staru[NCOULMX];
+EXTERN TIMEINFOU           *timeu[NCOULMX];
+EXTERN MESUREU             *mesu[NCOULMX];
+EXTERN int_4               *indexu[NCOULMX];
+EXTERN unsigned short      *meslun[NCOULMX];
+EXTERN double              *date[NCOULMX];
+EXTERN float               *ampli[NCOULMX];
+EXTERN void (*Calibration_Absolue)(float,float,STARCALU *, void*);
+EXTERN void*  Calibration_Absolue_UParms;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void UINIT(void);
+void UDATCLEAN(int coul);
+void UINITCCD(void);
+void UEVT(void);
+void UENDCCD(void);
+void UEND(void);
+int read_timeinfo(int ic,int imes,TIMEINFO *tim);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
Index: trunk/FrEROS/AnaLC/nbsreadu_base.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbsreadu_base.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsreadu_base.cc	(revision 3308)
@@ -0,0 +1,216 @@
+/*
+- Test des divers calcul de ligne de base pour la couleur 0
+                           (la couleur 1 n'est pas traitee)
+*/
+#include "sopnamsp.h"
+#include "machdefs.h"
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fsvcache.h"
+#include "nbmath.h"
+#include "fmath.h"
+#include "filtccd.h"
+#include "fsvst.h"
+#include "nbsread.h"
+#include "nbgene.h"
+
+#include "ntuple.h"
+
+void FILL_USER(void);
+
+#define N 5
+
+float *TimeU,*FluxU,*FluxFlU,*eFluxU,*eFluxFlU,*FluxUnoA,*AmpliU;
+int_4 npt_;
+
+POutPersist *pos_ = NULL;
+NTuple *ntbase = NULL;
+
+/*==========================================================================*/
+void UINIT(void)
+{
+ pos_ = new POutPersist("nbsread_base.ppf");
+}
+
+/*===========================================================================*/
+#define NXNT 28
+void UINITCCD(void)
+{
+int_4 n;
+n = ( nmesure[0] > 0 ) ? nmesure[0] : 1 ;
+TimeU     = (float*) malloc((size_t) n*sizeof(float));
+FluxU     = (float*) malloc((size_t) n*sizeof(float));
+eFluxU    = (float*) malloc((size_t) n*sizeof(float));
+FluxFlU   = (float*) malloc((size_t) n*sizeof(float));
+eFluxFlU  = (float*) malloc((size_t) n*sizeof(float));
+FluxUnoA  = (float*) malloc((size_t) n*sizeof(float));
+AmpliU    = (float*) malloc((size_t) n*sizeof(float));
+
+// Create NTuple
+char *nament[NXNT] = {
+      "et","xref","flr","dm1","dm21","xp","yp","npt"
+     ,"mean","sig","sigi"
+     ,"meanB","sigB"
+     ,"meanS","sigS","rcS"
+     ,"meanSs","sigSs","rcSs"
+     ,"meanP","rcP"
+     ,"meanPs","rcPs"
+     ,"u0","t0","tau","a0","npta"
+};
+if(ntbase == NULL) delete ntbase;
+ntbase = new NTuple(NXNT,nament);
+
+}
+
+/*=========================================================================*/
+void UDATCLEAN(int coul)
+/* pour tuer une photo selon des criteres utilisateur, mettre date a GRAND2 */
+{
+int_4 ic = coul-1;
+if(nmes[ic]<=0) return;
+for(int i=0;i<nmes[ic];i++) {
+  if(date[ic][i]<0.)  date[ic][i] = GRAND2;
+  if(timeu[ic][i].FgCalib<=0) date[ic][i] = GRAND2;
+}
+}
+
+/*=========================================================================*/
+void UEVT(void)
+{
+int i,n,rc,nptas;
+float mean,sigmaI,sigma,most;
+float xnt[NXNT];
+
+/* association rouge-bleu existante et correcte */
+if(staru[0].NumEt <= 0 ) return;
+if(staru[0].FluxRef<= 0.) return;
+for(i=0;i<NXNT;i++) xnt[i] = -9999.;
+
+FILL_USER();
+
+if( iet[0]%50 == 0 )
+  printf("UEVT: et=[%7d,%7d] pt nmesure=[%5d] npt=[%5d]\n"
+        ,iet[0],iet[1],nmesure[0],npt_);
+
+/* on remplit le ntuple de selection */
+xnt[0]=  iet[0];
+xnt[1]=  staru[0].XRef;
+xnt[2] = staru[0].FluxRef;
+xnt[3] = staru[0].DisMin;
+xnt[4] = staru[0].DisM2;
+xnt[5] = staru[0].XPos;
+xnt[6] = staru[0].YPos;
+xnt[7] = npt_;
+
+/****************** Filtre Median *******************************/
+n = npt_;
+rc = FiltMed(FluxU,eFluxU,FluxFlU,eFluxFlU,n);
+if(rc<0) for(i=0;i<npt_;i++) {FluxFlU[i]=FluxU[i]; eFluxFlU[i]=eFluxU[i];}
+
+/****************** Moyenne non amplifiee *******************************/
+n = npt_;
+rc = MeanLine(FluxUnoA,eFluxU,&n,2,4.,&mean,&sigma);
+if(rc==0) {
+  xnt[8] = mean;
+  xnt[9] = sigma;
+}
+
+/*********************** Calcul du sigma interne ***************************/
+nptas = 0;
+n = npt_;
+sigmaI = SigmaInt(TimeU,FluxU,eFluxU,&n,4.);
+if(sigmaI>0) {
+  xnt[10] = sigmaI;
+}
+if(sigmaI>0 && mean>0) {
+  for(i=0;i<npt_;i++) if(eFluxU[i]>0 && (AmpliU[i]-1.)*mean<sigmaI) nptas++;
+}
+
+/****************** Calcul de la base sur donnees filtrees ************/
+n = npt_; rc=-1;
+if(sigmaI>0) rc = BaseLine(FluxFlU,eFluxFlU,&n,4.,sigmaI,&mean,&sigma,&most);
+if(rc>=0) {
+  xnt[11] = most;
+  xnt[12] = sigma;
+}
+
+rc = BaseLineS(FluxU,eFluxU,npt_,N,&mean,&sigma);
+if(rc>0) {
+  xnt[13] = mean;
+  xnt[14] = sigma;
+  xnt[15] = rc;
+}
+
+rc = BaseLineS(FluxU,eFluxU,npt_,-N,&mean,&sigma);
+if(rc>0) {
+  xnt[16] = mean;
+  xnt[17] = sigma;
+  xnt[18] = rc;
+}
+
+rc = BaseLineP(FluxU,eFluxU,npt_,N,&mean);
+if(rc>0) {
+  xnt[19] = mean;
+  xnt[20] = rc;
+}
+
+rc = BaseLineP(FluxU,eFluxU,npt_,-N,&mean);
+if(rc>0) {
+  xnt[21] = mean;
+  xnt[22] = rc;
+}
+
+xnt[23] = mc.U0Sim;
+xnt[24] = mc.T0Sim;
+xnt[25] = mc.TauSim;
+xnt[26] = mc.A0Max;
+xnt[27] = nptas;
+ 
+ntbase->Fill(xnt);
+
+}
+
+/*=========================================================================*/
+void UENDCCD(void)
+{
+free(TimeU); free(FluxU); free(eFluxU); free(FluxUnoA);
+free(FluxFlU); free(eFluxFlU); free(AmpliU);
+
+if(ntbase->NEntry()>0) pos_->PutObject(*ntbase,"ntbase");
+if(ntbase!=NULL) delete ntbase; ntbase = NULL;
+}
+
+/*=========================================================================*/
+void UEND(void)
+{
+ if(pos_!=NULL) delete pos_; pos_ = NULL;
+}
+
+/*=========================================================================*/
+void FILL_USER(void)
+{
+int i,j;
+double Flux,FluxB,Xi2,ErrFlux;
+
+npt_=0;
+for(i=0;i<nmesure[0];i++) {
+  j = indexu[0][i];
+  FluxB   = mesu[0][j].FluxB;
+  Flux    = mesu[0][j].Flux;
+  ErrFlux = mesu[0][j].ErrFlux;
+  Xi2     = mesu[0][j].Xi2;
+  if( ErrFlux<0. ) ErrFlux *= -1.;
+  if( Xi2<=0. || ErrFlux==0. ) continue;
+  TimeU[npt_] = date[0][j];
+  FluxUnoA[npt_] = Flux;
+  if(mc.montecar > 0) Flux *= ampli[0][j];
+  AmpliU[npt_] = ampli[0][j];
+  FluxU[npt_] = Flux;
+  eFluxU[npt_] = ErrFlux;
+  npt_++;
+}
+
+}
Index: trunk/FrEROS/AnaLC/nbsreadu_bosse.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbsreadu_bosse.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsreadu_bosse.cc	(revision 3308)
@@ -0,0 +1,351 @@
+/* definitions */
+#define NbossMAX 400
+/* type de recherche de bosse */
+#define BOSSEN
+/* define FILTMED */
+
+#include "sopnamsp.h"
+#include "machdefs.h"
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "nomfits.h"
+#include "fsvcache.h"
+#include "nbtri.h"
+#include "nbrandom.h"
+#include "nbmath.h"
+#include "fmath.h"
+#include "filtccd.h"
+#include "hbook.h"
+#include "fsvst.h"
+#include "transfost.h"
+#include "nbsread.h"
+#include "nbgene.h"
+
+#include "ntuple.h"
+
+void FILL_USER(void);
+
+float *TimeU[NCOULMX],*FluxU[NCOULMX],*eFluxU[NCOULMX]
+     ,*FluxflU[NCOULMX],*eFluxflU[NCOULMX];
+int_4 npt[NCOULMX];
+int nslues,nsgood;
+
+POutPersist *pos_ = NULL;
+NTuple *ntbosse = NULL;
+
+/*==========================================================================*/
+void UINIT(void)
+{
+ pos_ = new POutPersist("nbsread_bosse.ppf");
+}
+
+/*===========================================================================*/
+#define NXNT 48
+void UINITCCD(void)
+{
+int_4 ic,n;
+nslues = nsgood = 0;
+for(ic=0;ic<NCOULMX;ic++) {
+  n = ( nmesure[ic] > 0 ) ? nmesure[ic] : 1 ;
+  TimeU[ic] = (float*) malloc((size_t) n*sizeof(float));
+  FluxU[ic] = (float*) malloc((size_t) n*sizeof(float));
+  eFluxU[ic] = (float*) malloc((size_t) n*sizeof(float));
+  FluxflU[ic] = (float*) malloc((size_t) n*sizeof(float));
+  eFluxflU[ic] = (float*) malloc((size_t) n*sizeof(float));
+}
+
+// Create NTuple
+char *nament[NXNT] = {
+      "etr","etb","fr","fb",
+      "dmin1","dmin2","dm21","dm22",
+      "x1","y1","nptr","nptb",
+      "mostr","mostb","sintr","sintb",
+      "u0","t0","tau","a0",
+      "nbosr","nbosb",
+      "t1Pr","t2Pr","pkPr","nPr","i1Pr","i2Pr",
+      "t1Pb","t2Pb","pkPb","nPb","i1Pb","i2Pb",
+      "t1Sr","t2Sr","pkSr","nSr","i1Sr","i2Sr",
+      "t1Sb","t2Sb","pkSb","nSb","i1Sb","i2Sb",
+      "rec1","rec2"
+};
+if(ntbosse == NULL) delete ntbosse;
+ntbosse = new NTuple(NXNT,nament);
+
+}
+
+/*=========================================================================*/
+void UDATCLEAN(int coul)
+/* pour tuer une photo selon des criteres utilisateur, mettre date a GRAND2 */
+{
+int_4 ic = coul-1;
+if(nmes[ic]<=0) return;
+for(int i=0;i<nmes[ic];i++) {
+  if(date[ic][i]<0.)  date[ic][i] = GRAND2;
+  if(timeu[ic][i].FgCalib<=0) date[ic][i] = GRAND2;
+}
+}
+
+/*=========================================================================*/
+void UEVT(void)
+{
+int_4 i,n,ic
+     ,nbosse[NCOULMX],npoint[NCOULMX][NbossMAX],rc[NCOULMX]
+     ,ideb[NCOULMX][NbossMAX],ifin[NCOULMX][NbossMAX]
+     ,classB[NCOULMX][NbossMAX],I[NCOULMX],II[NCOULMX]
+     ,I1[NCOULMX],I2[NCOULMX],II1[NCOULMX],II2[NCOULMX];
+float xnt[NXNT],t1p[NCOULMX],t2p[NCOULMX],t1s[NCOULMX],t2s[NCOULMX]
+     ,min,max,dt0,dt1,recouv1,recouv2;
+float SigmaI[NCOULMX],Most[NCOULMX],/* Mean[NCOULMX], */Sigma[NCOULMX]
+     ,chi2[NCOULMX][NbossMAX],Probchi2[NCOULMX][NbossMAX];
+float *FlU[NCOULMX], *eFlU[NCOULMX];
+
+nslues++;
+
+/* association rouge-bleu existante et correcte */
+if(iet[1] <= 0 ) return;
+if(staru[0].XRef <= 0 ) return;
+if(staru[0].NumEt <= 0 ) return;
+if(staru[0].FluxRef<= 0.) return;
+if(staru[0].XRef>0) if(staru[1].FluxRef<= 0.) return;
+FILL_USER();
+/* nombre de mesures suffisant */
+if( npt[0]<3 || npt[1]<3 ) return;
+
+if( iet[0]%50 == 0 )
+  printf("UEVT: et=[%7d,%7d] pt nmesure=[%5d,%5d] npt=[%5d,%5d]\n"
+        ,iet[0],iet[1],nmesure[0],nmesure[1],npt[0],npt[1]);
+
+nsgood++;
+
+/****************** Filtre Median *******************************/
+for(ic=0;ic<NCOULMX;ic++) {
+  n = npt[ic];
+  rc[ic] = FiltMed(FluxU[ic],eFluxU[ic],FluxflU[ic],eFluxflU[ic],n);
+}
+if(rc[0]<0 && rc[1]<0) return;
+
+/**************** Choix du tableau pour les bosses ***************/
+#if defined(FILTMED)
+for(ic=0;ic<NCOULMX;ic++) {FlU[ic] = FluxU[ic]; eFlU[ic] = eFluxU[ic];}
+#else
+for(ic=0;ic<NCOULMX;ic++) {FlU[ic] = FluxflU[ic]; eFlU[ic] = eFluxflU[ic];}
+#endif
+
+/*********************** Calcul du sigma interne *****************/
+for(ic=0;ic<NCOULMX;ic++) {
+  n = npt[ic];
+  SigmaI[ic] = SigmaInt(TimeU[ic],FlU[ic],eFlU[ic],&n,4.);
+}
+if(SigmaI[0]<=0 && SigmaI[1]<=0) return;
+
+/****************** Calcul de la base ***************************/
+
+/*
+for(ic=0;ic<NCOULMX;ic++) {
+  n = npt[ic];
+  rc[ic] = BaseLine(FlU[ic],eFlU[ic],&n,4.,SigmaI[ic],&Mean[ic],&Sigma[ic],&Most[ic]);
+}
+if(rc[0]<0 || rc[1]<0) return;
+*/
+/*
+for(ic=0;ic<NCOULMX;ic++)
+  rc[ic] = BaseLineP(FlU[ic],eFlU[ic],npt[ic],-5,&Most[ic]);
+if(rc[0]<=0 || rc[1]<=0) return;
+*/
+for(ic=0;ic<NCOULMX;ic++)
+  rc[ic] = BaseLineS(FlU[ic],eFlU[ic],npt[ic],-5,&Most[ic],&Sigma[ic]);
+if(rc[0]<=0 || rc[1]<=0) return;
+ 
+/****************** Recherche des bosses *****************************/
+
+for(ic=0;ic<NCOULMX;ic++) {
+  n = npt[ic];
+#if defined(BOSSEN)
+  nbosse[ic] = BosseN(FlU[ic],eFlU[ic],n,Most[ic],1.5,4,1.,4,
+               &chi2[ic][0],&npoint[ic][0],&Probchi2[ic][0],&ideb[ic][0],&ifin[ic][0],
+               &classB[ic][0],NbossMAX);  
+#else
+  nbosse[ic] = Bosse(FlU[ic],eFlU[ic],n,Most[ic],5,1.,3.,
+               &chi2[ic][0],&npoint[ic][0],&Probchi2[ic][0],&ideb[ic][0],&ifin[ic][0],
+               &classB[ic][0],NbossMAX);
+#endif
+  if(nbosse[ic]>0) {
+    I[ic]= classB[ic][0];
+    I1[ic]= ideb[ic][I[ic]];
+    I2[ic]= ifin[ic][I[ic]];
+    t1p[ic] = TimeU[ic][I1[ic]];
+    t2p[ic] = TimeU[ic][I2[ic]];
+    if(nbosse[ic]>1) {
+      II[ic]= classB[ic][1];
+      II1[ic]= ideb[ic][II[ic]];
+      II2[ic]= ifin[ic][II[ic]];
+      t1s[ic] = TimeU[ic][II1[ic]];
+      t2s[ic] = TimeU[ic][II2[ic]];
+    }
+  }
+}
+
+/********************** calcul du recouvrement R/B ************************/
+
+recouv1 = -1.;
+if (nbosse[0]>0 && nbosse[1]>0) {
+  dt0 = t2p[0] - t1p[1];
+  dt1 = t2p[1] - t1p[0];
+  if ((t2p[0]-t1p[0]) < (t2p[1]-t1p[1])) {
+    min = (t2p[0]-t1p[0]);
+    max = (t2p[1]-t1p[1]);
+  } else {
+    min = (t2p[1]-t1p[1]);
+    max = (t2p[0]-t1p[0]);
+  }
+  if ( dt0*dt1 < 0.) recouv1 = 0.;
+  else if ((min<dt0) && (min<dt1)) recouv1 = min/max;
+  else recouv1 = (dt0>dt1) ? dt1/dt0 : dt0/dt1;
+}
+
+recouv2 = -1.;
+if (nbosse[0]>1 && nbosse[1]>1) {
+  dt0 = t2s[0] - t1s[1];
+  dt1 = t2s[1] - t1s[0];
+  if ((t2s[0]-t1s[0]) < (t2s[1]-t1s[1])) {
+    min = (t2s[0]-t1s[0]);
+    max = (t2s[1]-t1s[1]);
+  } else {
+    min = (t2s[1]-t1s[1]);
+    max = (t2s[0]-t1s[0]);
+  }
+  if ( dt0*dt1 < 0.) recouv2 = 0.;
+  else if ((min<dt0) && (min<dt1)) recouv2 = min/max;
+  else recouv2 = (dt0>dt1) ? dt1/dt0 : dt0/dt1;
+}
+
+/********************** on remplit le ntuple de selection **********************/
+
+for(i=0;i<NXNT;i++) xnt[i] = -1.;
+xnt[0]=  iet[0];                         /* etr */
+xnt[1]=  iet[1];                         /* etb */
+xnt[2] = staru[0].FluxRef;               /* fr */
+xnt[3] = staru[1].FluxRef;               /* fb */
+xnt[4] = staru[0].DisMin;                /* dmin1 */
+xnt[5] = staru[1].DisMin;                /* dmin2 */
+xnt[6] = staru[0].DisM2;                 /* dm21 */
+xnt[7] = staru[1].DisM2;                 /* dm22 */
+xnt[8] = staru[0].XPos;                  /* x1 */
+xnt[9] = staru[0].YPos;                  /* y1 */
+xnt[10] = npt[0];                        /* nptr */
+xnt[11] = npt[1];                        /* nptb */
+
+xnt[12] = Most[0];                       /* mostr */
+xnt[13] = Most[1];                       /* mostb */
+xnt[14] = SigmaI[0];                     /* sintr */
+xnt[15] = SigmaI[1];                     /* sintb */
+
+xnt[16] = mc.U0Sim;                      /* u0 */
+xnt[17] = mc.T0Sim;                      /* t0 */
+xnt[18] = mc.TauSim;                     /* tau */
+xnt[19] = mc.A0Max;                      /* a0 */
+
+xnt[20] = nbosse[0];                     /* nbosr */
+xnt[21] = nbosse[1];                     /* nbosb */
+
+/* bosse rouge 1ere */
+if(nbosse[0]>0) {
+  xnt[22] = t1p[0];                      /* t1Pr */
+  xnt[23] = t2p[0];                      /* t2Pr */
+  xnt[24] = Probchi2[0][I[0]];           /* pkPr */
+  xnt[25] = npoint[0][I[0]];             /* nPr */
+  xnt[26] = I1[0];                       /* i1Pr */
+  xnt[27] = I2[0];                       /* i2Pr */
+}
+
+/* bosse bleue 1ere */
+if(nbosse[1]>0) {
+  xnt[28] = t1p[1];                      /* t1Pb */
+  xnt[29] = t2p[1];                      /* t2Pb */
+  xnt[30] = Probchi2[1][I[1]];           /* pkPb */
+  xnt[31] = npoint[1][I[1]];             /* nPb */
+  xnt[32] = I1[1];                       /* i1Pb */
+  xnt[33] = I2[1];                       /* i2Pb */
+}
+
+/* bosse rouge 2sd */
+if(nbosse[0]>1) {
+  xnt[34] = t1s[0];                      /* t1Sr */
+  xnt[35] = t2s[0];                      /* t2Sr */
+  xnt[36] = Probchi2[0][II[0]];          /* pkSr */
+  xnt[37] = npoint[0][II[0]];            /* nSr */
+  xnt[38] = II1[0];                      /* i1Sr */
+  xnt[39] = II2[0];                      /* i2Sr */
+}
+
+/* bosse bleue 2sd */
+if(nbosse[1]>1) {
+  xnt[40] = t1s[1];                      /* t1Sb */
+  xnt[41] = t2s[1];                      /* t2Sb */
+  xnt[42] = Probchi2[1][II[1]];          /* pkSb */
+  xnt[43] = npoint[1][II[1]];            /* nSb */
+  xnt[44] = II1[1];                      /* i1Sb */
+  xnt[45] = II2[1];                      /* i2Sb */
+}
+
+/* recouvrement 1ere 2sd */
+xnt[46] = recouv1;                       /* rec1 */
+xnt[47] = recouv2;                       /* rec2 */
+
+ ntbosse->Fill(xnt);
+
+}
+
+/*=========================================================================*/
+void UENDCCD(void)
+{
+int ic;
+printf("Nombre d etoiles lues= %d, bonnes= %d, mauvaises=%d\n"
+      ,nslues,nsgood,nslues-nsgood);
+fflush(stdout);
+for(ic=0;ic<NCOULMX;ic++) {
+  free(TimeU[ic]);
+  free(FluxU[ic]);
+  free(eFluxU[ic]);
+  free(FluxflU[ic]);
+  free(eFluxflU[ic]);
+}
+
+if(ntbosse->NEntry()>0) pos_->PutObject(*ntbosse,"ntbosse");
+if(ntbosse!=NULL) delete ntbosse; ntbosse = NULL;
+}
+
+/*=========================================================================*/
+void UEND(void)
+{
+ if(pos_!=NULL) delete pos_; pos_ = NULL;
+}
+
+/*=========================================================================*/
+void FILL_USER(void)
+{
+int ic,i,j;
+double Flux,FluxB,Xi2,ErrFlux;
+  
+for(ic=0;ic<NCOULMX;ic++) {
+  npt[ic]=0;
+  for(i=0;i<nmesure[ic];i++) {
+    j = indexu[ic][i];
+    FluxB = mesu[ic][j].FluxB;
+    Flux = mesu[ic][j].Flux;
+    ErrFlux = mesu[ic][j].ErrFlux;
+    Xi2 = mesu[ic][j].Xi2;
+    if( ErrFlux<0 ) ErrFlux *= -1.;
+    if(Xi2<=0.)   continue;
+    TimeU[ic][npt[ic]] = date[ic][j];
+    if(mc.montecar > 0) Flux *= ampli[ic][j];
+    FluxU[ic][npt[ic]] = Flux;
+    eFluxU[ic][npt[ic]] = ErrFlux;
+    npt[ic]++;
+  }
+}
+
+}
Index: trunk/FrEROS/AnaLC/nbsreadu_db.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbsreadu_db.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsreadu_db.cc	(revision 3308)
@@ -0,0 +1,126 @@
+/*
+Ecriture des corubes de lumieres individuelles pour database ErosI
+*/
+#include "sopnamsp.h"
+#include "machdefs.h"
+#include <iostream>
+#include <string>
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fsvcache.h"
+#include "fsvst.h"
+#include "fmath.h"
+#include "nbmath.h"
+#include "nbrandom.h"
+#include "nbsread.h"
+#include "nbgene.h"
+
+/*================================================================*/
+void UINIT(void)
+{
+ printf("UINIT\n");
+}
+
+/*=================== ============================================*/
+void UDATCLEAN(int coul)
+/*
+  Attention ici coul = 1,2
+    donc pour tuer une image pour la couleur coul:
+    date[coul-1][...] = GRAND2;
+*/
+{
+ int ic = coul - 1;
+ cout<<"UDATCLEAN: couleur "<<coul<<", indice tableau "<<ic<<endl;
+ if(nmes[ic]<=0) return;
+
+ for(int i=0;i<nmes[ic];i++) {
+   if(date[ic][i]<0.)  date[ic][i] = GRAND2;
+   if(timeu[ic][i].FgCalib<=0) date[ic][i] = GRAND2;
+ }
+
+}
+
+/*================================================================*/
+void UINITCCD(void)
+{
+ printf("UINITCCD: Debut de l'etude du CCD %d %d\n",numccd,ccdnum);
+}
+
+/*================================================================*/
+void UEVT(void)
+{
+ printf("> Et=%d (%d) %d (%d)  fref=%g %g  nmes=%d %d  nmesure=%d %d\n"
+       ,iet[0],staru[0].XRef,iet[1],staru[1].XRef,staru[0].FluxRef,staru[1].FluxRef
+       ,nmes[0],nmes[1],nmesure[0],nmesure[1]);
+
+ if(nmesure[0]<=0) return;
+ if(iet[0]<=0) return;
+
+ // Generate file name
+ char fname[512];  sprintf(fname,"e%d.data",iet[0]);
+
+ // Open file
+ FILE *file = fopen(fname,"w");
+ if(file == NULL) {
+   cout<<"ERROR: file "<<fname<<" NOT OPENED"<<endl;
+   return;
+ }
+
+ // Fill header
+ for(int ic=0;ic<NCOULMX;ic++) {
+   string sname = "?";
+   if(nbfil[ic]>0) {
+     sname = lunnam[ic][0];
+     int ip = sname.find_last_of('/');
+     if(ip<0 || ip>=(int)sname.size()) ip = -1;
+     sname = sname.substr(++ip);
+   }
+   fprintf(file,"# %d %d %s\n",ic,nbfil[ic],sname.c_str());
+ }
+ 
+ fprintf(file,"# color(0/1) nmesure NumEt XRef FluxRef XPos YPos DisMin DisM2 NbVois\n");
+ for(int ic=0;ic<NCOULMX;ic++) {
+   fprintf(file,"@ %d %d %d %d %.3f %.3f %.3f %.3f %.3f %d\n",
+          ic,nmesure[ic],
+          staru[ic].NumEt,staru[ic].XRef,staru[ic].FluxRef,
+          staru[ic].XPos,staru[ic].YPos,
+          staru[ic].DisMin,staru[ic].DisM2,staru[ic].NbVois);
+ }
+
+
+ // Fill mesures
+ fprintf(file,"# color(0/1) TStart(s) Flux ErrFlux FluxB ErrFluxB Fond PixMax S9Pix global_(Fond SigX SigY Rho)\n");
+ for(int ic=0;ic<NCOULMX;ic++) {
+     if(iet[ic]<=0) continue;   // pas d'etoile associee
+     if(nmesure[ic]<=0) continue;
+     for(int j=0;j<nmesure[ic];j++) {
+       int i = indexu[ic][j];
+       fprintf(file,"%d %d %.3f %.3f %.3f %.3f %.3f %.0f %.0f %.3f %.3f %.3f %.5f\n",
+               ic,
+	       timeu[ic][i].TStart,
+               mesu[ic][i].Flux,mesu[ic][i].ErrFlux,
+               mesu[ic][i].FluxB,mesu[ic][i].ErrFluxB,
+               mesu[ic][i].Fond,mesu[ic][i].PixMax,mesu[ic][i].S9Pix,
+               timeu[ic][i].Fond,
+               timeu[ic][i].SigX,timeu[ic][i].SigY,timeu[ic][i].Rho);
+     }
+ }
+
+ // Close file
+ fclose(file);
+}
+
+/*================================================================*/
+void UENDCCD(void)
+{
+ printf("UENDCCD: Fin de l'etude du CCD %d %d\n",numccd,ccdnum);
+}
+
+/*================================================================*/
+void UEND(void)
+{
+ printf("UEND: Fin du job\n");
+}
Index: trunk/FrEROS/AnaLC/nbsreadu_ppf.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbsreadu_ppf.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsreadu_ppf.cc	(revision 3308)
@@ -0,0 +1,325 @@
+/*
+- Creation de NTuple et de courbes de lumieres:
+nbsreadu_squel fichier.dataccd -prt 1 \
+           -mc 2 -u0 0.01,0.5 -t0 1,-1,-1 -tau 2,10,-1 -tf 2,0,2 -bl 1
+*/
+#include "sopnamsp.h"
+#include "machdefs.h"
+#include <iostream>
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fsvcache.h"
+#include "fsvst.h"
+#include "fmath.h"
+#include "nbmath.h"
+#include "nbrandom.h"
+#include "nbsread.h"
+#include "nbgene.h"
+
+#include "ntuple.h"
+#include "tvector.h"
+
+POutPersist *pos_ = NULL;
+NTuple *ntsti_[2] = {NULL,NULL};
+
+/*================================================================*/
+void UINIT(void)
+{
+ printf("UINIT\n");
+ pos_ = new POutPersist("nbsread_ppf.ppf");
+}
+
+/*=================== ============================================*/
+void UDATCLEAN(int coul)
+/*
+  Attention ici coul = 1,2
+    donc pour tuer une image pour la couleur coul:
+    date[coul-1][...] = GRAND2;
+*/
+{
+ int ic = coul - 1;
+ cout<<"UDATCLEAN: couleur "<<coul<<", indice tableau "<<ic<<endl;
+ if(nmes[ic]<=0) return;
+
+ TVector<r_8> vdate(nmes[ic]); vdate = 0;
+ for(int i=0;i<nmes[ic];i++) {
+   vdate(i) = date[ic][i];
+   if(date[ic][i]<0.)  date[ic][i] = GRAND2;
+   if(timeu[ic][i].FgCalib<=0) date[ic][i] = GRAND2;
+ }
+
+ char str[16]; sprintf(str,"date%d",ic);
+ pos_->PutObject(vdate,str);
+
+}
+
+/*================================================================*/
+void UINITCCD(void)
+{
+ printf("UINITCCD: Debut de l'etude du CCD %d %d\n",numccd,ccdnum);
+
+ // Fill TimeInfoU into NTuple
+ const int nxtn = 12;
+ char *nament[nxtn] =
+   {"ts","texp","fd","sfd","sx","sy","rho","dx","dy","absor","amass","fgcal"};
+ r_8 xnt[nxtn];
+ NTuple nttinf(nxtn,nament);
+ 
+ for(int ic=0;ic<NCOULMX;ic++) {
+   if(nmesure[ic]<=0) continue;
+   NTuple nttinf(nxtn,nament);
+   for(int j=0;j<nmesure[ic];j++) {
+     int i = indexu[ic][j];
+     xnt[0] = timeu[ic][i].TStart/86400.;
+     xnt[1] = timeu[ic][i].Expose;
+     xnt[2] = timeu[ic][i].Fond;
+     xnt[3] = timeu[ic][i].SigFond;
+     xnt[4] = timeu[ic][i].SigX;
+     xnt[5] = timeu[ic][i].SigY;
+     xnt[6] = timeu[ic][i].Rho;
+     xnt[7] = timeu[ic][i].DelX;
+     xnt[8] = timeu[ic][i].DelY;
+     xnt[9] = timeu[ic][i].Absorption;
+     xnt[10] = timeu[ic][i].AirMass;
+     xnt[11] = timeu[ic][i].FgCalib;
+     nttinf.Fill(xnt);
+   }
+   char str[16]; sprintf(str,"tinf%d",ic);
+   pos_->PutObject(nttinf,str);
+ }
+
+ // Create NTuple for StarInfo
+ const int nsti = 12;
+ char *namentsti[nsti] =
+   {"net","xref","fmean","fsig","fref","xp","yp","dm","dm2","dm2r","fgref","nbvois"};
+ for(int ic=0;ic<NCOULMX;ic++) {
+   cout<<"...Creating NTuple for StarInfo ic="<<ic<<endl;
+   if(ntsti_[ic] == NULL) delete ntsti_[ic];
+   ntsti_[ic] = new NTuple(nsti,namentsti);
+ }
+
+}
+
+/*================================================================*/
+void UEVT(void)
+{
+ printf("****> Et=%d (%d) %d (%d)  fref=%g %g  nmes=%d %d  nmesure=%d %d\n"
+       ,iet[0],staru[0].XRef,iet[1],staru[1].XRef,staru[0].FluxRef,staru[1].FluxRef
+       ,nmes[0],nmes[1],nmesure[0],nmesure[1]);
+
+ // Fill StarInfo information into NTuple
+ for(int ic=0;ic<NCOULMX;ic++) {
+   if(iet[ic]<=0) continue;   // pas d'etoile associee
+   int n = ntsti_[ic]->NVar();
+   if(n<=0) continue;
+   r_8 *xnt = new r_8[n];
+   xnt[0] = staru[ic].NumEt;
+   xnt[1] = staru[ic].XRef;
+   xnt[2] = staru[ic].FlxMean;
+   xnt[3] = staru[ic].FlxSig;
+   xnt[4] = staru[ic].FluxRef;
+   xnt[5] = staru[ic].XPos;
+   xnt[6] = staru[ic].YPos;
+   xnt[7] = staru[ic].DisMin;
+   xnt[8] = staru[ic].DisM2;
+   xnt[9] = staru[ic].DisM2R;
+   xnt[10] = staru[ic].FgRef;
+   xnt[11] = staru[ic].NbVois;
+   ntsti_[ic]->Fill(xnt);
+   delete [] xnt;
+ }
+
+ // Fill light curve into NTuple
+ if(FgSelSt==iet[0]) {
+   cout<<"...Writing light curve for "<<iet[0]<<" "<<iet[1]<<endl;
+
+   const int nxtn = 15;
+   char *nament[nxtn] =
+     {"ic",
+      "ts","fd","sx","sy","rho",
+      "f","fb","xi2","ef","efb","fdl","s9p","pxm",
+      "fr"
+     };
+   r_8 xnt[nxtn];
+   NTuple nt(nxtn,nament);
+
+   for(int ic=0;ic<NCOULMX;ic++) {
+     if(iet[ic]<=0) continue;   // pas d'etoile associee
+     if(nmesure[ic]<=0) continue;
+     for(int j=0;j<nmesure[ic];j++) {
+       int i = indexu[ic][j];
+       xnt[0] = ic;
+       xnt[1] = timeu[ic][i].TStart/24.;
+       xnt[2] = timeu[ic][i].Fond;
+       xnt[3] = timeu[ic][i].SigX;
+       xnt[4] = timeu[ic][i].SigY;
+       xnt[5] = timeu[ic][i].Rho;
+       xnt[6] = mesu[ic][i].Flux;
+       xnt[7] = mesu[ic][i].FluxB;
+       xnt[8] = mesu[ic][i].Xi2;
+       xnt[9] = mesu[ic][i].ErrFlux;
+       xnt[10] = mesu[ic][i].ErrFluxB;
+       xnt[11] = mesu[ic][i].Fond;
+       xnt[12] = mesu[ic][i].S9Pix;
+       xnt[13] = mesu[ic][i].PixMax;
+       xnt[14] = staru[ic].FluxRef;
+       nt.Fill(xnt);
+     }
+   }
+   if(nt.NEntry()>0) {
+     char str[64]; sprintf(str,"e%d",iet[0]);
+     pos_->PutObject(nt,str);
+   }
+
+ }
+
+}
+
+/*================================================================*/
+void UENDCCD(void)
+{
+ printf("UENDCCD: Fin de l'etude du CCD %d %d\n",numccd,ccdnum);
+ if(ntsti_[0]->NEntry()>0) pos_->PutObject(*ntsti_[0],"sti0");
+ if(ntsti_[1]->NEntry()>0) pos_->PutObject(*ntsti_[1],"sti1");
+ if(ntsti_[0]!=NULL) delete ntsti_[0]; ntsti_[0] = NULL;
+ if(ntsti_[1]!=NULL) delete ntsti_[1]; ntsti_[1] = NULL;
+}
+
+/*================================================================*/
+void UEND(void)
+{
+ printf("UEND: Fin du job\n");
+ if(pos_!=NULL) delete pos_; pos_ = NULL;
+}
+
+
+/*
+
+openppf nbsread_ppf.ppf
+
+zone 1 2
+n/plot date0.val%n val>0
+n/plot date1.val%n val>0
+
+#### timeinfo
+zone 1 2
+
+n/plot tinf0.fd%ts ! ! "circlemarker3 red"
+n/plot tinf1.fd%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.sx%ts ! ! "circlemarker3 red"
+n/plot tinf1.sx%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.sy%ts ! ! "circlemarker3 red"
+n/plot tinf1.sy%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.rho%ts ! ! "circlemarker3 red"
+n/plot tinf1.rho%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.dx%ts ! ! "circlemarker3 red"
+n/plot tinf1.dx%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.dy%ts ! ! "circlemarker3 red"
+n/plot tinf1.dy%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.absor%ts ! ! "circlemarker3 red"
+n/plot tinf1.absor%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.amass%ts ! ! "circlemarker3 red"
+n/plot tinf1.amass%ts ! ! "circlemarker3 blue"
+
+n/plot tinf0.fgcal%ts ! ! "circlemarker3 red"
+n/plot tinf1.fgcal%ts ! ! "circlemarker3 blue"
+
+#### starinfo
+zone
+
+n/plot sti0.yp%xp ! ! "nsta red crossmarker5"
+n/plot sti1.yp%xp  ! ! "nsta blue circlemarker5 same"
+
+n/plot sti0.log10(fref) fref>0 ! ! "red"
+n/plot sti1.log10(fref) fref>0 ! ! "blue keepbin same"
+
+n/plot sti0.dm xref>0 ! ! "red"
+n/plot sti1.dm xref>0 ! ! "blue keepbin same"
+
+n/plot sti0.dm2 xref>0 ! ! "red"
+n/plot sti1.dm2 xref>0 ! ! "blue keepbin same"
+
+n/plot sti0.nbvois ! ! ! "red"
+n/plot sti1.nbvois ! ! ! "blue keepbin same"
+
+n/plot sti0.dm2%dm xref>0 ! "nsta red crossmarker5"
+n/plot sti1.dm2%dm  xref>0 ! "nsta blue circlemarker5"
+
+#### light curve
+set et 2005
+
+zone 1 2
+n/plot e$et.f%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.f%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.ef%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.ef%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.fb%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.fb%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.efb%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.efb%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.(f-fb)/f%ts ic==0&&f>0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.(f-fb)/f%ts ic==1&&f>0 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.fd%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.fd%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.fdl%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.fdl%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.s9p%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.s9p%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+n/plot e$et.pxm%ts ic==0 ! "nsta connectpoints red circlemarker3"
+n/plot e$et.pxm%ts ic==1 ! "nsta connectpoints blue circlemarker3"
+
+# Distributions
+zone
+
+n/plot e$et.fb ic==0
+n/plot e$et.f ic==0 ! ! "keepbin same red"
+n/plot e$et.fb ic==1
+n/plot e$et.f ic==1 ! ! "keepbin same blue"
+
+n/plot e$et.fdl ic==0 ! ! "red"
+n/plot e$et.fdl ic==1 ! ! "keepbin same blue"
+
+n/plot e$et.s9p ic==0 ! ! "red"
+n/plot e$et.s9p ic==1 ! ! "keepbin same blue"
+
+n/plot e$et.pxm ic==0 ! ! "red"
+n/plot e$et.pxm ic==1 ! ! "keepbin same blue"
+
+# Correlations
+zone
+
+n/plot e$et.f%fb ic==0 ! "red circlemarker3"
+func x 0 1000 10000 "same"
+n/plot e$et.f%fb ic==1 ! "blue circlemarker3"
+func x 0 1000 10000 "same"
+
+n/plot e$et.s9p%fb ic==0 ! "red circlemarker3"
+func x 0 1000 10000 "same"
+n/plot e$et.s9p%fb ic==1 ! "blue circlemarker3"
+func x 0 1000 10000 "same"
+
+n/plot e$et.pxm%fb ic==0 ! "red circlemarker3"
+func x 0 1000 10000 "same"
+n/plot e$et.pxm%fb ic==1 ! "blue circlemarker3"
+func x 0 1000 10000 "same"
+func x 0 1000 10000 "same"
+
+ */
Index: trunk/FrEROS/AnaLC/nbsreadu_squel.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbsreadu_squel.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsreadu_squel.cc	(revision 3308)
@@ -0,0 +1,187 @@
+/*
+nbsreadu_squel fichier.dataccd -prt 1 \
+           -mc 2 -u0 0.01,0.5 -t0 1,-1,-1 -tau 2,10,-1 -tf 2,0,2 -bl 1
+*/
+#include "machdefs.h"
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fsvcache.h"
+#include "fsvst.h"
+#include "fmath.h"
+#include "nbmath.h"
+#include "nbrandom.h"
+#include "nbsread.h"
+#include "nbgene.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Prototype des routines locales en C ou C++ */
+void mycalib(float f1,float f2, STARCALU* stcal, void *user_parm);
+void myblending(void);
+float mytiretau(float);
+#ifdef __cplusplus
+}
+#endif
+
+/*================================================================*/
+void UINIT(void)
+{
+static char CcdParm[20];
+
+/* fonction utilisateur de calibration absolue */
+Calibration_Absolue = mycalib;
+strcpy(CcdParm,"CCD");
+Calibration_Absolue_UParms = CcdParm;
+/* fonction utilisateur de generation des parametres du blending */
+mc.Get_Par_Blending = myblending;
+/* fonction utilisateur de tirage du parametre Tau */
+mc.TireTau = mytiretau;
+}
+
+/*=================== ============================================*/
+void UDATCLEAN(int coul)
+/*
+  Attention ici coul = 1,2
+    donc pour tuer une image pour la couleur coul:
+    date[coul-1][...] = GRAND2;
+*/
+{
+int ic = coul - 1;
+printf("UDATCLEAN: couleur %d, indice tableau %d\n",coul,ic);
+}
+
+/*================================================================*/
+void UINITCCD(void)
+{
+printf("UINITCCD: Debut de l'etude du CCD %d %d\n",numccd,ccdnum);
+}
+
+/*================================================================*/
+void UEVT(void)
+{
+int ic,i,j;
+float xnt[30];
+double fball[2], fbgood[2], w;
+
+if( ffprt > 0 || iet[0]%100==0 ) {
+  printf("****> Et= %d %d   Sel=%d  fref=%g,%g\n"
+        ,iet[0],iet[1],FgSelSt,staru[0].FluxRef,staru[1].FluxRef);
+  printf("      B=%g V=%g R=%g I=%g Rs=%g t=%d\n"
+        ,starcal.Mag_B,starcal.Mag_V,starcal.Mag_R,starcal.Mag_I
+        ,starcal.Rstar,starcal.Rtype);
+  printf("      u0=%g t0=%g tau=%g U=%g\n",mc.U0Sim,mc.T0Sim,mc.TauSim,mc.USim);
+  printf("      Arec1=%g,%g Arec2=%g,%g Rstar1=%g Rstar2=%g\n"
+        ,mc.coeff_Arec1[0],mc.coeff_Arec1[1],mc.coeff_Arec2[0],mc.coeff_Arec2[1]
+        ,mc.starcal1.Rstar,mc.starcal2.Rstar);
+  printf("      A0_pct=%g A0_tf=%g A0_blend=%g,%g\n"
+        ,mc.A0MaxPt,mc.A0Max,mc.A0Max_blend[0],mc.A0Max_blend[1]);
+  fflush(stdout);
+}
+
+/* moyenne des flux bruts de toutes les images et des images valides */
+for(ic=0;ic<NCOULMX;ic++) {
+
+  fball[ic] = w = 0.;
+  if( nmes[ic] > 0 ) {
+    for(i=0;i<nmes[ic];i++) {
+      if( mesu[ic][i].Xi2 < 0. ) continue;
+      if( mesu[ic][i].ErrFluxB <= 0. ) continue;
+      fball[ic] += mesu[ic][i].FluxB*mesu[ic][i].ErrFluxB;
+      w += mesu[ic][i].ErrFluxB;
+    }
+    if( w > 0. ) fball[ic] /= w;
+  }
+
+  fbgood[ic] = w = 0.;
+  if( nmesure[ic] > 0 ) {
+    for(j=0;j<nmesure[ic];j++) {
+      i = indexu[ic][j];
+      if( mesu[ic][i].Xi2 < 0. ) continue;
+      if( mesu[ic][i].ErrFluxB <= 0. ) continue;
+      fbgood[ic] += mesu[ic][i].FluxB*mesu[ic][i].ErrFluxB;
+      w += mesu[ic][i].ErrFluxB;
+    }
+    if( w > 0. ) fbgood[ic] /= w;
+  }
+
+}
+
+xnt[ 0] = iet[0];
+xnt[ 1] = iet[1];
+xnt[ 2] = staru[0].FluxRef;
+xnt[ 3] = staru[1].FluxRef;
+xnt[ 4] = starcal.Mag_B;
+xnt[ 5] = starcal.Mag_V;
+xnt[ 6] = starcal.Mag_R;
+xnt[ 7] = starcal.Mag_I;
+xnt[ 8] = starcal.Rstar;
+xnt[ 9] = starcal.Rtype;
+xnt[10] = mc.U0Sim;
+xnt[11] = mc.T0Sim;
+xnt[12] = mc.TauSim;
+xnt[13] = mc.USim;
+xnt[14] = mc.A0MaxPt;
+xnt[15] = mc.A0Max;
+xnt[16] = mc.A0Max_blend[0];
+xnt[17] = mc.A0Max_blend[1];
+xnt[18] = mc.starcal1.Rstar;
+xnt[19] = mc.starcal2.Rstar;
+xnt[20] = fball[0];
+xnt[21] = fball[1];
+xnt[22] = fbgood[0];
+xnt[23] = fbgood[1];
+// a stoquer dans votre fichier prefere
+
+}
+
+/*================================================================*/
+void UENDCCD(void)
+{
+printf("UENDCCD: Fin de l'etude du CCD %d %d\n",numccd,ccdnum);
+}
+
+/*================================================================*/
+void UEND(void)
+{
+}
+
+/*================================================================*/
+void mycalib(float f1,float f2, STARCALU* stcal, void *user_parm)
+/* fonction de calibration absolue completement idiote */
+{
+if(f1<=0. || f2<0.) return;
+if( strcmp((char *) user_parm,"CCD") ) return;
+stcal->Mag_B = stcal->Mag_V = -2.5*log10((double) f2);
+stcal->Mag_R = stcal->Mag_I = -2.5*log10((double) f1);
+stcal->Rtype = (int) (drand01()+1.5);
+stcal->Rstar = 3.*drand01();
+}
+
+/*================================================================*/
+void myblending(void)
+/* fonction de generation de blending completement idiote */
+{
+mc.coeff_Arec1[0] = 0.5+drand01()/2.;
+mc.coeff_Arec1[1] = 0.5+drand01()/2.;
+mc.starcal1.Rstar = 3.*drand01();
+
+mc.coeff_Arec2[0] = 0.5-drand01()/2.;
+mc.coeff_Arec2[1] = 0.5-drand01()/2.;
+mc.starcal2.Rstar = 3.*drand01()/2.;
+}
+
+/*================================================================*/
+float mytiretau(float alea)
+/* fonction de tirage aleatoire de Tau personnelle */
+/* (tirage logarithmique en Tau)                   */
+{
+if( mc.TauMinI<=0. || mc.TauMaxI<=0. || mc.TauMaxI<=mc.TauMinI ) {
+  mc.TauMinI = 1.; mc.TauMaxI = 100.;
+}
+alea *= log(mc.TauMaxI/mc.TauMinI);
+return( (float) mc.TauMinI*exp((double) alea) );
+}
Index: trunk/FrEROS/AnaLC/nbsreadu_stlist.cc
===================================================================
--- trunk/FrEROS/AnaLC/nbsreadu_stlist.cc	(revision 3308)
+++ trunk/FrEROS/AnaLC/nbsreadu_stlist.cc	(revision 3308)
@@ -0,0 +1,56 @@
+/*
+Ecriture des corubes de lumieres individuelles pour database ErosI
+*/
+#include "sopnamsp.h"
+#include "machdefs.h"
+#include <iostream>
+#include <string>
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fsvcache.h"
+#include "fsvst.h"
+#include "nbsread.h"
+#include "nbgene.h"
+
+FILE* fstlist = NULL;
+int icount = 0;
+
+/*================================================================*/
+void UINIT(void) {}
+void UDATCLEAN(int coul) {}
+void UINITCCD(void)
+{
+  fstlist = fopen("nbsread_stlist.data","w");
+  icount = 0;
+}
+void UENDCCD(void)
+{
+  if(fstlist != NULL) fclose(fstlist); fstlist = NULL;
+}
+void UEND(void) {}
+
+/*================================================================*/
+void UEVT(void)
+{
+ if(icount%1000==0)
+   printf("> Et=%d (%d) %d (%d)  fref=%g %g\n"
+         ,iet[0],staru[0].XRef,iet[1],staru[1].XRef,staru[0].FluxRef,staru[1].FluxRef);
+
+ icount++;
+ if(nmesure[0]<=0 || nmesure[1]<=0) return;
+ if(iet[0]<=0 || iet[1]<=0) return;
+ 
+ fprintf(fstlist,"%d %.3f %.3f %.3f  %d %.3f %.3f %.3f\n",
+	 staru[0].NumEt,staru[0].XPos,staru[0].YPos,staru[0].FluxRef,
+	 staru[1].NumEt,staru[1].XPos,staru[1].YPos,staru[1].FluxRef);
+
+ /*
+ fprintf(fstlist,"%d %.3f %.3f %.3f  %d %.3f %.3f %.3f\n",
+	 staru[1].NumEt,staru[1].XPos,staru[1].YPos,staru[1].FluxRef,
+	 staru[0].NumEt,staru[0].XPos,staru[0].YPos,staru[0].FluxRef);
+ */
+
+}
Index: trunk/FrEROS/AnaLC/nomfits.c
===================================================================
--- trunk/FrEROS/AnaLC/nomfits.c	(revision 3308)
+++ trunk/FrEROS/AnaLC/nomfits.c	(revision 3308)
@@ -0,0 +1,178 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "strutil.h"
+#include "nomfits.h"
+
+/*  RZ + CMV  07/94, modifs EROS II CMV 27/11/96  */
+
+/* 
+++ 
+  Module	Codage des noms de fichiers Eros 1 et 2 (C)
+  Lib	LibsUtil
+  include	nomfits.h
+
+	Pour coder et decoder les noms de fichiers Fits Eros 1 et 2.
+--
+*/
+
+/* Nouvelle-Fonction */
+/*
+++
+int CodeFitsName(char const* nom)
+	Decodage d'un `nom' de fichier pour fournir un entier code (Rc).
+| Rc :   C A MM JJ NNN  pour EROS I
+|      1 C A MM JJ NNN  pour EROS II
+|     (Une lettre = un chiffre decimal)
+| C Couleur : 1 = Rouge, 2= Bleu, 0 Sinon (cas EROS I)
+|   Camera  : 1 = Rouge, 2= Bleu, 0 Sinon (cas EROS II)
+| A  Annee  (Ex 1994 -> 4)
+| MM Mois   (01 a 12)   JJ  Jour (01 a 31)
+| NNN Numero de sequence en decimal (jusqu'a 999)
+| Remarque: Marche pour un nom EROS I ou EROS II
+--
+*/
+int CodeFitsName(char const* nom)
+{
+int c,a,jj,mm,nn,l,rc;
+int ieros,ic,ia,im,ij,in;
+char name[30],s[6];
+
+strncpy(name,nom,28);  name[29] = '\0';
+strip(name,'B',' '); 
+if ( (l=posc(name,'.')) >= 0)  name[l] = '\0';
+l = strlen(name);
+if (l < 8) {  /* type de nom inconnu */
+  return(0);
+} else if (l < 15 ) { /* c'est un nom EROS I */
+  ieros = 1;
+  ic = 1; ia = 2; im = 3; ij = 4; in = 6;
+} else {              /* c'est un nom EROS II */
+  ieros = 2;
+  ic = 5; ia = 10; im = 11; ij = 12; in = 14;
+}
+
+/* codage de la couleur/camera */
+if( ieros == 1 ) {
+  if(name[ic] == 'r')        c = 1;
+    else if(name[ic] == 'b') c = 2;
+      else                   c = 0;
+} else {
+   c = (int)name[ic] - (int)'0'; c += 10;
+}
+rc = c*100000000;
+
+/* codage de l'annee */
+s[0] = name[ia];  s[1] = '\0';
+a = atoi(s);
+rc += a*10000000;
+
+/* codage du mois */
+mm = (int)name[im]-(int)'a'+1;
+rc += mm*100000;
+
+/* codage du jour */
+s[0] = name[ij];  s[1] = name[ij+1];  s[2] = '\0';
+jj = atoi(s);
+rc += jj*1000;
+
+if( ieros == 1 ) {
+  nn = strtol(name+in,NULL,16);
+} else {
+  strncpy(s,&name[in],3); /* pas plus de 999 */
+  nn = atoi(s);
+}
+rc += nn;
+
+return(rc);
+}
+
+/* Nouvelle-Fonction */
+/*
+++
+char * DecodeNumPhoto(int num, char* nom)
+	Fonction inverse de CodeFitsName(). Retourne
+	le `nom' de fichier Fits Eros correspondant a l'entier `num'.
+--
+*/
+char * DecodeNumPhoto(int num, char* nom)
+{
+int f,a,m,j,n;
+char cm,cf[3];
+cf[0] = '-'; cf[1] = 'r'; cf[2] = 'b';
+
+n = num%1000;
+num = (num-n)/1000;  j = num%100;
+num = (num-j)/100;  m = num%100;
+if ((m<1) || (m > 12) )  cm = '-';
+else  cm = 'a'+(m-1);
+num = (num-m)/100;  a = num%10;
+num = (num-a)/10;   f = num;
+if( f >= 10 ) {  /* c'est un nom EROS II */
+  f -= 10;
+  sprintf(nom,"@%1d%1d%c%02d%d",f,a,cm,j,n);
+} else {        /* c'est un nom EROS I  */
+  if ((f>2) || (f<0))  f = 0;
+  sprintf(nom,"@%c%1d%c%02d%02x",cf[f],a,cm,j,n);
+}
+
+return(nom);
+}
+
+/* Nouvelle-Fonction */
+int CodeFilterName(char const* filtre)
+/*  Renvoie 1 pour filtre rouge , 2 Bleu, 0 sinon */
+{
+char name[25];
+
+strncpy(name,filtre,20);  name[20] = '\0';
+strip(name,'B',' '); 
+if (tolower(name[0]) == 'r')  return(1);
+if (tolower(name[0]) == 'b')  return(2);
+return(0);
+}
+
+/* Nouvelle-Fonction */
+/*
+++
+int CodeFilterName2(char const* nom,int* champ,int* coul,int* ccd)
+	Decortique un nom de fichier EROS II et le code dans 3 entiers.
+| champ = conversion decimale du champ ex: cg601 -> 20909665
+| coul  = codage numero de camera (D) + numero de filtre (Z)
+|       = nfilt*10 + ncam,  ex: camera 1 filtre z -> 35*10+1 = 351
+|       recup rapide du num de camera: coul%10
+| ccd   = codage du mumero de sous image (Z) et de CCD (D)
+|       = nssima*10 + nccd, ex: ssima=t ccd 7 -> 29*10+7 = 297
+|       recup rapide du num de ccd: ccd%10
+| Rc = 0 si OK, -1 sinon
+--
+*/
+int CodeFilterName2(char const* nom,int* champ,int* coul,int* ccd)
+{
+int i1,i2,l;
+char name[30],s[6];
+*champ = *coul = *ccd = 0;
+
+strncpy(name,nom,28);  name[29] = '\0';
+strip(name,'B',' '); 
+if ( (l=posc(name,'.')) >= 0)  name[l] = '\0';
+l = strlen(name);
+if (l < 15 ) return(-1); /* c'est pas un nom EROS II */
+
+strncpy(s,name,5); s[5]='\0';
+*champ = strtol(s,NULL,36);
+
+strncpy(s,&name[8],1); s[1]='\0';
+i1 = strtol(s,NULL,36);
+i2 = (int)name[5] - (int)'0';
+*coul = i1*10 + i2;
+
+strncpy(s,&name[7],1); s[1]='\0';
+i1 = strtol(s,NULL,36);
+i2 = (int)name[6] - (int)'0';
+*ccd = i1*10 + i2;
+
+return(0);
+}
Index: trunk/FrEROS/AnaLC/nomfits.h
===================================================================
--- trunk/FrEROS/AnaLC/nomfits.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/nomfits.h	(revision 3308)
@@ -0,0 +1,19 @@
+/*    Include_file contenant les fonctions de codage/decodage EROS1  */
+
+#ifndef  NOMFITS_H_SEEN
+#define  NOMFITS_H_SEEN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int CodeFitsName(char const* nom);
+char * DecodeNumPhoto(int num, char* nom);
+int CodeFilterName(char const* filtre);
+int CodeFilterName2(char const* nom,int* champ,int* coul,int* ccd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
Index: trunk/FrEROS/AnaLC/nomfits2.c
===================================================================
--- trunk/FrEROS/AnaLC/nomfits2.c	(revision 3308)
+++ trunk/FrEROS/AnaLC/nomfits2.c	(revision 3308)
@@ -0,0 +1,469 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include "strutil.h"
+#include "nomfits2.h"
+#include "datime.h"
+
+/* 
+++ 
+  Module	Aide au codage des noms Fits (C).
+  Lib	LibsUtil
+  include	nomfits2.h
+
+	Pour aider a coder et decoder les noms de fichiers Fits Eros 1 et 2.
+	Pour verifier la bonne sante d'un fichier Fits.
+--
+*/
+/* ----------------------------------------------------------------- */
+/* Reza+farhang, Avril 2007, copie depuis Peida/LibsUtil/datime.h .c */
+/*
+++
+  int DecodeStrgtoJMAHMS(const char* strg, JMA* jma, HMS* hms)
+	Decodage d'une chaine sous forme "yyyy-mm-ddThh:mm:ss.s" ou "dd/mm/yy" ou
+	"yy/mm/dd" (si yy > 31) ou "yyyy-mm-dd" ou "dd/mm/yyThh:mm:ss.s" en 
+	structure JMA et HMS. Si yy < 100 , 1900 est ajoute a l'annee.
+	Les argumets "jma" ou "hms" peuvenet etre nuls. 
+	Code de retour :
+|	Bit 0 ( -> 1) :  Decodage date OK
+|	Bit 1 ( -> 2) :  DecodaGE Heure OK
+
+--
+*/
+/* Nouvelle-Fonction */
+int DecodeStrgtoJMAHMS(const char* strg, JMA* jma, HMS* hms)
+{
+JMA lj;
+HMS lh;
+int i,j,l,rc;
+int tiret;
+int T;
+char buff[256];
+
+if (jma == NULL) jma = &lj;
+if (hms == NULL) hms = &lh;
+
+/* Initialisation de la date et de l'heure */
+rc = 0;
+hms->Heures = 0;
+hms->Minutes = 0;
+hms->Secondes = 0.;
+jma->Annee = 0;
+jma->Mois = 0;
+jma->Jour = 0;
+
+
+l = strlen(strg);
+tiret = T = -1;
+for(i=0,j=0; i<l; i++) {
+  if (j > 254)  break;
+  if (strg[i] == ' ') continue;
+  buff[j] = strg[i];
+  if (buff[j] == '-')  { buff[j] = ' '; tiret = 1;  } /* Date code avec un tiret  */
+  if (buff[j] == 'T')  T = j;      /*  Heure code dans la chaine  */
+  j++;
+  }  
+
+buff[j] ='\0';
+if (T >= 0)  { 
+  buff[T] ='\0';
+  sscanf(buff+T+1,"%d:%d:%lf", &(hms->Heures),&(hms->Minutes),&(hms->Secondes));
+  if ( (hms->Heures>=0.) && (hms->Heures<24.)  && 
+       (hms->Minutes>=0.) && (hms->Minutes<60.) &&
+       (hms->Secondes>=0.) && (hms->Secondes<60.) )  rc += 2;
+  }
+if (tiret < 0) {  
+  sscanf(buff,"%d/%d/%d", &(jma->Jour),&(jma->Mois),&(jma->Annee));
+  /* Jour > 31 -> On tente yy/mm/dd  */
+  if (jma->Jour>31) sscanf(buff,"%d/%d/%d", &(jma->Annee),&(jma->Mois),&(jma->Jour));
+  }
+else { /* Date code avec un tiret  */
+  sscanf(buff,"%d %d %d", &(jma->Annee),&(jma->Mois),&(jma->Jour));
+  }
+if (jma->Annee < 100)  jma->Annee += 1900;
+if ( (jma->Mois >= 1) && (jma->Mois <= 12) && (jma->Jour >= 1) && (jma->Jour <= 31) ) rc += 1;
+return(rc);
+}
+/* --- fin ajout depuis Peida/LibsUtil/datime.h ----- */
+
+
+/*====================================================*/
+/*
+++
+unsigned long int decode_zeza(char* s, int i1, int i2)
+	Pour coder (Rc) en entier decimal la chaine de caracteres
+	comprise entre `s[i1]' et `s[i2]' interpretee comme
+	une suite de Zezas (base 36 : 0 a z).
+--
+*/
+unsigned long int decode_zeza(char* s, int i1, int i2)
+{
+  unsigned long int D, ibase = 1;
+  int i, i0, sic;
+
+  if( i1 < 0 ) i1 = 0;
+  if( i2 > strlen(s) ) i2 = strlen(s);
+  if( i2 < i1 ) return(0);
+  for(i=i1; i<=i2; i++) if( ! isalnum((int) s[i]) ) break;
+  i2 = i-1;
+  /* printf("s=%s i1=%d i2=%d\n",s,i1,i2); */
+  if( i2 < i1 ) return(0);
+
+  D = 0;
+  for(i=i2; i>=i1; i--) {
+    sic = (int) s[i];
+    if( islower(sic) ) i0 = (int) 'a' - 10;
+      else if( isupper(sic) ) i0 = (int) 'A' - 10;
+        else i0 = (int) '0';
+    D += (unsigned long int) ( sic - i0 ) * ibase;
+    /* printf("-- s[%d]=%c sic=%d i0=%d D=%ld\n",i,s[i],sic,i0,D); */
+    ibase *= 36;
+  }
+  return( D );
+}
+
+/*====================================================*/
+/*
+++
+char * dec2zeza(unsigned long z, char *s, int n)
+	Pour coder en Zeza (base 36) dans la chaine de characteres
+	`s' de longeur maximum `n' le nombre entier decimal `z'.
+--
+*/
+char * dec2zeza(unsigned long z, char *s, int n)
+{
+int r,i,j;
+char sz[16];
+if(n<2) return NULL;
+sz[0] = '0'; sz[1] = '\0';
+i=0;
+while (z) {
+  r = z%36;
+  if(r<10) sz[i] = '0'+r; else sz[i] = 'a'+r-10;
+  z /= 36;
+  i++;
+  }
+for(j=0;j<i && j<n-1;j++) s[j] = sz[i-j-1];
+s[j] = '\0';
+
+return( s );
+} 
+
+/*====================================================*/
+/*
+++
+int qSort_fits2(const void *x1,const void *x2)
+	Pour trier avec `qsort' un tableau de pointeurs sur
+	des chaines de caracteres de noms de fichiers fits Eros2.
+	Le tri s'effectue dans l'ordre canonique suivant,
+	apres convertion des chaines de caracteres
+	interpretees comme des Zezas en entier decimal:
+| nom = oo ccc C c s f t dddd sss
+|   1- sur la date dddd,
+|   2- sur l'objet oo,
+|   3- sur le champ ccc,
+|   4- sur le numero de camera C
+|   5- sur le nom du filtre f,
+|   6- sur le type de traitement t,
+|   7- sur le numero de sequence sss,
+|   8- sur le numero de sous-image s,
+|   9- sur le numero de ccd c.
+--
+*/
+int qSort_fits2(const void *x1,const void *x2)
+/*  oo ccc c c s f t dddd sss  */
+/*  bb hhh a c s i r aaaa eee  */
+/*  jj ppp m d i l a tttt qqq  */
+/*  */
+/*  01 234 5 6 7 8 9 1111 111  */
+/*                   0123 456  */
+{
+unsigned long int i,j;
+char *s1, *s2;
+
+s1 = *((char **) x1);
+s2 = *((char **) x2);
+
+/* tri par date */
+i = decode_zeza(s1,10,13);
+j = decode_zeza(s2,10,13);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par objet*/
+i = decode_zeza(s1,0,1);
+j = decode_zeza(s2,0,1);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par champ */
+i = decode_zeza(s1,2,4);
+j = decode_zeza(s2,2,4);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par camera */
+i = decode_zeza(s1,5,5);
+j = decode_zeza(s2,5,5);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par filtre */
+i = decode_zeza(s1,8,8);
+j = decode_zeza(s2,8,8);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par traitement */
+i = decode_zeza(s1,9,9);
+j = decode_zeza(s2,9,9);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par sequence */
+i = decode_zeza(s1,14,999);
+j = decode_zeza(s2,14,999);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par sous-image */
+i = decode_zeza(s1,7,7);
+j = decode_zeza(s2,7,7);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* puis tri par ccd */
+i = decode_zeza(s1,6,6);
+j = decode_zeza(s2,6,6);
+if(i<j) return(-1); else if(i>j) return(1);
+
+/* Ici les noms sont identiques. */
+return(0);
+}
+
+
+
+/* CMV: test des conneries du serveur MG ! */
+
+/* taille du block d'un fichier fits */
+#define HEAD_SIZE_CMV 2880
+/* nombre maximum permis de blocks pour le header */
+#define N_BLK_HEAD_CMV 100
+
+/*
+++
+int Test_NoCorrupt(char *flnm)
+	Test pour voir si le fichier Fits de nom `flnm' n'est
+	pas corrompu.
+| Rc =  0 : fichier OK
+|      -1 : echec open
+|      -2 : le buffer lu ne fait pas 80 caracteres
+|      -3 : clef Fits sans signe =
+|      -4 : la longueur que l'on deduit de l'entete fits
+|           est incompatible avec celle du fichier.
+|      -5 : il manque une clef Fits (NAXIS1,NAXIS2,NAXIS, BITPIX)
+|           ou la clef BITPIX n'est pas correcte.
+--
+*/
+int Test_NoCorrupt(char *flnm)
+{
+int lp=0;
+FILE *fip;
+char buff[81],*c,*cval;
+unsigned short naxis_set, naxis1_set, naxis2_set, bitpix_set, end_set;
+int naxis1, naxis2, naxis, bitpix;
+long int nbytes_head,nbytes_pix,nbytes_tot,nbytes_mes;
+size_t i;
+
+fip = fopen(flnm,"rb");
+if( fip == NULL ) {
+  if(lp) printf("fopen: impossible de lire %s\n",flnm);
+  return(-1);
+}
+
+naxis_set = naxis1_set = naxis2_set = bitpix_set = end_set = 0;
+naxis1 = naxis2 = naxis = bitpix = 0;
+nbytes_head = nbytes_pix = nbytes_tot = nbytes_mes = 0;
+
+for(;;) {
+
+  i = fread(buff,1,80,fip);
+  if(lp) printf("fread: rc=%d\n",(int) i);
+  if( i != 80 ) return(-2);
+  nbytes_head += (long int) i;
+
+  if( nbytes_head / HEAD_SIZE_CMV > N_BLK_HEAD_CMV ) {
+    if(lp) printf("Trop de block dans le header %d > %d\n"
+            , (int) nbytes_head/HEAD_SIZE_CMV,N_BLK_HEAD_CMV);
+    break;
+  }
+
+  buff[80] = '\0';
+  if(lp) printf("buff=(%s)\n",buff);
+
+  c = buff;
+  strip(c,'B',' ');
+  if(lp) printf("   c=(%s)\n",c);
+
+  if(strcmp(c,"END")    == 0) {
+    if(lp) printf("  END trouve\n");
+    end_set = 1;
+  } else {
+    if( (i=posc(c,'=')) < 0 ) {
+      if(lp) printf("  pas de signe =\n");
+      return(-3);
+    }
+    *(c+i)='\0';
+    cval = c+i+1;
+    strip(c,'B',' ');
+    strip(cval,'B',' ');
+    if(lp) printf("   c=(%s) cval=(%s)\n",c,cval);
+ 
+    if(strcmp(c,"NAXIS") == 0) {
+      sscanf(cval,"%d",&naxis);
+      if(lp) printf("  NAXIS trouve\n");
+      naxis_set = 1;
+    }
+    if(strcmp(c,"NAXIS1") == 0) {
+      sscanf(cval,"%d",&naxis1);
+      if(lp) printf("  NAXIS1 trouve= %d\n",naxis1);
+      naxis1_set = 1;
+    }
+    if(strcmp(c,"NAXIS2") == 0) {
+      sscanf(cval,"%d",&naxis2);
+      if(lp) printf("  NAXIS2 trouve= %d\n",naxis2);
+      naxis2_set = 1;
+    }
+    if(strcmp(c,"BITPIX") == 0) {
+      sscanf(cval,"%d",&bitpix);
+      if(lp) printf("  BITPIX trouve= %d\n",bitpix);
+      bitpix_set = 1;
+    }
+  }
+
+  if(end_set) {
+    if( naxis1_set && naxis2_set && bitpix_set && bitpix%8==0 ) {
+
+      if( nbytes_head % HEAD_SIZE_CMV == 0 ) nbytes_head = nbytes_head / HEAD_SIZE_CMV;
+        else  nbytes_head = nbytes_head / HEAD_SIZE_CMV + 1;
+      nbytes_head = nbytes_head*HEAD_SIZE_CMV;
+
+      if( bitpix < 0 ) bitpix *= -1;
+      bitpix /= 8;
+      nbytes_pix = bitpix * naxis1*naxis2;
+      if( nbytes_pix % HEAD_SIZE_CMV == 0 ) nbytes_pix = nbytes_pix / HEAD_SIZE_CMV;
+        else  nbytes_pix = nbytes_pix / HEAD_SIZE_CMV + 1;
+      nbytes_pix = nbytes_pix*HEAD_SIZE_CMV;
+
+      nbytes_tot = nbytes_head + nbytes_pix;
+
+      if(lp)
+        printf("Taille predite: header=%ld core=%ld tot=%ld bytes\n"
+              ,nbytes_head,nbytes_pix,nbytes_tot);
+
+      fseek(fip, 0L, SEEK_END);
+      nbytes_mes = ftell(fip);
+      if(lp) printf("Taille totale mesuree= %ld bytes\n",nbytes_mes);
+
+      fclose(fip);
+      if( nbytes_tot == nbytes_mes ) return(0); else return(-4);
+    } else break;
+  }
+
+}
+
+fclose(fip);
+return(-5);
+}
+#undef HEAD_SIZE_CMV
+#undef N_BLK_HEAD_CMV
+
+
+/*====================================================*/
+/*
+++
+uint_4 DateTstoInt(char *date,char *t)
+	Pour coder la date et l'heure 
+	dans un entier (TimeInfo).
+| 16 bits de poids forts  : nombre de jours ecoules depuis de 1/1/90.
+|                  faibles: temps en unites de 2sec.
+--
+*/
+uint_4 DateTstoInt(const char *date,const char *ts)
+{
+JMA D,D0;
+HMS T;
+uint_4 Dj,Ts;
+int_4 dDj;
+
+/* init pout protection contre date,ts mal definis */
+StrgtoJMA("01/01/1990",D);
+StrgtoHMS("0:0:0",T);
+
+StrgtoJMA(date,D);
+StrgtoJMA("01/01/1990",D0);
+dDj = JMAtoJ(D) - JMAtoJ(D0);
+if( dDj > 32767 )  dDj = 32767;
+if( dDj < -32767 ) dDj = -32767;
+if (dDj >= 0) Dj = dDj;
+else Dj = 32768-dDj;
+
+StrgtoHMS(ts,T);
+Ts = (uint_4)(HMStoSec(T)/2.);
+if( Ts > 65535 ) Ts = 65535;
+
+return ((Dj<<16)+Ts);
+}
+
+/*====================================================*/
+/*
+++
+uint_4 DateTimetoInt(const char *datetime)
+	Pour coder la date et l'heure 
+	dans un entier (TimeInfo).
+| 16 bits de poids forts  : nombre de jours ecoules depuis de 1/1/90.
+|                  faibles: temps en unites de 2sec.
+--
+*/
+uint_4 DateTimetoInt(const char *datetime)
+{
+JMA D,D0;
+HMS T;
+uint_4 Dj,Ts;
+int_4 dDj;
+int rc;
+
+/* init pout protection contre date,ts mal definis */
+StrgtoJMA("01/01/1990",D);
+StrgtoHMS("0:0:0",T);
+rc = DecodeStrgtoJMAHMS(datetime, &D, &T);
+if (rc != 3) 
+  printf("DateTimetoInt(%s)/Warning - incomplete Date/Time specification (Rc=%d) \n", 
+         datetime, rc);
+StrgtoJMA("01/01/1990",D0);
+dDj = JMAtoJ(D) - JMAtoJ(D0);
+if( dDj > 32767 )  dDj = 32767;
+if( dDj < -32767 ) dDj = -32767;
+if (dDj >= 0) Dj = dDj;
+else Dj = 32768-dDj;
+
+Ts = (uint_4)(HMStoSec(T)/2.);
+if( Ts > 65535 ) Ts = 65535;
+
+return ((Dj<<16)+Ts);
+}
+
+/*====================================================*/
+/*
+++
+void InttoDateTs(uint_4 n,int_4 *date,int_4 *t)
+	Pour decoder la date et l'heure 
+	depuis un entier (TimeInfo).
+| n   : entier code.
+| date: nombre de jours ecoules depuis de 1/1/90.
+| t   : heure en secondes (precision 2s).
+--
+*/
+void InttoDateTs(uint_4 n,int_4 *date,int_4 *ts)
+{
+uint_4 dj, dt;
+dt = 2 * (n & 0xFFFF);
+dj = (n>>16) & 0xFFFF;
+if (dj > 32767) dj = 32768 - dj;
+*ts = dt;
+*date = dj;
+}
Index: trunk/FrEROS/AnaLC/nomfits2.h
===================================================================
--- trunk/FrEROS/AnaLC/nomfits2.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/nomfits2.h	(revision 3308)
@@ -0,0 +1,33 @@
+#ifndef  NOMFITS2_H_SEEN
+#define  NOMFITS2_H_SEEN
+#include "machdefs.h"
+
+/* Reza+farhang, Avril 2007, copie depuis Peida/LibsUtil/datime.h .c */
+#include "datime.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Reza+farhang, Avril 2007, copie depuis Peida/LibsUtil/datime.h .c */
+int  DecodeStrgtoJMAHMS(const char* strg, JMA* jma, HMS* hms);
+/* --- fin ajout depuis Peida/LibsUtil/datime.h ----- */
+
+unsigned long int decode_zeza(char* s, int i1, int i2);
+char * dec2zeza(unsigned long z, char *s, int n);
+int qSort_fits2(const void *x1,const void *x2);
+
+/* CMV: test des conneries du serveur MG ! */
+int Test_NoCorrupt(char *flnm);
+
+/* codage de la date/tsid dans timeinfo */
+uint_4 DateTstoInt(const char *date,const char *ts);
+uint_4 DateTimetoInt(const char *datetime);
+void InttoDateTs(uint_4 n,int_4 *date,int_4 *ts);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
Index: trunk/FrEROS/AnaLC/swapbytes.h
===================================================================
--- trunk/FrEROS/AnaLC/swapbytes.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/swapbytes.h	(revision 3308)
@@ -0,0 +1,40 @@
+/*  Macro pour faire des bytes-swap        */
+/*                   CMV+Reza Fev 98       */
+
+#ifndef  SWAPBYTES_H_SEEN
+#define  SWAPBYTES_H_SEEN
+
+/*  Les arguments des define sont consideres comme pointeur */
+
+#define  Swap_Bytes8(_x8_)                                 \
+{                                                          \
+  uint_8 _tmp_ = *(uint_8*)(_x8_);                         \
+  *(uint_8*)(_x8_) = ((_tmp_ >> (7*8)) & 0x000000FF) |     \
+                     ((_tmp_ >> (5*8)) & 0x0000FF00) |     \
+                     ((_tmp_ >> (3*8)) & 0x00FF0000) |     \
+                     ((_tmp_ >> (1*8)) & 0xFF000000) |     \
+                     ((_tmp_ & 0xFF000000) << (1*8))  |    \
+                     ((_tmp_ & 0x00FF0000) << (3*8))  |    \
+                     ((_tmp_ & 0x0000FF00) << (5*8))  |    \
+                     ((_tmp_ & 0x000000FF) << (7*8));      \
+}
+
+
+#define  Swap_Bytes4(_x4_)                                 \
+{                                                          \
+  uint_4 _tmp_ = *(uint_4*)(_x4_);                         \
+  *(uint_4*)(_x4_) = ((_tmp_ >> 24) & 0x000000FF) |        \
+                     ((_tmp_ >> 8)  & 0x0000FF00) |        \
+                     ((_tmp_ & 0x0000FF00) << 8)  |        \
+                     ((_tmp_ & 0x000000FF) << 24);         \
+}
+
+
+#define  Swap_Bytes2(_x2_)                                 \
+{                                                          \
+  uint_2 _tmp_ = *(uint_2*)(_x2_);                         \
+  *(uint_2*)(_x2_) = ((_tmp_ >> 8) & 0x00FF) |             \
+                     ((_tmp_ & 0x00FF) << 8);              \
+}
+
+#endif
Index: trunk/FrEROS/AnaLC/transfost.c
===================================================================
--- trunk/FrEROS/AnaLC/transfost.c	(revision 3308)
+++ trunk/FrEROS/AnaLC/transfost.c	(revision 3308)
@@ -0,0 +1,109 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "machdefs.h"
+#include "fmath.h"
+
+#include "transfost.h"
+
+/* Nouvelle-Fonction */
+void PrintTransfo(TRANSFO *tr)
+
+/*  Impression des coefficients du 1er ordre  */
+{
+int k;
+char sg[3],sgp[3],*st[2];
+
+strcpy(sg,"XY"); strcpy(sgp,"xy");
+st[0] = "Source";  st[1] = "Dest";
+
+printf("PrintTransfo:  Degre = %d (Coeff d'ordre 1) \n", tr->DegPolxy); 
+for(k=0; k<2; k++)
+  printf(" T%c %c = %10.5f  + %10.5f x + %10.5f y \n", sgp[k], sg[k], 
+         tr->Polxy[0][0][k], tr->Polxy[1][0][k], tr->Polxy[0][1][k]);
+
+for(k=0; k<2; k++)
+  {
+  printf("Lim[%6s] MidX,Y= %10g %10g  LargX,Y= %10g %10g\n",
+         st[k],tr->midx[k], tr->midy[k], tr->largx[k], tr->largy[k]);
+  printf("   XMin,Max= %10g %10g   YMin,Max= %10g %10g \n",
+         tr->xmin[k], tr->xmax[k], tr->ymin[k], tr->ymax[k]);
+  }
+
+return;
+}
+
+
+/* Nouvelle-Fonction */
+void RedCord(double x, double y, double *xr, double *yr, TRANSFO *transf, int i)
+{
+  *xr = (x - transf->midx[i]) / transf->largx[i];
+  *yr = (y - transf->midy[i]) / transf->largy[i];
+}
+
+
+/* Nouvelle-Fonction */
+void ExpCord(double xr, double yr, double *x, double *y, TRANSFO *transf, int i)
+{
+  *x = transf->largx[i] * xr + transf->midx[i];
+  *y = transf->largy[i] * yr + transf->midy[i];
+}
+
+
+/* Nouvelle-Fonction */
+void CordTransf(double xS, double yS, double *xD, double *yD, TRANSFO *transf)
+{
+  double xi,yi,xo,yo,xk,yl;
+  int k,l;
+
+  RedCord(xS,yS,&xi,&yi,transf,0);
+  if (transf->DegPolxy == 1) {
+    xo = transf->Polxy[0][0][0] + transf->Polxy[1][0][0]*xi + transf->Polxy[0][1][0]*yi;
+    yo = transf->Polxy[0][0][1] + transf->Polxy[1][0][1]*xi + transf->Polxy[0][1][1]*yi;
+    }
+  else {
+    xo = yo = 0.0;
+    xk = 1.0;
+    for (k = 0; k<=transf->DegPolxy; k++) {
+      yl = 1.0;
+      for (l = 0; l<=transf->DegPolxy-k; l++) {
+        xo += transf->Polxy[k][l][0]*xk*yl;
+        yo += transf->Polxy[k][l][1]*xk*yl;
+        yl *= yi;
+      }
+      xk *= xi;
+    }
+  }
+  ExpCord(xo,yo,xD,yD,transf,1);
+}
+
+
+/* Nouvelle-Fonction */
+void CordTransfEros2(double xS,double yS,double *xD,double *yD,TRANSFO *transf)
+/*
+Dans Eros2 les infos concernant les coordonnees reduites sont codees
+dans TRANSFO mais la transformation est donnee pour les coordonnees normales
+*/
+{
+  double xk,yl;
+  int k,l;
+
+  if (transf->DegPolxy == 1) {
+    *xD = transf->Polxy[0][0][0] + transf->Polxy[1][0][0]*xS + transf->Polxy[0][1][0]*yS;
+    *yD = transf->Polxy[0][0][1] + transf->Polxy[1][0][1]*xS + transf->Polxy[0][1][1]*yS;
+    }
+  else {
+    *xD = *yD = 0.0;
+    xk = 1.0;
+    for (k = 0; k<=transf->DegPolxy; k++) {
+      yl = 1.0;
+      for (l = 0; l<=transf->DegPolxy-k; l++) {
+        *xD += transf->Polxy[k][l][0]*xk*yl;
+        *yD += transf->Polxy[k][l][1]*xk*yl;
+        yl *= yS;
+      }
+      xk *= xS;
+    }
+  }
+}
Index: trunk/FrEROS/AnaLC/transfost.h
===================================================================
--- trunk/FrEROS/AnaLC/transfost.h	(revision 3308)
+++ trunk/FrEROS/AnaLC/transfost.h	(revision 3308)
@@ -0,0 +1,31 @@
+/*   Decalaration des structures transfo        */
+/*                Eric Aubourg   03/94          */
+/*                R.A. + CMV     06/94          */
+
+#ifndef TRANSFOST_H_SEEN   
+#define TRANSFOST_H_SEEN   
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  double Polxy[5][5][2];
+  int_4 DegPolxy;
+  double largx[2],largy[2],midx[2],midy[2]; /* 0 pour source, 1 pour dest */
+  double xmin[2],xmax[2],ymin[2],ymax[2];
+} TRANSFO;
+
+void PrintTransfo(TRANSFO *tr);
+void RedCord(double x, double y, double *xr, double *yr, TRANSFO *transf, int i);
+void ExpCord(double xr, double yr, double *x, double *y, TRANSFO *transf, int i);
+void CordTransf(double xS, double yS, double *xD, double *yD, TRANSFO *transf);
+void CordTransfEros2(double xS,double yS,double *xD,double *yD,TRANSFO *transf);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 
+
