ocsElecFilter.hh

Go to the documentation of this file.

// $Id: ocsElecFilter.hh,v 1.2 2005/07/06 16:27:46 zweck Exp $

//###################################################################
//
//           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_FILTER_HH_
#define  _OCS_ELEC_FILTER_HH_

#include "ocsOptSignal.hh"
#include "ocsPhotodetector.hh"



enum typeElecFilter { NO_ELEC_FILTER = 0, 
                      GAUSSIAN = 1, 
                      BESSEL = 2,
                      MEASURED = 3,
                      INTEGRATE_AND_DUMP = 4,
                      ANRITSU = 5,
                      GAUSSIAN_AND_ANRITSU = 6}; 

// ##### Input parameter to initialize Electrical Filters
struct ElecFilterParam
{
   int TypeElecFilter;
   int OrderElecFilter;
   double FreqFWHM_ElecFilter;
   double CenterFreqElecFilter;
};

// ##### Class Electrical filter

class ElecFilter
{
   public:
      ElecFilter();
      void InitElecFilter(cfftw *fft2
                      ,fftPowerMatrices sfftPM2
                      , ElecFilterParam ElecFilter);

      ElecFilter(string InFileName, Photodetector *oPhotodetector2);

      ElecFilter(ElecFilter *oElecFilter2, Photodetector *oPhotodetector2);


      ElecFilter(string InFileName, Photodetector *oPhotodetector2,
                 cplx * MeasuredFilterFreq2,bool ReadMeasuredFilterFlag);


      ElecFilter(string InFileName, cfftw *fft2,fftPowerMatrices sfftPM2);
  
      void FilterElecSignal(void);
 
      void SetPhotodetector(Photodetector *oPhotodetector2);

         // add by Jonathan Hu
          string GetAnritsuFilterFileName(void)
            {return AnritsuFilterFileName;};
                        
      typeElecFilter GetTypeElecFilter(void)
            {return TypeElecFilter;};

      int GetOrderElecFilter(void)
            {return OrderElecFilter;};

      double GetCenterFreqElecFilter(void)
            {return CenterFreqElecFilter;};                         

      double GetFreqFWHM_ElecFilter(void)
            {return FreqFWHM_ElecFilter;};
      cplx GetMeasuredFilterFreq(int ii) 
            {return MeasuredFilterFreq[ii];};
      void SetFreqFWHM_ElecFilter(double FreqFWHM_ElecFilter2);
      
      void Set_f_3dB_ElecFilter(double f_3dB_ElecFilter2);
      
      double Get_f_3dB_ElecFilter(void)
            {return FreqFWHM_ElecFilter/2.;};

      void WriteFreqPowerGaussianFilter(string OutFileName);
      
      //writes to file the impulse response of the filter
      //that is the output signal when the input signal is an impulse
      //at the center of the time window
      void WriteTimePowerFilter(string OutFileName);
      // writes to file the frequency response of the filter
      void WriteFreqPowerFilter(string OutFileName);

      double ComputeMatchAndFilter(void);

      
     void GetClockRecoveryTime(BitString *oBitString); // By Wei Wang
     void WriteFreqCplxFilter(string OutFileName);

     double GetCurrentEquivalentSpectralWidth(void);
     void WriteFilterImpulseResponse(string FileNameImpulseResponseTime,
                                     string FileNameImpulseResponseFreq);

  int GetDebugLevel(void) {return DebugLevel;};

  // ######## PUBLIC DATA ##################


   double * AverageCurrentInBit;

  // ########## PRIVATE METHODS ##################
   
   private:

     void ElectricalFilterB5(cplx *my_power_time,cfftw *fft, 
                             double omega_0, double fwhm_norm);
     void ElectricalFilterB4(cplx *my_power_time,cfftw *fft, 
                             double omega_0, double fwhm_norm);
     void ElectricalFilterGaussian(cplx *my_power_time, 
                                   cfftw *fft, double omega_0, 
                                   double fwhm_norm);

     
     void IntegrateAndDumpFilter(cplx *my_power_time,cfftw *fft);


     void ElectricalFilterMeasured(void);

 
     void ReadMeasuredFilterData(void);

     void ReadMeasuredFilterData(cplx *MeasuredFilterFreq2);

   // the following function is writen by Jonathan Hu
         double GetPhase(double Frequency);
         void ReadElecPhase(string InFileName);
         void ReadElecPhasePaola(string InFileName);
        
         double GetElecGain(double Frequency);
         void ReadElecGain(string InFileName);

         double * xElecGain;
         double * yElecGain;
         double * y2ElecGain;
         double ElecGainStartFreq;
         double ElecGainStepFreq;
         int NumElecGainWidth;

         string AnritsuFilterFileName;

         double * xElecPhase;
         double * yElecPhase;
         double * y2ElecPhase;
        double ElecPhaseStartFreq;
        double ElecPhaseStepFreq;
        int NumElecPhaseWidth;
        int RunAnritsuFilter;
        void AnritsuFilter(cplx *my_power_time, cfftw *fft, double omega_0, 
                double fwhm_norm);
        void AnritsuFilterPaola(cplx *my_power_time, cfftw *fft, 
                double omega_0, 
                double fwhm_norm);
        double GainPeak;
        double FreqGain3dB;
        
        double splint( double *xa,  double *ya,  double *y2a, int n, double x);
        void spline(double *x,  double *y,  int n, double yp1, double ypn,  double *y2);
        double GaussianSmooth(double *y, int Order, int N );

        // up to here (JH)
        


     void IntegrateAndDumpFilter_OLD(void);
 
     void AllocateMemoryForAverageCurrentinBit(void);

     double GetAverageCurrentInTimeRange(double LeftTime, 
                                         double RightTime);
//       int GetBitWeightCenter(int index);


     cplx Bessel5(double omega, double omega_0, double FWHM);
     cplx Bessel4(double omega, double omega_0, double FWHM);
     double Gaussian(double omega, double omega_0, double FWHM);


    cplx IntegrateAndDump(double freq); 


     void Time2Freq(void);
 

    void Freq2Time(void);

   // ########## PRIVATE DATA ##################
  
      fftPowerMatrices sfftPM;
      cfftw *fft;   
      int ObjectInitialized;                  
      int qtPoints;

      double DeltaFreq, DeltaTime,FreqWindow, TimeWindow, BitLength; 
      double ClockRecoveryTimeForIntegrateAndDump;
      int StringLength;



      typeElecFilter TypeElecFilter;
      int OrderElecFilter;
      double FreqFWHM_ElecFilter; 

      // FreqFWHM_ElecFilter is the FWHM of the power of the filter
      // in the frequency domain. (JZ)

      double CenterFreqElecFilter;  


      string MeasuredElecFilterFileName;


      cplx * MeasuredFilterFreq;
      Photodetector *oPhotodetector;

      int DebugLevel;

   
};

#endif /*  _OCS_ELEC_FILTER_HH_ */