TDSPWssus.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 TDSPWSSUS_H
#define TDSPWSSUS_H

#include <TDSPVector.h>
#include <TDSPMatrix.h>
#include <TDSPLTVChannel.h>

class TDSPWssus : public TDSPLTVChannel  {
 protected:

  Int_t       fType; 

  TDSPMatrix* fTransferFunction; 
  TDSPMatrix* fScatteringFunction; 
  TDSPMatrix* fSpreadingFunction; 

  Double_t    fMaxDoppler;    
  Double_t    fCarrierFreq;   
  Double_t    fSymbolRate; 
  Double_t    fOverSampling; 

  Double_t    fExpDecay; 
  Double_t    fMaxDelay; 


  static TDSPMatrix* 
    ScatFunction(Int_t     type,
         Double_t  alpha,
         Double_t  beta,
         UInt_t    t0,
         UInt_t    f0,
         UInt_t    clen,
         TDSPMatrix *ScatFun=NULL);

  static TDSPMatrix*
    TapFunction(TDSPMatrix *ScatFun,       // The Scattering Matrix
        UInt_t      tlen,          // Maximum Time Delay
        UInt_t      flen,          // Maximum Doppler Shift
        UInt_t      TapFunLen,     // The length of the tapfunction
        TDSPMatrix *TapFun=NULL);  // The tapfun itself
  
 public: 
  TDSPWssus(char *name = NULL);
  ~TDSPWssus();
  
  // Setting Options
  //
  // jakes - jakes spectrum
  // flat  - flat spectrum
  // or - see more : TDSPLTVChannel::SetOption(..)

  void               SetOption(Option_t *opt); 
  
  void               SetSymbolRate(Double_t s) { fSymbolRate=s;};
  void               SetSymbolRateMHz(Double_t s) { SetSymbolRate(s*1.0e6);};
  void               SetOverSampling(Double_t s) { fOverSampling=s;};
  void               SetMaxDoppler(Double_t d) { fMaxDoppler=d;};
  void               SetSpeed(Double_t v) { SetMaxDoppler(v/3.0e8*fCarrierFreq);}; 
  void               SetSpeedKMH(Double_t v) { SetSpeed(v*1000./3600.);}; 
  void               SetCarrierFrequency(Double_t f) { fCarrierFreq=f;}; 
  void               SetCarrierFrequencyMHz(Double_t f) { SetCarrierFrequency(f*1.0e6); }; 
  void               SetCarrierFrequencyGHz(Double_t f) { SetCarrierFrequency(f*1.0e9); }; 
  void               SetExpDecay(Double_t al) { fExpDecay = al;}; 
  void               SetExpDecayMHz(Double_t al) { SetExpDecay(al*1.0e6);}; 
  void               SetMaxDelay(Double_t md) { fMaxDelay = md;}; 
  void               SetMaxDelayMus(Double_t md) { SetMaxDelay(md/1.0e6);}; 

  Double_t           GetSamplePeriod() { return 1./GetSamplingRate();}; 
  Double_t           GetSamplePeriodMus() { return 1./GetSamplingRateMHz();}; 
  Double_t           GetSymbolPeriod() { return 1./GetSymbolRate();}; 
  Double_t           GetSymbolPeriodMus() { return 1./GetSymbolRateMHz();}; 
  Double_t           GetMaxDelay() const { return fMaxDelay;};
  Double_t           GetMaxDelayMus() { return fMaxDelay*1.0e6;} 
  Double_t           GetExpDecay() const { return fExpDecay;}; 
  Double_t           GetExpDecayMHz() const { return fExpDecay/1.0e6;}; 
  Double_t           GetSymbolRate() const { return fSymbolRate;};
  Double_t           GetSymbolRateMHz() { return GetSymbolRate()/1.0e6;};
  Double_t           GetSamplingRate() { return GetSymbolRate()*fOverSampling;};
  Double_t           GetSamplingRateMHz() { return GetSymbolRateMHz()*fOverSampling;};
  Double_t           GetOverSampling() const { return fOverSampling;};
  Double_t           GetMaxDoppler() const { return fMaxDoppler;};
  Double_t           GetSpeed() { return fMaxDoppler*3.0e8/fCarrierFreq;};
  Double_t           GetSpeedKMH() { return GetSpeed()/1000.*3600.;};
  Double_t           GetCarrierFrequency() const { return fCarrierFreq;};
  Double_t           GetCarrierFrequencyMHz() { return GetCarrierFrequency()/1.0e6;};
  Double_t           GetCarrierFrequencyGHz() { return GetCarrierFrequency()/1.0e9;};
  Int_t              GuessChannelBlockLen(); 
  // Discrete Variables 

  Int_t    GetDiscreteMaxDelay()   {return TMath::Nint(TMath::Max(GetMaxDelay()*GetSamplingRate(),1.));};
  Double_t GetDiscreteExpDecay()   {return GetExpDecay()/GetSamplingRate();};
  Int_t    GetDiscreteMaxDoppler() {return TMath::Nint(TMath::Max(GetMaxDoppler(),1.));};
  Int_t    GetDiscreteScatteringMatrixSize(); 
  

  TDSPMatrix*        GetTransferFunction(); 
  TDSPMatrix*        GetScatteringFunction(); 
  TDSPMatrix*        GetSpreadingFunction();  
  TDSPMatrix*        CreateTransferFunction(TDSPMatrix *out=NULL); 
  TDSPMatrix*        CreateScatteringFunction(TDSPMatrix *out=NULL); 
  TDSPMatrix*        CreateSpreadingFunction(TDSPMatrix *out=NULL); 
  virtual TDSPMatrix*CreateImpulseResponse(TDSPMatrix *out=NULL); 

  Bool_t   fHaveScatteringFunction; 
  Bool_t   fHaveTransferFunction; 
  Bool_t   fHaveSpreadingFunction; 


  

  virtual void        ChangeRepresentation(); 

  

  virtual void        Draw(Option_t *o="");
  virtual void        Print();
  
  ClassDef(TDSPWssus,1)

};

#endif

---