TDSPSymbolGenerator.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 TDSPSYMBOLGENERATOR_H
#define TDSPSYMBOLGENERATOR_H

#include <TRandom.h>
#include <TH1.h>
#include <TH2.h>
#include <Rtypes.h>
#include <TDSPOutput1.h>
#include <TDSPStatistics.h>

// Options
//
#define kDEFAULT_OPTIONS               0

#define NOT_DETECTED -1

#define NUMSYMBOLS64

class TDSPSymbolGenerator : public TDSPOutput1  {
  
 private:
  Bool_t      fAnalysed;      // Is there Analysed Data already ?

 protected:
  UInt_t      fDumpOptions;   // Dump options during simnulation
  UInt_t      fOptions;       //   Options
#ifdef  NUMSYMBOLS64
  Long64_t    fAnalyseGrid;   //   how many detected symbols should analysed together 
  Long64_t    fNumAnalysed;
#else
  UInt_t      fAnalyseGrid;   //   how many detected symbols should analysed together 
  UInt_t      fNumAnalysed;
#endif
  Int_t       fNumSymbols;    //   Number of possible Symbols 
  Double_t   *fProbs;         
  
  Double_t   *fDetectSigmas;  

  TDSPSignal *fDecisionSignal; 
  
  Int_t       fNumISymbols;   
  Int_t       fNumISymbolsAlloc;  
  Int_t      *fISymbols;      
  Double_t   *fDetectProbs;   
  

  TComplex    fGlobalCorrection; 
  TComplex    fCorrection;       
  UInt_t      fCorrectionTrackingInterval;    
  UInt_t      fCorrectionTrackingIndex; 
  TDSPSignal* fReferenceSignal; 
  
  TString          Slot_Generate;
  TString          Slot_Update;
  TString          Slot_ReferenceUpdate;

  void             NormalizeProbs();
  

  virtual void     BookSymbols(Int_t num);
  virtual void     InitSymbols() = 0;

  // This split up of the generation routines 
  // allowing better optimizations
  
  virtual void     GenerateSymbols(Int_t, TComplex*); // Generate a lot of symbols 
  virtual Int_t    GenerateSymbol(TComplex*); // returns the symbol index

  virtual Int_t    DetectSymbol(TComplex&);   // returns the symbol index

  void             Analyse_Reset();
  void             Analyse_Finish();
  void             Analyse_Symbol(Int_t,TComplex*,
                  Int_t,TComplex*);

  
  // Distances

  Double_t         fMinDistance;
  Double_t         fMeanDistance;
  Double_t         fVarianceDistance;
  Double_t         fQWeightedDistance;
  Double_t         fQWeightedVarianceDistance;

  void             _calc_distances();
  void             _check_distances();
  Bool_t           _recalc_distances;

  void             DumpStep(); 

 public: 

  TComplex   *fSymbols;       

  Int_t      *fYields;        
  Int_t       fMisIdentified; //   number of misidentifications
  Double_t    fInEfficiency;  //   Inefficiency
  Double_t    fdInEfficiency; //   abs. Error of Inefficiency

  Double_t    fNoisePower;    //   Noise Power
  Double_t    fSignalPower;   //   sent Signal Power
  Double_t    fReceivedPower;   // received Signal Power
  TComplex    fAttentuation;   // the mean attentuation and phase rotation
  Double_t    fSINR;           //  SINR in dB
  Double_t    fLogSER;        //   LogSER 
  Double_t    fdLogSER;       //   Error of LogSER

  // Constructor and Destructor
  //
 
  TDSPSymbolGenerator(char *name, 
              Int_t,
              UInt_t = kDEFAULT_OPTIONS);

  ~TDSPSymbolGenerator();

  // Theoretic Error Rates
  //
  
  virtual Double_t SER(Double_t SNR);
  Double_t LogSER_dB(Double_t SNRdB);
  TComplex* GetSymbols() const { return fSymbols;};
  

  UInt_t GetNumSymbols() { return fNumSymbols;};
  void   SetAnalyseGrid(UInt_t a);
  void   SetSignalLength(Int_t num);
  void   ReduceSignalLength(Int_t num);
  Int_t  GetSignalLength() { return fNumISymbols;};
  Bool_t IsAnalysed() { return fAnalysed; };
  void   SetOption(Option_t*);

