def run(fquadrnts=None): quadrnts = None n_qdrnts = 1 if fquadrnts is not None: if K == 4: quadrnts = [[int(g_Ms[0]*fquadrnts[0][0])], [int(g_Ms[1]*fquadrnts[1][0])], [int(g_Ms[2]*fquadrnts[2][0])], [int(g_Ms[3]*fquadrnts[3][0])]] n_qdrnts = (len(quadrnts[0])+1) * (len(quadrnts[1])+1) * (len(quadrnts[2])+1) * (len(quadrnts[3])+1) elif K == 1: quadrnts = [[int(g_Ms[0]*fquadrnts[0][0])]] n_qdrnts = (len(quadrnts[0])+1) run_os, run_es, run_vs, lftovr_os, lftovr_es = _Gu.get_obs_exp_v(g_Ms, expctd, chi2_boxes_mk, 6., quadrnts=quadrnts) fp = open("%(df)s/exp_obs%(qd)s.txt" % {"df" : outdirN, "qd" : n_qdrnts}, "w+") fp.write("# quadrants %s\n" % str(fquadrnts)) fp.write("# ks D, pv\n") fp.write("%(d).3e %(pv).3e -1\n" % {"d" : ks_D, "pv" : ks_pv}) fp.write("# chi2, pv, dg freedom # quadrnt#, \n") for nq in xrange(n_qdrnts): reslt = _ss.chisquare(run_os[nq], run_es[nq]) fp.write("%(chi2).3e %(pv).3e %(n)d # nq %(nq)d\n" % {"chi2" : reslt[0], "pv" : reslt[1], "n" : len(run_es[nq]), "nq" : nq}) fp.close() lftovr = _N.empty((n_qdrnts, 2)) lftovr[:, 0] = lftovr_os lftovr[:, 1] = lftovr_es _U.savetxtWCom("%(df)s/lftovrs%(qd)d.txt" % {"df" : outdirN, "qd" : n_qdrnts}, lftovr, fmt="%d %.3f", delimiter=" ", com=("# observed, expeceted, quadrants %s" % str(fquadrnts)))
bfn = "u" if (mvPat == UNIF) else "n" if (mvPat == NUNIF) and (Amx > 0): bfn = "b" bfn += "n" if (mSM > 0) else "s" iInd = 0 while not bFnd: iInd += 1 fn = "../DATA/%(bfn)s%(iI)d.dat" % {"bfn" : bfn, "iI" : iInd} fnocc="../DATA/%(bfn)s%(iI)docc.png" % {"bfn" : bfn, "iI" : iInd} if not os.access(fn, os.F_OK): # file exists bFnd = True dat = _N.zeros((NT, 5)) dat[:, 0] = pths dat[sts, 1] = 1 dat[:, 2] = ctr dat[:, 3] = sx dat[:, 4] = l0 com = "# f=%(mx).3f q2=%(q2).4f l0=%(l0).4f" % {"mx" : mx, "q2" : _N.mean(sx), "l0" : _N.mean(l0)} _U.savetxtWCom("%s" % fn, dat, fmt="%.4f %d %.4f %.4f %.4f", delimiter=" ", com=com) print "created %s" % fn fig = _plt.figure() _plt.hist(dat[:, 0], bins=_N.linspace(0, 3, 61), color="black") _plt.savefig(fnocc) _plt.close()
def stochasticAssignment(oo, epc, it, Msc, M, K, l0, f, q2, u, Sg, _f_u, _u_u, _f_q2, _u_Sg, Asts, t0, mASr, xASr, rat, econt, gz, qdrMKS, freeClstr, hashthresh, cmp2Existing, nthrds=1): # Msc Msc signal clusters # M all clusters, including nz clstr. M == Msc when not using nzclstr # Gibbs sampling # parameters l0, f, q2 # mASr, xASr just the mark, position of spikes btwn t0 and t1 #qdrMKS2 = _N.empty(qdrMKS.shape) t1 = _tm.time() nSpks = len(Asts) twpi = 2*_N.pi Kp1 = K+1 #rat = _N.zeros(M+1) pc = _N.zeros(M) ur = u.reshape((M, 1, K)) fr = f.reshape((M, 1)) # centers #print q2 iq2 = 1./q2 iSg = _N.linalg.inv(Sg) iq2r = iq2.reshape((M, 1)) try: ## warnings because l0 is 0 isN = _N.where(q2 <= 0)[0] if len(isN) > 0: q2[isN] = 0.3 is0 = _N.where(l0 <= 0)[0] if len(is0) > 0: l0[is0] = 0.001 pkFR = _N.log(l0) - 0.5*_N.log(twpi*q2) # M except RuntimeWarning: print "WARNING" print l0 print q2 mkNrms = _N.log(1/_N.sqrt(twpi*_N.linalg.det(Sg))) mkNrms = mkNrms.reshape((M, 1)) # M x 1 rnds = _N.random.rand(nSpks) pkFRr = pkFR.reshape((M, 1)) dmu = (mASr - ur) # mASr 1 x N x K, ur is M x 1 x K N = mASr.shape[1] #t2 = _tm.time() #_N.einsum("mnj,mjk,mnk->mn", dmu, iSg, dmu, out=qdrMKS) #t3 = _tm.time() _fm.multi_qdrtcs_par_func(dmu, iSg, qdrMKS, M, N, K, nthrds=nthrds) # fr is M x 1, xASr is 1 x N, iq2r is M x 1 #qdrSPC = (fr - xASr)*(fr - xASr)*iq2r # M x nSpks # 0.01s qdrSPC = _N.empty((M, N)) _hcb.hc_bcast1(fr, xASr, iq2r, qdrSPC, M, N) ### how far is closest cluster to each newly observed mark # mAS = mks[Asts+t0] # xAS = x[Asts + t0] # position @ spikes if cmp2Existing: # compare only non-hash spikes and non-hash clusters # realCl = _N.where(freeClstr == False)[0] # print freeClstr.shape # print realCl.shape abvthrEachCh = mASr[0] > hashthresh # should be NxK of abvthrAtLeast1Ch = _N.sum(abvthrEachCh, axis=1) > 0 # N x K newNonHashSpks = _N.where(abvthrAtLeast1Ch)[0] newNonHashSpksMemClstr = _N.ones(len(newNonHashSpks), dtype=_N.int) * (M-1) # initially, assign all of them to noise cluster #print "spikes not hash" #print abvthrInds abvthrEachCh = u[0:Msc] > hashthresh # M x K (M includes noise) abvthrAtLeast1Ch = _N.sum(abvthrEachCh, axis=1) > 0 knownNonHclstrs = _N.where(abvthrAtLeast1Ch & (freeClstr == False) & (q2[0:Msc] < wdSpc))[0] #print "clusters not hash" # Place prior for freeClstr near new non-hash spikes that are far # from known clusters that are not hash clusters nNrstMKS_d = _N.sqrt(_N.min(qdrMKS[knownNonHclstrs], axis=0)/K) # dim len(sts) nNrstSPC_d = _N.sqrt(_N.min(qdrSPC[knownNonHclstrs], axis=0)) # for each spike, distance to nearest non-hash cluster # print nNrstMKS_d # print nNrstSPC_d # print "==============" s = _N.empty((len(newNonHashSpks), 3)) # for each spike, distance to nearest cluster s[:, 0] = newNonHashSpks s[:, 1] = nNrstMKS_d[newNonHashSpks] s[:, 2] = nNrstSPC_d[newNonHashSpks] _N.savetxt(resFN("qdrMKSSPC%d" % epc, dir=oo.outdir), s, fmt="%d %.3e %.3e") dMK = nNrstMKS_d[newNonHashSpks] dSP = nNrstSPC_d[newNonHashSpks] ### assignment into farMKinds = _N.where(dMK > 4)[0] # # mean of prior for center - mean of farMKinds # cov of prior for center - how certain am I of mean? farSPinds = _N.where(dSP > 4)[0] # 4 std. deviations away farMKSPinds = _N.union1d(farMKinds, farSPinds) print farMKinds print newNonHashSpks ## points in newNonHashSpks but not in farMKinds notFarMKSPinds = _N.setdiff1d(_N.arange(newNonHashSpks.shape[0]), farMKSPinds) farMKSP = _N.empty((len(farMKSPinds), K+1)) farMKSP[:, 0] = xASr[0, newNonHashSpks[farMKSPinds]] farMKSP[:, 1:] = mASr[0, newNonHashSpks[farMKSPinds]] notFarMKSP = _N.empty((len(notFarMKSPinds), K+1)) notFarMKSP[:, 0] = xASr[0, newNonHashSpks[notFarMKSPinds]] notFarMKSP[:, 1:] = mASr[0, newNonHashSpks[notFarMKSPinds]] # farSP = _N.empty((len(farSPinds), K+1)) # farMK = _N.empty((len(farMKinds), K+1)) # farSP[:, 0] = xASr[0, farSPinds] # farSP[:, 1:] = mASr[0, farSPinds] # farMK[:, 0] = xASr[0, farMKinds] # farMK[:, 1:] = mASr[0, farMKinds] minK = 1 maxK = farMKSPinds.shape[0] / K maxK = maxK if (maxK < 6) else 6 freeClstrs = _N.where(freeClstr == True)[0] if maxK >= 2: print "coming in here" #labs, bics, bestLab, nClstrs = _oT.EMBICs(farMKSP, minK=minK, maxK=maxK, TR=1) labs, labsH, clstrs = emMKPOS_sep1B(farMKSP, None, TR=1, wfNClstrs=[[1, 4], [1, 4]], spNClstrs=[[1, 4], [1, 3]]) nClstrs = clstrs[0] bestLab = labs cls = clrs.get_colors(nClstrs) _U.savetxtWCom(resFN("newSpksMKSP%d" % epc, dir=oo.outdir), farMKSP, fmt="%.3e %.3e %.3e %.3e %.3e", com=("# number of clusters %d" % nClstrs)) _U.savetxtWCom(resFN("newSpksMKSP_nf%d" % epc, dir=oo.outdir), notFarMKSP, fmt="%.3e %.3e %.3e %.3e %.3e", com=("# number of clusters %d" % nClstrs)) L = len(freeClstrs) unqLabs = _N.unique(bestLab) upto = nClstrs if nClstrs < L else L # this should just count large clusters ii = -1 fig = _plt.figure() for fid in unqLabs[0:upto]: iths = farMKSPinds[_N.where(bestLab == fid)[0]] ths = newNonHashSpks[iths] for w in xrange(K): fig.add_subplot(2, 2, w+1) _plt.scatter(xASr[0, ths], mASr[0, ths, w], color=cls[ii]) if len(ths) > K: ii += 1 im = freeClstrs[ii] # Asts + t0 gives absolute time newNonHashSpksMemClstr[iths] = im _u_u[im] = _N.mean(mASr[0, ths], axis=0) u[im] = _u_u[im] _f_u[im] = _N.mean(xASr[0, ths], axis=0) f[im] = _f_u[im] q2[im] = _N.std(xASr[0, ths], axis=0)**2 * 9 # l0 = Hz * sqrt(2*_N.pi*q2) l0[im] = 10*_N.sqrt(q2[im]) _f_q2[im] = 1 _u_Sg[im] = _N.cov(mASr[0, ths], rowvar=0)*25 print "ep %(ep)d new cluster # %(m)d" % {"ep" : epc, "m" : im} print _u_u[im] print _f_u[im] print _f_q2[im] else: print "too small this prob. doesn't represent a cluster" _plt.savefig("newspks%d" % epc) # ####### known clusters # for fid in unqLabs[0:upto]: # iths = farMKSPinds[_N.where(bestLab == fid)[0]] # ths = newNonHashSpks[iths] # for w in xrange(K): # fig.add_subplot(2, 2, w+1) # _plt.scatter(xASr[0, ths], mASr[0, ths, w], color=cls[ii]) # if len(ths) > K: # ii += 1 # im = freeClstrs[ii] # Asts + t0 gives absolute time # newNonHashSpksMemClstr[iths] = im # _u_u[im] = _N.mean(mASr[0, ths], axis=0) # u[im] = _u_u[im] # _f_u[im] = _N.mean(xASr[0, ths], axis=0) # f[im] = _f_u[im] # q2[im] = _N.std(xASr[0, ths], axis=0)**2 * 9 # # l0 = Hz * sqrt(2*_N.pi*q2) # l0[im] = 10*_N.sqrt(q2[im]) # _f_q2[im] = 1 # _u_Sg[im] = _N.cov(mASr[0, ths], rowvar=0)*25 # print "ep %(ep)d new cluster # %(m)d" % {"ep" : epc, "m" : im} # print _u_u[im] # print _f_u[im] # print _f_q2[im] # else: # print "too small this prob. doesn't represent a cluster" # _plt.savefig("newspks%d" % epc) else: # just one cluster im = freeClstrs[0] # Asts + t0 gives absolute time _u_u[im] = _N.mean(mASr[0, newNonHashSpks[farMKSPinds]], axis=0) _f_u[im] = _N.mean(xASr[0, newNonHashSpks[farMKSPinds]], axis=0) _u_Sg[im] = _N.cov(mASr[0, newNonHashSpks[farMKSPinds]], rowvar=0)*16 _f_q2[im] = _N.std(xASr[0, newNonHashSpks[farMKSPinds]], axis=0)**2 * 16 # ## kernel density estimate # xs = _N.linspace(-6, 6, 101) # xsr = xs.reshape(101, 1) # isg2= 1/(0.1**2) # spatial kernel bandwidth # # fig = _plt.figure(figsize=(6, 9)) # # fig.add_subplot(1, 2, 1) # # _plt.scatter(xASr[0, newNonHashSpks[farMKinds]], mASr[0, newNonHashSpks[farMKinds], 0]) # # fig.add_subplot(1, 2, 2) # # _plt.scatter(xASr[0, newNonHashSpks[farSPinds]], mASr[0, newNonHashSpks[farSPinds], 0]) # freeClstrs = _N.where(freeClstr == True)[0] # L = len(freeClstrs) # jjj = 0 # if (len(farSPinds) >= Kp1) and (len(farMKinds) >= Kp1): # jjj = 1 # l1 = L/2 # for l in xrange(l1): # mASr is 1 x N x K # im = freeClstrs[l] # Asts + t0 gives absolute time # _u_u[im] = _N.mean(mASr[0, newNonHashSpks[farMKinds]], axis=0) # y = _N.exp(-0.5*(xsr - xASr[0, newNonHashSpks[farMKinds]])**2 * isg2) # yc = _N.sum(y, axis=1) # ix = _N.where(yc == _N.max(yc))[0][0] # _f_u[im] = xs[ix] # _u_Sg[im] = _N.cov(mASr[0, newNonHashSpks[farMKinds]], rowvar=0)*30 # _f_q2[im] = _N.std(xASr[0, newNonHashSpks[farMKinds]], axis=0)**2 * 30 # # _plt.figure() # # _plt.plot(xs, yc) # for l in xrange(l1, L): # im = freeClstrs[l] # Asts + t0 gives absolute time # _u_u[im] = _N.mean(mASr[0, newNonHashSpks[farSPinds]], axis=0) # y = _N.exp(-0.5*(xsr - xASr[0, newNonHashSpks[farSPinds]])**2 * isg2) # yc = _N.sum(y, axis=1) # ix = _N.where(yc == _N.max(yc))[0][0] # _f_u[im] = xs[ix] # _u_Sg[im] = _N.cov(mASr[0, newNonHashSpks[farSPinds]], rowvar=0)*30 # _f_q2[im] = _N.std(xASr[0, newNonHashSpks[farSPinds]], axis=0)**2 * 30 # # _plt.figure() # # _plt.plot(xs, yc) # elif (len(farSPinds) >= Kp1) and (len(farMKinds) < Kp1): # jjj = 2 # for l in xrange(L): # im = freeClstrs[l] # Asts + t0 gives absolute time # _u_u[im] = _N.mean(mASr[0, newNonHashSpks[farSPinds]], axis=0) # y = _N.exp(-0.5*(xsr - xASr[0, newNonHashSpks[farSPinds]])**2 * isg2) # yc = _N.sum(y, axis=1) # ix = _N.where(yc == _N.max(yc))[0][0] # _f_u[im] = xs[ix] # _u_Sg[im] = _N.cov(mASr[0, newNonHashSpks[farSPinds]], rowvar=0)*30 # _f_q2[im] = _N.std(xASr[0, newNonHashSpks[farSPinds]], axis=0)**2 * 30 # # _plt.figure() # # _plt.plot(xs, yc) # elif (len(farSPinds) < Kp1) and (len(farMKinds) >= Kp1): # jjj = 3 # for l in xrange(L): # im = freeClstrs[l] # Asts + t0 gives absolute time # _u_u[im] = _N.mean(mASr[0, newNonHashSpks[farMKinds]], axis=0) # y = _N.exp(-0.5*(xsr - xASr[0, newNonHashSpks[farMKinds]])**2 * isg2) # yc = _N.sum(y, axis=1) # ix = _N.where(yc == _N.max(yc))[0][0] # _f_u[im] = xs[ix] # _u_Sg[im] = _N.cov(mASr[0, newNonHashSpks[farMKinds]], rowvar=0)*30 # _f_q2[im] = _N.std(xASr[0, newNonHashSpks[farMKinds]], axis=0)**2 * 30 # # _plt.figure() # # _plt.plot(xs, yc) """ print "^^^^^^^^" print freeClstrs print "set priors for freeClstrs %d" % jjj #print _u_u[freeClstrs] #print _u_Sg[freeClstrs] print _f_u[freeClstrs] print _f_q2[freeClstrs] """ #if len(farSPinds) > 10: # set the priors of the freeClusters to be near the far spikes #### outside cmp2Existing here # (Mx1) + (Mx1) - (MxN + MxN) #cont = pkFRr + mkNrms - 0.5*(qdrSPC + qdrMKS) cont = _N.empty((M, N)) _hcb.hc_qdr_sum(pkFRr, mkNrms, qdrSPC, qdrMKS, cont, M, N) mcontr = _N.max(cont, axis=0).reshape((1, nSpks)) cont -= mcontr _N.exp(cont, out=econt) for m in xrange(M): rat[m+1] = rat[m] + econt[m] rat /= rat[M] """ # print f # print u # print q2 # print Sg # print l0 """ # print rat M1 = rat[1:] >= rnds M2 = rat[0:-1] <= rnds gz[it] = (M1&M2).T if cmp2Existing: # gz is ITERS x N x Mwowonz (N # of spikes in epoch) gz[it, newNonHashSpks] = False # not a member of any of them gz[it, newNonHashSpks, newNonHashSpksMemClstr] = True
def create(Lx, Hx, N, mvPat, RTs, frqmx, Amx, pT, l_sx_chpts, l_l0_chpts, l_ctr_chpts, mk_chpts, Covs, LoHis, km, bckgrdLam=None, script="no info", addShortStops=False, stops=10, stopDur=500, thresh=None): """ km tells me neuron N gives rise to clusters km[N] (list) bckgrd is background spike rate (Hz) """ global UNIF, NUNIF ##### First check that the number of neurons and PFs all consistent. nNrnsSX = len(l_sx_chpts) nNrnsL0 = len(l_l0_chpts) nNrnsCT = len(l_ctr_chpts) nNrnsMK = len(mk_chpts) nNrnsMKA = LoHis.shape[0] nNrnsMKC = Covs.shape[0] if not (nNrnsSX == nNrnsL0 == nNrnsCT == nNrnsMK == nNrnsMKA == nNrnsMKC): print "Number of neurons not consistent" return None nNrns = nNrnsSX if not (LoHis.shape[1] == Covs.shape[1] == Covs.shape[2]): print "Covariance of LoHis not correct" return None K = LoHis.shape[1] PFsPerNrn = _N.zeros(nNrns, dtype=_N.int) sx_chpts = [] l0_chpts = [] ctr_chpts = [] M = 0 nrnNum = [] for nrn in xrange(nNrns): # # of place fields for neuron nrn nPFsSX = len(l_sx_chpts[nrn]) nPFsL0 = len(l_l0_chpts[nrn]) nPFsCT = len(l_ctr_chpts[nrn]) sx_chpts.extend(l_sx_chpts[nrn]) l0_chpts.extend(l_l0_chpts[nrn]) ctr_chpts.extend(l_ctr_chpts[nrn]) if not (nPFsSX == nPFsL0 == nPFsCT): print "Number of PFs for neuron %d not consistent" % nrn return None M += len(l_ctr_chpts[nrn]) nrnNum += [nrn] * nPFsSX PFsPerNrn[nrn] = nPFsSX # M = # of clusters (in mark + pos space) # nNrns = # of neurons #### build data Ns = _N.empty(RTs, dtype=_N.int) if mvPat == NUNIF: for rt in xrange(RTs): Ns[rt] = N * ((1 - pT) + pT * _N.random.rand()) else: Ns[:] = N NT = _N.sum(Ns) # total time we have data pths = _N.empty(NT) x01 = _N.linspace(0, 1, len(pths)) x01 = x01.reshape((1, NT)) plastic = False ########## nonstationary center width # sxt should be (M x NT) sxt = _N.empty((M, NT)) for m in xrange(M): # sxts time scale sxt[m] = createSmoothedPath(sx_chpts[m], NT) if len(sx_chpts[m]) > 1: plastic = True sx = sxt**2 # var of firing rate function ########## nonstationary center height l0 # f is NT x M l0 = _N.empty((M, NT)) for m in xrange(M): l0[m] = createSmoothedPath(l0_chpts[m], NT) if len(l0_chpts[m]) > 1: plastic = True f = l0 / _N.sqrt(2 * _N.pi * sx) # f*dt ########## nonstationary center location ctr = _N.empty((M, NT)) for m in xrange(M): ctr[m] = createSmoothedPath(ctr_chpts[m], NT) if len(ctr_chpts[m]) > 1: plastic = True if K > 0: ########## nonstationary marks mk_MU = _N.empty((nNrns, NT, K)) for n in xrange(nNrns): mk_MU[n] = createSmoothedPathK(mk_chpts[n], NT, K, LoHis[n]) if len(mk_chpts[n]) > 1: plastic = True if mvPat == NUNIF: now = 0 for rt in xrange(RTs): N = Ns[rt] # each traverse slightly different duration rp = _N.random.rand(N / 100) x = _N.linspace(Lx, Hx, N) xp = _N.linspace(Lx, Hx, N / 100) r = _N.interp(x, xp, rp) # creates a velocity vector # create movement without regard for place field frqmxR = _N.abs(frqmx * (1 + 0.25 * _N.random.randn())) _N.linspace(0, 1, N, endpoint=False) rscld_t = _N.random.rand(N) # rscld_t rscld_t /= (_N.max(rscld_t) * 1.01) rscld_t.sort() phi0 = _N.random.rand() * 2 * _N.pi r += _N.exp(Amx * _N.sin(2 * _N.pi * rscld_t * frqmxR + phi0)) pth = _N.zeros(N + 1) for n in xrange(1, N + 1): pth[n] = pth[n - 1] + r[n - 1] pth /= (pth[-1] - pth[0]) pth *= (Hx - Lx) pth += Lx pths[now:now + N] = pth[0:N] now += N else: now = 0 x = _N.linspace(Lx, Hx, N) for rt in xrange(RTs): N = Ns[rt] pths[now:now + N] = x now += N if addShortStops: for ist in xrange(stops): done = False while not done: t0 = int(_N.random.rand() * NT) t1 = t0 + int(stopDur * (1 + 0.1 * _N.random.randn())) if _N.abs(_N.max(_N.diff(pths[t0:t1]))) < 0.05 * (Hx - Lx): done = True # not crossing origin pths[t0:t1] = _N.mean(pths[t0:t1]) ### now calculate firing rates dt = 0.001 fdt = f * dt # change place field location Lam = f * dt * _N.exp(-0.5 * (pths - ctr)**2 / sx) #_N.savetxt("lam", Lam.T) #_N.savetxt("pths", pths) rnds = _N.random.rand(M, NT) #dat = _N.zeros((NT, 2 + K)) dat = _N.zeros((NT, 2 + K)) dat[:, 0] = pths datNghbr = _N.zeros( (NT, 2 + K)) ## if spk in bin already exists, nxt door datNghbr[:, 0] = pths for m in xrange(M): sts = _N.where(rnds[m] < Lam[m])[0] # spikes from this neuron alrdyXst = _N.where(dat[:, 1] == 1)[0] # places where synchronous ndToMove = _N.intersect1d(alrdyXst, sts) dntMove = _N.setdiff1d(sts, ndToMove) # empty slots nonsynch = _N.empty(len(sts)) datNghbr[dntMove, 1] = 1 nonsynch[0:len(dntMove)] = dntMove print len(ndToMove) iStart = len(dntMove) # in nonsynch for iOcpd in ndToMove: # occupied bDone = False while not bDone: iOcpd += 1 if datNghbr[iOcpd, 1] == 0: datNghbr[iOcpd, 1] = 1 nonsynch[iStart] = iOcpd iStart += 1 bDone = True snonsynch = _N.sort(nonsynch) dat[sts, 1] = 1 nrn = nrnNum[m] if K > 0: for t in xrange(len(sts)): obsMrk = _N.random.multivariate_normal(mk_MU[nrn, sts[t]], Covs[nrn], size=1) dat[sts[t], 2:] = obsMrk datNghbr[nonsynch[t], 2:] = obsMrk # now noise spikes if bckgrdLam is not None: nzsts = _N.where(rnds[m] < (bckgrdLam * dt) / float(M))[0] dat[nzsts, 1] = 1 nrn = nrnNum[m] if K > 0: for t in xrange(len(nzsts)): dat[nzsts[t], 2:] = _N.random.multivariate_normal(mk_MU[nrn, nzsts[t]], Covs[nrn], size=1) if thresh is not None: sts = _N.where(dat[:, 1] == 1)[0] nID, nC = _N.where(dat[sts, 2:] < thresh) swtchs = _N.zeros((len(sts), K)) swtchs[nID, nC] = 1 # for all cells, all components below hash == 1 swtchsK = _N.sum(swtchs, axis=1) blw_thrsh_all_chs = _N.where(swtchsK == K)[0] abv_thr = _N.setdiff1d(_N.arange(len(sts)), blw_thrsh_all_chs) print "below thresh in all channels %(1)d / %(2)d" % { "1": len(blw_thrsh_all_chs), "2": len(sts) } dat[sts[blw_thrsh_all_chs], 1:] = 0 bFnd = False ## us un uniform sampling of space, stationary or non-stationary place field ## ns nn non-uni sampling of space, stationary or non-stationary place field ## bs bb biased and non-uni sampling of space bfn = "" if (M == 1) else ("%d" % M) if mvPat == UNIF: bfn += "u" else: bfn += "b" if (Amx > 0) else "n" bfn += "n" if plastic else "s" iInd = 0 while not bFnd: iInd += 1 dd = os.getenv("__EnDeDataDir__") fn = "%(dd)s/%(bfn)s%(iI)d.dat" % {"bfn": bfn, "iI": iInd, "dd": dd} fnocc = "%(dd)s/%(bfn)s%(iI)docc.png" % { "bfn": bfn, "iI": iInd, "dd": dd } fnprm = "%(dd)s/%(bfn)s%(iI)d_prms.pkl" % { "bfn": bfn, "iI": iInd, "dd": dd } if not os.access(fn, os.F_OK): # file exists bFnd = True smk = " %.4f" * K _U.savetxtWCom("%s" % fn, dat, fmt=("%.4f %d" + smk), delimiter=" ", com="# script=%s.py" % script) _U.savetxtWCom("%s_NS.dat" % fn[:-4], datNghbr, fmt=("%.4f %d" + smk), delimiter=" ", com="# script=%s.py" % script) pcklme = {} pcklme["l0"] = l0[:, ::100] pcklme["f"] = ctr[:, ::100] pcklme["sq2"] = sx[:, ::100] pcklme["u"] = mk_MU[:, ::100] pcklme["covs"] = Covs pcklme["intv"] = 100 pcklme["km"] = km dmp = open(fnprm, "wb") pickle.dump(pcklme, dmp, -1) dmp.close() print "created %s" % fn fig = _plt.figure() _plt.hist(dat[:, 0], bins=_N.linspace(Lx, Hx, 101), color="black") _plt.savefig(fnocc) _plt.close()
def create(Lx, Hx, N, mvPat, RTs, frqmx, Amx, pT, l_sx_chpts, l_l0_chpts, l_ctr_chpts, mk_chpts, Covs, LoHis, km, bckgrdLam=None, script="no info", addShortStops=False, stops=10, stopDur=500, thresh=None): """ km tells me neuron N gives rise to clusters km[N] (list) bckgrd is background spike rate (Hz) """ global UNIF, NUNIF ##### First check that the number of neurons and PFs all consistent. nNrnsSX = len(l_sx_chpts) nNrnsL0 = len(l_l0_chpts) nNrnsCT = len(l_ctr_chpts) nNrnsMK = len(mk_chpts) nNrnsMKA= LoHis.shape[0] nNrnsMKC= Covs.shape[0] if not (nNrnsSX == nNrnsL0 == nNrnsCT == nNrnsMK == nNrnsMKA == nNrnsMKC): print "Number of neurons not consistent" return None nNrns = nNrnsSX if not (LoHis.shape[1] == Covs.shape[1] == Covs.shape[2]): print "Covariance of LoHis not correct" return None K = LoHis.shape[1] PFsPerNrn = _N.zeros(nNrns, dtype=_N.int) sx_chpts = [] l0_chpts = [] ctr_chpts = [] M = 0 nrnNum = [] for nrn in xrange(nNrns): # # of place fields for neuron nrn nPFsSX = len(l_sx_chpts[nrn]) nPFsL0 = len(l_l0_chpts[nrn]) nPFsCT = len(l_ctr_chpts[nrn]) sx_chpts.extend(l_sx_chpts[nrn]) l0_chpts.extend(l_l0_chpts[nrn]) ctr_chpts.extend(l_ctr_chpts[nrn]) if not (nPFsSX == nPFsL0 == nPFsCT): print "Number of PFs for neuron %d not consistent" % nrn return None M += len(l_ctr_chpts[nrn]) nrnNum += [nrn]*nPFsSX PFsPerNrn[nrn] = nPFsSX # M = # of clusters (in mark + pos space) # nNrns = # of neurons #### build data Ns = _N.empty(RTs, dtype=_N.int) if mvPat == NUNIF: for rt in xrange(RTs): Ns[rt] = N*((1-pT) + pT*_N.random.rand()) else: Ns[:] = N NT = _N.sum(Ns) # total time we have data pths = _N.empty(NT) x01 = _N.linspace(0, 1, len(pths)) x01 = x01.reshape((1, NT)) plastic = False ########## nonstationary center width # sxt should be (M x NT) sxt = _N.empty((M, NT)) for m in xrange(M): # sxts time scale sxt[m] = createSmoothedPath(sx_chpts[m], NT) if len(sx_chpts[m]) > 1: plastic = True sx = sxt**2 # var of firing rate function ########## nonstationary center height l0 # f is NT x M l0 = _N.empty((M, NT)) for m in xrange(M): l0[m] = createSmoothedPath(l0_chpts[m], NT) if len(l0_chpts[m]) > 1: plastic = True f = l0/_N.sqrt(2*_N.pi*sx) # f*dt ########## nonstationary center location ctr = _N.empty((M, NT)) for m in xrange(M): ctr[m] = createSmoothedPath(ctr_chpts[m], NT) if len(ctr_chpts[m]) > 1: plastic = True if K > 0: ########## nonstationary marks mk_MU = _N.empty((nNrns, NT, K)) for n in xrange(nNrns): mk_MU[n] = createSmoothedPathK(mk_chpts[n], NT, K, LoHis[n]) if len(mk_chpts[n]) > 1: plastic = True if mvPat == NUNIF: now = 0 for rt in xrange(RTs): N = Ns[rt] # each traverse slightly different duration rp = _N.random.rand(N/100) x = _N.linspace(Lx, Hx, N) xp = _N.linspace(Lx, Hx, N/100) r = _N.interp(x, xp, rp) # creates a velocity vector # create movement without regard for place field r += Amx*(1.1+_N.sin(2*_N.pi*_N.linspace(0, 1, N, endpoint=False)*frqmx)) pth = _N.zeros(N+1) for n in xrange(1, N+1): pth[n] = pth[n-1] + r[n-1] pth /= (pth[-1] - pth[0]) pth *= (Hx-Lx) pth += Lx pths[now:now+N] = pth[0:N] now += N else: now = 0 x = _N.linspace(Lx, Hx, N) for rt in xrange(RTs): N = Ns[rt] pths[now:now+N] = x now += N if addShortStops: for ist in xrange(stops): done = False while not done: t0 = int(_N.random.rand()*NT) t1 = t0 + int(stopDur*(1+0.1*_N.random.randn())) if _N.abs(_N.max(_N.diff(pths[t0:t1]))) < 0.05*(Hx-Lx): done = True # not crossing origin pths[t0:t1] = _N.mean(pths[t0:t1]) ### now calculate firing rates dt = 0.001 fdt = f*dt # change place field location Lam = f*dt*_N.exp(-0.5*(pths-ctr)**2 / sx) rnds = _N.random.rand(M, NT) #dat = _N.zeros((NT, 2 + K)) dat = _N.zeros((NT, 2 + K)) dat[:, 0] = pths for m in xrange(M): sts = _N.where(rnds[m] < Lam[m])[0] dat[sts, 1] = 1 nrn = nrnNum[m] if K > 0: for t in xrange(len(sts)): dat[sts[t], 2:] = _N.random.multivariate_normal(mk_MU[nrn, sts[t]], Covs[nrn], size=1) # now noise spikes if bckgrdLam is not None: nzsts = _N.where(rnds[m] < (bckgrdLam*dt)/float(M))[0] dat[nzsts, 1] = 1 nrn = nrnNum[m] if K > 0: for t in xrange(len(nzsts)): dat[nzsts[t], 2:] = _N.random.multivariate_normal(mk_MU[nrn, nzsts[t]], Covs[nrn], size=1) if thresh is not None: sts = _N.where(dat[:, 1] == 1)[0] nID, nC = _N.where(dat[sts, 2:] < thresh) swtchs = _N.zeros((len(sts), K)) swtchs[nID, nC] = 1 # for all cells, all components below hash == 1 swtchsK = _N.sum(swtchs, axis=1) blw_thrsh_all_chs = _N.where(swtchsK == K)[0] abv_thr = _N.setdiff1d(_N.arange(len(sts)), blw_thrsh_all_chs) print "below thresh in all channels %(1)d / %(2)d" % {"1" : len(blw_thrsh_all_chs), "2" : len(sts)} dat[sts[blw_thrsh_all_chs], 1:] = 0 bFnd = False ## us un uniform sampling of space, stationary or non-stationary place field ## ns nn non-uni sampling of space, stationary or non-stationary place field ## bs bb biased and non-uni sampling of space bfn = "" if (M == 1) else ("%d" % M) if mvPat == UNIF: bfn += "u" else: bfn += "b" if (Amx > 0) else "n" bfn += "n" if plastic else "s" iInd = 0 while not bFnd: iInd += 1 dd = os.getenv("__EnDeDataDir__") fn = "%(dd)s/%(bfn)s%(iI)d.dat" % {"bfn" : bfn, "iI" : iInd, "dd" : dd} fnocc="%(dd)s/%(bfn)s%(iI)docc.png" % {"bfn" : bfn, "iI" : iInd, "dd" : dd} fnprm = "%(dd)s/%(bfn)s%(iI)d_prms.pkl" % {"bfn" : bfn, "iI" : iInd, "dd" : dd} if not os.access(fn, os.F_OK): # file exists bFnd = True smk = " %.4f" * K _U.savetxtWCom("%s" % fn, dat, fmt=("%.4f %d" + smk), delimiter=" ", com="# script=%s.py" % script) pcklme = {} pcklme["l0"] = l0[:, ::100] pcklme["f"] = ctr[:, ::100] pcklme["sq2"] = sx[:, ::100] pcklme["u"] = mk_MU[:, ::100] pcklme["covs"]= Covs pcklme["intv"]= 100 pcklme["km"] = km dmp = open(fnprm, "wb") pickle.dump(pcklme, dmp, -1) dmp.close() print "created %s" % fn fig = _plt.figure() _plt.hist(dat[:, 0], bins=_N.linspace(Lx, Hx, 101), color="black") _plt.savefig(fnocc) _plt.close()
def create(Lx, Hx, N, mvPat, RTs, frqmx, Amx, pT, l_sx_chpts, l_l0_chpts, l_ctr_chpts, mk_chpts, Covs, LoHis, km, bckgrdLam=None, script="no info", addShortStops=False, stops=10, stopDur=500, thresh=None, x_mvt=None, nz_mvt=None, spc_dim=1, segs=None): """ km tells me neuron N gives rise to clusters km[N] (list) bckgrd is background spike rate (Hz) """ global UNIF, NUNIF ##### First check that the number of neurons and PFs all consistent. nNrnsSX = len(l_sx_chpts) nNrnsL0 = len(l_l0_chpts) nNrnsCT = len(l_ctr_chpts) nNrnsMK = len(mk_chpts) nNrnsMKA = LoHis.shape[0] nNrnsMKC = Covs.shape[0] if not (nNrnsSX == nNrnsL0 == nNrnsCT == nNrnsMK == nNrnsMKA == nNrnsMKC): print("Number of neurons not consistent") return None nNrns = nNrnsSX if not (LoHis.shape[1] == Covs.shape[1] == Covs.shape[2]): print("Covariance of LoHis not correct") return None K = LoHis.shape[1] PFsPerNrn = _N.zeros(nNrns, dtype=_N.int) sx_chpts = [] l0_chpts = [] ctr_chpts = [] M = 0 # of place fields total. a neuron may have > 1 PFs. nrnNum = [] for nrn in range(nNrns): # # of place fields for neuron nrn nPFsSX = len(l_sx_chpts[nrn]) nPFsL0 = len(l_l0_chpts[nrn]) nPFsCT = len(l_ctr_chpts[nrn]) sx_chpts.extend(l_sx_chpts[nrn]) l0_chpts.extend(l_l0_chpts[nrn]) ctr_chpts.extend(l_ctr_chpts[nrn]) if not (nPFsSX == nPFsL0 == nPFsCT): print("Number of PFs for neuron %d not consistent" % nrn) return None M += len(l_ctr_chpts[nrn]) nrnNum += [nrn] * nPFsSX PFsPerNrn[nrn] = nPFsSX # M = # of clusters (in mark + pos space) # nNrns = # of neurons if x_mvt is None: #### build data Ns = _N.empty(RTs, dtype=_N.int) if mvPat == NUNIF: for rt in range(RTs): Ns[rt] = N * ((1 - pT) + pT * _N.random.rand()) else: Ns[:] = N NT = _N.sum(Ns) # total time we have data pths = _N.empty(NT) else: NT = x_mvt.shape[0] # total time we have data plastic = False ########## nonstationary center width # sx_chpts is flattened version of l_sx_chpts, which is a list per neuron # of place field change points. neur#1 has 1 pf, neur#2 has 5 pfs = 6 pfs # sxt should be (M x NT) sx = _N.empty((M, NT)) if spc_dim == 1 else _N.empty((M, NT, 2, 2)) isx = _N.empty((M, NT)) if spc_dim == 1 else _N.empty((M, NT, 2, 2)) for m in range(M): # sxts time scale if spc_dim == 1: sx[m] = createSmoothedPath( sx_chpts[m], NT)**2 # sx_chpts[m] is an ndaray. sx_chpts is a list if len(sx_chpts[m]) > 1: plastic = True isx[m] = 1. / sx[m] else: sx[m, :, 0, 0] = createSmoothedPath(sx_chpts[m][:, _N.array([0, 1])], NT)**2 sx[m, :, 1, 0] = createSmoothedPath(sx_chpts[m][:, _N.array([0, 2])], NT)**2 sx[m, :, 0, 1] = sx[m, :, 1, 0] sx[m, :, 1, 1] = createSmoothedPath(sx_chpts[m][:, _N.array([0, 3])], NT)**2 isx[m] = _N.linalg.inv(sx[m]) ########## nonstationary center height l0 # f is NT x M l0 = _N.empty((M, NT)) for m in range(M): l0[m] = createSmoothedPath(l0_chpts[m], NT) if len(l0_chpts[m]) > 1: plastic = True f = l0 / _N.sqrt(2 * _N.pi * sx) if spc_dim == 1 else l0 / _N.sqrt( (2 * _N.pi) * (2 * _N.pi) * _N.linalg.det(sx)) ########## nonstationary center width # sx_chpts is flattened version of l_sx_chpts, which is a list per neuron # of place field change points. neur#1 has 1 pf, neur#2 has 5 pfs = 6 pfs # sxt should be (M x NT) ctr = _N.empty((M, NT)) if spc_dim == 1 else _N.empty((M, NT, 2)) for m in range(M): # sxts time scale if spc_dim == 1: ctr[m] = createSmoothedPath( ctr_chpts[m], NT) # sx_chpts[m] is an ndaray. sx_chpts is a list if len(ctr_chpts[m]) > 1: plastic = True else: ctr[m, :, 0] = createSmoothedPath(ctr_chpts[m][:, _N.array([0, 1])], NT) ctr[m, :, 1] = createSmoothedPath(ctr_chpts[m][:, _N.array([0, 2])], NT) if K > 0: ########## nonstationary marks mk_MU = _N.empty((nNrns, NT, K)) print("------- ") for n in range(nNrns): mk_MU[n] = createSmoothedPathK(mk_chpts[n], NT, K, LoHis[n]) if len(mk_chpts[n]) > 1: plastic = True if x_mvt is None: if mvPat == NUNIF: now = 0 for rt in range(RTs): N = Ns[rt] # each traverse slightly different duration rp = _N.random.rand(N // 100) x = _N.linspace(Lx, Hx, N) xp = _N.linspace(Lx, Hx, N // 100) r = _N.interp(x, xp, rp) # creates a velocity vector # create movement without regard for place field frqmxR = _N.abs(frqmx * (1 + 0.25 * _N.random.randn())) _N.linspace(0, 1, N, endpoint=False) rscld_t = _N.random.rand(N) # rscld_t rscld_t /= (_N.max(rscld_t) * 1.01) rscld_t.sort() phi0 = _N.random.rand() * 2 * _N.pi r += _N.exp(Amx * _N.sin(2 * _N.pi * rscld_t * frqmxR + phi0)) pth = _N.zeros(N + 1) for n in range(1, N + 1): pth[n] = pth[n - 1] + r[n - 1] pth /= (pth[-1] - pth[0]) pth *= (Hx - Lx) pth += Lx pths[now:now + N] = pth[0:N] now += N else: # x_mvt is not None now = 0 x = _N.linspace(Lx, Hx, N) for rt in range(RTs): N = Ns[rt] pths[now:now + N] = x now += N if addShortStops: for ist in range(stops): done = False while not done: t0 = int(_N.random.rand() * NT) t1 = t0 + int(stopDur * (1 + 0.1 * _N.random.randn())) if _N.abs(_N.max(_N.diff(pths[t0:t1]))) < 0.05 * (Hx - Lx): done = True # not crossing origin pths[t0:t1] = _N.mean(pths[t0:t1]) else: pths = x_mvt ### now calculate firing rates dt = 0.001 fdt = f * dt # change place field location if spc_dim == 1: Lam = f * dt * _N.exp(-0.5 * (pths - ctr)**2 / sx) else: # spc_dim == 2 Lam = _N.empty((M, NT)) for m in range(M): dif = pths - ctr[m] Lam[m] = f[m] * dt * _N.exp( -0.5 * _N.einsum("ni,nij,nj->n", dif, isx[m], dif)) _N.savetxt("lam", Lam.T) _N.savetxt("pths", pths) rnds = _N.random.rand(M, NT) if spc_dim == 1: dat = _N.zeros((NT, 2 + K + 1)) dat[:, 0] = pths if segs is not None: dat[:, 2 + K] = segs else: dat[:, 2 + K] = 1 else: dat = _N.zeros((NT, 3 + K + 2)) if nz_mvt is not None: dat[:, 0:2] = nz_mvt else: dat[:, 0:2] = pths dat[:, 7:9] = segs spkind = 1 if spc_dim == 1 else 2 mrk_frm = 2 if spc_dim == 1 else 3 for m in range(M): sts = _N.where(rnds[m] < Lam[m])[0] # spikes from this neuron print("neuron %(m)d %(s)d spks" % {"m": m, "s": len(sts)}) alrdyXst = _N.where(dat[:, spkind] == 1)[0] # places where synchronous ndToMove = _N.intersect1d(alrdyXst, sts) dntMove = _N.setdiff1d(sts, ndToMove) # empty slots nonsynch = _N.empty(len(sts)) nonsynch[0:len(dntMove)] = dntMove print(len(ndToMove)) iStart = len(dntMove) # in nonsynch # for iOcpd in ndToMove: # occupied # bDone = False # while not bDone: # iOcpd += 1 # if datNghbr[iOcpd, 1] == 0: # datNghbr[iOcpd, 1] = 1 # nonsynch[iStart] = iOcpd # iStart += 1 # bDone = True snonsynch = _N.sort(nonsynch) dat[sts, spkind] = 1 nrn = nrnNum[m] if K > 0: for t in range(len(sts)): obsMrk = _N.random.multivariate_normal(mk_MU[nrn, sts[t]], Covs[nrn], size=1) dat[sts[t], mrk_frm:mrk_frm + K] = obsMrk # now noise spikes if bckgrdLam is not None: nzsts = _N.where(rnds[m] < (bckgrdLam * dt) / float(M))[0] dat[nzsts, spkind] = 1 nrn = nrnNum[m] if K > 0: for t in range(len(nzsts)): dat[nzsts[t], mrk_frm:mrk_frm + K] = _N.random.multivariate_normal(mk_MU[nrn, nzsts[t]], Covs[nrn], size=1) if thresh is not None: sts = _N.where(dat[:, spkind] == 1)[0] nID, nC = _N.where(dat[sts, mrk_frm:mrk_frm + K] < thresh) swtchs = _N.zeros((len(sts), K)) swtchs[nID, nC] = 1 # for all cells, all components below hash == 1 swtchsK = _N.sum(swtchs, axis=1) blw_thrsh_all_chs = _N.where(swtchsK == K)[0] abv_thr = _N.setdiff1d(_N.arange(len(sts)), blw_thrsh_all_chs) print("below thresh in all channels %(1)d / %(2)d" % { "1": len(blw_thrsh_all_chs), "2": len(sts) }) dat[sts[blw_thrsh_all_chs], spkind] = 0 bFnd = False ## us un uniform sampling of space, stationary or non-stationary place field ## ns nn non-uni sampling of space, stationary or non-stationary place field ## bs bb biased and non-uni sampling of space bfn = "" if (M == 1) else ("%d" % M) if mvPat == UNIF: bfn += "u" else: bfn += "b" if (Amx > 0) else "n" bfn += "n" if plastic else "s" iInd = 0 while not bFnd: iInd += 1 dd = os.getenv("__JIFIDataDir__") fn = "%(dd)s/%(bfn)s%(iI)d.dat" % {"bfn": bfn, "iI": iInd, "dd": dd} fnocc = "%(dd)s/%(bfn)s%(iI)docc.png" % { "bfn": bfn, "iI": iInd, "dd": dd } fnprm = "%(dd)s/%(bfn)s%(iI)d_prms.pkl" % { "bfn": bfn, "iI": iInd, "dd": dd } if not os.access(fn, os.F_OK): # file exists bFnd = True smk = " %.2f" * K if spc_dim == 1: smk += " %d" _U.savetxtWCom("%s" % fn, dat, fmt=("%.4f %d" + smk), delimiter=" ", com="# script=%s.py" % script) else: smk += " %d %d" _U.savetxtWCom("%s" % fn, dat, fmt=("%.2f %.2f %d" + smk), delimiter=" ", com="# script=%s.py" % script) pcklme = {} pcklme["l0"] = l0[:, ::100] pcklme["u"] = mk_MU[:, ::100] pcklme["covs"] = Covs pcklme["intv"] = 100 pcklme["km"] = km pcklme["f"] = ctr[:, ::100] pcklme["sq2"] = sx[:, ::100] dmp = open(fnprm, "wb") pickle.dump(pcklme, dmp, -1) dmp.close() print("created %s" % fn)
def done(): """ come here after 6 landmarks chosen """ global r, seg_ts, segs, Nsgs, inout, a_inout, lindist, lin_lr, lin_inout, lin_lr_inout, lr, raw_lindist global scxMin, scxMax, scyMin, scyMax global an, day, ep hdir = _N.empty(2) vdir = _N.empty(2) linp = _N.empty(2) """ L5 L0 L3 || || || || || || 5 1 3 || || || || || || L4===4===L1===2===L2 """ scxMin, scxMax, scyMin, scyMax = get_boundaries(r) segs_from_landmarks(segs, landmarks, length) e = inout_dir(segs, Nsgs) a_s, b_s, c_s = slopes_of_segs(segs) _plt.plot([segs[0, 0, 0], segs[0, 1, 0]], [segs[0, 0, 1], segs[0, 1, 1]], lw=3, color="black") _plt.plot([segs[1, 0, 0], segs[1, 1, 0]], [segs[1, 0, 1], segs[1, 1, 1]], lw=3, color="black") _plt.plot([segs[2, 0, 0], segs[2, 1, 0]], [segs[2, 0, 1], segs[2, 1, 1]], lw=3, color="black") _plt.plot([segs[3, 0, 0], segs[3, 1, 0]], [segs[3, 0, 1], segs[3, 1, 1]], lw=3, color="black") _plt.plot([segs[4, 0, 0], segs[4, 1, 0]], [segs[4, 0, 1], segs[4, 1, 1]], lw=3, color="black") segsr = segs.reshape((10, 2)) clrs = ["blue", "orange", "red", "green", "yellow", "black", "brown"] fillin_unobsvd(r) N = r.shape[0] seg_ts = _N.empty(N, dtype=_N.int) lindist = _N.empty(N) lin_lr = _N.empty(N) lin_inout = _N.empty(N) lin_lr_inout = _N.empty(N) lr = _N.ones(N, dtype=_N.int) * -3 inout = _N.empty(N, dtype=_N.int) a_inout = _N.empty(N) gk = gauKer(30) gk /= _N.sum(gk) fx = _N.convolve(0.5 * (r[:, 1] + r[:, 3]), gk, mode="same") fy = _N.convolve(0.5 * (r[:, 2] + r[:, 4]), gk, mode="same") xp = fx yp = fy xpyp = _N.empty((N, 2)) xpyp[:, 0] = xp xpyp[:, 1] = yp _xpyp = _N.repeat(xpyp, Nsgs * 2, axis=0) rxpyp = _xpyp.reshape((N, Nsgs * 2, 2)) dv = segsr - rxpyp dists = _N.sum(dv * dv, axis=2) # closest point on maze from field points rdists = dists.reshape((N, Nsgs, 2)) print rdists.shape online = _N.empty(Nsgs, dtype=bool) mins = _N.empty(Nsgs) for n in xrange(N): x0 = xpyp[n, 0] y0 = xpyp[n, 1] # xcs, ycs: pt on all line segs closest to x0, y0 (may b byond endpts) xcs = (b_s * (b_s * x0 - a_s * y0) - a_s * c_s) / (a_s * a_s + b_s * b_s) ycs = (-a_s * (b_s * x0 - a_s * y0) - b_s * c_s) / (a_s * a_s + b_s * b_s) find_clsest(n, x0, y0, segs, rdists, seg_ts, Nsgs, online, offset, xcs, ycs, mins, linp) # fig = _plt.figure() # _plt.plot(seg_ts) # clean_seg_ts(seg_ts) # _plt.plot(seg_ts) raw_lindist = _N.zeros(N) lindist_x0y0(N, xpyp, segs, rdists, seg_ts, Nsgs, online, offset, a_s, b_s, c_s, mins, linp, raw_lindist) smooth_lindist(raw_lindist, lindist) # fig = _plt.figure(figsize=(10, 4)) # _plt.plot(lindist) # gk = gauKer(8) # don't want to make this too large. if we just pass through the choice point, we can miss it. # gk /= _N.sum(gk) # flindist = _N.convolve(lindist, gk, mode="same") # lindist = flindist # rm_lindist_jumps(N, lindist, seg_ts) fig = _plt.figure(figsize=(10, 4)) _plt.plot(lindist) spd_thr = 0.35 a_inout_x0y0(N, a_inout, inout, r, seg_ts, spd_thr, e) #_plt.plot([x0, x0], [y0, y0], ms=10, marker=".", color=clr) make_lin_inout(N, lindist, inout, lin_inout) make_lin_lr(N, lr, lindist, seg_ts, r) build_lin_lr_inout(N, lin_lr_inout, lindist, lr, inout, gkRWD) # inout cp_lr, cp_inout = cpify_LR_inout(lr, inout) sday = ("0%d" % day) if (day < 10) else ("%d" % day) fn = _edd.datFN("lindist.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % { "dy": sday, "ep": (ep + 1), "an": anim2 }, create=True) _N.savetxt(fn, lindist, fmt="%.3f") fn = _edd.datFN("cp_lr.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % { "dy": sday, "ep": (ep + 1), "an": anim2 }) _U.savetxtWCom( fn, cp_lr, fmt="%d %d", com= ("# N=%d. 1st column time, 2nd column - inout value from this time until time in next row" % N)) fn = _edd.datFN("cp_inout.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % { "dy": sday, "ep": (ep + 1), "an": anim2 }) _U.savetxtWCom( fn, cp_inout, fmt="%d %d", com= ("# N=%d. 1st column time, 2nd column - inout value from this time until time in next row" % N)) fn = _edd.datFN("lin_lr_inout.dat", dir="linearize/%(an)s%(dy)s0%(ep)d" % { "dy": sday, "ep": (ep + 1), "an": anim2 }) _N.savetxt(fn, lin_lr_inout, fmt="%.3f") """ """ t0 = 0 winsz = 1000 t1 = 0 iw = -1 while t1 < N: iw += 1 t0 = iw * winsz t1 = (iw + 1) * winsz if (iw + 1) * winsz < N else N - 1 #btwnfigs(anim2, day, ep, t0, t1, inout, [-1.1, 1.1], seg_ts+1, [0.9, 5.1], r, 1, 2, scxMin, scxMax, scyMin, scyMax) btwnfigs(anim2, day, ep, t0, t1, inout, "INOUT", [-1.1, 1.1], lr, "LR", [-1.1, 1.1], lin_lr_inout, "lin_lr_inout", [-6.1, 6.1], r, 1, 2, scxMin, scxMax, scyMin, scyMax)