Index: /trunk/AddOn/TAcq/acqparam_exemple.d
===================================================================
--- /trunk/AddOn/TAcq/acqparam_exemple.d	(revision 3680)
+++ /trunk/AddOn/TAcq/acqparam_exemple.d	(revision 3681)
@@ -34,8 +34,14 @@
 @memmgr  4,128
 #  Parametres traitement au vol optionnnel (monitoring)
-#  @monitor  NMaxBlocProc  
-#  Par defaut  @monitor 0
-@monitor 0
+#  @monitor  NMean  Step  NMaxBlocProc 
+#  Par defaut NoMonitoring   @monitor 512 10 0
+@monitor 0  384 4 
 #  Reduction des tailles de paquets si cle present
 #  @reducpaqsz ReducedSize Offset 
 reducpaqsz 1024 0 
+#  Pour desactiver l'ecriture des fichiers FITS
+#  @nosavesigfits
+nosavesigfits
+#  Taux de perte de paquets en simulation (Sans carte PCIExpress) 
+#  @nopcilossrate Perte     (0<=Perte<1)
+#  Defaut @nopcilossrate 0. 
Index: /trunk/AddOn/TAcq/brparam.cc
===================================================================
--- /trunk/AddOn/TAcq/brparam.cc	(revision 3680)
+++ /trunk/AddOn/TAcq/brparam.cc	(revision 3681)
@@ -94,8 +94,12 @@
 
 /* --Methode-- */
-BRParList::BRParList(string fibres,unsigned int paqsz ,unsigned int dmaszkb, 
-		     int nfiles, string acqmod,int nblocfile,int nmxproc ,
-		     string outpath, uint_4 nzon , uint_4 npaqzon, bool fgcntlc)
-{
+BRParList::BRParList(string acqmod, string fibres,unsigned int paqsz, 
+		     unsigned int dmaszkb, int nfiles, int nblocfile,
+		     string outpath, uint_4 nzon , uint_4 npaqzon)
+{
+  AcqMode=acqmod;
+  fgdatafft=false;
+  fgsinglechannel=false;
+
   FiberListS=fibres;
   NbFibers=0;
@@ -103,16 +107,17 @@
   PaqSize=paqsz;
   dmasizekb=dmaszkb;
+
   NbFiles=nfiles;
-  AcqMode=acqmod;
   NBlocPerFile=nblocfile;
-  NMaxProc=nmxproc;
   OutPathName=outpath;
+
   nZones=nzon;
   nPaqZone=npaqzon;
+
   swapall=BR_Copy;
   savesigfits=true;
   fgnulldev4fits=false;
 
-  fg_hard_ctrlc=fgcntlc;
+  fg_hard_ctrlc=false;
 
   fgreducpsize=false;
@@ -123,6 +128,13 @@
 
   skysource="";
+
+  fgdoProc=false;
+  nmeanProc=512;
+  stepProc=5;
+  nmaxProc=0;
+
   monothr=false;
   activate_pattern=false;
+  nopciLossRate=0.;
 
   Decode();    // On decode et on complete les parametres 
@@ -138,16 +150,22 @@
 void BRParList::Set(BRParList const & p)
 {
+  AcqMode=p.AcqMode;
+  fgdatafft=p.fgdatafft;
+  fgsinglechannel=p.fgsinglechannel;
+
   FiberListS=p.FiberListS;
   NbFibers=p.NbFibers;
   for (int fib=0; fib<PMAXNBFIBRES;fib++)  FiberNum[fib]=p.FiberNum[fib];
+
   PaqSize=p.PaqSize;
   dmasizekb=p.dmasizekb;
+
   NbFiles=p.NbFiles;
-  AcqMode=p.AcqMode;
   NBlocPerFile=p.NBlocPerFile;
-  NMaxProc=p.NMaxProc;
   OutPathName=p.OutPathName;
+
   nZones=p.nZones;
   nPaqZone=p.nPaqZone;
+
   swapall=p.swapall;
   savesigfits=p.savesigfits;
@@ -163,7 +181,14 @@
 
   skysource=p.skysource;
+  
+  fgdoProc=p.fgdoProc;
+  nmeanProc=p.nmeanProc;
+  stepProc=p.stepProc;
+  nmaxProc=p.nmaxProc;
 
   monothr=p.monothr;
   activate_pattern=p.activate_pattern;
+
+  nopciLossRate=p.nopciLossRate;
   return;
 }
@@ -188,7 +213,14 @@
     reducoffset=(uint_4)conf.IParam("reducpaqsz",1,0);
   }
-  NMaxProc=conf.IParam("monitor",0,0);
+  if (conf.HasKey("monitor")) {
+    fgdoProc=true;
+    nmeanProc=conf.IParam("monitor",0,512);
+    stepProc=conf.IParam("monitor",1,10);
+    nmaxProc=conf.IParam("monitor",2,0);
+  }
+  nopciLossRate=conf.DParam("nopcilossrate",0,0.);
+
   fg_hard_ctrlc=conf.HasKey("hard_ctrlc");
-
+  if (conf.HasKey("nosavesigfits"))  savesigfits=false;
   Decode();
 }
