ofdmreceiver.h

Go to the documentation of this file.

/***************************************************************************
                          ofdmreceiver.h  -  description
                             -------------------
    begin                : Mit Mai 22 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef OFDMRECEIVER_HEADER
#define OFDMRECEIVER_HEADER

#include <fstream>
#include <string>
#include <exception>

#include "signals.h"
#include "fft.h"
#include "channel.h"
#include "misc.h"

#include "basicdevice.h"
#include "interfaces.h"
#include "modulator.h"
#include "receiver.h"
#include "transmitter.h"
#include "firfilter.h"
#include "propertylist.h"


namespace simthlib
{

class OfdmReceiver : public Receiver
{

  public:
  
    OfdmReceiver(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl, 
         int oversampling, int carr, double guardTime, double dist,
                 ofdm::FillUpScheme diffScheme);

    OfdmReceiver(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl);

    ~OfdmReceiver() = 0;
                 
    virtual void receiveSignal(const simth::TimeSignal& signalSamples, simth::ModSeq* modSeq,
                               double* noise=NULL, simth::ModSeq* trans = NULL);
    
    virtual void updateInputLengths();

    virtual void updateOutputLengths();

    void setNumPhases(int usedPhases);

    bool needNumPhases() const {return needNumPhases_;}

    void setLinearPhaseCorrection(bool state);

    virtual void startOfSimulation();

    virtual void print(std::ostream &os) const;

    typedef simth::ModSeq::value_type mod_value;
    typedef simth::PhaseSeq::value_type phase_value;

  protected:

    int numCarrier() const {return num_carr;}
    int numGuard() const {return num_guard;}
    int oversampling() const {return oversampling_;}
    int symbolsPerOfdm() const {return num_carr;}
    int samplesPerOfdmSymbol() const {return num_carr * oversampling_ + num_guard;}
    int samplesPerSymbol() const {return oversampling_;}
    double carrierDistance() const {return carr_dist;}
    double oneOverTimeDistance() const;

    bool isLinearPhaseCorrection() const {return isLinearPhaseCorrection_;}

    int numReceivedOfdmSymbols() const {return numReceivedOfdmSymbols_;}

    void linearPhaseCorrection(simth::ModSeq* modulationSymbols) const;


    void initScramblingVector(ofdm::FillUpScheme mode,simth::checkedVector<int>* vec) const;

    void initOfdm2origVector( );

    ofdm::FillUpScheme diffDecodingScheme() const;

    void diffDecodingScheme(ofdm::FillUpScheme newDiffMode);

    std::pair<int, int> getOfdmBlockDimensions(int sequenceLength) const;


    int ofdmIndex2origIndex(int ofdmIndex) const;

    int origIndex2ofdmIndex(int origIndex) const;


    std::pair<int, int> index2position(int ofdmIndex) const;

    int position2index(int timePos, int freqPos) const;


    int getTimePos(int index) const;

    int getCarrierPos(int index) const;

    void subGuard(const simth::Array<mod_value> &inArray, 
          simth::Array<mod_value>* outArray) const;

    void FFT(const simth::Array<mod_value> &inArray, 
         simth::Array<mod_value>* outArray) const;

    void fillOfdmSymbol(const simth::TimeSignal& timeSeq, int currBlockNumber);
    void flushOfdmSymbol(simth::ModSeq* modSymbols, int currBlock) const;

    int computeNumGuardSamples(double guardTime) const;

    virtual void invariante() const;

    virtual int numTimeSamples(int numModSymbols) const;

    virtual int numModSymbols(int numTimeSamples) const;


    virtual void transformSignal(const simth::TimeSignal& signalSamples_ptr,
                 simth::ModSeq* modSeq);

    virtual void channelEstimation(const simth::ModSeq& modSymbols, 
                   simth::ModSeq* transfer) const;

    virtual void noiseEstimation(const simth::ModSeq& modSymbols, 
                 double* noise) const;


    int numPhases( ) const {return numPhases_;}

    void needNumPhases(bool state) {needNumPhases_=state;}


      private:
    // oversampling rate by the IDFT (IFFT) of the received signal:
    const int oversampling_;
    const int num_carr;      // number of subcarriers
    const double carr_dist;  // subcarrier spacing
    const int space;         // sampling space = 1
    const int num_guard;     // length of guard interval

    ofdm::FillUpScheme diffDecodingScheme_;

    //is used to scramble the output symbols to 
    //provide differential
    //decoding for different schemes,
    //e.g. differential decoding in frequency direction
    simth::checkedVector<int> ofdmIndex2origIndex_;
    //the inverse of ofdmIndex2origIndex_:
    simth::checkedVector<int> origIndex2ofdmIndex_;

    int computeIndex(int col,int row) const;


    simth::Array<Complex> ofdmVector;
    FastFourierTrans fft;
  
    int numPhases_;
    bool needNumPhases_;

    bool isLinearPhaseCorrection_;

    double refArg;
    phase_value phaseCorrectionSum;
    int phaseCorrectionCounter;


    /* Returns a complex correction factor for the given carrier index.
    */
    mod_value linearPhaseCorrectionFactor(int carrier) const;

    /*  Computes a linear phase correction for the current filled
        ofdmVector and added this correction to the previous computed
        estimation. This could be useful if the received signal was
        sent over a channel with time delay (e.g. a WssusChannel). The
        receiver does not consider this time delay, therefore the
        symbols sustain a multiplication with a complex factor in the
        frequency domain. This complex factor depends linearly on the
        freqeuncy, i.e. the number of the subcarrier. This function
        computes this factor using the complex symbols filled into
        ofdmVector.
    */
    void traceLinearPhaseCorrection();

    /* For the sake of computational efficiency, store the number of received OFDM symbols.
     */
    int numReceivedOfdmSymbols_;

    
};



