TDSPNofdm.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 TDSPNOFDM_H
#define TDSPNOFDM_H


#include <TH1F.h>
#include <TDSPSignal.h>
#include <TDSPBlockMap.h>

class TDSPNofdm : public TDSPBlockMap  {
  
 private:

  // Some more signal-processing typical 
  // slot-names (implemented as Delegation to the
  // original slots)

  TString Delegation_Transmit;
  TString Delegation_Receive;

  TString Delegation_Transmitted;
  TString Delegation_Received;

  TString& _build_pulse_param_string(TString& start);

 protected:
  

  Int_t    fMode; // Mode BFDM/CORR etc.
  Bool_t   fDual; // Use Dual system ?
  Bool_t   fTight; // Make system tight ?
  UInt_t   fOptions; // Some Options
  Int_t    fNumCarriers; // Number of Carriers / or equivalents
  Int_t    fNumTime; // Number of Time-steps / or equivalents

  Int_t    fTimePad; 
  Int_t    fFreqPad; 
  Int_t    fLength;  

  TString  fPulseName; // The Name of pulse
  Int_t    fPulseNumParams; // Number of Parameters to put into the pulse
  Double_t fPulseParams[4]; // The Pulse-Parameters
  TString  fPulseFile; // The Name of the last used pulse file

  TDSPMatrix *fMapping; 
  TDSPMatrix *fMappingPart1; 
  TDSPMatrix *fCorrelation; // the input<->output correlation
  TDSPMatrix *fNoiseCorrelation; // the input<->output correlation for Noise between transmitter and receiver
  TDSPMatrix *fTransmitMatrix; // The Transmit Filter
  TDSPMatrix *fReceiverMatrix; // The Receiver Filter
  TDSPMatrix *fChannel; // A Channel Model 
  
  TDSPMatrix *f_PseudoInverseMatrix; // if the class allocs itself the pseudo-inv. matrix we need a copy of the pointer
  void _free_mode(Int_t);  // Clean up a mode
  void _new_mode(Int_t);   // Set a new mode

  // Some flags

  Bool_t _recalc_correlations;
  Bool_t _recalc_mapping;

  // Some Helper Functions

  void   _calc_correlations();
  void   _calc_mapping();

 public: 
  
  TH1F   *fHistogram_all;
  TH1F   *fHistogram_diag;
  TH1F   *fHistogram_nondiag;

  TH1F   *fHistogram_corr_all;
  TH1F   *fHistogram_corr_diag;
  TH1F   *fHistogram_corr_nondiag;

  // Constructor / Destructor
  //
  TDSPNofdm(char *name = NULL);
  virtual ~TDSPNofdm();  

  // Set/Get Parameters
  //
  Int_t GetNumCarriers() const { return fNumCarriers; };
  void  SetNumCarriers(Int_t n) { Error("SetNumCarriers","Not yet implemented!"); };
  Int_t GetLength() const { return fLength;};
  void  SetLength(Int_t l) { fLength = l;};
  Int_t GetTimePad() const { return fTimePad;};
  void  SetTimePad(Int_t t) { fTimePad = t;fNumTime=fLength/fTimePad;};
  Int_t GetFreqPad() const { return fFreqPad;};
  void  SetFreqPad(Int_t t) { fFreqPad = t;fNumCarriers=fLength/fFreqPad;};
  void  SetPads(Int_t time, Int_t freq) { SetTimePad(time);SetFreqPad(freq);};

  void  SetTransmitMatrix(TDSPMatrix *h);
  void  SetReceiverMatrix(TDSPMatrix *h);

  TDSPVector* GetTransmitPulse(TDSPVector *p=NULL);
  TDSPVector* GetReceiverPulse(TDSPVector *p=NULL);

  TDSPMatrix* GetTransmitMatrix() const { return fTransmitMatrix;};
  TDSPMatrix* GetReceiverMatrix() const { return fReceiverMatrix;};

  void  SetPulseName(TString n) { fPulseName = n;};
  void  SetPulseParam(Int_t num, Double_t v);
  Double_t GetPulseParam(Int_t num);
  char* GetPulseFile() { return (char*)fPulseFile.Data();};

  virtual void  Print();
  virtual void  Draw();

  void  SetChannel(TDSPMatrix*);
  TDSPMatrix*  GetChannel() const { return fChannel;};
  void  SetMode(Int_t mode);
  
  // Setting Options
  //
  // opt = "bfdm"  / "corr" 
  //     = "tight" / "nontight"
  //     = "dual"  / "nondual"
  //     = "analysecorr"
  //     = "analysemapping"
  //     = "debugcorrelation"
  //     = "showpulse" / "noshowpulse"
  //     = "wilson" - Multiplying Wilson-Phases on Gamma and GStar

  void  SetOption(Option_t *opt);
  TDSPMatrix*  GetMapping() { if (_recalc_mapping) _calc_mapping();return fMapping;};
  TDSPMatrix*  GetMappingPart1() { if (_recalc_mapping) _calc_mapping();return fMappingPart1;};
  TDSPMatrix*  GetCorrelation() { if (_recalc_correlations) _calc_correlations();return fCorrelation;};
  TDSPMatrix*  GetNoiseCorrelation() { if (_recalc_correlations) _calc_correlations(); return fNoiseCorrelation;};

  TDSPSignal* GetTransmitSignal() { return GetSignal(); };
  TDSPSignal* GetReceivedSignal() { return GetInverseSignal(); };
  Double_t    GetBandWidthEfficiency() { return Double_t(fNumCarriers*fNumTime)/Double_t(fLength); };

  void  CreatePulses();
  void  LoadPulses(char *fname, char *transmitname="TransmitMatrix", char *receivername="ReceiverMatrix");
  void  SavePulses(char *fname, char *transmitname="TransmitMatrix", char *receivername="ReceiverMatrix");

  void  CalcMappingFromChannel(TDSPMatrix* channel); 
  void  CalcCorrelationFromChannel(TDSPMatrix* channel); 
  void  Correlation(TDSPMatrix*c);  
  void  Mapping(TDSPMatrix*c);  
  void  MappingPart1(TDSPMatrix*c);  

  ClassDef(TDSPNofdm,1)

};
#endif

---