ocsOptFiber.hh

Go to the documentation of this file.

// $Id: ocsOptFiber.hh,v 1.2 2006/05/11 23:46:04 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_HH_
#define _OCS_OPT_FIBER_HH_


#include "ocsOptSignal.hh"

// ##### Class OptFiber

class OptFiber
{
   public:

      OptFiber();

  // #########################################
  // 
  // ## The following methods added by John Zweck

  // Use this constructor:

  OptFiber(string InFileName, OptSignal *oOptSignal2, RanNumGen *RNG2);

  // This method modifies X polarization only and should be used 
  // in conjunction with OptAmplifier::AmplifySignalScalar()
      
  void PropagateFiberScalarNLS(double *PropagatedLengthFiber);

 // This method modifies X and Y polarizations  and can be used when there
  // is no PMD, but where the amps have PDL/PDG
  // It should be used 
  // in conjunction with OptAmplifier::AmplifySignal

  void PropagateFiberDecoupledNLS(double *PropagatedLengthFiber);

  // ## The PropagateFiberScalarNLS method outputs dist-time-power
  // ## data at  FirstWriteLength + k*DeltaWriteLength for k=0,1,2...
  // ## provided the flag  WriteFlag is set.
  // ## The TimeIndexIncrement variable enables the data to be sampled
  // ## in time every TimeIndexIncrement
  // ## The int *NumSlicesZ keeps track of how many times we have written
  // ## out the data along the whole transmission line.
  // ## Note that it you can initially have 
  // ## PropogatedLengthFiber > FirstWriteLength
  // ## in which case you output at the first k for which 
  // ## PropogatedLengthFiber >= FirstWriteLength + k*DeltaWriteLength
  // ## To make sure this is done correctly we need to also pass 
  // ## NumSlicesFirstWriteLength.


      void PropagateFiberScalarNLSWriteData(double *PropagatedLengthFiber,
                                   int WriteFlag,
                                   char *DistTimePowerPhaseFileName,
                                   int TimeIndexIncrement,
                                   double FirstWriteLength,
                                   double DeltaWriteLength, 
                                   int *NumSlicesZ,
                                   int NumSlicesFirstWriteLength);


      void SwitchOptSignalData(OptSignal *oOptSignal2);
      void SetLengthFiberAndQtStepsFiber(double Length,int numSteps);
      void SetStepLengths(double *usrStepLength); 
      void SetStepLength(double StepLength, int StepNumber); //## Avoid this function
      void SetSndOrDispFiber(double SndOrDispFiber2);
      void SetFstOrDispFiber(double FstOrDispFiber2);
      void SetGammaFiber(double gamma2);
      void SetAttenuation(double AttenuationFiber2);



      void GetRandomStepLengths(double RelativeRangeLengths); 
      void WriteFileStepLengths(char *outFile);       
          

      //## The next two functions are out of the standard
      //## Anyway, we can live with that.
      double GetFirstOrderDispersion() {return  FstOrDispFiber;};
      double GetSecondOrderDispersion() {return  SndOrDispFiber;};
      double GetFiberLength() {return LengthFiber;};

      double GetFstOrDispFiber() {return  FstOrDispFiber;};
      double GetSndOrDispFiber() {return  SndOrDispFiber;};
      void   WriteFileDispersionProfile(char *outFile);  
      double GetLengthFiber() {return LengthFiber;};
      int    GetQtStepsFiber() {return qtStepsFiber;};
      double GetAttenuationFiber() {return AttenuationFiber;};
      double GetNepperAttenuationFiber() {return NepperAttenuationFiber;};
      double GetNonLinIndexFiber() {return NonLinIndexFiber;};
      double GetGamma() {return gamma;};


      void SetNonLinCoupling(double a11, double a12, double a21, double a22) 
            {NonLinCoupling[0][0] = a11;
             NonLinCoupling[0][1] = a12;
             NonLinCoupling[1][0] = a21;
             NonLinCoupling[1][1] = a22;};

