"""Function to correct for precision errors.

Args:

-----

x : ndarray.

Returns:

--------

y : ndarray correction of x.

"""

# Tolarance:

tol = 1.0e-07

sign = np.sign(x)

y = np.abs(x)

# correct for precision:

for i in np.arange(np.size(x)):

if np.abs(y[i] - 1.0) < tol:

y[i] = 1.0

elif np.abs(y[i] - 0.0) < tol:

y[i] = 0.0

"""Function to map the rotational axis:

Args:

-----

alpha : magnetic inclination angle w.r.t the rotatinal axis (degrees)

beta : line of sight closest approach to the magnetic axis (degrees)

Returns:

--------

xlos, ylos : The coordinates of the rotatinal plane; both the size of phi.

"""

cosR = np.cos(np.deg2rad(alpha+beta)) * np.cos(np.deg2rad(alpha))

cosR += np.sin(np.deg2rad(alpha+beta)) * np.sin(np.deg2rad(alpha)) * np.cos(np.deg2rad(phi))

R = np.arccos(correct(cosR))

# problems with precision for 180 degrees

cosgamma = np.zeros_like(R)

for i in np.arange(len(R)):

if int(R[i]*100.0) == 180.0:

R[i] = int(R[i]*100.0)/100.0

elif R[i] != 0.0 and R[i] != 180.0 and alpha > 0.0:

cosgamma[i] = (np.cos(np.deg2rad(alpha+beta)) - np.cos(np.deg2rad(alpha)) * cosR[i]) \

/(np.sin(np.deg2rad(alpha)) * np.sin(R[i]))

else:

cosgamma[i] = 0.0

cosgamma_corr = correct(cosgamma)

gamma = np.arccos(cosgamma_corr)

xp = R * np.sin(gamma)

for i in np.arange(len(phi)):

if phi[i] > 0.0:

xp[i] = -xp[i]

yp = -R * np.cos(gamma)

"""Function to determine the line of sight cut across the beam.

Args:

-----

alpha : Inclination angle (degrees).

beta : Impact parameter (degrees).

Returns:

--------

xlos : The line of sight x-coordinates (degrees).

ylos : The line of sight y-coordinates (degrees).

thetalos : The line of sight angle in degrees (degrees).

"""

# rotational phase:

phi = np.linspace(-180, 180, num=res, endpoint=True)

# line of sight x,y plane:

xlos, ylos = mapphi(alpha, beta, phi)

thetalos = np.arctan2(ylos, xlos) * (180 / np.pi) - 90.0

thetalos = np.abs(thetalos)

#for i in np.arange(len(thetalos)):

# if thetalos[i] < 0:

# thetalos[i] = -thetalos[i]

"""Function to determine emission heights given the period. If no emission height range

is specified, default used for P < 0.15 is between [950, 1000] and between [20, 1000]

for P > 0.15.

Args:

-----

P : Rotational period (seconds).

ncomp : Integer number of component.

iseed : Integer seed for a pseudo-random number generator.

hmin : Minimum emission height (in km).

hmax : Maximum emission height (in km).

fanBeam : beam model to simulate

Returns:

--------

H : Emission heights (in km).

"""

np.random.seed(iseed)

if fanBeam or hollowCone:

num_H = 1

else:

num_H = ncomp # number of discrete emission height

# If height range is not specified:

if hmin == None and hmax == None:

# emission height for a short period pulsar: only one emission height (KJ07)

if P <= 0.15:

hmin = 950

hmax = 1000

H = np.random.uniform(hmin, hmax, size=1)

elif P > 0.15:

hmin = 20

hmax = 500

H = np.random.uniform(hmin, hmax, size=num_H)

# For specified height range:

else: H = np.random.uniform(hmin, hmax, size=num_H)

"""Function to determine frequency dependent emission heights.

Args:

-----

H : heights (km)

freq : frequency (GHz)

Returns

-------

H_mu : Frequency dependent height (km)

"""

#gamma = 0.83 # with rho \prop mu^-0.43 (error +/- 0.06 ref: fig.12 Hassall et al. 2012.)

#H_mu = 0.6*H * (freq)**(-gamma) + 0.4*H # frequency dependence on height (KJ07 eqn.4/beam code)

H_mu = H * (9 * freq**(-0.95) + 41)/(9 + 41)

