cmap='hsv',
s=50,
linewidth=0)
plt.tight_layout()
plt.xlim(min(latlongs[:, 0]) - .0005, max(latlongs[:, 0]) + .0005)
plt.ylim(min(latlongs[:, 1]) - .0005, max(latlongs[:, 1]) + .0005)
plt.savefig(PATH + PLACE + "_MAP_" + str(CLST_METHOD) + "_" + namePad +
".png",
dpi=500)
plt.close()
###########################################################################
# Export distance matrix
###########################################################################
distPath = PATH + PLACE + "_DST_" + str(
CLST_METHOD) + "_" + namePad + ".csv"
distMat = monet.calculateDistanceMatrix(latlongs,
distFun=vn.vincenty) * 1000
# np.savetxt(distPath, distMat.astype(int), fmt='%i', delimiter=',')
# heat = sns.heatmap(distMat, annot=False)
# heat.get_figure().savefig(PATH + PLACE + "DIST.png", dpi=500)
###########################################################################
# Export migration matrix
###########################################################################
migrPath = PATH + PLACE + "_MIG_" + str(
CLST_METHOD) + "_" + namePad + ".csv"
zeroInflation = pow(lifeStayProb, adultMortality)
migrMat = monet.zeroInflatedExponentialMigrationKernel(
distMat, params=monet.AEDES_EXP_PARAMS, zeroInflation=zeroInflation)
monet.testMarkovMatrix(migrMat)
# np.savetxt(migrPath, migrMat, delimiter=',')
# heat = sns.heatmap(migrMat, annot=False)
# heat.get_figure().savefig(PATH + "MIGR.png", dpi=500)
def genSingle(n, zeroInflation, landscapeProb, mskMat):
(lo, hi, n) = (0, 1225, n)
# ############################################################################
# Mosquito biological behaviour
# ############################################################################
# mskMat: This matrix defines how probable is for a mosquito to
# move from one life stage to the next (and, as a consequence, from a site
# type to the next).
# ############################################################################
passMkvtest = aux.testMarkovMat(mskMat)
passMkvtest
# ############################################################################
# Landscape
# ############################################################################
# Creates a random landscape (x,y coordinates) and calculates the distances
# matrix.
# ############################################################################
#landscape = land.genUniformLandscape(lo, hi, n)
landscape = land.genLineLandscape(lo, hi, n)
distMat = monet.calculateDistanceMatrix(landscape)
# ############################################################################
# Migration
# ############################################################################
# Converts the distances matrix into a proper migration matrix by applying
# the kernel, and normalizing it.
# ############################################################################
migrMat = monet.zeroInflatedExponentialMigrationKernel(
distMat,
params=monet.AEDES_EXP_PARAMS,
zeroInflation=0.75
)
aux.testMarkovMat(migrMat)
# ############################################################################
# Point types
# ############################################################################
# Assigns classes types to the points in the landscape (this routine will
# fail if there's few points with respect to the dimension of the point
# types)
# ############################################################################
# pointClasses = bts.genURandLandscapeClasses(len(mskMat), n)
pointClasses = bts.genMRandLanscapeClasses(len(mskMat), n, landscapeProb)
# plot the assigned landscape
landscape_plot = sns.scatterplot(
[i[0] for i in landscape],
[i[1] for i in landscape],
hue=pointClasses, legend=False
)
clandMskMat = bts.calcClandMskMat(pointClasses, mskMat)
# print(clandMskMat)
# ############################################################################
# Full network
# ############################################################################
# Applies the point-types mask to the migration matrix, and normalizes it
# to take into account the movement due to life-stage, and distance.
# ############################################################################
network = mntw.normalizeMskMgrMat(migrMat, clandMskMat)
return (network, pointClasses, landscape_plot)
mskMat = [
[0.20, 0.80, 0.00],
[0.10, 0.75, 0.15],
[0.80, 0.00, 0.20]
]
passMkvtest = aux.testMarkovMat(mskMat)
# ############################################################################
# Landscape
# ############################################################################
# Creates a random landscape (x,y coordinates) and calculates the distances
# matrix.
# ############################################################################
# landscape = land.genURandLandscape(lo, hi, ptsNum)
landscape = land.genLineLandscape(lo, hi, ptsNum)
distMat = monet.calculateDistanceMatrix(landscape)
print(distMat)
sns.heatmap(distMat, annot=True)
# ############################################################################
# Migration
# ############################################################################
# Converts the distances matrix into a proper migration matrix by applying
# the kernel, and normalizing it.
# ############################################################################
migrMat = monet.zeroInflatedExponentialMigrationKernel(
distMat,
params=monet.AEDES_EXP_PARAMS,
zeroInflation=zeroInflation
)
aux.testMarkovMat(migrMat)
r = rand.uniform(radius[0], radius[1])
# calculating coordinates
x = r * math.cos(alpha) + center[0]
y = r * math.sin(alpha) + center[1]
coords.append([x, y])
else:
coords = list(zip(rand.uniform(*xRan, POINTS), rand.uniform(*yRan,
POINTS)))
# Point-types -----------------------------------------------------------------
pNum = len(list(coords))
pTypes = np.array(PTYPE_PROB).cumsum().searchsorted(np.random.sample(pNum))
sites = np.asarray(coords)
###############################################################################
# Generate matrices
###############################################################################
dist = monet.calculateDistanceMatrix(coords)
tau = monet.zeroInflatedExponentialMigrationKernel(dist,
aux.MKERN,
zeroInflation=0.75)
###############################################################################
# Generate masking matrix
###############################################################################
itr = list(range(len(coords)))
msk = np.zeros((pNum, pNum))
r = 0
for r in itr:
for c in itr:
msk[r, c] = PTS_TMAT[pTypes[r], pTypes[c]]
tauN = normalize(msk * tau, axis=1, norm='l1')
###############################################################################
# Check matrices