@@ -212,6 +244,7 @@
   }
   string acqmode = AcqMode;
+  fgdatafft=false;  fgsinglechannel=false;
   reducneedcopy=false;  pqreducmode=BR_TwoChanReduc;
-  if (acqmode == "std")   swapall = BR_Copy ;  
+  if ((acqmode == "std")||(acqmode=="raw2c"))   swapall = BR_Copy ;  
   if (acqmode == "nosw")   swapall = BR_Copy ;
   if (acqmode == "nof")  { swapall = BR_Copy ; savesigfits = false; }
@@ -254,4 +287,11 @@
     { swapall = BR_FFTTwoChanSwap32;  savesigfits = false; reducneedcopy=true;  pqreducmode=BR_TwoChanReducK0; }
 
+  if ((swapall==BR_FFTTwoChan)||(swapall==BR_FFTTwoChanSwapAll)||(swapall==BR_FFTTwoChanSwap32)) {
+    fgdatafft=true;  
+  }
+  if ((swapall==BR_FFTOneChan)||(swapall==BR_FFTOneChanSwapAll)||(swapall==BR_FFTOneChanSwap32)) {
+    fgdatafft=true;  fgsinglechannel=true; 
+  }
+  
   if (fgreducpsize) {
     if (redpqsize>=PaqSize) fgreducpsize=false;
@@ -280,4 +320,7 @@
     os << " PaquetSize Reduction, ReducedSize=" << redpqsize << " Offset=" << reducoffset << endl;
   }
+  if (fgdoProc>0) 
+    os << " Monitoring  NMeanProc=" << nmeanProc << " StepProc=" << stepProc << " NMaxProc=" << nmaxProc << endl;
+  else os << " No monotoring thread " << endl;
   os << " fg_hard_ctrlc=" << ((fg_hard_ctrlc)?"true":"false");
   os << " Save to fits " << ((savesigfits)?"true":"false") << endl;
