ocsOptAmplifier.hh

Go to the documentation of this file.

// $Id: ocsOptAmplifier.hh,v 1.8 2007/10/24 14:29:19 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)
//
//###################################################################

// some change is writen by Jonathan Hu 
// new constructor
// several functions


#ifndef _OCS_OPT_AMPLIFIER_HH_
#define _OCS_OPT_AMPLIFIER_HH_

#include "ocsOptSignal.hh"
#include "ocsOptSpectrumAnalyzer.hh"
#include "ocsPolDepAttenuator.hh"
#include "ocsReduOptAmplifier.hh"

// The following two enums are also defined in ocsReduOptAmplifier.hh

#ifndef _OCS_TYPE_AMPLIFIER_
#define _OCS_TYPE_AMPLIFIER_

enum typeAmplifier { NO_AMPLIFICATION = 0,
                     SCALAR_SIMPLE = 1, SCALAR_SATURATED = 2, 
                     VECTOR_SIMPLE = 3, VECTOR_SATURATED = 4, 
                     VECTOR_FIXED_OUTPUT_POWER = 5,
                     VECTOR_FIXED_TOTAL_OUTPUT_POWER = 6 };



#ifndef _TYPE_AMPLIFIER_NOISE_
#define _TYPE_AMPLIFIER_NOISE_

enum typeAmplifierNoise { NOISE_OFF = 0, 
                          NOISE_ON_CONST_POWER_RANDOM_PHASE = 1,
                          NOISE_ON_GAUSSIAN_WHITE = 2, 
                          NOISE_ON_NO_RNG = 3,
                          NOISE_ON_SEMI_ANALYTICAL = 4, 
                          NOISE_ON_BIASED = 5}; 
                                                  
                                                          
#endif // _TYPE_AMPLIFIER_NOISE_

#endif /* _OCS_TYPE_AMPLIFIER_ */

enum typeGainProfile { FLAT_GAIN = 1,  RIPPLED_GAIN = 2, 
                       USER_DEFINED_GAIN_PROFILE = 3,
                       FLAT_GAIN_INSIDE_BANDWIDTH = 4,
                                           HOMOGENEOUS_MODEL = 5 };

// The OptAmplifier class has been written by Ivan Lima and 
// John Zweck. It can be used for any of the following:

// As a general rule, the user should only use the constructor and the  
// the methods

// SetTypeAmplifier(typeAmplifier TypeAmplifier2)
// SetTypeAmplifierNoise(typeAmplifier TypeAmplifierNoise2)
// SetTypeGainProfile(typeGainProfile TypeGainProfile2)
 
// AmplifyOptSignal(void)

// The enum types  typeAmplifier and  typeAmplifierNoise are defined in
// ocsGlobalStructures.hh. 

// Possible values for typeAmplifier are 

// NO_AMPLIFICATION
// SCALAR_SIMPLE
// VECTOR_SIMPLE
// SCALAR_SATURATED
// VECTOR_SATURATED
// VECTOR_FIXED_OUTPUT_POWER


// Possible values for typeAmplifierNoise are 

// NOISE_OFF
// NOISE_ON
// NOISE_ON_GAUSSIAN_WHITE 
// NOISE_ON_SEMI_ANALYTICAL
// NOISE_ON_BIASED              added by walter for MMC and importance sampling
//                              simulation


// NOTE: Users should use SCALAR amps with NOISE_ON with great caution!!!!!!
// The code has not been debugged in this situation.

// If the propagation along the fiber is scalar 
// (i.e. only the X polarization is being propagated) then the user should
// use one of the two SCALAR options above.

// Possible values for typeGainProfile are

// FLAT_GAIN
// RIPPLED_GAIN
// USER_DEFINED_GAIN_PROFILE
// FLAT_GAIN_INSIDE_BANDWIDTH

// CAUTION: Currently USER_DEFINED_GAIN_PROFILE has not been 
// implemented while RIPPLED_GAIN only works for the
// VECTOR_FIXED_OUTPUT_POWER type of amplifier.


// The saturated amplifier code has been extensively tested 
// both as an isolated device and as a component of a large system.
// These tests were made by comparing a system which was simulated
// using the OCS code with an experimental system in Gary Carter's lab.
// In particular, we obtained excellent agreement between simulation 
// and experiment for the evolution of both the noise-power
//  and the signal-to-noise ratio.

// The method WriteSteadyStateGainVersusPower can be used to
// estimate the two basic parameters, UnsaturatedGaindB and SaturatingPowerdB,
// of the 

