---

copy-ocsTools.hh

Go to the documentation of this file.

// $Id: ocsTools.hh,v 1.30 2002/06/21 21:20:36 zweck Exp $

// #####################################################################
//
//    ocsTools.hh
//
//    Header file for ocsTools.cc.
//
//    Copyright:
//       Optical Fiber Communications Laboratory (OFCL)
//       Computer Science & Electrical Engineering Department (CSEE)
//       University of Maryland Baltimore County (UMBC)
//
//    The copyright applies to functions written by the OFCL members
// #####################################################################


#ifndef _OCS_TOOLS_HH_
#define _OCS_TOOLS_HH_


#include <unistd.h>

#include "cfftw.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"

#define NEAR_ZERO 2.2e-13

typedef complex<double> cplx; 

// #### square
template<class T> inline T sq(T);
template<class T> inline T sq(T in)
{
  return (in*in);
}

// ##### cube
template<class T> inline T cube(T);
template<class T> inline T cube(T in)
{
  return (in*in*in);
}

// ##### Sign function
inline int sgn(double x); 
inline int sgn(double x) 
{
   if (x >= 0)
      return(1);
   else   
      return(-1);
}

inline double min(double a, double b);
inline double min(double a, double b)
{
  if(a<b)
    return a;
  else
    return b;
}


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

// Functions added by Ivan

double GetRadiusCircle(double *PointA, double *PointB, double *PointC);
double GetDistance2Points(double *PointA, double *PointB, int FirstCoord);
int Periodicity(int ii, int Periodicity);
void TransRzRyV3to_Xhat( double *Vector, double *thetaZthetaY);
//                        ,double Rotation[][3]);
void TransRyV3to_YZ( double *Vector, double *thetaY);
void TransRzRxV3to_Xhat( double *Vector, double *thetaZthetaX);
void TransRzRxV3to_Xhat( double *Vector, double *thetaZ, double *thetaX);

//                    ,double Rotation[][3]);
void RotatesAboutZ(double angle, double *Vector); //, double Rz[][3]);
void RotatesAboutX(double angle, double *Vector); //, double Rx[][3]);
void RotatesAboutY(double angle, double *Vector); //, double Rx[][3]);

void RotatesAboutX(double angle, cplx *JonesVector);
void RotatesAboutY(double angle, cplx *JonesVector);
void RotatesAboutZ(double angle, cplx *JonesVector); 

void Multiply( double Left[][3], double Right[][3]);  
void Multiply(double Left[][3],double Right[3]);
double ScalarProduct(double *VectorA, double *VectorB);
void CrossProduct(double Left[4], double Right[4], int FirstCoord);
double GetVectorLength(double *Vector, int Dimension);

double dB2Linear(double dBvalue);
double dBm2Linear(double dBmPower);
double Linear2dB(double LinearValue);
double Linear2dBm(double LinearPower);
double Linear2dB_Limited(double LinearValue, double MaxValue_dB);

double GetDegreeOfPolarization(double *StokesVector);
double GetPhase(const cplx Phasor);
void Stokes2Jones(const double *Stokes, cplx *Jones);
void Jones2Stokes(const cplx *Jones, double *Stokes);
void Stokes2JonesKeepPower(const double *Stokes, cplx *Jones);
void Jones2StokesKeepPower(const cplx *Jones, double *Stokes);

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

// Functions added by John

double Frequency2Wavelength(double Frequency); // Freq in Hz
double Wavelength2Frequency(double Wavelength); // Freq in Hz


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

// Functions added by Ron
inline double lin_map(double x, double a1, double diff_a, double b1, double diff_b);
inline int lin_map(double x, double a1, double diff_a, int b1, int num_b);
inline double lin_map(int x, int a1, int num_a, double b1, double diff_b);
inline double lin_map(int x, int a1, int num_a, int b1, int num_b);
inline double lin_interpolate(double x, double a1, double diff_a, int b1, int num_b, double *data);
inline cplx lin_interpolate(double x, double a1, double diff_a, int b1, int num_b, cplx *data);

enum{MOSIX_UNLOCK, MOSIX_LOCK};
int lock_or_unlock_mosix(int what);
int cpujob_mosix(void);
int slow_mosix(void);
inline double dB_to_factor(double G_dB);
inline double factor_to_dB(double factor);

double gaussian(double t, double t0, double FWHM_norm);
void gaussian_pdf(int N, double stan_dev, double *vec);

inline double soliton(double t, double t0, double eta);
cplx bessel5(double omega, double omega_0, double FWHM);
void electrical_filter(cplx *my_power_time, cfftw *fft, double fwhm);
void optical_filter(cplx *my_field_time, cplx *my_field_freq, cfftw *fft, double fwhm);
void    my_error(char *spruch);

double peak_power(cplx *in, int N);
double pulse_energy(cplx *in, int N, double width);

void fftshift (cplx *v, int datlen_l);
void ifftshift (cplx *v, int datlen_l);

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

// ## Numerical Recipes Functions
float ranG(long *); // ## from ran2()
float Gaussian_pdf(long *idum);
void frprmn(float p[], int n, float ftol, int *iter, float *fret,
        float (*func)(float []), void (*dfunc)(float [], float []));
void frprmnd(double p[], int n, double ftol, int *iter, double *fret,
        double (*func)(double []), void (*dfunc)(double [], double []));
void powell(float p[], float xi[][4], int n, float ftol, int *iter, float *fret,
        float (*func)(float []));
//void powell(float p[], float **xi, int n, float ftol, int *iter, float *fret,
//      float (*func)(float []));

double **dmatrix(long nrl, long nrh, long ncl, long nch);
cplx **cmatrix(long nrl, long nrh, long ncl, long nch);
void free_dmatrix(double **m, long nrl, long nrh, long ncl, long nch);
void free_cmatrix(cplx **m, long nrl, long nrh, long ncl, long nch);
void gaussj(double **a, int n, double **b, int m);
void gaussj_complex(cplx **a, int n, cplx **b, int m);
float erffc(float x);
float gammp(float a, float x);
void gcf(float *gammcf, float a, float x, float *gln);
void gser(float *gamser, float a, float x, float *gln);
float gammln(float xx);
float gammq(float a, float x);
// ## End of Numerical Recipes Functions

#endif /* OCS_TOOLS_HH_ */

---