ocsOptSignal.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_OPT_SIGNAL_HH_
#define _OCS_OPT_SIGNAL_HH_

#ifndef _OCS_SYSTEM_HDRS_
#define _OCS_SYSTEM_HDRS_

#include <iostream.h>
#include <string.h>
#include <math.h> 
#include <fstream.h>
#include <complex.h>
#include <stdlib.h>
#include <stdio.h>
#include <strstream>

#include <string>
  using namespace std;


#endif /* _OCS_SYSTEM_HDRS_ */

#include "ocsConst.hh"
#include "ocsTools.hh"
#include "ocsReadWriteTools.hh"
#include "ocsRanNumGen.hh"

#include "ModulationFormats.hh"
#include "ocsReduOptSignal.hh"


#ifndef _OCS_TYPE_SOLVER_
#define _OCS_TYPE_SOLVER_

enum typeSolver { SCALAR_NLS = 1, VECTOR_MANAKOV_PMD = 2, 
                  VECTOR_MANAKOV_NO_PMD = 3 };

#endif /* _OCS_TYPE_SOLVER_ */

#ifndef _OCS_FFT_MATRICES_
#define _OCS_FFT_MATRICES_


struct fftMatrices 
{
      cplx* tOptSignalX;    
      cplx* fOptSignalX;
      cplx* tOptSignalY;    
      cplx* fOptSignalY;      
};



struct OptFiberLocalErrorWorkSpace
{
 fftMatrices sfftM_Start;
 fftMatrices sfftM_Coarse;
 cplx * LaserWorkX;
 cplx * LaserWorkY;
 cplx * FreqDomainOperatorX;
 cplx * FreqDomainOperatorY;
 cplx * SqFreqDomainOperatorX;
 cplx * SqFreqDomainOperatorY;
 
};


#endif /* _OCS_FFT_MATRICES_ */

#ifndef _PHOSSIL_FFT_POWER_MATRICES_
#define _PHOSSIL_FFT_POWER_MATRICES_

struct fftPowerMatrices
{
      cplx* tPowerSignal;
      cplx* fPowerSignal;
};

#endif /*  _PHOSSIL_FFT_POWER_MATRICES_ */


enum typeEOMElecData {EOM_BINARY_DATA_PERFECT_RECT = 1,
                      EOM_BINARY_DATA_ARCTANH_SMOOTHING = 2,
                      EOM_BINARY_DATA_SUPERGAUSS_SMOOTHING =3,
                      EOM_BINARY_DATA_RCOS=4};

enum typeEOMElecFilter {EOM_NO_ELEC_FILTER = 0,EOM_GAUSSIAN = 1,EOM_BESSEL = 2};


#include "ocsBitString.hh"

// ##### Class OptSignal ############


class OptSignal
{

  // ####### Public Methods ########

   public:

      // #### Constructors ####

      // OptSignal();

      // Use these constructors:


      OptSignal(string InFileName, RanNumGen *RNG2);
 

 
      OptSignal(string InFileName, RanNumGen *RNG2, string DataFileName);


      
      void ConstructOptSignal(string InFileName, RanNumGen *RNG2);


 
      OptSignal(OptSignal & OrigOptSignal); 


      OptSignal & operator=(OptSignal & RHS_Signal);
                  


     OptSignal & operator-(OptSignal & Signal2); 


     void SubtractFreqDomain(OptSignal *oOptSignal2);


     void AddFreqDomain(OptSignal *oOptSignal2);
  

     OptSignal(OptSignal & Signal1,OptSignal & Signal2,RanNumGen *RNG3);
        


     friend void AddSignals(OptSignal * Signal1,OptSignal * Signal2,
                            OptSignal * Signal3);



  void AddReducedNoiseToNoiseFreeSignal(ReduOptSignal *ReduOptSignal1);


      ~OptSignal();

 
      void RegenerateSignalString(void); 
 

      void GetNewRandomSignalString(void);  


     void ConstantPhaseShift(double PhaseShiftAmount);
   

