ocsTools.hh

Go to the documentation of this file.

// $Id: ocsTools.hh,v 1.2 2006/05/11 23:48:11 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;
}

void MinAndArgMin(double * Vec, int Length, double & MinValue, int & ArgMin);
void MaxAndArgMax(double * Vec, int Length, double & MaxValue, int & ArgMax);

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

// 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 TransRzRyV3toXhat( double *Vector, double *thetaZthetaY);
void TransRzRxV3toXhat( double *Vector, double *thetaZthetaY);

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 Multiply(cplx Left[][2], cplx Right[][2]);
void URotatesAboutZ(double angle, cplx UMatrix[][2]);
void URotatesAboutY(double angle, cplx UMatrix[][2]);
void URotatesAboutX(double angle, cplx UMatrix[][2]);
void MRotatesAboutZ(double angle, double MMatrix[][3]);
void MRotatesAboutY(double angle, double MMatrix[][3]);
void MRotatesAboutX(double angle, double MMatrix[][3]);
void MGeneralRotation(double angle, double *r_vec, double MMatrix[][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);
void CrossProduct(double *Left, double *Right, double *Product);
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 Zweck


void JonesPair2MixedStokes(const cplx *Jones1, const cplx * Jones2,
                           cplx *MixedStokes);


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



double MaxOfArray(double * Array, int Length);


double MinOfArray(double * Array, int Length);


double Quadrature(double * Data, int NumPts, 
                  double LeftEndPt, double RightEndPt);


inline cplx exp_jc_real(double __x)
{
#if !defined __NO_MATH_INLINES && defined __OPTIMIZE__ && defined __GNUC__
  register long double __cosr;
  register long double __sinr;
  __asm __volatile__
    ("fsincos\n\t"
     : "=t" (__cosr), "=u" (__sinr) : "0" (__x));

// alternatively:
//  double sin_x, cos_x;
//  __sincos(x, &sin_x, &cos_x);

  return cplx(double(__cosr), double(__sinr));
#else
  return cplx(cos(__x), sin(__x));
#endif
}


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

// 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);
double erfccExtendedRange(double x);
float erfcc(float x);
float zbrent(float (*func)(float), float x1, float x2, float tol);
float brent(float ax, float bx, float cx, float (*f)(float), float tol,
        float *xmin);
double brentd(double ax, double bx, double cx, double (*f)(double), 
        double tol, double *xmin);

double splint( double *xa,  double *ya,  double *y2a, int n, double x);
void spline(double *x,  double *y,  int n, double yp1, double ypn,  double *y2);

// ## End of Numerical Recipes Functions

#endif /* OCS_TOOLS_HH_ */