---

copy-ocsAppPape.cc

Go to the documentation of this file.

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


//###################################################################\\
//                                                                   \\
// The applications in this file were written by John Zweck          \\
// and are not to be modified by anyone else for now.                \\
//                                                                   \\
//###################################################################\\

#include <iostream.h>
#include <complex.h>
   
#include "ocs.hh"
#include "StartupPape.hh"
   
#include <time.h>
#include <sys/time.h>
#include <sys/times.h>
   
   
extern ofstream LogFile;
   
void AJ(StartupZweck * Startup);
   
   
// ## Application Wrapper
    
/*********************************************************************\
/  #Function added by John Zweck                                      \
/  Documention: Pape D. Thiam                                         \
/                                                                     \
/  Function :  MyApplication                                          \
/  usage    :  This function is passed by default the two parameters  \
/              that the main function received from the keyboard. An  \
/              object of type "StartupZweck" is instantiated. A  data \
/              member of the class object is expected to hold the     \
/              value '1'. If it actually holds the value '1', the     \
/              function "AJ" is called and the instantiated object is \
/              passed to it by reference, conversly, an error message \
/              is thrown to the screen if the data member does not    \ 
/              hold the value '1'.                                    \ 
/                                                                     \
/  input(s) :  The data is read from a file                           \
/  output(s):  The data is written to a file as well.                 \
\*********************************************************************/

// The main function takes data from the keyboard and make it available to the 
// user by passing it to this function.
void MyApplication(int argc, char *argv[])  
{  
  // An object of type "StartupZweck" is instantiated and a string is 
  // passed to the constructor to initiate a data member
  StartupZweck Startup("Startup.in");
  
  // The object accesses a private data member via its accessor
  // Note that the object "Startup" can not access the private data members
  // of the class "StartupZweck" unless it is a friend of the class or through
  // private inheritance.
  switch(Startup.GetSimType())
    {
    // If the content of the switch statement returns a 1, the function AJ
    // is called and the object "Startup" is passed by reference. If "case 1"
    // is not executed, the default case gets executed, an error message
    // is thrown directly to the screen, and the program is exited.
    case 1: 
      AJ(&Startup);
      break;
       
    default:
      cerr << "MyApplication: Invalid choice of application in SimType" 
           << endl;
      exit(1);
      
    } // end switch
  
} // end MyAppn


