---

copy-ocsBitString.cc

Go to the documentation of this file.

// $Id: ocsBitString.cc,v 1.15 2001/08/30 18:05:34 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)
//
//###################################################################

// ## Written by John Zweck, Oct 12, 2000
// ## by adapting and extending code written by Ivan Lima


#include "ocsBitString.hh"

#include <strstream>

extern ofstream LogFile;

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

BitString::BitString(ifstream * InFile, RanNumGen *RNG2 )
{

  // Written by John Zweck.
  // Substantially rewritten on Feb 17th 2001 by JZ

  // IF YOU MODIFY THIS CONSTRUCTOR YOU MAY ALSO NEED TO MODIFY
  // BitString::BitString(BitString & oBitString1) 
  // BitString & BitString::operator=(BitString & RHS_BitString)
  //BitString(BitString & BitString1,BitString & BitString2,RanNumGen *RNG3);
  // It is assumed that the InFile has already been opened
  // by the OptSignal constructor which  calls this constructor

DebugLevel = ReadInt("DebugLevel"," ",0,-1,LOWER_ONLY,InFile);

RNG = RNG2;

NumChannels = ReadInt("NumChannels"," ",0,-1,LOWER_ONLY,InFile);
StringLength = ReadInt("StringLength"," ",1,-1,LOWER_ONLY,InFile);

TypeBitString = typeBitString(ReadInt("TypeBitString"," ",0,6,
                                       LOWER_AND_UPPER,InFile));

BitStringArray  = new int[StringLength*NumChannels];

if(!BitStringArray)
   {
     cerr << "Malloc error in BitString::BitString" << endl
          << "ABORTING NOW!!" << endl;
     exit(1);

   }


if(DebugLevel >= 1)
   {
     LogFile << "TypeBitString = " << WriteTypeBitString() << endl;
   }

if(DebugLevel >= 2)
   {
     LogFile << "NumChannels = " << NumChannels << endl;
     LogFile << "StringLength = " << StringLength << endl;
     LogFile << "DebugLevel = " << DebugLevel << endl;
   }

 switch(TypeBitString)
   {
     case ALL_ZEROS:
       for(int ch = 0; ch < NumChannels; ch++)
         SetAllZeros(ch);
       break;

     case ALL_ONES:
       for(int ch = 0; ch < NumChannels; ch++)
         SetAllOnes(ch);
       break;

     case SINGLE_ONE:
       for(int ch = 0; ch < NumChannels; ch++)
         SetSingleOne(ch);
       break;

     case USER_DEFINED:
       SetUserDefined(InFile);
       break;

   case RANDOM_SIMPLE: case RANDOM_EQUAL_ZEROS_ONES: case PSEUDO_RANDOM:
        GetRandomString();
        break;

   default:
       cerr << "BitString::BitString switch error" << endl
            << "ABORTING NOW!!" << endl;
       exit(1);

   } // ## end switch(TypeBitString)

 if(DebugLevel >= 3)
   WriteBitString();

} // ## end constructor

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

BitString::BitString(BitString & oBitString1) // Copy Constructor
{
  // NOTE: The BitStringChann1 is not being copied as it's 
  // not used after apply copy constructor and moreover
  // is soon to be a defunct parameter 

  NumChannels = oBitString1.NumChannels;
  StringLength = oBitString1.StringLength;
  TypeBitString = oBitString1.TypeBitString;
  DebugLevel = oBitString1.DebugLevel;
  RNG = oBitString1.RNG;  // We want to keep the same RanNumGen

  BitStringArray = new int[StringLength*NumChannels];

  for(int ch = 0; ch < NumChannels; ch++)
    for(int ii = 0; ii < StringLength; ii++)
      SetBit(ch,ii,oBitString1.GetBit(ch,ii));

}// end Copy Constructor

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

