Changeset 3872 in Sophya for trunk


Ignore:
Timestamp:
Aug 28, 2010, 12:43:04 AM (15 years ago)
Author:
ansari
Message:

Ajout classe BRFFTCalculator et programme specmfib.cc, Reza 28/08/2010

Location:
trunk/AddOn/TAcq
Files:
3 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/AddOn/TAcq/README

    r3658 r3872  
    2929  - racquproc.h racquproc.cc : la classe thread de traitement des donnees
    3030
    31         ================ Remote ====================
     31       
    3232
    33 5/ Ensemble de classes + programme test developpes en 2005, pour I/O PPF sur
     335/  ================ Remote ====================
     34  Ensemble de classes + programme test developpes en 2005, pour I/O PPF sur
    3435   stream IP - provenaant du repertoire Remote
    3536  - swrapsock.h swrapsock.cc : Classes Socker ServerSocket ClientSocket
    … …  
    5051   serverName : Name or IP adress of the machine where tsok S is running
    5152   NLoop,SizeX,SizeY: Number of transfers, 2D array size for OPEMsg=PPFSOCKET
    52 
     53   ================================================
    5354
    54556/ --- Avril 2009
    … …  
    6566     de plusieurs fibres dans un meme objet RAcqMemZoneMgr
    6667   o Amelioration de la classe MiniFITSFile pour permettre l'ajout d'information ds l'entete FITS
     68
     698/ --- Novembre/Decembre 2009
     70   o Introduction des classes lecteur fits multi-fibres ( BRMultiFitsReader ), classe de base
     71   thread de traitement (BRBaseProcessor)
     72   o Classe d'ecriture de cube de donnees fits multi-fibres FitsCubeWriter
     73   o Classe de calcul de visibilites BRVisibilityCalculator
     74   o Introduction du nouveau programme d'acquisition mfacq.cc  (Nov 2009)
     75
     769/ --- Avril/Mai 2010
     77   o Calcul parallele pour visibilites ( BRVisCalcGroup ) 
     78   o Programme de lecture multi-fibres (treadmfib) calcul des visibilites (vismfib)
     79   o Nouvelle structuire du programme d'acquisition pour echange sur ethernet
     80     Classes PCIEToEthernet , EthernetReader
     81
     8210/ --- Aout/Septembre 2010
     83   o Ajout processeur de calcul de TF sur donnees brutes ( BRFFTCalculator )
     84   o Amelioration classe BRMeanSpecCalculator et ajout programme specmfib.cc

  • trunk/AddOn/TAcq/branap.cc

    r3776 r3872  
    2525  nzones_=nzon;
    2626  npaqinzone_=npaqz;
     27  fgdatafft_=false;  fgsinglechannel_=false;
    2728  prtlevel_=0;
    2829  nbcalgrp_=1;
    … …  
    150151  char flnm[1024];
    151152  sprintf(flnm,"%s/signal%d.fits",dirlist_[0].c_str(),imin_);
    152   return DecodeMiniFitsHeader(flnm,paqsize_, npaqinfile_);
     153  return DecodeMiniFitsHeader(flnm,paqsize_, npaqinfile_,fgdatafft_, fgsinglechannel_);
    153154}
    154155
    … …  
    165166  cout << " PaqSize=" << paqsize_ << "  -  NZones=" << nzones_ << " NPaqZone=" << npaqinzone_
    166167       << " PrtLevel=" << prtlevel_ << endl;
     168  cout << " AcqMode: " << ((fgdatafft_)?" Data_FFT " : " Data_Raw " )
     169       << ((fgsinglechannel_)?" SingleChannel " : " TwoChannels " ) << endl;
    167170  cout << " NbVisibCalculator in Group: " <<  nbcalgrp_ << " with N//threads: " << nthreads_ << endl;
    168171
    … …  
    172175
    173176/* --Fonction-- */
    174 int BRAnaParam::DecodeMiniFitsHeader(const char* filename, uint_4& paqsz, uint_4& npaq)
     177int BRAnaParam::DecodeMiniFitsHeader(const char* filename, uint_4& paqsz, uint_4& npaq,
     178                                     bool& fgdatafft, bool& fgsinglechannel)
    175179{
    176180  cout << " DecodeMiniFitsHeader - Opening file: " << filename << endl;
    177181  MiniFITSFile mff(filename, MF_Read);
     182  string acqmode=mff.GetKeyValue("ACQMODE");
    178183  cout << "DecodeMiniFitsHeader()... Type=" << mff.DataTypeToString() << " NAxis1=" << mff.NAxis1()
    179        << " NAxis2=" << mff.NAxis2() << endl;
     184       << " NAxis2=" << mff.NAxis2() << " AcqMode=" << acqmode << endl;
    180185  paqsz = mff.NAxis1();
    181186  npaq = mff.NAxis2();
     187  if (acqmode.substr(0,3)=="fft") fgdatafft=true;
     188  if (acqmode.find("1c") < acqmode.length()) fgsinglechannel=true;
    182189  return 0;
    183190}

  • trunk/AddOn/TAcq/branap.h

    r3776 r3872  
    2525  ostream& Print(ostream& os);
    2626
    27   static int DecodeMiniFitsHeader(const char* filename, uint_4& paqsz, uint_4& npaq);
     27  static int DecodeMiniFitsHeader(const char* filename, uint_4& paqsz, uint_4& npaq,
     28                                  bool& fgdatafft, bool& fgsinglechannel);
    2829
    2930  vector<string> dirlist_;
    … …  
    3738  uint_4 nzones_, npaqinzone_;
    3839  uint_4 npaqinfile_;    // nombre de paquets dans un fichier p
     40  bool fgdatafft_;  // true -> donnee FFT (provenant du firmware FFT)
     41  bool fgsinglechannel_; // true -> un seul canal par fibre (par defaut=2 canaux/fibres)
    3942  int prtlevel_;
    4043  uint_4 nbcalgrp_;    // Nb d'objets/threads dans BRVisCalcGroup

  • trunk/AddOn/TAcq/brbaseproc.cc

    r3779 r3872  
    1818/* --Methode-- */
    1919BRBaseProcessor::BRBaseProcessor(RAcqMemZoneMgr& memgr, MemZaction mmact)
    20   : memgr_(memgr), vpaq_(memgr.NbFibres()), vpchk_(memgr.NbFibres()), vfgok_(memgr.NbFibres()),
     20  : memgr_(memgr), fbuff_(memgr.NbFibres()), fprocbuff_(memgr.NbFibres()),
     21    vpaq_(memgr.NbFibres()), vprocpaq_(memgr.NbFibres()),
     22    vpchk_(memgr.NbFibres()), vfgok_(memgr.NbFibres()),
    2123    curfc_(memgr.NbFibres()), fcfirst_(memgr.NbFibres()), ttfirst_(memgr.NbFibres())
    2224{
    … …  
    2426  stop_ = false;
    2527  for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
    26     fbuff_.push_back(NULL);
     28    fbuff_[fib]=NULL;
     29    fprocbuff_[fib]=NULL;
    2730    vpaq_[fib]=BRPaquet(NULL,memgr_.PaqSize());
     31    vprocpaq_[fib]=NULL;
    2832    vpchk_[fib]=BRPaqChecker(true,0);
    2933    vfgok_[fib]=true;
    … …  
    7579  int rc=0;
    7680  try {
    77     cout << " BRBaseProcessor[" << bpid_ << "]::run() - Starting " << " NFibers=" << memgr_.NbFibres()
    78          << " NChan=" << 2*memgr_.NbFibres() << endl;   
     81    cout << "BRBaseProcessor[" << bpnom_ << "," << bpid_ << "]::run() - Starting " << " NFibers="
     82         << memgr_.NbFibres() << " NChan=" << 2*memgr_.NbFibres() << endl;     
    7983
    8084    size_t paqsz=memgr_.PaqSize();
     85    size_t procpaqsz=memgr_.ProcPaqSize();
    8186    bool fgrun=true;
    8287    while (fgrun) {
    … …  
    8792      //      if (buffg == NULL) {
    8893      if (mid < 0) {
    89         cout << "BRBaseProcessor[" << bpid_ << "]::run()/ERROR FindMemZoneId("
     94        cout << "BRBaseProcessor[" << bpnom_ << "," << bpid_ << "]::run()/ERROR FindMemZoneId("
    9095             << (int)mmact_ << ") ->" << mid << ") -> NULL" << endl;
    9196        setRC(7);      fgrun=false;             
    … …  
    95100        fbuff_[fib] = memgr_.GetMemZone(mid,fib);
    96101        if (fbuff_[fib] == NULL) { // cela ne devrait pas arriver
    97           cout << "BRBaseProcessor[" << bpid_ << "]::run()/ERROR memgr.GetMemZone(" << mid << "," << fib << ") -> NULL" << endl;
     102          cout << "BRBaseProcessor[" << bpnom_ << "," << bpid_ << "]::run()/ERROR memgr.GetMemZone("
     103               << mid << "," << fib << ") -> NULL" << endl;
     104          setRC(9);       fgrun=false;         
     105          break;
     106        }
     107        if ((procpaqsz>0)&&((fprocbuff_[fib]=memgr_.GetProcMemZone(mid,fib))==NULL)) {   // cela ne devrait pas arriver non plus
     108          cout << "BRBaseProcessor[" << bpnom_ << "," << bpid_ << "]::run()/ERROR memgr.GetProcMemZone("
     109               << mid << "," << fib << ") -> NULL" << endl;
    98110          setRC(9);       fgrun=false;         
    99111          break;
    … …  
    106118          vfgok_[fib] = vpchk_[fib].Check(vpaq_[fib],curfc_[fib]);
    107119          if (!vfgok_[fib])  fgokallfibers_=false;
     120          if (procpaqsz>0)    vprocpaq_[fib] = fprocbuff_[fib]+jp*procpaqsz;
    108121        }
    109122        //--- Traitement
    … …  
    124137    } // Fin de boucle sur les zones a traiter
    125138    //------------------------------------
    126     cout << " ---- END BRBaseProcessor[" << bpid_ << "]::run() , TotNbProcPaq=" << totprocnpaq_ << endl;
     139    cout << " ---- END BRBaseProcessor[" << bpnom_ << "," << bpid_ << "]::run() , TotNbProcPaq="
     140         << totprocnpaq_ << endl;
    127141    /*
    128142    for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  vpchk_[fib].Print();
    … …  
    131145  }
    132146  catch (std::exception& exc) {
    133     cout << " BRBaseProcessor[" << bpid_ << "]::run()/catched std::exception " << exc.what() << endl;
     147    cout << "BRBaseProcessor[" << bpnom_ << "," << bpid_ << "]::run()/catched std::exception " << exc.what() << endl;
    134148    setRC(98); 
    135149    return;
    136150  }
    137151  catch(...) {
    138     cout << " BRBaseProcessor[" << bpid_ << "]::run()/catched unknown ... exception " << endl;
     152    cout << "BRBaseProcessor[" << bpnom_ << "," << bpid_ << "]::run()/catched unknown ... exception " << endl;
    139153    setRC(99); 
    140154    return;

  • trunk/AddOn/TAcq/brbaseproc.h

    r3778 r3872  
    4646  bool stop_;
    4747  vector<Byte*> fbuff_;      // Vecteur de pointeur de zone memoire pour chaque fibre
     48  vector<Byte*> fprocbuff_;   // Vecteur de pointeur de proc_zone_mem pour chaque fibre
    4849  vector<BRPaquet> vpaq_;   // Vecteur de BRPaquet pour chaque fibre
     50  vector<Byte*> vprocpaq_;  // Vecteur de pointeur de zone memoire pour donnees traitees de chaque paquet/fibre
    4951  vector<BRPaqChecker> vpchk_;
    5052  vector<uint_8> vfgok_;    // Vecteur de flag si paquet OK pour chaque fibre

  • trunk/AddOn/TAcq/brproc.cc

    r3780 r3872  
    1 #include "racquproc.h"
     1//----------------------------------------------------------------
     2// Projet BAORadio - (C) LAL/IRFU  2008-2010
     3// Classes de threads de traitement pour BAORadio
     4//----------------------------------------------------------------
    25
    36#include <stdlib.h>
    … …  
    2629#include "brproc.h"
    2730
    28 //---------------------------------------------------------------------
    29 // Classe de traitement - calcul de visibilite pour n fibres
    30 //---------------------------------------------------------------------
    31 
    32 /* --Methode-- */
    33 BRVisibilityCalculator::BRVisibilityCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean, size_t nthr)
    34   : BRBaseProcessor(memgr), paralex_(*this, nthr), nparthr_(nthr),
    35     outpath_(outpath), nmean_(nmean), nbcalc_(1), calcid_(0), vpdata_(2*memgr.NbFibres())
    36     // , dtfos_(outpath+"visdt.fits", Fits_Create), visdt_(dtfos_, 1024, true);
    37 { 
    38   DefineRank(1,0);
    39 
    40   uint_4 maxnpairs = (2*memgr_.NbFibres()+1)*memgr_.NbFibres();
    41   chanum_.SetSize(maxnpairs);
    42   sa_size_t k=0;
    43   for(size_t i=0; i<2*memgr_.NbFibres(); i++)  vpdata_[i]=NULL;
    44   for(size_t i=0; i<2*memgr_.NbFibres(); i++) {
    45     for(size_t j=i; j<2*memgr_.NbFibres(); j++) {
    46       chanum_(k) = (i+1)*100+(j+1);  k++;
    47     }
    48   }
    49   SelectPairs();
    50 
    51   //  visdt_.AddFloatColumn("mfc");
    52   visdt_.AddDoubleColumn("mfc");
    53   visdt_.AddDoubleColumn("mtt");
    54   visdt_.AddIntegerColumn("jfreq");
    55   visdt_.AddIntegerColumn("numch");
    56   visdt_.AddFloatColumn("vre");
    57   visdt_.AddFloatColumn("vim");
    58 
    59   if (nmean_ < 1)  nmean_=memgr_.NbPaquets();
    60   if (nmean_ < 1)  nmean_=1;
    61 
    62   cout << " BRVisibilityCalculator::/Info  nmean=" << nmean_ << endl;
    63 
    64   totnbpaq_=0;
    65   numfile_=0;
    66   nb_flop_=0.;
    67   moyfc_=moytt_=0.;
    68 
    69   fgallfibok=NULL;
    70   fgcktt_=false;
    71   setNameId("viscalc", 0);
    72 }
    73 
    74 /* --Methode-- */
    75 BRVisibilityCalculator::~BRVisibilityCalculator()
    76 {
    77   cout << " BRVisibilityCalculator - Visibility Datatable : " << endl;
    78   cout << visdt_;
    79   string filename;
    80   filename = outpath_+"visdt.ppf";
    81   if (nbcalc_>1) {
    82     char sbuff[32];
    83     sprintf(sbuff,"visdt_%d",(int)calcid_);
    84     filename = outpath_+sbuff;
    85   }
    86   POutPersist po(filename);
    87   po << visdt_;
    88   if (calcid_ == 0) {
    89     POutPersist poc(outpath_+"chanum.ppf");
    90     poc << chanum_;
    91  
    92     if (fgcktt_) {
    93       cout << " BRVisibilityCalculator -  Check TimeTag done: TotNPaqProc= " << totnbpaq_ << endl;
    94       for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
    95         cout << " BRTTCheck-Fiber[" << fib << "] NBadTT=" << vbadtt_[fib] << " NDiffTT>5="
    96              << vndiff5tt_[fib] << "  NotSameTT=" << vnsamett_[fib] << endl;
    97       }
    98       POutPersist pott(outpath_+"ttfcmtx.ppf");
    99       pott << PPFNameTag("FC") << fcmtx_;
    100       pott << PPFNameTag("TT") << ttmtx_;     
    101     }
    102   }
    103 }
    104 
    105 /* --Methode-- */
    106 void BRVisibilityCalculator::DefineRank(uint_4 nbc, uint_4 cid)
    107 {
    108   if ((nbc>6)||(cid>=nbc))
    109     throw ParmError("BRVisibilityCalculator::DefineRank() NbCalc > 6 !");
    110   nbcalc_=nbc;
    111   calcid_=cid;
    112   if (nbcalc_>1) {
    113     uint_4 maxnpairs = (2*memgr_.NbFibres()+1)*memgr_.NbFibres();
    114     uint_4 npairs=maxnpairs/nbcalc_;
    115     if (calcid_==(nbcalc_-1))
    116       SelectPairs(calcid_*npairs, maxnpairs-calcid_*npairs);
    117     else
    118       SelectPairs(calcid_*npairs, npairs);
    119     MemZaction mmzas[6]={MemZA_ProcA,MemZA_ProcB,MemZA_ProcC,MemZA_ProcD,MemZA_ProcE,MemZA_ProcF};
    120     SetMemZAction(mmzas[calcid_]);
    121     setNameId("viscalc_grp", calcid_);
    122   }
    123   return ;
    124 }
    125 
    126 /* --Methode-- */
    127 uint_4 BRVisibilityCalculator::SelectPairs(uint_4 pair1, uint_4 nbpairs)
    128 {
    129   BRPaquet paq(memgr_.PaqSize());
    130   uint_4 maxnpairs = (2*memgr_.NbFibres()+1)*memgr_.NbFibres();
    131 
    132   if (pair1 >= maxnpairs)  pair1=maxnpairs-1;
    133   if (nbpairs > maxnpairs-pair1)  nbpairs=maxnpairs-pair1;
    134   pairst_=pair1;
    135   nbpairs_=nbpairs;
    136   vismtx_.SetSize(nbpairs_, paq.DataSize()/4);
    137   return nbpairs_;
    138 }
    139 
    140 /* --Methode-- */
    141 int BRVisibilityCalculator::SelectFreqBinning(uint_4 freq1, uint_4 freq2, uint_4 nbfreq)
    142 {
    143   jf1_=freq1; jf2_=freq2;
    144   if ((jf1_<1)||(jf1_>=vismtx_.NCols()))  jf1_=1;
    145   if ((jf2_<1)||(jf2_>=vismtx_.NCols())||(jf2_<jf1_))  jf2_=vismtx_.NCols()-1;
    146   if (nbfreq<1) nbfreq=1;
    147   djf_=(jf2_-jf1_)/nbfreq;
    148   if (djf_<1) djf_=0;
    149   cout << " BRVisibilityCalculator::SelectFreqBinning/Info  JF1=" << jf1_
    150        << " JF2=" << jf2_ << " DJF=" << djf_ << endl;
    151 
    152 }
    153 
    154 
    155 /* --Methode-- */
    156 int BRVisibilityCalculator::ActivateTimeTagCheck(uint_8 maxnpaq)
    157 {
    158   mindeltatt_=memgr_.PaqSize()/2;
    159   if (mindeltatt_<1) mindeltatt_=1;
    160   fcmtx_.SetSize(memgr_.NbFibres(), maxnpaq);
    161   ttmtx_.SetSize(memgr_.NbFibres(), maxnpaq);
    162   vlasttt_.resize(memgr_.NbFibres(), 0);
    163   vbadtt_.resize(memgr_.NbFibres(), 0);
    164   vnsamett_.resize(memgr_.NbFibres(), 0);
    165   vndiff5tt_.resize(memgr_.NbFibres(), 0);
    166 
    167   fgcktt_=true;
    168   cout << " BRVisibilityCalculator::ActivateTimeTagCheck() - TT/Fc matrix NCols=" << maxnpaq
    169        << " MinDeltaTT=" << mindeltatt_ << endl;
    170 
    171   return 0;
    172 }
    173 
    174 
    175 /* --Methode-- */
    176 void BRVisibilityCalculator::run()
    177 {
    178   cout << " BRVisibilityCalculator[" << calcid_ << "/" << nbcalc_
    179        << "]::run() - Starting " << " NFibers=" << memgr_.NbFibres()
    180        << " NChan=" << 2*memgr_.NbFibres() << " NPairs=" << nbpairs_ << " First:" << pairst_ << endl;   
    181  
    182   if (nparthr_ < 2)  return BRBaseProcessor::run();
    183   // Execution multithread parallele
    184   setRC(1);     
    185   int rc=0;
    186   try {
    187     if ((nmean_%memgr_.NbPaquets())!=0) {
    188       uint_4 mnmean = (nmean_/memgr_.NbPaquets()+1)*memgr_.NbPaquets();
    189       cout << " BRVisibilityCalculator::run()/Info changing nmean=" << nmean_  << " to multiple of"
    190            << " memgr_.NbPaquets() -> " << mnmean << endl;
    191       nmean_=mnmean;
    192     }
    193     paralex_.SetParallelTask(*this);
    194     cout << " BRVisibilityCalculator::run()/Info : starting ParallelExecutor with nThreads="
    195          << paralex_.nThreads() << " ... " << endl;
    196     paralex_.start();
    197 
    198     fgallfibok = new bool[memgr_.NbPaquets()];
    199 
    200     size_t paqsz=memgr_.PaqSize();
    201     bool fgrun=true;
    202     while (fgrun) {
    203       if (stop_) break;
    204       if (memgr_.GetRunState() == MemZR_Stopped) break;
    205       int mid = memgr_.FindMemZoneId(mmact_);  // (MemZA_ProcA);
    206       //      Byte* buffg = memgr_.GetMemZone(mid);
    207       //      if (buffg == NULL) {
    208       if (mid < 0) {
    209         cout << "BRVisibilityCalculator[" << calcid_ << "]::run()/ERROR FindMemZoneId("
    210              << (int)mmact_ << ") ->" << mid << ") -> NULL" << endl;
    211         setRC(7);      fgrun=false;             
    212         break; 
    213       }
    214       for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
    215         fbuff_[fib] = memgr_.GetMemZone(mid,fib);
    216         if (fbuff_[fib] == NULL) { // cela ne devrait pas arriver
    217           cout << "BRVisibilityCalculator[" << calcid_ << "]::run()/ERROR memgr.GetMemZone(" << mid << "," << fib << ") -> NULL" << endl;
    218           setRC(9);       fgrun=false;         
    219           break;
    220         }
    221       }
    222 
    223       if (totnbpaq_%nmean_ == 0) {
    224         if (totnbpaq_ > 0) {
    225           moyfc_/=nmean_;
    226           moytt_/=nmean_;
    227           vismtx_.Info()["MeanFC"] = moyfc_;
    228           vismtx_.Info()["MeanTT"] = moytt_;
    229           vismtx_.Info()["NPAQSUM"] = nmean_;
    230          
    231           // ATTENTION : Matrice visibilites non moyennee
    232           char nfile[48];
    233           if (nbcalc_==1)
    234             sprintf(nfile,"vismtx%d.ppf",numfile_);
    235           else
    236             sprintf(nfile,"vismtx_%d_%d.ppf",(int)calcid_,numfile_);
    237           string flnm=outpath_+nfile;
    238           POutPersist po(flnm);
    239           po << vismtx_;
    240           cout << numfile_ << "-BRVisibilityCalculator[" << calcid_ << "]::run() NPaqProc="
    241                << totnbpaq_ << "  -> Visibility Matrix in " << flnm << endl;
    242           FillVisibTable(moyfc_, moytt_);
    243           numfile_++;
    244         }
    245         vismtx_ = complex<r_4>((r_4)0.,(r_4)0.);
    246         moyfc_=moytt_=0.;
    247       }
    248 
    249       for(size_t jp=0; jp<memgr_.NbPaquets(); jp++) {   // boucle sur les paquets d'une zone 
    250         fgallfibok[jp]=fgokallfibers_=true;
    251         for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
    252           vpaq_[fib].Set(fbuff_[fib]+jp*paqsz);
    253           vfgok_[fib] = vpchk_[fib].Check(vpaq_[fib],curfc_[fib]);
    254           if (!vfgok_[fib])  fgallfibok[jp]=fgokallfibers_=false;
    255         }
    256         if (fgokallfibers_)  {
    257           if (totprocnpaq_==0) {
    258             for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
    259               fcfirst_[fib]=curfc_[fib];
    260               ttfirst_[fib]=vpaq_[fib].TimeTag();
    261             }
    262           }
    263           totprocnpaq_++;
    264           moyfc_ += curfc_[0];
    265           moytt_ += (vpaq_[0].TimeTag()-ttfirst_[0]);
    266           if ((fgcktt_)&&(calcid_==0))  CheckTimeTag();
    267           totnbpaq_++;
    268         }
    269       }  // Fin de boucle sur les paquets
    270      
    271       // Execution parallele  pour calcul des visibilites par bandes de frequence
    272       int rcpex=paralex_.execute();
    273       if (rcpex!=0)  cout << " BRVisibilityCalculator[" << calcid_ << "]::run() / Error Rc[paralex_.execute()]=" << rcpex << endl;
    274 
    275       memgr_.FreeMemZone(mid, mmsta_);  // (MemZS_ProcA);
    276     } // Fin de boucle sur les zones a traiter
    277     //------------------------------------
    278     cout << " --------- END BRVisibilityCalculator[" << calcid_ << "]::run() , TotNbProcPaq=" << totprocnpaq_ << endl;
    279     /*
    280     for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  vpchk_[fib].Print();
    281     cout << " ------------------------------------ " << endl;
    282     */
    283     delete[] fgallfibok;
    284   }
    285   catch (std::exception& exc) {
    286     cout << " BRVisibilityCalculator[" << calcid_ << "]::run()/catched std::exception " << exc.what() << endl;
    287     setRC(98); 
    288     return;
    289   }
    290   catch(...) {
    291     cout << " BRVisibilityCalculator[" << calcid_ << "]::run()/catched unknown ... exception " << endl;
    292     setRC(99); 
    293     return;
    294   }
    295  
    296 }
    297 
    298 /* --Methode-- */
    299 int BRVisibilityCalculator::Process()
    300 {
    301    
    302   for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
    303     vpdata_[2*fib] = vpaq_[fib].Data1C();
    304     vpdata_[2*fib+1] = vpaq_[fib].Data2C();
    305   }
    306  
    307   if (totnbpaq_%nmean_ == 0) {
    308     if (totnbpaq_ > 0) {
    309       moyfc_/=nmean_;
    310       moytt_/=nmean_;
    311       vismtx_.Info()["MeanFC"] = moyfc_;
    312       vismtx_.Info()["MeanTT"] = moytt_;
    313       vismtx_.Info()["NPAQSUM"] = nmean_;
    314 
    315       // ATTENTION : Matrice visibilites non moyennee
    316       char nfile[48];
    317       if (nbcalc_==1)
    318         sprintf(nfile,"vismtx%d.ppf",numfile_);
    319       else
    320         sprintf(nfile,"vismtx_%d_%d.ppf",(int)calcid_,numfile_);
    321       string flnm=outpath_+nfile;
    322       POutPersist po(flnm);
    323       po << vismtx_;
    324       cout << numfile_ << "-BRVisibilityCalculator::Process() NPaqProc="
    325            << totnbpaq_ << "  -> Visibility Matrix in " << flnm << endl;
    326       FillVisibTable(moyfc_, moytt_);
    327       numfile_++;
    328     }
    329     vismtx_ = complex<r_4>((r_4)0.,(r_4)0.);
    330     moyfc_=moytt_=0.;
    331   }
    332 
    333   sa_size_t k=0;
    334   for(size_t i=0; i<vpdata_.size(); i++) {
    335     for(size_t j=i; j<vpdata_.size(); j++) {
    336       size_t kpair=i*vpdata_.size()+j;
    337       if (kpair<pairst_)  continue;
    338       if (kpair>=(pairst_+nbpairs_))  break;
    339       TVector< complex<r_4> > vis = vismtx_.Row(k);   k++;
    340       for(sa_size_t f=1; f<vis.Size(); f++) {
    341         vis(f) += complex<r_4>((r_4)vpdata_[i][f].realB(), (r_4)vpdata_[i][f].imagB()) *
    342           complex<r_4>((r_4)vpdata_[j][f].realB(), -(r_4)vpdata_[j][f].imagB());
    343       }
    344       nb_flop_ += (7.*(r_8)vis.Size());
    345     }
    346   }
    347 
    348   moyfc_ += curfc_[0];
    349   moytt_ += (vpaq_[0].TimeTag()-ttfirst_[0]);
    350   if ((fgcktt_)&&(calcid_==0))  CheckTimeTag();
    351   totnbpaq_++;
    352   return 0;
    353 }
    354 
    355 /* --Methode-- */
    356 int BRVisibilityCalculator::execute(int tid)
    357 {
    358   vector<TwoByteComplex*>  pvpdata(2*memgr_.NbFibres());
    359   size_t paqsz=memgr_.PaqSize();
    360   BRPaquet ppaq(paqsz);
    361 
    362   sa_size_t fdelt = vismtx_.NCols()/nparthr_;
    363   sa_size_t fdeb = tid*fdelt;
    364   sa_size_t ffin = (tid+1)*fdelt;
    365 
    366   if (fdeb<1) fdeb=1;
    367   if ((ffin>vismtx_.NCols())||(tid==(nparthr_-1))) ffin=vismtx_.NCols();
    368 
    369   for(size_t jp=0; jp<memgr_.NbPaquets(); jp++) {   // boucle sur les paquets d'une zone 
    370     if (!fgallfibok[jp])  continue;
    371     for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
    372       ppaq.Set(fbuff_[fib]+jp*paqsz);
    373       pvpdata[2*fib] = ppaq.Data1C();
    374       pvpdata[2*fib+1] = ppaq.Data2C();
    375     }
    376     sa_size_t k=0;
    377     for(size_t i=0; i<vpdata_.size(); i++) {
    378       for(size_t j=i; j<vpdata_.size(); j++) {
    379         size_t kpair=i*vpdata_.size()+j;
    380         if (kpair<pairst_)  continue;
    381         if (kpair>=(pairst_+nbpairs_))  break;
    382         TVector< complex<r_4> > vis = vismtx_.Row(k);   k++;
    383         for(sa_size_t f=fdeb; f<ffin; f++) {
    384           vis(f) += complex<r_4>((r_4)pvpdata[i][f].realB(), (r_4)pvpdata[i][f].imagB()) *
    385             complex<r_4>((r_4)pvpdata[j][f].realB(), -(r_4)pvpdata[j][f].imagB());
    386         }
    387         nb_flop_ += (7.*(r_8)(ffin-fdeb));
    388       }
    389     }
    390 
    391   }  // Fin de boucle sur les paquets
    392  
    393   return 0;
    394 }
    395 
    396 /* --Methode-- */
    397 int BRVisibilityCalculator::FillVisibTable(double fcm, double ttm)
    398 {
    399   double xnt[10];
    400   xnt[0]=fcm;  xnt[1]=ttm/1.25e8;
    401 
    402   if (djf_<2) {
    403     for(sa_size_t rv=0; rv<vismtx_.NRows(); rv++) {
    404       for(sa_size_t jf=jf1_; jf<jf2_; jf++) {
    405         xnt[2]=jf;
    406         xnt[3]=chanum_(rv+pairst_);
    407         xnt[4]=vismtx_(rv,jf).real()/(r_4)(nmean_);
    408         xnt[5]=vismtx_(rv,jf).imag()/(r_4)(nmean_);
    409         visdt_.AddRow(xnt);
    410       }
    411     }
    412   }
    413   else {
    414     for(sa_size_t rv=0; rv<vismtx_.NRows(); rv++) {
    415       for(sa_size_t jf=jf1_; jf<jf2_; jf+=djf_) {
    416         r_4 moyreal=0.;
    417         r_4 moyimag=0.;
    418         sa_size_t jjfmx=jf+djf_;
    419         if (jjfmx > vismtx_.NCols()) jjfmx=vismtx_.NCols();
    420         for(sa_size_t jjf=jf; jjf<jjfmx; jjf++) {
    421           moyreal+=vismtx_(rv,jjf).real();
    422           moyimag+=vismtx_(rv,jjf).imag();
    423         }
    424         xnt[2]=jf+djf_/2;
    425         xnt[3]=chanum_(rv+pairst_);
    426         xnt[4]=moyreal/(r_4)(nmean_*djf_);
    427         xnt[5]=moyimag/(r_4)(nmean_*djf_);
    428         visdt_.AddRow(xnt);
    429       }
    430     }
    431   }
    432   return 0;
    433 }
    434 
    435 /* --Methode-- */
    436 int BRVisibilityCalculator::CheckTimeTag()
    437 {
    438   if (totnbpaq_==0) {
    439     for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)  {
    440       vlasttt_[fib]=ttfirst_[fib];
    441       if (ttmtx_.NCols()>0) {
    442         fcmtx_(fib,totnbpaq_) = curfc_[fib];
    443         ttmtx_(fib,totnbpaq_) = vlasttt_[fib];
    444       }
    445     }
    446     return 0;
    447   }
    448   for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
    449     int_8 ld = (int_8)vpaq_[fib].TimeTag()-(int_8)vlasttt_[fib];
    450     int_8 fd = (int_8)vpaq_[fib].TimeTag()-(int_8)ttfirst_[fib]-(int_8)vpaq_[0].TimeTag()+(int_8)ttfirst_[0];
    451     /*    if ( (ld < mindeltatt_) || (fd<-5) || (fd>5)) { vbadtt_[fib]++; vnsamett_[fib]++; }
    452     else {
    453       if (fd!=0)  vnsamett_[fib]++;
    454     }
    455     */
    456     if  (ld < mindeltatt_) vbadtt_[fib]++;
    457     else {
    458       if (fd != 0)  vnsamett_[fib]++;
    459       if ((fd<-5)||(fd>5))  vndiff5tt_[fib]++;
    460     }
    461     vlasttt_[fib]=vpaq_[fib].TimeTag();
    462     if (totnbpaq_<ttmtx_.NCols()) {
    463       fcmtx_(fib,totnbpaq_) = curfc_[fib];
    464       ttmtx_(fib,totnbpaq_) = vlasttt_[fib];
    465     }
    466   }
    467   return 0;
    468 }
    469 
    470 //-------------------------------------------------------------------------------
    471 // Classe Groupe (ensemble) de Calculateur de Visibilites, tourant en parallele
    472 //-------------------------------------------------------------------------------
    473 
    474 /* --Methode-- */
    475 BRVisCalcGroup::BRVisCalcGroup(size_t nbcalc, RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean, size_t nthr)
    476   : tm_(false)
    477 {
    478   if ((nbcalc<1)||(nbcalc>6))
    479     throw ParmError("BRVisCalcGroup::BRVisCalcGroup NbCalc > 6 !");
    480   for(size_t i=0; i<nbcalc; i++) {
    481     BRVisibilityCalculator * viscp=new BRVisibilityCalculator(memgr, outpath, nmean, nthr);
    482     viscp->DefineRank(nbcalc, i);
    483     viscalcp_.push_back(viscp);
    484   }
    485 }
    486 /* --Methode-- */
    487 BRVisCalcGroup::~BRVisCalcGroup()
    488 {
    489   for(size_t i=0; i<viscalcp_.size(); i++)
    490     delete viscalcp_[i];
    491 }
    492 /* --Methode-- */
    493 int BRVisCalcGroup::SelectFreqBinning(uint_4 freq1, uint_4 freq2, uint_4 nbfreq)
    494 {
    495   int rc=0;
    496   for(size_t i=0; i<viscalcp_.size(); i++)
    497     rc=viscalcp_[i]->SelectFreqBinning(freq1, freq2, nbfreq);
    498   return rc;
    499 }
    500 /* --Methode-- */
    501 void BRVisCalcGroup::start()
    502 {
    503   for(size_t i=0; i<viscalcp_.size(); i++)
    504     viscalcp_[i]->start();
    505   tm_.SplitQ();
    506 }
    507 /* --Methode-- */
    508 void BRVisCalcGroup::join()
    509 {
    510   r_8 totflop=0.;
    511   for(size_t i=0; i<viscalcp_.size(); i++) {
    512     viscalcp_[i]->join();
    513     totflop += viscalcp_[i]->TotNbFLOP();
    514   }
    515   tm_.SplitQ();
    516   cout << "      ----------------------------------------------------------" << endl;
    517   cout << " BRVisCalcGroup::join() : Finished , Elaspsed time: " << tm_.PartialElapsedTimems()
    518        << " ms (total:" << tm_.TotalElapsedTimems() << ")" << endl;
    519   cout << " ... TotalMegaFLOP= " << totflop/(1024.e3) << " @ "
    520        << totflop/(r_8)tm_.PartialElapsedTimems()/(1024) << " MFLOP/s" << endl;
    521   cout << "      ----------------------------------------------------------" << endl;
    522   return;
    523 }
    52431
    52532
    … …  
    52835//---------------------------------------------------------------------
    52936/* --Methode-- */
    530 BRMeanSpecCalculator::BRMeanSpecCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean)
    531   : BRBaseProcessor(memgr), outpath_(outpath), nmean_(nmean)
    532 {
     37BRMeanSpecCalculator::BRMeanSpecCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean,
     38                                           bool fgdatafft, bool fgsinglechan)
     39  : BRBaseProcessor(memgr), outpath_(outpath), nmean_(nmean),
     40    fgdatafft_(fgdatafft), fgsinglechannel_(fgsinglechan)
     41{
     42  setNameId("meanSpecCalc",1);
    53343  BRPaquet paq(memgr_.PaqSize());
    534   mspecmtx_.SetSize(2*memgr_.NbFibres(), paq.DataSize()/4);
     44  if (fgsinglechannel_)
     45    mspecmtx_.SetSize(memgr_.NbFibres(), paq.DataSize()/2);
     46  else
     47    mspecmtx_.SetSize(2*memgr_.NbFibres(), paq.DataSize()/4);
     48  mspecmtx_=(r_8)(0.);
    53549  numfile_=0;
     50  nbpaq4mean_=0;
    53651  totnbpaq_=0;
    53752}
    … …  
    54055BRMeanSpecCalculator::~BRMeanSpecCalculator()
    54156{
    542 }
    543 
     57  if (nbpaq4mean_>1)  SaveSpectra();
     58}
     59
     60
     61static inline r_4 Zmod2(complex<r_4> z)
     62{ return (z.real()*z.real()+z.imag()*z.imag()); }
    54463
    54564/* --Methode-- */
    … …  
    54766{
    54867     
    549   if (totnbpaq_%nmean_ == 0) {
    550     if (totnbpaq_ > 0) {
    551       mspecmtx_.Info()["NPAQSUM"] = nmean_;
    552       mspecmtx_ /= (double)nmean_;
    553       char nfile[32];
    554       sprintf(nfile,"mspecmtx%d.ppf",numfile_);
    555       string flnm=outpath_+nfile;
    556       POutPersist po(flnm);
    557       po << mspecmtx_;
    558       cout << numfile_ << "-BRMeanSpecCalculator::Process() NPaqProc="
    559            << totnbpaq_ << "  -> Mean spectra Matrix in " << flnm << endl;
    560       numfile_++;
     68  if (nbpaq4mean_==nmean_)  SaveSpectra();
     69   
     70  if (fgdatafft_) {  // Donnees firmware FFT
     71    for(sa_size_t i=0; i<(size_t)mspecmtx_.NRows(); i++) {
     72      TwoByteComplex* zp=NULL;
     73      if (fgsinglechannel_) {
     74        zp=vpaq_[i].Data1C();
     75      }
     76      else {
     77        zp=vpaq_[i/2].Data1C();
     78        if (i%2==1)  zp=vpaq_[i/2].Data2C();
     79      }
     80      TVector< r_4 > spec = mspecmtx_.Row(i);
     81      for(sa_size_t f=1; f<spec.Size(); f++)  spec(f) += zp[f].module2F();
    56182    }
    562     mspecmtx_ = (r_8)(0.);
    563   }
    564 
    565   sa_size_t k=0;
    566   for(size_t i=0; i<(size_t)2*memgr_.NbFibres(); i++) {
    567     TwoByteComplex* zp=vpaq_[i/2].Data1C();
    568     if (i%2==1)  zp=vpaq_[i/2].Data2C();
    569     TVector< r_4 > spec = mspecmtx_.Row(k);   k++;
    570     for(sa_size_t f=1; f<spec.Size(); f++) {
    571       spec(f) += zp[f].module2F();
    572       }
     83  }
     84  else {  // Donnees RAW qui ont du etre processe par BRFFTCalculator
     85    for(sa_size_t i=0; i<(size_t)mspecmtx_.NRows(); i++) {
     86      complex<ODT>* zp=NULL;
     87      if (fgsinglechannel_) {
     88        zp=reinterpret_cast< complex<ODT>* > (vprocpaq_[i]);
     89      }
     90      else {
     91        zp=reinterpret_cast< complex<ODT>* > (vprocpaq_[i/2]);
     92        if (i%2==1)  zp= reinterpret_cast< complex<ODT>* >(vprocpaq_[i/2]+memgr_.ProcPaqSize()/2) ;
     93      }
     94      TVector< r_4 > spec = mspecmtx_.Row(i);
     95      for(sa_size_t f=1; f<spec.Size(); f++)  spec(f) += Zmod2(zp[f]);
     96     
    57397    }
    574 
    575   totnbpaq_++;
     98  }
     99  nbpaq4mean_++;   totnbpaq_++;
    576100  return 0;
     101}
     102
     103/* --Methode-- */
     104void BRMeanSpecCalculator::SaveSpectra()
     105{
     106  mspecmtx_.Info()["NPAQSUM"] = nbpaq4mean_;
     107  mspecmtx_ /= (double)nbpaq4mean_;
     108  char nfile[32];
     109  sprintf(nfile,"mspecmtx%d.ppf",numfile_);
     110  string flnm=outpath_+nfile;
     111  POutPersist po(flnm);
     112  po << mspecmtx_;
     113  cout << numfile_ << "-BRMeanSpecCalculator::SaveSpectra() NPaqProc="
     114       << totnbpaq_ << "  -> Mean spectra Matrix in " << flnm << endl;
     115  numfile_++;  nbpaq4mean_=0;
     116  mspecmtx_ = (r_8)(0.);
     117  return;
     118}
     119
     120//---------------------------------------------------------------------
     121// Classe de thread de calcul de FFT sur donnees RAW
     122//---------------------------------------------------------------------
     123/* --Methode-- */
     124BRFFTCalculator::BRFFTCalculator(RAcqMemZoneMgr& memgr, bool fgsinglechannel)
     125  : BRBaseProcessor(memgr), fgsinglechannel_(fgsinglechannel), totnbfftpaq_(0)
     126{
     127  BRPaquet paq(memgr_.PaqSize());
     128  setNameId("FFTCalc",2);
     129  ffts_.SetInDataSize((fgsinglechannel_)?paq.DataSize():paq.DataSize()/2);
     130}
     131
     132/* --Methode-- */
     133BRFFTCalculator::~BRFFTCalculator()
     134{
     135}
     136
     137
     138/* --Methode-- */
     139int BRFFTCalculator::Process()
     140{
     141  for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
     142    ffts_.DoFFT( reinterpret_cast<IDT *>(vpaq_[fib].Data1() ), 
     143                 reinterpret_cast< complex<ODT>* > (vprocpaq_[fib]) );
     144    totnbfftpaq_++;
     145    if ( fgsinglechannel_ ) continue;
     146    ffts_.DoFFT( reinterpret_cast<IDT *>(vpaq_[fib].Data2() ), 
     147                 reinterpret_cast< complex<ODT>* > (vprocpaq_[fib]+memgr_.ProcPaqSize()/2) );
     148    totnbfftpaq_++;
     149  }   
     150  return 0;
     151}
     152
     153
     154//-------------------------------------------------------------------------
     155// Classe WBRFFT : Calcul de TF sur donnees brutes (firmware RAW)
     156//-------------------------------------------------------------------------
     157ZMutex* WBRFFT::mtx_fftwp_ = NULL;
     158
     159/* --Methode-- */
     160WBRFFT::WBRFFT(uint_4 sz)
     161  : sz_(sz)
     162{
     163  if (mtx_fftwp_ == NULL) mtx_fftwp_ = new ZMutex;
     164  if (sz>0)  SetInDataSize(sz);
     165}
     166
     167/* --Methode-- */
     168WBRFFT::~WBRFFT()
     169{
     170}
     171
     172/* --Methode-- */
     173void WBRFFT::SetInDataSize(uint_4 sz)
     174{
     175  sz_ = sz;
     176  if (sz_<1) return;
     177  inp.SetSize(sz);
     178  outfc.SetSize(sz/2+1);
     179  mtx_fftwp_->lock();
     180  myplan_ = fftwf_plan_dft_r2c_1d(inp.Size(), inp.Data(),
     181                       (fftwf_complex*)outfc.Data(), FFTW_ESTIMATE);
     182  mtx_fftwp_->unlock();
     183}
     184
     185/* --Methode-- */
     186void WBRFFT::DoFFT( IDT *indata, complex<ODT> * ofc)
     187{
     188  if (sz_<1) return;
     189  for(uint_4 k=0; k<inp.Size(); k++)   inp(k)=(ODT)indata[k];
     190  fftwf_execute(myplan_);
     191  for(uint_4 k=0; k<outfc.Size(); k++)   ofc[k]=outfc(k);
     192  return;
     193}
     194
     195/* --Methode-- */
     196void WBRFFT::PrintData(IDT *indata,  complex<ODT> * ofc, uint_4 sz)
     197{
     198    cout << " --- WBRFFT::PrintData() size=" << sz << endl;
     199  for(uint_4 k=0; k<sz; k+=8) {
     200    IDT* in = indata+k;
     201    cout << " Indata[" << k << "..." << k+8 << "]= ";
     202    for(uint_4 i=0; i<8; i++)   cout << (IIDT)in[i] << "  ";
     203    cout << endl; 
     204  }
     205  cout << endl;
     206  for(uint_4 k=0; k<sz/2; k+=4) {
     207    complex< ODT>* out = ofc+k;
     208    cout << " OutFC[" << k << "..." << k+4 << "]= ";
     209    for(uint_4 i=0; i<4; i++)   cout << out[i] << "  ";
     210    cout << endl; 
     211  }
     212  return;
     213
    577214}
    578215
    … …  
    580217//---------------------------------------------------------------
    581218// Classe thread de traitement donnees ADC avec 2 voies par frame
     219//         !!!! OBSOLETE  !!!!   
    582220//---------------------------------------------------------------
    583221
    … …  
    612250
    613251
    614 static inline r_4 Zmod2(complex<r_4> z)
    615 { return (z.real()*z.real()+z.imag()*z.imag()); }
     252
    616253
    617254static inline string card2name_(int card)
    … …  
    1004641}   
    1005642
     643
    1006644//---------------------------------------------------------------------
    1007645// Classe thread de traitement 2 x 2 voies/frames (Apres BRProcA2C)
     646//         !!!! OBSOLETE  !!!!   
    1008647//---------------------------------------------------------------------
    1009648

  • trunk/AddOn/TAcq/brproc.h

    r3777 r3872  
    55// Projet BAORadio - (C) LAL/IRFU  2008-2010
    66// Classes de threads de traitememt donnees BAORadio
     7//  Principales classes utilisables
     8//  - BRMeanSpecCalculator (donnees FFT)
     9//  - BRFFTCalculator (donnees RAW)
    710//----------------------------------------------------------------
    811
    … …  
    1922#include "ntuple.h"
    2023#include "datatable.h"
     24#include "FFTW/fftw3.h"
    2125
    2226using namespace std;
    2327
    2428
    25 //---------------------------------------------------------------------
    26 // Classe de traitement - calcul de visibilite pour n fibres
    27 //---------------------------------------------------------------------
    28 class BRVisibilityCalculator : public BRBaseProcessor, ParallelTaskInterface {
    29 public:
    30   BRVisibilityCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000, size_t nthr=1);
    31   virtual ~BRVisibilityCalculator(); // Fait le nettoyage final , sauvegarde des objets ...
    32 
    33   // Pour definir le rang de l'objet lors d'un traitement avec plusieurs BRVisibilityCalculator en //
    34   void DefineRank(uint_4 nbc, uint_4 cid);
    35 
    36   // Pour limiter le calcul des visibilites a certaines fibres
    37   uint_4 SelectPairs(uint_4 pair1=0, uint_4 nbpairs=99999999);
    38   // pour definir le binning en frequence pour la VisibDataTable
    39   int SelectFreqBinning(uint_4 freq1=0, uint_4 freq2=0, uint_4 nbfreq=1);
    40 
    41   // Pour activer la verification des timetag
    42   // Creation / sauvegarde d'une matrice de TimeTag / FrameCounter avec NCols=maxnpaq (nb de paquets/trigger) 
    43   int ActivateTimeTagCheck(uint_8 maxnpaq);
    44 
    45   // Methode d'execution standard du thread (on redefinit la methode de BRBaseProcessor)
    46   virtual void run(); 
    47   // Methode de la classe ParallelTaskInterface
    48   virtual int    execute(int tid);
    49 
    50   // Le nombre total d'operations effectuees
    51   inline r_8 TotNbFLOP() { return nb_flop_; }
    52 
    53 protected:
    54   virtual int Process();
    55   virtual int FillVisibTable(double fcm, double ttm);
    56   virtual int CheckTimeTag();
    57 
    58   ParallelExecutor paralex_;  // Pour l'execution en parallele 
    59   size_t nparthr_;
    60 
    61   uint_4 nmean_;  // Nombre de spectres pour le calcul des moyennes
    62   string outpath_;  // directory pour fichiers de sortie
    63   uint_4 nbcalc_, calcid_;  // Nombre total de threads/objets BRVisibilityCalculator parallèles, l'identificateur de l'objet 
    64 
    65   uint_4 pairst_, nbpairs_;   // Numero de la premiere paire, nombre de paires
    66   uint_4 jf1_,jf2_,djf_;  // binning en frequence pour la datatable
    67 
    68   vector<TwoByteComplex*> vpdata_;
    69   bool* fgallfibok; 
    70 
    71   double moyfc_, moytt_;
    72   TMatrix< complex<r_4> > vismtx_;
    73   TVector< uint_4 > chanum_;
    74   //  FitsInOutFile dtfos_;
    75   DataTable visdt_;
    76 
    77   uint_4 numfile_;
    78   uint_8 totnbpaq_;
    79 
    80   r_8 nb_flop_;   // Nombre total d'operations effectuees
    81 
    82   // Variables/objets pour la verifications des timetag
    83   bool fgcktt_;  // true -> checktimetag
    84   int_8 mindeltatt_;       // difference minimum de deux timetag successifs
    85   TMatrix< uint_8 > fcmtx_; // matrices des framecounters
    86   TMatrix< uint_8 > ttmtx_; // matrices des timetag
    87   vector< uint_8 > vlasttt_;  // dernieres valeurs de TimeTag / fibre
    88   vector< uint_8 > vbadtt_;  // Number of bad TimeTag paquets per fiber
    89   vector< uint_8 > vnsamett_;  // Number of paquets having TimeTag <> TT_Fiber1 per fiber
    90   vector< uint_8 > vndiff5tt_;  // Number of paquets having |TimeTag-TT_Fiber1|>5 per fiber
    91 
    92 };
    93 
    94 
    95 //-------------------------------------------------------------------------------
    96 // Classe Groupe (ensemble) de Calculateur de Visibilites, tourant en parallele
    97 //-------------------------------------------------------------------------------
    98 
    99 class BRVisCalcGroup {
    100 public:
    101   BRVisCalcGroup(size_t nbcalc, RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000, size_t nthr=1);
    102   ~BRVisCalcGroup();
    103   int SelectFreqBinning(uint_4 freq1=0, uint_4 freq2=0, uint_4 nbfreq=1);
    104   inline int ActivateTimeTagCheck(uint_8 maxnpaq)
    105   { return viscalcp_[0]->ActivateTimeTagCheck(maxnpaq); }
    106 
    107   void start();
    108   void join();
    109 protected:
    110   vector<BRVisibilityCalculator *> viscalcp_;
    111   Timer tm_;
    112 };
    11329 
    11430//---------------------------------------------------------------------
    11531// Classe de traitement simple - calcul de spectres moyennes / voie
     32// a partir de donnees de type FFT (firmware FFT)
    11633//---------------------------------------------------------------------
    11734class BRMeanSpecCalculator : public BRBaseProcessor
    11835{
    11936public:
    120   BRMeanSpecCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000);
     37  BRMeanSpecCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000,
     38                       bool fgdatafft=true, bool fgsinglechan=false);
    12139  virtual ~BRMeanSpecCalculator(); // Fait le nettoyage final , sauvegarde des objets ...
    12240
    12341protected:
    12442  virtual int Process();
     43  virtual void SaveSpectra();
    12544
    12645  uint_4 nmean_;  // Nombre de spectres pour le calcul des moyennes
    12746  string outpath_;  // directory pour fichiers de sortie
     47  bool fgdatafft_;
     48  bool fgsinglechannel_;
    12849  uint_4 numfile_;
     50  uint_8 nbpaq4mean_;
    12951
    13052  uint_8 totnbpaq_;
    13153  TMatrix< r_4 > mspecmtx_;    // Matrice des spectres moyennees
    13254};
     55
     56//-------------------------------------------------------------------------
     57// Classe WBRFFT : Calcul de TF sur donnees brutes (firmware RAW)
     58//   en utilisant FFTW et en effectuant une copie ds tableau local
     59//-------------------------------------------------------------------------
     60typedef unsigned char IDT ;   // definition type de donnees en entree de WBRFFT
     61typedef int_2  IIDT ;      // definition type de donnees intermediaire
     62typedef float  ODT;  // type de donnees en sortie (complex < ODT > )
     63//----Classe WBRFFT----
     64class WBRFFT {
     65public:
     66  WBRFFT(uint_4 sz=0);
     67  virtual ~WBRFFT();
     68
     69  void SetInDataSize(uint_4 sz);
     70  void DoFFT(IDT *indata, complex<ODT> * ofc);
     71  static void PrintData(IDT *indata,  complex<ODT> * ofc, uint_4 sz);
     72
     73  uint_4 sz_;   // Taille tableau d'entree
     74  TVector< ODT > inp;
     75  TVector< complex<ODT> > outfc;
     76  fftwf_plan myplan_;
     77  static ZMutex* mtx_fftwp_;  // Mutex de protection pour la creation du plan fftw
     78};
     79//--------------------
     80
     81//---------------------------------------------------------------------
     82// Classe de thread de calcul de FFT sur donnees RAW
     83//---------------------------------------------------------------------
     84class BRFFTCalculator : public BRBaseProcessor
     85{
     86public:
     87  BRFFTCalculator(RAcqMemZoneMgr& memgr, bool fgsinglechannel=false);
     88  virtual ~BRFFTCalculator(); // Fait le nettoyage final , sauvegarde des objets ...
     89
     90protected:
     91  virtual int Process();
     92 
     93  bool fgsinglechannel_;
     94  uint_8 totnbfftpaq_;
     95  WBRFFT ffts_;
     96};
     97
    13398
    13499//-------------------------------------------------------------------------
    … …  
    151116  o card : numero de carte , juste pour les impressions
    152117*/
    153 class BRProcA2C : public ZThread {
     118class BRProcA2C : public ZThread {   // !!!! OBSOLETE  !!!!
    154119public:
    155120  BRProcA2C(RAcqMemZoneMgr& mem, string& path, bool fgraw,
    … …  
    174139//---------------------------------------------------------------------
    175140// Classe thread de traitement 2 x 2 voies/paquet (Apres BRProcA2C)
     141//         !!!! OBSOLETE  !!!!   
    176142//---------------------------------------------------------------------
    177143/*-- Arguments du constructeur :
    … …  
    184150*/
    185151
    186 class BRProcB4C : public ZThread {
     152class BRProcB4C : public ZThread {  //   !!!! OBSOLETE  !!!!   
     153
    187154public:
    188155  BRProcB4C(RAcqMemZoneMgr& mem1, RAcqMemZoneMgr& mem2, string& path,

  • trunk/AddOn/TAcq/makefile

    r3795 r3872  
    66# all : traidio  tmtfft tstminifits tbrpaq tpciew tmtacq tstrdfits mfits2spec tsok
    77# all : traidio  tmtfft tstminifits tmtacq tstrdfits mfits2spec tsok mcrd
    8 all :  mfacq vismfib treadmfib tmtacq mfits2spec mcrd svv2mtx svv2mtx2 tsok traidio tstminifits tbrpaq
     8all :  mfacq vismfib specmfib treadmfib tmtacq mfits2spec mcrd svv2mtx svv2mtx2 tsok traidio tstminifits tbrpaq
    99
    1010clean :
    … …  
    1515        rm -f Objs/* *.ppf *.fits
    1616
     17PKGOLIST = $(OBJ)branap.o  $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brpaqu.o \
     18           $(OBJ)brfitsrd.o $(OBJ)brdiskw.o  $(OBJ)minifits.o \
     19           $(OBJ)brbaseproc.o $(OBJ)brproc.o $(OBJ)brviscalc.o \
     20           $(OBJ)racqueth.o $(OBJ)racquproc.o $(OBJ)racqurw.o  $(OBJ)pciewrap.o \
     21           $(OBJ)swrapsock.o $(OBJ)sockrawstream.o $(OBJ)burawstream.o
     22PKGHLIST = bracqvers.h branap.h brparam.h racqumem.h brpaqu.h brtypes.h \
     23           brdiskw.h brfitsrd.h minifits.h brviscalc.h brbaseproc.h brproc.h \
     24           mfacq.h  tmtacq.h racqueth.h  racquproc.h racqurw.h pciewrap.h  \
     25           swrapsock.h burawstream.h sockrawstream.h tmtacq.h
    1726########################################################
    1827
    … …  
    2130        echo '---mfacq made'
    2231
    23 $(EXE)mfacq : $(OBJ)mfacq.o $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)racqurw.o  $(OBJ)racqueth.o \
    24         $(OBJ)racquproc.o $(OBJ)brpaqu.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(OBJ)swrapsock.o
    25         $(CXXLINK) -o $(EXE)mfacq $(OBJ)mfacq.o $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)racqurw.o $(OBJ)racqueth.o \
    26               $(OBJ)racquproc.o $(OBJ)brpaqu.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(OBJ)swrapsock.o $(SOPHYAALLSLBLIST)
    27 
    28 $(OBJ)mfacq.o : mfacq.cc brparam.h racquproc.h racqurw.h racqueth.h racqumem.h brpaqu.h
     32$(EXE)mfacq : $(OBJ)mfacq.o $(PKGOLIST)
     33        $(CXXLINK) -o $(EXE)mfacq $(OBJ)mfacq.o $(PKGOLIST) $(SOPHYAALLSLBLIST)
     34
     35$(OBJ)mfacq.o : mfacq.cc $(PKGHLIST)
    2936        $(CXXCOMPILE) -c -DNOPCIECARD -o $(OBJ)mfacq.o mfacq.cc
    3037
    … …  
    3340        echo '---tmtacq made'
    3441
    35 $(EXE)tmtacq : $(OBJ)tmtacq.o  $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)racqurw.o $(OBJ)racquproc.o \
    36                $(OBJ)brpaqu.o $(OBJ)pciewrap.o $(OBJ)minifits.o
    37         $(CXXLINK) -o $(EXE)tmtacq $(OBJ)tmtacq.o $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)racqurw.o \
    38                $(OBJ)racquproc.o $(OBJ)brpaqu.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(SOPHYAALLSLBLIST)
    39 
    40 $(OBJ)tmtacq.o : tmtacq.cc racquproc.h racqurw.h racqumem.h brpaqu.h
     42$(EXE)tmtacq : $(OBJ)tmtacq.o  $(PKGOLIST)
     43        $(CXXLINK) -o $(EXE)tmtacq $(OBJ)tmtacq.o $(PKGOLIST) $(SOPHYAALLSLBLIST)
     44
     45$(OBJ)tmtacq.o : tmtacq.cc $(PKGHLIST)
    4146        $(CXXCOMPILE) -c -DNOPCIECARD -o $(OBJ)tmtacq.o tmtacq.cc
    4247
    43 $(OBJ)brparam.o : brparam.cc brparam.h
     48$(OBJ)brparam.o : brparam.cc $(PKGHLIST)
    4449        $(CXXCOMPILE) -c -o $(OBJ)brparam.o brparam.cc
    4550
    46 $(OBJ)racqumem.o : racqumem.cc racqumem.h
     51$(OBJ)racqumem.o : racqumem.cc $(PKGHLIST)
    4752        $(CXXCOMPILE) -c -o $(OBJ)racqumem.o racqumem.cc
    4853
    49 $(OBJ)racqurw.o : racqurw.cc racqurw.h racqumem.h brpaqu.h
     54$(OBJ)racqurw.o : racqurw.cc $(PKGHLIST)
    5055        $(CXXCOMPILE) -c -o $(OBJ)racqurw.o racqurw.cc
    5156
    52 $(OBJ)racqueth.o : racqueth.cc racqueth.h racqurw.h racqumem.h brpaqu.h
     57$(OBJ)racqueth.o : racqueth.cc $(PKGHLIST)
    5358        $(CXXCOMPILE) -c -o $(OBJ)racqueth.o racqueth.cc
    5459
    55 $(OBJ)racquproc.o : racquproc.cc racquproc.h racqurw.h racqumem.h brpaqu.h
     60$(OBJ)racquproc.o : racquproc.cc $(PKGHLIST)
    5661        $(CXXCOMPILE) -c -o $(OBJ)racquproc.o racquproc.cc
    5762
    … …  
    6166        echo '---vismfib made'
    6267
    63 $(EXE)vismfib : $(OBJ)vismfib.o  $(OBJ)branap.o $(OBJ)brdiskw.o $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o $(OBJ)brpaqu.o \
    64              $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o
    65         $(CXXLINK) -o $(EXE)vismfib $(OBJ)vismfib.o $(OBJ)branap.o $(OBJ)brdiskw.o $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o \
    66                       $(OBJ)brpaqu.o $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(SOPHYAALLSLBLIST)
    67 
    68 $(OBJ)vismfib.o : vismfib.cc branap.h brfitsrd.h racqumem.h brproc.h brbaseproc.h racqurw.h
     68$(EXE)vismfib : $(OBJ)vismfib.o $(PKGOLIST)
     69        $(CXXLINK) -o $(EXE)vismfib $(OBJ)vismfib.o $(PKGOLIST) $(SOPHYAALLSLBLIST)
     70
     71$(OBJ)vismfib.o : vismfib.cc $(PKGHLIST)
    6972        $(CXXCOMPILE) -c  -o $(OBJ)vismfib.o vismfib.cc
    7073
    71 
     74#......
     75specmfib : $(EXE)specmfib
     76        echo '---specmfib made'
     77
     78$(EXE)specmfib : $(OBJ)specmfib.o $(PKGOLIST)
     79        $(CXXLINK) -o $(EXE)specmfib $(OBJ)specmfib.o $(PKGOLIST) $(SOPHYAALLSLBLIST)
     80
     81$(OBJ)specmfib.o : specmfib.cc $(PKGHLIST)
     82        $(CXXCOMPILE) -c  -o $(OBJ)specmfib.o specmfib.cc
     83
     84#......
    7285treadmfib : $(EXE)treadmfib
    7386        echo '---treadmfib made'
    7487
    75 $(EXE)treadmfib : $(OBJ)treadmfib.o  $(OBJ)branap.o $(OBJ)brdiskw.o $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o $(OBJ)brpaqu.o \
    76              $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o
    77         $(CXXLINK) -o $(EXE)treadmfib $(OBJ)treadmfib.o $(OBJ)branap.o $(OBJ)brdiskw.o $(OBJ)brparam.o $(OBJ)racqumem.o $(OBJ)brfitsrd.o $(OBJ)brproc.o $(OBJ)brbaseproc.o $(OBJ)racquproc.o \
    78                       $(OBJ)brpaqu.o $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(SOPHYAALLSLBLIST)
    79 
    80 $(OBJ)treadmfib.o : treadmfib.cc branap.h brfitsrd.h racqumem.h brproc.h brbaseproc.h racqurw.h
     88$(EXE)treadmfib : $(OBJ)treadmfib.o  $(PKGOLIST)
     89        $(CXXLINK) -o $(EXE)treadmfib $(OBJ)treadmfib.o $(PKGOLIST) $(SOPHYAALLSLBLIST)
     90
     91$(OBJ)treadmfib.o : treadmfib.cc $(PKGHLIST)
    8192        $(CXXCOMPILE) -c  -o $(OBJ)treadmfib.o treadmfib.cc
    8293
    83 $(OBJ)branap.o : branap.cc branap.h
     94$(OBJ)branap.o : branap.cc $(PKGHLIST)
    8495        $(CXXCOMPILE) -c  -o $(OBJ)branap.o branap.cc
    8596
    86 $(OBJ)brdiskw.o : brdiskw.cc brdiskw.h
     97$(OBJ)brdiskw.o : brdiskw.cc $(PKGHLIST)
    8798        $(CXXCOMPILE) -c  -o $(OBJ)brdiskw.o brdiskw.cc
     99
     100$(OBJ)brfitsrd.o : brfitsrd.cc $(PKGHLIST)
     101        $(CXXCOMPILE) -c -o $(OBJ)brfitsrd.o brfitsrd.cc
     102
     103$(OBJ)brviscalc.o : brviscalc.cc $(PKGHLIST)
     104        $(CXXCOMPILE) -c  -o $(OBJ)brviscalc.o brviscalc.cc
     105
     106$(OBJ)brproc.o : brproc.cc $(PKGHLIST)
     107        $(CXXCOMPILE) -c  -o $(OBJ)brproc.o brproc.cc
     108
     109$(OBJ)brbaseproc.o : brbaseproc.cc brbaseproc.h racqumem.h brpaqu.h
     110        $(CXXCOMPILE) -c  -o $(OBJ)brbaseproc.o brbaseproc.cc
    88111
    89112##   --------------
    … …  
    91114        echo '---mcrd made'
    92115
    93 $(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 \
    94              $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o
    95         $(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 \
    96                       $(OBJ)brpaqu.o $(OBJ)racqurw.o $(OBJ)pciewrap.o $(OBJ)minifits.o $(SOPHYAALLSLBLIST)
    97 
    98 $(OBJ)mcrd.o : mcrd.cc brfitsrd.h racqumem.h brproc.h brbaseproc.h racqurw.h
     116$(EXE)mcrd : $(OBJ)mcrd.o  $(PKGOLIST)
     117        $(CXXLINK) -o $(EXE)mcrd $(OBJ)mcrd.o $(PKGOLIST) $(SOPHYAALLSLBLIST)
     118
     119$(OBJ)mcrd.o : mcrd.cc $(PKGHLIST)
    99120        $(CXXCOMPILE) -c  -o $(OBJ)mcrd.o mcrd.cc
    100 
    101 $(OBJ)brfitsrd.o : brfitsrd.cc brfitsrd.h racqumem.h brpaqu.h
    102         $(CXXCOMPILE) -c -o $(OBJ)brfitsrd.o brfitsrd.cc
    103 
    104 $(OBJ)brproc.o : brproc.cc brproc.h  brbaseproc.h racqumem.h brpaqu.h
    105         $(CXXCOMPILE) -c  -o $(OBJ)brproc.o brproc.cc
    106 
    107 $(OBJ)brbaseproc.o : brbaseproc.cc brbaseproc.h racqumem.h brpaqu.h
    108         $(CXXCOMPILE) -c  -o $(OBJ)brbaseproc.o brbaseproc.cc
    109121
    110122##   --------------
    … …  
    126138$(OBJ)svv2mtx2.o : svv2mtx2.cc
    127139        $(CXXCOMPILE) -o $(OBJ)svv2mtx2.o svv2mtx2.cc
    128 
    129 ##   --------------
    130 tbrpaq : $(EXE)tbrpaq
    131         echo '---tbrpaq made'
    132 
    133 $(EXE)tbrpaq : $(OBJ)tbrpaq.o $(OBJ)brpaqu.o
    134         $(CXXLINK) -o $(EXE)tbrpaq $(OBJ)tbrpaq.o $(OBJ)brpaqu.o  $(SOPHYAALLSLBLIST)
    135 
    136 $(OBJ)tbrpaq.o : tbrpaq.cc brpaqu.h
    137         $(CXXCOMPILE) -c -o $(OBJ)tbrpaq.o tbrpaq.cc
    138 
    139 $(OBJ)brpaqu.o : brpaqu.cc brpaqu.h
    140         $(CXXCOMPILE) -c -o $(OBJ)brpaqu.o brpaqu.cc
    141 
    142 ##   --------------
    143 tpciew : $(EXE)tpciew
    144         echo '---tpciew made'
    145 
    146 $(EXE)tpciew : $(OBJ)tpciew.o $(OBJ)pciewrap.o
    147         $(CXXLINK) -o $(EXE)tpciew  $(OBJ)tpciew.o $(OBJ)pciewrap.o $(SOPHYAEXTSLBLIST)
    148 
    149 $(OBJ)tpciew.o : tpciew.cc pciewrap.h
    150         $(CXXCOMPILE) -o $(OBJ)tpciew.o tpciew.cc
    151 
    152 $(OBJ)pciewrap.o : pciewrap.cc pciewrap.h
    153         $(CXXCOMPILE) -o $(OBJ)pciewrap.o pciewrap.cc
    154140
    155141##   --------------  Lecture minifits et calcul de spectre
    … …  
    184170$(OBJ)minifits.o : minifits.cc minifits.h
    185171        $(CXXCOMPILE) -o $(OBJ)minifits.o minifits.cc
     172
     173
     174
     175##   --------------
     176tbrpaq : $(EXE)tbrpaq
     177        echo '---tbrpaq made'
     178
     179$(EXE)tbrpaq : $(OBJ)tbrpaq.o $(OBJ)brpaqu.o
     180        $(CXXLINK) -o $(EXE)tbrpaq $(OBJ)tbrpaq.o $(OBJ)brpaqu.o  $(SOPHYAALLSLBLIST)
     181
     182$(OBJ)tbrpaq.o : tbrpaq.cc brpaqu.h
     183        $(CXXCOMPILE) -c -o $(OBJ)tbrpaq.o tbrpaq.cc
     184
     185$(OBJ)brpaqu.o : brpaqu.cc brpaqu.h
     186        $(CXXCOMPILE) -c -o $(OBJ)brpaqu.o brpaqu.cc
     187
     188##   --------------
     189tpciew : $(EXE)tpciew
     190        echo '---tpciew made'
     191
     192$(EXE)tpciew : $(OBJ)tpciew.o $(OBJ)pciewrap.o
     193        $(CXXLINK) -o $(EXE)tpciew  $(OBJ)tpciew.o $(OBJ)pciewrap.o $(SOPHYAEXTSLBLIST)
     194
     195$(OBJ)tpciew.o : tpciew.cc pciewrap.h
     196        $(CXXCOMPILE) -o $(OBJ)tpciew.o tpciew.cc
     197
     198$(OBJ)pciewrap.o : pciewrap.cc pciewrap.h
     199        $(CXXCOMPILE) -o $(OBJ)pciewrap.o pciewrap.cc
     200
    186201
    187202##   -------------- Tests performances I/O et FFT multi-threads

  • trunk/AddOn/TAcq/vismfib.cc

    r3780 r3872  
    2626#include "brfitsrd.h"
    2727#include "brproc.h"
     28#include "brviscalc.h"
    2829#include "brdiskw.h"
    2930
    … …  
    4344    // Decodage parametres
    4445    BRAnaParam par;
     46    cout << " ===> visimfib.cc: decoding command line arguments " << endl;
    4547    rc = par.DecodeArgs(narg, arg);
    4648    if (rc) return rc;
Note: See TracChangeset for help on using the changeset viewer.