  void GenerateImpulseSignal(void);  


  void ChangeAveragePowerChannCurrentSignal(double AveragePowerChann2);


  void RegenerateSignalWithGivenAveragePowerChann(double AveragePowerChann2);


   void GenerateSignalStringGaussianOrSechWithPhaseShift(
                                 double PhaseShiftAmount);


  void GenerateSignalStringRaisedCosinesWithPhaseShift(
                                 double PhaseShiftAmount);



  void InputTimeDataFromFile(void);


   void InitializeFirstOrderPMDSignal(double PowerSplit, double DGD);

   void ChangeAbsoluteCenterFreq(double CenterFreq2);


   double GetRelativeCenterFrequency(int ChannelArrayIndex);

  double GetAccumulatedFirstOrderDispersion(void) 
               { return AccumulatedFirstOrderDispersion;};

  double GetAccumulatedSecondOrderDispersion(void) 
               { return AccumulatedSecondOrderDispersion;};

  void ResetAccumulatedFirstOrderDispersionToZero(void) 
               {  AccumulatedFirstOrderDispersion = 0.0;};

  void ResetAccumulatedSecondOrderDispersionToZero(void) 
               {  AccumulatedSecondOrderDispersion = 0.0;};
  
  void SetAccumulatedFirstOrderDispersion(double Value) 
               {  AccumulatedFirstOrderDispersion = Value;};

  void SetAccumulatedSecondOrderDispersion(double Value) 
               {  AccumulatedSecondOrderDispersion = Value;};

  void SetWriteAccumulatedFirstOrderDispersionFlag(int Value)
          { WriteAccumulatedFirstOrderDispersionFlag = Value; }


  void OpenAccumulatedFirstOrderDispersionFile(string FileName);


  void CloseAccumulatedFirstOrderDispersionFile(void);

  
  void WriteAccumulatedFirstOrderDispersion(double PropagatedLength);



  double GetAccumulatedTotalNoiseSpectralDensityGaussianStatistics(void)
    {return AccumulatedTotalNoiseSpectralDensityGaussianStatistics;};

  void SetAccumulatedTotalNoiseSpectralDensityGaussianStatistics(double Value)
         {AccumulatedTotalNoiseSpectralDensityGaussianStatistics=Value;};

  void AddToAccumulatedTotalNoiseSpectralDensityGaussianStatistics
         (double Increment)
       {AccumulatedTotalNoiseSpectralDensityGaussianStatistics += Increment;};

  void GainOfAccumulatedTotalNoiseSpectralDensityGaussianStatistics
       (double LinearPowerGainFactor)
            {AccumulatedTotalNoiseSpectralDensityGaussianStatistics 
               *= LinearPowerGainFactor;};

  double GetNoiseBandwidthGaussianStatistics(void)
    {return NoiseBandwidthGaussianStatistics;};

  void SetNoiseBandwidthGaussianStatistics(double Value)
         {NoiseBandwidthGaussianStatistics=Value;};

  // GET METHODS


      typeSimulation GetTypeSimulation(void) { return TypeSimulation;};
      typePulse GetTypePulse(void) {return TypePulse;};

      int GetChannelArrayIndex(int ChannelPhysicalIndex);
      int GetChannelPhysicalIndex(int ChannelArrayIndex);
      double GetFrequency(int ChannelArrayIndex);
      double GetWavelength(int ChannelArrayIndex);

      double GetCenterFreq(void) {return CenterFreq;}; 
      double GetCenterWavelength(void) {return CenterWavelength;};  

      int GetNumChannels(void) {return NumChannels;};
      double GetBitLength(void) {return BitLength;};

      int GetQtPoints(void) {return qtPoints;};
      double GetDeltaTime(void) {return DeltaTime;};
      double GetFWHM_Pulse(void) {return FWHM_Pulse;};
      double GetBitRateChann(void)  {return BitRateChann;};
      int GetStringLength(void) {return oBitString->GetStringLength();}
      double GetChannSpacing(void) {return ChannSpacing;}; 
      double GetOptPowerChann(void) {return OptPowerChann;};
      double GetDeltaFreq(void) {return DeltaFreq;};
      double GetTimeWindow(void) {return TimeWindow;};
      double GetFreqWindow(void) {return FreqWindow;};
      int GetDebugLevel(void) {return DebugLevel;};
      bool GetRandomPolarizationsFlag() { return RandomPolarizationsFlag;};