BitString & BitString::operator=(BitString & RHS_BitString)
{

  // This assignment operator assumes that the StringLength
  // and NumChannelsof the BitStrings on both sides of this function are
  // the same.

  /*
  cout << "NumChannels1 = " << NumChannels << endl;
  cout << "NumChannels2 = " << RHS_BitString.GetNumChannels() << endl;
  cout << "StringLength1 = " << StringLength << endl;
  cout << "StringLength2 = " << RHS_BitString.GetStringLength() << endl;
  */

 if( // NumChannels != RHS_BitString.GetNumChannels() ||
     StringLength != RHS_BitString.GetStringLength() )
    {
      LogFile << "Error in application of BitString::operator=" << endl 
              << flush;

      exit(1);
    }
  

  RNG = RHS_BitString.RNG;  // We want to keep the same RanNumGen
  
  TypeBitString = RHS_BitString.TypeBitString;

  DebugLevel = RHS_BitString.DebugLevel;

  for(int ch = 0; ch < NumChannels; ch++)
    for(int ii = 0; ii < StringLength; ii++)
      SetBit(ch,ii,RHS_BitString.GetBit(ch,ii));

  return *this;

}// end assigment operator

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

BitString::BitString(BitString & BitString1,BitString & BitString2,
                     RanNumGen *RNG3)
{


  RNG = RNG3;

  if(BitString1.GetStringLength() != BitString2.GetStringLength())
    {
      cerr << "BitString::BitString(BitString1,BitString2,RNG3):" << endl
           << "Incompatable parameters" << endl
          << "Aborting now!!" << endl;
     exit(1);
    }

  NumChannels = BitString1.NumChannels+BitString2.NumChannels;
  StringLength = BitString1.StringLength;
  TypeBitString = BitString1.TypeBitString;
  DebugLevel = BitString1.DebugLevel;
  

  BitStringArray = new int[StringLength*NumChannels];

  int ch,mm;

 for(ch=0;ch<BitString1.NumChannels;ch++)
   { 
     for(mm=0;mm<StringLength;mm++)
       SetBit(ch,mm,BitString1.GetBit(ch,mm));
   }

 for(ch=BitString1.NumChannels;ch<NumChannels;ch++)
  {
   for(mm=0;mm<StringLength;mm++)
     SetBit(ch,mm,BitString2.GetBit(ch-BitString1.NumChannels,mm));
   
  }

 if(DebugLevel >=3)
   { 
    BitString1.WriteBitString();
    BitString2.WriteBitString();
    WriteBitString();
   }

} // ## end Sum BitString constructor



//#############################################
//## Allocate the bit string array
//#  It is necessary to make conversions from
//#  WDM to single channel in the demuxer
//#  Thus, it should be used with attention.
//## By: Ivan Lima (7/9/01)
void BitString::AllocateBitStringArray(int NumChannels2)
{
   NumChannels = NumChannels2;
   BitStringArray = new int[StringLength*NumChannels];
}


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

void AddBitStrings(BitString * BitString1,
                   BitString * BitString2,
                   BitString * BitString3)
{

   if(BitString3->NumChannels != BitString1->NumChannels + 
                                BitString2->NumChannels)
    {
      cerr << "BitString::AddBitStrings: Incompatable parameters. ABORT!"
           << endl;
      exit(1);
    }


  int ch,mm;

 for(ch=0;ch<BitString1->NumChannels;ch++)
   { 
     for(mm=0;mm<BitString3->StringLength;mm++)
       BitString3->SetBit(ch,mm,BitString1->GetBit(ch,mm));
   }

 for(ch=BitString1->NumChannels;ch<BitString3->NumChannels;ch++)
  {
   for(mm=0;mm<BitString3->StringLength;mm++)
     BitString3->SetBit(ch,mm,
                 BitString2->GetBit(ch-BitString1->NumChannels,mm));
   
  }

 /*
    BitString1->WriteBitString();
    BitString2->WriteBitString();
    BitString3->WriteBitString();
 */

} // ## end AddBitStrings

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

BitString::~BitString()
{

  delete [] BitStringArray;

}

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

string BitString::WriteTypeBitString(void)
{

  string Type;

  switch(TypeBitString)
   {

    case ALL_ZEROS: Type = "ALL_ZEROS"; break;
    case ALL_ONES:  Type = "ALL_ONES"; break;
    case SINGLE_ONE: Type = "SINGLE_ONE"; break;
    case RANDOM_SIMPLE: Type = "RANDOM_SIMPLE"; break;
    case RANDOM_EQUAL_ZEROS_ONES: Type = "RANDOM_EQUAL_ZEROS_ONES"; break;
    case PSEUDO_RANDOM: Type = "PSEUDO_RANDOM"; break;
    case USER_DEFINED: Type = "USER_DEFINED"; break;
    default:
       cerr << "Invalid TypeBitString in BitString::WriteTypeBitString"
            << endl
            << "ABORTING NOW!!" << endl;

       exit(1);

   }// ## end switch

  return Type;

}

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

