source: Sophya/trunk/AddOn/TAcq/brviscalc.h@ 4012

#ifndef  BRVISCALC_H_SEEN
#define  BRVISCALC_H_SEEN

//----------------------------------------------------------------
// Projet BAORadio - (C) LAL/IRFU  2008-2010
// Classes de threads de calcul de visibilites pour BAORadio 
//  Principales classes utilisables 
//  - BRVisibilityCalculator (donnees FFT)
//  - BRVisCalcGroup  
//----------------------------------------------------------------

#include <string>
#include <vector>
#include <iostream>

// --- include SOPHYA
#include "machdefs.h"
#include "sopnamsp.h"
#include "tvector.h"
#include "parlex.h"
#include "datatable.h"
#include "ctimer.h"

//--- include BAORadio 
#include "racqumem.h"
#include "brpaqu.h"
#include "brbaseproc.h"

using namespace std;

//---------------------------------------------------------------------
// Classe de traitement - calcul de visibilite pour n fibres 
//---------------------------------------------------------------------
// Pour convertir une paire de numeros de canaux en un seul entier C1*CHANPAIRCONVFAC+C2
#define  CHANPAIRCONVFAC  1000 

class BRVisibilityCalculator : public BRBaseProcessor, ParallelTaskInterface {
public: 
  BRVisibilityCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000, size_t nthr=1);
  virtual ~BRVisibilityCalculator(); // Fait le nettoyage final , sauvegarde des objets ...

  // configuration avec donnees firmware FFT (defaut) 
  inline void SetFFTData()  { fgdataraw_=false; } 
  // configuration avec donnees firmware RAW  
  inline void SetRawData()  { fgdataraw_=true; } 

  // Pour definir le rang de l'objet lors d'un traitement avec plusieurs BRVisibilityCalculator en //
  void DefineRank(uint_4 nbc, uint_4 cid, uint_4 pair1=0, uint_4 nbpairs=999999999, bool fgpimp=false);

  // Pour limiter le calcul des visibilites a certaines voies, determine par les numeros de sequences des paires 
  // Exemple pour 2 fibres et 4 voies 
  // kpair=numero sequentiel de la paire: 0->(0,0), 1->(0,1), 2->(0,2), 3->(0,3), 4->(1,1), 5->(1,2) ...
  // fgpimp=true : on calcule uniquement les visib avec un numero de voie paire, un numero de voie impair
  //               fgpimp=true est utile pour le calcul des visib entre deux cylindres (E-W) 
  uint_4 SelectPairs(uint_4 pair1=0, uint_4 nbpairs=999999999, bool fgpimp=false);
  // pour definir le binning en frequence pour la VisibDataTable 
  // par defaut, toutes les frequences avec un pas de 1 
  int SelectFreqBinning(uint_4 freq1=0, uint_4 freq2=0, uint_4 nbfreq=0);

  // Pour activer la verification des timetag
  // Creation / sauvegarde d'une matrice de TimeTag / FrameCounter avec NCols=maxnpaq (nb de paquets/trigger)  
  int ActivateTimeTagCheck(uint_8 maxnpaq);
  // Pour activer le remplissage du DataTable des visibilites 
  inline void ActivateVisDTable(bool fgfdt=false)  { fgvisdt_=fgfdt;  return; }
  // Pour ecrire les fichiers de sortie au format fits (format PPF sinon) 
  inline void SetFitsOutput() { fgfitsout_=true; }
  // Pour ecrire les fichiers de sortie au format PPF (defaut) 
  inline void SetPPFOutput() { fgfitsout_=false; }
  // Pour passer en mode nombre de paquet pour sauvegarde matrices visibilites (defaut)
  inline void SetNPaqIntervalMode(uint_4 nmean=1000)  
    { fgnpaq_time=true; nmean_=(nmean>0)?nmean:1000; }
  // Pour passer en mode intervalle en temps pour sauvegarde matrices visibilites - intervalle de temps en secondes 
  inline void SetTimeIntervalMode(double dtime=1.)
    { fgnpaq_time=false; dtimemean_=(dtime>1e-6)?dtime:1.; }

  // Methode d'execution standard du thread (on redefinit la methode de BRBaseProcessor)
  virtual void run();  
  // Methode de la classe ParallelTaskInterface 
  virtual int  execute(int tid);

  // Le nombre total d'operations effectuees
  inline r_8 TotNbFLOP() { return nb_flop_; }
  inline r_8 TotNbMegaFLOP() { return nb_flop_/(1024.e3); }

  //---- niveau d'impression 
  inline void SetPrintLevel(int lev=0, uint_8 prtmodulo=10) 
    { prtlev_=lev;   prtmodulo_=prtmodulo;}