      bool GetUsingOptFiberLocalError(void) {return UsingOptFiberLocalError;};

      double GetChirpParameter(void) {return ChirpParameter;};
      double GetInStokes(const int ChannelArrayIndex, 
                               const int StokesIndex);
      cplx GetInJones(const int ChannelArrayIndex, int JonesIndex);

      double * GetInStokes(const int ChannelArrayIndex);
      cplx * GetInJones(const int ChannelArrayIndex);

      double GetFreqForPDVectorOFLE(void) {return FreqForPDVectorOFLE;};


   void GetRandomJones(cplx * Jones);
   void TestGetRandomJones(string OutFileName, int NumberPoints);


   void ResetPDVectorOFLE(void);


   void SetNumberChannelsForDemuxer(int NumChannels2); // ## JZ


   void SetNumChannels(const int NumChannels2); //## (IL)


   void ReduceToSingleChannel(int ChannelArrayIndex); //## (IL)

   // SET METHODS

      void SetFWHM_Pulse(double Value)
           { FWHM_Pulse =  Value;};

      void SetRiseTime(double Value)
            { RiseTime = Value;};

      void SetExtinctionRatio(double Value)
            { LinearExtinctionRatio = dB2Linear(Value);};


      void SetOptPowerChannel(const double Power2)
                        { OptPowerChann = Power2; } ; 

      void SetCenterFreq(const double CenterFreq2)
                        { CenterFreq = CenterFreq2; };

      void SetChannSpacing(const double ChannSpacing2)
                        { ChannSpacing = ChannSpacing2; };

      void SetFrequency(int ChannelArrayIndex, double Freq);

      void SetInStokes(const int ChannelArrayIndex, const int StokesIndex,
                       double StokesValue);
      void SetInJones(const int ChannelArrayIndex, const int JonesIndex,
                       cplx JonesValue);

      void SetInStokes(const int ChannelArrayIndex,double * StokesVector);
      void SetInJones(const int ChannelArrayIndex, cplx * JonesVector);

      void SetRandomJonesVectors(void);

      void SetEOM_RiseTime(double Value)
           {EOM_RiseTime = Value;
            EOM_SlopeFactor = (2.0/EOM_RiseTime)*atanh(0.8);};

      void SetEOM_ElecFilter_FreqFWHM(double Value)
           {EOM_ElecFilter_FreqFWHM = Value;};

      //######## Methods to read in InStokes ########
      // Written by John Zweck

      void InitializeInStokes(ifstream * InFile);
      int ReadInStokes(string InStokesName, int ch, ifstream * InFile);

      // #### Methods written by Ivan Lima ####


      void EliminateSignal(void) {
              EliminateX_Polarization();
              EliminateY_Polarization();
      };       


      void ClearSignal(void) {EliminateSignal();};      


      void EliminateX_Polarization(void);


      void EliminateY_Polarization(void);      

      void ScaleSignal(double ScaleFactor);

      void SwitchXandYPolarizations(void);


      double GetAveragePower(void);


      double GetAveragePowerFreqDomain(void);



      double GetAveragePowerFreqDomainInsideChannels(void);


      double GetAveragePowerFreqDomainInsideChannel(int ChannelArrayIndex); 


      cplx GetAutocorrelationFunctionOptSignalX(double TimeOffset);

      double GetDegreeOfPolarization(void);


      double GetDegreeOfPolarization(double BandWidth);

      double GetDegreeOfPolarization(double RelMinFreq, double RelMaxFreq);

      const char * WriteTypePulse(void);


      void WriteDegreeOfPolarization(double PropLength,
                                     double RelMinFreq, double RelMaxFreq);
 