void BitString::SetBit(int ChannelArrayIndex, int BitSlot, int BitValue)
{
 //## Written by John Zweck Oct 11, 2000

  // ## FIX: Add bounds checking!!

  BitStringArray[BitSlot + ChannelArrayIndex*StringLength] = BitValue;

}

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

int BitString::GetBit(int ChannelArrayIndex, int BitSlot)
{
  //## Written by John Zweck Oct 11, 2000

 // ## FIX: Add bounds checking!!

 return BitStringArray[BitSlot + ChannelArrayIndex*StringLength];

}

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


void BitString::SetRandomString(int ChannelArrayIndex)
{
  // Generates a random string  
  // Created by Ivan Lima
  // Adapted by John Zweck, Nov 8, 2000
  // Further adapted by John Zweck, Feb 17th, 2001

  switch(TypeBitString)
    {

    case RANDOM_SIMPLE:

      for ( int ii = 0; ii < StringLength ; ii++ ) 
        {
         if (RNG->GetRanNum() <= 0.5) 
           SetBit(ChannelArrayIndex,ii,0);         
         else
           SetBit(ChannelArrayIndex,ii,1);
  
        } // end for-loops

      break;

    case RANDOM_EQUAL_ZEROS_ONES:

    {

      // Aside; We need the {} block to get around a scoping
      // problem within the switch.

      double * RanNumArray;

      RanNumArray = new double[StringLength];

      for(int ii = 0; ii < StringLength; ii++)
        RanNumArray[ii] = RNG->GetRanNum();

      StatisticsOfArray Stats(StringLength,RanNumArray);

      for ( int ii = 0; ii < StringLength ; ii++ ) 
        {
         if (RanNumArray[ii] <= Stats.GetMedian()) 
           SetBit(ChannelArrayIndex,ii,0);         
         else
           SetBit(ChannelArrayIndex,ii,1);
  
        } // end for-loop

       delete [] RanNumArray;
    }

      break;

    case PSEUDO_RANDOM:


      cerr << "BitString::SetRandomString" << endl
           << "Option PSEUDO_RANDOM not implemented yet" << endl
           << "ABORTING NOW!!" <<  endl;

      exit(1);

      break;

    default: 

      cerr << "BitString::SetRandomString" << endl
           << "Invalid switch option" << endl
           << "ABORTING NOW!!" <<  endl;

      exit(1);

    } // ## end switch


} //## end SetRandomString(int ChannelArrayIndex)

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