inline
ofdm::FillUpScheme OfdmReceiver::diffDecodingScheme() const
{
  return diffDecodingScheme_;
}

inline
void OfdmReceiver::diffDecodingScheme(ofdm::FillUpScheme newDiffMode)
{
  diffDecodingScheme_ = newDiffMode;
  initOfdm2origVector();
}

inline
std::pair<int, int> OfdmReceiver::getOfdmBlockDimensions(int sequenceLength) const
{
  int dim2 = numCarrier();
  if(SECURITY) {
    if(sequenceLength % numCarrier() != 0) {
      throw std::runtime_error("std::pair<int, int> OfdmReceiver::getOfdmBlockDimensions(int sequenceLength) const : error 1");
    }
  }
  int dim1 = sequenceLength/dim2;
  return std::pair<int, int>(dim1,dim2);
}

inline
std::pair<int,int> OfdmReceiver::index2position(int index) const
{
  return ofdm::index2position(index,numCarrier());
}


inline
int OfdmReceiver::position2index(int timePos, int carrierPos) const
{
  return ofdm::position2index(timePos,carrierPos,numCarrier());
}


inline 
int OfdmReceiver::ofdmIndex2origIndex(int ofdmIndex) const
{
#if DEBUG != 0
  if(unsigned(ofdmIndex) >= ofdmIndex2origIndex_.size()) {
    throw std::logic_error("int OfdmReceiver::ofdmIndex2origIndex(int ofdmIndex) const : "
                           "ofdmIndex >= ofdmIndex2origIndex_.size()");
  }
#endif
  return ofdmIndex2origIndex_[ofdmIndex];
}

inline
int OfdmReceiver::origIndex2ofdmIndex(int origIndex) const
{
#if DEBUG != 0
  if(unsigned(origIndex) >= origIndex2ofdmIndex_.size()) {
    throw std::logic_error("int OfdmReceiver::origIndex2ofdmIndex(int origIndex) const : "
                           "origIndex >= origIndex2ofdmIndex_.size()");
  }
#endif
  return origIndex2ofdmIndex_[origIndex];
}


