Changeset 3774 in Sophya

Timestamp:

May 17, 2010, 5:18:10 PM (15 years ago)

Author:

ansari

Message:

Ajout/modif classes (brproc.h,.cc) pour analyse de donnees BAORadio, Reza 17/05/2010

Location:

trunk/AddOn/TAcq

Files:

• branap.cc (modified) (1 diff)
• brbaseproc.cc (modified) (4 diffs)
• brbaseproc.h (modified) (2 diffs)
• brpaqu.h (modified) (1 diff)
• brproc.cc (modified) (5 diffs)
• brproc.h (modified) (1 diff)
• vismfib.cc (modified) (2 diffs)

trunk/AddOn/TAcq/branap.cc

@@ -120 +120 @@
     return 5;
   }
-  cout << " -act Action: cube3d or vis or viscktt  \n"
+  cout << " -act Action: cube3d or vis or viscktt or mspec \n"
        << "    cube3d: create 3D fits cubes, vis: compute visibilites,  \n" 
        << "    viscktt: compute visibilities and check TimeTag/FrameCounter\n "
+       << "    mspec: compute and save mean spectra for each channel \n "
        << " -out OutPath: Output directory name \n"
        << " -nmean NMean: Number of packet used for spectra/visibility computation \n"

trunk/AddOn/TAcq/brbaseproc.cc

@@ -17 +17 @@
 
 /* --Methode-- */
-BRBaseProcessor::BRBaseProcessor(RAcqMemZoneMgr& memgr)
+BRBaseProcessor::BRBaseProcessor(RAcqMemZoneMgr& memgr, MemZaction mmact)
   : memgr_(memgr), vpaq_(memgr.NbFibres()), vpchk_(memgr.NbFibres()), vfgok_(memgr.NbFibres()), 
     curfc_(memgr.NbFibres()), fcfirst_(memgr.NbFibres()), ttfirst_(memgr.NbFibres())
 {
+  SetMemZAction(mmact);
   stop_ = false;
   for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
@@ -33 +34 @@
   fgokallfibers_=true;
   totprocnpaq_=0;
+}
+
+/* --Methode-- */
+MemZStatus BRBaseProcessor::SetMemZAction(MemZaction mmact)
+{
+  mmact_=mmact;
+  mmsta_=MemZS_ProcA;
+  switch (mmact) {
+  case MemZA_ProcA:
+    mmsta_=MemZS_ProcA;    
+    break;
+  case MemZA_ProcB:
+    mmsta_=MemZS_ProcB;    
+    break;
+  case MemZA_ProcC:
+    mmsta_=MemZS_ProcC;    
+    break;
+  case MemZA_ProcD:
+    mmsta_=MemZS_ProcD;    
+    break;
+  case MemZA_ProcE:
+    mmsta_=MemZS_ProcE;    
+    break;
+  case MemZA_ProcF:
+    mmsta_=MemZS_ProcF;    
+    break;
+  default:
+    mmact_=MemZA_ProcA;
+    mmsta_=MemZS_ProcA;
+    break;
+  }
+  return mmsta_;
 }
 
@@ -49 +82 @@
       if (stop_) break;
       if (memgr_.GetRunState() == MemZR_Stopped) break;
-      int mid = memgr_.FindMemZoneId(MemZA_ProcA);
+      int mid = memgr_.FindMemZoneId(mmact_);  // (MemZA_ProcA);
       Byte* buffg = memgr_.GetMemZone(mid);
       if (buffg == NULL) {
@@ -85 +118 @@
         //      if (rcp != 0)   { fgrun=false; break; }
       }  // Fin de boucle sur les paquets 
-      memgr_.FreeMemZone(mid, MemZS_ProcA);
+      memgr_.FreeMemZone(mid, mmsta_);   // (MemZS_ProcA);
     } // Fin de boucle sur les zones a traiter 
     //------------------------------------

trunk/AddOn/TAcq/brbaseproc.h

