ocsOptSpectrumAnalyzer.hh

Go to the documentation of this file.

// $Id: ocsOptSpectrumAnalyzer.hh,v 1.2 2006/05/11 23:46:55 zweck Exp $

//###################################################################
//
//           Optical Communication Systems Simulator
//
//       Copyright (2001):
//       Optical Fiber Communications Laboratory (OFCL)
//       Computer Science & Electrical Engineering Department (CSEE)
//       University of Maryland Baltimore County (UMBC)
//
//###################################################################

#ifndef _OCS_OPT_SPECTRUM_ANALYZER_HH_
#define _OCS_OPT_SPECTRUM_ANALYZER_HH_

#include "ocsOptSignal.hh"

// Written by John Zweck, 10 Jan, 2001 (10/1/01).

// This class is an implementation of an optical spectrum analyzer (OSA).
// It was written to have two modes, Gaussian and Rectangular,
// corresponding to  two types of filters which can be used to average 
// the optical signal over a given input ResolutionBandwidthHz.
// (FIX: We should probably use ResolutionBandwidth_nm instead of 
// ResolutionBandwidthHz.)
// The choice of mode is determined by the variable OSAMode, with 1 being
// Gaussian and 2 being Rectangular.
// At this stage the Gaussian mode is fairly well tested. The rectangular
// mode is not quite so well tested, but it also simpler
// and so is probably less buggy.

// The Gaussian OSA does the following. Given a distance along the fiber
// it outputs the Gaussian-filtered optical spectrum at that distance,
// in the form of (wavelength, Power in dB) pairs. It also computes 
// the Signal-to-Noise ratio for each channel by taking the difference
// between the maximum power of the signal (in dB) and the maximum noise power
// in  two side bands, one on either side of the given channel. 
// (Code has also been written to compute average rather than maximum noise
// powers but this code (or its application?) still seems a little buggy to me.
//  In any case the maximum noise  value seems to be a good enough measure
// of the noise power.) The SNR's for each channel as well as associated
// quantities are output to a file in the method OutputSNR_OSA().

// To use the OSA in an application you just need to do the following.
// (1) For each distance you want to output the OSA and/or measure the SNR
//     you must construct an OSA object.
// (2) At the appropriate point in your application code you need to 
//     call the Update(double PropagatedLength2) method.
//     This method is usually called multiple times in the course of
//     a simulation, once per Monte Carlo experiment.
// (3) Either at the very end of the program, or periodically after 
//     a number of Monte Carlo experiments, the user can output the 
//     most recent estimates of the optical spectrum and the SNR by calling
//     the Output(int NumExpts) method.

// The Update() and Output() methods call other  methods
// in the OSA class which actually perform the required computations.

// The code has been tested in against a real experimental system in Gary 
// Carter's lab. We obtained very close agreement between simulation
// and experiment.

 

class OptSpectrumAnalyzer
{

 public:

 OptSpectrumAnalyzer(string InFileName,string Job2,
                     int AppendFlag2,OptSignal *oOptSignal2);

  // The following constructor is used in the OptAmplifier class

 OptSpectrumAnalyzer(OptSignal *oOptSignal2,
                     double ResolutionBandwidthHz2,
                     int ModeOSA2,
                     double SuperGaussExponent2);

 OptSpectrumAnalyzer(OptSignal *oOptSignal2,
                     double ResolutionBandwidthHz2,
                     int ModeOSA2,
                     double SuperGaussExponent2,
                     int TypeAmplifierNoise2);

  ~OptSpectrumAnalyzer();

  void AllocateMemory(void);
  void Update(double PropagatedLength2);
  void Output(int NumExpts);
  double GetPeakPowerdBm(int ChannelArrayIndex, int ExptNum);
  double GetValleyPowerdBm(int ChannelArrayIndex, int ExptNum);
  void  Clear();
  
 //void  UpdateSignalNoiseAverages(double PropagatedLength2);
 void  UpdateSNR_OSA(double PropagatedLength2);
 double ComputeAveragePowerFreqWindow(double LeftFreq,double RightFreq);

 void OutputSignalNoiseAverages(int NumExpts);
 void OutputSNR_OSA(int NumExpts);
 void OutputSNR_OSA(int NumExpts, string Str);
 void WriteFileOutputOSA( string OutFileName, int ExptNum);