// The saturating amplifier model has two basic parameters, 
// UnsaturatedGaindB and SaturatingPowerdB. These can be estimated
// from experimental data using the WriteSteadyStateGainVersusPower
// method which gives GaindB versus InputPowerdB.

// Note that the parameter SaturatingPowerdB is not the "3dB down"
// power level, but rather is an intrinsic parameter of the ODE 
// which describes the evolution of power along the amplifier's fiber.

// FUTURE IMPROVEMENTS:

// (1) Allow SaturatingPower_3dB_down as an input parameter
// (2) Add ability to have a gain profile (Gain versus wavelength)
//     which is often important for WDM simulations.
// (3) Implement the coupled amplifier model described in Ruo-Mei's
//     "Theory versus Experiment" paper which should be used in the 
//      situation that the relaxation time of the amplifiers in a 
//      recirculating loop is comparable to the time required for
//      light to travel around the loop.
// (4) Add Moshe Horowitz n_sp model for high gain amps.

class OptAmplifier
{
   public:

     // The following TWO methods are now OUT OF DATE (JZ)

      //OptAmplifier(); 
      ~OptAmplifier(); //## Do nothing, for now.
      //void GetAmplifierSample(long *fSeedNoise); // to be implemented  

      void SetFixedOutputPowerFromCurrentOptSignal(void);
      void SetFixedTotalOutputPowerFromCurrentOptSignal(void);

      void SetPolDepGain(double PolDepGainOptAmplifier2)
                    {PolDepGainOptAmplifier = PolDepGainOptAmplifier2;};
      double GetPolDepGain(void) 
                {return PolDepGainOptAmplifier;};

      void SetGainCompressionSaturatedAmplifier(
                   double GainTarget_dB, double GainCompression_dB, 
                   double OutputPowerTarget);
                
      double GetSpectralNoisePowerDensityAddedPerPolarization(void)
                {return (sq(NoiseAmplitudeFactor)*CenterFreq
                         /DeltaFreq);};
                         
      void AmplifyAlternateOptSignalWithoutNoiseWithPrevioslyComputedGain(
              OptSignal *oOptSignal2);                   

      void SwitchOptSignalData(OptSignal *oOptSignal2);

      typeAmplifier GetTypeAmplifier(void)
             {return TypeAmplifier;};

      typeAmplifierNoise GetTypeAmplifierNoise(void)
             {return TypeAmplifierNoise;};


      double GetLinearGainOptAmplif(void)
            {return LinearGainOptAmplif;};

      double GetFixedTotalOutputPower(void) 
             {return OutputPowerLinear;};

      void SetFixedTotalOutputPower(double OutputPowerLinear2) 
             {OutputPowerLinear = OutputPowerLinear2;};

      void SetLinearGainOptAmplif(double Value)
             { LinearGainOptAmplif = Value; };

      void SetNoiseAmplitudeFactor(double Value);

      double GetNoiseAmplitudeFactor(void)
             {return NoiseAmplitudeFactor;};

     // #########  Methods Added by John Zweck ############


       // Use this constructor from now on:

       OptAmplifier(string InFileName,OptSignal *oOptSignal2, RanNumGen *RNG2);
       OptAmplifier(string InFileName,OptSignal *oOptSignal2, RanNumGen *RNG2,
                    OptSpectrumAnalyzer *PowerMeter2);

       void SetGain(double dBGain2);

       void SetTypeAmplifier(typeAmplifier TypeAmplifier2);
       void SetTypeAmplifierNoise(typeAmplifierNoise TypeAmplifierNoise2);
       void SetTypeGainProfile(typeGainProfile TypeGainProfile2);

       string WriteTypeAmplifier(void);
       string WriteTypeAmplifierNoise(void);
       string WriteTypeGainProfile(void);

       void AmplifyOptSignal(void);

       void WriteSteadyStateGainVersusPower(string OutFileName,
                        double InputPowerMaxLinear, int NumPowerSteps);

      void WriteGainProfile(string OutFileName);


       double GetSaturatingPowerLinear(void){return SaturatingPowerLinear;}; 

      double GetdBGain() {return dBGain;};

      void SetDebugLevel(int Level) {DebugLevel = Level;};

// used by Jonathan Hu
        OptAmplifier(string InDir2, string InFileName, 
                           OptSignal *oOptSignal2, RanNumGen *RNG2);

        OptAmplifier(string InDir2, string InFileName, 
                     OptSignal *oOptSignal2, double * InputS, 
                     RanNumGen *RNG2, double F, double TotalTime2, 
                     int DataPointInCye2);
                                                   
        void PropagateSignalandNoise(OptSignal *NoiseFreeSignal,
                                     OptSignal * Noise);
                                   