"""Function to determine the opening angle of the beam given the rotational period and emission height.

Args:

-----

P : Rotational period (seconds).

heights : Emission heights (km).

Returns:

--------

rho : The opening angle (degrees).

"""

# opening angle (eqn 3.29, Lorimer and Kramer 2005):

rho = np.rad2deg(np.sqrt((9 * np.pi * heights) / (2 * (constants.c / 1000) * P)))

"""Function to calculate the width of a patchy emission region

within a pulsar beam at a given height.

Args:

-----

P : rotational period (seconds).

heights : emission heights (km).

Returns:

--------

patchwidths : the width of the patchy emission region (degrees).

"""

# width of the patch (eqn 3, KJ2007):

if hollowCone:

# Smaller patches for the hollow cone (~2.5 smaller than kj07)

patchwidths = 0.2 * np.sqrt(heights / ( 10 * P))

else:

patchwidths = 2.45 * 0.2 * np.sqrt(heights / ( 10 * P))

"""Function find centres of the patches

Args:

-----

P : rotational period.

heights : emission heights (in km).

npatch : number of patches.

iseed : random nunber seed.

fanBeam : option to use fan beam model.

Returns:

--------

centerx : the patch center projection on the x-axis

centery : the patch center projection on the y-axis

"""

# opening angle:

opa = rho(P, heights)

centerx = []

centery = []

np.random.seed(iseed)

if hollowCone:

# Model hollow cone beam

npatch = 40 # just arbitrary to create a circular ring

theta = 2 *np.arange(0, 2*np.pi, 2*np.pi/npatch)

elif fanBeam:

# Model fan beam

theta = 2 * np.pi * np.random.random(npatch)

else:

# Model patchy beam model by default

theta = 2 * np.pi * np.random.random(len(heights) * npatch)

for j in range(len(heights)): #for each emission height (comp!)

#find the center of the patch

tempCenterX = []

tempCenterY = []

if not fanBeam:

for i in np.arange(npatch):

tempCenterX.append(opa[j] * np.sin(theta[j*npatch + i]))

tempCenterY.append(opa[j] * np.cos(theta[j*npatch + i]))

else:

for i in np.arange(npatch):

tempCenterX.append(opa[j] * np.sin(theta[i]))

tempCenterY.append(opa[j] * np.cos(theta[i]))

centerx.append(tempCenterX)

centery.append(tempCenterY)

"""Function to determine polarization swing.

Args:

-----

alpha : inclination angle (degrees)

beta : impact parameter (degrees)

prof : one dimentional profile

Return:

-------

pa : polarization position angle (degrees).

"""

# predict the position angle (psi) swing through the observer's sight line:

zeta = alpha + beta

points = range(len(prof))

pa = []

phi0 = 0.

for point in points:

phi = np.deg2rad(prof[point])

numer = np.sin(np.deg2rad(alpha)) * np.sin(np.deg2rad(phi - phi0))

denom = np.sin(np.deg2rad(zeta)) * np.cos(np.deg2rad(alpha)) - np.cos(np.rad2deg(zeta)) * np.sin(np.rad2deg(alpha)) * np.cos(np.deg2rad(phi - phi0))

psi = np.arctan(numer/denom)

# restrict psi between [-pi/2, pi/2]

if psi < -np.pi/2.:

psi = psi + np.pi

if psi > np.pi/2.:

psi = psi - np.pi

# Convert psi back to degrees

pa.append(np.rad2deg(psi))

"""Function to determine the aberration ofset due to the curvature of the magnetic field.

Args:

-----

heights : emission heights

Returns:

--------

ab_ofsetx : ofset of the projected x coordinates

ab_ofsety : ofset of the projected y coordinates

"""

# aberration time scale:

ab_time = heights / (constants.c / 1e3)

ab_deg = (ab_time / P) * 360

ab_xofset, ab_yofset = mapphi(alpha, 0.0, ab_deg)

"""Function to determine the scattering time scale as in Bhat et al. (2004).

Args:

-----

freq : frequency (in GHz)

dm : dispersion measure (pc cm^-3)

Return:

-------

tau : the scattering time (in sec)

"""

# tau = scattering time scale as in Bhat et al. (2004)

np.random.seed(iseed)

log_tau = -6.46 + 0.154 * np.log10(dm) + 1.07 * (np.log10(dm))**2 - 3.86 * np.log10(freq) + np.random.uniform(-1,1) # scattering time with added noise term

tau = 10**log_tau / 1e3 # (time scale in seconds)

