ocsElecSignalStat.hh

Go to the documentation of this file.

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

#ifndef _OCS_ELEC_SIGNAL_STAT_HH_
#define _OCS_ELEC_SIGNAL_STAT_HH_

#include "ocsBitString.hh"
#include "ocsOptSignal.hh"
#include "ocsPhotodetector.hh"
#include "ocsOptFilter.hh"
#include "ocsElecFilter.hh"
#include "ocsTools.hh"


enum typeClockRecovery { USER_SET = 0,
                         FREQ_DOUBLING = 1,
                         RZ_SIGNAL_FREQ = 2,
                         NRZ_HALF_SIGNAL_FREQ = 3, 
                         BEST_Q_FACTOR = 4,
                         DIFFERENTIATE_SIGNAL = 5,
                         CONTINUOUS_EXOR = 6,
                         BINARY_EXOR = 7,
                         BEST_MIN_EYE_OPENING = 8 };



class ElecSignalStat
{
   public: 


      ElecSignalStat(OptSignal * oOptSignal2, 
                     Photodetector *oPhotodetector2);



      ElecSignalStat(string InFileName,OptSignal *oOptSignal2,
                     Photodetector *oPhotodetector2);

      ~ElecSignalStat(void);

  
      void SetUseAbsCurrentFlag(bool Value);
 

      string WriteTypeClockRecovery(void);


      void ClearElecSignalStat(void);

  void ClearGaussianPDFsMonteCarlo(void); // Added by Hua on Jan. 24, 2006


      void ComputePerformanceStatistics(void);


      void UpdatePerformanceStatistics(void);

    
  void ComputeEqualizedPerformanceStatistics(void);   
 

  void  UpdateEqualizedPerformanceStatistics(void);
  
  cplx *GetSignalTimeDomain(void) {return sfftPM.tPowerSignal;};
   
  int GetBitFromString(int ii){return oOptSignal->oBitString->GetBit(0,ii);};


   double GetMinAmplitudeMargin();      
      

      void WriteFileEyeDiagram(string outFile);  
 

     void WriteFileEyeDiagramFixedCLK(string outFile);  
      

      double GetClockRecoveryTime(void)
            {return ClockRecoveryTime=GetTargetTime();};


      double GetClockRecoveryTimeBeforeTimeShift(void)
           { return ClockRecoveryTimeBeforeTimeShift;};


      double GetClockTimeForMonteCarloEye(void);

      double GetClockCurrent(void);


  void OutputGaussianStatisticsFromMonteCarlo(string FileID);
  void SetTimeSlices(void);
  void ComputeAndOutputMomentsFromMonteCarlo(string FileID);
  void ComputeAveragePDFs(void);
  void WriteFilePDFTimeSlicesAndAveragePDFs(string FileID);
  void ComputeMinimumBERAndDecisionThreshold(string FileID);
  void WriteFilePairVectors(double * x, double *y, int dim, 
                                          string OutFileName);


  double GetPowerMeanBit(int BitIndex);
         

 

  double GetPowerStdDevBit(int BitIndex);
        


     double GetQtBit0(void) {return qtBit0;};


     double GetQtBit1(void) {return qtBit1;};


     double GetBit0_PowerMax(void) {return Bit0_PowerMax;};



     double GetBit1_PowerMin(void) {return Bit1_PowerMin;};
      

      double GetBit0_PowerMean(void) 
         {return Bit0_PowerSum/qtBit0;}; 


      double GetBit1_PowerMean(void) 
         {return Bit1_PowerSum/qtBit1;}; 


      double GetBit0_PowerStdDev(void)
         {return sqrt( (Bit0_PowerSquareSum
                      -qtBit0*sq(GetBit0_PowerMean()))
                      /(qtBit0 - 1.) );};



      double GetBit1_PowerStdDev(void)
         {return sqrt( (Bit1_PowerSquareSum
                      -qtBit1*sq(GetBit1_PowerMean()))
                      /(qtBit1 - 1.) );};

      double GetElecTimeDomainSNR(void) 
         {return (GetBit1_PowerMean() - GetBit0_PowerMean() )
                 /GetBit0_PowerMean();};


  double GetQ_Factor(void);
                

  double GetBitErrorRate(void) {return 
                exp(-sq(GetQ_Factor())/2)/(GetQ_Factor()*sqrt(2*pi));};