        void ReadGainProfile(string InFileName, int SignalPowerInputIndex);
        void ReadGainPowerDependent(string InFileName);
        void ReadInEDFAGain(string InDir3);
        void ReadInGainFlatenFilter(string InFileName);
        void ReadInPolynomialFilter(string InFileName);
                
        void ReadInErParameter(string InDir3);
                
        void Loss(double Loss);
        void AmplitudeFluctuation();
        void ResetTransient(double F, double TT);

  double GetSignalEms(double Wavelength);
  double GetSignalAbs(double Wavelength);
  
  double GetPumpPowerSystem0dB();
  double GetPumpPowerTransparency();
  void SetPumpPower(double Power);
  void CalculateAverageN2T(int IntStepT);
  void CalculateGain();

  double GetGainFlatenFilter(double Wavelength);
  double GetPolynomialFilter(double Wavelength);

  void ApplyGainFlatenFilter();  

// for transit
        void ChannelAddDrop();
        void ForwardTSignalStep(int StepsT);
        void ForwardTPumpStep(int StepsT);
        void ForwardTPumpSignalStep(int StepT);
        
        void ApplyPolynomial();
    void SetAmpLength(double AmpLength2);
    void SetPumpPowerTime(double PumpPowerT);
    void SetSaturationFactorAdjuctment(double SA);
        void SetEMSAdjustGA(double EMSAdjustGA2);
        void SetABSAdjustGA(double ABSAdjustGA2);

    void AmplifyOptSignalScalarSinTim();
        void AmplifyOptSignalScalarSinFreq();


  // added By Walter for MMC and importance sampling simulation  
   void SetBiasedNoiseVector(double* z_try, int dimension,
                             int AddBiasedNoiseFlag);

   void WriteFileBiasedNoiseTime(string PathAndFileName);

   void WriteFileBiasedNoiseFreq(string PathAndFileName);
   
        void TimeShiftBiasedNoise(int NumOfBitSlots);
                                    
   double GetSpontaneousEmissionFactor() 
          {return SpontaneousEmissionFactor;};

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

 private:

// used by Jonathan Hu
// used by Jonathan Hu
  void PropagatSignal();
  double GetEDFAGain(double Wavel, double SignalPower, double PumpPowerC);
  void AmplifyWithUserDefinedGain();
  void ReleaseMemory();
  double GetAttenuationFiber(double Wavelength);
  void FirstGuessForward(int IntStepI, double * PreSig, double * PrePum, 
                         double * PreNoi);
  double OptimizeForward(int IntStepI, double * PreSig, double * PrePum, 
                         double * PreNoi);
  void CalculateUpperN(int IntStepI, double * SigPower, double * PumPower, 
                       double * NoiPower);
  void ForwardStep(int StepI);
  void BackwardStep(int StepI);
  void AmplifyHomogeneous();
  double GetPumpAbs(double Wavelength);

  double GetPumpEms(double Wavlength) {return(0.0);};
  void ReadPumpCrossSection(string InDir4);
  void ReadSignalCrossSection(string InDir4);

  double PumpCurrent2Power(double Current);

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

  void AmplifyWithFlatGain(void);
  void AmplifyWithRippledGain(void);
  void ComputeNoiseAmplitudeFactor(void);

  void AdjustGainFixedTotalOutputPowerVector(void);

  void AmplifyOptSignalVector(void);   
  void AddPolDepGainEffect(void);

  void AmplifyOptSignalScalar(void); 
         // Use above method in conjunction with scalar NLS solver
         // Only operates on the X polarization

 double AmplifyOptSignalSteadyStateSaturatedGain(int ScalarNotVectorFlag);
        // Flag == 1 means using a scalar NLS solver with X polarization only
        // Flag == 0 means using a vector-NLS or Manakov solver with X&Y pols

  void AmplifyGaussianStatisticsNoise(void);

 double SteadyStateSaturatedGain(double InputPower);

 void ComputeGainForFixedOutputPower(void);
 void ComputeGainForFixedOutputPower_OLD(void);
 void ComputeGainForFixedTotalOutputPower(void);

 void AmplifyOptSignalVectorWithGainProfile(void);
 void ComputeNoiseAmplitudeFactorGainProfile(void);
 void AllocateGainProfileMemory();
 void AddRippleToGain(void); 



  // ######### Private Data ##############
           
   private:
      void SetPolDepGainPolarization(void);
      void PolDepAmplification(void);   
      double LinearGainOptAmplif;
      double GainBandwidthHz, GainMinRelFreqHz, GainMaxRelFreqHz;
      double LinearNoiseFigOptAmplif;
      double NoiseAmplitudeFactor;

