def normDist(
r, rsigma
): #defines an always positive normal distribution (for very broad size distributions)
x = pl.normal(r, rsigma)
while x < 0:
x = pl.normal(r, rsigma)
return x
def get_normal_input_times(self, mu=10, sigma=1):
''' generates n normal-distributed prosesses with mean mu and deviation sigma'''
times = pl.normal(mu, sigma, self.n)
for i in xrange(self.n):
while times[i] <= self.tstart or times[i] >= self.tstop:
times[i] = pl.normal(mu, sigma)
return times
def get_age_sex(is_crew=False,
min_age=18,
max_age=99,
crew_age=35,
crew_std=5,
guest_age=68,
guest_std=8):
'''
Define age-sex distributions. Passenger age distribution based on:
https://www.nytimes.com/reuters/2020/02/12/world/asia/12reuters-china-health-japan.html
"About 80% of the passengers were aged 60 or over [=2130], with 215 in their 80s and 11 in the 90s,
the English-language Japan Times newspaper reported."
'''
# Define female (0) or male (1) -- evenly distributed
sex = pl.randint(2)
# Define age distribution for the crew and guests
if is_crew:
age = pl.normal(crew_age, crew_std)
else:
age = pl.normal(guest_age, guest_std)
# Normalize
age = pl.median([min_age, age, max_age])
return age, sex
def test_anova():
import pandas as pd
A = normal(0.5, size=10000)
B = normal(0.25, size=10000)
C = normal(0, 0.5, size=10000)
df = pd.DataFrame({"A": A, "B": B, "C": C})
a = ANOVA(df)
print(a.anova())
a.imshow_anova_pairs()
def other():
data = pylab.concatenate((pylab.normal(1, .2,
5000), pylab.normal(2, .2, 2500)))
y, x, _ = pylab.hist(data, 100, alpha=.3, label='data')
# x = x[1:]
x = (x[1:] + x[:-1]) / 2 # for len(x)==len(y) # TODO what?
expected = (1, .2, 250, 2, .2, 125)
params, cov = curve_fit(bimodal, x, y, expected)
sigma = numpy.sqrt(numpy.diag(cov))
plt.plot(x, bimodal(x, *params), color='red', lw=3, label='model')
plt.legend()
print(params, '\n', sigma)
def Perturb(inmat,pfact=.1):
'''
Adds some noise to inmat.
'''
stds=np.std(inmat)
return inmat+np.array([pl.normal(0,tmp*pfact,inmat.shape[0]) for tmp in stds]).T
def pull(self):
rValue = self.meanReturn
if (self.varianceReturn > 0):
rValue = normal(self.meanReturn, self.varianceReturn)
return rValue
def __init__(self, mu=[-1,1], sigma=[1,1], mixture=[0.5,0.5], N=1000):
""".. rubric:: constructor
:param list mu: list of mean for each model
:param list sigma: list of standard deviation for each model
:param list mixture: list of amplitude for each model
"""
assert len(mu) == len(sigma)
assert len(mu) == len(mixture)
self.mu = mu
self.sigma = sigma
self.mixture = mixture
self.data = []
self.N = N
self.Ns = [int(x*N) for x in mixture]
self.k = len(self.mu)
if sum(self.Ns) != N:
print('Warning: rounding mixture ratio. total N will be %s' %
sum(self.Ns))
for m, s, n in zip(self.mu, self.sigma, self.Ns):
data = pylab.normal(m, s, size=n)
self.data.extend(data)
def __init__(self, mu=[-1, 1], sigma=[1, 1], mixture=[0.5, 0.5], N=1000):
""".. rubric:: constructor
:param list mu: list of mean for each model
:param list sigma: list of standard deviation for each model
:param list mixture: list of amplitude for each model
"""
assert len(mu) == len(sigma)
assert len(mu) == len(mixture)
self.mu = mu
self.sigma = sigma
self.mixture = mixture
self.data = []
self.N = N
self.Ns = [int(x * N) for x in mixture]
self.k = len(self.mu)
if sum(self.Ns) != N:
print('Warning: rounding mixture ratio. total N will be %s' %
sum(self.Ns))
for m, s, n in zip(self.mu, self.sigma, self.Ns):
data = pylab.normal(m, s, size=n)
self.data.extend(data)
def zeroPaddData(self,desiredLength,paddmode='zero',where='end'):
#zero padds the time domain data, it is possible to padd at the beginning,
#or at the end, and further gaussian or real zero padding is possible
#might not work for gaussian mode!
desiredLength=int(desiredLength)
#escape the function
if desiredLength<0:
return 0
#calculate the paddvectors
if paddmode=='gaussian':
paddvec=py.normal(0,py.std(self.getPreceedingNoise())*0.05,desiredLength)
else:
paddvec=py.ones((desiredLength,self.tdData.shape[1]-1))
paddvec*=py.mean(self.tdData[-20:,1:])
timevec=self.getTimes()
if where=='end':
#timeaxis:
newtimes=py.linspace(timevec[-1],timevec[-1]+desiredLength*self.dt,desiredLength)
paddvec=py.column_stack((newtimes,paddvec))
longvec=py.row_stack((self.tdData,paddvec))
else:
newtimes=py.linspace(timevec[0]-(desiredLength+1)*self.dt,timevec[0],desiredLength)
paddvec=py.column_stack((newtimes,paddvec))
longvec=py.row_stack((paddvec,self.tdData))
self.setTDData(longvec)
def reassign_values(dict):
for key in dict:
if dict[key] < 5:
dict[key] = plb.normal(2, 3, 256)
plb.hist(dict[key], density=True, bins=24)
plb.pause(1)
plb.close()
return dict
def tsallis_rv(qv, Tqv, D):
p = (3.-qv)/(2*(qv-1))
s = ((2.*(qv-1))**0.5) / (Tqv**(1./(3-qv)))
rv = zeros(D, dtype=float)
x = normal(0, 1, D)
u = stats.gamma.rvs(p, loc=0., scale=1., size=1)
y = s*(u**0.5)
rv[:] = x[:]/y
return rv
def histogram_1():
plb.figure(1)
gaus_dist = plb.normal(-2, 2, size=512)
plb.hist(gaus_dist, normed=True, bins=24)
plb.title('Gaussian distribution / Histogram')
plb.xlabel('Value')
plb.ylabel('Frequency')
plb.grid(True)
plb.pause(5)
def tsallis_rv(qv, Tqv, D):
p = (3. - qv) / (2 * (qv - 1))
s = ((2. * (qv - 1))**0.5) / (Tqv**(1. / (3 - qv)))
rv = zeros(D, dtype=float)
x = normal(0, 1, D)
u = stats.gamma.rvs(p, loc=0., scale=1., size=1)
y = s * (u**0.5)
rv[:] = x[:] / y
return rv
def mine_ok():
data = pylab.concatenate(
(pylab.normal(muP, sigmaP,
samplesP), pylab.normal(muC, sigmaC, samplesC)))
y, x, _ = pylab.hist(data, 100, alpha=.3, label='data')
# x = x[1:]
x = (x[1:] + x[:-1]) / 2 # for len(x)==len(y) # TODO what?
expected = (muP, sigmaP, aP, muC, sigmaC, aC)
params, cov = curve_fit(bimodal, x, y, expected)
sigma = numpy.sqrt(numpy.diag(cov))
plt.plot(x, bimodal(x, *params), color='red', lw=3, label='model')
plt.legend()
print('params: ', end='')
print(params)
print('sigma: ', end='')
print(sigma)
def transit_fit_example():
'''Simulate some data containing a transit plus white Gaussian
noise and fit for the planet / star radius ratio (p = Rp / Rs),
epoch Ttr, inclination, and ratio of semi-major axis to stellar
radius (a/Rs), while holding the other parameters fixed at their
true values.'''
JD = numpy.arange(100) * 0.01 - 0.5 + pylab.normal(0, 0.005, 100)
P = 3.0
Ttr_true = 0.0
Ttr_guess = 0.02
p_true = 0.1
p_guess = 0.08
incl_true = 0.99 * numpy.pi / 2.
incl_guess = numpy.pi / 2.
a_true = 5.0
a_guess = 4.5
cn = [0, 0.45, 0, 0.05]
Ecc = 0
omega = 0
sec = 0
truth = lightcurve(JD, P, p_true, Ttr_true, Ecc, a_true, incl_true, \
omega, cn, sec)
flux = truth + pylab.normal(0, 0.002, numpy.size(JD))
flux_err = numpy.ones(numpy.size(JD)) * 0.002
initial_guess = lightcurve(JD, P, p_guess, Ttr_guess, \
Ecc, a_guess, incl_guess, omega, cn, sec)
p_fit, Ttr_fit, incl_fit, a_fit = \
scipy.optimize.fmin(transit_errfunc_ptia, \
[p_guess, Ttr_guess, incl_guess, a_guess], \
args = ([P, Ecc, omega, cn, sec], JD, flux, flux_err))
fit = lightcurve(JD, P, p_fit, Ttr_fit, \
Ecc, a_fit, incl_fit, omega, cn, sec)
pylab.clf()
pylab.errorbar(JD, flux, yerr=flux_err, fmt='k.', label='data')
pylab.plot(JD, truth, 'k-', label='true')
pylab.plot(JD, initial_guess, 'b--', label='initial')
pylab.plot(JD, fit, 'r-', label='fit')
pylab.legend(loc='lower right')
print p_true, p_guess, p_fit
print Ttr_true, Ttr_guess, Ttr_fit
print incl_true, incl_guess, incl_fit
print a_true, a_guess, a_fit
return
def fn2(dict):
for key, val in dict.items():
if val < 5:
# 4.1 Using normal distrib. with mean=2 and std = 3 create a 256pts array
val = plb.normal(loc=2, scale=3, size=256)
# 4.2 Using a histogram with 12 bins, plot the result from 4.1
#plb.figure("Histogram"), plb.title("Gaussian distribution histogram")
#plb.hist(y[key])
#colour='red', label='Normal')
return dict
def rv_sample(obs = None, tspan = 180, npernight = 3, drun = 10, \
nrun = 3, nrand = 10, dnight = 8./24.):
if obs != None:
# Read in RV data
if obs == 'corot7':
rv = atpy.Table(corotdefs.ROOTDIR + 'LRa01/cands/corot7_rv.ipac')
time = rv.JDB
if obs == 'hd189':
rv = atpy.Table('/Users/suz/Data/HD189_rv.ipac')
time = rv.hjd
else:
# One point per night
days = scipy.arange(tspan)
dt_night = dnight / float(npernight + 1)
# Multiple points per night, with small deviations from regularity
obs = scipy.zeros((tspan, npernight))
for i in scipy.arange(npernight):
obs[:,i] = days[:] + dt_night * float(i) + \
pylab.normal(0, dt_night/2., tspan)
# Select points in "intensive" runs
if drun == tspan:
take = scipy.ones((tspan, npernight), 'int')
else:
take = scipy.zeros((tspan, npernight), 'int')
for i in scipy.arange(nrun):
ok = 0
while ok == 0:
tstart = scipy.fix(scipy.rand(1) * float(tspan))
tstart = tstart[0]
tend = tstart + drun
if tend > tspan: continue
if take[tstart:tend, :].any(): continue
take[tstart:tend, :] = 1
ok = 1
# Select additional individual points
ntot = tspan * npernight
obs = scipy.reshape(obs, ntot)
take = scipy.reshape(take, ntot)
index = scipy.argsort(obs)
obs = obs[index]
take = take[index]
for i in scipy.arange(nrand):
ok = 0
while ok == 0:
t = scipy.fix(scipy.rand(1) * float(ntot))
t = t[0]
if take[t] == 1: continue
take[t] = 1
ok = 1
time = obs[(take == 1)]
time -= time[0]
return time
def histogram_2():
plb.figure(2)
gaus_dist = plb.normal(-2, 2, size=512)
unif_dist = plb.uniform(-5, 5, size=512)
plb.hist(unif_dist, bins=24, histtype='stepfilled', normed=True, color='cyan', label='Uniform')
plb.hist(gaus_dist, bins=24, histtype='stepfilled', normed=True, color='orange', label='Gaussian', alpha=0.65)
plb.legend(loc='upper right')
plb.title('Gaussian vs Uniform distribution / Histrogram')
plb.xlabel('Value')
plb.ylabel('Frequency')
plb.grid(True)
plb.pause(5)
def rv_sample(obs = None, tspan = 180, npernight = 3, drun = 10, \
nrun = 3, nrand = 10, dnight = 8./24.):
if obs != None:
# Read in RV data
if obs == 'corot7':
rv = atpy.Table(corotdefs.ROOTDIR + 'LRa01/cands/corot7_rv.ipac')
time = rv.JDB
if obs == 'hd189':
rv = atpy.Table('/Users/suz/Data/HD189_rv.ipac')
time = rv.hjd
else:
# One point per night
days = scipy.arange(tspan)
dt_night = dnight / float(npernight+1)
# Multiple points per night, with small deviations from regularity
obs = scipy.zeros((tspan, npernight))
for i in scipy.arange(npernight):
obs[:,i] = days[:] + dt_night * float(i) + \
pylab.normal(0, dt_night/2., tspan)
# Select points in "intensive" runs
if drun == tspan:
take = scipy.ones((tspan, npernight), 'int')
else:
take = scipy.zeros((tspan, npernight), 'int')
for i in scipy.arange(nrun):
ok = 0
while ok == 0:
tstart = scipy.fix(scipy.rand(1) * float(tspan))
tstart = tstart[0]
tend = tstart + drun
if tend > tspan: continue
if take[tstart:tend,:].any(): continue
take[tstart:tend,:] = 1
ok = 1
# Select additional individual points
ntot = tspan*npernight
obs = scipy.reshape(obs, ntot)
take = scipy.reshape(take, ntot)
index = scipy.argsort(obs)
obs = obs[index]
take = take[index]
for i in scipy.arange(nrand):
ok = 0
while ok == 0:
t = scipy.fix(scipy.rand(1) * float(ntot))
t = t[0]
if take[t] == 1: continue
take[t] = 1
ok = 1
time = obs[(take==1)]
time -= time[0]
return time
def transit_fit_example():
'''Simulate some data containing a transit plus white Gaussian
noise and fit for the planet / star radius ratio (p = Rp / Rs),
epoch Ttr, inclination, and ratio of semi-major axis to stellar
radius (a/Rs), while holding the other parameters fixed at their
true values.'''
JD = numpy.arange(100) * 0.01 - 0.5 + pylab.normal(0, 0.005, 100)
P = 3.0
Ttr_true = 0.0; Ttr_guess = 0.02
p_true = 0.1; p_guess = 0.08
incl_true = 0.99 * numpy.pi / 2.; incl_guess = numpy.pi / 2.
a_true = 5.0; a_guess = 4.5
cn = [0, 0.45, 0, 0.05]
Ecc = 0; omega = 0; sec = 0
truth = lightcurve(JD, P, p_true, Ttr_true, Ecc, a_true, incl_true, \
omega, cn, sec)
flux = truth + pylab.normal(0, 0.002, numpy.size(JD))
flux_err = numpy.ones(numpy.size(JD)) * 0.002
initial_guess = lightcurve(JD, P, p_guess, Ttr_guess, \
Ecc, a_guess, incl_guess, omega, cn, sec)
p_fit, Ttr_fit, incl_fit, a_fit = \
scipy.optimize.fmin(transit_errfunc_ptia, \
[p_guess, Ttr_guess, incl_guess, a_guess], \
args = ([P, Ecc, omega, cn, sec], JD, flux, flux_err))
fit = lightcurve(JD, P, p_fit, Ttr_fit, \
Ecc, a_fit, incl_fit, omega, cn, sec)
pylab.clf()
pylab.errorbar(JD, flux, yerr = flux_err, fmt = 'k.', label = 'data')
pylab.plot(JD, truth, 'k-', label = 'true')
pylab.plot(JD, initial_guess, 'b--', label = 'initial')
pylab.plot(JD, fit, 'r-', label = 'fit')
pylab.legend(loc = 'lower right')
print p_true, p_guess, p_fit
print Ttr_true, Ttr_guess, Ttr_fit
print incl_true, incl_guess, incl_fit
print a_true, a_guess, a_fit
return
def draw_rand_gaussian_pos(self, min_r=pl.array([])):
'''optional min_r, array or tuple of arrays on the form
array([[r0,r1,...,rn],[z0,z1,...,zn]])'''
x = pl.normal(0, self.radius, self.n)
y = pl.normal(0, self.radius, self.n)
z = pl.normal(0, self.radius, self.n)
min_r_z = {}
if pl.size(min_r) > 0: # != False:
if type(min_r) == type(()):
for j in xrange(pl.shape(min_r)[0]):
min_r_z[j] = pl.interp(z, min_r[j][0, ], min_r[j][1, ])
if j > 0:
[w] = pl.where(min_r_z[j] < min_r_z[j - 1])
min_r_z[j][w] = min_r_z[j - 1][w]
minrz = min_r_z[j]
else:
minrz = pl.interp(z, min_r[0], min_r[1])
R_z = pl.sqrt(x**2 + y**2)
[u] = pl.where(R_z < minrz)
while len(u) > 0:
for i in xrange(len(u)):
x[u[i]] = pl.normal(0, self.radius, 1)
y[u[i]] = pl.normal(0, self.radius, 1)
z[u[i]] = pl.normal(0, self.radius, 1)
if type(min_r) == type(()):
for j in xrange(pl.shape(min_r)[0]):
min_r_z[j][u[i]] = pl.interp(
z[u[i]], min_r[j][0, ], min_r[j][1, ])
if j > 0:
[w] = pl.where(min_r_z[j] < min_r_z[j - 1])
min_r_z[j][w] = min_r_z[j - 1][w]
minrz = min_r_z[j]
else:
minrz[u[i]] = pl.interp(z[u[i]], min_r[0, ],
min_r[1, ])
R_z = pl.sqrt(x**2 + y**2)
[u] = pl.where(R_z < minrz)
soma_pos = {
'xpos': x,
'ypos': y,
'zpos': z,
}
return soma_pos
def rv_noise(time, tau = 0.5, ninit = 10):
npt = len(time)
# Burn-in section
dt = 2.3 * tau / float(ninit)
tinit = (scipy.arange(ninit) + 1) * dt
tsim = scipy.append(time[0] - tinit[::-1], time)
nsim = len(tsim)
# Instead of Gaussian white noise, to simulate effects of moon and
# such like, each point in the "WGN" component is drawn from a
# distribution with a different sigma each night, where the sigma itself is
# drawn from a powerlaw distribution between 1 and 10
wt = pylab.normal(0, 1, nsim)
ye = scipy.ones(nsim)
nights = scipy.fix(tsim)
unights = scipy.unique(nights)
nnights = len(unights)
sigma = 10.0 ** (scipy.rand(nnights))**4
for i in scipy.arange(nnights):
l = scipy.where(nights == unights[i])[0]
if l.any():
wt[l] *= sigma[i]
ye[l] = sigma[i]
# Now apply MA model with exponentially decaying correlation
ysim = scipy.copy(wt)
for i in scipy.arange(nsim):
j = i - 1
coeff = 1.0
while (j > 0) * (coeff > 0.1):
dt = tsim[i] - tsim[j]
coeff = scipy.exp(-dt/tau)
ysim[i] += coeff * wt[j]
j -= 1
# Discard burn-in and globally re-scale before returning
yout = ysim[ninit:]
eout = ye[ninit:]
med, sig = filter.medsig(yout)
yout /= sig
eout /= sig
return yout, eout
def targetFunction(x,y):
return sin(x-3.0)*cos(y) + normal(0,0.1)
print("Deltal = ", Deltal)
border = int(N[0] / 10)
mask = np.zeros(N)
mask[border:-border, border:-border] = 1.0
mask = np.ones(N)
fmask = np.sum(mask) / np.prod(N)
lmax = 10000
lbins = np.linspace(0, lmax, 50)
lcent = lbins[:-1] + np.diff(lbins) / 2.
# Make some E/B
N1 = pylab.normal(size=N)
T = gaussian_filter(N1, 2, mode='wrap')
E = gaussian_filter(N1, 2, mode='wrap')
B = np.zeros(N)
Eharm = cmbtools.map2harm(E, Delta)
Bharm = cmbtools.map2harm(B, Delta)
ClEE = cmbtools.harm2cl(Eharm, Deltal, lbins)
ClBB = cmbtools.harm2cl(Bharm, Deltal, lbins)
Qharm, Uharm = cmbtools.EB2QU(Eharm, Bharm, Deltal)
Q = cmbtools.harm2map(Qharm, Delta) * mask
U = cmbtools.harm2map(Uharm, Delta) * mask
def run(self,
seed_infections=1,
verbose=None,
calc_likelihood=False,
do_plot=False,
**kwargs):
''' Run the simulation '''
T = sc.tic()
# Reset settings and results
if verbose is None:
verbose = self['verbose']
self.init_results()
self.init_people(
seed_infections=seed_infections) # Actually create the people
daily_tests = self.data[
'new_tests'] # Number of tests each day, from the data
evacuated = self.data['evacuated'] # Number of people evacuated
# Main simulation loop
for t in range(self.npts):
# Print progress
if verbose >= 1:
string = f' Running day {t:0.0f} of {self.pars["n_days"]}...'
if verbose >= 2:
sc.heading(string)
else:
print(string)
self.results['t'][t] = t
test_probs = {
} # Store the probability of each person getting tested
# Update each person
for person in self.people.values():
# Count susceptibles
if person.susceptible:
self.results['n_susceptible'][t] += 1
# Handle testing probability
if person.infectious:
test_probs[person.uid] = self[
'symptomatic'] # They're infectious: high probability of testing
else:
test_probs[person.uid] = 1.0
# If exposed, check if the person becomes infectious
if person.exposed:
self.results['n_exposed'][t] += 1
if not person.infectious and t >= person.date_infectious: # It's the day they become infectious
person.infectious = True
if verbose >= 2:
print(
f' Person {person.uid} became infectious!'
)
# If infectious, check if anyone gets infected
if person.infectious:
# First, check for recovery
if person.date_recovered and t >= person.date_recovered: # It's the day they become infectious
person.exposed = False
person.infectious = False
person.recovered = True
self.results['recoveries'][t] += 1
else:
self.results['n_infectious'][
t] += 1 # Count this person as infectious
n_contacts = cov_ut.pt(
person.contacts
) # Draw the number of Poisson contacts for this person
contact_inds = cov_ut.choose_people(
max_ind=len(self.people),
n=n_contacts) # Choose people at random
for contact_ind in contact_inds:
exposure = cov_ut.bt(
self['r_contact']
) # Check for exposure per person
if exposure:
target_person = self.people[contact_ind]
if target_person.susceptible: # Skip people who are not susceptible
self.results['infections'][t] += 1
target_person.susceptible = False
target_person.exposed = True
target_person.date_exposed = t
incub_dist = round(
pl.normal(person.pars['incub'],
person.pars['incub_std']))
dur_dist = round(
pl.normal(person.pars['dur'],
person.pars['dur_std']))
target_person.date_infectious = t + incub_dist
target_person.date_recovered = target_person.date_infectious + dur_dist
if verbose >= 2:
print(
f' Person {person.uid} infected person {target_person.uid}!'
)
# Count people who recovered
if person.recovered:
self.results['n_recovered'][t] += 1
# Implement testing -- this is outside of the loop over people, but inside the loop over time
if t < len(
daily_tests
): # Don't know how long the data is, ensure we don't go past the end
n_tests = daily_tests.iloc[t] # Number of tests for this day
if n_tests and not pl.isnan(
n_tests): # There are tests this day
self.results['tests'][
t] = n_tests # Store the number of tests
test_probs = pl.array(list(test_probs.values()))
test_probs /= test_probs.sum()
test_inds = cov_ut.choose_people_weighted(probs=test_probs,
n=n_tests)
uids_to_pop = []
for test_ind in test_inds:
tested_person = self.people[test_ind]
if tested_person.infectious and cov_ut.bt(
self['sensitivity']
): # Person was tested and is true-positive
self.results['diagnoses'][t] += 1
tested_person.diagnosed = True
if self['evac_positives']:
uids_to_pop.append(tested_person.uid)
if verbose >= 2:
print(
f' Person {person.uid} was diagnosed!'
)
for uid in uids_to_pop: # Remove people from the ship once they're diagnosed
self.off_ship[uid] = self.people.pop(uid)
# Implement quarantine
if t == self['quarantine']:
if verbose >= 1:
print(f'Implementing quarantine on day {t}...')
for person in self.people.values():
if 'quarantine_eff' in self.pars.keys():
quarantine_eff = self['quarantine_eff'] # Both
else:
if person.crew:
quarantine_eff = self['quarantine_eff_c'] # Crew
else:
quarantine_eff = self['quarantine_eff_g'] # Guests
person.contacts *= quarantine_eff
# Implement testing change
if t == self['testing_change']:
if verbose >= 1:
print(f'Implementing testing change on day {t}...')
self['symptomatic'] *= self[
'testing_symptoms'] # Reduce the proportion of symptomatic testing
# Implement evacuations
if t < len(evacuated):
n_evacuated = evacuated.iloc[
t] # Number of evacuees for this day
if n_evacuated and not pl.isnan(
n_evacuated
): # There are evacuees this day # TODO -- refactor with n_tests
if verbose >= 1:
print(f'Implementing evacuation on day {t}')
evac_inds = cov_ut.choose_people(max_ind=len(self.people),
n=n_evacuated)
uids_to_pop = []
for evac_ind in evac_inds:
evac_person = self.people[evac_ind]
if evac_person.infectious and cov_ut.bt(
self['sensitivity']):
self.results['evac_diagnoses'][t] += 1
uids_to_pop.append(evac_person.uid)
for uid in uids_to_pop: # Remove people from the ship once they're diagnosed
self.off_ship[uid] = self.people.pop(uid)
# Compute cumulative results
self.results['cum_exposed'] = pl.cumsum(self.results['infections'])
self.results['cum_tested'] = pl.cumsum(self.results['tests'])
self.results['cum_diagnosed'] = pl.cumsum(self.results['diagnoses'])
# Compute likelihood
if calc_likelihood:
self.likelihood()
# Tidy up
self.results['ready'] = True
elapsed = sc.toc(T, output=True)
if verbose >= 1:
print(f'\nRun finished after {elapsed:0.1f} s.\n')
summary = self.summary_stats()
print(f"""Summary:
{summary['n_susceptible']:5.0f} susceptible
{summary['n_exposed']:5.0f} exposed
{summary['n_infectious']:5.0f} infectious
""")
if do_plot:
self.plot(**kwargs)
return self.results
def mklc(nspot = 200, incl = (scipy.pi)*5./12., amp = 0.01, \
tau = 30.5, diffrot = 0.0, \
dur = 20.0, samp = 0.01, noise = 0.001, doplot = False, myperiod = [10.0], Amplitude = 1.0, quarter = 3):
# spots.py calls runSim which calls mklc
''' This is a simplified version of the class-based routines in
spot_model.py. It generates a light curves for dark, point like
spots with no limb-darkening.
Parameters:
nspot = desired number of spots present on star at any
one time
amp = desired light curve amplitude
tau = characteristic spot life-time
dur = light curve duration
samp = time-sampling
diffrot = fractional difference between equatorial and polar
rotation period
doplot: set to True to produce plots
(unit of time is equatorial rotation period)'''
# IMPORT KEPLER LIGHTCURVE
name = '006370489'
time2 = []; lightcurve = []
quarter_times2 = []
quarter_times_start = []
quarter_times_fin = []
files = glob.glob('/Users/angusr/angusr/data2/all_Qs/kplr%s-*llc.fits' % (name))
#print len(files)
for f in range(0,12):
hdulist = pyfits.open(files[f])
tbdata = hdulist[1].data #"add the first extension to tbdata"
x = numpy.where(numpy.isfinite(tbdata['TIME']))
time = tbdata['TIME'][x]
lc = tbdata['PDCSAP_FLUX'][x]
x = numpy.where(numpy.isfinite(tbdata['PDCSAP_FLUX']))
time = tbdata['TIME'][x]
lc = tbdata['PDCSAP_FLUX'][x]
quarter_times2.append(tbdata['TIME'])
quarter_times_start.append(time[0])
quarter_times_fin.append(time[-1])
lightcurve.extend(numpy.array(lc))
time2.extend(numpy.array(time))
# myperiod = float(myperiod[0])
print 'Period = ', myperiod
dur = (max(time2) - min(time2))
# SET UP THE SPOTS
print 'Setting up the spots...'
# (crude estimate of) total number of spots needed during entire
# time-series
nspot_tot = int(nspot * dur / 2 / tau)
# uniform distribution of spot longitudes
lon = scipy.rand(nspot_tot) * 2 * scipy.pi
# distribution of spot latitudes uniform in sin(latitude)
lat = scipy.arcsin(scipy.rand(nspot_tot))
# spot rotation rate optionally depends on latitude
period = ((scipy.sin(lat) - 0.5) * diffrot + 1.0 )*myperiod
period0 = scipy.ones(nspot_tot)*myperiod
# all spots have the same maximum area
# (crude estimate of) filling factor needed per spot
ff = amp / scipy.sqrt(nspot)
scale_fac = 1
amax = scipy.ones(nspot_tot) * ff * scale_fac
# all spots have the evolution timescale
decay = scipy.ones(nspot_tot) * tau
# uniform distribution of spot peak times
# start well before and end well after time-series limits (to
# avoid edge effects)
extra = 3 * decay.max()
pk = scipy.rand(nspot_tot) * (dur + 2 * extra) - extra
# COMPUTE THE LIGHT CURVE
print 'Computing the light curve...'
time = numpy.array(time2- min(time2))
addit = min(time2)
npt = len(time)
area_tot = scipy.zeros(npt)
dF_tot = scipy.zeros(npt)
dF_tot0 = scipy.zeros(npt)
# add up the contributions of individual spots
for i in range(nspot_tot):
# Spot area
if (pk[i] == 0) + (decay[i] == 0):
area = scipy.ones(npt) * amax[i]
else:
area = amax[i] * \
scipy.exp(-(time - pk[i])**2 / 2. / decay[i]**2)
area_tot += area
# Fore-shortening
phase = 2 * scipy.pi * time / period[i] + lon[i]
phase0 = 2 * scipy.pi * time / period0[i] + lon[i]
mu = scipy.cos(incl) * scipy.sin(lat[i]) + \
scipy.sin(incl) * scipy.cos(lat[i]) * scipy.cos(phase)
mu0 = scipy.cos(incl) * scipy.sin(lat[i]) + \
scipy.sin(incl) * scipy.cos(lat[i]) * scipy.cos(phase0)
mu[mu < 0] = 0.0
mu0[mu0 < 0] = 0.0
# Flux
dF_tot -= area * mu
dF_tot0 -= area * mu0
print 'Adding noise...'
# ADD NOISE
noi = pylab.normal(0, 1, npt) * noise
dF_tot += noi
dF_tot0 += noi
amp_eff = dF_tot.max()-dF_tot.min()
nspot_eff = area_tot / scale_fac / ff
if doplot == True:
print 'Used %d spots in total over %d rotation periods.' \
% (nspot_tot, dur)
print 'Mean filling factor of individual spots was %.4f.' \
% ff
print 'Desired amplitude was %.4f, actual amplitude was %.4f.' \
% (amp, amp_eff)
print 'Desired number of spots at any one time was %d.' % nspot
print 'Actual number of spots was %d (min), %d (average), %d (max).' \
pylab.close(1)
pylab.figure(1, (10, 4))
xoff = 0.1
xoffr = 0.05
yoff = 0.13
yoffr = 0.07
xwi = (1.0 - xoff - xoffr)
ywi = (1.0 - yoff - yoffr) / 2
xll = xoff
yll = 1.0 - yoffr - ywi
ax1 = pylab.axes([xll, yll, xwi, ywi])
pylab.plot(time, area_tot * 100, 'k-')
#pylab.title('i=%.1f <Ns>=%d A=%.4f Fs=%.4f tau=%.2fP sig=%.4f diff=%.1f' \
# % (incl * 180 / scipy.pi, nspot_eff.mean(), amp_eff, ff, tau, noise, diffrot))
#pylab.title('i=%.1f <Ns>=%d tau=%.2fP Period = %d days' \
# % (incl * 180 / scipy.pi, nspot_eff.mean(), tau, myperiod))
pylab.ylabel('fill. fac. (%)')
yll = 1.0 - yoffr - 2 * ywi
axc = pylab.axes([xll, yll, xwi, ywi], sharex = ax1)
pylab.plot(time, 1 + dF_tot, 'k-', label = 'diff rot')
pylab.plot(time, 1 + dF_tot0 - amp_eff, 'r-', label = 'no diff rot')
pylab.ylabel('rel. flux')
pylab.xlabel('time (days)')
pylab.xlim(time.min(), time.max())
pylab.legend()
#pylab.savefig('/Users/angusr/angusr/ACF/star_spot_sim', )
# Split into quarters
print 'quarter = ', quarter
time = time + addit
#print 'start = ', quarter_times_start[quarter]
#print 'stop = ', quarter_times_fin[quarter]
print quarter_times_start
print quarter_times_fin
x = numpy.where(time == quarter_times_start[quarter])
y = numpy.where(time == quarter_times_fin[quarter])
start = int(x[0])
stop = int(y[0])
time = time[start:stop]
area_tot = area_tot[start:stop]
dF_tot = dF_tot[start:stop]
dF_tot0 = dF_tot0[start:stop]
lightcurve = lightcurve[start:stop]
# Add normalised Kepler lc to simulated lc
lightcurve = lightcurve/numpy.median(lightcurve)
lightcurve = lightcurve - numpy.median(lightcurve)
dF_tot = dF_tot - numpy.median(dF_tot)
dF_tot0 = dF_tot0 - numpy.median(dF_tot0)
#dF_tot = (dF_tot)*numpy.median(lightcurve) + lightcurve
#dF_tot0 = (dF_tot0)*numpy.median(lightcurve) + lightcurve
# Normalise
#dF_tot = dF_tot/numpy.median(dF_tot)
#dF_tot0 = dF_tot0/numpy.median(dF_tot0)
npt = len(time)
res0 = scipy.array([nspot_eff.mean(), ff, amp_eff, noise])
res1 = scipy.zeros((4, npt))
pylab.close(2)
pylab.figure(2)
pylab.subplot(3,1,1)
pylab.plot(time, dF_tot, 'r.')
pylab.ylim(min(dF_tot), max(dF_tot))
pylab.subplot(3,1,2)
pylab.ylim(min(lightcurve),max(lightcurve))
pylab.plot(time, lightcurve, 'b.')
pylab.subplot(3,1,3)
pylab.ylim(min(lightcurve),max(lightcurve))
dF_tot2 = dF_tot + lightcurve*Amplitude
pylab.plot(time, dF_tot, 'g.')
pylab.ylim(min(dF_tot), max(dF_tot))
res1[0,:] = time
res1[1,:] = area_tot
res1[2,:] = dF_tot
res1[3,:] = dF_tot0
print 'Done'
return res0, res1
def normDistRejected(
r, rd, rsigma): #looks for smaller particles in case of rejection
x = pl.normal(r, rsigma)
while x > rd:
x = pl.normal(r, rsigma)
return x
def targetFunction(x, y):
return sin(x - 3.0) * cos(y) + normal(0, 0.1)
B = my_func(A)
print(B)
def replace(my_dict, my_array):
for i, j in my_dict.items():
if j < 5:
my_dict[i] = my_array
else:
continue
return my_dict
my_array = plb.normal(loc=2, scale=3, size=256)
C = replace(B, my_array)
C['A'] = C.pop('E')
#print(C)
C['F'] = 1980
del C['D']
#print(C)
# if A.values() < B.values():
# print("A is less than B")
# elif A.values() < C.values():
# print("A is less than C")
# else:
# print('A is the father')
def walk(self, meanStep, varianceStep):
walkSize = normal(meanStep, varianceStep)
self.meanReturn += walkSize
return walkSize
def targetFunction(in1, in2):
return sin(in1 - 3.0) * cos(in2) + normal(0, 0.1)
logreturnf = np.vectorize(logreturn)
logret = (logreturnf(i))
return (logret)
with open(
'MICRO.csv'
) as csvdata: #gets the stoke price microsoft from dec20, 2016 to dec 20, 2019
read = csv.reader(csvdata, delimiter=',')
a1 = []
for r in read:
S = r[1]
a1.append(float(S))
S1 = a1
N = len(a1)
Normal = pl.normal(0, 1, size=len(f2(1))) #normal estimates
fig, ax = pl.subplots(1, 3)
ax[0].plot(a1)
ax[1].plot(pl.sort(Normal), f2(1)) #QQ plot
ax[1].set_xlabel('normal distribution')
ax[1].set_ylabel('normalized logret')
ax[1].legend(('QQ plot'), loc='upper right')
ax[2].acorr(f3(1), maxlags=60) #AUTOCORRELATION PLOT
ax[2].set_xlabel('autocorrelation plot')
pl.tight_layout()
pl.show()
S1 = a1
N = len(S1)
print("[mu,sigma]", f1(1))
#QUESTION NO (c)
def targetFunction(*X):
return sin(X[0]) + cos(X[1]) + normal(0., 0.1)
def targetFunction(in1,in2):
return sin(in1-3.0)*cos(in2) + normal(0,0.1)
def Main_vbjde(graph,Y,Onsets,Thrf,K,TR,beta,dt,hrf,NitMax = -1, hrf = None):
if NitMax < 0:
NitMax = 100
D = int(numpy.ceil(Thrf/dt))
M = len(Onsets)
N = Y.shape[0]
J = Y.shape[1]
l = int(sqrt(J))
sigma_epsilone = numpy.ones(J)
X = {}
for condition,Ons in Onsets.iteritems():
X[condition] = compute_mat_X_2(N, TR, D, dt, Ons)
mu_M = numpy.zeros((M,K),dtype=float)
sigma_M = 0.5 * numpy.ones((M,K),dtype=float)
mu_M0 = numpy.zeros((M,K),dtype=float)
sigma_M0 = numpy.zeros((M,K),dtype=float)
for k in xrange(0,K):
mu_M[:,0] = 2.0
mu_M0[:,:] = mu_M[:,:]
sigma_M0[:,:] = sigma_M[:,:]
#sigmaH = numpy.ones((J),dtype=float)
#sigmaH1 = numpy.ones((J),dtype=float)
sigmaH = 0.1
sigmaH1 = 0.1
order = 2
D2 = buildFiniteDiffMatrix(order,D)
R = numpy.dot(D2,D2) / pow(dt,2*order)
Gamma = numpy.identity(N)
q_Z = numpy.zeros((M,K,J),dtype=float)
for k in xrange(0,K):
q_Z[:,1,:] = 1
q_Z1 = q_Z.copy()
Z_tilde = q_Z.copy()
Sigma_A = numpy.zeros((M,M,J),float)
m_A = numpy.zeros((J,M),dtype=float)
m_H = numpy.zeros((D,J),dtype=float)
m_H1 = numpy.zeros((D,J),dtype=float)
m_H2 = numpy.zeros((D,J),dtype=float)
TT,m_h = getCanoHRF(Thrf-dt,dt)
for j in xrange(0,J):
Sigma_A[:,:,j] = 0.01*numpy.identity(M)
for m in xrange(0,M):
for k in xrange(0,K):
m_A[j,m] += normal(mu_M[m,k], numpy.sqrt(sigma_M[m,k]))*Z_tilde[m,k,j]
m_H[:,j] = numpy.array(m_h)
m_H1[:,j] = numpy.array(m_h)
#m_H = numpy.array(m_h)
#m_H1 = numpy.array(m_h)
Sigma_H = numpy.ones((D,D,J),dtype=float)
#Sigma_H = 0.1 * numpy.identity(D)
Beta = beta * numpy.ones((M),dtype=float)
m_A1 = numpy.zeros((J,M),dtype=float)
m_A1[:,:] = m_A[:,:]
Crit_H = [0]
Crit_Z = [0]
Crit_sigmaH = [0]
Hist_sigmaH = []
ni = 0
Y_bar_tilde = numpy.zeros((D),dtype=float)
zerosND = numpy.zeros((N,D),dtype=float)
X_tilde = numpy.zeros((Y.shape[1],M,D),dtype=float)
Q_bar = numpy.zeros(R.shape)
P = PolyMat( N , 4 , TR)
L = polyFit(Y, TR, 4,P)
PL = numpy.dot(P,L)
y_tilde = Y - PL
t1 = time.time()
Norm = numpy.zeros((J),dtype=float)
while (( (ni < 15) or (Crit_sigmaH[-1] > 5e-3) or (Crit_H[-1] > 5e-3) or (Crit_Z[-1] > 5e-3))) \
and (ni < NitMax):
print "------------------------------ Iteration n° " + str(ni+1) + " ------------------------------"
pyhrf.verbose(2,"------------------------------ Iteration n° " + str(ni+1) + " ------------------------------")
pyhrf.verbose(3, "E A step ...")
Sigma_A, m_A = expectation_A(Y,Sigma_H,m_H,m_A,X,Gamma,PL,sigma_M,q_Z,mu_M,D,N,J,M,K,y_tilde,Sigma_A,sigma_epsilone)
pyhrf.verbose(3,"E H step ...")
Sigma_H, m_H = expectation_H(Y,Sigma_A,m_A,X,Gamma,PL,D,R,sigmaH,J,N,y_tilde,zerosND,sigma_epsilone,Sigma_H,m_H)
Crit_H += [abs(numpy.mean(m_H - m_H1) / numpy.mean(m_H))]
m_H1[:,:] = m_H[:,:]
m_H2[:,:] = m_H[:,:]
pyhrf.verbose(3,"E Z step ...")
q_Z,Z_tilde = expectation_Z(Sigma_A,m_A,sigma_M,Beta,Z_tilde,mu_M,q_Z,graph,M,J,K)
DIFF = abs(numpy.reshape(q_Z,(M*K*J)) - numpy.reshape(q_Z1,(M*K*J)))
Crit_Z += [numpy.mean(DIFF) / (DIFF != 0).sum()]
q_Z1[:,:] = q_Z[:,:]
pyhrf.verbose(3,"M (mu,sigma) step ...")
mu_M , sigma_M = maximization_mu_sigma(mu_M,sigma_M,q_Z,m_A,K,M)
pyhrf.verbose(3,"M sigma_H step ...")
#print "M sigma_H step ..."
sigmaH = maximization_sigmaH(m_H,R,J,D,Sigma_H,sigmaH)
#print sigmaH
#sigmaH = numpy.dot(numpy.dot(m_H.transpose(),R) , m_H ) #+ (numpy.dot(Sigma_H,R)).trace()
Crit_sigmaH += [abs((sigmaH - sigmaH1) / sigmaH)]
Hist_sigmaH += [sigmaH]
sigmaH1 = sigmaH
pyhrf.verbose(3,"M L step ...")
L = maximization_L(Y,m_A,X,m_H,L,P)
PL = numpy.dot(P,L)
y_tilde = Y - PL
pyhrf.verbose(3,"M sigma_epsilone step ...")
sigma_epsilone = maximization_sigma_noise(Y,X,m_A,m_H,Sigma_H,Sigma_A,PL,sigma_epsilone,M)
for i in xrange(0,J):
Norm[i] = norm(m_H[:,i])
m_H2[:,i] /= Norm[i]
if ( (ni+1)% 1) == 0:
pyplot.clf()
figure(1)
plot(m_H[:,10],'r')
hold(True)
plot(hrf/norm(hrf),'b')
legend( ('Est','Ref') )
title(str(sigmaH))
hold(False)
draw()
show()
for m in range(0,M):
for k in range(0,K):
z1 = q_Z[m,k,:];
z2 = reshape(z1,(l,l));
figure(2).add_subplot(M,K,1 + m*K + k)
imshow(z2)
title("m = " + str(m) +"k = " + str(k))
draw()
show()
ni +=1
t2 = time.time()
CompTime = t2 - t1
for i in xrange(0,J):
Norm[i] = norm(m_H[:,i])
m_H[:,i] /= Norm[i]
m_A[i,:] *= Norm[i]
pyhrf.verbose(1, "Computational time = " + str(int( CompTime//60 ) ) + " min " + str(int(CompTime%60)) + " s")
return m_A, m_H, q_Z , sigma_epsilone, sigmaH
# Histogram 2/2:
import pylab as plb
plb.figure(2)
gaus_dist = plb.normal(size=512) # create a random floating point vector
unif_dist = plb.uniform(-5, 5,
size=512) # Create a uniform distribution vector
#plot the histogrm with specific bin number, color, transparency, label
plb.hist(unif_dist,
bins=24,
histtype='stepfilled',
density=True,
color='cyan',
label='Uniform')
plb.hist(gaus_dist,
bins=24,
histtype='stepfilled',
density=True,
color='orange',
label='Gaussian',
alpha=0.65)
plb.legend(loc='upper left')
plb.title("Gaussian vs Uniform distribution / Histogram")
plb.xlabel("value")
plb.ylabel("Frequency")
plb.grid(True)
plb.pause(5)
def targetFunction(in1,in2):
return sin(log(in1)/(in1**2+sqrt(2*in1)+1))+cos(exp(in2)/(in2**2-sqrt(2*in2)+1))+normal(0,0.5)
def GP_train_MCMC(Nstep, x, y, cov_par, cov_scales, cov_func = None, \
cov_typ = 'SE', cov_prior = None, \
MF = None, MF_par = None, MF_scales = None, MF_args = None, \
MF_prior = None):
'''
MCMC over GP hyper-parameters. Calls GP_negloglik. Takes care of
merging / splitting the fixed / variable and cov / MF parameters
Returns a Nstep x (M+1) array where M is the number of *variable*
(scale > 0) hyper-parameters. The first column of the return array
contains the neg log likelihood values, then the other columns the
parameters that were varied along the chain.
'''
# Sort out the fixed / variable and cov / MF parameters
if MF != None:
params = scipy.append(cov_par, MF_par)
scales = scipy.append(cov_scales, MF_scales)
n_MF_par = len(MF_par)
if MF_prior == None:
if cov_prior == None:
prior = None
else:
prior = numpy.copy(cov_prior)
else:
if cov_prior == None:
prior = numpy.copy(MF_prior)
else:
prior = scipy.append(cov_prior, MF_prior)
if MF_args == None: MF_args = x
else:
params = cov_par[:]
scales = cov_scales[:]
n_MF_par = 0
prior = numpy.copy(cov_prior)
# No do MCMC proper
fixed = scales == 0
var = scales > 0
nvar = var.sum()
var_par = params[scales > 0]
var_scales = scales[scales > 0]
fixed_par = scales[scales == 0]
chain = scipy.zeros((Nstep, nvar+1)) - 1
logL = - GP_negloglik(var_par, x, y, covfunc = cov_func, covtyp = cov_typ, \
MF = MF, n_MF_par = n_MF_par, \
MF_args = MF_args, fixed = fixed, fixed_par = params[fixed])
randnos = scipy.log(scipy.rand(Nstep))
for i in range(Nstep):
shift = pylab.normal(0., 1., nvar) * scales[var]
var_par_new = var_par + shift
print var_par_new
logL_new = \
- GP_negloglik(var_par_new, x, y, covfunc = cov_func, \
covtyp = cov_typ, MF = MF, n_MF_par = n_MF_par, \
MF_args = MF_args, fixed = fixed, fixed_par = params[fixed], \
prior = prior)
dlogL = logL_new - logL
if (randnos[i] <= dlogL):
print '%8.6f %11.6f %11.6f %8.6f %8.6f %1s' % \
(i/float(Nstep), logL, logL_new, dlogL, randnos[i], 'A')
var_par = var_par_new
logL = logL_new
else:
print '%8.6f %11.6f %11.6f %8.6f %8.6f %1s' % \
(i/float(Nstep), logL, logL_new, dlogL, randnos[i], 'R')
# Store the new values of the parameters and the new merit function
chain[i,0] = logL
chain[i,1:] = scipy.array(var_par)
return chain
def mklc(x, nspot, incl, amp, tau, diffrot, dur, samp, noise, myperiod, \
Amplitude, doplot = False):
''' This is a simplified version of the class-based routines in
spot_model.py. It generates a light curves for dark, point like
spots with no limb-darkening.
Parameters:
nspot = desired number of spots present on star at any
one time
amp = desired light curve amplitude
tau = characteristic spot life-time
dur = light curve duration
samp = time-sampling
diffrot = fractional difference between equatorial and polar
rotation period
doplot: set to True to produce plots
(unit of time is equatorial rotation period)'''
print 'Period = ', myperiod
dur = (max(x) - min(x))
# SET UP THE SPOTS
print 'Setting up the spots...'
# (crude estimate of) total number of spots needed during entire
# time-series
nspot_tot = int(nspot * dur / 2 / tau)
print nspot, 'nspot', dur, 'dur', tau, 'tau'
# uniform distribution of spot longitudes
lon = scipy.rand(nspot_tot) * 2 * scipy.pi
# distribution of spot latitudes uniform in sin(latitude)
lat = scipy.arcsin(scipy.rand(nspot_tot))
# spot rotation rate optionally depends on latitude
period = ((scipy.sin(lat) - 0.5) * diffrot + 1.0 )*myperiod
period0 = scipy.ones(nspot_tot)*myperiod
# all spots have the same maximum area
# (crude estimate of) filling factor needed per spot
ff = amp / scipy.sqrt(nspot)
scale_fac = 1
amax = scipy.ones(nspot_tot) * ff * scale_fac
# all spots have the evolution timescale
decay = scipy.ones(nspot_tot) * tau
# uniform distribution of spot peak times
# start well before and end well after time-series limits (to
# avoid edge effects)
extra = 3 * decay.max()
pk = scipy.rand(nspot_tot) * (dur + 2 * extra) - extra
# COMPUTE THE LIGHT CURVE
print 'Computing the light curve...'
time = np.array(x - min(x))
addit = min(x)
npt = len(time)
area_tot = scipy.zeros(npt)
dF_tot = scipy.zeros(npt)
dF_tot0 = scipy.zeros(npt)
print "add up the contributions of individual spots"
print nspot_tot
for i in range(nspot_tot):
# Spot area
if (pk[i] == 0) + (decay[i] == 0):
area = scipy.ones(npt) * amax[i]
else:
area = amax[i] * \
scipy.exp(-(time - pk[i])**2 / 2. / decay[i]**2)
area_tot += area
# Fore-shortening
phase = 2 * scipy.pi * time / period[i] + lon[i]
phase0 = 2 * scipy.pi * time / period0[i] + lon[i]
mu = scipy.cos(incl) * scipy.sin(lat[i]) + \
scipy.sin(incl) * scipy.cos(lat[i]) * scipy.cos(phase)
mu0 = scipy.cos(incl) * scipy.sin(lat[i]) + \
scipy.sin(incl) * scipy.cos(lat[i]) * scipy.cos(phase0)
mu[mu < 0] = 0.0
mu0[mu0 < 0] = 0.0
# Flux
dF_tot -= area * mu
dF_tot0 -= area * mu0
print 'Adding noise...'
# ADD NOISE
noi = pylab.normal(0, 1, npt) * noise
dF_tot += noi
dF_tot0 += noi
amp_eff = dF_tot.max()-dF_tot.min()
nspot_eff = area_tot / scale_fac / ff
if doplot == True:
print 'Used %d spots in total over %d rotation periods.' \
% (nspot_tot, dur)
print 'Mean filling factor of individual spots was %.4f.' \
% ff
print 'Desired amplitude was %.4f, actual amplitude was %.4f.' \
% (amp, amp_eff)
print 'Desired number of spots at any one time was %d.' % nspot
print 'Actual number of spots was %d (min), %d (average), %d (max).' \
pylab.close(1)
pylab.figure(1, (10, 4))
xoff = 0.1
xoffr = 0.05
yoff = 0.13
yoffr = 0.07
xwi = (1.0 - xoff - xoffr)
ywi = (1.0 - yoff - yoffr) / 2
xll = xoff
yll = 1.0 - yoffr - ywi
ax1 = pylab.axes([xll, yll, xwi, ywi])
pylab.plot(time, area_tot * 100, 'k-')
#pylab.title('i=%.1f <Ns>=%d A=%.4f Fs=%.4f tau=%.2fP sig=%.4f diff=%.1f' \
# % (incl * 180 / scipy.pi, nspot_eff.mean(), amp_eff, ff, tau, noise, diffrot))
#pylab.title('i=%.1f <Ns>=%d tau=%.2fP Period = %d days' \
# % (incl * 180 / scipy.pi, nspot_eff.mean(), tau, myperiod))
pylab.ylabel('fill. fac. (%)')
yll = 1.0 - yoffr - 2 * ywi
axc = pylab.axes([xll, yll, xwi, ywi], sharex = ax1)
pylab.plot(time, 1 + dF_tot, 'k-', label = 'diff rot')
pylab.plot(time, 1 + dF_tot0 - amp_eff, 'r-', label = 'no diff rot')
pylab.ylabel('rel. flux')
pylab.xlabel('time (days)')
pylab.xlim(time.min(), time.max())
pylab.legend()
# Normalise
dF_tot = dF_tot/np.median(dF_tot) - 1.
dF_tot0 = dF_tot0/np.median(dF_tot0) -1.
# Split into quarters
time = time + addit
res0 = scipy.array([nspot_eff.mean(), ff, amp_eff, noise])
res1 = scipy.zeros((4, npt))
res1[0,:] = time
res1[1,:] = area_tot
res1[2,:] = dF_tot
res1[3,:] = dF_tot0
print 'Done'
return res0, res1
plt.pause(1)
luminosity = image[:, :, 0]
plt.imshow(luminosity)
plt.show(5)
plt.imshow(luminosity, cmap='hot')
plt.show(5)
plt.imshow(luminosity, cmap='spectral')
plt.show(5)
# In[22]:
plb.figure(1)
gaus_dist = plb.normal(-2, 2, size=512) #random vector
plb.hist(gaus_dist, normed=True, bins=24)
plb.title("Gaussian Distribution / Histogram")
plb.xlabel("Value")
plb.ylabel("Frequency")
plb.grid(True)
plb.show()
# In[24]:
#Histogram 2
plb.figure(2)
gaus_dist = plb.normal(size=512)
unif_dist = plb.uniform(-5, 5, size=512) # uniform distibution vector