/*********************************************************************\
/  #Function added by John Zweck                                      \
/  Documention: Pape D. Thiam                                         \
/                                                                     \
/  Function :  AJ                                                     \
/  usage    :                                                         \
/                                                                     \
/                                                                     \
/                                                                     \
/                                                                     \
/                                                                     \
/                                                                     \
/                                                                     \ 
/                                                                     \ 
/                                                                     \
/  input(s) :                                                         \
/  output(s):                                                         \
\*********************************************************************/
void AJ(StartupZweck * Startup)
{
  // StartTime and EndTime are instantiated as objects of the class time_t
  // which is defined in the C++ standard template library 
  time_t StartTime,EndTime;
  
  struct tms my_tms;
               
  // Since NULL is passed to time, the value of the current time is not stored
  // but it is still returned by the function. Note that the reference time is 
  // a default time stored in the compiler. The actual value stored is 
  // actually the elapsed time since the default time stored in the compiler. 
  // Note that time_t is generally defined as long and it is calculated in 
  // seconds.  
  StartTime = time(NULL);
  
  // When ctime is called, the returned string has the following format
  //                 Www  Mmm dd hh:mm:ss yyy
  // Where Www is the weekday, Mmm the month in letters, dd the day of the 
  // month, hh:mm:ss is the time and yyy is the current year 
  cout << "Start Time: " << ctime(&StartTime) << endl;
  
  // This function call separates the data current data in the file from the
  // new data with a line of pound signs.
  LogFileSeparator();
  
  // Data is written into the file. Note that the buffer is flushed before and 
  // data is written to the file.
  LogFile <<  endl << "AJ" << endl;
  
  // Starup is a class object of type "StartupZweck". "GetInputFilesDir()" 
  // and "GetJobPrefix()" are two member functions (accessors). They both 
  // return strings.
  string InDir = Startup->GetInputFilesDir();
  string Job = Startup->GetJobPrefix();
  
  // Class objects of type RanNumGen are being instantiated and the
  // constructor is being passed a string. Note that InDir is a string and a
  // string is appended to it.
  RanNumGen RNGSignal(InDir + "RanNumGenSig.in");
  RanNumGen RNGAmps(InDir + "RanNumGenAmps.in");
  RanNumGen RNGFibers(InDir + "RanNumGenFibers.in");
  
  // ## Initiating the optical pulses
  
  // A class object of type "OptSignal" is instantiated as a pointer.
  OptSignal * Signal;
  
  // A block of memory is being allocated for Signal to point to.
  Signal = new OptSignal("Signal.in", &RNGSignal);
  
  // A class object of type "OptDataWriter" is instantiated and the 
  // constructor is passed a set of data.
  OptDataWriter DataWriter(InDir + "DataWriter.in", InDir,Job,Signal);
  
  DataWriter.WriteInitialData();
  
  // ## Declare and initialize the fibers 
  // Note that "OptFiberLocalError" is a class and the different parameters it
  // receives are geared towards its default constructor.
  OptFiberLocalError PreDCF(InDir + "PreDCF.in",Signal,&RNGFibers,Job);
  OptFiberLocalError PostDCF(InDir + "PostDCF.in",Signal,&RNGFibers,Job);
  OptFiberLocalError SMF(InDir + "SMF.in",Signal, &RNGFibers,Job);
  OptFiberLocalError DCF(InDir + "DCF.in",Signal, &RNGFibers,Job);
  
  // Four fibers are being used
  int NumFibers = 4;
  
  OptFiberLocalError * FiberPtr[NumFibers];
  
  FiberPtr[0] = &PreDCF;
  FiberPtr[1] = &PostDCF;
  FiberPtr[2] = &SMF;
  FiberPtr[3] = &DCF;
  
  // The Amplifiers are declared and initialized. Note that "OptAmplifier" is 
  // a class and the differed parameters it receives are geared towards its 
  // default constructor.
  OptAmplifier Amp(InDir + "Amp.in",Signal,&RNGAmps);
  OptAmplifier Amp2(InDir + "Amp2.in",Signal,&RNGAmps);
  OptAmplifier PAmp(InDir + "PAmp.in",Signal,&RNGAmps);
  
  // Three amplifiers are being used
  int NumAmps = 3;
  
  // A new array of amplifiers is declared as a pointer. And the cells of the
  // array point to the three amplifiers previously defined.
  OptAmplifier * AmpPtr[NumAmps];
  
  AmpPtr[0] =  &Amp;
  AmpPtr[1] =  &Amp2;
  AmpPtr[2] =  &PAmp;
  
  // The value stored in the private data member "DebugLevelAmps" is retrieved
  // If true is returned, the retrieved value is stored in all the three 
  // amplifier objects, i.e. the private data member "DebugLevel" of each of
  // the amplifier objects will be assigned the retrieved value. 
  if(Startup->GetDebugLevelAmps())
    {
      for(int i = 0; i < NumAmps; i++)
        AmpPtr[i]->SetDebugLevel(Startup->GetDebugLevelAmps());
    }
  
  // The type of amplifier is being setup.
  for(int i = 0; i < NumAmps; i++)
    AmpPtr[i]->SetTypeAmplifier(typeAmplifier(Startup->GetTypeAmp()));
  
  // The value stored in the private data member "AmpsNoiseOffFlag" 
  // is retrieved If true is returned,the noise of every amplifier is turned
  // off.
  if(Startup->GetAmpsNoiseOffFlag())
    {
      for(int i = 0; i < NumAmps; i++)
        AmpPtr[i]->SetTypeAmplifierNoise(NOISE_OFF);
    }
  
  // The private data member "SndOrDispFiber" of the fibers is initialized to 
  // zero if true is returned.
  if(Startup->GetBeta3ZeroFlag())
    {
      for(int i = 0; i < NumFibers; i++)
        FiberPtr[i]->SetSndOrDispFiber(0);
    }
  
  // The private data member "GammaFiber" of the fibers are initialized to 
  // zero if true is returned.
  if(Startup->GetNonLinearityZeroFlag())
    {
      for(int i = 0; i < NumFibers; i++)
        FiberPtr[i]->SetGammaFiber(0);
    }
  
  // The private data member "Attenuation" of the fibers are initialized to 
  // zero if true is returned.
  if(Startup->GetFiberLossZeroFlag()) 
    for(int ii = 0; ii < NumFibers; ii++)
      FiberPtr[ii]->SetAttenuation(0);
  
  // The private data member "RelativeErrorGoal" of the fibers are initialized 
  // to the value stored in "RelativeErrorGoal".
  for(int ii = 0; ii < NumFibers; ii++)
    FiberPtr[ii]->SetRelativeErrorGoal(Startup->GetRelativeErrorGoal());
  
  // The private data member "OutputStepSizesFlag" of the fibers are 
  // initialized to the value stored in "OutputStepSizesFlag".
  for(int ii = 0; ii < NumFibers; ii++)
    {
      FiberPtr[ii]->SetOutputStepSizesFlag(Startup->GetOutputStepSizesFlag());
    }
  
  
  // #### Propagate signal through fiber ####
  
  double PropagatedLength = 0;
  int ZStepNum = 0;
  
  // The signal is propagated trhough the "PreDCF" fiber and the "PAmp" 
  // amplifier amplifies it.
  PreDCF.Propagate(&PropagatedLength, &ZStepNum);
  PAmp.AmplifyOptSignal();
  
  int kk = 0;
  
  // ask questions about this and explain later
  DataWriter.WriteEndMap(0,kk,PropagatedLength);
  
  for(kk = 0; kk < Startup->GetQtMapSpans(); kk++) 
    {
      // The signal is propagated trhough the "SMF" fiber and the "Amp" 
      // amplifier amplifies it.
      SMF.Propagate(&PropagatedLength,&ZStepNum);
      DataWriter.WriteWithinMap(0,kk,PropagatedLength);
      Amp.AmplifyOptSignal();
      
      // ask questions about this and explain later
      DataWriter.WriteWithinMap(0,kk,PropagatedLength);
      
      // The signal is propagated trhough the "DCF" fiber and the "Amp2" 
      // amplifier amplifies it.
      DCF.Propagate(&PropagatedLength,&ZStepNum);
      DataWriter.WriteWithinMap(0,kk,PropagatedLength);
      Amp2.AmplifyOptSignal();
      
      // ask questions about this and explain later
      DataWriter.WriteEndMap(0,kk,PropagatedLength);
      
      if(kk % 10 == 0 && kk != 0)
        cout << "Completed " << kk << " periods of dispersion map " << endl;
      
    }// ## end for kk-loop
  
  // The signal is propagated trhough the "PostDCF" fiber and the "PAmp" 
  // amplifier amplifies it.
  PostDCF.Propagate(&PropagatedLength,&ZStepNum);
  PAmp.AmplifyOptSignal();
  
  // ####################### End of Propagation ###########################
  
  DataWriter.WriteEndTransmission(0,kk,PropagatedLength);
  
  // ask questions about this and explain later
  cout <<"Total PropagatedLength [km] = "<<PropagatedLength*1e-3<< endl;
  cout <<"Number Steps in Z taken by solver = " << ZStepNum << endl;
  
  // Since NULL is passed to time, the value of the current time is not stored
  // but it is still returned by the function. Note that the reference time is 
  // a default time stored in the compiler. The actual value stored is 
  // actually the elapsed time since the default time stored in the compiler. 
  // Note that time_t is generally defined as long and it is calculated in 
  // seconds. This is the end of the propagation.
  EndTime = time(NULL);
  
  // The propagation time is determined and stored in TotalTime
  double TotalTime = double(EndTime - StartTime);
  
  // ask questions about this and explain later
  times(&my_tms);
  
  // ask questions about this and explain later
  double CPUtime = (double(my_tms.tms_utime))/(double(sysconf(_SC_CLK_TCK)));
  
  // Since "TotalTime" & "CPU Time" are in seconds, they are converted to hours
  // The percentage of the CPU Time is also calculated
  cout << "Total Run Time [hrs] = " << TotalTime/3600.0 << endl
       << "Total CPU Time [hrs] = " << CPUtime/3600.0 << " = " 
       << 100.0*CPUtime/TotalTime << "%" << endl;
  
  // When ctime is called, the returned string has the following format
  //                 Www  Mmm dd hh:mm:ss yyy
  // Where Www is the weekday, Mmm the month in letters, dd the day of the 
  // month, hh:mm:ss is the time and yyy is the current year 
  cout << "End Time: " << ctime(&EndTime) << endl;
  
  cout << "THE END" << endl;
  
  // "THE END" is written to the file.
  LogFile << "THE END" << endl;
  
  
} // ## end AJ

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

---