def setParams(self):
oo = self
# #generate initial values of parameters
oo._d = _kfardat.KFARGauObsDat(oo.TR, oo.N, 1)
oo._d.copyData(oo.y)
# baseFN_inter baseFN_comps baseFN_comps
oo.smpx = _N.zeros((oo.TR, oo.N + 1)) # start at 0 + u
oo.ws = _N.empty((oo.TR, oo._d.N+1), dtype=_N.float)
if oo.q20 is None:
oo.q20 = 0.00077
oo.q2 = _N.ones(oo.TR)*oo.q20
oo.F0 = _N.array([0.9])
######## Limit the amplitude to something reasonable
xE, nul = createDataAR(oo.N, oo.F0, oo.q20, 0.1)
mlt = _N.std(xE) / 0.5 # we want amplitude around 0.5
oo.q2 /= mlt*mlt
xE, nul = createDataAR(oo.N, oo.F0, oo.q2[0], 0.1)
w = 5
wf = gauKer(w)
gk = _N.empty((oo.TR, oo.N+1))
fgk= _N.empty((oo.TR, oo.N+1))
for m in xrange(oo.TR):
gk[m] = _N.convolve(oo.y[m], wf, mode="same")
gk[m] = gk[m] - _N.mean(gk[m])
gk[m] /= 5*_N.std(gk[m])
fgk[m] = bpFilt(15, 100, 1, 135, 500, gk[m]) # we want
fgk[m, :] /= 2*_N.std(fgk[m, :])
if oo.noAR:
oo.smpx[m, 0] = 0
else:
oo.smpx[m] = fgk[m]
oo.s_lrn = _N.empty((oo.TR, oo.N+1))
oo.sprb = _N.empty((oo.TR, oo.N+1))
oo.lrn_scr1 = _N.empty(oo.N+1)
oo.lrn_iscr1 = _N.empty(oo.N+1)
oo.lrn_scr2 = _N.empty(oo.N+1)
oo.lrn_scr3 = _N.empty(oo.N+1)
oo.lrn_scld = _N.empty(oo.N+1)
if oo.bpsth:
oo.B = patsy.bs(_N.linspace(0, (oo.t1 - oo.t0)*oo.dt, (oo.t1-oo.t0)), df=oo.dfPSTH, knots=oo.kntsPSTH, include_intercept=True) # spline basis
if oo.dfPSTH is None:
oo.dfPSTH = oo.B.shape[1]
oo.B = oo.B.T # My convention for beta
if oo.aS is None:
oo.aS = _N.linalg.solve(_N.dot(oo.B, oo.B.T), _N.dot(oo.B, _N.ones(oo.t1 - oo.t0)*0.01)) # small amplitude psth at first
oo.u_a = _N.zeros(oo.dfPSTH)
else:
oo.B = patsy.bs(_N.linspace(0, (oo.t1 - oo.t0)*oo.dt, (oo.t1-oo.t0)), df=4, include_intercept=True) # spline basis
oo.B = oo.B.T # My convention for beta
oo.aS = _N.zeros(4)
#oo.u_a = _N.ones(oo.dfPSTH)*_N.mean(oo.us)
oo.u_a = _N.zeros(oo.dfPSTH)
def create(setname):
copyfile(
"%s.py" % setname, "%(s)s/%(s)s.py" % {
"s": setname,
"to": setFN("%s.py" % setname, dir=setname, create=True)
})
global dt, lambda2, rpsth, isis, us, TR, etme, f0VAR
nColumns = 3
alldat = _N.empty((N, TR * nColumns))
for tr in xrange(TR):
if f0VAR is None:
f0VAR = _N.zeros(TR)
sig = 0.1
x, y = createDataAR(100000, Bf, sig, sig)
stdf = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
x, y = createDataAR(100000, Ba, sig, sig)
stda = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
x, y = createDataAR(100000, Bf_1, sig, sig)
stdf_1 = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
x, y = createDataAR(100000, Ba_1, sig, sig)
stda_1 = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
x = createFlucOsc(
f0,
_N.array([f0VAR[tr]]),
N,
dt,
1,
Bf=Bf,
Ba=Ba,
amp=amp,
amp_nz=amp_nz,
stdf=stdf,
stda=stda,
sig=sig,
smoothKer=5,
dSA=dSA,
dSF=dSF
) # sig is arbitrary, but we need to keep it same as when stdf, stda measured
x_1 = createFlucOsc(
f0_1,
_N.array([f0VAR_1[tr]]),
N,
dt,
1,
Bf=Bf_1,
Ba=Ba_1,
amp=amp_1,
amp_nz=amp_nz_1,
stdf=stdf_1,
stda=stda_1,
sig=sig,
smoothKer=5,
dSA=dSA_1,
dSF=dSF_1
) # sig is arbitrary, but we need to keep it same as when stdf, stda measured
y = x[0, :] + x_1[0, :] + obsNz * _N.random.randn(N)
alldat[:, tr * nColumns] = x
alldat[:, tr * nColumns + 1] = x_1
alldat[:, tr * nColumns + 2] = y
fmtstr = "%.3f %.3f %.3f" * TR
_N.savetxt(resFN("gauobs.dat", dir=setname), alldat, fmt=fmtstr)
return alldat
def initGibbs(self): ################################ INITGIBBS
oo = self
if oo.bpsth:
oo.B = patsy.bs(_N.linspace(0, (oo.t1 - oo.t0) * oo.dt,
(oo.t1 - oo.t0)),
df=oo.dfPSTH,
knots=oo.kntsPSTH,
include_intercept=True) # spline basis
if oo.dfPSTH is None:
oo.dfPSTH = oo.B.shape[1]
oo.B = oo.B.T # My convention for beta
oo.aS = _N.linalg.solve(
_N.dot(oo.B, oo.B.T),
_N.dot(oo.B,
_N.ones(oo.t1 - oo.t0) * _N.mean(oo.u)))
# #generate initial values of parameters
oo._d = _kfardat.KFARGauObsDat(oo.TR, oo.N, oo.k)
oo._d.copyData(oo.y)
sPR = "cmpref"
if oo.use_prior == _cd.__FREQ_REF__:
sPR = "frqref"
elif oo.use_prior == _cd.__ONOF_REF__:
sPR = "onfref"
sAO = "sf" if (oo.ARord == _cd.__SF__) else "nf"
ts = "[%(1)d-%(2)d]" % {"1": oo.t0, "2": oo.t1}
baseFN = "rs=%(rs)d" % {"pr": sPR, "rs": oo.restarts}
setdir = "%(sd)s/AR%(k)d_%(ts)s_%(pr)s_%(ao)s" % {
"sd": oo.setname,
"k": oo.k,
"ts": ts,
"pr": sPR,
"ao": sAO
}
# baseFN_inter baseFN_comps baseFN_comps
###############
oo.Bsmpx = _N.zeros((oo.TR, oo.NMC + oo.burn, (oo.N + 1) + 2))
oo.smp_u = _N.zeros((oo.TR, oo.burn + oo.NMC))
oo.smp_q2 = _N.zeros((oo.TR, oo.burn + oo.NMC))
oo.smp_x00 = _N.empty((oo.TR, oo.burn + oo.NMC - 1, oo.k))
# store samples of
oo.allalfas = _N.empty((oo.burn + oo.NMC, oo.k), dtype=_N.complex)
oo.uts = _N.empty((oo.TR, oo.burn + oo.NMC, oo.R, oo.N + 2))
oo.wts = _N.empty((oo.TR, oo.burn + oo.NMC, oo.C, oo.N + 3))
oo.ranks = _N.empty((oo.burn + oo.NMC, oo.C), dtype=_N.int)
oo.pgs = _N.empty((oo.TR, oo.burn + oo.NMC, oo.N + 1))
oo.fs = _N.empty((oo.burn + oo.NMC, oo.C))
oo.amps = _N.empty((oo.burn + oo.NMC, oo.C))
if oo.bpsth:
oo.smp_aS = _N.zeros((oo.burn + oo.NMC, oo.dfPSTH))
radians = buildLims(oo.Cn, oo.freq_lims, nzLimL=1.)
oo.AR2lims = 2 * _N.cos(radians)
if (oo.rs < 0):
oo.smpx = _N.zeros(
(oo.TR, (oo.N + 1) + 2, oo.k)) # start at 0 + u
oo.ws = _N.empty((oo.TR, oo._d.N + 1), dtype=_N.float)
oo.F_alfa_rep = initF(oo.R, oo.Cs, oo.Cn,
ifs=oo.ifs).tolist() # init F_alfa_rep
print "begin---"
print ampAngRep(oo.F_alfa_rep)
print "begin^^^"
q20 = 1e-3
oo.q2 = _N.ones(oo.TR) * q20
oo.F0 = (-1 * _Npp.polyfromroots(oo.F_alfa_rep)[::-1].real)[1:]
######## Limit the amplitude to something reasonable
xE, nul = createDataAR(oo.N, oo.F0, q20, 0.1)
mlt = _N.std(xE) / 0.5 # we want amplitude around 0.5
oo.q2 /= mlt * mlt
xE, nul = createDataAR(oo.N, oo.F0, oo.q2[0], 0.1)
if oo.model == "Bernoulli":
oo.initBernoulli()
#smpx[0, 2:, 0] = x[0] ########## DEBUG
#### initialize ws if starting for first time
if oo.TR == 1:
oo.ws = oo.ws.reshape(1, oo._d.N + 1)
for m in xrange(oo._d.TR):
lw.rpg_devroye(oo.rn,
oo.smpx[m, 2:, 0] + oo.u[m],
num=(oo.N + 1),
out=oo.ws[m, :])
oo.smp_u[:, 0] = oo.u
oo.smp_q2[:, 0] = oo.q2
if oo.bpsth:
oo.u_a = _N.ones(oo.dfPSTH) * _N.mean(oo.u)
def create(setname):
global lowQs, lowQpc
copyfile(
"%s.py" % setname, "%(s)s/%(s)s.py" % {
"s": setname,
"to": setFN("%s.py" % setname, dir=setname, create=True)
})
ARcoeff = _N.empty((nRhythms, 2))
for n in xrange(nRhythms):
ARcoeff[n] = (-1 * _Npp.polyfromroots(alfa[n])[::-1][1:]).real
V = _N.empty(N)
dV = _N.empty(N)
dN = _N.zeros(N)
xprbsdN = _N.empty((N, 3 * TR))
isis = []
lowQs = []
spksPT = _N.empty(TR)
for tr in xrange(TR):
V[0] = 0.2 * _N.random.randn()
eps = bcksig * _N.random.randn(N) # time series
err = nzs[0, 1]
if _N.random.rand() < lowQpc:
err = nzs[0, 0]
lowQs.append(tr)
sTs = []
x, y = createDataAR(N, ARcoeff[0], err, obsnz, trim=trim)
dN[:] = 0
for n in xrange(N - 1):
dV[n] = -V[n] / tau + eps[n] + Is[tr] + x[n] + psth[n]
V[n + 1] = V[n] + dV[n] * dt
if V[n + 1] > thr:
V[n + 1] = rst
dN[n] = 1
sTs.append(n)
spksPT[tr] = len(sTs)
xprbsdN[:, tr * 3] = x
xprbsdN[:, tr * 3 + 1] = V
xprbsdN[:, tr * 3 + 2] = dN
isis.extend(_U.toISI([sTs])[0])
fmt = "% .2e %.3f %d " * TR
_N.savetxt(resFN("xprbsdN.dat", dir=setname, create=True),
xprbsdN,
fmt=fmt)
plotWFandSpks(
N - 1,
dN, [x],
sTitle="AR2 freq %(f).1fHz num spks %(d).0f spk Hz %(spkf).1fHz" % {
"f": (500 * ths[0] / _N.pi),
"d": _N.sum(dN),
"spkf": (_N.sum(dN) / (N * 0.001))
},
sFilename=resFN("generative", dir=setname))
#plotWFandSpks(N-1, dN, [x], sTitle="AR2 freq %(f).1fHz num spks %(d).0f spk Hz %(spkf).1fHz" % {"f" : (500*ths[0]), "d" : _N.sum(dN), "spkf" : (_N.sum(dN) / (N*0.001))}, sFilename=resFN("generative", dir=setname))
fig = _plt.figure(figsize=(8, 4))
_plt.hist(isis, bins=range(100), color="black")
_plt.grid()
_plt.savefig(resFN("ISIhist", dir=setname))
_plt.close()
cv = _N.std(spksPT)**2 / _N.mean(spksPT)
fig = _plt.figure(figsize=(13, 4))
_plt.plot(spksPT, marker=".", color="black", ms=8)
_plt.ylim(0, max(spksPT) * 1.1)
_plt.grid()
_plt.suptitle("avg. Hz %(hz).1f cv=%(cv).2f" % {
"hz": (_N.mean(spksPT) / (N * 0.001)),
"cv": cv
})
_plt.savefig(resFN("spksPT", dir=setname))
_plt.close()
"""
def create(setname):
# _plt.ioff()
copyfile(
"%s.py" % setname, "%(s)s/%(s)s.py" % {
"s": setname,
"to": setFN("%s.py" % setname, dir=setname, create=True)
})
global dt, lambda2, rpsth, isis, us, csTR, etme, bGenOscUsingAR, f0VAR, f0, Bf, Ba, amp, amp_nz, dSA, dSF, psth
if bGenOscUsingAR:
ARcoeff = _N.empty((nRhythms, 2))
for n in xrange(nRhythms):
ARcoeff[n] = (-1 * _Npp.polyfromroots(alfa[n])[::-1][1:]).real
stNzs = _N.empty((TR, nRhythms))
for tr in xrange(TR):
if _N.random.rand() < lowQpc:
lowQs.append(tr)
stNzs[tr] = nzs[:, 0]
else:
stNzs[tr] = nzs[:, 1] # high
elif bGenOscUsingSines:
if f0VAR is None:
f0VAR = _N.zeros(TR)
sig = 0.1
x, y = createDataAR(100000, Bf, sig, sig)
stdf = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
x, y = createDataAR(100000, Ba, sig, sig)
stda = _N.std(
x) # choice of 4 std devs to keep phase monotonically increasing
# x, prbs, spks 3 columns
nColumns = 3
alldat = _N.empty((N, TR * nColumns))
probNOsc = _N.empty((N, TR))
spksPT = _N.empty(TR)
lowQs = []
isis = []
rpsth = []
if csTR is None:
csTR = _N.ones(TR)
if etme is None:
etme = _N.ones((TR, N))
if us is None:
us = _N.zeros(TR)
elif (type(us) is float) or (type(us) is int):
us = _N.zeros(TR) * us
for tr in xrange(TR):
if bGenOscUsingAR:
#x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR, N, dt, ARcoeff, psth + us[tr], stNzs[tr], lambda2=lambda2, p=1, nRhythms=nRhythms, cs=csTR[tr], etme=etme[tr])
# psth is None. Turn it off for now
x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR,
N,
dt,
ARcoeff,
us[tr],
stNzs[tr],
lambda2=lambda2,
p=1,
nRhythms=nRhythms,
cs=csTR[tr],
etme=etme[tr],
offset=psth)
else:
xosc = createFlucOsc(
f0,
_N.array([f0VAR[tr]]),
N,
dt,
1,
Bf=Bf,
Ba=Ba,
amp=amp,
amp_nz=amp_nz,
stdf=stdf,
stda=stda,
sig=sig,
smoothKer=5,
dSA=dSA,
dSF=dSF
) * etme[
tr] # sig is arbitrary, but we need to keep it same as when stdf, stda measured
#x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR, N, dt, None, psth + us[tr], None, lambda2=lambda2, p=1, nRhythms=1, cs=csTR[tr], etme=etme[tr], x=xosc[0])
x, dN, prbs, fs, prbsNOsc = createDataPPl2(TR,
N,
dt,
None,
us[tr],
None,
lambda2=lambda2,
p=1,
nRhythms=1,
cs=csTR[tr],
etme=etme[tr],
x=xosc,
offset=psth)
spksPT[tr] = _N.sum(dN)
rpsth.extend(_N.where(dN == 1)[0])
alldat[:, nColumns * tr] = _N.sum(x, axis=0).T * etme[tr] * csTR[tr]
alldat[:, nColumns * tr + 1] = prbs
alldat[:, nColumns * tr + 2] = dN
probNOsc[:, tr] = prbsNOsc
isis.extend(_U.toISI([_N.where(dN == 1)[0].tolist()])[0])
savesetMT(TR, alldat, model, setname)
savesetMTnosc(TR, probNOsc, setname)
arfs = ""
xlst = []
if bGenOscUsingAR:
for nr in xrange(nRhythms):
arfs += "%.1fHz " % (500 * ths[nr] / _N.pi)
xlst.append(x[nr])
else:
xlst.append(x[0])
sTitle = "AR2 freq %(fs)s spk Hz %(spkf).1fHz TR=%(tr)d N=%(N)d" % {
"spkf": (_N.sum(spksPT) / (N * TR * 0.001)),
"tr": TR,
"N": N,
"fs": arfs
}
plotWFandSpks(N - 1,
dN,
xlst,
sTitle=sTitle,
sFilename=resFN("generative", dir=setname))
fig = _plt.figure(figsize=(8, 4))
_plt.hist(isis, bins=range(100), color="black")
_plt.grid()
_plt.savefig(resFN("ISIhist", dir=setname))
_plt.close()
fig = _plt.figure(figsize=(13, 4))
_plt.plot(spksPT, marker=".", color="black", ms=8)
_plt.ylim(0, max(spksPT) * 1.1)
_plt.grid()
_plt.suptitle("avg. Hz %.1f" % (_N.mean(spksPT) / (N * 0.001)))
_plt.savefig(resFN("spksPT", dir=setname))
_plt.close()
if (lambda2 is None) and (absrefr > 0):
lambda2 = _N.array([0.0001] * absrefr)
if lambda2 is not None:
_N.savetxt(resFN("lambda2.dat", dir=setname), lambda2, fmt="%.7f")
# if we want to double bin size
#lambda2db = 0.5*(lambda2[1::2] + lambda2[::2])
#_N.savetxt(resFN("lambda2db.dat", dir=setname), lambda2db, fmt="%.7f")
#_plt.ion()
if lowQpc > 0:
_N.savetxt(resFN("lowQtrials", dir=setname), lowQs, fmt="%d")
def create(setname):
global lowQs, lowQpc, f0VAR, oscCS, etme, xmultLo, updn, buff, thsVAR, a, B, Is, psthThisTrial, nPSTHs, psthTypsPc
copyfile("%s.py" % setname, "%(s)s/%(s)s.py" % {"s" : setname, "to" : setFN("%s.py" % setname, dir=setname, create=True)})
if etme is None:
etme = _N.ones((TR, N))
if updn is None:
updn = _N.zeros((TR, N+buff))
if bGenOscUsingAR:
alfa = _N.empty((TR, nRhythms, 2), dtype=_N.complex)
if thsVAR is None:
thsVAR = _N.zeros((TR, nRhythms))
for tr in xrange(TR):
for nr in xrange(nRhythms):
th = ths[nr] + thsVAR[tr, nr]
alfa[tr, nr, 0] = rs[nr]*(_N.cos(th) + 1j*_N.sin(th))
alfa[tr, nr, 1] = rs[nr]*(_N.cos(th) - 1j*_N.sin(th))
ARcoeff = _N.empty((TR, nRhythms, 2))
for tr in xrange(TR):
for n in xrange(nRhythms):
ARcoeff[tr, n] = (-1*_Npp.polyfromroots(alfa[tr, n])[::-1][1:]).real
elif bGenOscUsingSines:
if f0VAR is None:
f0VAR = _N.zeros(TR)
sig = 0.1
x, y = createDataAR(100000, Bf, sig, sig)
stdf = _N.std(x) # choice of 4 std devs to keep phase monotonically increasing
x, y = createDataAR(100000, Ba, sig, sig)
stda = _N.std(x) # choice of 4 std devs to keep phase monotonically increasing
if oscCS is None: # coupling strength of osc. given
oscCS = _N.ones(TR)
V = _N.empty(N+buff)
dV = _N.empty(N+buff)
dN = _N.zeros(N+buff)
xprbsdN= _N.empty((N, 3*TR))
isis = []
bGivenLowQs = True
bGivenPSTHbyTrial = True
if lowQs is None:
lowQs = []
bGivenLowQs = False
if (psthTypsPc is None) or (nPSTHs == 1):
bGivenPSTHbyTrial = False
psthThisTrial = _N.zeros(TR, dtype=_N.int)
nknts = a.shape[0]
else:
crat = _N.zeros(len(psthTypsPc)+1)
for ityp in xrange(len(psthTypsPc)):
crat[ityp+1] = crat[ityp] + psthTypsPc[ityp]
nknts = a.shape[1]
psthThisTrial = _N.empty(TR, dtype=_N.int)
for tr in xrange(TR):
rnd = _N.random.rand()
typ = _N.where((rnd > crat[0:-1]) & (rnd < crat[1:]))[0][0]
psthThisTrial[tr] = typ
spksPT= _N.empty(TR)
currentsPSTH = _N.empty((N+buff, TR))
currentsOsc = _N.empty((N+buff, TR))
currentsUpDn = _N.empty((N+buff, TR)) # slow up-downs
for tr in xrange(TR):
V[0] = 0.1*_N.random.randn()
eps = bcksig*_N.random.randn(N+buff) # time series
sTs = []
if bGenOscUsingAR:
err = nzs[0, 1]
if not bGivenLowQs: # randomly gen. trials which are lowQs
if _N.random.rand() < lowQpc:
err = nzs[0, 0]
lowQs.append(tr)
else:
try:
lowQs.index(tr)
err = nzs[0, 0]
except ValueError:
pass
maxPwr = 0
for i in xrange(cand):
x, y= createDataAR(N, ARcoeff[tr, 0], err, obsnz, trim=trim)
x *= etme[tr]
pwr = _N.sum(x**2)
if pwr > maxPwr:
xBest = x
maxPwr = pwr
elif bGenOscUsingSines:
xmult = 1
if not bGivenLowQs: # randomly gen. trials which are lowQs
if _N.random.rand() < lowQpc:
xmult = xmultLo
lowQs.append(tr)
else:
try:
lowQs.index(tr)
xmult = xmultLo
except ValueError:
pass
x = xmult*createFlucOsc(f0, _N.array([f0VAR[tr]]), N, dt, 1, Bf=Bf, Ba=Ba, amp=amp, amp_nz=amp_nz, stdf=stdf, stda=stda, sig=sig, smoothKer=5, dSA=dSA, dSF=dSF) * etme[tr] # sig is arbitrary, but we need to keep it same as when stdf, stda measured
_xBest = x[0]
dN[:] = 0
_psth = _N.empty((nPSTHs, N))
psth = _N.empty((nPSTHs, N+buff))
for np in xrange(nPSTHs):
if nPSTHs == 1:
_psth[np] = _N.dot(B, a + aNz*_N.random.randn(nknts))
else:
_N.dot(B, a[np] + aNz*_N.random.randn(nknts))
_psth[np] = _N.dot(B, a[np] + aNz*_N.random.randn(nknts))
psth[np] = _N.empty(N+buff)
psth[np, 0:buff] = _psth[np, 0]
psth[np, buff:] = _psth[np]
xBest = _N.empty(N+buff)
xBest[0:buff] = 0#_xBest[0:buff][::-1]
xBest[buff:] = _xBest
#etmeBUF = _N.ones((TR, N+buff))
#etmeBUF[:, buff:] = etme
for n in xrange(N-1+buff):
currentsPSTH[n, tr] = psth[psthThisTrial[tr], n]
currentsOsc[n, tr] = xBest[n]
currentsUpDn[n, tr] = updn[tr, n]
dV[n] = -V[n] / tau + eps[n] + currentsPSTH[n, tr] + Is[tr] + oscCS[tr]*currentsOsc[n, tr]
V[n+1] = V[n] + dV[n]*dt
if V[n+1] + updn[tr, n] > thr:
V[n + 1] = rst
dN[n] = 1
if n > buff:
sTs.append(n-buff)
spksPT[tr] = len(sTs)
xprbsdN[:, tr*3] = xBest[buff:]
xprbsdN[:, tr*3 + 1] = V[buff:]
xprbsdN[:, tr*3 + 2] = dN[buff:]
isis.extend(_U.toISI([sTs])[0])
fmt = "%.3f " * TR
_N.savetxt(resFN("currentsPSTH.dat", dir=setname, create=True), currentsPSTH[buff:], fmt=fmt)
fmt = "%.3f "
_N.savetxt(resFN("currentsIs.dat", dir=setname, create=True), Is, fmt=fmt)
fmt = "%.3f " * TR
_N.savetxt(resFN("currentsUpDn.dat", dir=setname, create=True), currentsUpDn[buff:], fmt=fmt)
fmt = "%.3f " * TR
_N.savetxt(resFN("currentsOsc.dat", dir=setname, create=True), currentsOsc[buff:], fmt=fmt)
if bGivenLowQs:
fmt = "%d"
_N.savetxt(resFN("lowQs.dat", dir=setname, create=True), lowQs, fmt=fmt)
if bGivenPSTHbyTrial:
fmt = "%d"
_N.savetxt(resFN("psthTyps.dat", dir=setname, create=True), psthThisTrial, fmt=fmt)
fmt = "% .2e %.3f %d " * TR
_N.savetxt(resFN("xprbsdN.dat", dir=setname, create=True), xprbsdN, fmt=fmt)
if bGenOscUsingAR:
plotWFandSpks(N-1, dN[buff:], [xBest[buff:]], sTitle="AR2 freq %(f).1fHz num spks %(d).0f spk Hz %(spkf).1fHz" % {"f" : (500*ths[0]/_N.pi), "d" : _N.sum(dN[buff:]), "spkf" : (_N.sum(dN[buff:]) / (N*0.001))}, sFilename=resFN("generative", dir=setname))
else:
plotWFandSpks(N-1, dN[buff:], [xBest[buff:]], sTitle="", sFilename=resFN("generative", dir=setname))
fig = _plt.figure(figsize=(8, 4))
_plt.hist(isis, bins=range(100), color="black")
_plt.grid()
_plt.savefig(resFN("ISIhist", dir=setname))
_plt.close()
cv = _N.std(spksPT)**2/_N.mean(spksPT)
fig = _plt.figure(figsize=(13, 4))
_plt.plot(spksPT, marker=".", color="black", ms=8)
_plt.ylim(0, max(spksPT)*1.1)
_plt.grid()
_plt.suptitle("avg. Hz %(hz).1f cv=%(cv).2f" % {"hz" : (_N.mean(spksPT) / (N*0.001)), "cv" : cv})
_plt.savefig(resFN("spksPT", dir=setname))
_plt.close()
cv = _N.std(isis) / _N.mean(isis)
#fig = _plt.figure(figsize=(7, 3.5))
fig, ax = _plt.subplots(figsize=(7, 8))
_plt.subplot(2, 1, 1)
_plt.hist(isis, bins=range(0, 50), color="black")
_plt.grid()
_plt.subplot(2, 1, 2)
_plt.hist(isis, bins=range(0, ISItmscl), color="black")
_plt.yscale("log")
_plt.grid()
_plt.suptitle("ISI cv %.2f" % cv)
_plt.savefig(resFN("ISIhist", dir=setname))
_plt.close()