      void OpenDegreeOfPolarizationFile(string InFileName,bool WriteDOPFlag);
      void CloseDegreeOfPolarizationFile(bool WriteDOPFlag);


      void GetTotalStokesParameters(double *Stokes);


      void GetTotalStokesParametersInBandwidth(double *Stokes,
                            double RelMinFreq, double RelMaxFreq);



       void GetTotalStokesParametersInTime(double *Stokes,
                                           int RelMinTimeIndex,
                                           int RelMaxTimeIndex);


      double GetDegreeOfPolarizationAndTotalStokesFreqDomain(double * Stokes);


      double GetSigmaSqOptSignal(void);  


      double ComputeFWHMPulsePower(void);


      void ImportOptSignal(OptSignal *oOptSignalOrig);


      void DampBounds(double DampTime); 

      void Time2Freq(void);
  

      void Time2FreqScalar(void);

 
      void Freq2Time(void);  


      void Freq2TimeScalar(void);
  

      void fftshift(void);


      void ifftshift(void);
  

      void TimeShiftSignal(double dTime);

      void FreqShiftSignal(double dFreq);

      
      void WriteFileTimePower(string outFile);


      void WriteFileFreqPower(string outFile);    


      void WriteFileWavelengthPower(string outFile);    

  
      void WriteFileFreqPower(string outFile,int TypeOutputFlag);
        
      // ### The following public methods were added by John Zweck #####

     void WriteFileFreqPowerdBm(string outFile);
     

     void WriteFileComplexFieldsTimeAndFreq(string OutFileName);


     void ReadFileComplexFieldsTimeAndFreq(string InFileName);


     void WriteComplexFields(string OutFileName, int ForRestartFlag);


 
    void ReadComplexFields(string InFileName);
 
    void ReadComplexFieldsX(string InFileName);


     void WriteComplexFieldsX(string OutFileName, int ForRestartFlag);



     void WriteComplexFieldsFreq(string OutFileName);


     void WriteFreqPhaseX(string OutFileName);



      void WriteDistTimePowerPhase(string outFile,  int timeIndexIncrement,
                                   double distance, 
                                   int appendFlag);



      void WriteDistTimePower(string outFile,  int timeIndexIncrement,
                                   double distance, 
                                   int appendFlag);


      void WriteDistTimeCplxWave(string outFile, double distance, 
                                 int appendFlag);



     void WriteAveragePowerdBm(string OutFileName,double distance,
                            int appendFlag); 


     void WritePowerdBmChannel(string OutFileName,double distance,
                                   int appendFlag,int ChannelArrayIndex);
  

     void WritePowerdBmFreqWindow(string OutFileName,double distance,
                                  int appendFlag,
                                  double LeftFreq,double RightFreq);


      void WriteFileTimeAmpPhase(string outFile);


      double GetLocalFrequency(int timeIndex);


      double GetChirp(int timeIndex);


      double ComputeAverageChirpOfMarks(double TimeWithinBitSlot);


      void WriteLocalFrequencyAndChirp(string outFile);


      void WriteChirp(string outFile);


     template<class T>  T WrapPeriodically(T periodicVariable, 
                                      T leftEndPoint, T rightEndPoint);


   int GetFloorIndex(double Time);

   int GetCeilIndex(double Time);

   double GetRealX(double Time);

   double GetImagX(double Time);

   double GetRealY(double Time);

   double GetImagY(double Time);


  //###### Methods to compute Energy, Written by JZ


  double GetEnergyInBitSlot(int BitSlotNumber);


  double GetTotalEnergy(void);


  double GetEnergyInTimeRange(double LeftTime, double RightTime);


  double ComputeMeanTimePulse(void);
 
  double ComputeMeanTimePulse(double StartTime, double EndTime);

  double ComputeMeanFreqSignal(void);

  double ComputeMeanPhasePulse(void);

  double ComputeMeanPhasePulse(double StartTime, double EndTime);

  
  double ComputeRMSPulseWidth(void);


