Changeset 1454 in Sophya for trunk/ArchTOIPipe/ProcWSophya


Ignore:
Timestamp:
Apr 9, 2001, 2:14:21 PM (24 years ago)
Author:
ansari
Message:

Modifs effectuees a St Pierre de Charetreuse - Reza 9/4/2001

Location:
trunk/ArchTOIPipe/ProcWSophya
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/ArchTOIPipe/ProcWSophya/simtoipr.cc

    r1443 r1454  
    11#include "simtoipr.h"
     2#include <math.h>
    23#include "toimanager.h"
    34#include "pexceptions.h"
    … …  
    1617  nsig = ns;
    1718  maxpoints = maxnpt;
    18   totnscount = glnscount = glcount = 0;
     19  totnscount = glnscount = glcount = out_range_nscount = 0;
    1920  deglitchdone = false;
     21  SetRange(-9.e39, 9.e39);
    2022}
    2123
    … …  
    2325{
    2426}
     27
    2528
    2629void SimpleDeglitcher::PrintStatus(ostream & os)
    … …  
    2932     << " SimpleDeglitcher::PrintStatus() - WindowSize=" << WSize()
    3033     << "  NbSigmas=" << NbSigmas() << " MaxPoints=" << MaxPoints() << endl;
     34  os << "  Range_Min= " << range_min << " Range_Max= " << range_max << endl;
    3135  TOIProcessor::PrintStatus(os);
    3236  if (deglitchdone) os << " Deglitching performed " << endl;
    3337  else os << " NO deglitching done " << endl;
    34   double nst = (TotalSampleCount() > 0) ? TotalSampleCount() : 1.;
    35   os << " TotalSampleCount=" << TotalSampleCount() << " GlitchCount= "
    36      << GlitchCount() << " GlitchSampleCount=" << GlitchSampleCount()
     38  double nst = (ProcessedSampleCount() > 0) ? ProcessedSampleCount() : 1.;
     39  os << " ProcessedSampleCount=" << ProcessedSampleCount()
     40     << " OutOfRangeSampleCount=" << OutOfRangeSampleCount() << endl;
     41  os << " GlitchCount= " << GlitchCount()
     42     << " GlitchSampleCount=" << GlitchSampleCount()
    3743     << "( " << (double)GlitchSampleCount()*100./nst << " % )" << endl;
    3844  os << " ------------------------------------------------------ " << endl;
    … …  
    8187    Timer tm("SimpleDeglitcher::run()");
    8288    // Le debut
    83     int wsz2 = wsize/2;
    8489    Vector vin(wsize);
     90    TVector<int_8> vfg(wsize);
    8591    int k;
    86     for(k=0; k<wsize; k++)
     92    for(k=0; k<wsize; k++) {
    8793      vin(k) = getData(0, k+snb);
     94      vfg(k) = getFlag(0, k+snb);
     95    }
    8896    double s = vin.Sum();
    8997    double mean = s/wsize;
     98    for(k=0; k<wsize; k++) {
     99      if ( (vin(k) < range_min) || (vin(k) > range_max) ) {
     100        vin(k) = mean;
     101        vfg(k) |= 2;
     102        out_range_nscount++;
     103      }
     104    }
     105    s = vin.Sum();
     106    mean = s/wsize;
     107
    90108    double s2 = vin.SumX2();
    91109    double sigma = sqrt(s2/wsize-mean*mean);
    … …  
    94112    bool fgglitch = false;
    95113    double valcur,valsub,valadd;
     114    uint_8 fgcur;
     115
     116    // Boucle sur les sampleNum
     117
    96118    for(k=0;k<=sne-snb;k++) {
    97119      totnscount++;
    98120//       if (k%10000 == 0) cout << " DBG: K=" << k << endl;
    99121      // Calcul mean-sigma
    100       if ((k>wsz2) && (k<sne-snb-wsz2)) {
    101         valsub = vin((k+wsz2)%wsize);
    102         vin((k+wsz2)%wsize) = valadd = getData(0, k+wsz2+snb);
     122      if (k>=wsize)  {
     123        valsub = vin(k%wsize);
     124        vin(k%wsize) = valadd = getData(0, k+snb);
     125        vfg(k%wsize) = getFlag(0, k+snb);
     126        if ( (valadd < range_min) || (valadd > range_max) )
     127          valadd = mean;
    103128        s += (valadd-valsub);
    104129        s2 += (valadd*valadd-valsub*valsub);
    … …  
    112137      if (fgsigma)
    113138        putData(2, k+snb, sigma, 0);
     139      if (fgincopie)
     140        putData(3, k+snb, vin(k%wsize), vfg(k%wsize));
    114141
    115142      valcur = vin(k%wsize);
    116       if (fgincopie)
    117         putData(3, k+snb, valcur, 0);
     143      if ( (valcur < range_min) || (valcur > range_max) ) {
     144        vin(k%wsize) = valcur = mean;
     145        vfg(k%wsize) |= 2;
     146        out_range_nscount++;
     147      }
    118148       
    119149      if (!fgout)   continue;  // Pas de sortie out (deglitche)
    … …  
    133163            glcount++;
    134164            for(ii=kgl; ii<k; ii++) {
    135               putData(0, ii+snb, mean, 7);
     165              putData(0, ii+snb, mean, vfg(ii%wsize)|5);
    136166              glnscount++;
    137167            }
    … …  
    140170          else {
    141171            for(ii=kgl; ii<k; ii++) {
    142               putData(0, ii+snb, vin(ii%wsize), 0);
     172              putData(0, ii+snb, vin(ii%wsize), vfg(ii%wsize));
    143173            }
    144174            lastput = snb+k-1; 
    … …  
    153183          if (k-kgl+1 >= maxpoints) {  // serie de points > seuil
    154184            for(ii=kgl; ii<=k; ii++)   // -> Donc pas glitch
    155               putData(0, ii+snb, vin(ii%wsize), 0);
     185              putData(0, ii+snb, vin(ii%wsize), vfg(ii%wsize));
    156186            lastput = snb+k;
    157187            fgglitch = false; 
    … …  
    163193          }
    164194          else { // On est toujours dans une serie > seuil
    165             putData(0, k+snb, valcur, 0);
     195            putData(0, k+snb, valcur, fgcur);
    166196            lastput = snb+k;
    167197          }
    … …  
    178208    //    cout << " DBG3- OUT of try bloc ! " << endl;
    179209    cout << " SimpleDeglitcher::run() - End of processing "
    180     << " TotalSampleCount=" << TotalSampleCount()
     210    << " ProcessedSampleCount=" << ProcessedSampleCount()
    181211    <<  " GlitchCount= " << GlitchCount() << endl;
    182212    if (fgout) deglitchdone = true;
    … …  
    189219
    190220
     221// -------------------------------------------------------------------
     222//   Classe SimpleFilter : Filtre simple ds le domaine temporel
     223// -------------------------------------------------------------------
     224
     225string SimpleFilter::FilterKind2String(FilterKind fk)
     226{
     227  switch (fk) {
     228    case UserFilter :
     229      return ("UserFilter");
     230      break;
     231    case MeanFilter :
     232      return ("MeanFilter");
     233      break;
     234    case SumFilter :
     235      return ("SumFilter");
     236      break;
     237    case GaussFilter :
     238      return ("GaussFilter");
     239      break;
     240    case DiffFilter :
     241      return ("DiffFilter");
     242      break;
     243    default :
     244      return ("ErrorFilterKind");
     245      break;
     246  }
     247  return("");
     248}
    191249
    192250SimpleFilter::SimpleFilter(int wsz, FilterKind fk, double a, double s)
    … …  
    195253  if (wsz%2 == 0) wsz++;
    196254  cout << "SimpleFilter::SimpleFilter() wsz= " << wsz
    197        << " fk=" << fk << endl;
     255       << " FilterKind=" << FilterKind2String(fk) << endl;
    198256  wsize = wsz;
    199257  totnscount = 0;
    200258  coef = new double[wsz];
    201   for(int kk=0; kk<wsz; kk++)
    202     coef[kk] = 1./wsize;
     259  switch (fk) {
     260    case UserFilter :
     261      throw ParmError("SimpleFilter: Error in filter Kind (UserFilter)!");
     262      break;
     263    case MeanFilter :
     264      for(int kk=0; kk<wsz; kk++)
     265        coef[kk] = a/wsize;
     266      break;
     267    case SumFilter :
     268      for(int kk=0; kk<wsz; kk++)
     269        coef[kk] = a;
     270      break;
     271    case GaussFilter :
     272      for(int kk=-(wsz/2); kk<=(wsz/2); kk++)
     273        coef[kk] = a*exp((double)(kk*kk)/(s*s));
     274      break;
     275    case DiffFilter :
     276      for(int kk=0; kk<wsz; kk++)
     277        coef[kk] = -a/wsize;
     278      coef[wsz/2+1] += 1.;
     279      break;
     280    default :
     281      throw ParmError("SimpleFilter: Error in filter Kind (UnknownFilter)!");
     282      break;
     283  }
     284}
     285
     286SimpleFilter::SimpleFilter(Vector const & vc)
     287{
     288  int wsz = vc.Size();
     289  if (wsz < 3) wsz = 3;
     290  if (wsz%2 == 0) wsz++;
     291  FilterKind fk = UserFilter;
     292  cout << "SimpleFilter::SimpleFilter(Vector & vc) vc.Size()= "
     293       << vc.Size() << " WSize=" << wsz
     294       << " FilterKind=" << FilterKind2String(fk) << endl;
     295  wsize = wsz;
     296  totnscount = 0;
     297  coef = new double[wsz];
     298  for(int kk=0; kk<vc.Size(); kk++)
     299    coef[kk] = vc(kk);
     300  for(int kk=vc.Size(); kk<wsz; kk++)
     301    coef[kk] = 0.;
    203302}
    204303
    … …  
    217316  for(int k=0; k<wsize; k++) os << coef[k] << " " ;
    218317  os << endl;
    219   os << " TotalSampleCount=" << TotalSampleCount() << endl;
     318  os << " ProcessedSampleCount=" << ProcessedSampleCount() << endl;
    220319  os << " ------------------------------------------------------ " << endl;
    221320}
    … …  
    257356    int wsz2 = wsize/2;
    258357    Vector vin(wsize);
     358    TVector<int_8> vfg(wsize);
    259359    int k;
    260     for(k=0; k<wsize; k++)
    261       vin(k) = getData(0, k+snb);
     360    for(k=0; k<wsize; k++) {
     361      vin(k%wsize) = getData(0, k+snb);
     362      vfg(k%wsize) = getFlag(0, k+snb);
     363    }
    262364    double mean = vin.Sum()/wsize;
    263     for(k=0; k<wsize/2; k++) vin(k) = mean;
     365    for(k=wsz2+1; k<wsize; k++) {
     366      vin(k) = mean;
     367      vfg(k) = 0;
     368    }
     369    int knext;
     370    bool fgfin = false;
     371    // Boucle sur les sampleNum
    264372    for(k=0;k<=sne-snb;k++) {
    265       totnscount++;
    266       // Calcul mean-sigma
    267       if ((k>wsz2) && (k<sne-snb-wsz2))
    268         vin((k+wsz2)%wsize) = getData(0, k+snb);
    269       //      if (k == sne-snb-wsz2) {
    270       //      }
    271373      double sortie = 0;
    272374      for(int ii=0; ii<wsize; ii++) {
    273         sortie += vin((ii+k)%wsize)*coef[ii];
    274       }
    275       putData(0,k+snb,sortie,0);
    276       if (fgincopie) putData(1,k+snb,vin(k%wsize),0);
     375        sortie += vin(ii)*coef[(ii+wsz2)%wsize];
     376      }
     377      putData(0,k+snb,sortie,vfg(k%wsize));
     378      if (fgincopie)
     379        putData(1, k+snb, vin(k%wsize), vfg(k%wsize));
     380      knext = k+wsz2+1;
     381      if (knext<=(sne-snb)) {
     382        vin(knext%wsize) = getData(0, knext+snb);
     383        vfg(knext%wsize) = getFlag(0, knext+snb);
     384      }
     385      else {
     386        if (!fgfin) {
     387          mean = vin.Sum()/wsize;
     388          fgfin = true;
     389        }
     390        vin(knext%wsize) = mean;
     391        vfg(knext%wsize) = 0;
     392      }
     393      totnscount++;
    277394    }  // Boucle sur les num-sample
    278395    cout << " SimpleFilter::run() - End of processing " << endl;
    … …  
    283400         << "\n .... Msg= " << exc.Msg() << endl;
    284401  }                                                                             
    285 
    286 
    287 }
     402}
     403
     404// ---------------------------------------------------------------
     405// -------------------- Classe SimpleAdder -----------------------
     406// ---------------------------------------------------------------
     407
     408SimpleAdder::SimpleAdder(int nbinput)
     409  : gains(nbinput)
     410{
     411  if (nbinput < 1)
     412    throw ParmError("SimpleAdder::SimpleAdder() NbInput < 1 !");
     413  nb_input = nbinput;
     414  for(int k=0; k<nb_input; k++) gains(k) = 1.;
     415  totnscount = 0;
     416}
     417
     418SimpleAdder::~SimpleAdder()
     419{
     420}
     421
     422void SimpleAdder::SetGain(int num, double g)
     423{
     424  if ((num < 0) || (num >= nb_input))
     425    throw RangeCheckError("SimpleAdder::SetGain() Out of range input number!");
     426  gains(num) = g;
     427  return;
     428}
     429
     430double SimpleAdder::Gain(int num)
     431{
     432  if ((num < 0) || (num >= nb_input))
     433    throw RangeCheckError("SimpleAdder::Gain() Out of range input number!");
     434  return gains(num);
     435}
     436
     437void SimpleAdder::PrintStatus(ostream & os)
     438{
     439  os << "\n ------------------------------------------------------ \n"
     440     << " SimpleAdder::PrintStatus() - NbInput=" << NbInput() << endl;
     441  TOIProcessor::PrintStatus(os);
     442  os << " Gains= " ;
     443  for(int k=0; k<nb_input; k++) os << gains(k) << " " ;
     444  os << endl;
     445  os << " ProcessedSampleCount=" << ProcessedSampleCount() << endl;
     446  os << " ------------------------------------------------------ " << endl;
     447}
     448
     449void SimpleAdder::init() {
     450  cout << "SimpleAdder::init NbInput=" << nb_input << endl;
     451  char buff[32];
     452  for(int k=0; k<nb_input; k++) {
     453    sprintf(buff,"in%d", k);
     454    declareInput(buff);
     455  }
     456
     457  declareOutput("out");
     458  name = "SimpleAdder";
     459  //  upExtra = 1;
     460}
     461
     462void SimpleAdder::run() {
     463  //  TOIManager* mgr = TOIManager::getManager();
     464  int snb = getMinIn();
     465  int sne = getMaxIn();
     466
     467  bool fgout = checkOutputTOIIndex(0);
     468  string msg_err;
     469  for(int ki=0;ki<nb_input;ki++) {
     470    if (!checkInputTOIIndex(ki)) {
     471      msg_err = "SimpleAdder::run() - Input TOI (" + getInName(ki) +
     472                " not connected!";
     473      cerr << msg_err << endl;
     474      throw ParmError(msg_err);
     475    }
     476  }
     477  if (!fgout) {
     478    cerr << " SimpleAdder::run() - No Output TOI connected! "
     479         << endl;
     480    throw ParmError("SimpleAdder::run() No output TOI connected!");
     481  }
     482
     483  cout << " SimpleAdder::run() SNRange=" << snb << " - " << sne << endl;
     484 
     485
     486  try {
     487    Timer tm("SimpleAdder::run()");
     488    int k,i;
     489    double out = 0.;
     490    unsigned long fgout = 0;
     491    for(k=snb;k<=sne;k++) {
     492      out = 0;
     493      fgout = 0;
     494      for(i=0; i<nb_input; i++) {
     495        out += gains(i)*getData(i, k);
     496        fgout = fgout | (unsigned int)getFlag(i,k);
     497      }
     498    putData(0,k,out,fgout);
     499    totnscount++;
     500    }  // Boucle sur les num-sample
     501    cout << " SimpleAdder::run() - End of processing " << endl;
     502  }  // Bloc try
     503
     504  catch (PException & exc) {
     505    cerr << "SimpleAdder: Catched Exception " << (string)typeid(exc).name()
     506         << "\n .... Msg= " << exc.Msg() << endl;
     507  }                                                                             
     508}
     509
     510
     511

  • trunk/ArchTOIPipe/ProcWSophya/simtoipr.h

    r1443 r1454  
    55
    66#include "toiprocessor.h"
     7#include "tvector.h"
    78
    89// ---------  Un deglitcheur simple
    … …  
    1617  virtual       ~SimpleDeglitcher();
    1718
     19  inline void   SetRange(double min, double max)
     20    { range_min = min; range_max = max; }
     21  inline void   GetRange(double& min, double& max) const
     22    { min = range_min; max = range_max; }
     23
    1824  virtual void  init(); 
    1925  virtual void  run();
    … …  
    2329  inline int    MaxPoints() const { return maxpoints; }
    2430 
    25   inline int    TotalSampleCount() const { return totnscount; }
    26   inline int    GlitchCount() const { return glcount; }
    27   inline int    GlitchSampleCount() const { return glnscount; }
     31  inline int_8  ProcessedSampleCount() const { return totnscount; }
     32  inline int_8  GlitchCount() const { return glcount; }
     33  inline int_8  GlitchSampleCount() const { return glnscount; }
     34  inline int_8  OutOfRangeSampleCount() const { return out_range_nscount; }
    2835 
    2936  virtual void  PrintStatus(ostream & os) ; // const plus tard
    3037 
    3138protected:
    32   int totnscount;   // Nombre total d'echantillon processe
    33   int glnscount;    // Nombre total de glitch
    34   int glcount;      // Nombre de glitch detecte
     39  int_8 totnscount;   // Nombre total d'echantillon processe
     40  int_8 glnscount;    // Nombre total de glitch
     41  int_8 glcount;      // Nombre de glitch detecte
     42  int_8 out_range_nscount;  // Nombre de sample Out Of Range
    3543  bool deglitchdone;  // Deglitch effectue
    3644
    … …  
    3846  double nsig;      // Seuil en nb de sigmas
    3947  int maxpoints;    // Nb maxi de points > ns sigmas
     48  double range_min, range_max;  // Range acceptable pour in
    4049};
    4150
    … …  
    5463  };
    5564
     65  static string FilterKind2String(FilterKind fk);
    5666                SimpleFilter(int wsz=128,
    57                               FilterKind fk=SimpleFilter::MeanFilter,
    58                               double a=1., double s=1.);
    59   //            SimpleFilter(int wsz, Arr_DoubleFunctionOfX f=NULL);
     67                             FilterKind fk=SimpleFilter::MeanFilter,
     68                             double a=1., double s=1.);
     69                SimpleFilter(Vector const & vc);
    6070                ~SimpleFilter();
    6171
    … …  
    6373
    6474  inline int    WSize() const { return wsize; }
    65   inline int    TotalSampleCount() const { return totnscount; }
     75  inline int_8  ProcessedSampleCount() const { return totnscount; }
     76  Vector        FilterCoefficients() const;
    6677
    6778  virtual void  PrintStatus(ostream & os) ; // const plus tard
    … …  
    7283protected:
    7384  FilterKind fkind;
    74   int totnscount;   // Nombre total d'echantillon processe
     85  int_8 totnscount;   // Nombre total d'echantillon processe
    7586  int wsize;        // Taille de fenetre de travail
    7687  double* coef;     // Coefficients du filtre
    … …  
    7889};
    7990
     91//  Classe SimpleAdder
     92//  Calcule la sortie = Somme_Entree [ coeff[num] * entree[num] ]
     93
     94class SimpleAdder : public TOIProcessor {
     95public:
     96                SimpleAdder(int nbinput);
     97                ~SimpleAdder();
     98
     99  void          SetGain(int num, double g);
     100  double        Gain(int num);
     101
     102  inline int    NbInput() const { return nb_input; }
     103  inline int_8  ProcessedSampleCount() const { return totnscount; }
     104
     105  virtual void  PrintStatus(ostream & os) ; // const plus tard
     106
     107  virtual void  init(); 
     108  virtual void  run();
     109
     110protected:
     111  int nb_input;
     112  Vector gains;
     113  int_8 totnscount;   // Nombre total d'echantillon processe
     114};
     115
     116
    80117#endif
Note: See TracChangeset for help on using the changeset viewer.