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']
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) # Transition to or from dormancy elif xi == 7: IndDict, ResLists, ResDict, numDead = bide.transition(IndDict, SpDicts, ResLists, ResDict, ComplexityLevels, numDead)