ocsReduOptSignal.hh

Go to the documentation of this file.

// $Id: 
//###################################################################
//
//           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_REDU_OPT_SIGNAL_HH_
#define _OCS_REDU_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 "ocsReducedModelTools.hh"
#include "ocsReadWriteTools.hh"
#include "ocsRanNumGen.hh"
#include "ModulationFormats.hh"

#ifndef _OVERLOADED_OPERATORS_
#define _OVERLOADED_OPERATORS_
//## Added by Ivan Lima to make the source compatible with g++
//## Most of the new code consists of overloading operators

inline double log (int a);
inline double log(int a)
{
   return log( (double) a );
}

inline double sqrt(int a);
inline double sqrt(int a)
{
   return sqrt( (double) a );
}

// End of extra 
#endif   // _OVERLOADED_OPERATORS_



// ##### Class ReduOptSignal
class ReduOptSignal
{
   public:

      ReduOptSignal(string InFileName, 
                    double SignalNoiseBandwidth2);



      ReduOptSignal(string InFileName2,string JobName);


      ~ReduOptSignal();


      ReduOptSignal(ReduOptSignal & OrigReduOptSignal);


   ReduOptSignal & operator=(ReduOptSignal & RHS_ReduOptSignal);



  void AddReducedNoise(ReduOptSignal * ReduOptSignal1);


      void RegenerateReduOptSignal(void);


      void RegenerateReduOptSignal(double * OptPowerChannArray2);


      void RegenerateReduOptSignalVaryingPower(void);




      void DepolarizeReduNoise(void);


      void WriteFileOptSignal(char *outFile);


      void WriteMatlabFileOptSignal(string OutFileName);


 
 
     void SetOptElecFilterBandwidth
                   ( double OptFilterBandwidthTmp
                    ,double ElecFilterBandwidthTmp);

 
     void SetOptElecFilterBandwidth
                   ( string FileNameOptFilter
                    ,string FileNameElecFilter);

      void SetEnhancementFactor(double EnhancementFactorTmp)
           {EnhancementFactor = EnhancementFactorTmp;};    

      double GetChannSpacing(void) {return ChannSpacing;}; 

      double GetSignalNoiseBandwidth(void) 
             {return SignalNoiseBandwidth;};



      double GetDegreeOfPolarization(void);


      double GetTotalPower(void);


      double GetSignalPower(void);


      const char * WriteTypePulse(void);




      double GetQ_Factor(int ChannelArrayIndex);

      double GetBitErrorRate(double Q_Factor) {return 
                exp(-sq(Q_Factor)/2)/(Q_Factor*sqrt(2*pi));};


      double GetOptSNR(int ChannelArrayIndex);

      double GetSignal(int ChannelArrayIndex) 
         {return StokesSignal[0][ChannelArrayIndex];};


      void GetTotalStokes( double *StokesTotal);


      double GetStokesSignal(int StokesIndex,
                             int ChannelArrayIndex)
         {return StokesSignal[StokesIndex][ChannelArrayIndex]
                /StokesSignal[0][ChannelArrayIndex];
         };
       

      double GetNoiseInsideChannel(int ChannelArrayIndex);
      double GetScalarProdSignalNoise(int ChannelArrayIndex);      
      double GetCoPolarizedNoiseInsideChannel(int ChannelArrayIndex);
      double GetOrthogPolarizedNoiseInsideChannel(int ChannelArrayIndex);            
 

      double GetStokesNoiseInsideChannel(int StokesIndex,
                             int ChannelArrayIndex)
         {
         //return StokesNoise[StokesIndex][ChannelArrayIndex]
         //       /StokesNoise[0][ChannelArrayIndex];
            return GetStokesNoise(StokesIndex,ChannelArrayIndex);
         };

      double GetStokesNoise(int StokesIndex,
                             int ChannelArrayIndex)
         {return StokesNoise[StokesIndex][ChannelArrayIndex]
                /( StokesNoise[0][ChannelArrayIndex] );
            //      +StokesExtraUnpolChannNoise/NumChannels );
         };

  

      double GetNoiseInsideBandwidth(int ChannelArrayIndex,
                                     double BandwidthNoise);


      double GetTotalNoiseSpectralDensity(void)
        { return GetNoiseInsideBandwidth(0,1.0);};

      double GetCoPolarizedNoiseInsideBandwidth(int ChannelArrayIndex,
                                              double BandwidthNoise );
      double GetOrthogPolarizedNoiseInsideBandwidth(int ChannelArrayIndex,
                                              double BandwidthNoise );
                                              
      double GetNormSignalNoiseBeatingCopolarized(int ChannelArrayIndex);
                                              
      double GetNormSignalNoiseBeatingOrthogPolarized(int ChannelArrayIndex);



      double GetElecTimeDomainSNR(int ChannelArrayIndex);


      double GetOutageProbGaussian(double MeanPenalty, 
                   double StdDevPenalty, double MaxAcceptablePenalty);


      void SetNumChannels(int NumChannels2);
      void SetOptPowerChannel(double OptPowerChann2) 
            {OptPowerChann = OptPowerChann2;};      

      int GetNumChannels(void) {return NumChannels;};
      double GetOptPowerChann(void) {return OptPowerChann;};
      double GetBitRateChann(void)  {return BitRateChann;};


      int GetChannelArrayIndex(int ChannelPhysicalIndex);


      int GetChannelPhysicalIndex(int ChannelArrayIndex);


      double GetCenterFreq(void) {return CenterFreq;};


      double GetFrequency(int ChannelArrayIndex) 
             {return Frequency[ChannelArrayIndex];};

  
      double GetEnhancementFactor(void)
             {return EnhancementFactor;};    



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


      double GetInStokes( const int ChannelArrayIndex
                         ,const int StokesIndex);



      // ## These vectors contain the actual data


      double *StokesSignal[4];


      double *StokesNoise[4];

   private:

      // ## Private Methods


      void AllocateMemory(void);


      void ReleaseMemory(void);


      void ProcessReduOptSignalParameters(ifstream *InFile);


      void InitializeInStokes(ifstream * InFile);



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



      void SetInStokes( const int ChannelArrayIndex 
                       ,const int StokesIndex 
                       ,double StokesValue);  


      double *GetInStokes(const int ChannelArrayIndex);



  void ReadFileFreqPower(string FrequencyDataInFileName);


      // ## Private data


      typePulse TypePulse;


      double CenterFreq;


      double CenterWavelength;

      int NumChannels;


      double ChannSpacing;


      double SignalNoiseBandwidth;



      double BitRateChann;


      double OptPowerChann; 


      double * OptPowerChannArray; 



      double *InStokes;


      double OptFilterBandwidth;


      double ElecFilterBandwidth;


      double EnhancementFactor;


      string InFileName;


      double *Frequency;

};

#endif // _OCS_REDU_OPT_SIGNAL_HH_