  double GetBitErrorRate(double Q_Factor) {return 
                exp(-sq(Q_Factor)/2)/(Q_Factor*sqrt(2*pi));};

  double GetAmplitudeMargin(void) {return AmplitudeMargin;};
    
  double GetMeanPower(void) {return MeanPower;};
            
  int GetBitStringShift(void) {return BitStringShift;};



      double GetQtIsolatedBit0(void) {return qtIsolatedBit0;};
      double GetQtIsolatedBit1(void) {return qtIsolatedBit1;};
      double GetIsolatedBit0_PowerMax(void) {return IsolatedBit0_PowerMax;};
      double GetIsolatedBit1_PowerMin(void) {return IsolatedBit1_PowerMin;};

      double GetIsolatedBit0_PowerMean(void) 
         {return IsolatedBit0_PowerSum/qtIsolatedBit0;}; 

      double GetIsolatedBit1_PowerMean(void) 
         {return IsolatedBit1_PowerSum/qtIsolatedBit1;}; 

      double GetIsolatedBit0_PowerStdDev(void)
         {return sqrt( (IsolatedBit0_PowerSquareSum
                      -qtIsolatedBit0*sq(GetIsolatedBit0_PowerMean()))
                      /(qtIsolatedBit0 - 1.) );};

      double GetIsolatedBit1_PowerStdDev(void)
         {return sqrt( (IsolatedBit1_PowerSquareSum
                      -qtIsolatedBit1*sq(GetIsolatedBit1_PowerMean()))
                      /(qtIsolatedBit1 - 1.) );};

      double GetElecTimeDomainSNR_IsolatedBits(void) 
         {return (GetIsolatedBit1_PowerMean() - GetIsolatedBit0_PowerMean() )
                 /GetIsolatedBit0_PowerMean();};

      double GetQ_FactorFromIsolatedBits(void); 
             
                                           


void SetOptElecFiltersForGaussianStatistics(
        OptFilter *oOptFilter,ElecFilter *oElecFilter);


 void ResetOptElecFiltersForGaussianStatistics(void);


void ResetOptElecFilterBandwidthsForGaussianStatistics(
                           double FreqFWHM_OptFilter2, 
                           double f3dB_ElecFilter2);

void CheckGaussianStatisticsInitialization(string CallingMethod);



double GetMeanNoiseGaussianStatistics(double TotalNoiseSpectralDensity);


  double GetNoiseNoiseVarianceGaussianStatistics(
                 double TotalNoiseSpectralDensity,
                 double DOP_Noise);


 double GetIntegralForNoiseNoiseVarianceGaussianStatistics(void);



 double GetSignalNoiseVarianceForUnpolarizedNoiseGaussianStatistics(
          double Time,
          double TotalNoiseSpectralDensity);


 double GetSignalNoiseVarianceForPolarizedSignalGaussianStatistics(
          double Time,
          double * UnitStokesSignal,
          double * UnitStokesNoise,
          double TotalNoiseSpectralDensity,
          double DOP_Noise);


 double GetIntegralForSignalNoiseVariance(OptSignal *OptSignalA,
                                          OptSignal *OptSignalB, 
                                          double TimeShiftA, double TimeShiftB, double Time);


      double GetEnhancementFactor(double OSA_NoiseBandwidth);
      double GetNormalizedEnhancementFactor(void);
       
      double GetESNR_Mark_GaussianStatistics(double NoiseSpectralDensity);
      
      double GetESNR_GaussianStatistics(double NoiseSpectralDensity);
      double GetNormKcoeff1_GaussianStatistics(void);
      double GetNormKcoeff0_GaussianStatistics(void);      
      double GetNormNumberNoiseModes_GaussianStatistics(void);
      double GetCurrentExtinctionRatio_GaussianStatistics(void);
      double GetQ_FactorFromESNR_GaussianStatistics( double ESNR);
      double GetQ_FactorFromESNR_GaussianStatistics( double ESNR,
                       double NoiseSpectralDensityX,
                       double NoiseSpectralDensityY);


      double GetQ_FactorGaussianStatisticsWorstPattern(
                        double NoiseSpectralDensity);
      double GetQ_FactorGaussianStatisticsWorstPattern(
                   double NoiseSpectralDensityX,double NoiseSpectralDensityY);

      double GetQ_FactorGaussianStatisticsFirstPattern(
                 double NoiseSpectralDensityX,double NoiseSpectralDensityY);