 void UpdateOSA(double PropagatedLength2);

 void UpdateOSA_OLD(double PropagatedLength2);

 void ComputeAveragePowerFreqWindowOSA
          (double LeftFreq,double RightFreq,
           double *Average_Watts);

  double ComputeMaxPowerLinFreqWindowOSA(double LeftFreq,double RightFreq);

 double GetNoiseEquivalentBandwidth(void);

 void OutputOSA(int ExptNum);
void OutputOSA(int ExptNum, string Str);

  double GetSNR_OSA(int ChannelArrayIndex) //## Ivan Lima (6/4/01)
         {return GetSignalOSA(ChannelArrayIndex)
                /GetNoiseOSA(ChannelArrayIndex);};
  double GetSNRdB_OSA(int ChannelArrayIndex) //## Ivan Lima (6/4/01)
         {return GetSNR_OSA(ChannelArrayIndex);};
  double GetSignalOSA(int ChannelArrayIndex) //## Ivan Lima (6/4/01)
         {return SignalPeakLin[ChannelArrayIndex]
                -NoiseAverageLin[ChannelArrayIndex];};
  double GetNoiseOSA(int ChannelArrayIndex) //## Ivan Lima (6/4/01)
         {return NoiseAverageLin[ChannelArrayIndex];};
  double GetNoiseSpectralDensityOSA(int ChannelArrayIndex) //## IL (5/11/02)
         {return NoiseAverageLin[ChannelArrayIndex]
                /ResolutionBandwidthHz;};
  //## Interface to the old function with bad english
  double GetSpectralNoiseDensityOSA(int ChannelArrayIndex)
        {return GetNoiseSpectralDensityOSA(ChannelArrayIndex);};

  double GetResolutionBandwidthHz(void)
               {return ResolutionBandwidthHz;}; 

  void SwitchOptSignalData(OptSignal *oOptSignal2);


  // The following PowerMeter methods were written by John Zweck, Apr 9th 2001
  // The OSA can also be used as a simple power meter
  // Experimentalists often measure the power map using
  // the peak signal power per channel in an OSA.
  // The power meter is designed to do just this.


  void  RunPowerMeter(double PropagatedLength2);
  void  ClearPowerMeter(void);
  void  OutputPowerMeter(void);

  // The power meter is also used to compute the average input power
  // level of the signal (averaged over the channels) for use in
  // the FIXED_OUTPUT_POWER method for computing the gain in the
  // optical amplifier. 

  double AmpPowerMeterInputLinear(void);
  double PowerMeterComputeAverageSignalPowerLin(void);

  void SetJob(string Job2) { Job = Job2;};
  void SetResolutionBandwidthHz(double ResolutionBandwidthHz2)
                  {ResolutionBandwidthHz = ResolutionBandwidthHz2;};

  void SetSuperGaussExponent(double SuperGaussExponent2)
                       {SuperGaussExponent = SuperGaussExponent2;};

  void SetModeOSA(int ModeOSA2) { ModeOSA = ModeOSA2;};
  void SetTypeAmplifierNoise(int TypeAmplifierNoise2) 
                             {TypeAmplifierNoise = TypeAmplifierNoise2;};

  void SetPowerMeterFlag(int PowerMeterFlag2) 
      { PowerMeterFlag = PowerMeterFlag2;};


  int GetNumChanns(void) {return NumChannels;};

  double GetOSAOutputLinear(int ExptNum, double RelFreq);

 private:

  OptSignal * oOptSignal;

  cfftw *fft;

  cplx * fPowerSignal;
  cplx * fOSA;

  cplx * tPowerSignal;
  cplx * tOSA;


  int ModeOSA; // 1: Gaussian OSA, 2: Rectangular Channel SNR's
  int TypeAmplifierNoise;
  int PowerMeterFlag;  

  string Job;
  
  double PropagatedLength;
  double AppendFlag;

  double ResolutionBandwidthHz;

  double * SignalPeakLin;
  double * NoiseAverageLin;


  int NumChannels;
  int qtPoints;
  double DeltaFreq;
  double SuperGaussExponent;

};


#endif /* _OCS_OPT_SPECTRUM_ANALYZER_HH_ */