@@ -24 +24 @@
 class BRBaseProcessor : public SOPHYA::ZThread {
 public: 
-  BRBaseProcessor(RAcqMemZoneMgr& memgr);
+  BRBaseProcessor(RAcqMemZoneMgr& memgr, MemZaction mmact=MemZA_ProcA);
+  
+  MemZStatus SetMemZAction(MemZaction mmact=MemZA_ProcA);
 
   virtual void run();
@@ -35 +37 @@
 
   RAcqMemZoneMgr& memgr_;
+  MemZaction mmact_;    // Definition de l'action sur les paquets (defaut=MemZA_ProcA)
+  MemZStatus mmsta_;    // Statut associe a mmact_ (defaut=MemZS_ProcA)
   bool stop_;
   vector<Byte*> fbuff_;      // Vecteur de pointeur de zone memoire pour chaque fibre 

trunk/AddOn/TAcq/brpaqu.h

@@ -58 +58 @@
   inline double realD() { return  (double)(val_)[0]; }
   inline double imagD() { return  (double)(val_)[1]; }
+
+  inline float  module2F() { return ((float)(val_)[0]*(float)(val_)[0]+(float)(val_)[1]*(float)(val_)[1]); }
+  inline double module2D() { return ((double)(val_)[0]*(double)(val_)[0]+(double)(val_)[1]*(double)(val_)[1]); }
 
   SByte val_[2];

trunk/AddOn/TAcq/brproc.cc

@@ -131 +131 @@
       if (stop_) break;
       if (memgr_.GetRunState() == MemZR_Stopped) break;
-      int mid = memgr_.FindMemZoneId(MemZA_ProcA);
+      int mid = memgr_.FindMemZoneId(mmact_);  // (MemZA_ProcA);
       Byte* buffg = memgr_.GetMemZone(mid);
       if (buffg == NULL) {
@@ -141 +141 @@
         fbuff_[fib] = memgr_.GetMemZone(mid,fib);
         if (fbuff_[fib] == NULL) { // cela ne devrait pas arriver 
-          cout << "BRBaseProcessor::run()/ERROR memgr.GetMemZone(" << mid << "," << fib << ") -> NULL" << endl;
+          cout << "BRVisibilityCalculator::run()/ERROR memgr.GetMemZone(" << mid << "," << fib << ") -> NULL" << endl;
           setRC(9);       fgrun=false;          
           break;
@@ -196 +196 @@
       if (rcpex!=0)  cout << " BRVisibilityCalculator::run() / Error Rc[paralex_.execute()]=" << rcpex << endl;
 
-      memgr_.FreeMemZone(mid, MemZS_ProcA);
+      memgr_.FreeMemZone(mid, mmsta_);  // (MemZS_ProcA);
     } // Fin de boucle sur les zones a traiter 
     //------------------------------------
@@ -207 +207 @@
   }
   catch (std::exception& exc) {
-    cout << " BRBaseProcessor::run()/catched std::exception " << exc.what() << endl;
+    cout << " BRVisibilityCalculator::run()/catched std::exception " << exc.what() << endl;
     setRC(98);  
     return; 
   }
   catch(...) {
-    cout << " BRBaseProcessor::run()/catched unknown ... exception " << endl;
+    cout << " BRVisibilityCalculator::run()/catched unknown ... exception " << endl;
     setRC(99);  
     return; 
@@ -397 +397 @@
   return 0;
 }
+
+
+//---------------------------------------------------------------------
+// Classe de traitement simple - calcul de spectres moyennes / voie
+//---------------------------------------------------------------------
+/* --Methode-- */
+BRMeanSpecCalculator::BRMeanSpecCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean)
+  : BRBaseProcessor(memgr), outpath_(outpath), nmean_(nmean)
+{
+  BRPaquet paq(memgr_.PaqSize());
+  mspecmtx_.SetSize(2*memgr_.NbFibres(), paq.DataSize()/4); 
+  numfile_=0;
+  totnbpaq_=0;
+}
+
+/* --Methode-- */
+BRMeanSpecCalculator::~BRMeanSpecCalculator()
+{
+}
+
+
+/* --Methode-- */
+int BRMeanSpecCalculator::Process()
+{
+      
+  if (totnbpaq_%nmean_ == 0) {
+    if (totnbpaq_ > 0) {
+      mspecmtx_.Info()["NPAQSUM"] = nmean_;
+      mspecmtx_ /= (double)nmean_;
+      char nfile[32];
+      sprintf(nfile,"mspecmtx%d.ppf",numfile_);
+      string flnm=outpath_+nfile;
+      POutPersist po(flnm);
+      po << mspecmtx_;
+      cout << numfile_ << "-BRMeanSpecCalculator::Process() NPaqProc="
+           << totnbpaq_ << "  -> Mean spectra Matrix in " << flnm << endl;
+      numfile_++;
+    }
+    mspecmtx_ = (r_8)(0.);
+  }
+
+  sa_size_t k=0;
+  for(size_t i=0; i<(size_t)2*memgr_.NbFibres(); i++) {
+    TwoByteComplex* zp=vpaq_[i/2].Data1C();
+    if (i%2==1)  zp=vpaq_[i/2].Data2C();
+    TVector< r_4 > spec = mspecmtx_.Row(k);   k++;
+    for(sa_size_t f=1; f<spec.Size(); f++) {
+      spec(f) += zp[f].module2F();
+      }
+    }
+
+  totnbpaq_++;
+  return 0;
+}
+
 
 //---------------------------------------------------------------

trunk/AddOn/TAcq/brproc.h

@@ -79 +79 @@
 
 
+//---------------------------------------------------------------------
+// Classe de traitement simple - calcul de spectres moyennes / voie
+//---------------------------------------------------------------------
+class BRMeanSpecCalculator : public BRBaseProcessor
+{
+public:
+  BRMeanSpecCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000);
+  virtual ~BRMeanSpecCalculator(); // Fait le nettoyage final , sauvegarde des objets ...
+
+protected:
+  virtual int Process(); 
+
+  uint_4 nmean_;  // Nombre de spectres pour le calcul des moyennes 
+  string outpath_;  // directory pour fichiers de sortie
+  uint_4 numfile_;
+
+  uint_8 totnbpaq_;
+  TMatrix< r_4 > mspecmtx_;    // Matrice des spectres moyennees 
+}; 
+
 //-------------------------------------------------------------------------
 //    **** OBSOLETE : BRProcA2C et BRProcB4C

trunk/AddOn/TAcq/vismfib.cc

@@ -65 +65 @@
                                 par.nbinfreq_, par.nthreads_);
     if (par.action_ == "viscktt")  proc.ActivateTimeTagCheck(par.TotalNPaquets());
+    BRMeanSpecCalculator procms(mmgr, par.outpath_, par.nmean_);
     FitsCubeWriter wrt(mmgr, par.outpath_, par.nbloc_);
     //    BRBaseProcessor proc(mmgr);
@@ -71 +72 @@
     reader.start();
     if (par.action_ == "cube3d")   wrt.start();
+    else if (par.action_ == "mspec")   procms.start();
     else  proc.start();
     usleep(200000);
     reader.join();
     if (par.action_ == "cube3d")  wrt.join();
+    else if (par.action_ == "mspec")  procms.join();
     else proc.join();
     mmgr.Print(cout);