TDSPStatistics.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TDSPSTATISTICS_H
#define TDSPSTATISTICS_H
#include <Rtypes.h>
#include <TError.h>
#include <TRandom.h>
#include <TComplex.h>
#include <TDSPRating.h>
#include <TDSPFifoFilter.h>


enum eStochasticType { 
  kNoChange,
  kGauss,
  kRayleigh,
  kFilterGauss,
  kFilterRayleigh
};

enum eEstimateNumSymbols {
  kEstimateSER,       
  kEstimateSERlog,
  kEstimatedSERlog
};

#include "TDSPSymbolGenerator.h"

class TDSPSymbolGenerator;


class TDSPStochasticProcess : public TDSPRating {
  
 protected:
  
  eStochasticType        fMode;
  
  TComplex *fSigmas;           
  TComplex  *fMeans;           

  
  virtual void ChangeRepresentation() {}; // This function has really to change the Representation

  
 public: 
  
  TDSPStochasticProcess();
  virtual ~TDSPStochasticProcess();

  void     SetMode(eStochasticType mode) { fMode = mode;}; // Set the Stochatistic Mode                   
  Int_t    GetMode(eStochasticType mode) { return fMode;}; // Get the Stochatistic Mode 
    

  Bool_t    SetRepresentation(Double_t rate=1);   

  void     SetMean(Double_t  mean)                    // same as SetMeans(s);
    { fMeans[0]  = mean;};
  void     SetSigma(Double_t sigma)                   // same as SetSigmas(s);
    { fSigmas[0] = TComplex(sigma,sigma);};         
  void     SetSigmas(Double_t sigma, Int_t index = 0) // Set equal real/imag Sigmas for Gaussian Process
    { fSigmas[index] = TComplex(sigma,sigma); };   
  void     SetSigmas(TComplex sigma, Int_t index = 0) // Set diff  real/imag Sigmas for Gaussian Process
    { fSigmas[index] = sigma; };  
  void     SetMeans(Double_t mean,   Int_t index = 0) // Set real Means for Gaussian Process
    { fMeans[index] = mean; };   
  void     SetMeans(TComplex mean, Int_t index = 0)  // Set complex Means for Gaussian Process
    { fMeans[index] = mean; };  

  virtual Double_t SER(Double_t SNR, TDSPSymbolGenerator*);

  
  TComplex GetSigmas( Int_t index = 0) { return fSigmas[index];}; // Get Sigmas for Gaussian Process
  TComplex GetMeans(  Int_t index = 0) { return fMeans[index];};  // Get Means for Gaussian Process

  virtual void    Reset() = 0;

  ClassDef(TDSPStochasticProcess,0)
};


class TDSPStochasticScalar : public TDSPStochasticProcess {

  
 protected:
  
  TComplex        fValue;      // The actual Representation of the Scalar 
  TDSPFifoFilter* fFifoFilter; // Fifo Filter for correlated output

 public:

  
  TDSPStochasticScalar();
  virtual ~TDSPStochasticScalar();

  void            SetMode(eStochasticType mode);
  TComplex&       Value() { return fValue; };
  virtual void    ChangeRepresentation();

  void            SetFifoFilter(TDSPFifoFilter* f) { fFifoFilter = f;};
  TDSPFifoFilter* GetFifoFilter() const { return fFifoFilter; };
  
  virtual void    PrepareRate(Double_t rate);
  
  virtual void    Reset();

  ClassDef(TDSPStochasticScalar,1)
};


class TDSPStatistics {
  
 public:
  
  static UInt_t EstimateNumSymbols(Double_t SER,                // the SER
                   Double_t dError,             // the Error
                   UInt_t Default,              // the Default Value
                   eEstimateNumSymbols method,  // the Method
                   UInt_t Min=0                 // Minimum Number
                   );
  static UInt_t   EstimateNumSymbols(Double_t SER,    // the SER
                     Double_t dError, // the Error
                     UInt_t Default,  // the Default Value (for SER=0)
                     char *method,    // the Method
                     UInt_t Min=0     // Minimum Number
                     );
    

  ClassDef(TDSPStatistics,0)
};



inline void TDSPStochasticScalar::PrepareRate(Double_t rate) {
  
    switch(fMode) {
  case kFilterGauss:
  case kFilterRayleigh:
    // Syncronize the required rate with the rate of the Filter
    //
    TDSPStochasticProcess::PrepareRate(rate*fFifoFilter->GetRate());
    
    break;
  default:
    TDSPStochasticProcess::PrepareRate(rate);
    break;
  }
}



inline void  TDSPStochasticScalar::ChangeRepresentation() {
  
  switch(fMode) {
    
  case kNoChange:
    fValue = 1;
    break;
    
  case kGauss:
    fValue = TComplex(gRandom->Gaus(fMeans->fRe,fSigmas->fRe), gRandom->Gaus(fMeans->fIm,fSigmas->fIm));
    break;

  case kRayleigh:  // No Phase Change (=Coherent Detection is possible)
    fValue = Abs(TComplex(gRandom->Gaus(fMeans->fRe,fSigmas->fRe), gRandom->Gaus(fMeans->fIm,fSigmas->fIm)));
    break;

  case kFilterGauss:
    if (fFifoFilter) {
      fValue = TComplex(gRandom->Gaus(fMeans->fRe,fSigmas->fRe), 
            gRandom->Gaus(fMeans->fIm,fSigmas->fIm));
      fValue = fFifoFilter->filter(fValue);
    } else {
      Error("ChangeRepresentation","No FifoFilter set !!");
      fValue=0;
    }
    break;

  case kFilterRayleigh:
    if (fFifoFilter) {
      fValue = TComplex(gRandom->Gaus(fMeans->fRe,fSigmas->fRe), 
            gRandom->Gaus(fMeans->fIm,fSigmas->fIm));
      fValue = Abs(fFifoFilter->filter(fValue));
    } else {
      Error("ChangeRepresentation","No FifoFilter set !!");
      fValue=0;
    }
    break;
    
  default:
    Error("ChangeRepresentation","Unknown Stochastic Model!");
    fValue = TComplex(0,0);
    break;

  }

}


inline Bool_t TDSPStochasticProcess::SetRepresentation(Double_t rate) {
  
  Bool_t RepresentationChanged = kFALSE;
  // Prepare the Rating of the Stochastic Process 
  // to use the the given rating "rate" of the input signal
  //
  PrepareRate(rate);
  
  // Do we have to change the Representation now ?
  //

  if ((RepresentationChanged = IsRate())) ChangeRepresentation();
  
  // Next Entry
  //
  
  Next();


  return RepresentationChanged; 

}

#endif

---