ChiSquareReceiver.hh

Go to the documentation of this file.

// $Id

//###################################################################
//
//           Optical Communication Systems Simulator
//
//       Copyright (2004):
//       Optical Fiber Communications Laboratory (OFCL)
//       Computer Science & Electrical Engineering Department (CSEE)
//       University of Maryland Baltimore County (UMBC)
//
//###################################################################

// Written by John Zweck, May 2004

#ifndef _CHI_SQUARE_RECEIVER_HH_
#define _CHI_SQUARE_RECEIVER_HH_

#include <gsl/gsl_errno.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_roots.h>

#include "NoiseCovariance.hh"
#include "ocsOptDemuxer.hh"
#include "ocsPhotodetector.hh"
#include "ocsElecFilter.hh"
#include "ocsHistogram2D.hh"
#include "ocsElecSignalStat.hh"


struct ChiSquareReceiverParameters
{
  double ActiveCurrentValue;
  int CovMatrixDim;
  double * LambdaVec;
  double * LambdaQSqVec;
};


cplx ChiSquareReceiverPsiCplx(cplx s, void * InParameters);
double ChiSquareReceiverPsi(double s, void * InParameters);
double ChiSquareReceiverDerivativePsi(double s, void * InParameters);
double ChiSquareReceiverSecondDerivativePsi(double s, void * InParameters);



enum typeOutput { PDFS = 1, EYE = 2};


enum typeIntegrationMethod { FOURIER_TRANSFORM = 1, STEEPEST_DESCENT = 2};

// For most compliers Fortran77 subroutines like myfun are recognized
// as myfun_ Therefore:

#define F77NAME(x) x##_

extern "C" void F77NAME(dsyev)(char*,char*,int*,double*,int*,double*,double*,
                               int*,int*);
// The last argument is an int which is the length of the
// character array name.

extern "C" int F77NAME(ilaenv)(int*,char*,char*,int*,int*,int*,int*,int);


class ChiSquareReceiver
{

 public:


  ChiSquareReceiver(string InFileName, NoiseCovariance * oNoiseCovariance2);

  ~ChiSquareReceiver(void);


  void ReceiveSignal(string OutFileNamePrefix2);
 
  void ComputeGaussianPDFsAndBER(void);
 
  double GetOSNR_dB(double B_OSA);
  double GetBitErrorRatio(void) {return BitErrorRatio;};
  double GetDecisionThresholdmV(void) 
         {return 1e3*DecisionThreshold/NormalizationFactor;};


  void SetOSNR(double Value);


  void SetElecFilterBandwidth(double ValueHz);


  void SetOptFilterBandwidth(double ValueHz);


  void ReceiveSignalCWNoLossNoDisp(string OutFileNamePrefix2,
                        double P_0, double z, double gamma, double N_ASE, double NF);
 


  double GetNormalizationFactor() {return NormalizationFactor;};
  void SetNormalizationFactor(double Value) {NormalizationFactor = Value;};

private:
  void ReceiveNoiseFreeSignalAndRecoverClock(void);
  void PrepareToComputeKLModes(void);

  void GetReducedNoiseFreeSigAndDiagonalizeCovMatrix(void);
  void ComputeTimeIndependentPartOfFilterMatrix(void);
  
  void ComputeKLModes(int TimeIndex);

  void ComputePDFAtTimeValue(int TimeIndex);
  void ComputePDFAtTimeValueFourierTransform(int TimeIndex);  
  double ComputePDFValueSteepestDescent(int TimeIndex,int CurrentIndex);
  double EvaluateGaussianApproximation(double SaddlePoint);

  void WriteFilePDFs(void);


  void WriteFileEye(void);


  void ComputeAveragePDFs(void);

  
  void ComputeMinimumBERAndDecisionThreshold(void);


  void ComputeMomentsInEachBit(void);


  void ComputeEye(void);


  void SymmetricEig(double ** Matrix, double * EigValue,
                    double ** EigVector,int Dim);


  void PrepareSymmetricEig(void);


  bool TestEigDecomposition(double ** Matrix, double * EigValue,
                            double ** EigVector,int Dim);


  inline double ReducedFrequency(int k) 
                {return (CovMatrixFirstIndex + k)*DeltaFreq;};

  void WriteFileSquareMatrix(double **A, int dim, string OutFileName, 
                             double NormalizationFactor);

  void WriteFileVector(double *V, int dim, string OutFileName, 
                   double NormalizationFactor);

