ocsHistogram.hh

Go to the documentation of this file.

// $Id: ocsHistogram.hh,v 1.2 2005/07/06 16:27:58 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_HISTOGRAM_HH_
#define  _OCS_HISTOGRAM_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"


// ##### Class Histogram


class Histogram
{
   public:


      Histogram() {};


      Histogram(int qtBins2,double MinRange2, double MaxRange2);


      Histogram(string InFileName);


      void InitHistogram(string InFileName);


      ~Histogram();

      void ReleaseMemory(void);


      void ClearHistogram(void);



      void AddSample(double vSample);


      void AddImportantSample(double vSample, double LikelihoodRatio);


      void ImportData(string InFileName, int Column,int qtColumns);


      void ImportData(string InFileName);


      void SetFileNameWithSamples(string FileNameWithSamples2);



      void Obtain_pdf(void); // the pdf will be pdfY:  pdfX x pdfY



      //void InitBalanceHeuristicDataStorage(double BiasingParam2,
      //                                     int qtRamdomSourcesPerSample2); 


      void MultipleHeuristicBalanceImport(string InFileName, 
                                          int Convert2dB_Scale);

      void MergeMultipleConditionalHeuristicBalance(string InFileName, 
                                          double z_min, double z_max,
                                          int Convert2dB_Scale);


      void MergeMultipleConditionalHeuristicBalance(string InFileName, 
                                          double z_min, double z_max,
                                          double w_min, double w_max,
                                          int Convert2dB_Scale);


      //void MultipleBalanceHeuristicImport(string InFileName); //## Best



      void MultipleWeightedImport(string InFileName);


      void MultipleSelectMaxRelNumHitsImport(string InFileName,
                                             int Convert2dB_Scale);


      void MultipleSelectiveImport(string InFileName);


      void ConditionalMultipleSelectiveImport(string InFileName,
                                              int Convert2dB_Scale);

      void MultipleImport(string InFileName, int Convert2dB_Scale);


      void MultipleUnbiasedImport(string InFileName);



      void WriteFile_pdf(string OutFileName);


      void WriteFile_cdf(string OutFileName);


      void WriteFile_cdfc(string OutFileName);


      void WriteFileQtSamplesBin(string OutFileName);


      void WriteFileBinValues(string OutFileName);



      void WriteFilePDF(string OutFileName);


      void WriteFileMaxwell_pdf(string OutFileName, int qtPoints);    
 

     void WriteFileSndOrderPDV_pdf(string OutFileName, int qtPoints);
  

      void WriteFileGaussian_pdf(string OutFileName, int qtPoints);      
      void WriteFileGaussian_cdf(string OutFileName, int qtPoints);
      void WriteFileGaussian_cdfc(string OutFileName, int qtPoints);

      int GetQtBins(void) {return qtBins;};
      double GetMinRange(void) {return MinRange;};
      double GetMaxRange(void) {return MaxRange;};
      long GetQtSamples(void) {return qtSamples;};     
      long GetQtSamplesInRange(void) {return qtSamplesInRange;};        

      void SetBin(int NumBin, double ValueBin) 
            { Bin[NumBin] = ValueBin;}; //## Be careful with this!!!
      double GetBin(int NumBin) {return Bin[NumBin];};
      double Get_cdfBin(int NumBin) {return cdfBin[NumBin];};
      double Get_cdfcBin(int NumBin) {return cdfcBin[NumBin];};            
      int GetIndex_pdf(double vSample);      
      long GetQtSamplesBin(int NumBin) {return qtSamplesBin[NumBin];};
      double GetSumLikelihoodRatio(void) {return SumLikelihoodRatio;};
      double GetMean(void) {return MeanTmp
                            /SumLikelihoodRatio;};
      double GetMeanSquare(void) {return MeanSquareTmp
                                  /SumLikelihoodRatio;};


      double GetStdDev(void);      
      double GetMinSample() {return MinSample;};
      double GetMaxSample() {return MaxSample;};


      double GetSumProbabilities(void); 

      double Get_pdfX(int ii) {return pdfX[ii];};
      double Get_pdfY(int ii) {return pdfY[ii];};
      double Get_pdfConfidence(int ii) {return pdfConfidence[ii];};
      double Get_cdfConfidence(int ii) {return cdfConfidence[ii];};      
      double Get_cdfcConfidence(int ii) {return cdfcConfidence[ii];};       
   private:   


      void InitHistogram(int qtBins2,double MinRange2, double MaxRange2);



      int ObjectInitialized;

      int Index_pdf;


      int MakeFileWithSamples;

      

      string FileNameWithSamples;


      string HistInFileName;

      int qtBins;

      int qtBinsLast;


      double MinRange;


      double MaxRange;
  

      double *Bin;



      double *BinSquare;


   double *cdfBin;
   
   double *cdfcBin;  //## For the computation of the outage probability
   
   double *cdfBinSquare;
   
   double *cdfcBinSquare;

      long *qtSamplesBin;


      long qtSamples;


      long qtSamplesInRange; 

      double SumLikelihoodRatio;  

      double SumUnitaryLikelihoodRatio;

      

      double *pdfX;

       double  *pdfY;
       

       double  *pdfConfidence;             
       int PreviouslyComputed_pdfConfidenceFlag;
       
       double *cdfConfidence;
       
       double *cdfcConfidence;

       double MeanTmp, MeanSquareTmp;

      double MinSample;
      double  MaxSample;   
      ofstream *OutFileWithSamples;
      double *ExpPolynomialCoef;


      int DebugLevel;
      
       /*
      //## Extra variables for the Heuristic Balance
      double BiasingParam;
      int qtRandomSourcesPerSample; 
      int BalanceHeuristicInitialized;
      */
};      


#endif /*  _OCS_HISTOGRAM_HH_ */