protected:
  virtual void UpdateChanIds(); 
  virtual int Process(); 
  virtual void SaveVisibilityMatrix();
  virtual void UpdateVisMtxInfo();
  virtual int FillVisibTable(double fcm, double ttm); 
  inline  bool CheckInterval4Save();  
  virtual int CheckTimeTag(); 
  inline const char* OutFileExtension() { return ((fgfitsout_)?"fits":"ppf"); } 
 // return true if npaq or time interval elasped to save visibility matrix 
  inline  bool CheckInterval4VisMtxSave()  
  {
    if (npaqcumul_<1) return false;
    if (fgnpaq_time) 
      return ((npaqcumul_>=nmean_)?true:false); 
    else {
      return (((vpaq_[0].TimeTag()-first_tt_)/1.25e8>=dtimemean_)?true:false);
    }
  }

  ParallelExecutor paralex_;  // Pour l'execution en parallele  
  size_t nparthr_;

  bool fgdataraw_;  // true -> donnees provenant du firmware RAW 
  string outpath_;  // directory pour fichiers de sortie
  uint_4 nbcalc_, calcid_;  // Nombre total de threads/objets BRVisibilityCalculator parallèles, l'identificateur de l'objet  

  //  Definition du mode (type d'intervalle) pour calcul des moyennes 
  uint_4 nmean_;  // Nombre de spectres pour le calcul des moyennes 
  double dtimemean_;  // Intervalle en temps pour le calcul des moyennes - exprimes en secondes 
  bool fgnpaq_time;  // true -> utilisation nmean_ comme nb de paquet/spectre, false -> dtimemean_

  uint_4 pairst_, nbpairs_;   // Numero de la premiere paire, nombre de paires ( 1 paire= 1 visibilites)
  bool fgpimp_;    //  true -> calculer uniquement visibilities avec no voie pair-impair  

  uint_4 jf1_,jf2_,djf_;  // binning en frequence pour la datatable

  vector<TwoByteComplex*> vpdata_;   // donnees du fimrware FFT 
  vector< complex<r_4>* > vpdatar_;   // donnees du fimrware RAW apres FFT soft 

  bool* fgallfibok;  

  uint_8 npaqcumul_;     // Nb de paquets cumules/moyennes ds la matrice de visibilite 
  double moyfc_, moytt_;  // moyenne des FrameCounter / TimeTag pour chaque matrice de visibilite
  uint_8 first_fc_,first_tt_;  // Valeurs premier FrameCounter / TimeTag pour chaque matrice de visibilite
  TimeStamp first_tmstamp_;   // Date-Heure pour premier FrameCounter / TimeTag pour chaque matrice de visibilite
  
  TMatrix< complex<r_4> > vismtx_; 
  TVector< int_4 > chanids_;    // Numero de chaque canal=FiberId*2-1, FiberId*2
  TVector< int_4 > chanpairnumall_;  // Liste de tous les numeros de paires de canaux (forme 1000*C1+C2=IIIJJJ)
  TMatrix< int_4 > chanpairsall_ ;  // Liste de toutes paires de canaux (forme (C1,C2) )
  TVector< int_4 > chanpairnum_;    // Liste des paires de canaux calcules par ce BRVisibilityCalculator
  TMatrix< int_4 > chanpairs_ ;  // Liste des paires de canaux (forme (C1,C2) ) pour ce BRVisibilityCalculator

  bool fgfitsout_;  // if true -> write visibility matrices in fits format 

  //  FitsInOutFile dtfos_;
  DataTable visdt_;
  bool fgvisdt_;   // true -> fill datatable
  uint_4 numfile_;
  uint_8 totnbpaq_;

  r_8 nb_flop_;   // Nombre total d'operations effectuees

  // Variables/objets pour la verifications des timetag
  bool fgcktt_;  // true -> checktimetag 
  int_8 mindeltatt_;       // difference minimum de deux timetag successifs 
  TMatrix< uint_8 > fcmtx_; // matrices des framecounters
  TMatrix< uint_8 > ttmtx_; // matrices des timetag 
  vector< uint_8 > vlasttt_;  // dernieres valeurs de TimeTag / fibre
  vector< uint_8 > vbadtt_;  // Number of bad TimeTag paquets per fiber 
  vector< uint_8 > vnsamett_;  // Number of paquets having TimeTag <> TT_Fiber1 per fiber 
  vector< uint_8 > vndiff5tt_;  // Number of paquets having |TimeTag-TT_Fiber1|>5 per fiber 

  int prtlev_;    // print level 
  uint_8 prtmodulo_;   // print periodicity (modulo) 
};


//-------------------------------------------------------------------------------
// Classe Groupe (ensemble) de Calculateur de Visibilites, tournant en parallele
//-------------------------------------------------------------------------------

class BRVisCalcGroup {
public: 
  BRVisCalcGroup(size_t nbcalc, RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean=1000,
                 uint_4 pair1=0, uint_4 nbpairs=999999999, bool fgpimp=false, size_t nthr=1);
  ~BRVisCalcGroup();

  MemZStatus SetMemZAction(MemZaction mmact=MemZA_ProcA);

  int SelectFreqBinning(uint_4 freq1=0, uint_4 freq2=0, uint_4 nbfreq=1);
  inline int ActivateTimeTagCheck(uint_8 maxnpaq)
  { return viscalcp_[0]->ActivateTimeTagCheck(maxnpaq); }
  void ActivateVisDTable(bool fgfdt=false);
  // Pour ecrire les fichiers de sortie au format fits (format PPF sinon) 
  void SetFitsOutput();
  // Pour ecrire les fichiers de sortie au format PPF (defaut) 
  void SetPPFOutput();
  // configuration avec donnees firmware FFT (defaut) 
  void SetFFTData();  
  // configuration avec donnees firmware RAW  
  void SetRawData();  
  // Pour passer en mode nombre de paquet pour sauvegarde matrices visibilites (defaut)
  void SetNPaqIntervalMode(uint_4 nmean=1000);
  // Pour passer en mode intervalle en temps pour sauvegarde matrices visibilites 
  void SetTimeIntervalMode(double dtime=1.);

  void SetPrintLevel(int lev=0, uint_8 prtmodulo=10);

  void start();
  void join();
protected:
  vector<BRVisibilityCalculator *> viscalcp_; 
  Timer tm_;
};


#endif