      double GetQ_FactorGaussianStatisticsFromBER(double NoiseSpectralDensity);
      double GetQ_FactorGaussianStatisticsFromBER(double NoiseSpectralDensityX,
                                              double NoiseSpectralDensityY);
          
      double GetBER_GaussianStatisticsFromDecisionThreshold(
                                 double DecisionCurrent);
      double GetBER_GaussianStatistics(void);
      double MinimizeSqQ_FactorVersusBER(double Q_FactorTmp);
  
      double brentHu(double ax, double bx, double cx, double (*f)(double), 
                     double tol,double *xmin);

      double testsq(double ax);

          
      double GetMeanASE_ASE(double NoiseSpectralDensity);
      double GetMeanASE_ASE(double NoiseSpectralDensityX,
                            double NoiseSpectralDensityY);

      double GetStdDevASE_ASE(double NoiseSpectralDensity);           
      double GetStdDevASE_ASE(double NoiseSpectralDensityX,
                              double NoiseSpectralDensityY);
                                
      double GetStdDevSignal_ASE_BitSlot(int BitSlot,
                                     double NoiseSpectralDensity);
      double GetStdDevSignal_ASE_BitSlot(int BitSlot,        
                                     double NoiseSpectralDensityX,
                                     double NoiseSpectralDensityY);
      double GetStdDevSignal_ASE_TimeIndex(int TargetIndexTime2,
                                 double NoiseSpectralDensityX,
                                 double NoiseSpectralDensityY);
                                 
    
      double GetStdDevWorstBit1_GaussianStatistics(double NoiseSpectralDensity);
      double GetStdDevWorstBit1_GaussianStatistics(
                             double NoiseSpectralDensityX,
                             double NoiseSpectralDensityY);

      double GetStdDevWorstBit0_GaussianStatistics(double NoiseSpectralDensity);
      double GetStdDevWorstBit0_GaussianStatistics(
                             double NoiseSpectralDensityX,
                             double NoiseSpectralDensityY);

      double GetMinCurrentBit1(void);
      double GetMaxCurrentBit0(void);                        

      double GetMinCurrentBit1(int *BitSlotMinCurrentBit1);
      double GetMaxCurrentBit0(int *BitSlotMaxCurrentBit0);
      

      double GetCurrentFirstBit1(int *BitSlotCurrentFirstBit1);
      double GetCurrentFirstBit0(int *BitSlotCurrentFirstBit0);     

      double GetCurrentBitFromRecoveredSignal(int BitSlotCurrentBit);      
      double GetCurrentBit(int BitSlotCurrentBit);    
      
                                  
      double GetMeanCurrentIsolatedBit1(void);
      double GetMeanCurrentIsolatedBit0(void);

 int GetQtPoints(void) {return qtPoints;};
 double GetDeltaTime(void) {return DeltaTime;};
 int GetBit(int BitSlot) {return oOptSignal->oBitString->GetBit(0,BitSlot);}; 
 double GetBitLength(void) {return BitLength;};
 int GetStringLength(void) {return StringLength;};

                
  // ###### METHODS FOR COMPUTING PATTERN STATS #####################

  // ######## Written by John Zweck, June 23rd 2002 #################


  void InitPatternStats(void);


  void AllocateMemoryForPatternStats(void);


  void ReleaseMemoryForPatternStats(void);


  void ClearPatternStats(void);


  void EnumeratePatterns(ofstream * OutFile);



  bool GetPattern(int PatternIndex,int BitIndex);


  bool GetCenterBitPattern(int PatternIndex);


  int GetPatternIndex(bool * LocalPatternArray, int LengthOfPattern);


  void UpdatePatternStats(int BitIndex,double PowerElecSignal);



  bool PatternEquality(bool * PatternArray1, bool * PatternArray2, 
                       int LengthOfPattern);



  void PreparePatternStatsForOutput(void);


  void WriteFilePatternStats(string OutFileName);

  // ## PUBLIC DATA

   OptSignal *oOptSignal;
   Photodetector *oPhotodetector;
   double *BitIntensity; 


  //########## PRIVATE  #############################

 private:

  // ## PRIVATE METHODS 

 void InitElecSignalStat(OptSignal * oOptSignal2, 
                     Photodetector *oPhotodetector2);
      


  void ComputePerformanceStatisticsNoTimeShift(void);


 void UpdateMoments(int BitIndex,double PowerElecSignal);