  Double_t GetSignalPower()  { return fSignalPower/fNumAnalysed;};
  Double_t GetReceivedPower()  { return fReceivedPower/fNumAnalysed;};
  Double_t GetIntNoisePower() { return fNoisePower/fNumAnalysed;};
  Double_t GetSINR() { return fSignalPower/fNoisePower;};
  TComplex GetAttentuation() { return fAttentuation/Double_t(fNumAnalysed);};

  Double_t GetDistance(Option_t *opt); // Get several distances from the alphabet
  
  TDSPSignal* GetDecisionSignal(); // Get the signal used for decision

  // Global Phase/Gain corrections

  TComplex& GetGlobalCorrection()  { return  fGlobalCorrection;};
  void      SetGlobalCorrection(TComplex c) { fGlobalCorrection=c;};

  // Tracking of Phase/Gain corrections (like CPEC/IDEAL_PHASE/REFERENCE_SIGNAL)
  // enable using SetOption(...)

  TComplex& GetCorrection()  { return fCorrection;}; 
  void      SetCorrection(TComplex c) { fCorrection=c;}; 

  UInt_t    GetCorrectionTrackingInterval() const { return fCorrectionTrackingInterval;}; 
  void      SetCorrectionTrackingInterval(UInt_t i) { fCorrectionTrackingInterval=i;}; 

  UInt_t EstimateNumSymbols(Double_t dError, 
                UInt_t   d,
                eEstimateNumSymbols method,
                UInt_t   min=0); // Estimates the needed Number of Symbols
  
  UInt_t EstimateNumSymbols(Double_t dError, 
                UInt_t   d = 10000,
                char *method = "",
                UInt_t   min=0); // Estimates the needed Number of Symbols

  // Slots
  
  void        Generate();
  TDSPSignal *Update(TDSPSignal*);
  void        ReferenceUpdate(TDSPSignal*s) { fReferenceSignal=s;};

  ClassDef(TDSPSymbolGenerator,1)

};



inline Int_t TDSPSymbolGenerator::GenerateSymbol(TComplex *c) {
  Double_t fR = gRandom->Rndm();
  Double_t prob = 0;
  
  for(Int_t i=0;i<fNumSymbols;i++) {
    prob += fProbs[i];
    if (fR < prob) {*c = fSymbols[i];return i;};
  }
  
  
  // This should only happen if fR==1
  // 

  Error("GenerateSymbol","(..) - Unnormal case fR = %f, prob = %f\n",
    fR,prob);
  
  *c = fSymbols[fNumSymbols-1];

  return fNumSymbols-1;
}

inline Int_t TDSPSymbolGenerator::DetectSymbol(TComplex& s) {
  
  Double_t len,s1;
  Double_t max_lik = 0;

  Int_t detected = NOT_DETECTED;

  // Calculate all Likelihoods
  //
  for(register Int_t i=0;i<fNumSymbols;i++) {

    len=Abs(s-fSymbols[i]);
    len*=-len;

    s1=2*fDetectSigmas[i];
    s1*=s1;

    fDetectProbs[i] = TMath::Exp(len/s1);
    
    if (fDetectProbs[i]>max_lik) {
      detected = i;
      max_lik = fDetectProbs[i];
    } else 
      if (fDetectProbs[i] == max_lik) {
    detected = NOT_DETECTED;
      }
  }


  return detected;

}

// Generate a lot of symbols
//
inline void TDSPSymbolGenerator::GenerateSymbols(Int_t num,
                         TComplex *c) {
  Int_t *sym = fISymbols;
  for(register Int_t i=num;i;--i) 
    *(sym++) = GenerateSymbol(c++);
}

// Generate one symbol
//
inline Double_t TDSPSymbolGenerator::LogSER_dB(Double_t SNRdB) {
  Double_t s=TMath::Power(10,SNRdB/10);
  return TMath::Log10(SER(s)); 
}


TDSPSymbolGenerator* Modulator(Option_t *name, Int_t param = 0);

#endif

---