Changeset 3683 in Sophya for trunk


Ignore:
Timestamp:
Nov 27, 2009, 11:32:46 AM (16 years ago)
Author:
ansari
Message:

Mise a jour et ajout de fichier pour taritement multifibres apres

prise de donnees de Nov2009 a Pittsburgh

  • Introduction des classes BRMultiFitsReader et BRBaseProcessor Reza, 27/11/2009
Location:
trunk/AddOn/TAcq
Files:
3 added
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/AddOn/TAcq/bracqvers.h

    r3675 r3683  
    55   Software version     LAL - 2008-2010
    66*/
    7 #define BAOR_ACQ_VER 6.5
    8 #define BAOR_ACQ_VER_STR "BaoAcq_v6r5_Nov09 "
     7#define BAOR_ACQ_VER 6.6
     8#define BAOR_ACQ_VER_STR "BaoAcq_v6r6_Nov09 "
    99
    1010#endif

  • trunk/AddOn/TAcq/brfitsrd.cc

    r3646 r3683  
    11//----------------------------------------------------------------
    2 // ---- classes de threads pour lecture fichiers minifits
    3 // LAL -      R. Ansari - Mai 2009
     2// Projet BAORadio - (C) LAL/IRFU  2008-2010
     3// Classes de threads pour lecture fichiers fits BAORadio
    44//----------------------------------------------------------------
    55
    … …  
    1010#include <unistd.h>
    1111#include <fstream>
    12 #include <signal.h>
     12#include <exception>
     13
    1314#include "pexceptions.h"
    1415#include "timestamp.h"
    … …  
    1617
    1718#include "brpaqu.h"
    18 #include "minifits.h"
    1919
    2020#include "resusage.h" // Pour mesure temps elapsed/CPU ...
    21 #include "datatable.h" // Pour sauver les entetes de paquet
    2221#include <sys/time.h>  // pour gettimeofday
    2322
     23using namespace SOPHYA;
     24
     25//---------------------------------------------------------------------
     26// Classe thread de lecture de Multi-fibres de fichiers FITS BAORadio 
     27//---------------------------------------------------------------------
     28
     29/* --Methode-- */
     30BRMultiFitsReader::BRMultiFitsReader(RAcqMemZoneMgr& mem, vector<string>& dirs, bool rdsamefc,
     31                                     uint_4 imin, uint_4 imax, uint_4 istep)
     32  :  memgr_(mem), dirs_(dirs), rdsamefc_(rdsamefc), imin_(imin), imax_(imax), istep_(istep)
     33{
     34  SetPrintLevel();
     35  totnbytesrd_ = 0;
     36  totsamefc_ = 0;
     37  if (memgr_.NbFibres() > MAXANAFIB)
     38    throw BAORadioException("BRMultiFitsReader::BRMultiFitsReader/ NbFibres>MAXANAFIB ");
     39  if (dirs_.size() != memgr_.NbFibres())
     40    throw BAORadioException("BRMultiFitsReader::BRMultiFitsReader/ NbFibres != Nb Data Directories");
     41
     42  packsize_=memgr_.PaqSize();
     43  mid_=-2;
     44  mmbuf_=NULL;
     45  max_targ_npaq = memgr_.NbPaquets();
     46  for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) mmbufib_[fib]=NULL;
     47
     48  char flnm[1024];
     49  for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
     50    sprintf(flnm,"%s/signal%d.fits",dirs_[fib].c_str(),imin_);
     51    mff_[fib].Open(flnm, MF_Read);
     52    if (mff_[fib].NAxis1() != memgr_.PaqSize())  {
     53      cout << " BRMultiFitsReader::BRMultiFitsReader/ fib=" << fib << " File=" << flnm <<
     54        " NAxis1()= " << mff_[fib].NAxis1() << " <> PaqSize()=" << memgr_.PaqSize() << endl;
     55      throw BAORadioException("BRMultiFitsReader::BRMultiFitsReader/ mff.NAxis1() != memgr_.PaqSize() ");
     56    }
     57    vfilenum_.push_back(imin_);
     58    vfpos_.push_back(0);
     59    vpaq_.push_back(BRPaquet(NULL,memgr_.PaqSize()));
     60    vpchk_.push_back(BRPaqChecker(true,0));
     61    curfc_.push_back(0);
     62    totnpqrd_.push_back(0);
     63    totnpqok_.push_back(0);   
     64  }
     65}
     66
     67
     68/* --Methode-- */
     69void BRMultiFitsReader::run()
     70{
     71  setRC(1);
     72  try {
     73    TimeStamp ts;
     74    Timer tm("BRMultiFitsReader", false);
     75    cout << " BRMultiFitsReader::run() - Starting " << ts << " NbFibres()=" << memgr_.NbFibres()
     76         << "  PaqSize() = " << memgr_.PaqSize() << endl;
     77    cout << " ...ReadMode: " << ((rdsamefc_)?"Paquets With SameFrameCounter":"All OK paquets")
     78         << " signalII.fits IMin=" << imin_ << " IMax=" << imax_ << " IStep=" << istep_ << endl;
     79
     80    Byte* nextpaq=NULL;
     81    bool fgok=true;
     82    while (fgok) {
     83      if (stop_) break;
     84      if ( MoveToNextTarget() ) {
     85        cout << "BRMultiFitsReader::run()/Error-A- MoveToNextTarget() returned true ->STOP 9" << endl;
     86        setRC(7);  fgok=false;  break;
     87      }
     88      for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
     89        nextpaq=GetPaquetTarget(fib);
     90        if (nextpaq == NULL) { // Cela ne devrait pas arriver
     91          cout << "BRMultiFitsReader::run()/Error-A2- GetPaquetTarget(fib)  returned NULL ->STOP 9" << endl;
     92          setRC(9);  fgok=false;  break;
     93        }
     94        vpaq_[fib].Set(nextpaq);
     95      }
     96      if (ReadNextAllFibers()) { fgok=false;  break; }
     97    }
     98
     99    MoveToNextTarget();  // Pour faire traiter le dernier paquet si plein
     100    MZoneManage(true);   // Nettoyage final
     101    usleep(50000);       // Attente de traitement du dernier paquet
     102    memgr_.Stop();        // Arret
     103
     104    cout << " ------------------  BRMultiFitsReader::run() END ----------------- " << endl;
     105    ts.SetNow();
     106    tm.SplitQ();
     107    cout << "  END reading : " << ts ;
     108    if (rdsamefc_) cout << " NSameFC=" << totsamefc_ << endl;
     109    else cout << endl;
     110    for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
     111      int perc=0;
     112      if (totnpqrd_[fib]>0) perc=100*totsamefc_/totnpqrd_[fib];
     113      cout << " Fiber" << fib << " TotNPaqRd=" << totnpqrd_[fib] << " TotNPaqOK=" << totnpqok_[fib]
     114           << " FracSameFC=" << perc << " %" << endl;
     115    }
     116    cout << "  TotalDiskRead= " << totnbytesrd_/(1024*1024) << " MBytes Disk-Read rate= "
     117         << (double)(totnbytesrd_)/1024./tm.PartialElapsedTimems() << " MB/s" << endl;   
     118    cout << " BRMultiFitsReader::run()/Timing: \n";
     119    tm.Print();
     120    cout << " ---------------------------------------------------------- " << endl;
     121
     122  }  // Fin du bloc try
     123  catch (std::exception& exc) {
     124    cout << " BRMultiFitsReader::run()/catched execption msg=  " << exc.what() << endl;
     125    setRC(3);   
     126    return;
     127  }
     128  catch(...) {
     129    cout << " BRMultiFitsReader::run()/catched unknown ... exception " << endl;
     130    setRC(4);   
     131    return;
     132  }
     133  setRC(0);
     134  return;
     135}
     136
     137/* --Methode-- */
     138bool BRMultiFitsReader::ReadNextAllFibers()
     139{
     140  for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
     141    if (ReadNext(fib)) return true;  // probleme
     142  }
     143  if (!rdsamefc_ || (memgr_.NbFibres()<2))  {
     144    totsamefc_++;  return false;  // c'est OK
     145  }
     146  uint_8 cfc=curfc_[0];
     147  bool fgsamefc=true;
     148  for(size_t fib=1; fib<memgr_.NbFibres(); fib++) {
     149    if (curfc_[fib]!=cfc) {
     150      fgsamefc=false;
     151      if (curfc_[fib] > cfc)  cfc=curfc_[fib];
     152    }
     153  }
     154  if (fgsamefc) {
     155    totsamefc_++;  return false;  // c'est OK  , same framecounter
     156  }
     157  else {  // else !fgsame
     158    for(uint_4 fib=0; fib<memgr_.NbFibres(); fib++) {
     159      while (curfc_[fib]<cfc) {
     160        if (ReadNext(fib)) return true;  // probleme
     161      }
     162    }
     163  }   // fin de  else !fgsame
     164  totsamefc_++;
     165  return false; // c'est OK
     166}
     167
     168/* --Methode-- */
     169bool BRMultiFitsReader::ReadNext(int fib)
     170{
     171  if (!mff_[fib].IsOpen())  return true;
     172  bool fggood=false;
     173  while(!fggood) {
     174    if (vfpos_[fib] >= mff_[fib].NAxis2()) {
     175      mff_[fib].Close();
     176      vfilenum_[fib]++;
     177      if (vfilenum_[fib]>imax_)  return true;
     178      char flnm[1024];
     179      sprintf(flnm,"%s/signal%d.fits",dirs_[fib].c_str(),vfilenum_[fib]++);
     180      if (prtlev_ > 0)
     181        cout << " BRMultiFitsReader::ReadNext() opening" << flnm << endl;
     182      mff_[fib].Open(flnm, MF_Read);
     183      if (mff_[fib].NAxis1() != packsize_)  {
     184        cout << " BRMultiFitsReader::ReadNext(fib=" << fib << " File=" << flnm <<
     185          " NAxis1()= " << mff_[fib].NAxis1() << " <> PaqSize()=" << packsize_ << endl;
     186        throw BAORadioException("BRMultiFitsReader::ReadNext()/ mff.NAxis1() != memgr_.PaqSize() ");
     187      }
     188      vfpos_[fib]=0;
     189    }
     190    mff_[fib].ReadB(vpaq_[fib].Begin(), packsize_, vfpos_[fib]*packsize_);
     191    vfpos_[fib]++;
     192    totnbytesrd_+=packsize_;
     193    totnpqrd_[fib]++;
     194    fggood = vpchk_[fib].Check(vpaq_[fib],curfc_[fib]);
     195  }
     196  totnpqok_[fib]++;
     197  return false;
     198}
     199
     200/* --Methode-- */
     201bool BRMultiFitsReader::MZoneManage(bool fgclean)    // Retourne true si probleme
     202{
     203  /* Pour debug
     204  cout << " BRMultiFitsReader::MZoneManage() mid_=" << mid_ << " arg_npaq_= " << targ_npaq_ 
     205       << " max_targ_npaq=" << max_targ_npaq << endl;
     206  */
     207  if (mid_ >= 0)  {
     208    if (fgclean) memgr_.FreeMemZone(mid_, MemZS_Free);   
     209    memgr_.FreeMemZone(mid_, MemZS_Filled);
     210  }
     211  mmbuf_ = NULL;  targ_npaq_ = 0;  mid_ = -2;
     212  for (int fib=0;fib<(int)memgr_.NbFibres() ;fib++) mmbufib_[fib]=NULL;
     213  if (fgclean)  return false;
     214  mid_ = memgr_.FindMemZoneId(MemZA_Fill);
     215  mmbuf_ = memgr_.GetMemZone(mid_);
     216  if (mmbuf_==NULL)   return true;
     217  for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)
     218    mmbufib_[fib]=memgr_.GetMemZone(mid_,fib);
     219  return false;
     220}
     221
    24222//-------------------------------------------------------
    25 // Classe thread de sauvegarde sur fichiers
     223// Classe thread de lecture de fichiers fits BAORadio
    26224//-------------------------------------------------------
    27225
     226/* --Methode-- */
    28227BRFitsReader::BRFitsReader(RAcqMemZoneMgr& mem, vector<string>& infiles, bool fgnotrl)
    29228  :  memgr(mem), infiles_(infiles), fgnotrl_(fgnotrl)
    30229{
    31230}
    32 void BRFitsReader::Stop()
    33 {
    34   // cout<< " BRFitsReader:Stop ........ " << endl;
    35   stop_=true;
    36 }
     231
     232/* --Methode-- */
    37233void BRFitsReader::run()
    38234{

  • trunk/AddOn/TAcq/brfitsrd.h

    r3646 r3683  
    33
    44//----------------------------------------------------------------
    5 // classes de threads pour lecture de fichier fits produit
    6 //    par le programme d'acquisition TAcq/ de BAORadio
    7 // LAL -      R. Ansari - Mai 2009
     5// Projet BAORadio - (C) LAL/IRFU  2008-2010
     6// Classes de threads pour lecture fichiers fits BAORadio
    87//----------------------------------------------------------------
    98
    … …  
    1211#include <vector>
    1312#include <iostream>
    14 #include "sopnamsp.h"
    15 #include "zthread.h"
    1613
    17 #include "brtypes.h"
    1814#include "brpaqu.h"
     15#include "minifits.h"
    1916
    2017using namespace std;
    2118
     19#ifndef MAXANAFIB
     20#define MAXANAFIB  32
     21#endif
     22
     23//-------------------------------------------------------
     24// Classe thread de lecture des fichiers data BAORadio
     25//  BRMultiFitsReader : Lecture multi-fibres
     26//-------------------------------------------------------
     27
     28class BRMultiFitsReader : public SOPHYA::ZThread {
     29public:
     30  BRMultiFitsReader(RAcqMemZoneMgr& mem, vector<string>& dirs,
     31                    bool rdsamefc=true, uint_4 imin=0, uint_4 imax=0, uint_4 istep=1);
     32
     33  virtual void run();
     34  inline void Stop() { stop_ = true; }
     35  inline void STOP() { stop_ = true; } 
     36
     37  inline int SetPrintLevel(int lev=0) { prtlev_=lev; }
     38protected:
     39  bool ReadNextAllFibers();      // Renvoie true si probleme
     40  bool ReadNext(int fib);   // Renvoie true si probleme
     41  // Permet d'avancer d'un paquet dans la zone - renvoie true si probleme
     42  inline bool MoveToNextTarget()  {
     43    if ((mmbuf_ == NULL )||(targ_npaq_ >= max_targ_npaq))
     44      if (MZoneManage()) return true;
     45    targ_npaq_++;
     46    return false;
     47  }
     48  inline Byte* GetPaquetTarget(int numfib)  {
     49    if ((mmbufib_[numfib] == NULL )||(targ_npaq_ > max_targ_npaq)||(targ_npaq_ == 0))  return NULL;
     50    Byte* rb=mmbufib_[numfib]+(targ_npaq_-1)*packsize_;
     51    return rb;
     52  }
     53  bool MZoneManage(bool clean=false);  // Renvoie true si probleme
     54
     55  RAcqMemZoneMgr& memgr_;
     56  vector<string> dirs_;  //  repertoires donnees chaque fibre
     57  bool stop_;
     58  bool rdsamefc_;  // if true, read paquets with same value of FrameCounter on different fibers
     59  uint_4 imin_, imax_, istep_;
     60  size_t totnbytesrd_;
     61  uint_8 totsamefc_;   // nombre total de paquets avec meme framecounter 
     62  MiniFITSFile mff_[MAXANAFIB];
     63  vector<uint_4> vfilenum_;
     64  vector<uint_4> vfpos_;
     65  vector<BRPaquet> vpaq_;
     66  vector<BRPaqChecker> vpchk_;
     67  vector<uint_8> curfc_;       // Numeros des FrameCounter des paquets courants
     68  vector<uint_8> totnpqrd_;    // nombre total de paquets lus / fibre
     69  vector<uint_8> totnpqok_;    // nombre total de paquets OK / fibre 
     70
     71  uint_4 packsize_;
     72  int mid_;  // Identificateur zone memoire
     73  uint_4 targ_npaq_;  // Numero de paquet dans une seule zone memoire
     74  uint_4 max_targ_npaq; // =  mmgr.NbPaquets() = Max de targ_npaq_
     75  Byte* mmbuf_;  // Pointeur zone memoire rendu par RAcqMemZoneMgr
     76  Byte* mmbufib_[MAXANAFIB];  // Pointeurs zone memoire de chaque fibre rendu par RAcqMemZoneMgr
     77
     78  int prtlev_;
     79};
    2280
    2381//-------------------------------------------------------
    … …  
    2583//-------------------------------------------------------
    2684
    27 class BRFitsReader : public ZThread {
     85class BRFitsReader : public SOPHYA::ZThread {
    2886public:
    2987  BRFitsReader(RAcqMemZoneMgr& mem, vector<string>& infiles, bool fgnotrl=false);
    3088
    3189  virtual void run();
    32   void Stop();
     90  inline void Stop() { stop_ = true; }
    3391  inline void STOP() { stop_ = true; } 
    3492

  • trunk/AddOn/TAcq/brpaqu.cc

    r3676 r3683  
    204204  dst_ = NULL;
    205205  sz_ = paqsz;
     206}
     207
     208/* --Methode__ */
     209BRPaquet::BRPaquet(BRPaquet const& paq)
     210{
     211  dst_ = paq.dst_;
     212  sz_ = paq.sz_;
    206213}
    207214
    … …  
    605612  DefineHDRTag();
    606613  DefineTRLTag();
     614}
     615
     616/* --Methode__ */
     617BRPaqChecker::BRPaqChecker(BRPaqChecker const& pck)
     618{
     619  totnframes=pck.totnframes;
     620  nframeok=pck.nframeok;
     621  lostframes=pck.lostframes;
     622  frclst=pck.frclst;
     623  lastframenum=pck.lastframenum;
     624  cktrl_=pck.cktrl_;
     625  cnt_saut=pck.cnt_saut;
     626  maxprt_=pck.maxprt_;
     627  hdrtag_=pck.hdrtag_;
     628  trltag_=pck.trltag_;
    607629}
    608630

  • trunk/AddOn/TAcq/brpaqu.h

    r3674 r3683  
    117117  BRPaquet(Byte* srcdst, int paqsz);
    118118  BRPaquet(int paqsz);
     119  BRPaquet(BRPaquet const& paq);
    119120
    120121  //  ~BRPaquet();
     122  inline void Set(Byte* dst)   { dst_=dst; return; }
     123  inline void Set(Byte* dst, int paqsz)   { dst_=dst;  sz_=paqsz; return; }
    121124
    122125  // Pour la copie/reduction de taille de paquet
    … …  
    210213  // if cktrl==true, check header AND trailer, ==false check header only
    211214  BRPaqChecker(bool cktrl=true, int maxprt=0);
     215  BRPaqChecker(BRPaqChecker const& pck);
     216
    212217  ~BRPaqChecker();
     218
     219  inline bool SetCheckTrailerFlag(bool cktrl=true) { cktrl_=cktrl; return cktrl_; }
     220  inline int SetMaxPrint(int maxprt=0) { maxprt=maxprt_; return maxprt_; }
    213221
    214222  UInt64 DefineHDRTag(UInt32 hdr1=0x76543210, UInt32 hdr2=0xFEDCBA98);
    … …  
    237245protected:
    238246  UInt64 totnframes;    // Nombre totale de frames/paquets traites
    239   UInt64  nframeok;     // Nombre totale de frames/paquets avec HDR/TRL OK
     247  UInt64 nframeok;      // Nombre totale de frames/paquets avec HDR/TRL OK
    240248  UInt64 lostframes;    // Nombre totale de frames/paquets perdus
    241249  UInt16 frclst;         // derniere valeur du frame-counter

  • trunk/AddOn/TAcq/brproc.cc

    r3658 r3683  
    2626#include "brproc.h"
    2727
     28//---------------------------------------------------------------------
     29// Classe de traitement - calcul de visibilite pour n fibres
     30//---------------------------------------------------------------------
     31
     32/* --Methode-- */
     33BRVisibilityCalculator::BRVisibilityCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean,
     34                       uint_4 freq1, uint_4 freq2, uint_4 nbfreq)
     35  : BRBaseProcessor(memgr), outpath_(outpath), nmean_(nmean), numfreq1_(freq1), numfreq2_(freq2), nbinfreq_(nbfreq)
     36{
     37  for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
     38    vframecount_.push_back(0);
     39    vtimetag_.push_back(0);
     40    vnpaqm_.push_back(0);
     41  }
     42}
     43
     44/* --Methode-- */
     45BRVisibilityCalculator::~BRVisibilityCalculator()
     46{
     47}
     48
     49/* --Methode-- */
     50int BRVisibilityCalculator::Process()
     51{
     52}
    2853
    2954//---------------------------------------------------------------
    … …  
    3560
    3661/* --Methode-- */
    37 BRProcARaw2C::BRProcARaw2C(RAcqMemZoneMgr& mem, string& path, uint_4 nmean,
     62BRProcA2C::BRProcA2C(RAcqMemZoneMgr& mem, string& path, bool fgraw, uint_4 nmean,
    3863                           uint_4 nmax, bool fghist, uint_4 nfsmap, bool fgnotrl, int card)
    3964  :  memgr(mem)
    4065{
     66  fgraw_ = fgraw;
    4167  nmax_ = nmax;
    4268  nmean_ = nmean;
     69  if (fgraw_) cout << " BRProcA2C::BRProcA2C() - constructeur RAW data - NMean=" << nmean_ << endl;
     70  else cout << " BRProcA2C::BRProcA2C() - constructeur FFT data - NMean=" << nmean_ << endl;
    4371  nfsmap_ = nfsmap;
    4472  stop_ = false;       
    … …  
    5179
    5280/* --Methode-- */
    53 void BRProcARaw2C::Stop()
     81void BRProcA2C::Stop()
    5482{
    5583 stop_=true;
    56  // cout <<" BRProcARaw2C::Stop ... > STOP " << endl;
     84 // cout <<" BRProcA2C::Stop ... > STOP " << endl;
    5785}
    5886
    … …  
    6795}
    6896/* --Methode-- */
    69 void BRProcARaw2C::run()
     97void BRProcA2C::run()
    7098{
    7199  setRC(1);     
    72100  try {
    73     Timer tm("BRProcARaw2C", false);
     101    Timer tm("BRProcA2C", false);
    74102    TimeStamp ts;
    75103    BRPaqChecker pcheck(!fgnotrl_);  // Verification/comptage des paquets
    … …  
    78106    size_t totnbytesproc = 0;
    79107
    80     cout << " BRProcARaw2C::run() - Starting " << ts << " NMaxMemZones=" << nmax_
     108    cout << " BRProcA2C::run() - Starting " << ts << " NMaxMemZones=" << nmax_
    81109         << " NMean=" << nmean_ << card2name_(card_) << endl;   
    82     cout << " BRProcARaw2C::run()... - Output Data Path: " << path_ << endl;
     110    cout << " BRProcA2C::run()... - Output Data Path: " << path_ << endl;
    83111    char fname[512];
    84112//    sprintf(fname,"%s/proc.log",path_.c_str());
    85113//    ofstream filog(fname);
    86 //    filog << " BRProcARaw2C::run() - starting log file " << ts << endl;                     
     114//    filog << " BRProcA2C::run() - starting log file " << ts << endl;                 
    87115//    filog << " ... NMaxMemZones=" << nmax_ << " NMean=" << nmean_ << " Step=" << step_ << endl;       
    88116
    … …  
    94122    double ms1,ms2,ms12,ms12re,ms12im,ms12phi;
    95123----*/
    96 // Time sample histograms
    97    Histo h1(-0.5, 255.5, 256);
    98    Histo h2(-0.5, 255.5, 256);
     124// Time sample (raw data) /FFT coeff histograms
     125   Histo* ph1=NULL;
     126   Histo* ph2=NULL;
     127   if (fghist_) {
     128     if (fgraw_) {
     129       ph1 = new Histo(-0.5, 255.5, 256);     
     130       ph2 = new Histo(-0.5, 255.5, 256);     
     131     }
     132     else {
     133       ph1 = new Histo(-128.5, 128.5, 257);     
     134       ph2 = new Histo(-128.5, 128.5, 257);     
     135     }
     136   }
     137
    99138// Initialisation pour calcul FFT
    100139    TVector< complex<r_4> > cfour1;  // composant TF
    … …  
    132171      timfreqV2.SetSize(nmean_, spectreV2.Size()/nfsmap_);
    133172    }
    134     cout << " *DBG*BRProcARaw2C PaqSz=" << paqsz << " ProcPaqSize=" << procpaqsz
     173    cout << " *DBG*BRProcA2C PaqSz=" << paqsz << " ProcPaqSize=" << procpaqsz
    135174         << " procpaqsz/2=" << procpaqsz/2 << " cfour1.Size()=" << cfour1.Size()
    136175         << " *8="  << cfour1.Size()*8 << endl;
    … …  
    160199      Byte* buff = memgr.GetMemZone(mid);
    161200      if (buff == NULL) {
    162          cout << " BRProcARaw2C::run()/ERROR memgr.GetMemZone(" << mid << ") -> NULL" << endl;
     201         cout << " BRProcA2C::run()/ERROR memgr.GetMemZone(" << mid << ") -> NULL" << endl;
    163202             break;             
    164203      }
    165204      Byte* procbuff = memgr.GetProcMemZone(mid);
    166205      if (procbuff == NULL) {
    167             cout << " BRProcARaw2C::run()/ERROR memgr.GetProcMemZone(" << mid << ") -> NULL" << endl;
     206            cout << " BRProcA2C::run()/ERROR memgr.GetProcMemZone(" << mid << ") -> NULL" << endl;
    168207        break; 
    169208      }
    … …  
    178217        if (fghist_) {
    179218          for(sa_size_t j=0; j<vx.Size(); j++) {
    180             r_4 vts=(r_4)(*(paq.Data1()+j));
    181             h1.Add((r_8)vts);
     219            r_4 vts=(fgraw_)?((r_4)(*(paq.Data1()+j))):((r_4)(*(paq.Data1S()+j)));
     220            ph1->Add((r_8)vts);
    182221            moysig[0] += (double)vts;
    183222            sigsig[0] += ((double)vts)*((double)vts);
    184223            nbsig[0]++;
    185             vx(j) = vts-127.5;
    186224          }
    187         }
    188         else {
    189           for(sa_size_t j=0; j<vx.Size(); j++)
    190             vx(j) = (r_4)(*(paq.Data1()+j))-127.5;
    191         }
    192 //        fftwf_complex* coeff1 = (fftwf_complex*)(procbuff+i*procpaqsz);
    193             fftwf_execute(plan1);
    194 //        complex<r_4>* zp1 = (complex<r_4>*)(vx.Data());
    195 //        ffts.FFTForward(vx, cfour1);
    196         for(sa_size_t j=0; j<spectreV1.Size(); j++)
    197           spectreV1(j) += Zmod2(cfour1(j));
    198         memcpy(procbuff+i*procpaqsz, cfour1.Data(), sizeof(complex<r_4>)*cfour1.Size());
    199         if (fgtimfreq) {   // Remplissage tableau temps-frequence
    200           for(sa_size_t c=1; c<timfreqV1.NCols(); c++) {
    201             for(sa_size_t j=c*nfsmap_; j<(c+1)*nfsmap_; j++)
    202               timfreqV1(nzm, c) += Zmod2(cfour1(j));
    203           }
    204         }
    205 // Traitement voie 2       
    206         if (fghist_) {
    207           for(sa_size_t j=0; j<vx.Size(); j++) {
    208             r_4 vts=(r_4)(*(paq.Data2()+j));
    209             h2.Add((r_8)vts);
     225          for(sa_size_t j=0; j<vx.Size(); j++) {
     226            r_4 vts=(fgraw_)?((r_4)(*(paq.Data2()+j))):((r_4)(*(paq.Data2S()+j)));
     227            ph2->Add((r_8)vts);
    210228            moysig[1] += (double)vts;
    211229            sigsig[1] += ((double)vts)*((double)vts);
    212230            nbsig[1]++;
    213             vx(j) = vts-127.5;
    214231          }
    215232        }
    216         else {
    217           for(sa_size_t j=0; j<vx.Size(); j++)
    218             vx(j) = (r_4)(*(paq.Data2()+j))-127.5;
    219         }
    220         fftwf_execute(plan2);
     233        if (fgraw_) {
     234          for(sa_size_t j=0; j<vx.Size(); j++)
     235            vx(j) = (r_4)(*(paq.Data1()+j))-127.5;
     236          //        fftwf_complex* coeff1 = (fftwf_complex*)(procbuff+i*procpaqsz);
     237          fftwf_execute(plan1);
     238          // Traitement voie 2             
     239          for(sa_size_t j=0; j<vx.Size(); j++)
     240            vx(j) = (r_4)(*(paq.Data2()+j))-127.5;
     241          fftwf_execute(plan2);
     242        }
     243        else {
     244          for(sa_size_t j=1; j<cfour1.Size()-1; j++) {
     245            cfour1(j) = complex<r_4>((r_4)paq.Data1C()[j].realB(), (r_4)paq.Data1C()[j].imagB());
     246            cfour2(j) = complex<r_4>((r_4)paq.Data2C()[j].realB(), (r_4)paq.Data2C()[j].imagB());
     247          }
     248          cfour1(0) = complex<r_4>((r_4)paq.Data1C()[0].realB(), (r_4)0.);
     249          cfour1(cfour1.Size()-1) = complex<r_4>((r_4)paq.Data1C()[0].imagB(), (r_4)0.);
     250          cfour2(0) = complex<r_4>((r_4)paq.Data2C()[0].realB(), (r_4)0.);
     251          cfour2(cfour2.Size()-1) = complex<r_4>((r_4)paq.Data2C()[0].imagB(), (r_4)0.);
     252        }
     253        for(sa_size_t j=0; j<spectreV1.Size(); j++)
     254          spectreV1(j) += Zmod2(cfour1(j));
     255        memcpy(procbuff+i*procpaqsz, cfour1.Data(), sizeof(complex<r_4>)*cfour1.Size());
     256        if (fgtimfreq) {   // Remplissage tableau temps-frequence
     257          for(sa_size_t c=1; c<timfreqV1.NCols(); c++) {
     258            for(sa_size_t j=c*nfsmap_; j<(c+1)*nfsmap_; j++)
     259              timfreqV1(nzm, c) += Zmod2(cfour1(j));
     260          }
     261        }
    221262        for(sa_size_t j=0; j<spectreV2.Size(); j++)
    222263          spectreV2(j) += Zmod2(cfour2(j));  // Zmod2(zp2[j]);
    … …  
    314355        po << PPFNameTag(tag12) << visiV12;
    315356        if (fghist_) {
    316           po << PPFNameTag(tagh1) << h1;
    317           po << PPFNameTag(tagh2) << h2;
     357          po << PPFNameTag(tagh1) << (*ph1);
     358          po << PPFNameTag(tagh2) << (*ph2);
    318359
    319360          double sspvmax[3] = {0.,0.,0.};
    … …  
    354395        visiV12 = complex<r_4>(0., 0.);
    355396        if (fghist_) {
    356           h1.Zero();
    357           h2.Zero();
     397          ph1->Zero();
     398          ph2->Zero();
    358399          moysig[0]=moysig[1]=0.;
    359400          sigsig[0]=sigsig[1]=0.;
    … …  
    367408//        ts.SetNow();
    368409//        filog << ts << " :  proc file  " << fname << endl;                   
    369         cout << " BRProcARaw2C::run() created file  " << fname << card2name_(card_) << endl;
     410        cout << " BRProcA2C::run() created file  " << fname << card2name_(card_) << endl;
    370411      }   
    371412     
    372413      memgr.FreeMemZone(mid, MemZS_ProcA);
    373414    }  // Fin de boucle sur les zones a traiter
    374   cout << " ------------  BRProcARaw2C::run() END " << card2name_(card_)
     415  cout << " ------------  BRProcA2C::run() END " << card2name_(card_)
    375416       << " ------------ " << endl;
    376417/*---- DELETE
    … …  
    381422  POutPersist po(fname);
    382423  po << PPFNameTag("ntv12") << nt;
    383   cout << " BRProcARaw2C::run() created NTuple file " << fname << card2name_(card_) << endl;
     424  cout << " BRProcA2C::run() created NTuple file " << fname << card2name_(card_) << endl;
    384425  }
    385426---- */
    … …  
    405446    po << PPFNameTag("rsbV1") << rsbV1;
    406447    po << PPFNameTag("rsbV2") << rsbV2;
    407     cout << " BRProcARaw2C::run() created moysigspec file " << fname << card2name_(card_) << endl;
    408   }
    409 
     448    cout << " BRProcA2C::run() created moysigspec file " << fname << card2name_(card_) << endl;
     449  }
     450
     451  if (fghist_) {
     452    delete ph1;
     453    delete ph2;
     454  }
    410455  ts.SetNow();
    411456  tm.SplitQ();
    … …  
    414459       << " ProcDataOut=" <<  totnbytesout/(1024*1024) << " MB" << endl;   
    415460  cout << pcheck;
    416   cout << " BRProcARaw2C::run()/Timing: " << card2name_(card_) << endl;
     461  cout << " BRProcA2C::run()/Timing: " << card2name_(card_) << endl;
    417462  tm.Print();
    418463  cout << " ---------------------------------------------------------- " << endl;
    … …  
    420465  }
    421466  catch (PException& exc) {
    422     cout << " BRProcARaw2C::run()/catched PException " << exc.Msg() << endl;
     467    cout << " BRProcA2C::run()/catched PException " << exc.Msg() << endl;
    423468    setRC(3);   
    424469    return;
    425470  }
    426471  catch(...) {
    427     cout << " BRProcARaw2C::run()/catched unknown ... exception " << endl;
     472    cout << " BRProcA2C::run()/catched unknown ... exception " << endl;
    428473    setRC(4);   
    429474    return;
    … …  
    434479
    435480//---------------------------------------------------------------------
    436 // Classe thread de traitement 2 x 2 voies/frames (Apres BRProcARaw2C)
     481// Classe thread de traitement 2 x 2 voies/frames (Apres BRProcA2C)
    437482//---------------------------------------------------------------------
    438483
    439484/* --Methode-- */
    440 BRProcBRaw4C::BRProcBRaw4C(RAcqMemZoneMgr& mem1, RAcqMemZoneMgr& mem2,
    441                            string& path, uint_4 nmean, uint_4 nmax, bool fgnotrl)
     485BRProcB4C::BRProcB4C(RAcqMemZoneMgr& mem1, RAcqMemZoneMgr& mem2, string& path,
     486                     bool fgraw, uint_4 nmean, uint_4 nmax, bool fgnotrl)
    442487  :  memgr1(mem1), memgr2(mem2)
    443488{
     489  fgraw_ = fgraw;
    444490  nmax_ = nmax;
    445491  nmean_ = nmean;
     492  if (fgraw_) cout << " BRProcB4C::BRProcB4C() - constructeur RAW data - NMean= " << nmean_ << endl;
     493  else cout << " BRProcB4C::BRProcB4C() - constructeur FFT data - NMean= " << nmean_ << endl;
    446494  stop_ = false;       
    447495  path_ = path;
    … …  
    450498
    451499/* --Methode-- */
    452 void BRProcBRaw4C::Stop()
     500void BRProcB4C::Stop()
    453501{
    454502 stop_=true;
    455  // cout <<" BRProcBRaw4C::Stop ... > STOP " << endl;
    456 }
    457 
    458 
    459 /* --Methode-- */
    460 void BRProcBRaw4C::run()
     503 // cout <<" BRProcB4C::Stop ... > STOP " << endl;
     504}
     505
     506
     507/* --Methode-- */
     508void BRProcB4C::run()
    461509{
    462510  setRC(1);     
    463511  try {
    464     Timer tm("BRProcBRaw4C", false);
     512    Timer tm("BRProcB4C", false);
    465513    TimeStamp ts;
    466514    BRPaqChecker pcheck1(!fgnotrl_);  // Verification/comptage des paquets
    … …  
    470518    size_t totnbytesproc = 0;
    471519
    472     cout << " BRProcBRaw4C::run() - Starting " << ts << " NMaxMemZones=" << nmax_
     520    cout << " BRProcB4C::run() - Starting " << ts << " NMaxMemZones=" << nmax_
    473521         << " NMean=" << nmean_ << endl;       
    474     cout << " BRProcBRaw4C::run()... - Output Data Path: " << path_ << endl;
     522    cout << " BRProcB4C::run()... - Output Data Path: " << path_ << endl;
    475523
    476524    uint_4 paqsz = memgr1.PaqSize();
    477525    uint_4 procpaqsz = memgr1.ProcPaqSize();
    478526    if ((paqsz != memgr2.PaqSize())||(procpaqsz!= memgr2.ProcPaqSize())) {
    479       cout << "BRProcBRaw4C::run()/ERROR : different paquet size -> stop \n ...(PaqSz1="
     527      cout << "BRProcB4C::run()/ERROR : different paquet size -> stop \n ...(PaqSz1="
    480528           << paqsz << " Sz2=" << memgr2.PaqSize() << " ProcPaqSz1="
    481529           << procpaqsz << " Sz2=" << memgr2.ProcPaqSize() << " )" << endl;
    … …  
    504552    TVector< complex<r_4> > visiV24( szfour );
    505553    // cout << " *DBG*AAAAA ---- Vectors OK" << endl;
    506     cout << " *DBG*BRProcBRaw4C PaqSz=" << paqsz << " ProcPaqSize=" << procpaqsz
     554    cout << " *DBG*BRProcB4C PaqSz=" << paqsz << " ProcPaqSize=" << procpaqsz
    507555         << " procpaqsz/2=" << procpaqsz/2 << " cfour.Size()=" << szfour
    508556         << " *8="  << szfour*8 << endl;
    … …  
    537585      Byte* buff1 = memgr1.GetMemZone(mid1);
    538586      if (buff1 == NULL) {
    539          cout << " BRProcBRaw4C::run()/ERROR memgr.GetMemZone(" << mid1 << ") -> NULL" << endl;
     587         cout << " BRProcB4C::run()/ERROR memgr.GetMemZone(" << mid1 << ") -> NULL" << endl;
    540588             break;             
    541589      }
    542590      Byte* procbuff1 = memgr1.GetProcMemZone(mid1);
    543591      if (procbuff1 == NULL) {
    544             cout << " BRProcBRaw4C::run()/ERROR memgr.GetProcMemZone(" << mid1 << ") -> NULL" << endl;
     592            cout << " BRProcB4C::run()/ERROR memgr.GetProcMemZone(" << mid1 << ") -> NULL" << endl;
    545593        break; 
    546594      }
    … …  
    548596      Byte* buff2 = memgr2.GetMemZone(mid2);
    549597      if (buff1 == NULL) {
    550          cout << " BRProcBRaw4C::run()/ERROR memgr.GetMemZone(" << mid2 << ") -> NULL" << endl;
     598         cout << " BRProcB4C::run()/ERROR memgr.GetMemZone(" << mid2 << ") -> NULL" << endl;
    551599             break;             
    552600      }
    553601      Byte* procbuff2 = memgr2.GetProcMemZone(mid2);
    554602      if (procbuff2 == NULL) {
    555             cout << " BRProcBRaw4C::run()/ERROR memgr.GetProcMemZone(" << mid2 << ") -> NULL" << endl;
     603            cout << " BRProcB4C::run()/ERROR memgr.GetProcMemZone(" << mid2 << ") -> NULL" << endl;
    556604        break; 
    557605      }
    … …  
    584632        if (fgfirst) {
    585633          firsttt=paq1.TimeTag();  firsttt2=paq2.TimeTag();
    586           cout << " BRProcBRaw4C()/Info First FC="<<curfc<<" , "<<curfc2<<" -> TT="
     634          cout << " BRProcB4C()/Info First FC="<<curfc<<" , "<<curfc2<<" -> TT="
    587635               << firsttt<<" , "<<firsttt2 <<endl;
    588636          fgfirst=false;
    … …  
    653701//        ts.SetNow();
    654702//        filog << ts << " :  proc file  " << fname << endl;                   
    655         cout << " BRProcBRaw4C::run() created file  " << fname << endl;
     703        cout << " BRProcB4C::run() created file  " << fname << endl;
    656704      }   
    657705      double okfrac = (nokpaq>1)?((double)noksfc/(double)nokpaq*100.):0.;
    658       cout << "BRProcBRaw4C ["<<kmz<<"] NOKPaq=" << nokpaq << " NSameFC=" << noksfc
     706      cout << "BRProcB4C ["<<kmz<<"] NOKPaq=" << nokpaq << " NSameFC=" << noksfc
    659707           << " (" << okfrac << " %)" << endl;
    660708      totnokpaq += nokpaq;
    661709      totnoksfc += noksfc;
    662710    }  // Fin de boucle sur les zones a traiter
    663     cout << " ------------------  BRProcBRaw4C::run() END ----------------- " << endl;
     711    cout << " ------------------  BRProcB4C::run() END ----------------- " << endl;
    664712    {     
    665713    dt.Info()["FirstTT1"]=firsttt;     
    … …  
    670718    POutPersist po(fname);
    671719    po << PPFNameTag("ttfc") << dt;
    672     cout << " BRProcBRaw4C::run() created TimeTag/FrameCounter file " << fname  << endl;
     720    cout << " BRProcB4C::run() created TimeTag/FrameCounter file " << fname  << endl;
    673721    }     
    674722    ts.SetNow();
    … …  
    681729//  cout << pcheck1;
    682730//  cout << pcheck2;
    683     cout << " BRProcBRaw4C::run()/Timing: \n";
     731    cout << " BRProcB4C::run()/Timing: \n";
    684732    tm.Print();
    685733    cout << " ---------------------------------------------------------- " << endl;
    686734}
    687735  catch (PException& exc) {
    688     cout << " BRProcBRaw4C::run()/catched PException " << exc.Msg() << endl;
     736    cout << " BRProcB4C::run()/catched PException " << exc.Msg() << endl;
    689737    setRC(3);   
    690738    return;
    691739  }
    692740  catch(...) {
    693     cout << " BRProcBRaw4C::run()/catched unknown ... exception " << endl;
     741    cout << " BRProcB4C::run()/catched unknown ... exception " << endl;
    694742    setRC(4);   
    695743    return;

  • trunk/AddOn/TAcq/brproc.h

    r3656 r3683  
    1 #ifndef  BRPROCA_H_SEEN
    2 #define  BRPROCA_H_SEEN
     1#ifndef  BRPROC_H_SEEN
     2#define  BRPROC_H_SEEN
    33
    44//----------------------------------------------------------------
    5 // ---- classe de thread de traitememt  acquisition BAORadio -----
    6 // LAL -      R. Ansari - Juin/Juillet 2008
     5// Projet BAORadio - (C) LAL/IRFU  2008-2010
     6// Classes de threads de traitememt donnees BAORadio
    77//----------------------------------------------------------------
    88
    99
    10 #include "racqumem.h"
    1110#include <string>
    1211#include <vector>
    1312#include <iostream>
     13
     14#include "racqumem.h"
     15#include "brbaseproc.h"
    1416#include "sopnamsp.h"
    15 #include "zthread.h"
    16 
    17 #include "brtypes.h"
     17#include "tvector.h"
     18#include "ntuple.h"
     19#include "datatable.h"
    1820
    1921using namespace std;
    … …  
    2123
    2224//---------------------------------------------------------------------
    23 // Classe thread de traitement avec 2 voies par frame (donnees brutes)
     25// Classe de traitement - calcul de visibilite pour n fibres
     26//---------------------------------------------------------------------
     27class BRVisibilityCalculator : public BRBaseProcessor {
     28public:
     29  BRVisibilityCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000,
     30                         uint_4 freq1=0, uint_4 freq2=0, uint_4 nbfreq=1);
     31  virtual ~BRVisibilityCalculator(); // Fait le nettoyage final , sauvegarde des objets ...
     32
     33  virtual int Process();
     34protected:
     35  uint_4 nmean_;  // Nombre de spectres pour le calcul des moyennes
     36  string outpath_;  // directory pour fichiers de sortie
     37  uint_4 numfreq1_,numfreq2_,nbinfreq_;
     38  vector<uint_8> vframecount_;
     39  vector<uint_8> vtimetag_;
     40  vector<uint_8> vnpaqm_;
     41
     42};
     43
     44
     45//-------------------------------------------------------------------------
     46//    **** OBSOLETE : BRProcA2C et BRProcB4C
     47//   Anciennes classes de traitement (Avant Nov2009) utilises par mcrd.cc
     48//-------------------------------------------------------------------------
     49//---------------------------------------------------------------------
     50// Classe thread de traitement avec 2 voies par frame (donnees raw/FFT
    2451//---------------------------------------------------------------------
    2552
    … …  
    3562  o card : numero de carte , juste pour les impressions
    3663*/
    37 class BRProcARaw2C : public ZThread {
     64class BRProcA2C : public ZThread {
    3865public:
    39   BRProcARaw2C(RAcqMemZoneMgr& mem, string& path, uint_4 nmean=10,
    40                uint_4 nmax=100, bool fgtshist=false, uint_4 nfsmap=0,
    41               bool fgnotrl=false, int card=1);
     66  BRProcA2C(RAcqMemZoneMgr& mem, string& path, bool fgraw,
     67            uint_4 nmean=10, uint_4 nmax=100, bool fgtshist=false,
     68            uint_4 nfsmap=0, bool fgnotrl=false, int card=1);
    4269  virtual void run();
    4370  void Stop();
    … …  
    4673  RAcqMemZoneMgr& memgr;
    4774  bool stop_; 
     75  bool fgraw_;   // true -> raw data
    4876  uint_4 nmax_;  // Nombre maxi de blocs MemZone traites
    4977  uint_4 nmean_;  // Nombre de spectres pour le calcul des moyennes
    … …  
    5684
    5785//---------------------------------------------------------------------
    58 // Classe thread de traitement 2 x 2 voies/frames (Apres BRProcARaw2C)
     86// Classe thread de traitement 2 x 2 voies/paquet (Apres BRProcA2C)
    5987//---------------------------------------------------------------------
    6088/*-- Arguments du constructeur :
    … …  
    6795*/
    6896
    69 class BRProcBRaw4C : public ZThread {
     97class BRProcB4C : public ZThread {
    7098public:
    71   BRProcBRaw4C(RAcqMemZoneMgr& mem1, RAcqMemZoneMgr& mem2, string& path,
    72               uint_4 nmean=10, uint_4 nmax=100, bool fgnotrl=false);
     99  BRProcB4C(RAcqMemZoneMgr& mem1, RAcqMemZoneMgr& mem2, string& path,
     100            bool fgraw, uint_4 nmean=10, uint_4 nmax=100, bool fgnotrl=false);
    73101  virtual void run();
    74102  void Stop();
    … …  
    78106  RAcqMemZoneMgr& memgr2;
    79107  bool stop_; 
     108  bool fgraw_;   // true -> raw data
    80109  uint_4 nmax_;  // Nombre maxi de blocs MemZone traites
    81110  uint_4 nmean_;  // Nombre de blocs pour le calcul des moyennes

  • trunk/AddOn/TAcq/makefile

    r3675 r3683  
    66# all : traidio  tmtfft tstminifits tbrpaq tpciew tmtacq tstrdfits mfits2spec tsok
    77# all : traidio  tmtfft tstminifits tmtacq tstrdfits mfits2spec tsok mcrd
    8 all :  mfacq tmtacq mfits2spec mcrd svv2mtx tsok traidio tstminifits tbrpaq
     8all :  mfacq vismfib tmtacq mfits2spec mcrd svv2mtx tsok traidio tstminifits tbrpaq
    99
    1010clean :
    … …  
    5555## Lecture / traitement minifits multi-thread
    5656##   --------------
     57vismfib : $(EXE)vismfib
     58        echo '---mcrd made'
     59
     60$(EXE)vismfib : $(OBJ)vismfib.o  $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o $(OBJ)brpaqu.o \
     61             $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o
     62        $(CXXLINK) -o $(EXE)vismfib $(OBJ)vismfib.o $(OBJ)brparam.o  $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o \
     63                      $(OBJ)brpaqu.o $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(SOPHYAALLSLBLIST)
     64
     65$(OBJ)vismfib.o : vismfib.cc brfitsrd.h racqumem.h brproc.h brbaseproc.h racqurw.h
     66        $(CXXCOMPILE) -c  -o $(OBJ)vismfib.o vismfib.cc
     67
     68##   --------------
    5769mcrd : $(EXE)mcrd
    5870        echo '---mcrd made'
    5971
    60 $(EXE)mcrd : $(OBJ)mcrd.o  $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)racquproc.o $(OBJ)brpaqu.o \
     72$(EXE)mcrd : $(OBJ)mcrd.o  $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o $(OBJ)brpaqu.o \
    6173             $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o
    62         $(CXXLINK) -o $(EXE)mcrd $(OBJ)mcrd.o $(OBJ)brparam.o  $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)racquproc.o \
     74        $(CXXLINK) -o $(EXE)mcrd $(OBJ)mcrd.o $(OBJ)brparam.o  $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o \
    6375                      $(OBJ)brpaqu.o $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(SOPHYAALLSLBLIST)
    6476
    65 $(OBJ)mcrd.o : mcrd.cc brfitsrd.h racqumem.h brproc.h racqurw.h
     77$(OBJ)mcrd.o : mcrd.cc brfitsrd.h racqumem.h brproc.h brbaseproc.h racqurw.h
    6678        $(CXXCOMPILE) -c  -o $(OBJ)mcrd.o mcrd.cc
    6779
    … …  
    6981        $(CXXCOMPILE) -c -o $(OBJ)brfitsrd.o brfitsrd.cc
    7082
    71 $(OBJ)brproc.o : brproc.cc brproc.h racqumem.h brpaqu.h
     83$(OBJ)brproc.o : brproc.cc brproc.h  brbaseproc.h racqumem.h brpaqu.h
    7284        $(CXXCOMPILE) -c  -o $(OBJ)brproc.o brproc.cc
     85
     86$(OBJ)brbaseproc.o : brbaseproc.cc brbaseproc.h racqumem.h brpaqu.h
     87        $(CXXCOMPILE) -c  -o $(OBJ)brbaseproc.o brbaseproc.cc
    7388
    7489##   --------------

  • trunk/AddOn/TAcq/mcrd.cc

    r3658 r3683  
    6363static double LossRate=0.1;
    6464
     65static bool fgraw=true;  // true -> RAW data , false -> FFT data
    6566static bool fg4c=false;  // true -> 4 channels (2 fibers)
    6667static bool fgrdfits=true;  // false -> Don't read fits files, generate paquets
    … …  
    7172int Usage(bool fgshort=true);
    7273// Pour traitement (calcul FFT et visibilites (ProcA) 1 fibre, 2 voies RAW)
    73 int Proc1FRawA(string& outname, string& inpath, int jf1, int jf2);
     74int Proc1FA(string& outname, string& inpath, int jf1, int jf2);
    7475// Pour traitement (calcul FFT et visibilites (ProcA,ProcB) 2 fibre, 4 voies RAW)
    75 int Proc2FRawAB(string& outname, string& path1, string& path2, int jf1, int jf2);
     76int Proc2FAB(string& outname, string& path1, string& path2, int jf1, int jf2);
    7677
    7778//----------------------------------------------------
    … …  
    9192    fgnotrl=false;   // true -> fichier fits SANS Trailer de frame (< mai 2009)
    9293    fghist=false;   // true -> histo des valeurs des time sample
     94    fgraw=true;     // raw data
    9395    if (act.substr(0,2)=="-4") fg4c=true;
    9496    if (act.length()>2) {
    9597      for(size_t ks=2; ks<act.length(); ks++) {
    96         if(act[ks]=='g') fgrdfits=false;
     98        if (act[ks]=='f') fgraw=false;
     99        else if(act[ks]=='g') fgrdfits=false;
    97100        else if(act[ks]=='n') fgnotrl=true;
    98101        else if(act[ks]=='h') fghist=true;
    … …  
    119122    ResourceUsage resu;
    120123    if (fg4c)
    121       rc =  Proc2FRawAB(outname, inpath, inpath2, imin, imax);
     124      rc =  Proc2FAB(outname, inpath, inpath2, imin, imax);
    122125    else
    123       rc =  Proc1FRawA(outname, inpath, imin, imax);
     126      rc =  Proc1FA(outname, inpath, imin, imax);
    124127    cout << resu ;
    125128  }
    … …  
    147150
    148151// Pour traitement (calcul FFT et visibilites (ProcA) 1 fibre, 2 voies RAW)
    149 int Proc1FRawA(string& outname, string& inpath, int imin, int imax)
     152int Proc1FA(string& outname, string& inpath, int imin, int imax)
    150153{
    151154  vector<string> infiles;
    … …  
    163166         << " NPaq in file=" << npaqf
    164167         << " PaqSz=" << paqsz << " NMaxZ=" << nmaxz << " NMean=" << NMean << endl;
     168    if (fgraw) cout << " ======>  RAW data processing " << endl;
     169    else cout << " ======>  FFT data processing " << endl;
    165170  }
    166171  else {
    … …  
    178183
    179184  outname += "/Ch12";
    180   BRProcARaw2C proc(mmgr, outname, NMean, nmaxz, fghist, NFreqSMap, fgnotrl);
    181 
    182   cout << " mcrd/Proc1FRawA: Starting threads (reader, proc) ... " << endl;
     185  BRProcA2C proc(mmgr, outname, fgraw, NMean, nmaxz, fghist, NFreqSMap, fgnotrl);
     186
     187  cout << " mcrd/Proc1FA: Starting threads (reader, proc) ... " << endl;
    183188
    184189  if (fgrdfits) reader.start();
    … …  
    187192  proc.start();
    188193  sleep(1);
    189   cout << " mcrd/Proc1FRawA: Waiting for reader thread to finish ... " << endl;
     194  cout << " mcrd/Proc1FA: Waiting for reader thread to finish ... " << endl;
    190195  if (fgrdfits) reader.join();
    191196  else pcird.join();
    192   cout << " mcrd/Proc1FRawA: Reader finished, waiting for process thread to finish ... " << endl;
     197  cout << " mcrd/Proc1FA: Reader finished, waiting for process thread to finish ... " << endl;
    193198  sleep(2);
    194199  mmgr.Stop();
    … …  
    200205
    201206// Pour traitement (calcul FFT et visibilites (ProcA) 1 fibre, 2 voies RAW)
    202 int Proc2FRawAB(string& outname, string& path1, string& path2, int imin, int imax)
     207int Proc2FAB(string& outname, string& path1, string& path2, int imin, int imax)
    203208{
    204209  vector<string> infiles1;
    … …  
    216221    DecodeMiniFitsHeader(infiles1[0],paqsz, npaqf, fgnotrl);
    217222    nmaxz = infiles1.size()*npaqf/NPaqinZone;
    218     cout << " mcrd/Proc2FRawAB/ReadFits: NZones=" << NZones << " NbPaq=" << NPaqinZone
     223    cout << " mcrd/Proc2FAB/ReadFits: NZones=" << NZones << " NbPaq=" << NPaqinZone
    219224         << " NPaq in file=" << npaqf
    220225         << " PaqSz=" << paqsz << " NMaxZ=" << nmaxz << " NMean=" << NMean << endl;
     226    if (fgraw) cout << " ======>  RAW data processing " << endl;
     227    else cout << " ======>  FFT data processing " << endl;
    221228  }
    222229  else {
    223230    paqsz = GPaqSz;
    224231    nmaxz = NGenZ;
    225     cout << " mcrd/Proc2FRawAB/GeneratePaquets: NZones=" << NZones << " NbPaq=" << NPaqinZone
     232    cout << " mcrd/Proc2FAB/GeneratePaquets: NZones=" << NZones << " NbPaq=" << NPaqinZone
    226233         << "  PaqSz=" << paqsz << " NMean=" << NMean << endl;
    227234  }
    … …  
    245252  string outname1 = outname;
    246253  outname1 += "/Ch12";
    247   BRProcARaw2C proc1(mmgr1, outname1, NMean, nmaxz, fghist, NFreqSMap, fgnotrl);
     254  BRProcA2C proc1(mmgr1, outname1, fgraw, NMean, nmaxz, fghist, NFreqSMap, fgnotrl);
    248255  string outname2 = outname;
    249256  outname2 += "/Ch34";
    250   BRProcARaw2C proc2(mmgr2, outname2, NMean, nmaxz, fghist, NFreqSMap, fgnotrl,2);
     257  BRProcA2C proc2(mmgr2, outname2, fgraw, NMean, nmaxz, fghist, NFreqSMap, fgnotrl,2);
    251258  string outname12 = outname;
    252259  outname12 += "/Ch1234";
    253   BRProcBRaw4C proc12(mmgr1, mmgr2, outname12, NMean, nmaxz, fgnotrl);
     260  BRProcB4C proc12(mmgr1, mmgr2, outname12, fgraw, NMean, nmaxz, fgnotrl);
    254261
    255262  cout << " mcrd/Proc2FRawAB: Starting threads (reader1,2, procA1,2, procAB) ... " << endl;
    … …  
    302309    return 1;
    303310  }
    304   cout << " ACT= -2[ghn] -> 1 fiber, 2 raw channel processing (ProcA)\n"
    305        << " ACT= -4[ghn] -> 2 fibers, 4 raw channels (ProcA, ProcB)\n"
     311  cout << " ACT= -2[ghnf] -> 1 fiber, 2 channel processing (ProcA)\n"
     312       << " ACT= -4[ghnf] -> 2 fibers, 4 channels (ProcA, ProcB)\n"
     313       << "   f FFT data ( raw if not) -> \n"
    306314       << "   n (notrl) -> FITS files without frame trailer \n"
    307315       << "   g (generate paquets) -> generate paquets instead of reading fits files\n"

  • trunk/AddOn/TAcq/mfacq.cc

    r3681 r3683  
    7272  }
    7373  catch (PCIEWException& exc) {
    74     cerr << " mfacq.cc catched MiniFITSException " << exc.Msg() << endl;
     74    cerr << " mfacq.cc catched PCIEWException " << exc.Msg() << endl;
    7575    rc = 75;
    7676  } 
    … …  
    137137    cout <<"mfacq[2] CreatePCIEWrapperV6- indice " << i <<  "INIT card " << card
    138138         << " fibre " << cardfiber << endl;
    139     pciwp[i] =  CreatePCIEWrapperV6(card,acpar.PatternSize(),acpar.dmasizekb,acpar.activate_pattern,cardfiber);
     139    pciwp[i] =  CreatePCIEWrapperV6(card,acpar.PatternSize(),acpar.DMASizeBytes(),acpar.activate_pattern,cardfiber);
    140140  }
    141141#else

  • trunk/AddOn/TAcq/minifits.h

    r3658 r3683  
    4747  void Close();
    4848
     49  inline bool IsOpen() { return (fip!=NULL) ; }
    4950  inline MiniFITS_DT DataType() { return dtype; }
    5051  string DataTypeToString(); 

  • trunk/AddOn/TAcq/pciewrap.cc

    r3671 r3683  
    99#include <math.h>
    1010#include <iostream>
     11
     12using namespace SOPHYA;
    1113
    1214/* --Methode-- */

  • trunk/AddOn/TAcq/pciewrap.h

    r3645 r3683  
    6464  BRPaqChecker pchk_;
    6565//  FMTRandGen rg_;
    66   ThSDR48RandGen rg_;
     66  SOPHYA::ThSDR48RandGen rg_;
    6767};
    6868

  • trunk/AddOn/TAcq/racqumem.cc

    r3671 r3683  
    11#include "racqumem.h"
     2
     3using namespace SOPHYA;
    24
    35//----------------------------------------------------------------
    … …  
    2931  st.act = (uint_4)MemZA_None;
    3032  st.stat = (uint_4)MemZS_Free;
    31   for(int k=0; k<6; k++) st.nbact[k] = 0;
     33  for(int k=0; k<MXNACTMZM; k++) st.nbact[k] = 0;
    3234  uint_8 mzsz = nfibres*npaq*paqsz;
    3335  uint_8 procmzsz = nfibres*npaq*procpaqsz;
    … …  
    4042  serial_ = 0;
    4143  SetFinalizedMask();
     44  SetProcSavedReadyMask();
    4245}
    4346
    … …  
    122125        if (rid >= 0) states[rid].act = MemZA_ProcC;             
    123126        break;
     127      case MemZA_ProcD:
     128        for(uint_4 k=0; k<NbZones(); k++) {
     129          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
     130              (states[k].stat & MemZS_ProcC) && !(states[k].stat & MemZS_ProcD) ) {
     131            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
     132          }
     133        }
     134        if (rid >= 0) states[rid].act = MemZA_ProcD;             
     135        break;
     136      case MemZA_ProcE:
     137        for(uint_4 k=0; k<NbZones(); k++) {
     138          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
     139              (states[k].stat & MemZS_ProcD) && !(states[k].stat & MemZS_ProcE) ) {
     140            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
     141          }
     142        }
     143        if (rid >= 0) states[rid].act = MemZA_ProcE;             
     144        break;
     145      case MemZA_ProcF:
     146        for(uint_4 k=0; k<NbZones(); k++) {
     147          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
     148              (states[k].stat & MemZS_ProcE) && !(states[k].stat & MemZS_ProcF) ) {
     149            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
     150          }
     151        }
     152        if (rid >= 0) states[rid].act = MemZA_ProcF;             
     153        break;
     154      case MemZA_SaveProc:
     155        for(uint_4 k=0; k<NbZones(); k++) {
     156          if ((states[k].act == MemZA_None) &&
     157              (states[k].stat & mask_saveproc_ready_) && !(states[k].stat & MemZS_SavedProc) ) {
     158            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
     159          }
     160        }
     161        if (rid >= 0) states[rid].act = MemZA_SaveProc;
     162        break;
    124163      case MemZA_None:   // MTQ pour supprimer un warning
    125164        break;
    … …  
    177216    case MemZS_ProcC :
    178217      if (states[id].act != MemZA_ProcC)  rc = 64;
    179       else states[id].nbact[4]++;         
     218      else states[id].nbact[5]++;         
    180219      states[id].stat |= MemZS_ProcC;
    181220      states[id].act = MemZA_None;
    182221      break;
     222    case MemZS_ProcD :
     223      if (states[id].act != MemZA_ProcD)  rc = 128;
     224      else states[id].nbact[6]++;         
     225      states[id].stat |= MemZS_ProcD;
     226      states[id].act = MemZA_None;
     227      break;
     228    case MemZS_ProcE :
     229      if (states[id].act != MemZA_ProcE)  rc = 256;
     230      else states[id].nbact[7]++;         
     231      states[id].stat |= MemZS_ProcE;
     232      states[id].act = MemZA_None;
     233      break;
     234    case MemZS_ProcF :
     235      if (states[id].act != MemZA_ProcF)  rc = 512;
     236      else states[id].nbact[8]++;         
     237      states[id].stat |= MemZS_ProcF;
     238      states[id].act = MemZA_None;
     239      break;
     240    case MemZS_SavedProc :
     241      if (states[id].act != MemZA_SaveProc)  rc = 1024;
     242      else states[id].nbact[9]++;         
     243      states[id].stat |= MemZS_ProcF;
     244      states[id].act = MemZA_None;
     245      break;
    183246    default :
    184       rc = 128;
     247      rc = 65536;
    185248      states[id].serial = 0;
    186249      states[id].stat = MemZS_Free;
    … …  
    193256}
    194257
    195 /*  MIS en inline
    196 Byte* RAcqMemZoneMgr::GetMemZone(int id)
    197 {
    198   if ((id < 0) || (id >= memzones.size()))  return NULL;
    199   return memzones[id];
    200 }
    201 */
    202258ostream& RAcqMemZoneMgr::Print(ostream& os)
    203259{
    … …  
    208264         << " ProcZoneSize()=" << ProcZoneSize() << endl;
    209265  else cout << " ... NO Processed Data Zones" << endl;
    210   for(uint_4 k=0; k<states.size(); k++)
     266  for(uint_4 k=0; k<states.size(); k++) {
    211267    os << " [" << k << "] Act=" << states[k].act << " Stat=" << states[k].stat
    212        << " NbAct[0..5]=" << states[k].nbact[0] << "," << states[k].nbact[1]
    213        << "," << states[k].nbact[2] << "," << states[k].nbact[3]
    214        << "," << states[k].nbact[4] << "," << states[k].nbact[5] << endl;       
     268       << " NbAct[0.."<< MXNACTMZM-1 << "]=" << states[k].nbact[0];
     269    for(uint_4 j=1; j<MXNACTMZM; j++)  cout << "," << states[k].nbact[j];
     270    cout << endl;
     271  }
    215272  return os;   
    216273}

  • trunk/AddOn/TAcq/racqumem.h

    r3658 r3683  
    1111
    1212
    13 #include "machdefs.h"
     13#include "zthread.h"
    1414#include <string>
    1515#include <vector>
    1616#include <iostream>
    17 #include "sopnamsp.h"
    18 #include "zthread.h"
    19 // #include "dmamgrintf.h"
    2017#include "brtypes.h"
    21 #include "pciewrap.h"
     18
    2219using namespace std;
    2320
    24 // Structure de gestion utilisee par la classe RAcqMemMgr
    25 typedef struct {
    26   uint_8 serial;    // Numero de serie permettant d'ordonner en temps les zones memoire rempli
    27   uint_4 act;       // Indique l'action en cours sur une zone Fill,Save ...
    28   uint_4 stat;      // Champ de flag (bits) indiquant les operations effectuees sur la zone
    29   uint_4 nbact[6];  // compteurs nb de fois ou (fill,save,proc,procA/B/C) a ete effectuee sur la zone
    30 //  int tid;        Pas utilise pour le moment, permet l'identification du thread operant sur la zone
    31 } St_MemZ;
    32 
     21//-----------------------------------------------------------------------
     22// Projet BAORadio - (C) LAL/IRFU  2008-2010
     23//  Structures de gestion memoire et synchronisation inter-threads
     24//-----------------------------------------------------------------------
    3325
    3426// Les flags (bits) correspondant aux operations effectuees sur une zone
    35 // Free->libre, Filled->rempli(par DMA), Saved(ecrit sur disque), Proc(Traitement)
    36 // ProcA/B/C : Trois traitement qui doivent s'enchainer
     27// + Free : libre,
     28// + Filled : rempli (par DMA ou lecture fits)
     29// + Saved : ecrit sur disque
     30// + Proc : traite (utilise principalement pour le monitoring durant l'acquisition)
     31// + ProcA/B/C/D/E/F : Un maximum de SIX traitements qui peuvent s'enchainer
     32// + ProcSaved : ecrit sur disque apres traitement
     33
    3734enum MemZStatus { MemZS_Free=0, MemZS_Filled=1, MemZS_Saved=2, MemZS_Proc=4,
    38                   MemZS_ProcA=8, MemZS_ProcB=16, MemZS_ProcC=32 };
    39 // L'action en cours sur une zone
     35                  MemZS_ProcA=8, MemZS_ProcB=16, MemZS_ProcC=32,
     36                  MemZS_ProcD=64, MemZS_ProcE=128, MemZS_ProcF=256,
     37                  MemZS_SavedProc=16384 };
     38
     39// L'action en cours sur une zone (associe aux flags MemZStatus ci-dessus)
    4040enum MemZaction { MemZA_None=0, MemZA_Fill=1, MemZA_Save=2, MemZA_Proc=4,
    41                   MemZA_ProcA=8, MemZA_ProcB=16, MemZA_ProcC=32 };
     41                  MemZA_ProcA=8, MemZA_ProcB=16, MemZA_ProcC=32,
     42                  MemZA_ProcD=64, MemZA_ProcE=128, MemZA_ProcF=256,
     43                  MemZA_SaveProc=16384 };
    4244
    4345// configuration du RAcqMemZoneMgr
    … …  
    4850enum MemZRunState { MemZR_Running=0, MemZR_Waiting=1, MemZR_Stopped=2};
    4951
     52
     53// --------------------------------------------------------------------
     54// Structure de gestion utilisee par la classe RAcqMemMgr
     55#define MXNACTMZM  10
     56typedef struct {
     57  uint_8 serial;    // Numero de serie permettant d'ordonner en temps les zones memoire rempli
     58  uint_4 act;       // Indique l'action en cours sur une zone Fill,Save ...
     59  uint_4 stat;      // Champ de flag (bits) indiquant les operations effectuees sur la zone
     60  uint_4 nbact[MXNACTMZM];  // compteurs nb de fois ou (fill,save,proc,procA/B/C) a ete effectuee sur la zone
     61//  int tid;        Pas utilise pour le moment, permet l'identification du thread operant sur la zone
     62} St_MemZ;
    5063
    5164
    … …  
    91104  inline uint_4 GetFinalizedMask() { return mask_finalized_; }
    92105
    93   // Retourne un MemZone disponible pour une action specifique
     106  // Definit l'etat des operations obligatoires avant qu'une zone
     107  // ne puissent etre sauvee apres traitement (subir l'action ProcSaved)
     108  inline void   SetProcSavedReadyMask(uint_4 mask=((uint_4)MemZS_ProcA))
     109    { mask_saveproc_ready_ = mask; }
     110  inline uint_4 GetProcSavedReadyMask() { return mask_saveproc_ready_; }
     111
     112  // Retourne l'identificateur d'une zone memoire disponible pour une action specifique
    94113  int FindMemZoneId(MemZaction act);
    95114  // Libere une zone memoire en marquant son etat
    96115  int FreeMemZone(int id, MemZStatus st);
    97   // Retourne le pointeur de la zone numero k pour les datas
    98116
    99117  // Retourne le pointeur de la zone numero k pour les datas pour une fibre donnee
    … …  
    120138 
    121139  ostream& Print(ostream& os);
     140  inline ostream& Print() { return Print(cout); }
    122141
     142  // Pour controler l'etat d'execution global
    123143  void Stop();
    124144  inline MemZRunState GetRunState()
    … …  
    131151
    132152  // ... variables membres
    133   ZMutex mex;   
     153  SOPHYA::ZMutex mex;   
    134154  uint_4  nzones, nfibres, npaq, paqsz, procpaqsz;
    135155//  DMAMgrInterface &dma_;
    … …  
    140160  MemZRunState runstate_;
    141161  uint_4 mask_finalized_;
     162  uint_4 mask_saveproc_ready_;
    142163  uint_8 serial_; 
    143164};

  • trunk/AddOn/TAcq/racquproc.cc

    r3682 r3683  
    1717#include "fftpserver.h"
    1818#include "fftwserver.h"
     19#include "histos.h"
    1920
    2021#include "FFTW/fftw3.h"
    … …  
    140141  fftwf_plan plan = fftwf_plan_dft_r2c_1d(vx.Size(), vx.Data(),
    141142                                          (fftwf_complex *)cfour.Data(), FFTW_ESTIMATE);
     143
     144  // Histo pour valeurs des bytes dans les paquets
     145  Histo* phist[2*MAXNBFIB] = {NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL};
     146  if (par_.fgdatafft) {    // data de type FFT   
     147    for(sa_size_t lc=0; lc<2*memgr.NbFibres(); lc++) 
     148      phist[lc] = new Histo(-128.5,+128.5,257);
     149  }
     150  else {
     151    for(sa_size_t lc=0; lc<2*memgr.NbFibres(); lc++) 
     152      phist[lc] = new Histo(-0.5,256.5,257);   
     153  }
     154
    142155  TimeStamp ts;   
    143156  char fname[512];
    … …  
    178191        if (par_.fgdatafft) {    // Traitement data de type FFT
    179192          TwoByteComplex* tbcp=paq.Data1C();
    180           for(sa_size_t j=1; j<spectre_.NCols(); j++)
     193          for(sa_size_t j=1; j<spectre_.NCols(); j++) {
     194            phist[lc]->Add((r_4)tbcp[j].realD());
     195            phist[lc]->Add((r_4)tbcp[j].imagD());
    181196            spectre_(lc,j) += Zmod2(tbcp[j]);
     197          }
    182198          nzm_[lc]++;   
    183199          tbcp=paq.Data2C();   lc++;
    184           for(sa_size_t j=1; j<spectre_.NCols(); j++)
     200          for(sa_size_t j=1; j<spectre_.NCols(); j++) {
     201            phist[lc]->Add((r_4)tbcp[j].realD());
     202            phist[lc]->Add((r_4)tbcp[j].imagD());
    185203            spectre_(lc,j) += Zmod2(tbcp[j]);
     204          }
    186205          nzm_[lc]++;
    187206        }
    188207        else {   // Traitement RawData
    189           for(sa_size_t j=0; j<vx.Size(); j++)
     208          for(sa_size_t j=0; j<vx.Size(); j++) {
     209            phist[lc]->Add((r_8)(*(paq.Data1()+j)));
    190210            vx(j) = (r_4)(*(paq.Data1()+j))-127.5;
     211          }
    191212          fftwf_execute(plan);
    192213          //   ffts_.FFTForward(vx, cfour_);
    … …  
    194215            spectre_(lc,j) += Zmod2(cfour(j+1));
    195216          nzm_[lc]++;      lc++;
    196           for(sa_size_t j=0; j<vx.Size(); j++)
     217          for(sa_size_t j=0; j<vx.Size(); j++) {
     218            phist[lc]->Add((r_8)(*(paq.Data2()+j)));
    197219            vx(j) = (r_4)(*(paq.Data2()+j))-127.5;
     220          }
    198221          fftwf_execute(plan);
    199222          //    ffts_.FFTForward(vx, cfour_);
    … …  
    223246      nfiles_++;
    224247      POutPersist po(fname);
    225       //      po << PPFNameTag("spectre") << spectre_;
    226       po << spectre_;       
     248      po << PPFNameTag("spectre") << spectre_;
    227249      spectre_ = (r_4)(0.);
    228       for(int lc=0; lc<2*memgr.NbFibres(); lc++)  nzm_[lc]=0;
     250      char buftag[32];
     251      for(int lc=0; lc<2*memgr.NbFibres(); lc++)  {
     252        sprintf(buftag,"hvalV%d",(int)lc);
     253        po << PPFNameTag(buftag) << (*phist[lc]);
     254        phist[lc]->Zero();
     255        nzm_[lc]=0;
     256      }
    229257      ts.SetNow();
    230258      // Calcul / impression fraction des paquets avec same-framecounter
    … …  
    258286    sprintf(fname,"%s/meanspec%d.ppf",path_.c_str(),(int)nfiles_);
    259287    POutPersist po(fname);
    260     po << spectre_;     
     288    po << PPFNameTag("spectre") << spectre_;
    261289    spectre_ = (r_4)(0.);
    262     for(int lc=0; lc<2*memgr.NbFibres(); lc++)  nzm_[lc]=0;
     290    char buftag[32];
     291    for(int lc=0; lc<2*memgr.NbFibres(); lc++)  {
     292      sprintf(buftag,"hvalV%d",(int)lc);
     293      po << PPFNameTag(buftag) << (*phist[lc]);
     294      delete phist[lc];
     295      nzm_[lc]=0;
     296    }
    263297    ts.SetNow();
    264298    // Calcul / impression fraction des paquets avec same-framecounter

  • trunk/AddOn/TAcq/racqurw.cc

    r3677 r3683  
    813813        // Sans TRAILER de paquet mff.setDTypeNaxis(MF_Byte, paq0.DataSize()+paq0.HeaderSize(), npaqperfile);
    814814        }
     815        AddFitsKWStart(mff,bpar);
    815816        fnum++;   fgfirstfctt=true;
    816817      }
    … …  
    870871          framecnt_last_[fib] = pcheck[fib].LastFrameNum();
    871872
    872         AddFitsKW(mff,bpar);
     873        AddFitsKWEnd(mff,bpar);
    873874        for(uint_4 fib=0; fib<memgr.NbFibres(); fib++) {
    874875          header[fib].close();
    … …  
    906907
    907908/* --Methode-- */
    908 int MultiDataSaver::AddFitsKW(MiniFITSFile* mff, BRAcqConfig& acpar)
     909int MultiDataSaver::AddFitsKWStart(MiniFITSFile* mff, BRAcqConfig& acpar)
    909910{
    910911  TimeStamp ts;
    … …  
    913914  bool hassrc=false;
    914915  if (skysrc.length()>0)  hassrc=true;
     916  bool fgredpsz = acpar.GetParams().fgreducpsize;
    915917  for(uint_4 fib=0; fib<memgr.NbFibres(); fib++) {
    916     mff[fib].AddKeyS("DATE", cdtu.c_str(), " File Creation time(YYYY-MM-DDThh:mm:ss UT) ");       
    917918    mff[fib].AddKeyS("DATEOBS", cdtu.c_str(), " Observation Time (YYYY-MM-DDThh:mm:ss UT) ");
     919    mff[fib].AddKeyS("TMSTART", cdtu.c_str(), " File Acqu. Start Time/Date  ");   
    918920    mff[fib].AddKeyD("ACQVER", acpar.AcqVersion(), " BAORadio Acq Software version ") ;
    919921    mff[fib].AddKeyS("ACQMODE", acpar.GetParams().AcqMode, " BAORadio Acq run  mode" );
     922    mff[fib].AddKeyS("BRPAQCFMT", BRPaquet::FmtConvToString(acpar.GetParams().GetDataConvFg()),
     923                         " BAORadio BRPaquet DataFormatConversion" );
    920924    mff[fib].AddKeyI("FIBERNUM", acpar.GetParams().FiberNum[fib], " Fiber number/id") ;
    921925    if (hassrc)
    922926      mff[fib].AddKeyS("SKYSOURC", skysrc, " Source identification" );
     927    if (fgredpsz) {
     928      mff[fib].AddKeyS("REDPSZMOD", BRPaquet::ReducActionToString(acpar.GetParams().pqreducmode),
     929                          "PaquetSize Reduction Mode") ;
     930      mff[fib].AddKeyI("REDPSZOF", acpar.GetParams().reducoffset," PaquetSize Reduction Offset") ;
     931    }
     932  }
     933  return 0;
     934}
     935
     936/* --Methode-- */
     937int MultiDataSaver::AddFitsKWEnd(MiniFITSFile* mff, BRAcqConfig& acpar)
     938{
     939  TimeStamp ts;
     940  string cdtu=ts.ToString();
     941  for(uint_4 fib=0; fib<memgr.NbFibres(); fib++) {
     942    mff[fib].AddKeyS("TMEND", cdtu.c_str(), " File Acqu. End Time/Date  ");       
    923943    mff[fib].AddKeyI("FCFIRST", framecnt_first_[fib], " First valid frame counter in file") ;
    924944    mff[fib].AddKeyI("FCLAST", framecnt_last_[fib], " Last valid frame counter in file") ;

  • trunk/AddOn/TAcq/racqurw.h

    r3681 r3683  
    170170  inline void STOP() { stop_ = true; } 
    171171protected:
    172   int  AddFitsKW(MiniFITSFile* mff, BRAcqConfig& acpar);
     172  int  AddFitsKWStart(MiniFITSFile* mff, BRAcqConfig& acpar);
     173  int  AddFitsKWEnd(MiniFITSFile* mff, BRAcqConfig& acpar);
    173174
    174175  RAcqMemZoneMgr& memgr;
Note: See TracChangeset for help on using the changeset viewer.