inline
int OfdmReceiver::getTimePos(int index) const
{

  if(DEBUG) {
    if (index<0) {
      throw std::runtime_error("int OfdmReceiver::getTimePos(int index) : error 1");
    }
  }

  return index / numCarrier();

}


inline
int OfdmReceiver::getCarrierPos(int ofdmIndex) const
{

  if(DEBUG) {
    if (ofdmIndex<0) {
      throw std::runtime_error("int OfdmReceiver::getTimePos(int index) : error 1");
    }
  }
  return ofdmIndex % numCarrier();
}



inline void OfdmReceiver::FFT(const simth::Array<mod_value> &inArray, simth::Array<mod_value>* outArray) const
{
  fft.FFT(inArray, outArray, oversampling(), space);
  if(DEBUG) {
    if(int(outArray->size())!=num_carr) {
      throw std::logic_error("inline void OfdmReceiver::FFT(const simth::Array<mod_value> &inArray, simth::Array<mod_value>* outArray) const : error 1");
    }
  }
}


inline void OfdmReceiver::invariante() const
{
  if(DEBUG) {
    if(num_guard > (num_carr * oversampling())) {
      throw std::logic_error("inline void OfdmReceiver::invariante() : error 1");
    }
    if(int(ofdmVector.size()) != num_carr) {
      throw std::logic_error("inline void OfdmReceiver::invariante() : error 3");
    }
  }
}



class OfdmReceiverNoEstimation : public OfdmReceiver
{
  private:

  protected:

  public:

    OfdmReceiverNoEstimation(int deviceID, simth::DeviceSystemIntf* system,
                 const simth::PropertyList& pl, 
                 int oversampling, int carr,
                 double guardTime, double dist,
                 ofdm::FillUpScheme diffScheme);
    OfdmReceiverNoEstimation(int deviceID, simth::DeviceSystemIntf* system,
                 const simth::PropertyList& pl);

    void print(std::ostream &os) const;
};




class OfdmReceiverIdealEstimation : public OfdmReceiver
{
  private:

    //Pointer to channel, is used for ideal channel estimation:
    const Channel* channel;

  protected:

    virtual void channelEstimation(const simth::ModSeq& modSymbols, 
                   simth::ModSeq* transfer) const;

    virtual void noiseEstimation(const simth::ModSeq& modSymbols, double* noise) const;

    void fillTransfer(simth::ModSeq* transfer, int timePos, int modPos) const;

    void estimateTransfer(int timePos,  simth::FreqSignal* transferFactor) const;

  public:

    OfdmReceiverIdealEstimation(int deviceID, simth::DeviceSystemIntf* system,
                const simth::PropertyList& pl, 
                int oversampling, int carr, double guardTime, double dist,
                                ofdm::FillUpScheme diffScheme, const Channel* channelPtr);

    OfdmReceiverIdealEstimation(int deviceID, simth::DeviceSystemIntf* system,
                const simth::PropertyList& pl);

    //void startOfSimulation();

    void print(std::ostream &os) const;
};


inline void OfdmReceiverIdealEstimation::estimateTransfer(int timePos, simth::FreqSignal* transferFactor) const
{
  if(channel == NULL) {
    throw std::runtime_error("void OfdmReceiver::estimateTransfer(int timePos, "
                             "FreqSignal* transferFactor) const : connection to channel is not set");
  }
  if(transferFactor == NULL) {
    throw std::logic_error("void OfdmReceiver::estimateTransfer(int timePos, simth::FreqSignal* "
                           "transferFactor) const : error 2");
  }

  if(int(transferFactor->size()) != numCarrier()) {
    transferFactor->resize(numCarrier());
  }
  if(transferFactor->rAttributes().deltaF() != carrierDistance()) {
    transferFactor->wAttributes().setDeltaF(carrierDistance());
  }
  channel->getTransfer(timePos,*transferFactor);
}



}

#endif

---