Index: trunk/ArchTOIPipe/ProcWSophya/simtoipr.cc
===================================================================
--- trunk/ArchTOIPipe/ProcWSophya/simtoipr.cc	(revision 1478)
+++ trunk/ArchTOIPipe/ProcWSophya/simtoipr.cc	(revision 1479)
@@ -5,9 +5,10 @@
 #include "pexceptions.h"
 #include "ctimer.h"
-
-SimpleDeglitcher::SimpleDeglitcher(int wsz, double ns, int maxnpt)
+#include "fftpserver.h"
+
+SimpleDeglitcher::SimpleDeglitcher(int wsz, double ns, int maxnpt, int minnpt)
 {
   SetWSize(wsz);
-  SetDetectionParam(ns, ns/2., maxnpt);
+  SetDetectionParam(ns, ns/2., maxnpt, minnpt);
   SetRange(-9.e39, 9.e39);
   RepBadSamples(true, true);
@@ -24,9 +25,11 @@
 }
 
-void SimpleDeglitcher::SetDetectionParam(double ns, double ns2, int maxnpt, int wszrec)
+void SimpleDeglitcher::SetDetectionParam(double ns, double ns2, int maxnpt, 
+					 int minnpt, int wszrec)
 {
   nsig = (ns > 0.01) ? ns : 1.;
   nsig2 = (ns2 > 0.01) ? ns2 : nsig/2.;
   maxpoints = ((maxnpt > 0) && (maxnpt <= wsize)) ? maxnpt : 5;
+  minpoints = ((minnpt > 0) && (minnpt <= maxpoints)) ? minnpt : maxpoints/2;
   wrecsize = ((wszrec > 0) && (wszrec <= wsize)) ? wszrec : 2*maxpoints;
 }
@@ -42,6 +45,7 @@
   os << "\n ------------------------------------------------------ \n" 
      << " SimpleDeglitcher::PrintStatus() - WindowSize=" << WSize() 
-     << "  NbSigmas=" << NbSigmas() << " MaxPoints=" << MaxPoints() << endl;
-  os << "  NbSigmas2=" << NbSigmas2() << "  WRecSize= " << WRecSize() 
+     << " MaxPoints=" << MaxPoints() << " MinPoints=" << MinPoints() << endl;
+  os << " NbSigmas=" << NbSigmas() 
+     << "  NbSigmas2=" << NbSigmas2() << "  WRecSize= " << WRecSize() 
      << "  Range_Min= " << range_min << " Range_Max= " << range_max << endl;
   os << "  RepOutOfRangeSamples: " << _Bool2YesNo(rec_out_range_samples) 
@@ -117,5 +121,5 @@
       getData(0, k+snb, vin(k), vfg(k));
 
-    int nokdebut = 0.;
+    int nokdebut = 0;
     double s = 0.;    
     double mean = 0.;