"""Function to create a train of pulses given a single pulse profile.

Args:

-----

npulses : number of pulses

numberofbins : number of bins (res; def = 1e3)

prof : pulse profile

Return:

-------

train : a train of pulse profiles (size = size(profile)*npulses)

"""

binsrange = np.linspace(1, numberofbins, num=numberofbins, endpoint=True)

nbins = np.max(binsrange)

train = np.zeros(npulses * int(nbins))

for i in range(npulses):

startbin = i * nbins

train[int(startbin):int(startbin + nbins)] = prof

"""Function that takes the output convolution

Args:

-----

sc_train : a scattered train of pulse profiles

pulsefromend : number position of pulse to extract (from the last pulse)

binsperpulse : number of bins per pulse

Returns:

--------

pulse : a single pulse profile

"""

if pulsesfromend == 0:

start = 0

end = binsperpulse

#zerobpulse = train[start:int(end)] - np.min(train[start:int(end)])

#rectangle = np.min(train[start:int(end)])*binsperpulse

#flux = np.sum(train[start:int(end)]) - rectangle

else:

start = -pulsesfromend*binsperpulse

end = start + binsperpulse

#zerobpulse = train[start:int(end)]-np.min(train[start:int(end)])

#rectangle = np.min(train[start:inte(end)])*binsperpulse

#flux = np.sum(train[start:int(end)]) - rectangle

pulse = sc_train[int(start):int(end)]

"""Function to determine the broadening function of the profile due to scattering.

Args:

-----

tau : scattering time (in seconds)

P : period (in seconds)

Return:

-------

broad_func : broadening function

"""

t = np.linspace(0, P, num=res, endpoint=True)

broad_func = 1/tau * np.exp(-(t / tau))

"""Function to scatter a pulse profile / a train of pulse profiles. Returns a convolution of the profile with the scattering function.

Args:

-----

pulse : pulse profile (extracted from a function extractpulse())

bf : broadening function

Returns:

-------

conv : scattered profile

"""

conv = np.convolve(train, bf)

# normalise the profile:

profint = np.sum(train) # integral / area of the profile

convint = np.sum(conv) # integral / area of the scattered profile

sc_prof = conv * (profint / float(convint))

out = sc_prof[0 : len(train) + 1]

"""Function that finds a maximum peak of a profile.

Args:

-----

prof : pulse profile

Return:

-------

peak : peak value of the profile

"""

peak = np.max(prof)

""" Function to find the width at 10% of the peak intensity.

Args:

-----

prof : profile (1D array)

Returns:

--------

w10 : width at 10% of the peak intensity

"""

peak = find_peak(prof)

left = 0

right = 0

for i in range(len(prof)):

if prof[i] > 0.1 * peak:

left = i

break

for i in range(len(prof)):

if prof[-i] > 0.1 *peak:

right = len(prof) - i

break

w10 =(float(right -left)/float(len(prof)))* 360.

"""Function to randomly select a dm value from the known pulsar dms in the catalogue.

Creates a distribution of the dm values given their probabilities, and randomly select

a dm value to use for scattering.

Args:

-----

psrcatdmfile : a file containing psrcat dm values in 1 column (nan values replaced with zeros)

iseed : seed for the random number generator [int].

nbins : number of bins.

n : size of the samples to draw

Returns:

--------

rand_dm : randomly selected dm value (pc cm^-3).

"""

dm_file_name = str(psrcatdm)

dm_file = np.loadtxt(dm_file_name) # Load the txt file containing the DM

dm_dat = dm_file[np.where(dm_file > 0)] # Exclude the zero dms used to replace null values from psrcat

hist, bin_edges = np.histogram(dm_dat, bins=nbins) # creates a histogram distribution

probs = hist/float(len(dm_dat)) # Compute probabilities

dm_range = np.linspace(np.min(dm_dat), np.max(dm_dat), endpoint=True, num=len(probs))

normdiscrete = stats.rv_discrete(values=(dm_range, probs), seed=iseed) # Find an arbitrary distribution

rand_dm = normdiscrete.rvs(size=n) # draw a sample of size n

#noise_rms(snr, peak):

"""Function to determine the noise level given a signal to noise

and the peak of the profile. Detemines the rms that will give maximum

signal to noise. Assumes 0 baseline.

Args:

-----

snr : signal to noise ratio

peak : peak of the profile

Return:

-------

rms : noise rms

"""