  // ##############################

      ~OptFiber();


      //###########################
      //## Methods related to PMD
      void SetMeanDGD_SqrtLength(double MeanDGD_SqrtLength2);
      void SetPMD_Fiber(double PMD_Fiber2);   

      void GetFiberSampleCompleteScatt(void);
      void SkipOptFibers(int qtOptFibersSkipped);
      
      void PropagateFiberCoupledNLS(double *PropagatedLength);

      void PropagateFiberCoupledNLS(void)
         {double PropagatedLength;
          PropagateFiberCoupledNLS(&PropagatedLength);}; //## IL (9/6/02)

      void PropagateFullNonlinearFiberCoupledNLS(double *PropagatedLengthFiber)
            {PropagateFullNonlinearFiberCoupledNLS(PropagatedLengthFiber,0);};      

      void PropagateFullNonlinearFiberCoupledNLS(double *PropagatedLengthFiber,
                                                 double DampTime);
                  


      void PropagateFiberCoupledNLSFreqDomainOnly(double *PropagatedLength);

      void TransformJonesVectorThroughFiber(double RelFreq,cplx *JonesVec);

      void GetFiberSampleUnifRz(void);
      void GetFiberSampleUnifRyRzRy(void);
      void GetFiberSampleUnifRxRzRy(void);

      //## Apply Importance Sampling (high DGDs for BiasingParam > 0)
      double GetFiberSample(int TypeDistrib, double BiasingParam);     
      double GetFiberSampleImportSamplingFstSndOrderPDV_Exp(
                                 double BiasedAngleFstOrder,
                                 double BiasingParamFstOrder,
                                 double BiasingParamSndOrder);        

      double GetFiberSampleImportSamplingFstSndOrderPDV_VariableAngleExp(
                                 double BiasedAngleFstOrder,
                                 double BiasingParamFstOrder,
                                 double BiasingParamSndOrder);    

      double GetFiberSampleImportSamplingExp(double BiasingParam);
      double GetFiberSampleImportSamplingCosRx(double BiasingParam);
      double GetFiberSampleImportSamplingSndOrderPDV_Exp(
                                           double BiasedAngle,
                                           double BiasingParam);
      double GetFiberSampleImportSamplingSndOrderPDV_VariableAngleExp(
                                     double BiasedAngle,
                                     double BiasingParam); 

      double GetHeuristicBalanceForSndOrderPDV_VariableAngleExp(
                            string InFileNameWithDirectories, 
                            string InFileNameWithImpSampWeights,
                            string OutFileNameWithHeuristicBalance); 
                                     
      void SetScatteringMatrix( int IndexStep, double Theta
                               ,double Phi, double Psi);
      void SetScatteringMatrixRxRzRy( int IndexStep, double Theta 
                                ,double Phi, double Psi);                              
      void SetScatteringMatrixRzRxRzRyRzRy( int IndexStep, 
      double Chi, double Ksi,double Delta,double Phi,double Theta, double Psi)  ;                               
           