  double ComputeSigmaSqTimeWindow(double StartTime, double EndTime);


  double ComputeAverageSigmaMarks(void); 


  double ComputeRMSSpectralWidth(void); 

  double ComputeMaxPower(void);

  double ComputeMaxPower(int & ArgMaxIndex);

  void OpenAveragePulseWidthFile(string FileName,int WriteFlag);
  void CloseAveragePulseWidthFile(int WriteFlag);


  void WriteAveragePulseWidth(double PropagatedLength,int WriteFlag);

  void ResetJonesMatrix(void);



  void GenerateSignalStringGaussianOrSech(void);


  void GenerateSignalStringRZGaussianPattern(void);

   
  void GenerateSignalStringRaisedCosines(void);


  void GenerateSignalStringUsingInputSequence(void);
 

  void GenerateSignalStringQPSK_Gaussian(void);
  void GenerateSignalStringQPSK_CW(void);

  void GenerateSignalStringNRZ_RCOS_MachZehnderModulator(void);

  void GenerateSignalStringBPSKPhaseModulator(void);
  void GenerateSignalStringBPSKMachZehnderModulator(void);

  void GenerateSignalStringCSRZMachZehnderModulator(void);
  void GenerateSignalStringRZ33MachZehnderModulator(void);
  void GenerateSignalStringRZ50MachZehnderModulator(void);

  void GenerateSignalStringQPSK_SEQ_PM_NRZ(void);
  void GenerateSignalStringQPSK_DPMZ_PM_NRZ(void);

  void GenerateSignalStringQPSK_SEQ_PM_AM_RZ33(void);
  void GenerateSignalStringQPSK_SEQ_PM_AM_RZ50(void);
  void GenerateSignalStringQPSK_DPMZ_PM_AM_RZ33(void);
  void GenerateSignalStringQPSK_DPMZ_PM_AM_RZ50(void);

  void EOM_MachZehnderModulatorOptData(double V_pi1, double V_pi2,
                                double Phi_10, double Phi_20,
                                double SinusoidalRate, 
                                double SinusoidalThetaShift);

  void EOM_MachZehnderModulatorOptNRZOLD(double V_pi1, double V_pi2,
                                double Phi_10, double Phi_20,
                                double SinusoidalRate,
                                double SinusoidalThetaShift);

  void GenerateSignalStringCSRZMachZehnderModulatorOLD(void);
  void GenerateSignalStringRZ33MachZehnderModulatorOLD(void);
  void GenerateSignalStringRZ50MachZehnderModulatorOLD(void);

  void EOM_MachZehnderModulatorElecNRZ(double V_pi1, double V_pi2,
                                double Phi_10, double Phi_20,
                                double SinusoidalRate,
                                double SinusoidalTimeShift,
                                double SinusoidalVertShift);

  void SetEOM_V_pi_RelError(double EOM_V_pi_RelError2);

  void SetEOM_Phi_10_RelError(double EOM_Phi_10_RelError2);

  void SetEOM_Phi_20_RelError(double EOM_Phi_20_RelError2);

  void SetEOM_SinusoidalVertShift_RelError(
        double EOM_SinusoidalVertShift_RelError2);

  void EOM_WriteFileElecData(string OutFileName);

  void EOM_SinusoidallyModulateElecData(double SinusoidalRate, 
                                        double SinusoidalTimeShift,
                                        double SinusoidalVertShift);

  void EOM_PhaseModulator(void);
 
  string EOM_GetTypeElecData(void);
  string EOM_GetTypeElecFilter(void);

  void EOM_GenerateRaisedCosineBinaryElecData(int ChannelArrayIndex,
                                              bool ZeroOneNotMinusPlusFlag);
  double RaisedCosineForNRZ_RCOS_MZ(double Time);

  void EOM_GeneratePerfectRectBinaryElecData(int ChannelArrayIndex);
  void EOM_GenerateSmoothedRectBinaryElecDataArctanh(int ChannelArrayIndex);
  void EOM_GenerateSmoothedRectBinaryElecDataSuperGauss(int ChannelArrayIndex);

