ocsOptFiberLocalError.hh

Go to the documentation of this file.

// $Id: ocsOptFiberLocalError.hh,v 1.8 2008/08/08 02:21:34 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_OPT_FIBER_LOCAL_ERROR_HH_
#define _OCS_OPT_FIBER_LOCAL_ERROR_HH_

#include "ocsOptSignal.hh"
#include "ocsRamanAmp.hh"



enum typeRamanAmplification { NO_RAMAN = 0, 
                              SIMPLE_RAMAN = 1, 
                              FULL_RAMAN = 2 }; 



enum typeFiberLossGain {LOSSY_FIBER = 0,
                        FIBER_AMPLIFIER = 1};

enum typeFiberAmplifierNoise {FIBER_AMP_NOISE_OFF = 0,
                              FIBER_AMP_NOISE_GAUSSIAN_WHITE = 2};


enum typeFiberAmplifierGain {FIBER_AMP_UNSATURATED_FLAT_GAIN = 0,
                             FIBER_AMP_SATURABLE_SUPERGAUSSFILT_GAIN = 1};      



enum typeFastSaturableAbsorption {QUADRATIC_ANALYTIC=0,QUADRATIC=1};



enum typeStepSizes { LOCAL_ERROR_3RD = 1, 
                     LOCAL_ERROR_2ND = 2, 
                     WALK_OFF = 3,
                     CONSTANT = 4 };


enum { APPLY_ONCE = 0, APPLY_TWICE = 1 };

class OptFiberLocalError
{

 public:


  OptFiberLocalError(string InFileName, OptSignal *oOptSignal, RanNumGen *RNG2,
                    string Job2);

  void SetRamanAmpPointer(RamanAmp * oRaman2);


 ~OptFiberLocalError(void);


 void Propagate(double * PropagatedLength,int * ZStepNum);


 void PropagateWithRaman(double * PropagatedLength,
                         int * ZStepNum,
                         double  RamanStartingLength2);
 
 string WriteTypeSolver(void);
 string WriteTypeStepSizes(void); 
 string WriteTypeFiberLossGain(void);
 string WriteTypeFiberAmplifierNoise(void);
 string WriteTypeFiberAmplifierGain(void);

 void OpenStepSizesFile(string StepSizesFileName,int Mode);
 void WriteStepSizes(double PropagatedLength);
 void WriteAveragePowerdBm(double PropagatedLength2);

 // Get methods

 double GetFirstOrderDispersion() {return  FstOrDispFiber;};
 double GetSecondOrderDispersion() {return  SndOrDispFiber;};
 double GetFiberLength() {return LengthFiber;};
 double GetNepperAttenuationFiber() {return NepperAttenuationFiber;};
 double GetNonLinIndexFiber() {return NonLinIndexFiber;};
 double GetGamma() {return gamma;};
 double GetDeltaZ() {return DeltaZ;}; 
 int GetNumStepsBetweenScatterings() {return NumStepsBetweenScatterings;};

 void SetNumStepsBetweenScatterings(int value) 
        {NumStepsBetweenScatterings = value;
         SetFiberLengthsForPMD(); };


  double GetDispersion(double Wavelength);

 // Set methods

 void SetTypeStepSizes(int TypeStepSizes2);
 void SetWalkOffParameter(double WalkOffParameter2); 
 void SetConstantDeltaZ(double DeltaZValue);

 // void SetNumStepsBetweenScatterings(int Value);

 void SetOutputStepSizesFlag(int OutputStepSizesFlag2);
 void SetRelativeErrorGoal(double RelativeErrorGoal2);


 void SetFstOrDispFiber(double FstOrDispFiber2);

 void SetSndOrDispFiber(double SndOrDispFiber2);
 void RecoverSndOrDispFiber();

 void SetDispersion(double DispersionFiberRefWavelength,
                    double DispSlopeFiberRefWavelength); // s/m^2 and s/m^3

 void SetGammaFiber(double gamma2);
 void RecoverGammaFiber();


 void SetAttenuationdB(double AttenuationFiber2);

 
 void SetNepperAttenuation(double NepperAttenuation2);



 void SetFiberAmplifierUnsaturatedNepperGain(
           double FiberAmplifierUnsaturatedNepperGain2);


 void ComputeDeltaZMax(void);

 void SetWriteAveragePowerdBmFlag(int Value);

  void SetWritePulseWidthFlag(int Value) {WritePulseWidthFlag = Value;};

  void SetFiberLength(double Value);
  void SetScatteringStepSize(double Value);

  // ####### Methods related to Manakov-PMD equation ######

  void GetNewFiberRealization(void);
  void SetFiberRealization(int SectionNumber, 
                           double Theta2, double Phi2, double Psi2);

  void ApplyPMDCompleteScatteringFreqDomainOperator(
                       int ScatteringSectionIndex);
  
  void ComputeEulerMatrixAndUpdateOutputPDVector(int ScatteringSectionIndex);

  void GetEulerMatrix(double theta,double phi,double psi);

  void SetFiberLengthsForPMD(void);