      double GetDGD(double Freq);   
      double GetDGD_Manakov(double Freq);  // ## Slower version    
      double GetSndOrderDGD(double Freq);
      double GetThirdOrderDGD(double Freq);
      double Get_dDGD_domega(double Freq);
      double GetNum_dDGD_domega(double Freq);
      double GetNum_d2DGD_domega2(double Freq);      
      void GetInPD_Vector(double Freq, double *InPD_Vector);   
      void GetInPD_VectorOld(double Freq, double *InPD_Vector);   
      void RotateThroughFiber(double Freq, double *OutVector);         
      void GetOutPD_Vector(double Freq, double *OutPD_Vector);
      void GetOutPD_VectorOld(double Freq, double *OutPD_Vector);
      void GetSndOrderOutPD_Vector(double Freq
                                  ,double *SndOrderOutPD_Vector);
      void GetSndOrderOutPD_Vector(double Freq
                                  ,double *SndOrderOutPD_Vector
                                  ,double *OutPD_Vector);
      void GetNumSndOrderOutPD_Vector(double Freq
                                  ,double *SndOrderOutPD_Vector);
      void GetThirdOrderOutPD_Vector(double Freq
                                  ,double *ThirdOrderOutPD_Vector);
     void GetThirdOrderOutPD_Vector(double Freq
                                  ,double *ThirdOrderOutPD_Vector
                                  ,double *SndOrderOutPD_Vector
                                  ,double *OutPD_Vector);
      void GetNumThirdOrderOutPD_Vector(double Freq
                                  ,double *ThirdOrderOutPD_Vector);
      void GetNumOutPD_Vector(double *NumOutPD_Vector[3]);      
      double GetExpectedDGD(void)
             {return rms2meanDGD()*sqrt(LengthFiber)*PMD_Fiber; };
      //       {return sqrt(8./(3.*pi)*LengthFiber)*PMD_Fiber; };
      double GetExpectedSndOrderDGD(void) 
             {return sq(GetExpectedDGD())/sqrt(3.); };
      double GetExpectedThirdOrderDGD(void) 
             {return cube(GetExpectedDGD())/sqrt(7./3.); };
      double GetMeanDGD_SqrtLength(void) 
             {return sqrt(1e3)/1e-12*MeanDGD_SqrtLength;};
             //## return value in ps/km^{1/2}

      double GetLocalBeatLength(void);

      double GetLocalBeatLength(double Freq) 
         {return 2*pi/abs(2*dBeta_2dOmega*2*pi*Freq);};

      //FiberParam soOptFiber;

      //double ExpectedDGD;
      //double ExpectedSndOrderDGD;


   private:
      void AllocateMemory_SetLengthSteps(void); 
      double rms2meanDGD(void);
      void ReleaseMemory(void);
      void GetEulerMatrix(int IndexStep);
      void GetRyRzRyMatrix(int IndexStep);
      void GetRxRzRyMatrix(int IndexStep);
      void GetRxRzRyRzRyMatrix(int IndexStep); 
      void GetRzRxRzRyRzRyMatrix(int IndexStep);     
      void GetTmOut(void);
      int TypeScattering; // ## 1 -> Euler Matrix; 2 -> RyRz
      OptSignal *oOptSignal;
      cfftw *fft;
      fftMatrices sfftM;                   
      int    MemAllocated;
      
      RanNumGen * RNG;
      
      int    GotFiberSample;
      double *theta,*psi,*phi; 
      double *delta,*ksi, *chi; //## For biasing the 2nd Order PDV
      double *StepLength; 
      int    qtStepsFiber;
      int    qtStepsFiberLast;
      double LengthFiber;
      double PMD_Fiber;
      double MeanDGD_SqrtLength;
      double FstOrDispFiber;
      double SndOrDispFiber;
      double NonLinIndexFiber;
      int    WithNonLin;              
      double EffectAreaFiber;  
      double AttenuationFiber;      
      double NepperAttenuationFiber;
      double CenterFreq;      
      int    qtPoints;
      double DeltaFreq;     

      double cvtheta2,cvtheta;      
      cplx   *TransM[2][2]; // ## Vector with all complex 2x2 Euler Matrix
        
      double DeltaZ;         
      double dBeta_2dOmega;
      double gamma;
      double NonLinCoupling[2][2];

      // ## Variables used for numerical calculation of PD vector
      fftMatrices sfftNumPD_Vector;
      double *Tmp1PD_Vector[3];        
      double *Tmp2PD_Vector[3];    
      double *Dev1PD_Vector[3];       
      double *Dev2PD_Vector[3];             
      
      //## For the importance sampling
      bool FlagImportSamplingSndOrderPDV_VariableAngleExp;

      int DebugLevel;
}; 

#endif //## _OCS_OPT_FIBER_HH_