# assumes the beam is normalized such that the LOS cut at center produce a beam (2d gaussian with max amplitude 1)

# The peak of the profile = 10 times

#rms = peak / snr

rms = 10/snr

"""Function that add noise to a profile. Finds a signal to noise of

a profile and determine the noise level to add for that specific

profile. Adds a gaussian noise to a profile using a fixed noise

rms, assuming a normalised profile.

NB: If 'prof' is the scattered profile from scatterering function

'scatter()', then the profile is normalised!

Args:

-----

prof : pulse profile

rms : noise rms

Returns:

--------

noisy_prof : a profile with added noise

"""

peak = find_peak(prof)

noise = np.random.normal(0, rms, np.shape(prof))

noisy_prof = prof + noise

# noisy_prof = np.asarray(prof).T

# for i in range(np.shape(prof)[0]):

# noisy_prof[:,i] += noise

# noisy_prof = noisy_prof.T

"""Function to determine signal to noise ratio for each profile.

Uses the previously determined noise level from function

'noise_rms' to determine the signal to noise ratio for each

profile.

Args:

----

peak : peak of the profile

rms : noise rms

Return:

-------

snr : signal to noise of each profile

"""

snr = (peak / rms )

"""Function to find a bin closest to the peak of a profile.

Args:

-----

profile : a profile (1D numpy array)

Returns:

--------

phase_bin : a bin where the profile peaks

"""

# Find the bin where the profile is max:

peak = np.max(prof)

for prof_id, prof_val in enumerate(prof):

if prof[prof_id] == peak:

phase_bin = prof_id

""" Finds the time delay to smear profile accross a given width

Args:

-----

width : W, the estimated width of our profiles

Returns:

--------

delta_t : time delay to shift aprofiles accros given width

"""

delta_t = width/360.0 * P

"""Function to determine the delay of the profiles as a function of freq.

Assumes the the profiles are already de-despersed; this is an additional

delay due to the dm variation with profile

Args:

-----

freq_ref : reference frequecy (in GHz)

freq : frequency to shift (in GHz)

delta_dm : dispersion measures to try

t_res : time per bin (Period/resolution in seconds)

Return:

-------

bin_shift: relative shift of freq w.r.t the reference freq (in bins)

Function use the maximum frequency as the reference frequency.

Find the dispersion measure that give the maximum S/N.

"""

D = 4.148808 * 1e3 # +/- 3e-6 MHz^2 pc^-1 cm^3 s

delta_t = D * ((freq_ref * 1e3)**(-2) - (freq * 1e3)**(-2)) * delta_dm # in seconds; eqn. 5.2 (handbook)

if np.isnan(delta_t):

delta_t = np.nan_to_num(delta_t)

else:

delta_t = delta_t

bin_shift = np.int(delta_t * (1/t_res)) # phase shift in bins

#print 'bin_shift', bin_shift

"""Function to average profiles

"""

profile = np.asarray(prof)

averageP = np.average(prof, 0)

"""Template matching function. Cross-correlate profiles with a template,

and determine the lag (is seconds).

Input:

profiles: profiles in the channels

template: template to use for cross-correlation

period: pulse period (s)

resample_factor: factor to use fp resampling the correlation functions

"""

resolution = len(profiles[0])

time_resolution = period/float(resolution)

delay = np.zeros(np.shape(profiles)[0])

for i in range(np.shape(profiles)[0]):

correlation_coefficients = correlate(template, profiles[i])

resampled_coeffiecients = resample(correlation_coefficients, resample_factor \

* len(correlation_coefficients))

lag = np.argmax(resampled_coeffiecients) / float(resample_factor)

lag = np.mod(lag, resolution) + 1.0 # scipy correlate return N + 1 points

# Restrict the lag from shifting profiles across full period

if lag > len(template)/2.:

lag = len(template) - lag

else:

lag = -lag

delay[i] = time_resolution * lag

"""Function to determine a dispersive delay within a band, given a DM.

Input:

frequencies: channel frequencies (MHz)

DM: dispersion measure (pc cm^-3)

C: some constant that shifts the function along x-axis

"""

K = 4.148808 * 1e3 # MHz^2 pc^-1 cm^3 s

fi = frequencies[-1] # Assuming last freq is the highest frequency (set as reference)

time_delay = K * ( frequencies ** (-2) - fi ** (-2) ) * DM + C