  void SetMeanDGDPerSqrtLength(double MeanDGDPerSqrtLength2);
  void SetPMD(double PMD2);
  double GetFreqDerivativeOfBirefringence(void);

  double GetDGD(void);  
 
  void PropagateOutputPDVector(double Freq,
                                double theta, double phi, double psi);

  double GetExpectedDGD() 
             {return sqrt(8./(3.*pi)*LengthFiber)*PMD; };
  double GetExpectedSndOrderDGD() 
             {return sq(GetExpectedDGD())/sqrt(3.); };
  double GetMeanDGD_SqrtLength(void) 
             {return sqrt(1e3)/1e-12*MeanDGDPerSqrtLength;};

  // JZ Commented out 
   void UpdateJonesMatrixAfterBiregringence(double StepSizeZ);

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

public:

  RamanAmp * oRaman;

  // ########## PRIVATE METHODS ####################

 private:

  // Private Methods

 void PropagateWithPMD(double * PropagatedLength,
                                           int * ZStepNum);

 void PropagateWithoutPMD(double * PropagatedLength,
                                           int * ZStepNum);

 void PropagateLocalError(double * PropagatedLength, int * ZStepNum);


 void PropagateConstStepSizeOrWalkOff(double * PropagatedLength,
                                        int * ZStepNum);


 void ResetVolatileVariables(void);

 void inline UpdateFreq(void);
 void inline UpdateTime(void);

 void ComputeWalkOffStepSize(void);

 void ComputeDispersionOperator(double StepSizeZ);
 void ApplyDispersionOperator(bool ApplyTwiceFlag);
 void ApplySaturableGainOperator(double StepSizeZ);
 void ApplyFreqDomainOperator(bool ApplyDispersionTwiceFlag,
                              double GainSatStepSizeZ);

 void ApplyRamanOperator(double CurrentZValueWithinFiber2,double ZStep2);
 void ApplyTimeDomainOperator(double StepSizeZ);

 void ApplyKerrNonlinearityOperator(double StepSizeZ);
 void ApplyFastSaturableAbsorptionOperator(double StepSizeZ);
 void ApplyFastSaturableAbsorptionQuadraticAnalytic(double StepSizeZ);
 void ApplyFastSaturableAbsorptionHeunsMethod(double StepSizeZ);
 cplx FastSaturableAbsorptionFunction(cplx u);

 double ComputeMaxPower(void);

 void CopyFftMatricesFreqData(fftMatrices * OrigData,fftMatrices * CopyOfData);

 double ComputeThirdOrderSolutionAndRelativeError(void);
 double ComputeThirdOrderSolutionAndRelativeErrorOLD(void);

  // AccumulatedFirstOrderDispersion is a data member in the 
  // OptSignal class which keeps track of the total dispersion
  // (beta'') in s^2 which the signal has experienced.
  // The UpdateAccumulatedFirstOrderDispersion is called each z-step.

 void UpdateAccumulatedFirstOrderDispersion(double StepSize);
 void UpdateAccumulatedSecondOrderDispersion(double StepSize);


 void FiberAmplifierComputeSaturableGain(void);


 double FiberAmplifierComputeSaturableGainForHeunsMethod(bool FirstStep);


 double FiberAmplifierGetEnergyForHeunsMethod(bool FirstStep);


  void FiberAmplifierComputeNoiseAmplitudeFactor(double StepSize);


  void FiberAmplifierAddMonteCarloNoise(double StepSize);

  void AllocateMemoryForEulerAngles(void);

  // Private Raman Methods
  
  void ApplySimpleRamanOperator(double CurrentZValueWithinFiber2,
                                double ZStep2);

  void ApplyFullRamanOperator(double CurrentZValueWithinFiber2,double ZStep2);

  // ########## PRIVATE DATA ######################

  // Private Data

 ofstream StepSizesFile;

 int OutputStepSizesFlag;
 int StepSizesFileMode;
 string Job;

 typeSimulation TypeSimulation;

  /* Options are 
     -# SCALAR_NLS = 1: The PDE is the scalar nonlinear Schroedinger equation
        as used in optical communications. This code can be run with or without
        the 8/9-ths factor in the Kerr nonlinearity term. This factor should
        be included when using a scalar PDE to
        model noise-free systems in the limit as the birefringence
        goes to zero, or more precsiely in the limit that the characteristic 
        length scale for PMD is longer than system length (See CRM's paper
        J Eng Math, Eqn 68).
     -# VECTOR_MANAKOV_PMD = 2: The PDE is the vector Manakov equation
        as in CRM's J Eng Math, Eqn (67), in the case that there is no linear
        PMD term and no nonlinear PMD. This equation is appropriate for
        simulations with noise when the characteristic 
        length scale for PMD is longer than system length.
     -# VECTOR_MANAKOV_NO_PMD = 3: The PDE is the vector Manakov equation
        as in CRM's J Eng Math, Eqn (67) with linear PMD (but not nonlinear
        PMD term). Includes the birefringence and random scattering on 
        the Poincare sphere.
  */