  double EOM_SuperGauss(double Time);
  void EOM_FilterElecData(void);

  void EOM_ElectricalFilterBessel4(cplx *my_power_time,double fwhm_norm);
  void EOM_ElectricalFilterGaussian(cplx *my_power_time,
                                             double fwhm_norm);

  cplx EOM_Bessel4(double omega,double FWHM);
  double EOM_Gaussian(double omega,double FWHM);

 
  void ComputeRelevantNumModesOFLE(void);

  int GetRelevantNumModesOFLE(void) {return RelevantNumModesOFLE;};

  void SetBandwidthForRelevantNumModesOFLE(double BandwidthGHz);


   void SetBitLengthJZ(double Value) {BitLength = Value;}; 
            

   void SetBitRateChannJZ(double Value)  {BitRateChann = Value;};

  

  void SetBitRateChannBM(double Value);


  void AddSignalBM(OptSignal * oOptSignal2);


  void AddCWSignal(double PowerCWChann, double FreqCWChann);
   
  // ####### Public Data ######

  public:

    cfftw *fft;           
    fftMatrices sfftM; 


    BitString *oBitString; 

    RanNumGen * RNG;


    ReduOptSignal * oReduOptSignal;

    cplx *JonesMatrixChannel;  
   

    OptFiberLocalErrorWorkSpace OFLEWork; 


    double * QuadratureWorkSpace;



    double * OutputPDVectorOFLE;


    double * InputPDVectorOFLE;


  double ** StokesTransferMatrixTransposeOFLE;

  // ########## Private Methods

  private:

     void AllocateOptFiberLocalErrorWorkSpace(void);
     void DeallocateOptFiberLocalErrorWorkSpace(void);


  // ##### Private Data #######

  private:

      typeSimulation TypeSimulation;

      int NumChannels;
      
      double CenterFreq;
      double CenterWavelength;
      double ChannSpacing; 


      double * Frequency; 


      double BitLength; 
      double BitRateChann;


      typePulse TypePulse; 


      int StringLength;
      double FWHM_Pulse;
      double ChirpParameter;
      double LinearExtinctionRatio;
      double RiseTime;
      double OptPowerChann;


      string InputTimeDataFileName;

    
      string InputSequenceFileName;

      double *InStokes; 

      cplx *InJones;  


      bool RandomPolarizationsFlag;

      int qtPoints;
      double TimeWindow,DeltaTime;
      double FreqWindow,DeltaFreq;  

      double AccumulatedFirstOrderDispersion;
      double AccumulatedSecondOrderDispersion;

      ofstream AccumulatedFirstOrderDispersionFile;
      int WriteAccumulatedFirstOrderDispersionFlag;

      ofstream AveragePulseWidthFile;

      ofstream DegreeOfPolarizationFile;

      double FreqForPDVectorOFLE;     
     

  bool ComputeInputPDVectorFlagOFLE;



     int RelevantNumModesOFLE;


     bool ComputeRelevantNumModesOFLEFlag;


      int DebugLevel;
   
      int MemAllocated; 
      bool UsingOptFiberLocalError;

  

      double AccumulatedTotalNoiseSpectralDensityGaussianStatistics;


  double NoiseBandwidthGaussianStatistics;

  typeEOMElecData TypeEOMElecData;
  typeEOMElecFilter TypeEOMElecFilter;
      
  fftPowerMatrices EOM_sfftPM;
  fftPowerMatrices EOM_sfftPM1;
  fftPowerMatrices EOM_sfftPM2;

  double EOM_RiseTime;
  double EOM_SlopeFactor;
  double EOM_ShiftAmt;
  int EOM_SuperGaussExponent;
  double EOM_ElecFilter_FreqFWHM;

  double EOM_V_pi_RelError;
  double EOM_Phi_10_RelError;
  double EOM_Phi_20_RelError;
  double EOM_SinusoidalVertShift_RelError;

};

#endif /* _OCS_OPT_SIGNAL_HH_ */