Index: /trunk/AddOn/TAcq/brparam.h
===================================================================
--- /trunk/AddOn/TAcq/brparam.h	(revision 3680)
+++ /trunk/AddOn/TAcq/brparam.h	(revision 3681)
@@ -77,8 +77,7 @@
 class BRParList {
 public: 
-  BRParList (string fibres="1", unsigned int szframe= 16424, unsigned int dmaszkb = 32, 
-	     int nfiles=1, string acqmode="fft2c", int nblocfile=10,  
-	     int nmaxpr = 0, string outpath="TstAcq", 
-	     uint_4 nzon = 4, uint_4 npaqzon = 128, bool fgcntlc=false);
+  BRParList (string acqmode="fft2c", string fibres="1", unsigned int paqsz= 16424, 
+	     unsigned int dmaszkb = 32, int nfiles=1, int nblocfile=10, string outpath="TstAcq", 
+	     uint_4 nzon = 4, uint_4 npaqzon = 128);
 
   BRParList(BRParList const & p);
@@ -118,4 +117,7 @@
 
   string AcqMode;  // Mode d'acquisition (conditionne la mise en ordre/conversion des donnees lues par DMA 
+  bool fgdatafft;  // true -> donnee FFT (provenant du firmware FFT)
+  bool fgsinglechannel; // true -> un seul canal par fibre (par defaut=2 canaux/fibres)
+
   string FiberListS ;  // liste des fibres a utiliser 1,3,4 par exemple
   int NbFibers;  // liste des fibres a utiliser 1,3,4 par exemple
@@ -128,5 +130,4 @@
   int NbFiles; // nombre de fichier produits
   int NBlocPerFile; // nombre de bloc par fichier
-  int NMaxProc;  // Nombre de blocs traites par le thread de calcul
   // Gestionnaire zones memoire 
   uint_4 nZones;  // Nombre de zones memoires
@@ -149,4 +150,11 @@
   // Identification source observee dans le ciel
   string skysource;
+
+  //  Variables pour le traitement/monitoring 
+  bool fgdoProc;    // false -> pas de thread de monitoring 
+  uint_4 nmeanProc;  // nombre de paquets moyennes par le thread de traitement/monitoring 
+  uint_4 stepProc;  // 1/stepProc zones traite - si =0 -> fraction de paquets traites depend de la puissance disponible
+  uint_4 nmaxProc;  // Nombre de blocs traites par le thread de traitement/monitoring (0-> MaxNbBlocs())
+ 
   // Pour des tests de performances ou sans carte ADC (pattern) 
   bool monothr ;           // pour les test mono thread 
Index: /trunk/AddOn/TAcq/mfacq.cc
===================================================================
--- /trunk/AddOn/TAcq/mfacq.cc	(revision 3680)
+++ /trunk/AddOn/TAcq/mfacq.cc	(revision 3681)
@@ -124,9 +124,12 @@
   RAcqMemZoneMgr mmgr(acpar.nZones, bpar.NFibers(), acpar.nPaqZone, acpar.MMgrPaquetSize());
   pMmgr=&mmgr;  
-  int stepproc = 2;  
-  int nmean = acpar.nPaqZone*acpar.NBlocPerFile/stepproc;
-
+  if (acpar.fgdoProc && (acpar.stepProc>0)) {
+    // Dans ce cas, toutes les zones doivent passer ds le thread de monitoring 
+    // pour etre au moins marque comme traite - seul 1/acpar.stepProc sont effectivement traite 
+    mmgr.SetFinalizedMask(((uint_4)MemZS_Saved) | ((uint_4)MemZS_Proc));
+    cout << " mfacq[1.b]/Info: Mmgr.SetFinalizedMask( MemZS_Saved | MemZS_Proc )" << endl;
+  }
+  
 #ifndef NOPCIECARD  
-
   for (int i=0 ;i <acpar.NFibers() ;i++) {
     UINT32 card=(acpar.FiberNum[i]-1)/2+1;
@@ -147,24 +150,28 @@
 #endif 
 
-  cout <<"mfacq[3] Creating DataSaver and DataProc2C objects ... " << endl;
+  cout <<"mfacq[2] Creating MultiDataSaver and  MonitorProc thread objects ... " << endl;
   MultiDataSaver DsThr(mmgr);   //   Utilise les parametres globaux BRAcqConfig
   string ppath=bpar.OutputDirectory();
-  DataProc2C PrThr(mmgr, ppath, 1280, stepproc, acpar.NMaxProc);
+  MonitorProc PrThr(mmgr);
   vector<PCIEWrapperInterface*> vec_pciw;
   for  (int i=0 ;i<bpar.NFibers();i++)  vec_pciw.push_back( pciwp[i]);
-  cout << "mfacq[3] Creating   PCIEMultiReader       " << endl;
+  cout << "mfacq[3] Creating   PCIEMultiReader thread object     " << endl;
   PCIEMultiReader PcierThr(vec_pciw, mmgr, bpar.GetParams());
-  usleep(200);  // attente au cas ou ...
+  //  usleep(200);  attente au cas ou ...
   pPcierThr=&PcierThr;
   tm.Split("Threads created");  
-  cout << "mfacq[4] - starting 3 threads pcir, ds, pr ... " << endl;
+  if (acpar.fgdoProc>0) 
+    cout << "mfacq[4] - starting three threads: PCIEMultiReader, MultiDataSaver, MonitorProc ... " << endl;
+  else 
+    cout << "mfacq[4] - starting two threads: PCIEMultiReader, MultiDataSaver  ... " << endl;
+
   PcierThr.start();
   DsThr.start();
-  if (acpar.NMaxProc>0) { // On ne demarre que si au moins NMaxProc>0
+  if (acpar.fgdoProc>0) { // On ne demarre que si au moins NMaxProc>0
     PrThr.start();
   }
   
   // On attend avant de declencher la terminaison des threads
-  usleep(100000);
+  usleep(200000);
   
   cout << "mfacq[5] -  Waiting for threads to finish ... " << endl;  
@@ -172,5 +179,5 @@
   DsThr.join();
   mmgr.Stop();
-  if (acpar.NMaxProc>0) { // On ne demarre que si au moins NMaxProc>0
+  if (acpar.fgdoProc) { // On n'attend la fin que si le thread a ete demarre (NMaxProc>0)
     PrThr.join();
   }
@@ -179,4 +186,5 @@
   tm.Split("Threads Finished");  
  
+  mmgr.Print(cout);
 #ifndef NOPCIECARD
   for (int i=0 ;i <acpar.NbFibers ;i++) {
Index: /trunk/AddOn/TAcq/racquproc.cc
===================================================================
--- /trunk/AddOn/TAcq/racquproc.cc	(revision 3680)
+++ /trunk/AddOn/TAcq/racquproc.cc	(revision 3681)
@@ -1,3 +1,8 @@
 #include "racquproc.h"
+
+/* ----------------------------------------
+     Projet BAORadio --- LAL 
+     2008 - 2010 
+-------------------------------------------  */
 
 #include <stdlib.h>
@@ -19,6 +24,308 @@
 #include "brpaqu.h"
 #include "minifits.h"
-struct sigaction act;
-
+
+/* Fonction, module^2 des nombres complexes */
+static inline r_4 Zmod2(complex<r_4> z) 
+{ return (z.real()*z.real()+z.imag()*z.imag()); }
+static inline r_8 Zmod2(complex<r_8> z) 
+{ return (z.real()*z.real()+z.imag()*z.imag()); }
+static inline r_4 Zmod2(TwoByteComplex z) 
+{ return ((r_4)z.realB()*(r_4)z.realB()+(r_4)z.imagB()*(r_4)z.imagB()); }
+
+//---------------------------------------------------------------------
+// Classe thread de traitement/monitoring multifibre Raw/FFT 
+//---------------------------------------------------------------------
+/* --Methode-- */
+MonitorProc::MonitorProc(RAcqMemZoneMgr& mem)
+  :  memgr(mem) 
+{
+  BRAcqConfig bpar;
+  par_.Set(bpar.GetParams());
+  nmax_ = par_.nmaxProc; 
+  if (nmax_==0) nmax_=par_.MaxNbBlocs();
+  nmean_ = par_.nmeanProc;
+  step_ = par_.stepProc;
+  stop_ = false;	
+  path_ = bpar.OutputDirectory();
+  nfiles_ = 0;
+  nblocproc_ = 0;
+  nprocpaq_=0;
+  npaqsamefc_=0;
+  totnprocpaq_=0;
+  totnpaqsamefc_=0;
+  curfc_.SetSize(memgr.NbFibres(), memgr.NbPaquets());
+  cpaqok_.SetSize(memgr.NbFibres(), memgr.NbPaquets());
+}
+
+/* --Methode-- */
+MonitorProc::~MonitorProc()
+{
+  //  cout << " **** DBG ***** MonitorProc::~MonitorProc() " << endl;
+}
+
+/* --Methode-- */
+void MonitorProc::Stop()
+{
+ stop_=true;
+}
+
+/* --Methode-- */
+void MonitorProc::run()
+{
+  setRC(1);	
+  int rc=0;
+  try {
+    TimeStamp ts; 
+    cout << " MonitorProc::run() - Starting " << ts << " NMaxMemZones=" << nmax_ 
+	 << " NMean=" << nmean_ << " Step=" << step_ << endl;	
+    cout << " MonitorProc::run()... - Output Data Path: " << path_ << endl;
+    char fname[512];
+    sprintf(fname,"%s/monproc.log",path_.c_str());
+    ofstream filog(fname);
+    filog << " MonitorProc::run() - starting log file " << ts << endl;		       
+    filog << " ... NMaxMemZones=" << nmax_ << " NMean=" << nmean_ << " Step=" << step_ << endl;	
+    uint_4 paqsz = memgr.PaqSize();
+    BRPaquet pq(paqsz); 
+    if (par_.fgsinglechannel) {
+      spectre_.SetSize(memgr.NbFibres(), pq.DataSize()/2);
+      for(int kc=0; kc<memgr.NbFibres(); kc++)  nzm_.push_back(0);
+      rc=procData1C(filog);
+    }
+    else {
+      spectre_.SetSize(2*memgr.NbFibres(), pq.DataSize()/4);
+      for(int kc=0; kc<2*memgr.NbFibres(); kc++)  nzm_.push_back(0);
+      rc=procData2C(filog);
+    }
+    cout << " ---- MonitorProc::run()/End NBlocProcessed=" << nblocproc_ 
+	  << " NFiles=" << nfiles_ << " Rc=" << rc << endl;
+    ts.SetNow();
+    filog << " ---- MonitorProc::run()/End " << ts << endl;
+    filog << " --------- MonitorProc::run()/End NBlocProcessed=" << nblocproc_ 
+	  << " NFiles=" << nfiles_ << " Rc=" << rc << endl;
+  }
+  catch (std::exception& exc) {
+    cout << " MonitorProc::run()/catched std::exception " << exc.what() << endl;
+    setRC(98);	
+    return; 
+  }
+  catch(...) {
+    cout << " MonitorProc::run()/catched unknown ... exception " << endl;
+    setRC(99);	
+    return; 
+  }
+
+  setRC(rc);
+  return;
+}   
+
+/* --Methode-- */
+int MonitorProc::procData1C(ofstream& logf)
+{
+  cout << " MonitorProc::procData1C() - NOT IMPLEMENTED -> Rc=67" << endl;
+  logf << " MonitorProc::procData1C() - NOT IMPLEMENTED -> Rc=67" << endl;
+  return 67;  
+}
+
+/* --Methode-- */
+int MonitorProc::procData2C(ofstream& filog)
+{
+  BRPaqChecker pcheck[MAXNBFIB];  // Verification/comptage des paquets 
+// Initialisation pour calcul FFT 
+  uint_4 paqsz = memgr.PaqSize();
+  BRPaquet pq(paqsz); 
+  TVector<r_4> vx(pq.DataSize()/2);
+  vx = (r_4)(0.);
+  TVector< complex<r_4> > cfour(pq.DataSize()/4+1);  // composant TF
+  
+  fftwf_plan plan = fftwf_plan_dft_r2c_1d(vx.Size(), vx.Data(), 
+					  (fftwf_complex *)cfour.Data(), FFTW_ESTIMATE); 
+  TimeStamp ts;   
+  char fname[512];
+  nfiles_ = 0;  			        
+  for (uint_4 kmz=0; kmz<nmax_; kmz++) {
+    if (stop_) break;
+    if (memgr.GetRunState() == MemZR_Stopped) break;
+
+    int mid = memgr.FindMemZoneId(MemZA_Proc);
+    Byte* buffg = memgr.GetMemZone(mid);
+    if (buffg == NULL) {
+      cout << " MonitorProc::procData2C()/ERROR memgr.GetMemZone(" << mid << ") -> NULL" << endl;
+      break;	
+    }
+    if ((step_>1)&&(kmz%step_ != 0))  {
+      memgr.FreeMemZone(mid, MemZS_Proc);
+      continue;
+    }
+    sa_size_t lc=0;
+    Byte* fbuff[MAXNBFIB];
+    for(uint_4 fib=0; fib<memgr.NbFibres(); fib++)  {  // Boucle sur les fibres 
+      fbuff[fib] = memgr.GetMemZone(mid,fib);
+      if (fbuff[fib] == NULL) { // cela ne devrait pas arriver 
+	cout << " MonitorProc::procData2C()/ERROR memgr.GetMemZone(" << mid << "," << fib << ") -> NULL" << endl;
+	return 9;	
+      }
+    }
+    
+    cpaqok_ = (uint_1)0;
+    curfc_ = (uint_8)0;
+    for(uint_4 fib=0; fib<memgr.NbFibres(); fib++) {
+      for(uint_4 i=0; i<memgr.NbPaquets(); i++) {
+	BRPaquet paq(fbuff[fib]+i*paqsz, paqsz); 
+	bool pqok=pcheck[fib].Check(paq,curfc_(fib,i));   // Verification du paquet / FrameCounter 
+	if (!pqok)  continue;
+	cpaqok_(fib,i) = 1;
+	sa_size_t lc=2*fib;
+	if (par_.fgdatafft) {    // Traitement data de type FFT 
+	  TwoByteComplex* tbcp=paq.Data1C();
+	  for(sa_size_t j=1; j<spectre_.NCols(); j++) 
+	    spectre_(lc,j) += Zmod2(tbcp[j]);
+	  nzm_[lc]++;	
+	  tbcp=paq.Data2C();
+	  for(sa_size_t j=1; j<spectre_.NCols(); j++) 
+	    spectre_(lc,j) += Zmod2(tbcp[j]);
+	  nzm_[lc+1]++;
+	}
+	else {   // Traitement RawData 
+	  for(sa_size_t j=0; j<vx.Size(); j++) 
+	    vx(j) = (r_4)(*(paq.Data1()+j))-127.5;
+	  fftwf_execute(plan); 
+	  //   ffts_.FFTForward(vx, cfour_);
+	  for(sa_size_t j=0; j<spectre_.NCols(); j++) 
+	    spectre_(lc,j) += Zmod2(cfour(j+1));
+	  nzm_[lc]++;
+	  for(sa_size_t j=0; j<vx.Size(); j++) 
+	    vx(j) = (r_4)(*(paq.Data2()+j))-127.5;
+	  fftwf_execute(plan); 
+	  //    ffts_.FFTForward(vx, cfour_);
+	  for(sa_size_t j=0; j<spectre_.NCols(); j++) 
+	    spectre_(lc,j) += Zmod2(cfour(j+1));
+	  nzm_[lc+1]++;
+	}	
+      }  // FIN de la boucle sur les paquets 
+    }   // Boucle sur les fibres 
+    memgr.FreeMemZone(mid, MemZS_Proc);
+    CheckFrameCounters();
+
+    nblocproc_ ++;   
+    totnprocpaq_ += memgr.NbPaquets();  nprocpaq_ += memgr.NbPaquets();
+    bool fgnzm=true;
+    for(int lc=0; lc<2*memgr.NbFibres(); lc++)  
+      if (nzm_[lc]<nmean_) fgnzm=false;
+    
+    if (fgnzm) {
+      char buff[32];
+      for(sa_size_t lc=0; lc<2*memgr.NbFibres(); lc++)  {
+	spectre_.Row(lc) /= (r_4)nzm_[lc];
+	sprintf(buff,"NPaqMoy%d",(int)lc);
+	spectre_.Info()[buff] = nzm_[lc];
+      }
+      sprintf(fname,"%s/meanspec%d.ppf",path_.c_str(),(int)nfiles_);
+      nfiles_++;
+      POutPersist po(fname);
+      po << PPFNameTag("spectre") << spectre_;       
+      spectre_ = (r_4)(0.);
+      for(int lc=0; lc<2*memgr.NbFibres(); lc++)  nzm_[lc]=0;
+      ts.SetNow();
+      // Calcul / impression fraction des paquets avec same-framecounter
+      int fracsame=0;
+      if (nprocpaq_>0)  fracsame=100*npaqsamefc_/nprocpaq_;
+      int totfracsame=0;
+      if (totnprocpaq_>0)  totfracsame=100*totnpaqsamefc_/totnprocpaq_;
+      filog << ts << " :  proc file (meanspectra) " << fname << endl;
+      filog << "  NBlocProcessed=" << nblocproc_ << " NSameFC=" << totnpaqsamefc_ << " / " << totnprocpaq_
+	    << " -> " << totfracsame << " % (LastPqs: " << npaqsamefc_ <<  " / " << nprocpaq_ 
+	    << " -> " << fracsame << " % )" << endl;
+      cout << " MonitorProc::procData2C() " << ts << " : created file  " << fname << endl;
+      cout << "  NBlocProcessed=" << nblocproc_ << " NSameFC=" << totnpaqsamefc_ << " / " << totnprocpaq_
+	   << " -> " << totfracsame << " % (LastPqs: " << npaqsamefc_ <<  " / " << nprocpaq_ 
+	   << " -> " << fracsame << " % )" << endl;
+      nprocpaq_=npaqsamefc_=0;
+    }
+  }   // Fin de boucle sur les kmz ( bloc MemZoneMgr  a traiter )
+
+  bool fgnzm=false;
+  for(int lc=0; lc<2*memgr.NbFibres(); lc++)  
+    if (nzm_[lc]>0) fgnzm=true;
+  
+  if (fgnzm) {
+    char buff[32];
+    for(sa_size_t lc=0; lc<2*memgr.NbFibres(); lc++)  {
+      if (nzm_[lc]>0)  spectre_.Row(lc) /= (r_4)nzm_[lc];
+      sprintf(buff,"NPaqMoy%d",(int)lc);
+      spectre_.Info()[buff] = nzm_[lc];
+    }
+    sprintf(fname,"%s/meanspec%d.ppf",path_.c_str(),(int)nfiles_);
+    POutPersist po(fname);
+    po << PPFNameTag("spectre") << spectre_;       
+    spectre_ = (r_4)(0.);
+    for(int lc=0; lc<2*memgr.NbFibres(); lc++)  nzm_[lc]=0;
+    ts.SetNow();
+    // Calcul / impression fraction des paquets avec same-framecounter
+    int fracsame=0;
+    if (nprocpaq_>0)  fracsame=100*npaqsamefc_/nprocpaq_;
+    int totfracsame=0;
+    if (totnprocpaq_>0)  totfracsame=100*totnpaqsamefc_/totnprocpaq_;
+    filog << ts << " :  proc file (meanspectra) " << fname << endl;		       
+    filog << "  NBlocProcessed=" << nblocproc_ << " NSameFC=" << totnpaqsamefc_ << " / " << totnprocpaq_
+	  << " -> " << totfracsame << " % (LastPqs: " << npaqsamefc_ <<  " / " << nprocpaq_ 
+	  << " -> " << fracsame << " % )" << endl;
+    cout << " MonitorProc::procData2C() " << ts << " : created file  " << fname << endl;
+    cout << "  NBlocProcessed=" << nblocproc_ << " NSameFC=" << totnpaqsamefc_ << " / " << totnprocpaq_
+	 << " -> " << totfracsame << " % (LastPqs: " << npaqsamefc_ <<  " / " << nprocpaq_ 
+	 << " -> " << fracsame << " % )" << endl;
+  }
+  return 0;
+}
+
+/* --Methode-- */
+int MonitorProc::CheckFrameCounters()
+{
+  if (memgr.NbFibres()<2)  { 
+    npaqsamefc_++;  totnpaqsamefc_++;
+    return 99;
+  }
+  sa_size_t  pidx[MAXNBFIB];
+  sa_size_t maxidx=curfc_.NCols();
+  uint_8 cfc=0;
+  for(uint_4 fib=0; fib<curfc_.NRows(); fib++) {
+    pidx[fib]=0;
+    while((pidx[fib]<maxidx)&&(cpaqok_(fib,pidx[fib])==0)) pidx[fib]++;
+  }
+
+  bool fgsuite=true;
+  while (fgsuite) {   // Boucle sur l'ensemble des paquets
+    for(uint_4 fib=0; fib<curfc_.NRows(); fib++)  {
+      if ((pidx[fib]>=maxidx)||(cpaqok_(fib,pidx[fib])==0))  { fgsuite=false; break; } 
+    }
+    if (!fgsuite) break;
+    cfc=curfc_(0,pidx[0]);
+    bool fgsame=true;
+    for(uint_4 fib=1; fib<curfc_.NRows(); fib++) {
+      if (curfc_(fib,pidx[fib])!=cfc) {
+	fgsame=false;
+	if (curfc_(fib,pidx[fib]) > cfc)  cfc=curfc_(fib,pidx[fib]);
+      }
+    }
+    if (fgsame) {
+      npaqsamefc_++;  totnpaqsamefc_++;
+      for(uint_4 fib=0; fib<curfc_.NRows(); fib++) {
+	pidx[fib]++;
+	while((pidx[fib]<maxidx)&&(cpaqok_(fib,pidx[fib])==0)) pidx[fib]++;
+      }
+    }   // fin if (fgsame) 
+    else {  // else !fgsame
+      for(uint_4 fib=0; fib<memgr.NbFibres(); fib++) {
+	if (curfc_(fib,pidx[fib])<cfc) {
+	  pidx[fib]++;
+	  while((pidx[fib]<maxidx)&&(cpaqok_(fib,pidx[fib])==0)) pidx[fib]++;
+	}
+      }
+    }   // fin de  else !fgsame 
+  }  // Fin de while sur l'ensemble des paquets
+  return 0;
+}
+
+
+static struct sigaction act;
 //-------------------------------------------------------
 // Classe thread de traitement  avec 1 voie par frame
@@ -42,6 +349,4 @@
 }
 
-static inline r_4 Zmod2(complex<r_4> z) 
-{ return (z.real()*z.real()+z.imag()*z.imag()); }
 
 void DataProc::Stop()
Index: /trunk/AddOn/TAcq/racquproc.h
===================================================================
--- /trunk/AddOn/TAcq/racquproc.h	(revision 3680)
+++ /trunk/AddOn/TAcq/racquproc.h	(revision 3681)
@@ -4,5 +4,10 @@
 //----------------------------------------------------------------
 // ---- classe de thread de traitememt  acquisition BAORadio -----
-// LAL -      R. Ansari - Juin/Juillet 2008 
+// LAL -      R. Ansari - 2008-2010
+//  A/ Juin 2008 - Juin 2009 
+//       Classes DataProc, DataProc2C, DataProcFFT2C avec des 
+//       threads de traitement mono-fibre
+//  B/ Novembre 2009 
+//    MonitorProc : Classe de traitement pour monitoring multifibres
 //----------------------------------------------------------------
 
@@ -14,10 +19,55 @@
 #include "sopnamsp.h"
 #include "zthread.h"
+#include "tmatrix.h"
 
 #include "brtypes.h"
+#include "brparam.h"
 
 using namespace std;
 
+// Quelques definitions globales
+// Nombre maximum de fibres geres par les classes MonitorProc
+#ifndef MAXNBFIB
+#define MAXNBFIB  4   
+#endif
 
+//---------------------------------------------------------------------
+// Classe thread de traitement/monitoring multifibre Raw/FFT 
+//---------------------------------------------------------------------
+class MonitorProc : public ZThread {
+public:	
+  MonitorProc(RAcqMemZoneMgr& mem);
+  virtual ~MonitorProc();
+  virtual void run(); 
+  void Stop();
+  inline void STOP() { stop_ = true; }	
+protected:
+  int procData2C(ofstream& logf);
+  int procData1C(ofstream& logf);
+  int CheckFrameCounters();
+
+  RAcqMemZoneMgr& memgr;
+  BRParList par_;
+  bool stop_;  
+  uint_4 nmax_;  // Nombre maxi de blocs MemZone traites
+  uint_4 step_;  // 1/step_ paquet traite ds chaque bloc
+  uint_4 nmean_;  // Nombre de blocs pour le calcul des moyennes 
+  string path_;
+  uint_4 nfiles_;
+  TMatrix<r_4> spectre_;
+  vector<uint_4> nzm_;
+  uint_4 nblocproc_;         // nombre total de bloc MemMgr traites 
+  uint_8 nprocpaq_;          // nombre de paquets traites entre deux mises a zero
+  uint_8 npaqsamefc_;        // nombre de paquets avec meme framecounter  entre deux mises a zero
+  uint_8 totnprocpaq_;       // nombre de paquets traites entre deux mises a zero
+  uint_8 totnpaqsamefc_;     // nombre de paquets avec meme framecounter  entre deux mises a zero
+  TMatrix<uint_8> curfc_;    // Numeros de FrameCounter dans le bloc
+  TMatrix<uint_1> cpaqok_;   // Paquets OK ou pas dans le bloc
+};
+
+
+//-------------------------------------------------------------------
+//--------  Premieres version - pour tmtacq.cc 
+//-------------------------------------------------------------------
 //-------------------------------------------------------------------
 // Classe thread de traitement avec 1 voie par frame (donnees brutes)
Index: /trunk/AddOn/TAcq/racqurw.h
===================================================================
--- /trunk/AddOn/TAcq/racqurw.h	(revision 3680)
+++ /trunk/AddOn/TAcq/racqurw.h	(revision 3681)
@@ -25,5 +25,7 @@
 // Quelques definitions globales
 // Nombre maximum de fibres geres par les classes MultiReader / MultiDiskWriter
+#ifndef MAXNBFIB
 #define MAXNBFIB  4   
+#endif
 
 //-------------------------------------------------------