 void ComputeTargetFreqIndex(void);


 int GetTargetIndexTime(void);



 double GetTargetTime(void);

 double ComputePhaseTargetFreq(void);
 int GetTargetIndexTimeBestQ_Factor(void);
  int GetTargetIndexTimeBestMinEyeOpening(void);

 void UpdateClock(void);

  //## PRIVATE DATA 

 int ObjectInitialized;
 bool UseAbsCurrentFlag;

 cfftw *fft;
 fftPowerMatrices sfftPM;   
 typePulse TypePulse;
 int qtPoints;
 int qtPointsLast;        
 double  DeltaTime, TimeWindow;
 double DeltaFreq;
 int StringLength;
 double BitLength;                    
 double BitRateChann;

 typeClockRecovery TypeClockRecovery;

 int UseSmoothingToRecoverClockFlag;
 double GaussianSmoothingFWHM;

 int BitStringShift; 
  
 double InputClockRecoveryTime;
 double ClockRecoveryTime;
 double ClockRecoveryTimeBeforeTimeShift;

 int TargetFreqIndex;
 int FirstTargetIndexTime;
 int SumRelTargetIndexTime;

 int NumCallsToUpdateClock; // For UpdateClock()
 double SumTargetIndexTimesForUpdateClock;
           
 int qtRunsEyeDiagram;
 int qtRunsEyeDiagramFixedCLK;
      
 double Q_Factor;
 double BitErrorRate;      
 double AmplitudeMargin;
 double MeanPower;      
 
 int qtBit0, qtBit1;      
 double Bit0_PowerSum,Bit1_PowerSum;
 double Bit0_PowerSquareSum, Bit1_PowerSquareSum; 
 double Bit0_PowerMax, Bit1_PowerMin;

 int qtIsolatedBit0, qtIsolatedBit1;      
 double IsolatedBit0_PowerSum,IsolatedBit1_PowerSum;
 double IsolatedBit0_PowerSquareSum, IsolatedBit1_PowerSquareSum; 
 double IsolatedBit0_PowerMax, IsolatedBit1_PowerMin;

 // Variables for the semi-analytical method

 bool InitializedGaussianStatisticsFlag;
 double *VariancesCurrentSignalNoiseBeating; 
      
 OptSignal *oOptSignal1; 
 OptSignal *oOptSignal2; 
 OptSignal *oOptSignal3;
 OptSignal *oOptSignalX;

 OptFilter *oOrigOptFilter;
 OptFilter *oOptFilter2;
 Photodetector *oPhotodetector2;
 ElecFilter *oElecFilter2;

 ElecSignalStat *oElecSignalStat2; 
        
 // add by Jonathan Hu
      
 OptSignal *oOptSignal4;
 OptFilter *oOptFilter4;
 Photodetector *oPhotodetector4;
 ElecFilter *oElecFilter4;
 ElecSignalStat *oElecSignalStat4;  
 double BER_GaussianStatistics;
 double Q_FactorPre;
 double NoiseSpectralDensityX_PD;
 double NoiseSpectralDensityY_PD;

  // Variables for DoGaussianPDFsMonteCarlo

  bool DoGaussianPDFsMonteCarloFlag;
  int NumTimeSlices;
  double * TimeSlices;
  int * TimeSliceIndices;
  int * BitString;

  double * StdDevCurrentMonteCarlo;
  double * MeanCurrentMonteCarlo;

  double * PowerSumBit;
  double * PowerSquareSumBit;
  int * qtBit;

  double  MinCurrent,MaxCurrent,DeltaCurrent;
  int NumPointsCurrent;
  double * CurrentVector;

  double * BERGaussianPDFs;
  double * AverageGaussianPDFZeros;
  double * AverageGaussianPDFOnes;
  double ** GaussianPDFTimeSlices;
  double * GaussianPDFTimeSlicesStorageVec;


           // ####### VARIABLES FOR PATTERN STATS ###################


  bool ComputePatternStatsFlag;


  int PatternLength;


  int NumPatterns;


  bool * PatternArray;



  double * MeanPattern;


  double * StdDevPattern;


  int * NumOccurencesPattern;


  double * VoltageSumPattern;      



  double * VoltageSumSquaresPattern;      

 
  double * MaximumVoltagePattern;

 
  double * MinimumVoltagePattern;
       
};

#endif /*  _OCS_ELEC_SIGNAL_STAT_HH_ */