def iter_procs(iD, sD, rD, ps, ct, minlim):
pr, D = 0, 0
pD = float('NaN')
h, r, u, nr, im, Si = ps
procs = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
shuffle(procs)
for p in procs:
if p is 0: rD = bd.ResIn(rD, ps)
elif p is 1: rD = bd.res_flow(rD, ps)
elif p is 2: sD, iD = bd.immigration(sD, iD, ps)
elif p is 3: iD = bd.ind_flow(iD, ps)
elif p is 4: iD = bd.ind_disp(iD, ps)
elif p is 5: iD, rD, D = bd.consume(iD, rD, ps)
elif p is 6: iD = bd.grow(iD, ps)
elif p is 7: iD = bd.transition(iD, ps)
elif p is 8: iD = bd.maintenance(iD, ps)
elif p is 9: sD, iD, pr = bd.reproduce(sD, iD, ps)
avgQ = []
Sz = []
Ris = []
SpIDs = []
states = []
if len(list(iD)) > 0:
for k, v in iD.items():
Ris.append(v['q'] / (v['mt'] * v['sz']))
avgQ.append(v['q'])
Sz.append(v['sz'])
SpIDs.append(v['sp'])
states.append(v['st'])
avgQ = mean(avgQ)
Sz = mean(Sz)
N = len(states)
pD = states.count('d') / N
S = len(list(set(SpIDs)))
Ri = mean(Ris)
return [
iD, sD, rD, N, S,
len(list(rD)), ct + 1, pr, pD, avgQ, Sz, D, Ri
]
else:
return [
iD, sD, rD, 0, 0,
len(list(rD)), ct + 1, 0,
float('NaN'),
float('NaN'),
float('NaN'),
float('NaN'),
float('NaN')
]
def iter_procs(iD, sD, rD, ps, ct, minlim):
pr, D = 0, 0
pD = float('NaN')
h, r, u, nr, im, Si = ps
procs = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
shuffle(procs)
for p in procs:
if p is 0: rD = bd.ResIn(rD, ps)
elif p is 1: rD = bd.res_flow(rD, ps)
elif p is 2: sD, iD = bd.immigration(sD, iD, ps)
elif p is 3: iD = bd.ind_flow(iD, ps)
elif p is 4: iD = bd.ind_disp(iD, ps)
elif p is 5: iD, rD, D = bd.consume(iD, rD, ps)
elif p is 6: iD = bd.grow(iD, ps)
elif p is 7: iD = bd.transition(iD, ps)
elif p is 8: iD = bd.maintenance(iD, ps)
elif p is 9: sD, iD, pr = bd.reproduce(sD, iD, ps)
avgQ = []
Sz = []
Ris = []
SpIDs = []
states = []
if len(list(iD)) > 0:
for k, v in iD.items():
Ris.append(v['q']/(v['mt']*v['sz']))
avgQ.append(v['q'])
Sz.append(v['sz'])
SpIDs.append(v['sp'])
states.append(v['st'])
avgQ = mean(avgQ)
Sz = mean(Sz)
N = len(states)
pD = states.count('d')/N
S = len(list(set(SpIDs)))
Ri = mean(Ris)
return [iD, sD, rD, N, S, len(list(rD)), ct+1, pr, pD, avgQ, Sz, D, Ri]
else: return [iD, sD, rD, 0, 0, len(list(rD)), ct+1, 0, float('NaN'),
float('NaN'), float('NaN'), float('NaN'), float('NaN')]
def nextFrame(arg):
""" Function called for each successive animation frame; arg is the frame number """
global ADs, ADList, AVG_DIST, SpecDisp, SpecMaint, SpecGrowth, fixed, p, BurnIn, t, num_sims, width, height, Rates, u0, rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, SpColorDict, GrowthDict, N_RD, P_RD, C_RD, DispDict, MaintDict, one9th, four9ths, one36th, barrier, gmax, dmax, maintmax, IndIDs, Qs, IndID, IndTimeIn, IndExitAge, IndX, IndY, Ind_scatImage, SpeciesIDs, EnvD, TY, tracer_scatImage, TTimeIn, TIDs, TExitAge, TX, RTypes, RX, RY, RID, RIDs, RVals, RTimeIn, RExitAge, resource_scatImage, bN, bS, bE, bW, bNE, bNW, bSE, bSW, ct1, Mu, Maint, motion, reproduction, speciation, seedCom, m, r, nNi, nP, nC, rmax, sim, RAD, splist, N, ct, splist2, WTs, Jcs, Sos, RDens, RDiv, RRich, S, ES, Ev, BP, SD, Nm, sk, T, R, LowerLimit, prod_i, prod_q, viscosity, alpha, Ts, Rs, PRODIs, Ns, TTAUs, INDTAUs, RDENs, RDIVs, RRICHs, Ss, ESs, EVs, BPs, SDs, NMAXs, SKs, MUs, MAINTs, PRODNs, PRODPs, PRODCs, lefts, bottoms, Gs, Ms, NRs, PRs, CRs, Ds, RTAUs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, amp, freq, flux, pulse, phase, disturb, envgrads, barriers
ct += 1
#plot_system = 'yes'
plot_system = 'no'
# fluctuate flow according to amplitude, frequency, & phase
u1 = u0 + u0 * (amp * sin(2 * pi * ct * freq + phase))
if u1 > 1: u1 == 1.0
# Fluid dynamics
nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier = LBM.stream(
[nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier])
rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW = LBM.collide(
viscosity, rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, u0)
# Inflow of tracers
if motion == 'white_noise' or motion == 'brown_noise':
numt = 10
TIDs, TTimeIn, TX, TY = bide.NewTracers(numt, motion, TIDs, TX, TY,
TTimeIn, width, height, 2)
elif ct == 1:
numt = 10
TIDs, TTimeIn, TX, TY = bide.NewTracers(numt, motion, TIDs, TX, TY,
TTimeIn, width, height, 2)
else:
numt = 1
TIDs, TTimeIn, TX, TY = bide.NewTracers(numt, motion, TIDs, TX, TY,
TTimeIn, width, height, u0)
# moving tracer particles
if len(TIDs) > 0:
if motion == 'fluid':
TIDs, TX, TY, TExitAge, TTimeIn = bide.fluid_movement(
'tracer', TIDs, TTimeIn, TExitAge, TX, TY, ux, uy, width,
height, u0)
else:
TIDs, TX, TY, TExitAge, TTimeIn = bide.nonfluid_movement(
'tracer', motion, TIDs, TTimeIn, TExitAge, TX, TY, ux, uy,
width, height, u0)
# Inflow of resources
if motion == 'white_noise' or motion == 'brown_noise':
u1 = 2
RTypes, RVals, RX, RY, RIDs, RID, RTimeIn = bide.ResIn(
motion, RTypes, RVals, RX, RY, RID, RIDs, RTimeIn, r, rmax, nNi, nP,
nC, width, height, u1)
# resource flow
Lists = [RTypes, RIDs, RID, RVals]
if len(RTypes) > 0:
if motion == 'fluid':
RTypes, RX, RY, RExitAge, RIDs, RID, RTimeIn, RVals = bide.fluid_movement(
'resource', Lists, RTimeIn, RExitAge, RX, RY, ux, uy, width,
height, u0)
else:
RTypes, RX, RY, RExitAge, RIDs, RID, RTimeIn, RVals = bide.nonfluid_movement(
'resource', motion, Lists, RTimeIn, RExitAge, RX, RY, ux, uy,
width, height, u0)
# Inflow of individuals (immigration)
if ct == 1:
SpeciesIDs, IndX, IndY, MaintDict, EnvD, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.immigration(
dmax, gmax, maintmax, motion, seedCom, 1, SpeciesIDs, IndX, IndY,
width, height, MaintDict, EnvD, envgrads, GrowthDict, DispDict,
SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, nNi,
nP, nC, u1, alpha, GrowthList, MaintList, N_RList, P_RList,
C_RList, DispList, ADList)
else:
SpeciesIDs, IndX, IndY, MaintDict, EnvD, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.immigration(
dmax, gmax, maintmax, motion, 1, m, SpeciesIDs, IndX, IndY, width,
height, MaintDict, EnvD, envgrads, GrowthDict, DispDict,
SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, nNi,
nP, nC, u1, alpha, GrowthList, MaintList, N_RList, P_RList,
C_RList, DispList, ADList)
# dispersal
Lists = [
SpeciesIDs, IndIDs, IndID, Qs, DispDict, GrowthList, MaintList,
N_RList, P_RList, C_RList, DispList, ADList, Qs
]
if len(SpeciesIDs) > 0:
if motion == 'fluid':
SpeciesIDs, IndX, IndY, IndExitAge, IndIDs, IndID, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList, Qs = bide.fluid_movement(
'individual', Lists, IndTimeIn, IndExitAge, IndX, IndY, ux, uy,
width, height, u0)
else:
SpeciesIDs, IndX, IndY, IndExitAge, IndIDs, IndID, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList, Qs = bide.nonfluid_movement(
'individual', motion, Lists, IndTimeIn, IndExitAge, IndX, IndY,
ux, uy, width, height, u0)
# Chemotaxis
#SpeciesIDs, Qs, IndIDs, ID, TimeIn, X, Y, GrowthDict, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.chemotaxis(reproduction, speciation, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, width, height, GrowthDict, DispDict, SpColorDict, N_RD, P_RD, C_RD, MaintDict, EnvD, envgrads, nNi, nP, nC, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
# Forage
#SpeciesIDs, Qs, IndIDs, ID, TimeIn, X, Y, GrowthDict, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.density_forage(RVals, RX, RY, reproduction, speciation, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, width, height, GrowthDict, DispDict, SpColorDict, N_RD, P_RD, C_RD, MaintDict, EnvD, envgrads, nNi, nP, nC, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
PRODI, PRODN, PRODC, PRODP = 0, 0, 0, 0
p1, TNQ1, TPQ1, TCQ1 = metrics.getprod(Qs)
# Consume
RTypes, RVals, RIDs, RID, RTimeIn, RExitAge, RX, RY, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.consume(
RTypes, RVals, RIDs, RID, RX, RY, RTimeIn, RExitAge, SpeciesIDs, Qs,
IndIDs, IndID, IndTimeIn, IndX, IndY, width, height, GrowthDict, N_RD,
P_RD, C_RD, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList,
DispList, ADList)
# Reproduction
SpeciesIDs, Qs, IndIDs, ID, TimeIn, X, Y, GrowthDict, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.reproduce(
reproduction, speciation, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn,
IndX, IndY, width, height, GrowthDict, DispDict, SpColorDict, N_RD,
P_RD, C_RD, MaintDict, EnvD, envgrads, nNi, nP, nC, GrowthList,
MaintList, N_RList, P_RList, C_RList, DispList, ADList)
# maintenance
SpeciesIDs, X, Y, IndExitAge, IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.maintenance(
SpeciesIDs, IndX, IndY, IndExitAge, SpColorDict, MaintDict, EnvD,
IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList,
C_RList, DispList, ADList)
# transition to or from dormancy
Sp_IDs, IDs, Qs, GrowthList, MaintList, ADList = bide.transition(
SpeciesIDs, IndIDs, Qs, GrowthList, MaintList, ADList)
p2, TNQ2, TPQ2, TCQ2 = metrics.getprod(Qs)
PRODI = p2 - p1
PRODN = TNQ2 - TNQ1
PRODP = TPQ2 - TPQ1
PRODC = TCQ2 - TCQ1
# disturbance
if np.random.binomial(1, disturb * u0) == 1:
SpeciesIDs, X, Y, IndExitAge, IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.decimate(
SpeciesIDs, IndX, IndY, IndExitAge, SpColorDict, MaintDict, EnvD,
IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList,
C_RList, DispList, ADList)
ax = fig.add_subplot(111)
plt.tick_params(axis='both',
which='both',
bottom='off',
top='off',
left='off',
right='off',
labelbottom='off',
labelleft='off')
if len(SpeciesIDs) >= 1: RAD, splist = bide.GetRAD(SpeciesIDs)
else: RAD, splist, N, S = [], [], 0, 0
N, S, tt, rr = sum(RAD), len(RAD), len(TIDs), len(RIDs)
numD = ADList.count('d')
if N != len(ADList):
print N, len(SpeciesIDs), len(ADList)
print "N != len(ADList)"
sys.exit()
if N > 0:
Title = [
'Individuals consume resources, grow, reproduce, and die as they move through the environment. \nAverage speed on the x-axis is '
+ str(u0) + ' units per time step. ' + str(len(TExitAge)) +
' tracers have passed through.\nN: ' + str(N) + ', S: ' + str(S) +
', tracers: ' + str(tt) + ', resources: ' + str(rr) + ', ct: ' +
str(ct) + ', %dormant: ' + str(round((numD / N) * 100, 2))
]
else:
Title = [
'Individuals consume resources, grow, reproduce, and die as they move through the environment. \nAverage speed on the x-axis is '
+ str(u0) + ' units per time step. ' + str(len(TExitAge)) +
' tracers have passed through.\nN: ' + str(N) + ', S: ' + str(S) +
', tracers: ' + str(tt) + ', resources: ' + str(rr) + ', ct: ' +
str(ct) + ', %dormant: nan'
]
txt.set_text(' '.join(Title))
ax.set_ylim(0, height)
ax.set_xlim(0, width)
if plot_system == 'yes':
##### PLOTTING THE SYSTEM ##############################################
resource_scatImage.remove()
tracer_scatImage.remove()
Ind_scatImage.remove()
colorlist = []
sizelist = []
for i, val in enumerate(SpeciesIDs):
if ADList[i] == 'a':
colorlist.append('red')
elif ADList[i] == 'd':
colorlist.append('0.3')
sizelist.append(min(Qs[i]) * 1000)
resource_scatImage = ax.scatter(RX,
RY,
s=RVals * 100,
c='w',
edgecolor='SpringGreen',
lw=0.6,
alpha=0.3)
Ind_scatImage = ax.scatter(IndX,
IndY,
s=sizelist,
c=colorlist,
edgecolor='0.2',
lw=0.2,
alpha=0.9)
tracer_scatImage = ax.scatter(TX,
TY,
s=200,
c='r',
marker='*',
lw=0.0,
alpha=0.6)
Ns.append(N)
if N == 0 and BurnIn == 'not done':
Ns = [Ns[-1]] # only keep the most recent N value
BurnIn = 'done'
if ct > 200 and BurnIn == 'not done':
if len(Ns) > 100:
AugmentedDickeyFuller = sta.adfuller(Ns)
val, p = AugmentedDickeyFuller[0:2]
if p >= 0.05:
Ns.pop(0)
elif p < 0.05 or isnan(p) == True:
BurnIn = 'done'
Ns = [Ns[-1]] # only keep the most recent N value
if ct > 300 and BurnIn == 'not done':
Ns = [Ns[-1]] # only keep the most recent N value
BurnIn = 'done'
if BurnIn == 'done':
PRODIs.append(PRODI)
PRODNs.append(PRODN)
PRODPs.append(PRODP)
PRODCs.append(PRODC)
if len(RExitAge) > 0:
RTAUs.append(mean(RExitAge))
if len(IndExitAge) > 0:
INDTAUs.append(mean(IndExitAge))
if len(TExitAge) > 0:
TTAUs.append(mean(TExitAge))
# Examining the resource RAD
if len(RTypes) > 0:
RRAD, Rlist = bide.GetRAD(RTypes)
RDens = len(RTypes) / (height * width)
RDiv = float(metrics.Shannons_H(RRAD))
RRich = len(Rlist)
RDENs.append(RDens)
RDIVs.append(RDiv)
RRICHs.append(RRich)
# Number of tracers, resource particles, and individuals
T, R, N = len(TIDs), len(RIDs), len(SpeciesIDs)
Ts.append(T)
Rs.append(R)
Ss.append(S)
if N >= 1:
if R >= 1:
q = min([10, R])
#avg_dist = spatial.avg_dist(X, RX, Y, RY, q)
avg_dist = spatial.nearest_neighbor(X, RX, Y, RY, q)
AVG_DIST.append(avg_dist)
spD = DispDict.values()
spM = MaintDict.values()
spG = GrowthDict.values()
SpecDisp.append(mean(spD))
SpecMaint.append(mean(spM))
SpecGrowth.append(mean(spG))
RAD, splist = bide.GetRAD(SpeciesIDs)
RAD, splist = zip(*sorted(zip(RAD, splist), reverse=True))
RAD = list(RAD)
S = len(RAD)
Ss.append(S)
# Evenness, Dominance, and Rarity measures
Ev = metrics.e_var(RAD)
EVs.append(Ev)
ES = metrics.e_simpson(RAD)
ESs.append(ES)
if len(Ns) == 1:
splist2 = list(splist)
if len(Ns) > 1:
wt = metrics.WhittakersTurnover(splist, splist2)
jc = metrics.jaccard(splist, splist2)
so = metrics.sorensen(splist, splist2)
splist2 = list(splist)
WTs.append(wt)
Jcs.append(jc)
Sos.append(so)
Nm, BP = [max(RAD), Nm / N]
NMAXs.append(Nm)
BPs.append(BP)
SD = metrics.simpsons_dom(RAD)
SDs.append(SD)
sk = stats.skew(RAD)
SKs.append(sk)
Gs.append(mean(GrowthList))
Ms.append(mean(MaintList))
Ds.append(mean(DispList))
numD = ADList.count('d')
ADs.append(numD / len(ADList))
Nmeans = [sum(x) / len(x) for x in zip(*N_RList)]
NRs.append(mean(Nmeans))
Pmeans = [sum(x) / len(x) for x in zip(*P_RList)]
PRs.append(mean(Pmeans))
Cmeans = [sum(x) / len(x) for x in zip(*C_RList)]
CRs.append(mean(Cmeans))
#process = psutil.Process(os.getpid())
#mem = round(process.get_memory_info()[0] / float(2 ** 20), 1)
# return the memory usage in MB
if len(Ns) > 100:
t = time.clock() - t
#print sim, ' N:', int(round(mean(Ns))), 'S:', int(round(mean(Ss))), 'WT:', round(mean(WTs),2), ': flow:', u0, 'time:', round(t,1), 'seconds', ': Ttaus:',round(mean(TTimeIn)), round(mean(TExitAge)), ': Etau:', round(width/u0) #' MB:',int(round(mem)), 'p-val =', round(p,3)
#print sim, ' N:', int(round(mean(Ns))), 'S:', int(round(mean(Ss))), ': flow:', u0, 'time:', round(t,1), 'seconds', ' height:', str(height), ' Avg dist:', round(mean(AVG_DIST),3), ' f(dormant):',round(mean(ADs),3)
print sim, ' N:', int(round(mean(Ns))), 'S:', int(round(
mean(Ss))), ' flow:', u0, 'time:', round(
t,
1), 'Ttaus:', round(mean(TExitAge), 2), ': Etau:', round(
(width - 1) / u0, 2), 'dormant:', round(mean(ADs), 3)
t = time.clock()
SString = str(splist).strip('()')
RADString = str(RAD).strip('()')
RADString = str(RAD).strip('[]')
IndRTD = str(IndExitAge).strip('[]')
TRTD = str(TExitAge).strip('[]')
RRTD = str(RExitAge).strip('[]')
OUT1 = open(GenPath + 'examples/SimData.csv', 'a')
OUT2 = open(GenPath + 'examples/RADs.csv', 'a')
OUT3 = open(GenPath + 'examples/Species.csv', 'a')
OUT4 = open(GenPath + 'examples/IndRTD.csv', 'a')
OUT5 = open(GenPath + 'examples/TracerRTD.csv', 'a')
OUT6 = open(GenPath + 'examples/ResRTD.csv', 'a')
#TTAUs = np.mean(TExitAge), np.mean(TTimeIn)
outlist = [
sim, motion,
mean(PRODIs),
mean(PRODNs),
mean(PRODPs),
mean(PRODCs), r, nNi, nP, nC, rmax, gmax, maintmax, dmax,
barriers, alpha, seedCom, u0, width - 0.2, height, viscosity,
N, m,
mean(RTAUs),
mean(TExitAge),
mean(INDTAUs),
mean(RDENs),
mean(RDIVs),
mean(RRICHs),
mean(Ss),
mean(ESs),
mean(EVs),
mean(BPs),
mean(SDs),
mean(NMAXs),
mean(SKs), T, R, speciation,
mean(WTs),
mean(Jcs),
mean(Sos),
mean(Gs),
mean(Ms),
mean(NRs),
mean(PRs),
mean(CRs),
mean(Ds), amp, flux, freq, phase, disturb,
mean(SpecGrowth),
mean(SpecDisp),
mean(SpecMaint),
mean(AVG_DIST),
mean(ADs)
]
outlist = str(outlist).strip('[]')
print >> OUT1, outlist
print >> OUT2, RADString
print >> OUT3, SString
print >> OUT4, ct1, ',', sim, ',', IndRTD
print >> OUT5, ct1, ',', sim, ',', TRTD
print >> OUT6, ct1, ',', sim, ',', RRTD
OUT1.close()
OUT2.close()
OUT3.close()
OUT4.close()
OUT5.close()
OUT6.close()
ct1 += 1
ct = 0
Rates = np.roll(Rates, -1, axis=0)
u0 = Rates[0]
n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier, rho, ux, uy, bN, bS, bE, bW, bNE, bNW, bSE, bSW = LBM.SetLattice(
u0, viscosity, width, height, lefts, bottoms, barriers)
u1 = u0 + u0 * (amp * sin(2 * pi * ct * freq + phase))
RDens, RDiv, RRich, S, ES, Ev, BP, SD, Nm, sk, Mu, Maint, ct, IndID, RID, N, ct1, T, R, PRODI, PRODQ = [
0
] * 21
ADList, ADs, AVG_DIST, SpecDisp, SpecMaint, SpecGrowth, SpColorList, GrowthList, MaintList, N_RList, P_RList, C_RList, RColorList, DispList = [
list([]) for _ in xrange(14)
]
RAD, splist, IndTimeIn, SpeciesIDs, IndX, IndY, IndIDs, Qs, IndExitAge, TX, TY, TExitAge, TIDs, TTimeIn, RX, RY, RIDs, RTypes, RExitAge, RTimeIn, RVals, Gs, Ms, NRs, PRs, CRs, Ds, Ts, Rs, PRODIs, PRODNs, PRODPs, PRODCs, Ns, RTAUs, TTAUs, INDTAUs, RDENs, RDIVs, RRICHs, Ss, ESs, EVs, BPs, SDs, NMAXs, SKs, MUs, MAINTs, WTs, Jcs, Sos, splist2 = [
list([]) for _ in xrange(53)
]
p = 0
BurnIn = 'not done'
#if u0 in Rates:
if u0 == max(Rates):
print '\n'
sim += 1
if sim > num_sims:
print "simplex finished"
sys.exit()
width, height, alpha, motion, reproduction, speciation, seedCom, m, r, nNi, nP, nC, rmax, gmax, maintmax, dmax, amp, freq, flux, pulse, phase, disturb, envgrads, barriers, Rates = rp.get_rand_params(
fixed)
for i in range(barriers):
lefts.append(np.random.uniform(0.2, .8))
bottoms.append(np.random.uniform(0.1, 0.7))
n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier, rho, ux, uy, bN, bS, bE, bW, bNE, bNW, bSE, bSW = LBM.SetLattice(
u0, viscosity, width, height, lefts, bottoms, barriers)
u1 = u0 + u0 * (amp * sin(2 * pi * ct * freq + phase))
SpColorDict, GrowthDict, MaintDict, EnvD, N_RD, P_RD, C_RD, RColorDict, DispDict, EnvD = {}, {}, {}, {}, {}, {}, {}, {}, {}, {}
####################### REPLACE ENVIRONMENT ########################
ax = fig.add_subplot(111)
def nextFrame(arg):
""" Function called for each successive animation frame; arg is the frame number """
global mmax, pmax, ADs, ADList, AVG_DIST, SpecDisp, SpecMaint, SpecGrowth
global fixed, p, BurnIn, t, num_sims, width, height, Rates, u0, rho, ux, uy
global n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, SpColorDict, GrowthDict, N_RD
global P_RD, C_RD, DispDict, MaintDict, one9th, four9ths, one36th, barrier
global gmax, dmax, maintmax, IndIDs, Qs, IndID, IndTimeIn, IndExitAge, IndX
global IndY, Ind_scatImage, SpeciesIDs, EnvD, TY, tracer_scatImage, TTimeIn
global TIDs, TExitAge, TX, RTypes, RX, RY, RID, RIDs, RVals, RTimeIn, RExitAge
global resource_scatImage, bN, bS, bE, bW, bNE, bNW, bSE, bSW, ct1, Mu, Maint
global motion, reproduction, speciation, seedCom, m, r, nNi, nP, nC, rmax, sim
global RAD, splist, N, ct, splist2, WTs, Jcs, Sos, RDens, RDiv, RRich, S, ES
global Ev, BP, SD, Nm, sk, T, R, LowerLimit, prod_i, prod_q, viscosity, alpha
global Ts, Rs, PRODIs, Ns, TTAUs, INDTAUs, RDENs, RDIVs, RRICHs, Ss, ESs, EVs
global BPs, SDs, NMAXs, SKs, MUs, MAINTs, PRODNs, PRODPs, PRODCs, lefts, bottoms
global Gs, Ms, NRs, PRs, CRs, Ds, RTAUs, GrowthList, MaintList, N_RList, P_RList
global C_RList, DispList, amp, freq, flux, pulse, phase, disturb, envgrads
global barriers, MainFactorDict, RPFDict
ct += 1
#plot_system = 'yes'
plot_system = 'no'
# fluctuate flow according to amplitude, frequency, & phase
u1 = u0 + u0*(amp * sin(2*pi * ct * freq + phase))
if u1 > 1: u1 == 1.0
# Fluid dynamics
nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier = LBM.stream([nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier])
rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW = LBM.collide(viscosity, rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, u0)
# Inflow of resources
if motion == 'white_noise' or motion == 'brown_noise':
u1 = 2
RTypes, RVals, RX, RY, RIDs, RID, RTimeIn = bide.ResIn(motion, RTypes, RVals, RX, RY, RID, RIDs, RTimeIn, r, rmax, nNi, nP, nC, width, height, u1)
# resource flow
Lists = [RTypes, RIDs, RID, RVals]
if len(RTypes) > 0:
if motion == 'fluid': RTypes, RX, RY, RExitAge, RIDs, RID, RTimeIn, RVals = bide.fluid_movement('resource', Lists, RTimeIn, RExitAge, RX, RY, ux, uy, width, height, u0)
else: RTypes, RX, RY, RExitAge, RIDs, RID, RTimeIn, RVals = bide.nonfluid_movement('resource', motion, Lists, RTimeIn, RExitAge, RX, RY, ux, uy, width, height, u0)
# Inflow of individuals (immigration)
if ct == 1:
SpeciesIDs, IndX, IndY, MaintDict, MainFactorDict, RPFDict, EnvD, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.immigration(mmax, pmax, dmax, gmax, maintmax, motion, seedCom, 1, SpeciesIDs, IndX, IndY, width, height, MaintDict, MainFactorDict, RPFDict, EnvD, envgrads, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, nNi, nP, nC, u1, alpha, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
else:
SpeciesIDs, IndX, IndY, MaintDict, MainFactorDict, RPFDict, EnvD, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.immigration(mmax, pmax, dmax, gmax, maintmax, motion, 1, m, SpeciesIDs, IndX, IndY, width, height, MaintDict, MainFactorDict, RPFDict, EnvD, envgrads, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, N_RD, P_RD, C_RD, nNi, nP, nC, u1, alpha, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
# dispersal
Lists = [SpeciesIDs, IndIDs, IndID, Qs, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList]
if len(SpeciesIDs) > 0:
if motion == 'fluid': SpeciesIDs, IndX, IndY, IndExitAge, IndIDs, IndID, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList, Qs = bide.fluid_movement('individual', Lists, IndTimeIn, IndExitAge, IndX, IndY, ux, uy, width, height, u0)
else: SpeciesIDs, IndX, IndY, IndExitAge, IndIDs, IndID, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.nonfluid_movement('individual', motion, Lists, IndTimeIn, IndExitAge, IndX, IndY, ux, uy, width, height, u0)
# Chemotaxis
#SpeciesIDs, Qs, IndIDs, ID, TimeIn, X, Y, GrowthDict, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.chemotaxis(reproduction, speciation, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, width, height, GrowthDict, DispDict, SpColorDict, N_RD, P_RD, C_RD, MaintDict, MainFactorDict, RPFDict, EnvD, envgrads, nNi, nP, nC, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
# Forage
#SpeciesIDs, Qs, IndIDs, ID, TimeIn, X, Y, GrowthDict, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.density_forage(RVals, RX, RY, reproduction, speciation, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, width, height, GrowthDict, DispDict, SpColorDict, N_RD, P_RD, C_RD, MaintDict, MainFactorDict, RPFDict, EnvD, envgrads, nNi, nP, nC, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
PRODI, PRODN, PRODC, PRODP = 0, 0, 0, 0
p1, TNQ1, TPQ1, TCQ1 = metrics.getprod(Qs)
# Consume
#RTypes, RVals, RIDs, RID, RTimeIn, RExitAge, RX, RY, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.consume(RTypes, RVals, RIDs, RID, RX, RY, RTimeIn, RExitAge, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, width, height, GrowthDict, N_RD, P_RD, C_RD, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
# Reproduction
SpeciesIDs, Qs, IndIDs, ID, TimeIn, X, Y, GrowthDict, DispDict, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.reproduce(reproduction, speciation, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndX, IndY, width, height, GrowthDict, DispDict, SpColorDict, N_RD, P_RD, C_RD, MaintDict, MainFactorDict, RPFDict, EnvD, envgrads, nNi, nP, nC, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
# maintenance
#SpeciesIDs, X, Y, IndExitAge, IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.maintenance(SpeciesIDs, IndX, IndY, IndExitAge, SpColorDict, MaintDict, MainFactorDict, RPFDict, EnvD, IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
# transition to or from dormancy
Sp_IDs, IDs, Qs, GrowthList, MaintList, ADList = bide.transition(SpeciesIDs, IndIDs, Qs, GrowthList, MaintList, MainFactorDict, RPFDict, ADList)
p2, TNQ2, TPQ2, TCQ2 = metrics.getprod(Qs)
PRODI = p2 - p1
PRODN = TNQ2 - TNQ1
PRODP = TPQ2 - TPQ1
PRODC = TCQ2 - TCQ1
# disturbance
#if np.random.binomial(1, disturb*u0) == 1: SpeciesIDs, X, Y, IndExitAge, IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList = bide.decimate(SpeciesIDs, IndX, IndY, IndExitAge, SpColorDict, MaintDict, MainFactorDict, RPFDict, EnvD, IndIDs, IndTimeIn, Qs, GrowthList, MaintList, N_RList, P_RList, C_RList, DispList, ADList)
ax = fig.add_subplot(111)
plt.tick_params(axis='both', which='both', bottom='off', top='off', left='off', right='off', labelbottom='off', labelleft='off')
if len(SpeciesIDs) >= 1: RAD, splist = bide.GetRAD(SpeciesIDs)
else: RAD, splist, N, S = [], [], 0, 0
N, S, tt, rr = sum(RAD), len(RAD), len(TIDs), len(RIDs)
numD = ADList.count('d')
if N != len(ADList):
print N, len(SpeciesIDs), len(ADList)
print "N != len(ADList)"
sys.exit()
if N > 0:
Title = ['Individuals consume resources, grow, reproduce, and die as they move through the environment. \nAverage speed on the x-axis is '+str(u0)+' units per time step. '+str(len(TExitAge))+' tracers have passed through.\nN: '+str(N)+', S: '+str(S)+', tracers: '+str(tt)+', resources: '+str(rr)+', ct: '+str(ct)+', %dormant: '+str(round((numD/N)*100, 2))]
else:
Title = ['Individuals consume resources, grow, reproduce, and die as they move through the environment. \nAverage speed on the x-axis is '+str(u0)+' units per time step. '+str(len(TExitAge))+' tracers have passed through.\nN: '+str(N)+', S: '+str(S)+', tracers: '+str(tt)+', resources: '+str(rr)+', ct: '+str(ct)+', %dormant: nan']
txt.set_text(' '.join(Title))
ax.set_ylim(0, height)
ax.set_xlim(0, width)
if plot_system == 'yes':
##### PLOTTING THE SYSTEM ##############################################
resource_scatImage.remove()
tracer_scatImage.remove()
Ind_scatImage.remove()
colorlist = []
sizelist = []
for i, val in enumerate(SpeciesIDs):
if ADList[i] == 'a':
colorlist.append('red')
elif ADList[i] == 'd':
colorlist.append('0.3')
sizelist.append(min(Qs[i]) * 1000)
resource_scatImage = ax.scatter(RX, RY, s = RVals*100, c = 'w', edgecolor = 'SpringGreen', lw = 0.6, alpha=0.3)
Ind_scatImage = ax.scatter(IndX, IndY, s = sizelist, c = colorlist, edgecolor = '0.2', lw = 0.2, alpha=0.9)
tracer_scatImage = ax.scatter(TX, TY, s = 200, c = 'r', marker='*', lw=0.0, alpha=0.6)
Ns.append(N)
if N == 0 and BurnIn == 'not done':
Ns = [Ns[-1]] # only keep the most recent N value
BurnIn = 'done'
if ct > 200 and BurnIn == 'not done':
if len(Ns) > 100:
AugmentedDickeyFuller = sta.adfuller(Ns)
val, p = AugmentedDickeyFuller[0:2]
if p >= 0.05:
Ns.pop(0)
elif p < 0.05 or isnan(p) == True:
BurnIn = 'done'
Ns = [Ns[-1]] # only keep the most recent N value
if ct > 300 and BurnIn == 'not done':
Ns = [Ns[-1]] # only keep the most recent N value
BurnIn = 'done'
if BurnIn == 'done':
PRODIs.append(PRODI)
PRODNs.append(PRODN)
PRODPs.append(PRODP)
PRODCs.append(PRODC)
if len(RExitAge) > 0:
RTAUs.append(mean(RExitAge))
if len(IndExitAge) > 0:
INDTAUs.append(mean(IndExitAge))
if len(TExitAge) > 0:
TTAUs.append(mean(TExitAge))
# Examining the resource RAD
if len(RTypes) > 0:
RRAD, Rlist = bide.GetRAD(RTypes)
RDens = len(RTypes)/(height*width)
RDiv = float(metrics.Shannons_H(RRAD))
RRich = len(Rlist)
RDENs.append(RDens)
RDIVs.append(RDiv)
RRICHs.append(RRich)
# Number of tracers, resource particles, and individuals
T, R, N = len(TIDs), len(RIDs), len(SpeciesIDs)
Ts.append(T)
Rs.append(R)
Ss.append(S)
if N >= 1:
if R >= 1:
q = min([10, R])
avg_dist = spatial.avg_dist(IndX, RX, IndY, RY, q)
avg_dist = spatial.nearest_neighbor(IndX, RX, IndY, RY, q)
AVG_DIST.append(avg_dist)
spD = DispDict.values()
spM = MaintDict.values()
spMF = MainFactorDict.values()
spRPF = RPFDict.values()
spG = GrowthDict.values()
SpecDisp.append(mean(spD))
SpecMaint.append(mean(spM))
SpecGrowth.append(mean(spG))
RAD, splist = bide.GetRAD(SpeciesIDs)
RAD, splist = zip(*sorted(zip(RAD, splist), reverse=True))
RAD = list(RAD)
S = len(RAD)
Ss.append(S)
# Evenness, Dominance, and Rarity measures
Ev = metrics.e_var(RAD)
EVs.append(Ev)
ES = metrics.e_simpson(RAD)
ESs.append(ES)
if len(Ns) == 1:
splist2 = list(splist)
if len(Ns) > 1:
wt = metrics.WhittakersTurnover(splist, splist2)
jc = metrics.jaccard(splist, splist2)
so = metrics.sorensen(splist, splist2)
splist2 = list(splist)
WTs.append(wt)
Jcs.append(jc)
Sos.append(so)
Nm, BP = [max(RAD), Nm/N]
NMAXs.append(Nm)
BPs.append(BP)
SD = metrics.simpsons_dom(RAD)
SDs.append(SD)
sk = stats.skew(RAD)
SKs.append(sk)
Gs.append(mean(GrowthList))
Ms.append(mean(MaintList))
Ds.append(mean(DispList))
numD = ADList.count('d')
ADs.append(numD/len(ADList))
Nmeans = [sum(x)/len(x) for x in zip(*N_RList)]
NRs.append(mean(Nmeans))
Pmeans = [sum(x)/len(x) for x in zip(*P_RList)]
PRs.append(mean(Pmeans))
Cmeans = [sum(x)/len(x) for x in zip(*C_RList)]
CRs.append(mean(Cmeans))
#process = psutil.Process(os.getpid())
#mem = round(process.get_memory_info()[0] / float(2 ** 20), 1)
# return the memory usage in MB
if len(Ns) > 100:
t = time.clock() - t
#print sim, ' N:', int(round(mean(Ns))), 'S:', int(round(mean(Ss))), 'WT:', round(mean(WTs),2), ': flow:', u0, 'time:', round(t,1), 'seconds', ': Ttaus:',round(mean(TTimeIn)), round(mean(TExitAge)), ': Etau:', round(width/u0) #' MB:',int(round(mem)), 'p-val =', round(p,3)
#print sim, ' N:', int(round(mean(Ns))), 'S:', int(round(mean(Ss))), ': flow:', u0, 'time:', round(t,1), 'seconds', ' height:', str(height), ' Avg dist:', round(mean(AVG_DIST),3), ' f(dormant):',round(mean(ADs),3)
print sim, ' N:', int(round(mean(Ns))), 'S:', int(round(mean(Ss))), ' flow:', u0, 'time:', round(t,1), 'Ttaus:', round(mean(TExitAge),2), ': Etau:', round((width-1)/u0,2), 'dormant:', round(mean(ADs),3)
t = time.clock()
SString = str(splist).strip('()')
RADString = str(RAD).strip('()')
RADString = str(RAD).strip('[]')
IndRTD = str(IndExitAge).strip('[]')
TRTD = str(TExitAge).strip('[]')
RRTD = str(RExitAge).strip('[]')
OUT1 = open(GenPath + '/SimData.csv','a')
#TTAUs = np.mean(TExitAge), np.mean(TTimeIn)
outlist = [sim,motion,mean(PRODIs),mean(PRODNs),mean(PRODPs),mean(PRODCs),r,nNi,nP,nC,rmax,gmax,maintmax,dmax,barriers,alpha,seedCom,u0,width-0.2,height,viscosity,N,m,mean(RTAUs), mean(TExitAge) ,mean(INDTAUs),mean(RDENs),mean(RDIVs),mean(RRICHs),mean(Ss),mean(ESs),mean(EVs),mean(BPs),mean(SDs),mean(NMAXs),mean(SKs),T,R,speciation,mean(WTs),mean(Jcs),mean(Sos),mean(Gs),mean(Ms),mean(NRs),mean(PRs),mean(CRs),mean(Ds),amp,flux,freq,phase,disturb, mean(SpecGrowth), mean(SpecDisp), mean(SpecMaint), mean(AVG_DIST), mean(ADs)]
outlist = str(outlist).strip('[]')
print>>OUT1, outlist
OUT1.close()
ct1 += 1
ct = 0
Rates = np.roll(Rates, -1, axis=0)
u0 = Rates[0]
n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier, rho, ux, uy, bN, bS, bE, bW, bNE, bNW, bSE, bSW = LBM.SetLattice(u0, viscosity, width, height, lefts, bottoms, barriers)
u1 = u0 + u0*(amp * sin(2*pi * ct * freq + phase))
RDens, RDiv, RRich, S, ES, Ev, BP, SD, Nm, sk, Mu, Maint, ct, IndID, RID, N, ct1, T, R, PRODI, PRODQ = [0]*21
ADList, ADs, AVG_DIST, SpecDisp, SpecMaint, SpecGrowth, SpColorList, GrowthList, MaintList, N_RList, P_RList, C_RList, RColorList, DispList = [list([]) for _ in xrange(14)]
RAD, splist, IndTimeIn, SpeciesIDs, IndX, IndY, IndIDs, Qs, IndExitAge, TX, TY, TExitAge, TIDs, TTimeIn, RX, RY, RIDs, RTypes, RExitAge, RTimeIn, RVals, Gs, Ms, NRs, PRs, CRs, Ds, Ts, Rs, PRODIs, PRODNs, PRODPs, PRODCs, Ns, RTAUs, TTAUs, INDTAUs, RDENs, RDIVs, RRICHs, Ss, ESs, EVs,BPs, SDs, NMAXs, SKs, MUs, MAINTs, WTs, Jcs, Sos, splist2 = [list([]) for _ in xrange(53)]
p = 0
BurnIn = 'not done'
#if u0 in Rates:
if u0 == max(Rates):
print '\n'
sim += 1
if sim > num_sims:
print "model finished"
sys.exit()
width, height, alpha, motion, reproduction, speciation, seedCom, m, r, nNi, nP, nC, rmax, gmax, maintmax, dmax, amp, freq, flux, pulse, phase, disturb, envgrads, barriers, Rates, pmax, mmax = rp.get_rand_params(fixed)
for i in range(barriers):
lefts.append(np.random.uniform(0.2, .8))
bottoms.append(np.random.uniform(0.1, 0.7))
n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier, rho, ux, uy, bN, bS, bE, bW, bNE, bNW, bSE, bSW = LBM.SetLattice(u0, viscosity, width, height, lefts, bottoms, barriers)
u1 = u0 + u0*(amp * sin(2*pi * ct * freq + phase))
SpColorDict, GrowthDict, MaintDict, MainFactorDict, RPFDict, EnvD, N_RD, P_RD, C_RD, RColorDict, DispDict, EnvD = {}, {}, {}, {}, {}, {}, {}, {}, {}, {}
####################### REPLACE ENVIRONMENT ########################
ax = fig.add_subplot(111)
def nextFrame(arg):
""" Function called for each successive animation frame; arg is the frame number """
global mmax, pmax, ADs, ADList, AVG_DIST, SpecDisp, SpecMaint, SpecGrowth
global fixed, p, BurnIn, t, num_sims, width, height, Rates, GrowthDict, RD
global DispDict, MaintDict, gmax, dmax, maintmax, IndIDs, Qs, EVList
global IndID, IndX, IndY, Ind_scatImage, SpeciesIDs, TLList
global RX, RY, RID, RIDs, RVals, EnvD, resource_scatImage, Mu, Maint
global seedCom, m, r, sim
global N, ct, RDens, RDiv, RRich, T, R, LowerLimit, prod_i, prod_q
global Ts, Rs, PRODIs, Ns, RDENs, RDIVs, RRICHs, GrowthList, MaintList, RList
global MUs, MAINTs, PRODNs, PRODPs, PRODCs, Gs, Ms, Ds
global DispList, envgrads, MainFactorDict, RPFDict, enzyme_field, u0
global TrophicComplexityLevel, SpatialComplexityLevel, encList, std
global ResourceComplexityLevel, BiologicalComplexityLevel
global Ragg, Iagg, static, Deadlist
numDead = 0
ct += 1
#print ct
encounters = 0
# Inflow of resources
RList, RVals, RX, RY, RIDs, RID = bide.ResIn(std, ct, RList, RVals, RX, RY, RID,\
RIDs, r, width, height, u0, TrophicComplexityLevel, SpatialComplexityLevel, \
ResourceComplexityLevel, BiologicalComplexityLevel)
# Immigration
SpeciesIDs, IndX, IndY, MaintDict, MainFactorDict, RPFDict, EnvD, GrowthDict,\
DispDict, IndIDs, IndID, Qs, RD, GrowthList, MaintList, DispList, ADList, EVList,\
TLList = bide.immigration(std, mmax, pmax, dmax, gmax, maintmax, seedCom, m, \
SpeciesIDs, IndX, IndY, width, height, MaintDict, MainFactorDict, RPFDict, EnvD, envgrads,\
GrowthDict, DispDict, IndIDs, IndID, Qs, RD, u0, GrowthList, MaintList, \
DispList, ADList, EVList, TLList, ct, TrophicComplexityLevel, \
SpatialComplexityLevel, ResourceComplexityLevel, BiologicalComplexityLevel)
# Dispersal
if SpatialComplexityLevel < 3:
SpeciesIDs, Qs, IndIDs, ID, IndX, IndY, GrowthDict, DispDict, GrowthList, \
MaintList, DispList, ADList, EVList, TLList, RList, RVals, RX, RY, RIDs, RID, numDead = bide.dispersal(SpeciesIDs,\
Qs, IndIDs, IndID, IndX, IndY, width, height, GrowthDict, \
DispDict, RD, MaintDict, MainFactorDict, RPFDict, EnvD, envgrads, \
GrowthList, MaintList, DispList, ADList, EVList, TLList, RList, RVals, RX, RY, RIDs, RID, TrophicComplexityLevel, \
SpatialComplexityLevel, ResourceComplexityLevel, BiologicalComplexityLevel, numDead)
elif SpatialComplexityLevel == 3:
RList, RVals, RIDs, RID, RX, RY, SpeciesIDs, Qs, IndIDs, IndID, IndX, IndY, width, height, GD, RD, DispD, GrowthList,\
MaintList, DispList, ADList, TLList, EVList, numDead = bide.chemotaxis(RList, RVals, RIDs, RID, RX, RY, SpeciesIDs, Qs, IndIDs, IndID,\
IndX, IndY, width, height, GrowthDict, RD, DispDict, GrowthList, MaintList, DispList, ADList, TLList, EVList,\
TrophicComplexityLevel, SpatialComplexityLevel, ResourceComplexityLevel, BiologicalComplexityLevel, numDead)
# Resource Dispersal
if SpatialComplexityLevel == 1:
RList, RVals, RX, RY, RID, RIDs = bide.res_dispersal(ct, RList, RVals, RX, RY, RID, RIDs, r,\
width, height, u0, TrophicComplexityLevel, SpatialComplexityLevel, \
ResourceComplexityLevel, BiologicalComplexityLevel)
PRODI = 0
p1 = len(Qs)
# Consume
RList, RVals, RIDs, RID, RX, RY, SpeciesIDs, Qs, encounters = bide.consume(enzyme_field, \
RList, RVals, RIDs, RID, RX, RY, SpeciesIDs, Qs, IndIDs, IndID, IndX, IndY, \
width, height, GrowthDict, MaintDict, RD, DispDict, GrowthList, MaintList, DispList, ADList, \
TLList, EVList, TrophicComplexityLevel, SpatialComplexityLevel, \
ResourceComplexityLevel, BiologicalComplexityLevel)
# Reproduction
SpeciesIDs, Qs, IndIDs, ID, IndX, IndY, GrowthDict, DispDict, GrowthList, MaintList, \
DispList, ADList, EVList, TLList, RList, RVals, RX, RY, RID, RIDs, numDead = bide.reproduce(SpeciesIDs, Qs, IndIDs, IndID, \
IndX, IndY, width, height, GrowthDict, DispDict, RD, MaintDict, MainFactorDict, \
RPFDict, EnvD, envgrads, GrowthList, MaintList, DispList, ADList, EVList, TLList, RList, RVals, RX, RY, RID, RIDs, \
TrophicComplexityLevel, SpatialComplexityLevel, ResourceComplexityLevel, \
BiologicalComplexityLevel, numDead)
# maintenance
SpeciesIDs, IndX, IndY, IndIDs, Qs, GrowthList, MaintList, DispList, ADList,\
EVList, TLList, RList, RVals, RX, RY, RIDs, RID, numDead = bide.maintenance(SpeciesIDs, IndX, IndY, MaintDict, MainFactorDict, \
RPFDict, EnvD, IndIDs, Qs, GrowthList, MaintList, DispList, ADList, EVList, TLList, RList, RVals, RX, RY, RIDs, RID,\
TrophicComplexityLevel, SpatialComplexityLevel, ResourceComplexityLevel, \
BiologicalComplexityLevel, numDead)
# transition to or from dormancy
SpeciesIDs, IndX, IndY, GrowthList, DispList, ADList, EVList, IndIDs, Qs, GrowthList, \
MaintList, TLList, RList, RVals, RX, RY, RIDs, RID, numDead = bide.transition(SpeciesIDs, IndX, IndY, GrowthList, DispList, ADList, EVList,\
IndIDs, Qs, MaintList, TLList, RList, RVals, RX, RY, RIDs, RID, MainFactorDict, RPFDict, \
TrophicComplexityLevel, SpatialComplexityLevel, ResourceComplexityLevel, \
BiologicalComplexityLevel, numDead)
p2 = len(Qs)
PRODI = p2 - p1
ax1 = fig.add_subplot(2,2,1) # initiate 1st plot
ax2 = fig.add_subplot(2,2,2) # initiate 2nd plot
ax3 = fig.add_subplot(2,2,3) # initiate 3rd plot
ax4 = fig.add_subplot(2,2,4) # initiate 4th plot
plt.tick_params(axis='both', which='both', bottom='off', top='off', \
left='off', right='off', labelbottom='off', labelleft='off')
N = len(IndIDs)
if N == 0 or N > 20000:
TrophicComplexityLevel = choice([1,2,3]) #
SpatialComplexityLevel = choice([1,2,3]) # goes up to 3
ResourceComplexityLevel = choice([1,2,3]) # goes up to 3 but needs enzyme breakdown
BiologicalComplexityLevel = 2
RDens, RDiv, RRich, Mu, Maint, ct, IndID, RID, N, T, R, PRODI, PRODQ = [0]*13
ADList, ADs, AVG_DIST, SpecDisp, SpecMaint, SpecGrowth, GrowthList, MaintList, RVals, \
DispList, EVList, TLList = [list([]) for _ in xrange(12)]
SpeciesIDs, IndX, IndY, IndIDs, Qs, RX, RY, RIDs, RList, RVals, Gs, Ms, \
Ds, Rs, PRODIs, Ns, RDENs, RDIVs, RRICHs, MUs, MAINTs, encList, Ragg, Iagg = [list([]) for _ in xrange(24)]
if u0 == max(Rates):
#sim += 1
width, height, seedCom, m, r, gmax, maintmax, dmax, envgrads, Rates, pmax, mmax, std = rp.get_rand_params(fixed)
GrowthDict, MaintDict, MainFactorDict, RPFDict, EnvD, RD, DispDict,\
EnvD = {}, {}, {}, {}, {}, {}, {}, {}
enzyme_field = [0]*(width*height)
p = 0
BurnIn = 'not done'
Ns.append(N)
rr = len(RIDs)
numD = ADList.count('d')
pD = 0.0
if N > 0:
pD = round((numD/N*100), 2)
Title = ['Active individuals (red) consume resources, grow, reproduce, go dormant (gray) and die in complex resource-limited environment.\n \
Resource complexity: ' + str(ResourceComplexityLevel) + ', Trophic complexity: ' + str(TrophicComplexityLevel) + ', \
Spatial complexity: ' + str(SpatialComplexityLevel) + ' N: '+str(N)+', Resources: '+str(rr)+', ct: '+str(ct)+ ', \
%Dormant: '+str(pD) + '\n# of inflowing resources: ' + str(r) + ', Aggregation: ' + str(round(std,2))]
txt.set_text(' '.join(Title))
#ax1.set_ylim(0, height)
#ax1.set_xlim(0, width)
plot_system = 'yes'
if plot_system == 'yes':
##### PLOTTING THE SYSTEM ##############################################
resource_scatImage.remove()
Ind_scatImage.remove()
plot2.remove()
plot3.remove()
plot4.remove()
colorlist = []
ind_sizelist = []
res_sizelist = []
for val in RVals:
res_sizelist.append(val*200)
for i, val in enumerate(SpeciesIDs):
if ADList[i] == 'a':
colorlist.append('red')
elif ADList[i] == 'd':
colorlist.append('0.3')
ind_sizelist.append(Qs[i] * 1000)
resource_scatImage = ax1.scatter(RX, RY, s = res_sizelist, c = 'w',
edgecolor = 'SpringGreen', lw = 2.0, alpha=0.7)
Ind_scatImage = ax1.scatter(IndX, IndY, s = ind_sizelist, c = colorlist,
edgecolor = '0.2', lw = 0.2, alpha=0.8)
ax2 = fig.add_subplot(2,2,2) # initiate 2nd plot
ax3 = fig.add_subplot(2,2,3) # initiate 3rd plot
ax4 = fig.add_subplot(2,2,4) # initiate 4th plot
plot2 = ax2.scatter([0],[0], alpha=0)
plot3 = ax3.scatter([0],[0], alpha=0)
plot4 = ax4.scatter([0],[0], alpha=0)
if len(Ns) >= 50:
if BurnIn == 'not done':
AugmentedDickeyFuller = sta.adfuller(Ns)
val, p = AugmentedDickeyFuller[0:2]
if p >= 0.05:
Ns.pop(0)
elif p < 0.05 or isnan(p) == True:
BurnIn = 'done'
Ns = [Ns[-1]] # only keep the most recent N value
if ct == 100:
BurnIn = 'done'
Ns = [Ns[-1]] # only keep the most recent N value
if BurnIn == 'done':
PRODIs.append(PRODI)
if len(RList) > 0:
RDens = len(RList)/(height*width)
RDENs.append(RDens)
R = len(RX)
Rs.append(R)
encList.append(encounters)
if N >= 1:
if N >= 2:
Imor = spatial.morisitas(IndX, IndY, width, height)
Iagg.append(Imor)
if R >= 1:
q = min([20, R])
#avg_dist1 = spatial.avg_dist(IndX, RX, IndY, RY, q)
avg_dist2 = spatial.nearest_neighbor(IndX, RX, IndY, RY, q)
AVG_DIST.append(avg_dist2)
if R >= 2:
Rmor = spatial.morisitas(RX, RY, width, height)
Ragg.append(Rmor)
spD = DispDict.values()
spM = MaintDict.values()
spG = GrowthDict.values()
SpecDisp.append(mean(spD))
SpecMaint.append(mean(spM))
SpecGrowth.append(mean(spG))
Gs.append(mean(GrowthList))
Ms.append(mean(MaintList))
Ds.append(mean(DispList))
numD = ADList.count('d')
ADs.append(numD/len(ADList))
Deadlist.append(numDead)
if len(Ns) >= 20:
print '%4s' % sim, ' r:','%4s' % r, ' R:','%4s' % int(round(mean(Rs))), ' N:','%5s' % int(round(mean(Ns))), \
' Dormant:', '%5s' % round(mean(ADs),3), ' Encounters:','%5s' % round(mean(encList),2), ' Spatial:', SpatialComplexityLevel, \
'Resource:', ResourceComplexityLevel, 'Trophic:', TrophicComplexityLevel#, \
#'Agg(I):', round(mean(Iagg), 2), 'Agg(R):', round(mean(Ragg),2)
Rates = np.roll(Rates, -1, axis=0)
u0 = Rates[0]
if static == 'no':
TrophicComplexityLevel = choice([1,2,3,4]) #
SpatialComplexityLevel = choice([1,2,3]) # goes up to 3
ResourceComplexityLevel = choice([1,2,3]) # goes up to 3 but needs enzyme breakdown
BiologicalComplexityLevel = 2
RDens, RDiv, RRich, Mu, Maint, ct, IndID, RID, N, T, R, PRODI, PRODQ, numD = [0]*14
ADList, ADs, AVG_DIST, SpecDisp, SpecMaint, SpecGrowth, GrowthList, MaintList, RVals, \
DispList, EVList, TLList, Deadlist = [list([]) for _ in xrange(13)]
SpeciesIDs, IndX, IndY, IndIDs, Qs, RX, RY, RIDs, RList, RVals, Gs, Ms, \
Ds, Rs, PRODIs, Ns, RDENs, RDIVs, RRICHs, MUs, MAINTs, encList, Ragg, Iagg = [list([]) for _ in xrange(24)]
p = 0
BurnIn = 'not done'
if u0 == max(Rates):
sim += 1
width, height, seedCom, m, r, gmax, maintmax, dmax, envgrads, Rates, pmax, mmax, std = rp.get_rand_params(fixed)
GrowthDict, MaintDict, MainFactorDict, RPFDict, EnvD, RD, DispDict,\
EnvD = {}, {}, {}, {}, {}, {}, {}, {}
enzyme_field = [0]*(width*height)
####################### REPLACE ENVIRONMENT ########################
ax1 = fig.add_subplot(2,2,1)
ax2 = fig.add_subplot(2,2,2) # initiate first plot
ax3 = fig.add_subplot(2,2,3) # initiate first plot
ax4 = fig.add_subplot(2,2,4) # initiate first plot
def Hbide(V, REStime, Rcons, Pcons, PropQ, time, mean, std, Kq, lgp, maint,
res_pulse, im_pulse, env_noise, spatial_het, basic, system, disp_mu,
disp_std):
"""
V : Volume
Rcons : resource concentration
Pcons : propagule concentration
maint : resource loss due to cell maintenance
REStime : residence time
time : number of time steps to run simulation. Needs to be large
enough to allow the community to reach a relatively stable state
dormancy : designate whether dormancy is allowed. If dormancy is True,
then cell quotas of 0 result in dormancy, if dormancy = False, then cell
quotas of 0 result in death and immediate 'removal'
"""
r = V / REStime # rate of flow
TR = Rcons * V # total resources in the local environment
num_in = int(round(r * Pcons))
if num_in < 1 and Pcons > 1:
return ['Continuously empty system']
Nlist = [] # total abundance
Glist = [] # average growth rate
Slist = [] # richness
Prodlist = [] # productivity list
Rlist = [] # total resources
Qlist = [] # cell quota
MAXUlist = []
Tlist = [] # number of generations in the system
MCT = []
if basic == False:
SoNlist = [] # average species abundance
TOlist = [] # biomass turnover
Evarlist = [] # evenness
Hlist = [] # Shannon's diversity
CTlist = [] # compositional turnover
RADlist = [] # list of RADs
maxUptake_list = []
maxUptake_dict = {}
xcoords = []
ycoords = []
zcoords = []
DispParamsDict = {}
Qs1 = []
Qs2 = list(Qs1)
N = len(Qs1)
Slist1 = []
Slist2 = list(Slist1)
inds1 = []
inds2 = list(inds1)
ID = 0
lag = 0
""" Initial bout of immigration """
init_n = 1000
Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict, maxUptake_list, DispParamsDict, xcoords, ycoords, zcoords = bide.immigration(
system, V, Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict,
maxUptake_list, DispParamsDict, mean, std, lgp, init_n, PropQ, xcoords,
ycoords, zcoords, disp_mu, disp_std)
Nlist2 = []
pastBurnIn = 'no'
Hurst = float()
pval = float()
for t in range(time):
""" Resource resupply """
TR += r * Rcons # Total Resources increase due to inflow
""" Immigration """
if system != 'ideal':
Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict, maxUptake_list, DispParamsDict, xcoords, ycoords, zcoords = bide.immigration(
system, V, Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict,
maxUptake_list, DispParamsDict, mean, std, lgp, num_in, PropQ,
xcoords, ycoords, zcoords, disp_mu, disp_std)
""" Growth """
Qs2, Slist2, inds2, maxUptake_list, Tlist, TR, glist, xcoords, ycoords, zcoords = bide.growth(
Qs2, Slist2, inds2, maxUptake_list, Tlist, TR, Kq, maint, xcoords,
ycoords, zcoords)
N = len(Qs2)
if N == 0:
return ['N = 0']
""" Reproduction """
Qs2, Slist2, inds2, Tlist, maxUptake_list, Kq, ID, prod, xcoords, ycoords, zcoords = bide.reproduction(
Qs2, Slist2, inds2, Tlist, maxUptake_list, Kq, ID, maint, xcoords,
ycoords, zcoords)
""" Check community variables and list lengths"""
check = checks(Qs2, Slist2, inds2, Tlist, xcoords, ycoords, zcoords)
if check[0] != 'pass':
return check
""" Emigration """ # will eventually be modified to allow individuals to naturally flow out
Qs2, Slist2, inds2, Tlist, maxUptake_list, xcoords, ycoords, zcoords = bide.emigration(
Qs2, Slist2, inds2, Tlist, maxUptake_list, r, V, xcoords, ycoords,
zcoords, system)
N = len(Qs2)
if N == 0:
return ['N = 0 after emigration']
""" Dispersal """
Qs2, Slist2, inds2, Tlist, maxUptake_list, DispParamsDict, Kq, ID, xcoords, ycoords, zcoords = bide.dispersal(
V, Qs2, Slist2, inds2, Tlist, maxUptake_list, DispParamsDict, Kq,
ID, xcoords, ycoords, zcoords, system)
""" Outflow """
TR, V = bide.outflow(TR, r, V)
N = len(Qs2)
if N == 0:
return ['N = 0']
if pastBurnIn == 'no':
Nlist2.append(N)
if len(Nlist2) > 500:
Hurst, pval = timeSeries.get_burnin(Nlist2)
if Hurst < 0.5 and pval < 0.01:
pastBurnIn = 'yes'
Nlist2 = []
burnIn = t
time += time # let the simulation go longer
else:
pastBurnIn = 'no'
if pastBurnIn == 'yes':
""" Record community info """
Glist.append(np.mean(glist))
Nlist.append(prod)
Slist.append(len(set(Slist2)))
Prodlist.append(prod)
Rlist.append(float(TR))
Qlist.append(float(sum(Qs2) / len(Qs2)))
MAXUlist.append(float(np.mean(maxUptake_list)))
if min(Tlist) == 0 and max(Tlist) == 0:
MCT.append(0)
else:
Tlist_noZeros = filter(lambda a: a != 0, Tlist)
MCT.append(float(np.mean(Tlist_noZeros)))
if basic == False:
S1 = set(Slist1)
s1 = len(S1)
S2 = set(Slist2)
s2 = len(S2)
c = len(S1 & S2)
CT = ((s1 - c) + (s2 - c)) / np.mean([s1, s2])
# Whittaker's tunover (species)
I1 = set(inds1)
i1 = len(I1)
I2 = set(inds2)
i2 = len(I2)
c = len(I1 & I2)
TO = ((i1 - c) + (i2 - c)) / np.mean([i1, i2])
# Whittaker's tunover (individuals)
RAD = [] # Generate the rank-abundance distribution (RAD)
for i in S2:
ab = Slist2.count(i)
RAD.append(ab)
RAD.sort()
RAD.reverse()
RADtaulist = [10, 100, 1000]
ct = RADtaulist.count(REStime)
if ct > 0 and t == time - 1:
RADlist = list([V, REStime, RAD])
TOlist.append(TO)
SoNlist.append(float(N / s2))
Hlist.append(float(metrics.Shannons_even(RAD)))
Evarlist.append(float(metrics.e_var(RAD)))
CTlist.append(float(CT))
if len(Nlist) >= 500:
#lag = timeSeries.get_uncorrelated(Nlist)
if REStime <= 10:
lag = 10
else:
lag = REStime
if lag > 0:
samp_size = int(round(len(Nlist) / lag))
if samp_size >= 10:
Glist = sample(Glist, samp_size)
Nlist = sample(Nlist, samp_size)
Slist = sample(Slist, samp_size)
Prodlist = sample(Prodlist, samp_size)
MAXUlist = sample(MAXUlist, samp_size)
Rlist = sample(Rlist, samp_size)
Qlist = sample(Qlist, samp_size)
MCT = sample(MCT, samp_size)
if basic == True:
return [
np.mean(Glist),
np.mean(Nlist),
np.mean(Slist),
np.mean(Rlist),
np.mean(Qlist),
np.mean(MAXUlist), burnIn, lag,
np.mean(Prodlist),
np.mean(MCT), Hurst, pval
]
elif basic == False:
TOlist = sample(TOlist, samp_size)
SoNlist = sample(SoNlist, samp_size)
Hlist = sample(Hlist, samp_size)
Evarlist = sample(Evarlist, samp_size)
CTlist = sample(CTlist, samp_size)
return [
np.mean(Glist),
np.mean(Nlist),
np.mean(Rlist),
np.mean(TOlist),
np.mean(Qlist),
np.mean(CTlist),
np.mean(Evarlist),
np.mean(Hlist), RADlist,
np.mean(SoNlist),
np.mean(MAXUlist), burnIn, lag,
np.mean(Prodlist),
np.mean(MCT), Hurst, pval
]
""" saving this generations lists """
Slist1 = list(Slist2)
inds1 = list(inds2)
Qs1 = list(Qs2)
if t == time - 1 and pastBurnIn == 'no':
return [
'failed to reach stationarity in ' + str(time) +
' generations, H = ' + str(round(Hurst, 3)) + ', p = ' +
str(round(pval, 3))
]
#lag = timeSeries.get_uncorrelated(Nlist)
if REStime <= 10:
lag = 10
else:
lag = REStime
if lag == 0:
return [
'no sufficient time lag in ' + str(len(Nlist)) + ' generations'
]
else:
samp_size = int(round(len(Nlist) / lag))
if samp_size < 10:
return [
'insufficient sample of unbiased time points from ' +
str(len(Nlist)) + ' generations'
]
Glist = sample(Glist, samp_size)
Nlist = sample(Nlist, samp_size)
Slist = sample(Slist, samp_size)
Prodlist = sample(Prodlist, samp_size)
MAXUlist = sample(MAXUlist, samp_size)
Rlist = sample(Rlist, samp_size)
Qlist = sample(Qlist, samp_size)
MCT = sample(MCT, samp_size)
if basic == True:
return [
np.mean(Glist),
np.mean(Nlist),
np.mean(Slist),
np.mean(Rlist),
np.mean(Qlist),
np.mean(MAXUlist), burnIn, lag,
np.mean(Prodlist),
np.mean(MCT), Hurst, pval
]
elif basic == False:
TOlist = sample(TOlist, samp_size)
SoNlist = sample(SoNlist, samp_size)
Hlist = sample(Hlist, samp_size)
Evarlist = sample(Evarlist, samp_size)
CTlist = sample(CTlist, samp_size)
return [
np.mean(Glist),
np.mean(Nlist),
np.mean(Rlist),
np.mean(TOlist),
np.mean(Qlist),
np.mean(CTlist),
np.mean(Evarlist),
np.mean(Hlist), RADlist,
np.mean(SoNlist),
np.mean(MAXUlist), burnIn, lag,
np.mean(Prodlist),
np.mean(MCT), Hurst, pval
]
return ['no result']
def Hbide(V, REStime, Rcons, Pcons, PropQ, time, mean, std, Kq, lgp, maint, res_pulse, im_pulse, env_noise, spatial_het, basic, system, disp_mu, disp_std):
"""
V : Volume
Rcons : resource concentration
Pcons : propagule concentration
maint : resource loss due to cell maintenance
REStime : residence time
time : number of time steps to run simulation. Needs to be large
enough to allow the community to reach a relatively stable state
dormancy : designate whether dormancy is allowed. If dormancy is True,
then cell quotas of 0 result in dormancy, if dormancy = False, then cell
quotas of 0 result in death and immediate 'removal'
"""
r = V/REStime # rate of flow
TR = Rcons * V # total resources in the local environment
num_in = int(round(r * Pcons))
if num_in < 1 and Pcons > 1:
return ['Continuously empty system']
Nlist = [] # total abundance
Glist = [] # average growth rate
Slist = [] # richness
Prodlist = [] # productivity list
Rlist = [] # total resources
Qlist = [] # cell quota
MAXUlist = []
Tlist = [] # number of generations in the system
MCT = []
if basic == False:
SoNlist = [] # average species abundance
TOlist = [] # biomass turnover
Evarlist = [] # evenness
Hlist = [] # Shannon's diversity
CTlist = [] # compositional turnover
RADlist = [] # list of RADs
maxUptake_list = []
maxUptake_dict = {}
xcoords = []
ycoords = []
zcoords = []
DispParamsDict = {}
Qs1 = []
Qs2 = list(Qs1)
N = len(Qs1)
Slist1 = []
Slist2 = list(Slist1)
inds1 = []
inds2 = list(inds1)
ID = 0
lag = 0
""" Initial bout of immigration """
init_n = 1000
Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict, maxUptake_list, DispParamsDict, xcoords, ycoords, zcoords = bide.immigration(system, V, Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict, maxUptake_list, DispParamsDict, mean, std, lgp, init_n, PropQ, xcoords, ycoords, zcoords, disp_mu, disp_std)
Nlist2 = []
pastBurnIn = 'no'
Hurst = float()
pval = float()
for t in range(time):
""" Resource resupply """
TR += r * Rcons # Total Resources increase due to inflow
""" Immigration """
if system != 'ideal':
Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict, maxUptake_list, DispParamsDict, xcoords, ycoords, zcoords = bide.immigration(system, V, Qs2, Slist2, inds2, Tlist, ID, maxUptake_dict, maxUptake_list, DispParamsDict, mean, std, lgp, num_in, PropQ, xcoords, ycoords, zcoords, disp_mu, disp_std)
""" Growth """
Qs2, Slist2, inds2, maxUptake_list, Tlist, TR, glist, xcoords, ycoords, zcoords = bide.growth(Qs2, Slist2, inds2, maxUptake_list, Tlist, TR, Kq, maint, xcoords, ycoords, zcoords)
N = len(Qs2)
if N == 0:
return ['N = 0']
""" Reproduction """
Qs2, Slist2, inds2, Tlist, maxUptake_list, Kq, ID, prod, xcoords, ycoords, zcoords = bide.reproduction(Qs2, Slist2, inds2, Tlist, maxUptake_list, Kq, ID, maint, xcoords, ycoords, zcoords)
""" Check community variables and list lengths"""
check = checks(Qs2, Slist2, inds2, Tlist, xcoords, ycoords, zcoords)
if check[0] != 'pass':
return check
""" Emigration """ # will eventually be modified to allow individuals to naturally flow out
Qs2, Slist2, inds2, Tlist, maxUptake_list, xcoords, ycoords, zcoords = bide.emigration(Qs2, Slist2, inds2, Tlist, maxUptake_list, r, V, xcoords, ycoords, zcoords, system)
N = len(Qs2)
if N == 0:
return ['N = 0 after emigration']
""" Dispersal """
Qs2, Slist2, inds2, Tlist, maxUptake_list, DispParamsDict, Kq, ID, xcoords, ycoords, zcoords = bide.dispersal(V, Qs2, Slist2, inds2, Tlist, maxUptake_list, DispParamsDict, Kq, ID, xcoords, ycoords, zcoords, system)
""" Outflow """
TR, V = bide.outflow(TR, r, V)
N = len(Qs2)
if N == 0:
return ['N = 0']
if pastBurnIn == 'no':
Nlist2.append(N)
if len(Nlist2) > 500:
Hurst, pval = timeSeries.get_burnin(Nlist2)
if Hurst < 0.5 and pval < 0.01:
pastBurnIn = 'yes'
Nlist2 = []
burnIn = t
time += time # let the simulation go longer
else:
pastBurnIn = 'no'
if pastBurnIn == 'yes':
""" Record community info """
Glist.append(np.mean(glist))
Nlist.append(prod)
Slist.append(len(set(Slist2)))
Prodlist.append(prod)
Rlist.append(float(TR))
Qlist.append(float(sum(Qs2)/len(Qs2)))
MAXUlist.append(float(np.mean(maxUptake_list)))
if min(Tlist) == 0 and max(Tlist) == 0:
MCT.append(0)
else:
Tlist_noZeros = filter(lambda a: a != 0, Tlist)
MCT.append(float(np.mean(Tlist_noZeros)))
if basic == False:
S1 = set(Slist1)
s1 = len(S1)
S2 = set(Slist2)
s2 = len(S2)
c = len(S1 & S2)
CT = ((s1 - c) + (s2 - c))/np.mean([s1, s2])
# Whittaker's tunover (species)
I1 = set(inds1)
i1 = len(I1)
I2 = set(inds2)
i2 = len(I2)
c = len(I1 & I2)
TO = ((i1 - c) + (i2 - c))/np.mean([i1, i2])
# Whittaker's tunover (individuals)
RAD = [] # Generate the rank-abundance distribution (RAD)
for i in S2:
ab = Slist2.count(i)
RAD.append(ab)
RAD.sort()
RAD.reverse()
RADtaulist = [10, 100, 1000]
ct = RADtaulist.count(REStime)
if ct > 0 and t == time-1:
RADlist = list([V, REStime, RAD])
TOlist.append(TO)
SoNlist.append(float(N/s2))
Hlist.append(float(metrics.Shannons_even(RAD)))
Evarlist.append(float(metrics.e_var(RAD)))
CTlist.append(float(CT))
if len(Nlist) >= 500:
#lag = timeSeries.get_uncorrelated(Nlist)
if REStime <= 10:
lag = 10
else: lag = REStime
if lag > 0:
samp_size = int(round(len(Nlist)/lag))
if samp_size >= 10:
Glist = sample(Glist, samp_size)
Nlist = sample(Nlist, samp_size)
Slist = sample(Slist, samp_size)
Prodlist = sample(Prodlist, samp_size)
MAXUlist = sample(MAXUlist, samp_size)
Rlist = sample(Rlist, samp_size)
Qlist = sample(Qlist, samp_size)
MCT = sample(MCT, samp_size)
if basic == True:
return [np.mean(Glist), np.mean(Nlist), np.mean(Slist),
np.mean(Rlist), np.mean(Qlist), np.mean(MAXUlist),
burnIn, lag, np.mean(Prodlist), np.mean(MCT),
Hurst, pval]
elif basic == False:
TOlist = sample(TOlist, samp_size)
SoNlist = sample(SoNlist, samp_size)
Hlist = sample(Hlist, samp_size)
Evarlist = sample(Evarlist, samp_size)
CTlist = sample(CTlist, samp_size)
return [np.mean(Glist), np.mean(Nlist), np.mean(Rlist), np.mean(TOlist),
np.mean(Qlist), np.mean(CTlist),
np.mean(Evarlist), np.mean(Hlist), RADlist,
np.mean(SoNlist), np.mean(MAXUlist), burnIn,
lag, np.mean(Prodlist), np.mean(MCT), Hurst, pval]
""" saving this generations lists """
Slist1 = list(Slist2)
inds1 = list(inds2)
Qs1 = list(Qs2)
if t == time-1 and pastBurnIn == 'no':
return ['failed to reach stationarity in '+str(time)+' generations, H = '+str(round(Hurst, 3))+', p = '+str(round(pval, 3))]
#lag = timeSeries.get_uncorrelated(Nlist)
if REStime <= 10:
lag = 10
else: lag = REStime
if lag == 0:
return ['no sufficient time lag in '+str(len(Nlist))+' generations']
else:
samp_size = int(round(len(Nlist)/lag))
if samp_size < 10:
return ['insufficient sample of unbiased time points from '+str(len(Nlist))+' generations']
Glist = sample(Glist, samp_size)
Nlist = sample(Nlist, samp_size)
Slist = sample(Slist, samp_size)
Prodlist = sample(Prodlist, samp_size)
MAXUlist = sample(MAXUlist, samp_size)
Rlist = sample(Rlist, samp_size)
Qlist = sample(Qlist, samp_size)
MCT = sample(MCT, samp_size)
if basic == True:
return [np.mean(Glist), np.mean(Nlist), np.mean(Slist), np.mean(Rlist),
np.mean(Qlist), np.mean(MAXUlist), burnIn,
lag, np.mean(Prodlist), np.mean(MCT), Hurst, pval]
elif basic == False:
TOlist = sample(TOlist, samp_size)
SoNlist = sample(SoNlist, samp_size)
Hlist = sample(Hlist, samp_size)
Evarlist = sample(Evarlist, samp_size)
CTlist = sample(CTlist, samp_size)
return [np.mean(Glist), np.mean(Nlist), np.mean(Rlist),
np.mean(TOlist), np.mean(Qlist), np.mean(CTlist),
np.mean(Evarlist), np.mean(Hlist), RADlist,
np.mean(SoNlist), np.mean(MAXUlist), burnIn,
lag, np.mean(Prodlist), np.mean(MCT), Hurst, pval]
return ['no result']
t0 = time.clock()
while sim < numSims:
numDead, encounters, res_in = 0, 0, 0
ct += 1
RowID += 1
shuffle(x)
t2 = float()
t1 = time.clock()
for xi in x:
# Inflow of resources
if xi == 0: ResLists, ResDict, res_in = bide.ResIn(ResLists, ResDict, params, ct, ComplexityLevels)
# Immigration
elif xi == 1: IndDict, SpDicts = bide.immigration(IndDict, SpDicts, params, ct, ComplexityLevels)
# Individual Dispersal
elif xi == 2 and '-none-' not in SC: IndDict, ResList, ResDict, numDead = bide.dispersal(IndDict, SpDicts, ResLists, ResDict, params, ComplexityLevels, numDead)
# Resource Dispersal
elif xi == 3: ResLists = bide.res_dispersal(ResLists, params, ct, ComplexityLevels)
# Consumption
elif xi == 4: ResLists, ResDict, IndDict, encounters, numDead = bide.consume(IndDict, SpDicts, ResLists, ResDict, params, ComplexityLevels, numDead)
# Reproduction
elif xi == 5: PRODI, IndDicts, ResLists, ResDict, numDead = bide.reproduce(IndDict, SpDicts, ResLists, ResDict, params, ComplexityLevels, numDead)
# Maintenance
elif xi == 6: IndDict, ResLists, ResDict, numDead = bide.maintenance(IndDict, SpDicts, ResLists, ResDict, ComplexityLevels, numDead)
def nextFrame(arg): # arg is the frame number
print arg
plot_system = 'yes'
logdata = 'no'
global width, height, length, Rates, u0, shift, sign, rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW
global SpColorDict, GrowthDict, ResUseDict, DispDict, MaintDict, one9th, four9ths, one36th, barrier
global IndIDs, Qs, IndID, IndTimeIn, IndExitAge, IndXcoords, IndYcoords, IndZcoords, Ind_scatImage, SpeciesIDs
global TracerYcoords, tracer_scatImage, TracerTimeIn, TracerZcoords, TracerIDs, TracerExitAge, TracerXcoords
global ResTypes, ResXcoords, ResYcoords, ResZcoords, ResID, ResIDs, ResVals, ResTimeIn, ResExitAge, resource_scatImage
global avg_Q, avg_maint, avg_disp, avg_res, avgTau, avg_growth, avg_prey, avg_symb, avg_parasite
global barrierN, barrierS, barrierE, barrierW, barrierNE, barrierNW, barrierSE, barrierSW
global BarrierWidth, BarrierHeight, BarrierXcoords1, BarrierYcoords1, BarrierXcoords2, BarrierYcoords2
global ct1, Mu, Maint, motion, D, reproduction, speciation, predators, parasites, symbionts
global env_gradient, seedcom, m, r, nr, rmax, sim, RAD, splist, N, TracerTau, IndTau, ct
global ResDens, ResDiv, ResRich, S, ES, Ev, BP, SD, Nm, sk, T, R, LowerLimit, prod_i, prod_q, viscosity, alpha
global Ts, Rs, PRODIs, PRODQs, Ns, TRACERTAUs, INDTAUs, RESDENs, RESDIVs, RESRICHs, Ss, ESs, EVs, BPs, SDs, NMAXs, SKs, MUs, MAINTs, RESTAUs
for step in range(1): # adjust number of steps for smooth animation
# inflow of tracers
TracerIDs, TracerTimeIn, TracerXcoords, TracerYcoords, TracerZcoords = bide.NewTracers(motion, TracerIDs, TracerXcoords, TracerYcoords, TracerZcoords, TracerTimeIn, width, height, length, u0, D)
# inflow of resources
ResTypes, ResVals, ResXcoords, ResYcoords, ResZcoords, ResIDs, ResID, ResTimeIn = bide.ResIn(motion, ResTypes, ResVals, ResXcoords, ResYcoords, ResZcoords, ResID, ResIDs, ResTimeIn, r, rmax, nr, width, height, length, u0, D)
# immigration
if ct == 0:
ct = 1
SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, MaintDict, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, ResUseDict = bide.immigration(motion, seedcom, SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, width, height, length, MaintDict, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, ResUseDict, nr, u0, alpha, D)
else:
SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, MaintDict, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, ResUseDict = bide.immigration(motion, m, SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, width, height, length, MaintDict, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, ResUseDict, nr, u0, alpha, D)
if motion == 'fluid' or motion == 'conveyor': # a 'conveyor' belt action wherein y-coordinates never change occurs when there is 0 turbulence
# stream & collide
nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier, shift, sign = LBM.stream([nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier, shift, sign])
rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW = LBM.collide(viscosity, rho, ux, uy, n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, u0)
# dispersal
Lists = [SpeciesIDs, IndIDs, IndID, Qs, DispDict]
if len(SpeciesIDs) > 0: SpeciesIDs, IndXcoords, IndYcoords, IndExitAge, IndIDs, IndID, IndTimeIn, Qs = bide.fluid_movement('individual', Lists, IndTimeIn, IndExitAge, IndXcoords, IndYcoords, ux, uy, width, height, u0)
# resource flow
Lists = [ResTypes, ResIDs, ResID, ResVals]
if len(ResTypes) > 0: ResTypes, ResXcoords, ResYcoords, ResExitAge, ResIDs, ResID, ResTimeIn, ResVals = bide.fluid_movement('resource', Lists, ResTimeIn, ResExitAge, ResXcoords, ResYcoords, ux, uy, width, height, u0)
# moving tracer particles
if len(TracerIDs) > 0: TracerIDs, TracerXcoords, TracerYcoords, TracerExitAge, TracerTimeIn = bide.fluid_movement('tracer', TracerIDs, TracerTimeIn, TracerExitAge, TracerXcoords, TracerYcoords, ux, uy, width, height, u0)
elif motion == 'random_walk' or motion == 'unidirectional':
# Moving tracer particles
if len(TracerIDs) > 0: TracerIDs, TracerExitAge, TracerTimeIn, TracerXcoords, TracerYcoords, TracerZcoords = bide.nonfluid_movement('tracer', motion, TracerIDs, TracerExitAge, TracerTimeIn, TracerXcoords, TracerYcoords, TracerZcoords, width, height, length, u0, D)
# Moving resource particles
if len(ResTypes) > 0:
Lists = [ResTypes, ResIDs, ResVals]
Lists, ResExitAge, ResTimeIn, Xcoords, Ycoords, Zcoords = bide.nonfluid_movement('resource', motion, Lists, ResExitAge, ResTimeIn, ResXcoords, ResYcoords, ResZcoords, width, height, length, u0, D)
ResTypes, ResIDs, ResVals = Lists
# Moving individuals
if len(SpeciesIDs) > 0:
Lists = [SpeciesIDs, IndIDs, Qs, DispDict]
Lists, IndExitAge, IndTimeIn, Xcoords, Ycoords, Zcoords = bide.nonfluid_movement('individual', motion, Lists, IndExitAge, IndTimeIn, IndXcoords, IndYcoords, IndZcoords, width, height, length, u0, D)
SpeciesIDs, IndIDs, Qs = Lists
# consume & reproduce
p1, q1 = [len(IndIDs), sum(Qs)]
ResTypes, ResVals, ResIDs, ResID, ResTimeIn, ResExitAge, ResXcoords, ResYcoords, ResZcoords, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndXcoords, IndYcoords, IndZcoords = bide.consume(ResTypes, ResVals, ResIDs, ResID, ResXcoords, ResYcoords, ResZcoords, ResTimeIn, ResExitAge, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndXcoords, IndYcoords, IndZcoords, width, height, length, GrowthDict, ResUseDict, DispDict, D)
SpeciesIDs, Qs, IDs, ID, TimeIn, Xcoords, Ycoords, Zcoords, GrowthDict, DispDict = bide.reproduce(reproduction, speciation, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndXcoords, IndYcoords, IndZcoords, width, height, length, GrowthDict, DispDict, SpColorDict, ResUseDict, MaintDict, D, nr)
PRODI, PRODQ = [len(IndIDs) - p1, sum(Qs) - q1]
# maintenance
SpeciesIDs, Xcoords, Ycoords, Zcoords, IndExitAge, IndIDs, IndTimeIn, Qs = bide.maintenance(SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, IndExitAge, SpColorDict, MaintDict, IndIDs, IndTimeIn, Qs, D)
"""
# predation
p1, n1 = [len(PredIDs), len(IndIDs)]
PredIDs, PredID, PredTimeIn, PredXcoords, PredYcoords, PredZcoords, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndXcoords, IndYcoords, IndZcoords = bide.predation(predation(PredIDs, PredID, PredXcoords, PredYcoords, PredZcoords, PredTimeIn, IndExitAge, SpeciesIDs, Qs, IndIDs, IndID, IndTimeIn, IndXcoords, IndYcoords, IndZcoords, width, height, length, D)
pred_i, pred_n = [len(PredIDs) - p1, sum(IndIDs) - n1]
"""
########## PLOT THE SYSTEM #################################################
if D == 3: ax = fig.add_subplot(111, projection='3d')
else: ax = fig.add_subplot(111)
plt.tick_params(axis='both', which='both', bottom='off', top='off', left='off', right='off', labelbottom='off', labelleft='off')
if len(SpeciesIDs) >= 1: RAD, splist = bide.GetRAD(SpeciesIDs)
else: RAD, splist, N, S = [], [], 0, 0
N, S, tt, rr = sum(RAD), len(RAD), len(TracerIDs), len(ResIDs)
Title = ['Individuals consume resources, grow, reproduce, and die as they move through the environment.'
'\nAverage speed on the x-axis is '+str(u0)+' units per time step. '+str(len(TracerExitAge))+' tracers have passed through.',
'\nMotion is '+motion+'; N: '+str(N)+', S: '+str(S)+', tracers: '+str(tt)+', resources: '+str(rr)+', replicate: '+str(len(Ns))]
txt.set_text(' '.join(Title))
ax.set_ylim(0, height)
ax.set_xlim(0, width)
if D == 3: ax.set_zlim(0,length)
if plot_system == 'yes':
##### PLOTTING THE INDIVIDUALS ############################################
resource_scatImage.remove()
tracer_scatImage.remove()
Ind_scatImage.remove()
colorlist = []
sizelist = []
for i, val in enumerate(SpeciesIDs):
colorlist.append(SpColorDict[val])
sizelist.append(Qs[i] * 1000)
if D == 2: resource_scatImage = ax.scatter(ResXcoords, ResYcoords, s = ResVals, c = 'w', edgecolor = 'SpringGreen', lw = 0.6, alpha=0.7)
elif D == 3: resource_scatImage = ax.scatter(ResXcoords, ResYcoords, ResZcoords, s = ResVals, c = 'w', edgecolor = 'SpringGreen', lw = 0.6, alpha=0.2)
if D == 2: Ind_scatImage = ax.scatter(IndXcoords, IndYcoords, s = sizelist, c = colorlist, edgecolor = '0.2', lw = 0.2, alpha=0.9)
elif D == 3: Ind_scatImage = ax.scatter(IndXcoords, IndYcoords, IndZcoords, s = Qs, c = colorlist, edgecolor = '0.2', lw = 0.2, alpha=0.99)
if D == 2: tracer_scatImage = ax.scatter(TracerXcoords, TracerYcoords, s = 200, c = 'r', marker='*', lw=0.0, alpha=0.6)
elif D == 3: tracer_scatImage = ax.scatter(TracerXcoords, TracerYcoords, TracerZcoords, s = 200, c = 'r', marker='*', lw=0.0, alpha=0.8)
plt.draw()
if u0 == 1.0: LowerLimit = 50
elif u0 >= 0.5: LowerLimit = 40
elif u0 >= 0.1: LowerLimit = 20
elif u0 > 0.01: LowerLimit = 10
elif u0 == 0.01: LowerLimit = 5
# Record model values and reset, or not
if len(TracerExitAge) >= LowerLimit or N == 0:
PRODIs.append(PRODI)
PRODQs.append(PRODQ)
RESTAUs.append(np.mean(ResExitAge))
INDTAUs.append(np.mean(IndExitAge))
TRACERTAUs.append(np.mean(TracerExitAge))
# Examining the resource RAD
if len(ResTypes) > 0:
ResRAD, Rlist = bide.GetRAD(ResTypes)
ResDens = sum(ResTypes)/(height*width)
ResDiv = float(metrics.Shannons_H(ResRAD))
ResRich = len(Rlist)
RESDENs.append(ResDens)
RESDIVs.append(ResDiv)
RESRICHs.append(ResRich)
# Residence times for tracers and Inds
TracerTau, IndTau, ResTau = [np.mean(TracerExitAge), np.mean(IndExitAge), np.mean(ResExitAge)]
# Number of tracers, resource particles, and individuals
T, R, N = len(TracerIDs), len(ResIDs), len(SpeciesIDs)
if logdata == 'yes':
IndRTD = str(IndExitAge).strip('[]')
TracerRTD = str(TracerExitAge).strip('[]')
ResRTD = str(ResExitAge).strip('[]')
OUT4 = open(mydir + '/GitHub/hydrobide/results/simulated_data/IndRTD.csv','a')
OUT5 = open(mydir + '/GitHub/hydrobide/results/simulated_data/TracerRTD.csv','a')
OUT6 = open(mydir + '/GitHub/hydrobide/results/simulated_data/ResRTD.csv','a')
print>>OUT4, ct1,',', sim,',', IndRTD
print>>OUT5, ct1,',', sim,',', TracerRTD
print>>OUT6, ct1,',', sim,',', ResRTD
OUT4.close()
OUT5.close()
OUT6.close()
TracerExitAge, IndExitAge, ResExitAge= [],[],[]
Ts.append(T)
Rs.append(R)
if N == 0:
Ns.append(0)
Ss.append(0)
if N >= 1:
RAD, splist = bide.GetRAD(SpeciesIDs)
RAD, splist = zip(*sorted(zip(RAD, splist), reverse=True))
S = len(RAD)
Ss.append(S)
Ns.append(N)
# Specific Growth rate and Maintenance
mu, maint = [0.0, 0.0]
for i, sp in enumerate(splist):
mu += (RAD[i] * GrowthDict[sp])
maint += (RAD[i] * MaintDict[sp])
Mu, Maint = [mu/N, maint/N]
MUs.append(Mu)
MAINTs.append(Maint)
# Evenness, Dominance, and Rarity measures
Ev = metrics.e_var(RAD)
EVs.append(Ev)
ES = metrics.e_simpson(RAD)
ESs.append(ES)
Nm, BP = [max(RAD), Nm/N]
NMAXs.append(Nm)
BPs.append(BP)
SD = metrics.simpsons_dom(RAD)
SDs.append(SD)
sk = stats.skew(RAD)
SKs.append(sk)
process = psutil.Process(os.getpid())
mem = round(process.get_memory_info()[0] / float(2 ** 20), 1) # return the memory usage in MB
if len(Ns) >= 1 or N == 0:
ct = 0
T, R, PRODI, PRODQ, N, RESTAU, TRACERTAU, INDTAU, RESDENS, RESDIV, RESRICH, S, ES, EV, BP, SD, NMAX, SK, MU, MAINT = [np.mean(Ts), np.mean(Rs), np.mean(PRODIs), np.mean(PRODQs), np.mean(Ns), np.mean(RESTAUs), np.mean(TRACERTAUs), np.mean(INDTAUs), np.mean(RESDENs), np.mean(RESDIVs), np.mean(RESRICHs), np.mean(Ss), np.mean(ESs), np.mean(EVs), np.mean(BPs), np.mean(SDs), np.mean(NMAXs), np.mean(SKs), np.mean(MUs), np.mean(MAINTs)]
print ct, sim, ' N:', int(round(N)), 'S:', int(round(S)), ' pI:', int(prod_i), 'pQ:', int(prod_q), ': flow:', u0, ' MB:',int(round(mem))
if logdata == 'yes':
SString = str(splist).strip('()')
RADString = str(RAD).strip('()')
OUT1 = open(mydir + '/GitHub/hydrobide/results/simulated_data/SimData.csv','a')
OUT2 = open(mydir + '/GitHub/hydrobide/results/simulated_data/RADs.csv','a')
OUT3 = open(mydir + '/GitHub/hydrobide/results/simulated_data/Species.csv','a')
print>>OUT1, ct1,',', sim,',', motion,',', D,',', PRODI,',', PRODQ,',', r,',', nr,',', rmax,',', BarrierWidth,',', BarrierHeight,',', alpha,',', seedcom,',', LowerLimit,',', u0,',', width,',', height,',', viscosity,',', N,',', m,',',RESTAU,',',TRACERTAU,',', INDTAU,',', RESDENS,',', RESDIV,',', RESRICH,',', S,',', ES,',', EV,',', BP,',', SD,',', NMAX,',', SK,',', MU,',', MAINT,',',T,',',R
print>>OUT2, RADString
print>>OUT3, SString
OUT1.close()
OUT2.close()
OUT3.close()
ct1 += 1
if u0 == min(Rates):
SpColorDict, GrowthDict, MaintDict, ResUseDict, ResColorDict, DispDict = {}, {}, {}, {}, {}, {}
width, height, length, alpha, motion, D, reproduction, speciation, predators, parasites, env_gradient, seedcom, m, r, nr, rmax = get_rand_params()
sim += 1
alpha = np.random.uniform(0.9, 0.999)
print '\n'
Rates = np.roll(Rates, -1, axis=0)
u0 = Rates[0] # initial in-flow speed
Ts, Rs, PRODIs, PRODQs, Ns, RESTAUs, TRACERTAUs, INDTAUs, RESDENs, RESDIVs, RESRICHs, Ss, ESs, EVs, BPs, SDs, NMAXs, SKs, MUs, MAINTs = [], [],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]
TracerTau, IndTau, ResDens, ResDiv, ResRich, S, ES, Ev, BP, SD, Nm, sk, Mu, Maint = [0,0,0,0,0,0,0,0,0,0,0,0,0,0]
IndTimeIn, SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, IndIDs, Qs, IndExitAge = [],[],[],[],[],[],[],[]
TracerXcoords, TracerYcoords, TracerZcoords, TracerExitAge, TracerIDs, TracerTimeIn = [],[],[],[],[],[]
ResXcoords, ResYcoords, ResZcoords, ResIDs, ResTypes, ResExitAge, ResTimeIn, ResVals = [],[],[],[],[],[],[],[]
if motion == 'fluid' or motion == 'conveyor':
n0, nN, nS, nE, nW, nNE, nNW, nSE, nSW, barrier, rho, ux, uy, barrierN, barrierS, barrierE, barrierW, barrierNE, barrierNW, barrierSE, barrierSW, BarrierXcoords1, BarrierYcoords1, BarrierXcoords2, BarrierYcoords2 = LBM.SetLattice(u0, viscosity, width, height, left1, bottom1, left2, bottom2, BarrierWidth, BarrierHeight, BarrierXcoords1, BarrierYcoords1, BarrierXcoords2, BarrierYcoords2)
if seedcom > 0:
# inflow of resources
ResTypes, ResVals, ResXcoords, ResYcoords, ResZcoords, ResIDs, ResID, ResTimeIn = bide.ResIn(motion, ResTypes, ResVals, ResXcoords, ResYcoords, ResZcoords, ResID, ResIDs, ResTimeIn, r, rmax, nr, width, height, length, u0, D)
# immigration
SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, MaintDict, GrowthDict, DispDict, SpColorDict, IDs, ID, TimeIn, Qs, ResUseDict = bide.immigration(motion, m, SpeciesIDs, IndXcoords, IndYcoords, IndZcoords, width, height, length, MaintDict, GrowthDict, DispDict, SpColorDict, IndIDs, IndID, IndTimeIn, Qs, ResUseDict, nr, u0, alpha, D)
####################### REPLACE ENVIRONMENT ############################
if D == 3: ax = fig.add_subplot(111, projection='3d')
elif D == 2: ax = fig.add_subplot(111)