void BitString::SetPseudoRandomString(int ChannelArrayIndex)
{
  //  Written by Brian Marks
  //  Last modified 17/05/2001
  // 
  //  Generates a PseudoRandom Bit String for the channel ChannelArrayIndex.
  //  Currently, this routine only supports bit strings of the length of a 
  //  power of 2, and currently only between 2^3 and 2^16 inclusively.  
  //  Pseudorandom strings shorter than this length do not make much sense, 
  //  and it would be straight forward to add the capability to make strings
  //  longer than this.  However, do we ever need to simulate more than 65536
  //  bits anyway?  
  //
  //  Truthfully, this routine creates a so-called DeBruijn string, which 
  //  accounts for all patterns of length PatternLength (n in 2^n) =including=
  //  the pattern of all 0s.  This is done by setting the seed for the 
  //  random pattern to [1 0 0 ... 0].  
  //  FIX: Add capability of arbitrary seed for 2^n-1 PRBS.
 
  int PatternLength;
  int next;
  
  //  The following creates the mask for XOR addition to find successive
  //  bits in the sequence.  That is, this represents the primitive polynomials
  //  of various orders to generate the sequence for various PatternLength.
  int mask[16][16] = { {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},        
                        // n = 1?
                       {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},        
                        // n = 2?
                       {0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},        
                        // x^3 + x^2 + 1
                       {1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},  
                        // x^4 + x + 1
                       {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},        
                        // x^5 + x^2 + 1
                       {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},        
                        // x^6 + x + 1
                       {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},  
                        // x^7 + x^6 + 1
                       {0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
                        // x^8 + x^4 + x^3 + x^2 + 1
                       {0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},        
                        // x^9 + x^5 + 1
                       {0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}, 
                        // x^10 + x^3 + 1
                       {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
                        // x^11 + x^2 + 1
                       {1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0},
                        // x^12 + x^6 + x^4 + x + 1
                       {1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
                        // x^13 + x^4 + x^3 + x + 1
                       {1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0},
                        // x^14 + x^10 + x^6 + x + 1
                       {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
                        // x^15 + x + 1
                       {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1}
                        // x^16 + x^12 + x^3 + x + 1            
                       };
                       
                       
  
  PatternLength = (int)rint(log(StringLength) / log(2.0));
  
  int seed[PatternLength];


  //  This sets the seed to [1 0 0 ... 0] for the DeBruijn pattern.  
  for ( int ii = 0; ii < PatternLength; ii++ )
    seed[ii] = 0; 
  seed[0] = 1;
  
  
  if (abs((log(StringLength) / log(2.0)) - PatternLength) > 1.0e-14)
  {
    cerr << "BitString::SetPseudoRandomString" << endl
         << "Requires string length of a power of 2." << endl
         << "ABORTING NOW!!" << endl;
 
    exit(1);
  }

  if (PatternLength < 3 || PatternLength > 16) 
  {
    cerr << "BitString::SetPseudoRandomString" << endl
         << "Currently only supports patterns of length between 3"
         << " and 16" << endl
         << "(StringLength between 8 and 65536)" << endl
         << "ABORTING NOW!!" << endl;
         
         exit(1);
  }  
  
  //  For the DeBruijn pattern, the first bit is always 0, followed by the seed.
  SetBit(ChannelArrayIndex, StringLength-1, 0);
  for ( int ii = 0; ii < PatternLength; ii++ )
    SetBit(ChannelArrayIndex, StringLength-2-ii, seed[PatternLength-1-ii]);
   
  for ( int ii = StringLength - PatternLength - 2; ii >= 0; ii-- )
    {
        // The following does the XOR addition to find the next bit
        next = 0;
        for ( int jj = 0; jj < PatternLength; jj++ )
          next += (mask[PatternLength-1][jj] * seed[jj]);
        next = next % 2;
        
        // The following does a one-bit shift register in the seed
        for ( int jj = PatternLength-1; jj > 0; jj-- )
          seed[jj] = seed[jj-1];
        seed[0] = next;
                
        SetBit(ChannelArrayIndex, ii, next);
    }  // end for-loop
        

}  // end SetPseudoRandomString(int ChannelArrayIndex)

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

void BitString::GetRandomString(void)
{
  // Written by John Zweck, Nov 8, 2000

  // This 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.

  // It is also used by the BitString constructor.

   switch(TypeBitString)
   {
     case ALL_ZEROS: case ALL_ONES: case SINGLE_ONE: case USER_DEFINED:
       // Do nothing!

       break;
       
     case PSEUDO_RANDOM:
     
 // KLUDGY:  Sets PRBSs in every channel.  This might not be what you want.

       for(int ch=0; ch<NumChannels; ch++)
         SetPseudoRandomString(ch);
       break;

     case RANDOM_SIMPLE: case RANDOM_EQUAL_ZEROS_ONES:
     
  
       for(int ch=0; ch<NumChannels;ch++)
           SetRandomString(ch);

       break;

    default:
       cerr << "BitString::BitString switch error" << endl
            << "ABORTING NOW!!" << endl;
       exit(1);

   } //## end switch

} // ## end GetRandomString

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

void BitString::SetAllZeros(int ChannelArrayIndex)
{
  for ( int ii = 0; ii < StringLength ; ii++ ) 
    SetBit(ChannelArrayIndex,ii,0); 
 
}

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

void BitString::SetAllOnes(int ChannelArrayIndex)
{
  for ( int ii = 0; ii < StringLength ; ii++ ) 
    SetBit(ChannelArrayIndex,ii,1); 
 
}

// ####################################################
  
void BitString::SetSingleOne(int ChannelArrayIndex)
{

  SetAllZeros(ChannelArrayIndex);

  if(StringLength%2 == 0) // StringLength is even
    {
      SetBit(ChannelArrayIndex,StringLength/2 - 1,1);   

      if(DebugLevel >=3)
        LogFile << "BitString::SetSingleOne" << endl
                << "The Single One is in bit with index "
                << StringLength/2 - 1
                << endl;
    }
  else // StringLength is odd
   {
      SetBit(ChannelArrayIndex,(StringLength-1)/2,1);   

      if(DebugLevel >=3)
        LogFile << "BitString::SetSingleOne" << endl
                << "The Single One is in bit with index "
                << (StringLength-1)/2
                << endl;
    }

} // ## end SetSingleOne
  
// ##########################################################

void BitString::SetUserDefined(ifstream * InFile)
{

  // Written by John Zweck, Oct 2000, Feb 17th 2001.

char C_String[20]; 
string BitStringName;

string BitString;
string BitStringPreviousChannel;

for(int ch = 0;ch < NumChannels; ch++)
   {
     
     // To create a string object from a string and an int
     // it seems simplest to use the sprintf function for
     // C Strings and then initialize the string using the
     // C String.

     sprintf(C_String,"BitStringChann%d",ch+1);
     BitStringName = C_String;

     BitStringPreviousChannel =  BitString;
 
     BitString = ReadString(BitStringName,InFile);
     
     if(BitString == " " && ch == 0)
       {
         LogFile << "ERROR: Input File for Optical Signal must" << endl
                 << "include parameter $BitStringChann1" << endl
                 << "ABORTING NOW" << endl;
         exit(1);
       }


     if(DebugLevel >=2)
       {
          LogFile << endl
             << "BitString read from input file in Physical Channel "
             << GetChannelPhysicalIndex(ch) << " = " 
             << BitString << endl;
       }

     if(BitString == " " && ch > 0)
       {
         BitString =  BitStringPreviousChannel;
         
         if(DebugLevel >=3)
           {
         LogFile << endl 
                 << "WARNING: BitStringChann" << ch+1 << " not specified." 
                 << endl
                 << "So using BitString from BitStringChann" << ch << endl;
           }

       }

  
     int InputStringLength =  BitString.length();
          
     if(InputStringLength > StringLength)
        {
              LogFile << "Bit String in channel " << ch+1 
                      << " is longer than StringLength" << endl
                      << "ABORTING NOW" << endl;
              exit(1);
        }


     for(int ii=0; ii < StringLength; ii++)
        SetBit(ch,ii,0);

     int left_ii = 0;
     int right_ii = StringLength - 1;

     if(InputStringLength != StringLength)
        {

          if(DebugLevel >=2)
           {
                 LogFile << endl
                      << "WARNING: In channel " << ch+1 
                      << " input string length" << endl
                      << "is less than StringLength, so pad  with 0's" 
                      << endl;
            }

          left_ii = int(floor((StringLength - InputStringLength)/2));
          right_ii = left_ii + InputStringLength - 1;

          if(DebugLevel >=3)
            {
              LogFile << "The first bit in the input file BitString becomes "
                      << "bit " << left_ii << endl;

               LogFile << "The last bit in the input file BitString becomes "
                   << "bit " << right_ii << endl;
            }

          if(left_ii < 0 || left_ii >= StringLength ||
             right_ii < 0 || right_ii >= StringLength)
             {
                    LogFile << "Error in bit string constructor" << endl
                            <<  "ABORTING NOW" << endl;
                    exit(1);

             }
        } //## end if(InputStringLength != StringLength)
           
         
     string temp; 

     for(int ii=left_ii; ii <= right_ii ; ii++)
         {

           temp = BitString[ii-left_ii]; 

           // The comparison BitString[ii] == "1" was disallowed
           // by the compiler as BitString[ii] is a pointer.

           if(temp == "1")
              SetBit(ch,ii,1);
           else
            {
              if(temp == "0")
                 SetBit(ch,ii,0);
              else
               {
                 LogFile << endl 
                         << "Bit " << ii << " = " << BitString[ii] << endl
                         << "WARNING: Bit String must be a string" << endl
                         <<  "of 0's and 1's"
                         << endl << "ABORTING NOW!!" << endl;
                  exit(1);
                } // end else
             } // end else

       } // ##end for(int ii=left_ii; ii <= right_ii ; ii++)
      
   } // end for ch loop

} // ## end SetUserDefined

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

void BitString::SetStringToSingleMarkPerChannel(void)
{

  int ch,i;

for(ch=0;ch<NumChannels;ch++)
for(i=0;i<StringLength;i++)
   SetBit(ch,i,0);

for(ch=0;ch<NumChannels;ch++)
   SetBit(ch,(StringLength-1)/2,1);

}

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

void BitString::ReduceToSingleChannelBitString(int ChannelArrayIndex)
{

  // 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.

  // Store the single channel BitString we want to extract
  // in a temporary array

  int *TempBitStringArray;

  TempBitStringArray = new int[StringLength];

  for(int ii = 0; ii < StringLength; ii++)
    TempBitStringArray[ii] = GetBit(ChannelArrayIndex,ii);

  // Delete the BitStringArray

  /*
  delete [] BitStringArray;
  BitStringArray = NULL;
  */

  // Set NumChannels

  //  NumChannels = 1;

  // Allocate memory for new BitString array

  /*
  BitStringArray = new int[StringLength];
  */

  // Initialize the values of the new BitStringArray

  // The reason I do this is its a quick and dirty way to ensure that
  // the  method will still work if change
  // the way  BitStringArray stores the bits.

    for(int ii = 0; ii < StringLength; ii++)
      SetBit(0,ii,TempBitStringArray[ii]);
 
}

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

void BitString::ReduceToSingleChannelBitString(BitString * SCBitString)
{

  // 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 SCBitString.
  // 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.

  // Store the single channel BitString we want to extract
  // in a temporary array


  // Initialize the values of the new BitStringArray

  // The reason I do this is its a quick and dirty way to ensure that
  // the  method will still work if change
  // the way  BitStringArray stores the bits.

    for(int ii = 0; ii < StringLength; ii++)
      SetBit(0,ii,SCBitString->GetBit(0,ii));
 
}

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

string BitString::ReadString(string ParameterName, ifstream * InFile) 
{

  int ParameterRead = 0;
  string ParameterValue;
  string NameBuffer;

  string ParameterNameDollar = "$"+ParameterName;

  InFile->clear(); // Resets ifstream state to good
  
  // In order for an input operation to actually do something its
  // state must be "good". When the end of file is reached the 
  // state is set to "eof" which is not good! (This will have happened
  // if the ReadInt function has been previously called.)
  // The clear() function resets the state to "good"


  InFile->seekg(0); // Resets the file pointer to the start of the file.


  while (*InFile >> NameBuffer)
    {
    if (ParameterNameDollar==NameBuffer) 
     {
         *InFile >> ParameterValue; 

         // FIX: Check that have really read value in correctly!

         ParameterRead = 1;
     }  // end if   
      
    } // end while


  if(!ParameterRead)
    {

      // Since this routine is used to input BitStrings
      // if the required BitString is not present we 
      // return the NULL string and let the BitString
      // constructor work out what to do.

       ParameterValue = " ";
    }
  else
   LogFile << ParameterName << " = " << ParameterValue << " " << endl;


  return ParameterValue;

} // end ReadString();

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

int BitString::GetChannelArrayIndex(int ChannelPhysicalIndex)
{

  //## Written by John Zweck Oct 11, 2000
  //## 
  //## ChannelPhysicalIndex runs 
  //## -N/2,..... N/2 - 1 for N = NumChannels even and
  //## - (N-1)/2, ... (N-1)/2 for N odd
  //##
  //## ChannelArrayIndex runs 0,1,...,N-1

  // FIX Add bounds checker!!

  if(NumChannels %2 == 0) // NumChannels even 
    return ChannelPhysicalIndex + NumChannels/2;
  else // NumChannels odd
    return ChannelPhysicalIndex + (NumChannels-1)/2;

} // ## end GetChannelArrayIndex

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

int BitString::GetChannelPhysicalIndex(int ChannelArrayIndex)
{

  //## Written by John Zweck Oct 11, 2000
  //## 
  //## ChannelPhysicalIndex runs 
  //## -N/2,..... N/2 - 1 for N = NumChannels even and
  //## - (N-1)/2, ... (N-1)/2 for N odd
  //##
  //## ChannelArrayIndex runs 0,1,...,N-1

  // FIX Add bounds checker!

  if(NumChannels %2 == 0) // NumChannels even 
    return ChannelArrayIndex - NumChannels/2;
  else // NumChannels odd
    return ChannelArrayIndex - (NumChannels-1)/2;

}

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

void BitString::WriteBitString(void)
{

  cout << "########################" << endl;


  for(int ch=0;ch<NumChannels;ch++)
    {
     for(int bit = 0; bit < StringLength; bit++)
       cout << GetBit(ch,bit);

     cout << endl;

    }

}

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

---