      double UserSpecifiedNoiseAmplitudeFactor;

      bool UserHasSpecifiedNoiseAmplitudeFactorFlag;

      double ModeOptAmplif; // Out of date
          double GetTempDepFactor(double Wavelength);

      typeAmplifier TypeAmplifier;
      typeAmplifierNoise TypeAmplifierNoise;
      typeGainProfile TypeGainProfile;
      typeSimulation TypeSimulation;

      double NoiseFigOptAmplifier;
      double SpontaneousEmissionFactor;

      double dBGain;
      double OutputPowerLinear;

      RanNumGen *RNG;      
      OptSignal *oOptSignal;
      OptSpectrumAnalyzer *PowerMeter ;
      PolDepAttenuator oPolDepAttenuator;

      ReduOptAmplifier * oReduOptAmplifier;

      double PolDepGainOptAmplifier;  
      //double *PolDepGainOrigPhase;
      double PolDepGain_thetaZthetaY[2];      

      cfftw *fft;
      fftMatrices sfftM;
      int qtPoints;
      double CenterFreq;
      double DeltaFreq;
      int    ObjectInitialized;

      int DebugLevel; // 1,2,3 with 3 spooling most info to LogFile

  // Variables for Gain Saturated Amplifiers
  // See SteadyStateSaturatedGain method for definitions of these
  // variables (JZ)

      double AmpLength;
      int NumZSteps;     
      double SaturatingPowerLinear;
      double SaturatingPowerdBm;
      
      double UnsaturatedGaindB;
      double UnsaturatedGainLinear;
      double UnsaturatedDifferentialGainLinear;

  // Variables related to non-flat gain profiles

  double * LinearGainProfile;
  double RippleAmplitudeLinear;
  double RipplePeriod;
  double RelativeRippleShift;
  double LinearGainFixedTotalOutputPower;
  
  // variables used by Joanthan Hu

 
  int TotPumpPowerIndex;

  int TotSignalPowerIndex;
  int NumGainWidth,NumGainWidthDep;
  double AmplifierPumpPowerC;
  double * oEDFAGain;
  double * oEDFAGainPowerDependent;
  int    ObjectInitializedJH;  
  string InDir;
  double StartWavelength;
  double DeltaWavelength;
  double StartPumpPower;
  double DeltaPumpPower;
  double MidPower;
  
  double PumpPowerSystem0dB;
  double PumpPowerTransparency;
  
  int PumpWavelengthForGain; 
  double WavelengthStartCrossSection;
  double WavelengthStepCrossSection;
  int NumCrossSectionWidth;

  double * oSignalPower;
  double * oPumpPower;
  double * oSignalWaveLth;
  double * oPumpWaveLth;
  int NumSigCh, NumPumCh, NumNoiCh;
  double * oSignalAbs;
  double * oSignalEms;
  double PumpABS;
  double * oPumpAbs;
  double * oNoiseWaveLth;
  double * oNoiseFPower;
  double * oNoiseBPower;
  
  double  WavelengthStartFilter;
  double  WavelengthStepFilter;
  int  NumFilterWidth;
  double * oGainFlatenFilter;
 

  double  WavelengthStartPolynomialFilter;
  double  WavelengthStepPolynomialFilter;
  int  NumPolynomialFilterWidth;
  double * oPolynomialFilter;

  double PumpPowerFactor;
  
 double DeltaWave;
 double ConfinementFactor;
 double AttenuationFiber;        
 double DopantConcentration;
 double EffectArea;
 double LifeTime;
 double SaturationFactorAdjuctment;

// double AmpLength;
 double DeltaZ;
 int TypeIntergration;
 int NumIntItr;
 
 double UpperN,LowerN;
 double * UpperNBackward;

// following is for transit
        int NumTSteps;
        double DeltaT;
        double * IntrinsicSaturationPowerPump ; 
        double * IntrinsicSaturationPowerSignal;
        double * GainSig ;
        double * GainPum ;

        double * PumpInput ;
        double * AbsorptionLossSignal ;
        double * AbsorptionLossPump ; 
        
// used for Transient
        double * SignalInput;
        double * AverageN2T;
        double SaturationFactor;
        double TotalTime;
        int     DataPointInCye;
        double ABSAdjustGA;
        double EMSAdjustGA;

        int PolynomialFilterAppliedFlag;

  // added by Walter for MMC and importance sampling simulations
        cplx* BiasedNoise;


};

#endif /* _OCS_OPT_AMPLIFIER_HH_ */