ocsBitString.hh

Go to the documentation of this file.

// $Id: ocsBitString.hh,v 1.1.1.1 2004/06/11 22:56:02 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_BIT_STRING_HH_
#define _OCS_BIT_STRING_HH_

enum typeBitString { ALL_ZEROS = 0, ALL_ONES = 1, SINGLE_ONE = 2,
                     RANDOM_SIMPLE = 3, RANDOM_EQUAL_ZEROS_ONES = 4,
                     PSEUDO_RANDOM = 5, USER_DEFINED = 6 };


#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 "ocsTools.hh"
#include "ocsReadWriteTools.hh"
#include "ocsRanNumGen.hh"


#include "StatisticsOfArray.hh"

#include <string>

// ##### Class BitString ############

// Written by John Zweck in October 2000 and Feb 2001.

// The BitString class is a helper class for the OptSignal class.
// It sets the BitString for the OptSignal. The type of BitString 
// is governed by the typeBitString enumerator which is declared
// in ocsGlobalStructures.hh. 

// The possible types of BitStrings are 

// ALL_ZEROS = 0
// ALL_ONES = 1
// SINGLE_ONE = 2
// RANDOM_SIMPLE = 3
// RANDOM_EQUAL_ZEROS_ONES = 4
// PSEUDO_RANDOM = 5
// USER_DEFINED = 6

 
class BitString
{

  // ### Public Methods ####

  public:

  
  BitString(ifstream * InFile, RanNumGen *RNG2); 
           // Constructor, called by OptSignal object

  BitString(BitString & oBitString); // Copy Constructor 

  BitString(BitString & BitString1,BitString & BitString2,RanNumGen *RNG3);
  // Constructor for sum of BitStrings

  friend void AddBitStrings(BitString * BitString1,
                            BitString * BitString2,
                            BitString * BitString3);


  BitString & operator=(BitString & RHS_BitString);
                  // assignment operator (JZ)

  ~BitString();

  void DeleteMemory(void);
  void ReallocateMemory(void);

  string WriteTypeBitString(void);


  int GetStringLength(void) {return StringLength;};
  int GetNumChannels(void) {return NumChannels;};
  void SetNumChannels(int value) {NumChannels = value;};


  int GetChannelPhysicalIndex(int ChannelArrayIndex);
  int GetChannelArrayIndex(int ChannelPhysicalIndex);

  void SetBit(int ChannelArrayIndex, int BitSlot, int BitValue); 
  int GetBit(int ChannelArrayIndex, int BitSlot); 

  void WriteBitString(void); // For debugging only

  string WriteBitString(int ChannelArrayIndex);

 // The following method can be used in a Monte Carlo simulation application
  // to get a new random string for the next MC experiment.
  // It will only do this if TypeBitString is one of the  RANDOM 
  // types. Otherwise it will not change the bit string at all.

  void GetRandomString();

  void SetAllZeros(int ChannelArrayIndex);
  void SetAllOnes(int ChannelArrayIndex);
  void SetSingleOne(int ChannelArrayIndex);
  
  void SetStringToSingleMarkPerChannel(void);

  // An OptDemuxer extracts a single channel signal from a WDM Signal.
  // The following method is used by the Demuxer to extract the BitString
  // of the extracted single channel signal  from the BitString of the
  // WDM Signal
  // Before calling this method we assume that the BitString object
  // is a multi-channel. The method changes the BitString to be 
  // single channel
  // In particular the parameter NumChannels is changed from 
  // NumChannels to 1 within this method.

  void ReduceToSingleChannelBitString(int ChannelArrayIndex);
  void ReduceToSingleChannelBitString(BitString * SCBitString);

  void AddBitStringBM(BitString & BitString2);


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

  string ReadString(string ParameterName, ifstream * InFile);

  void SetRandomString(int ChannelArrayIndex);
  void SetPseudoRandomString(int ChannelArrayIndex);
  void SetUserDefined(ifstream * InFile);

  //##  Allocate/release the bit string array
  //#  It is necessary to make conversions from
  //#  WDM to single channel in the demuxer. (IL)
  void AllocateBitStringArray(int NumChannels2);
  void ReleaseBitStringArray(void)
     { delete [] BitStringArray;};
  
  // ### Private Data ####

  private:

  typeBitString TypeBitString;

  int NumChannels;
  int StringLength; // Length of bit string in a single channel
  int * BitStringArray;  // Pointer to 1D array of length 
                        // NumChannels*StringLength which stores the BitStrings
                        // for all of the channels. Accessed using the methods
                        // SetBitString and GetBitString

  RanNumGen *RNG;

  int DebugLevel;
        // Typically debug level will be 1,2,3
        // The higher the level the more data is written to LogFile and cout.

}; // end class BitString

#endif /* _OCS_BIT_STRING_HH_ */