@@ -236,5 +240,6 @@
       if (valcur < mean+curnsig*sigma) {  // inferieur au seuil
 	if (fgglitch) {  
-	  if (k-kgl < maxpoints) {   // On vient de detecter un glitch
+	  if ( (k-kgl <= maxpoints) && (k-kgl >= minpoints) ) {   
+	    // On vient de detecter un glitch
 	    glcount++;
 	    if (rec_gl_samples) { // On change la valeur des samples
@@ -253,5 +258,5 @@
 	    lastput = snb+k-1;
 	  }  // - Fin de detection de glitch
-	  else {  // Trop long - ce n'est pas un glitch ...
+	  else {  // Trop long ou trop court - ce n'est pas un glitch ...
 	    for(ii=kgl; ii<k; ii++) {
 	      putData(0, ii+snb, vin(ii%wsize), vfg(ii%wsize));
@@ -267,5 +272,5 @@
       else {  // Superieur au seuil
 	if (fgglitch) {
-	  if (k-kgl+1 >= maxpoints) {  // serie de points > seuil
+	  if (k-kgl+1 > maxpoints) {  // serie de points > seuil
 	    for(ii=kgl; ii<=k; ii++)   // -> Donc pas glitch
 	      putData(0, ii+snb, vin(ii%wsize), vfg(ii%wsize));
@@ -600,4 +605,126 @@
 }
 
+// ----------------------------------------------------------------------
+//   Classe SimpleFourierFilter : Filtre simple ds le domaine de Fourier
+// ----------------------------------------------------------------------
+
+SimpleFourierFilter::SimpleFourierFilter(Vector const & vc)
+{
+  ffcoef = vc;
+  wsize = (ffcoef.Size()-1)*2;
+  if (wsize < 16) 
+    throw ParmError("SimpleFourierFilter::SimpleFourierFilter() WSize<16 !");
+  KeepSpectra(0);
+}
+
+SimpleFourierFilter::~SimpleFourierFilter()
+{
+}
+
+
+void SimpleFourierFilter::PrintStatus(ostream & os)
+{
+  os << "\n ------------------------------------------------------ \n" 
+     << " SimpleFourierFilter::PrintStatus() - WindowSize=" 
+     << WSize() << endl; 
+  TOIProcessor::PrintStatus(os);
+  os << " Coeff= " << ffcoef << endl;
+  os << " ProcessedSampleCount=" << ProcessedSampleCount() << endl;
+  os << " ------------------------------------------------------ " << endl;
+}
+
+void SimpleFourierFilter::init() {
+  cout << "SimpleFourierFFilter::init" << endl;
+  declareInput("in");
+  declareOutput("out");
+  declareOutput("incopie");
+  name = "SimpleFourierFilter";
+  //  upExtra = 1;
+}
+
+
+void SimpleFourierFilter::run() {
+  //  TOIManager* mgr = TOIManager::getManager();
+  int snb = getMinIn();
+  int sne = getMaxIn();
+
+  bool fgout = checkOutputTOIIndex(0);
+  bool fgincopie = checkOutputTOIIndex(1);
+
+  if (!checkInputTOIIndex(0)) {
+    cerr << " SimpleFourierFilter::run() - Input TOI (in) not connected! "
+	 << endl;
+    throw ParmError("SimpleFourierFilter::run() Input TOI (in) not connected!");
+  }
+  if (!fgout) {
+    cerr << " SimpleFourierFilter::run() - No Output TOI connected! "
+	 << endl;
+    throw ParmError("SimpleFourierFilter::run() No output TOI connected!");
+  }
+
+  cout << " SimpleFourierFilter::run() SNRange=" << snb << " - " << sne << endl; 
+  
+
+  try {
+    Timer tm("SimpleFourierFilter::run()");
+    // Le debut
+    Vector vin(wsize);
+    Vector vout(wsize);
+    TVector<int_8> vfg(wsize);
+    TVector< complex<r_8> > vfft;
+    TVector< complex<r_8> > zcoef(ffcoef.Size());
+    zcoef = ffcoef;
+
+
+    FFTPackServer ffts;
+    ffts.setNormalize(true);
+    // Boucle sur les sampleNum
+
+    int k,i,klast;
+    int nks = 0;
+
+    klast = snb-1;
+    // 1er partie, on traite par paquets de wsize
+    for(k=snb;k<=sne-wsize+1;k+=wsize) {
+      for(i=0; i<wsize; i++) 
+	getData(0, k+i, vin(i), vfg(i));
+      ffts.FFTForward(vin, vfft);
+      if (nks < nb_keep) {
+	string dbgfile = "ffiltdbg" + (string)MuTyV(nks) + ".ppf";
+	POutPersist po(dbgfile);
+	po << vfft; 
+	nks++;
+      }
+      vfft.MulElt(zcoef);
+      ffts.FFTBackward(vfft, vout);
+      for(i=0; i<wsize; i++) 
+	putData(0,k+i,vout(i),vfg(i));
+      if (fgincopie) 
+	for(i=0; i<wsize; i++) 
+	  putData(1, k+i, vin(i), vfg(i));
+      klast+=wsize;
+      totnscount+=wsize;
+    }
+    
+
+    // 2eme partie, on traite la fin du bloc d'echantillons si necessaire
+    double inval;
+    int_8 inflg;
+    if (klast < sne) 
+      for(k=klast+1; k<=sne; k++) {
+	getData(0, k, inval, inflg);
+	putData(0, k, inval, inflg);
+	if (fgincopie) 
+	  putData(1, k, inval, inflg);
+	totnscount++;
+      }
+    cout << " SimpleFourierFilter::run() - End of processing " << endl;
+  }  // Bloc try 
+
+  catch (PException & exc) {
+    cerr << "SimpleFourierFilter: Catched Exception " << (string)typeid(exc).name()
+         << "\n .... Msg= " << exc.Msg() << endl;
+  }                                                                             
+}
 
 // ---------------------------------------------------------------
@@ -659,5 +786,4 @@
   out_index = -1;
   int nbconin = 0;
-  bool fggin = false;
   char buff[64];
   for(int ki=0;ki<nb_input;ki++) {
Index: trunk/ArchTOIPipe/ProcWSophya/simtoipr.h
===================================================================
--- trunk/ArchTOIPipe/ProcWSophya/simtoipr.h	(revision 1478)
+++ trunk/ArchTOIPipe/ProcWSophya/simtoipr.h	(revision 1479)
@@ -14,5 +14,6 @@
 class SimpleDeglitcher : public TOIProcessor {
 public:
-		SimpleDeglitcher(int wsz=64, double ns=3, int maxnpt=5);
+		SimpleDeglitcher(int wsz=64, double ns=3, 
+				 int maxnpt=5, int minnpt=2);
   virtual	~SimpleDeglitcher();
 
@@ -26,5 +27,6 @@
 
 
-  void          SetDetectionParam(double ns, double ns2, int maxnpt, int wszrec=0);
+  void          SetDetectionParam(double ns, double ns2, int maxnpt, 
+				  int minnpt, int wszrec=0);
     
   inline void   RepBadSamples(bool gl_samples, bool out_range_samples, bool use_wrec=true)
@@ -40,4 +42,5 @@
   inline double NbSigmas2() const { return nsig2; }
   inline int	MaxPoints() const { return maxpoints; }
+  inline int	MinPoints() const { return minpoints; }
   
   inline int_8	ProcessedSampleCount() const { return totnscount; }
@@ -61,4 +64,5 @@
   double nsig2;     // Seuil en nb de sigmas, pour les points suivants le 1er
   int maxpoints;    // Nb maxi de points > ns sigmas
+  int minpoints;    // Nb mini de points > ns sigmas pour avoir un glitch
   double range_min, range_max;  // Range acceptable pour in
 
@@ -136,6 +140,34 @@
 
 
+//  Un filtre simple, dans le domaine de Fourier
+//  InverseFFT ( FFT(Vecteur(in)) * FilterCoefficient )
+
+class SimpleFourierFilter : public TOIProcessor {
+public:
+                SimpleFourierFilter(Vector const & vc);  
+		~SimpleFourierFilter();
+
+  inline int	WSize() const { return wsize; }
+  inline int_8	ProcessedSampleCount() const { return totnscount; }
+  inline Vector FilterCoefficients() const
+                { Vector rcv; rcv = ffcoef; return(rcv); } 
+
+  virtual void  PrintStatus(ostream & os) ; // const plus tard
+
+  virtual void	init();  
+  virtual void	run();
+
+  inline  void  KeepSpectra(int nb=0) 
+                { nb_keep = nb; }
+protected:
+  int_8 totnscount;   // Nombre total d'echantillon processe
+  int wsize;         // Taille de fenetre de travail
+  Vector ffcoef;     // Coefficients du filtre
+  int nb_keep;
+};
+
+
 //  Classe SimpleFanOut
-//  Transforme recopie chaque entree sur M lignes de sortie
+//  Recopie chaque entree sur M lignes de sortie
 
 class SimpleFanOut : public TOIProcessor {
@@ -159,3 +191,4 @@
 };
 
+
 #endif