  void WriteFilePairVectors(double * x, double *y, 
                            int dim,string OutFileName, 
                            double xNormalizationFactor, 
                            double yNormalizationFactor);

  void WriteFileComplexMatrix(cplx **A, int dim,
                              string RealOutFileName, 
                              string ImagOutFileName, 
                              double NormalizationFactor);


  void WriteFilePDFTimeSlices(string OutFileName);

  void WriteFileGSLFunction(double CurrentValue,double s_min,double s_max,
                            int NumPts,string OutFileName);

  void InitializeGSL_FunctionToDerivativePsi(void);
  double FindRootInterval(double &LowerBound,double &UpperBound);


 private:

  string Job;
  string OutFileNamePrefix;

  typeIntegrationMethod TypeIntegrationMethod;


  bool ReadInSignalAndCovMatrixFlag;

 

  string SignalAndCovMatrixDir;


  string SignalAndCovMatrixJob;


  double SetOSNRdB;


  double B_OSA;


  int DebugLevel;

  int DemuxChannArrayIndex;
  NoiseCovariance * oNoiseCovariance;  
  OptSignal * Signal;
  
  fftMatrices ReceiverReducedNoiseFreeSignal;
  double * ReducedNoiseFreeSignalRealVector;

  RanNumGen * RNG;

  OptSignal * DemuxedNoiseFreeSignal;
  OptFilter * TunableOptFilterForNoiseFreeSignal;
  OptDemuxer * OptDemuxerForNoiseFreeSignal;
  Photodetector * PhotodetectorForNoiseFreeSignal;
  ElecFilter * ElecFilterForNoiseFreeSignal;
  ElecSignalStat * ElecSignalStatForNoiseFreeSignal;

  OptSignal * OptFilterTransferFunction;
  Photodetector * ElecFilterTransferFunction;

  OptFilter * TunableOptFilterForTransferFunction;
  ElecFilter * ElecFilterForTransferFunction;

  double DeltaFreq; // equals ReducedDeltaFreq
  double TimeWindow; // equals ReducedTimeWindow
  double ReducedDeltaTime;
  double ReducedFreqWindow;


  double **CovarianceMatrix;

  typeOutput TypeOutput;


  int NumBitsToPlot;
  

  int NumBitsBetweenSlices;


  int NumSlicesPerBit;


  double TimeBetweenSlices;



  bool ReadInClockRecoveryTimeFlag;


  double ClockRecoveryTime;


  double ClockRecoveryCurrent;

  int NumTimeSlices;


  double * TimeSlices;


  double MinCurrent;
 

  double MaxCurrent;


  int NumPointsCurrent;

  double DeltaCurrent;


  double * CurrentVector;


  double * ActiveCurrentValuePtr;

  int CovMatrixDim;
  
  int CovMatrixFirstIndex;
  int CovMatrixLastIndex;

  double NormalizationFactor;

  double LowerPole;
  double UpperPole;

  double DecisionThreshold;
  double BitErrorRatio;

  int LengthSymmetricEigWork;

  double * SymmetricEigWork;


  double * CovarianceEvalues;

  
  double ** CovarianceEvectors;


  double * CovarianceEvectorsStorageVec;
  

  cplx ** FilterMatrixTimeIndependent;


  cplx * FilterMatrixTimeIndependentStorageVec;


  double ** FilterMatrix;


  double * FilterMatrixStorageVec;


  double ** HMatrix;


  double * HMatrixStorageVec;


  double ** VMatrix;


  double * VMatrixStorageVec;


  double ** WorkMatrix;


  double * WorkMatrixStorageVec;


  double ** TestEigMatrix;


  double * TestEigMatrixStorageVec;



  double * LambdaVec;

  
  double * LambdaQSqVec;


  double * WorkVec;

  gsl_function * GSL_Function;
  int RootFinderMaxIterations;

  double MinNegLambda;

  struct ChiSquareReceiverParameters * Parameters;

  // PDFTimeSlices[tt][vv], so tt-th row of PDFTimeSlices is the pdfs of
  // the tt-th TimeSlice. We write out its transpose though

  double ** PDFTimeSlices;
 

  double * PDFTimeSlicesStorageVec;


  double * AveragePDFZeros;


  double * AveragePDFOnes;


  double * PowerInSlice;


  int * BitString;


  double ** EyeMatrix;


  double * EyeMatrixStorageVec;


  double * BER;

  double * MomentsIntegrand;

  double * MeanCurrent;

  double * StandardDeviationCurrent;

};

#endif