def argsort_nearest(self, target_position, target_site_family=None):
"""Return an ndarray of site indices, sorted by distance from the target
Parameters
----------
target_position : array_like
target_site_family : int
Look for a specific sublattice site. By default any will do.
Returns
-------
np.ndarray
Examples
--------
>>> sites = Sites(([0, 1, 1.1], [0, 0, 0], [0, 0, 0]), [0, 1, 0])
>>> np.all(sites.argsort_nearest([1, 0, 0]) == [1, 2, 0])
True
>>> np.all(sites.argsort_nearest([1, 0, 0], target_site_family=0) == [2, 0, 1])
True
"""
distances = self.distances(target_position)
if target_site_family is None:
return np.argsort(distances)
else:
return ma.argsort(
ma.array(distances, mask=(self.ids != target_site_family)))
def predict(self, mu, sigma, Ys, model=None):
#calculating var
s = sigma + self.sigma
alpha = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8000, 0.9000])
q = np.outer(np.sqrt(2 * s), erfinv(2 * alpha - 1)) + mu
z = self.warp(model.Y)[0]
I = argsort(z, axis=0)
sortz = sort(z, axis=0)
sortt = model.Y[I]
quant = self.warpinv(q, self._get_initial_points(q, sortz, sortt), 100)
var = np.square((quant[:, 8] - (quant[:, 0])) / 4)
#calculating mu
H = np.array([7.6e-07, 0.0013436, 0.0338744, 0.2401386, 0.6108626, 0.6108626, 0.2401386, 0.0338744, 0.0013436, 7.6e-07])
quard = np.array([-3.4361591, -2.5327317, -1.7566836, -1.0366108, -0.3429013, 0.3429013, 1.0366108, 1.7566836, 2.5327317, 3.4361591])
mu_quad = np.outer(np.sqrt(2 * s), quard) + mu
mean = self.warpinv(mu_quad, self._get_initial_points(mu_quad, sortz, sortt), 100)
mean = mdot(mean, H[:, np.newaxis]) / np.sqrt(math.pi)
lpd = None
if not (Ys is None):
ts, w = self.warp(Ys)
lpd = -0.5*np.log(2*math.pi*s) - 0.5 * np.square(ts-mu)/s + np.log(w)
return mean, var[:, np.newaxis], lpd[:, 0][:, np.newaxis]
def argsort_nearest(self, target_position, target_sublattice=None):
"""Return an ndarray of site indices, sorted by distance from the target
Parameters
----------
target_position : array_like
target_sublattice : int
Look for a specific sublattice site. By default any will do.
Returns
-------
np.ndarray
Examples
--------
>>> sites = Sites(([0, 1, 1.1], [0, 0, 0], [0, 0, 0]), [0, 1, 0])
>>> np.all(sites.argsort_nearest([1, 0, 0]) == [1, 2, 0])
True
>>> np.all(sites.argsort_nearest([1, 0, 0], target_sublattice=0) == [2, 0, 1])
True
"""
distances = self.distances(target_position)
if target_sublattice is None:
return np.argsort(distances)
else:
target_sublattice = self._translate_sublattice(target_sublattice)
return ma.argsort(ma.array(distances, mask=(self.sublattices != target_sublattice)))
def aggrade_front(self, grid, tstep, source_cells_Qs, elev, SL): #ensure Qs and tstep units match!
self.total_sed_supplied_in_tstep = source_cells_Qs*tstep
self.Qs_sort_order = np.argsort(source_cells_Qs)[::-1] #descending order
self.Qs_sort_order = self.Qs_sort_order[:np.count_nonzero(self.Qs_sort_order>0)]
for i in self.Qs_sort_order:
subaerial_nodes = elev>=SL
subsurface_elev_array = ma.array(elev, subaerial_nodes)
xy_tuple = (grid.node_x[i], grid.node_y[i])
distance_map = grid.get_distances_of_nodes_to_point(xy_tuple)
loop_number = 0
closest_node_list = ma.argsort(ma.masked_array(distance_map, mask=subsurface_elev_array.mask))
smooth_cone_elev_from_apex = subsurface_elev_array[i]-distance_map*self.tan_repose_angle
while 1:
filled_all_cells_flag = 0
accom_space_at_controlling_node = SL - subsurface_elev_array[closest_node_list[loop_number]]
new_max_cone_surface_elev = smooth_cone_elev_from_apex + accom_space_at_controlling_node
subsurface_elev_array.mask = (elev>=SL or new_max_cone_surface_elev<elev)
depth_of_accom_space = new_max_cone_surface_elev - subsurface_elev_array
accom_depth_order = ma.argsort(depth_of_accom_space)[::-1]
#Vectorised method to calc fill volumes:
area_to_fill = ma.cumsum(grid.cellarea[accom_depth_order])
differential_depths = ma.empty_like(depth_of_accom_space)
differential_depths[:-1] = depth_of_accom_space[accom_depth_order[:-1]] - depth_of_accom_space[accom_depth_order[1:]]
differential_depths[-1] = depth_of_accom_space[accom_depth_order[-1]]
incremental_volumes = ma.cumsum(differential_depths*area_to_fill)
match_position_of_Qs_in = ma.searchsorted(incremental_volumes, self.total_sed_supplied_in_tstep[i])
try:
depths_to_add = depth_of_accom_space-depth_of_accom_space[match_position_of_Qs_in]
except:
depths_to_add = depth_of_accom_space-depth_of_accom_space[match_position_of_Qs_in-1]
filled_all_cells_flag = 1
depths_to_add = depths_to_add[ma.where(depths_to_add>=0)]
if not filled_all_cells_flag:
depths_to_add += (self.total_sed_supplied_in_tstep[i] - incremental_volumes[match_position_of_Qs_in-1])/area_to_fill[match_position_of_Qs_in-1]
subsurface_elev_array[accom_depth_order[len(depths_to_add)]] = depths_to_add
self.total_sed_supplied_in_tstep[i] = 0
break
else:
subsurface_elev_array[accom_depth_order] = depths_to_add
self.total_sed_supplied_in_tstep[i] -= incremental_volumes[-1]
loop_number += 1
return elev
def top_words_in_doc(doc_term_frequency: ndarray,
features: list,
row_id: int,
top_n: int = 20) -> List[Tuple[str, str]]:
"""
Top TF IDF features in specific document (matrix row).
:param doc_term_frequency: Document-term frequency matrix.
:param features: Feature names for the document term matrix.
:param row_id: Row index of the document.
:param top_n: Top number of words to display on wordcloud.
:return: List[(word, tf_idf)]
"""
row = squeeze(doc_term_frequency[row_id].toarray())
top_n_ids = argsort(row)[::-1][:top_n]
return [(features[i], row[i]) for i in top_n_ids]
def predict(self, mu, sigma, Ys, model=None):
# calculating var
s = sigma + self.sigma
alpha = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8000, 0.9000])
q = np.outer(np.sqrt(2 * s), erfinv(2 * alpha - 1)) + mu
z = self.warp(model.Y)[0]
I = argsort(z, axis=0)
sortz = sort(z, axis=0)
sortt = model.Y[I]
quant = self.warpinv(q, self._get_initial_points(q, sortz, sortt), 100)
var = np.square((quant[:, 8] - (quant[:, 0])) / 4)
# calculating mu
H = np.array(
[7.6e-07, 0.0013436, 0.0338744, 0.2401386, 0.6108626, 0.6108626, 0.2401386, 0.0338744, 0.0013436, 7.6e-07]
)
quard = np.array(
[
-3.4361591,
-2.5327317,
-1.7566836,
-1.0366108,
-0.3429013,
0.3429013,
1.0366108,
1.7566836,
2.5327317,
3.4361591,
]
)
mu_quad = np.outer(np.sqrt(2 * s), quard) + mu
mean = self.warpinv(mu_quad, self._get_initial_points(mu_quad, sortz, sortt), 100)
mean = mdot(mean, H[:, np.newaxis]) / np.sqrt(math.pi)
lpd = None
if not (Ys is None):
ts, w = self.warp(Ys)
lpd = -0.5 * np.log(2 * math.pi * s) - 0.5 * np.square(ts - mu) / s + np.log(w)
return mean, var[:, np.newaxis], lpd[:, 0][:, np.newaxis]
def probAdjustEquil(binProb,rates,uncert,threshold=0.0,fullCalcClust=False,fullCalcBins=False):
"""This function adjusts bin pops in binProb using rates and uncert matrices
fullCalcBins --> True for weighted avg, False for simple calc
fullCalcClust --> True for weighted avg, False for simple calc
threshold --> minimum weight (relative to max) for another value to be averaged
only matters if fullCalcBins == True (or later perhaps if fullCalcClust == True)
"""
# Check that rate matrix is square
Ni,Nj = rates.shape
if Ni != Nj:
print('\nWARNING: Not a square matrix!\n')
zi = np.where(binProb == 0.0)[0] # indices of bins with zero probability
rates_uncert = UncertMath.UncertContainer(rates,rates - uncert,rates + uncert)
# STEP 1a: Create matrix of ratios of probabilities based on DIRECT estimates
# that is, ij element is p_i / p_j = k_ji / k_ij
ratios_direct = rates_uncert.transpose() / rates_uncert
# STEP 1b: Create averaged matrix of ratios of probabilities based on both direct and indirect estimates
# Indirect means '3rd bin' estimates: p_i / p_j = ( k_ki / k_ik ) ( k_jk / k_kj )
# Turns out this is not helpful, so generally set fullCalcBins = 0
if fullCalcBins:
# Calculate indirect ratios using Einstein Summation convention where
# ratios_indirect_kij = ( k_ki / k_ik ) ( k_jk / k_kj ) = ratios_direct_ik * ratios_direct_kj
ri_vals = np.einsum('ik,kj->kij',ratios_direct.vals,ratios_direct.vals)
ri_min = np.einsum('ik,kj->kij',ratios_direct.dmin,ratios_direct.dmin)
ri_max = np.einsum('ik,kj->kij',ratios_direct.dmax,ratios_direct.dmax)
ratios_indirect = UncertMath.UncertContainer(ri_vals,ri_min,ri_max,mask=ratios_direct.vals.mask)
# Threshold indirect ratios
ti = ratios_indirect.wt < ratios_direct * threshold
ratios_indirect.mask = ti
ratios_indirect.update_mask()
ratios_indirect.concatenate(ratios_direct,axis=0)
ratios_average = ratios_indirect.weighted_average(axis=0)
else:
ratios_average = ratios_direct.weighted_average(axis=0,expaxis=0)
# STEP 2: Form clusters
# STEP 2a: Sort probability ratios based on uncertainty
# Sort uncertainties of ratios_average subject to the convention that p_i < p_j
i,j = np.triu_indices(Ni,1) # indices of ij pairs where i != j
# Remove pairs that include a bin that has zero probability
nzi = (binProb[i] != 0.0) & (binProb[j] != 0.0)
i = i[nzi]
j = j[nzi]
vals = ma.vstack((ratios_average.vals[i,j],ratios_average.vals[j,i]))
ias = ma.argsort(vals,axis=0,fill_value=np.inf)
ordered_ind = np.vstack((i,j))
flip_ind = np.nonzero(ias[0,:]) # Find pairs in which to select ji rather than ij
ordered_ind[:,flip_ind[0]] = ordered_ind[:,flip_ind[0]][::-1]
iind = ordered_ind[0,:]
jind = ordered_ind[1,:]
uncertij = ratios_average.uncert[iind,jind] # Get the uncert for ij pairs
count = uncertij.count() # Count of the unmasked uncertainties
ias = ma.argsort(uncertij,fill_value=np.inf) # Get the indices that would sort uncertij
iind = iind[ias[:count]] # Sort the indices excluding masked/undefined values
jind = jind[ias[:count]]
# STEP 2b: Create ClusterList object and cluster bins
clusters = BinCluster.ClusterList(ratios_average,Ni)
if fullCalcClust:
clusters.join((iind,jind))
else:
clusters.join_simple((iind,jind))
total_prob = 0.0 # total probability in all clusters
for cid in clusters.cluster_contents:
binlist = list(clusters.cluster_contents[cid])
if len(binlist):
prob_cluster = binProb[binlist].sum()
total_prob += prob_cluster
binProb[binlist] = prob_cluster * clusters.bin_data[binlist].vals
binProb[zi] = 0.0 # re-zero bins that previously had zero prob
#for bi,p in enumerate(binProb):
# print('bin: {} -- {}'.format(bi,p))
print('.........Total Probability: {}'.format(binProb.sum()))
def closest_neighbours(self, n=3):
"""For each boid get a list of indices of nearest neighbours that fall inside a visibility range"""
for x in self.rel_dist:
idx, = ma.where(x < self.max_vis)
yield idx[ma.argsort(x[idx])][:n]
def probAdjustEquil(binProb,rates,uncert,threshold=0.0,fullCalcClust=False,fullCalcBins=False):
"""This function adjusts bin pops in binProb using rates and uncert matrices
fullCalcBins --> True for weighted avg, False for simple calc
fullCalcClust --> True for weighted avg, False for simple calc
threshold --> minimum weight (relative to max) for another value to be averaged
only matters if fullCalcBins == True (or later perhaps if fullCalcClust == True)
"""
# Check that rate matrix is square
Ni,Nj = rates.shape
if Ni != Nj:
print('\nWARNING: Not a square matrix!\n')
zi = np.where(binProb == 0.0)[0] # indices of bins with zero probability
rates_uncert = UncertMath.UncertContainer(rates,rates - uncert,rates + uncert)
# STEP 1a: Create matrix of ratios of probabilities based on DIRECT estimates
# that is, ij element is p_i / p_j = k_ji / k_ij
ratios_direct = rates_uncert.transpose() / rates_uncert
# STEP 1b: Create averaged matrix of ratios of probabilities based on both direct and indirect estimates
# Indirect means '3rd bin' estimates: p_i / p_j = ( k_ki / k_ik ) ( k_jk / k_kj )
# Turns out this is not helpful, so generally set fullCalcBins = 0
if fullCalcBins:
# Calculate indirect ratios using Einstein Summation convention where
# ratios_indirect_kij = ( k_ki / k_ik ) ( k_jk / k_kj ) = ratios_direct_ik * ratios_direct_kj
ri_vals = np.einsum('ik,kj->kij',ratios_direct.vals,ratios_direct.vals)
ri_min = np.einsum('ik,kj->kij',ratios_direct.dmin,ratios_direct.dmin)
ri_max = np.einsum('ik,kj->kij',ratios_direct.dmax,ratios_direct.dmax)
ratios_indirect = UncertMath.UncertContainer(ri_vals,ri_min,ri_max,mask=ratios_direct.vals.mask)
# Threshold indirect ratios
ti = ratios_indirect.wt < ratios_direct * threshold
ratios_indirect.mask = ti
ratios_indirect.update_mask()
ratios_indirect.concatenate(ratios_direct,axis=0)
ratios_average = ratios_indirect.weighted_average(axis=0)
else:
ratios_average = ratios_direct.weighted_average(axis=0,expaxis=0)
# STEP 2: Form clusters
# STEP 2a: Sort probability ratios based on uncertainty
# Sort uncertainties of ratios_average subject to the convention that p_i < p_j
i,j = np.triu_indices(Ni,1) # indices of ij pairs where i != j
# Remove pairs that include a bin that has zero probability
nzi = (binProb[i] != 0.0) & (binProb[j] != 0.0)
i = i[nzi]
j = j[nzi]
vals = ma.vstack((ratios_average.vals[i,j],ratios_average.vals[j,i]))
ias = ma.argsort(vals,axis=0,fill_value=np.inf)
ordered_ind = np.vstack((i,j))
flip_ind = np.nonzero(ias[0,:]) # Find pairs in which to select ji rather than ij
ordered_ind[:,flip_ind[0]] = ordered_ind[:,flip_ind[0]][::-1]
iind = ordered_ind[0,:]
jind = ordered_ind[1,:]
uncertij = ratios_average.uncert[iind,jind] # Get the uncert for ij pairs
count = uncertij.count() # Count of the unmasked uncertainties
ias = ma.argsort(uncertij,fill_value=np.inf) # Get the indices that would sort uncertij
iind = iind[ias[:count]] # Sort the indices excluding masked/undefined values
jind = jind[ias[:count]]
# STEP 2b: Create ClusterList object and cluster bins
clusters = BinCluster.ClusterList(ratios_average,Ni)
if fullCalcClust:
clusters.join((iind,jind))
else:
clusters.join_simple((iind,jind))
total_prob = 0.0 # total probability in all clusters
for cid in clusters.cluster_contents:
binlist = list(clusters.cluster_contents[cid])
if len(binlist):
prob_cluster = binProb[binlist].sum()
total_prob += prob_cluster
binProb[binlist] = prob_cluster * clusters.bin_data[binlist].vals
binProb[zi] = 0.0 # re-zero bins that previously had zero prob
#for bi,p in enumerate(binProb):
# print('bin: {} -- {}'.format(bi,p))
print('.........Total Probability: {}'.format(binProb.sum()))