  typeSolver TypeSolver;

  typeStepSizes TypeStepSizes; // This variable used to be called
                               // TypeAlgorithm


  typeFiberLossGain TypeFiberLossGain;

  typeFiberAmplifierNoise TypeFiberAmplifierNoise;


  double FiberAmplifierSpontaneousEmissionFactor;


  double FiberAmplifierNoiseMaxStepSizeFactor;

  /*

    Used when TypeFiberLossGain = FIBER_AMPLIFIER and 
      TypeFiberAmplifierGain == FIBER_AMP_SATURABLE_SUPERGAUSSFILT_GAIN

    The step size is chosen to gaurantee that

    Power(z+delta_z)/Power(z) < FiberAmplifierGainSaturationMaxGainPerStep
   
    Note that this gain is specified on a linear scale.

    Default value is 1.01

    This ensures that power is correctly computed in calculation of saturable
    gain.

    \sa enum typeFiberAmplifierGain.

    \sa FiberAmplifierNoiseMaxStepSizeFactor

  */ 

  double FiberAmplifierGainSaturationMaxGainPerStep;


  double FiberAmplifierNoiseAmplitudeFactor;


  typeFiberAmplifierGain TypeFiberAmplifierGain;


  double FiberAmplifierSuperGaussFiltGainCoefficient;


  int FiberAmplifierSuperGaussFiltOrder;


  double FiberAmplifierUnsaturatedNepperGain;


  double FiberAmplifierSaturationEnergy;


  double FiberAmplifierSaturableGainPerLength;

  typeFastSaturableAbsorption TypeFastSaturableAbsorption;


  double FastSaturableAbsorptionCoefficient;


  bool DoFastSaturableAbsorptionFlag;


  bool DoTimeOperatorExactlyFlag;


  bool DispersionOperatorValid;

 int ScalarSolverEightNinthsFlag; 

 OptSignal * oOptSignal;
 RanNumGen * RNG;
 cfftw *fft;
 fftMatrices sfftM;  

 cplx * FreqDomainOperatorX;
 cplx * FreqDomainOperatorY;

 cplx * SqFreqDomainOperatorX;
 cplx * SqFreqDomainOperatorY;

  
 fftMatrices sfftM_Start;
 fftMatrices sfftM_Coarse;
 cplx * LaserWorkX;
 cplx * LaserWorkY;


 double LengthFiber;
 
 double RamanStartingLength;
 double PropagatedLengthStartFiber;
 int NumStepsBetweenScatterings; // For const step size second order algorithm

  double ReferenceFreq;
  double ReferenceWavelength;


  double DispersionFiberCenterWavelength; // s/(m^2)
  double DispSlopeFiberCenterWavelength; // s/(m^3)


 bool SetFstSndOrDispDirectlyFlag; 

 double FstOrDispFiber; // s^2/m
 double SndOrDispFiber;
 double SndOrDispFiber_Save;
 double NonLinIndexFiber;


 int    WithNonLin;                   

 double EffectAreaFiber;  


 double AttenuationFiber;      


 double NepperAttenuationFiber;

  typeRamanAmplification TypeRamanAmplification;

// Variables for simple raman model

  double RamanOnOffGaindB;
  double NepperRamanGain;
  double NepperRamanPumpLoss;

 double CenterFreq;      
 int    qtPoints;
 double DeltaFreq;     
 double gamma;
 double gamma_Save;

 double CurrentZValueWithinFiber; 
   // Ranges from 0 to LengthFiber during
  // course of propagation within the current fiber


 double DeltaZ;
 double DeltaZMaxInfile, DeltaZMax;


 double DeltaZInitial;

 bool InitializedDeltaZInitialFlag;
 
 double WalkOffStepSize;
 double WalkOffLastStepSize;
 int WalkOffNumSteps;
 double WalkOffParameter;
 
 double MaxPower;

 double FWHM_Pulse;

 bool TimeDataValid;
 bool FreqDataValid;

 double RelativeError;
 double RelativeErrorGoal;

 int LocalErrorFreqLimit;

 int WriteAveragePowerdBmFlag;
 int WritePulseWidthFlag;
 
   // ####### Variables related to Manakov-PMD equation ######

  double *OutputPDVector;
  double *InputPDVector;
  
  // Variables related to birefringence strength

 double PMD;
 double MeanDGDPerSqrtLength;

 // Variables related to random rotation of axes of birefringence

 double ScatteringStepSize;
 cplx EulerMatrix[2][2];

  int NumberScatterings;
  double TotalLengthFiber;
  double LengthFiberExceptLast, LengthFiberLast;

  // Arrays for length NumberScatterings for the Euler angles

  double * Theta;
  double * Phi;
  double * Psi;

 double *PDVectorHai;             //added by Hai 8/14/03
 
 
 cplx *JonesMatrix;   //added by Hai 7-1-03
 int NumberOfChannels;  //added by Hai 7-1-03
 double *FreqChannels;   //added by Hai 7-1-03




};

#endif /* _OCS_OPT_FIBER_LOCAL_ERROR_HH_ */