def init_distance_matrix(self, profiles=["car"]):
"Create distance_matrix database table"
logger.info(f'Calculating distance matrix for {profiles}...')
# TO DO: update this so that's it's in the same structure as self.calculated_centroid.df, etc.
if not hasattr(self, 'centroid_df'):
self.centroid_df = gp.GeoDataFrame.from_postgis("SELECT * FROM demand;", self.db_conn.conn, geom_col = 'centroid')
if not hasattr(self, 'poi'):
self.poi = gp.GeoDataFrame.from_postgis("SELECT * FROM poi;", "retrieved POI", self.db_conn.conn, geom_col = 'point')
for profile in profiles:
# TO DO: this will need to change based on different profiles
try:
DM = DistanceMatrix(self.poi, self.centroid_df, self.config.ORS_client, self.config.iso_catchment_range,
self.config.iso_catchment_type, self.config.iso_profile, self.config.iso_sleep_time, self.config.dm_metric,
self.config.dm_unit, self.config.dm_sleep_time, self.config.ORS_timeout)
logger.info(f'Successfully calculated distance matrix for {profile}')
except Exception as e:
logger.error(f'Unsuccessfully calculated the distance matrix for {profile}: {e}')
sys.exit(1)
# TO DO: update query for different distance_matrix_* based on mode of transportation (will have to update config.json)
query_create = """
DROP TABLE IF EXISTS distance_matrix_%s;
CREATE TABLE distance_matrix_%s(
id serial PRIMARY KEY,
geouid int""" % (profile, profile)
# loop through all columns to build query statement to create the distance_matrix_* table
# TO DO: consider different data type?
DM.distance_matrix = DM.distance_matrix.where(pd.notnull(DM.distance_matrix), 'NULL')
columns = ['geouid']
for col in DM.distance_matrix.columns.values[1:]:
columns.append(col)
if col == DM.distance_matrix.columns.values[-1]:
query_create += ", " + col + " float)"
else:
query_create += ", " + col + " float"
self.execute_query(query_create, "created distance_matrix_" + profile)
columns = ", ".join(DM.distance_matrix.columns.values.tolist()) # list of columns as a string
rows = DM.distance_matrix.to_numpy().tolist() # list of rows
# for each row in distance matrix
for i in DM.distance_matrix.index:
rows[i] = [str(value) for value in rows[i]] # cast each row value as string
values = ", ".join(rows[i]) # store a row's values into a list as a string
# insert row into database table
query_insert = """ INSERT into distance_matrix_%s (%s) VALUES (%s);""" % (profile, columns, values)
self.execute_query(query_insert, "updated distance_matrix")
# print(query_insert)
# create index for distance_matrix table
self.execute_query("CREATE INDEX idx_distance_matrix_%s ON distance_matrix_%s (%s);" % (profile, profile, columns), "indexed distance_matrix_%s" % (profile))
def __init__(self, Time_Step, Mol_List, Box_Dim, Atom_List, N):
self.Time_Step = Time_Step
self.Mol_List = Mol_List
self.Box_Dim = Box_Dim
self.num_Mols = len(Mol_List)
self.Atom_List = Atom_List
self.DistanceMatrix = DistanceMatrix()
self.DistanceMatrix.setPeriodicBound(Box_Dim)
self.numCarbon = 5680.
boxx, boxy, boxz = Box_Dim
return
def load_blossum(blos):
"""
loads a BLOSUM matrix
:param str blos: Specifeis the BLOSUM matrix to lead
:return: dict(str, dict(str, float)) - A BLOSUM1 matrix
"""
try:
mod = __import__('DistanceMatrices', fromlist=[blos])
return DistanceMatrix(getattr(mod, blos))
except:
mod = __import__('DistanceMatrices', fromlist=["BLOSUM50_distances"])
return DistanceMatrix(getattr(mod, "BLOSUM50_distances"))
def topologyDistanceMatrix(self, metric='sd'):
"""Returns a DistanceMatrix object showing topology distances.
Uses the :meth:`Tree.Tree.topologyDistance` method to compare
trees. That method returns distances between pairs of trees,
and this method simply collates those distances into a
:class:`DistanceMatrix.DistanceMatrix` object, which is
returned.
See :meth:`Tree.Tree.topologyDistance` for an explanation of the
different metrics. The metrics are given in
``var.topologyDistanceMetrics``"""
from DistanceMatrix import DistanceMatrix
d = DistanceMatrix()
d.names = []
for t in self.trees:
d.names.append(t.name)
d.dim = len(d.names)
#print d.names
#sys.exit()
d.matrix = []
for i in range(d.dim):
d.matrix.append([0.0] * d.dim)
for i in range(d.dim):
t1 = self.trees[i]
for j in range(i + 1, d.dim):
t2 = self.trees[j]
theDist = t1.topologyDistance(t2, metric=metric)
d.matrix[i][j] = theDist
d.matrix[j][i] = theDist
return d
def topologyDistanceMatrix(self, metric='sd'):
"""Returns a DistanceMatrix object showing topology distances.
Uses the :meth:`Tree.Tree.topologyDistance` method to compare
trees. That method returns distances between pairs of trees,
and this method simply collates those distances into a
:class:`DistanceMatrix.DistanceMatrix` object, which is
returned.
See :meth:`Tree.Tree.topologyDistance` for an explanation of the
different metrics. The metrics are given in
``var.topologyDistanceMetrics``"""
from DistanceMatrix import DistanceMatrix
d = DistanceMatrix()
d.names = []
for t in self.trees:
d.names.append(t.name)
d.dim = len(d.names)
#print d.names
#sys.exit()
d.matrix = []
for i in range(d.dim):
d.matrix.append([0.0] * d.dim)
for i in range(d.dim):
t1 = self.trees[i]
for j in range(i + 1, d.dim):
t2 = self.trees[j]
theDist = t1.topologyDistance(t2, metric=metric)
d.matrix[i][j] = theDist
d.matrix[j][i] = theDist
return d
def patristicDistanceMatrix(self):
"""Matrix of distances along tree path.
This method sums the branch lengths between each pair of taxa, and
puts the result in a DistanceMatrix object, which is returned.
Self.taxNames is required.
"""
gm = ['Tree.patristicDistanceMatrix()']
if not self.taxNames:
gm.append("No taxNames.")
raise Glitch, gm
# The tree will be rearranged, so make a copy to play with, so
# self is undisturbed.
t = self.dupe()
d = DistanceMatrix()
d.names = self.taxNames
d.dim = len(d.names)
#print d.names
d.matrix = []
for i in range(d.dim):
d.matrix.append([0.0] * d.dim)
for i in range(d.dim):
n1 = t.node(d.names[i])
t.reRoot(n1, moveInternalName=False)
for j in range(i + 1, d.dim):
n2 = t.node(d.names[j])
# sum up distances between n1 and n2
sum = n2.br.len
n2 = n2.parent
while n2 != n1:
sum = sum + n2.br.len
n2 = n2.parent
#print "Dist from %s to %s is %f" % (d.names[i], d.names[j], sum)
d.matrix[i][j] = sum
d.matrix[j][i] = sum
return d
def patristicDistanceMatrix(self):
"""Matrix of distances along tree path.
This method sums the branch lengths between each pair of taxa, and
puts the result in a DistanceMatrix object, which is returned.
Self.taxNames is required.
"""
gm = ["Tree.patristicDistanceMatrix()"]
if not self.taxNames:
gm.append("No taxNames.")
raise Glitch, gm
# The tree will be rearranged, so make a copy to play with, so
# self is undisturbed.
t = self.dupe()
d = DistanceMatrix()
d.names = self.taxNames
d.dim = len(d.names)
# print d.names
d.matrix = []
for i in range(d.dim):
d.matrix.append([0.0] * d.dim)
for i in range(d.dim):
n1 = t.node(d.names[i])
t.reRoot(n1, moveInternalName=False)
for j in range(i + 1, d.dim):
n2 = t.node(d.names[j])
# sum up distances between n1 and n2
sum = n2.br.len
n2 = n2.parent
while n2 != n1:
sum = sum + n2.br.len
n2 = n2.parent
# print "Dist from %s to %s is %f" % (d.names[i], d.names[j], sum)
d.matrix[i][j] = sum
d.matrix[j][i] = sum
return d
class Snap_Shot(object):
"""
Class defining a snap shot of the trajectory
instance variables: Time_step, Mol_List, Box_Dim, Rg_Dist, E2E_Dist, RDF_Dist
"""
def __init__(self, Time_Step, Mol_List, Box_Dim, Atom_List, N):
self.Time_Step = Time_Step
self.Mol_List = Mol_List
self.Box_Dim = Box_Dim
self.num_Mols = len(Mol_List)
self.Atom_List = Atom_List
self.DistanceMatrix = DistanceMatrix()
self.DistanceMatrix.setPeriodicBound(Box_Dim)
self.numCarbon = 5680.
boxx, boxy, boxz = Box_Dim
return
def showDistanceDistribution(self):
self.DistanceMatrix.showDistanceDistribution()
def pairCorrelation_Hist(self, numbins=200):
# print "Calculating Snapshot Distance Matrix"
for Mol in self.Mol_List:
self.DistanceMatrix.addPoint(Mol.COM())
# print "Finished placing atoms...Calculating Distance Distribution"
self.DistanceMatrix.calculateDistanceDistribution()
# print "returning pyplot"
n, bins = self.DistanceMatrix.pyplotDistanceDistribution(numbins = 200)
print "n is: "
print n
print bins
return n, bins
def Compute_COM(self):
"""
Compute the centers of mass of all the polymer chains
"""
for Mol in self.Mol_List:
Mass_Weighted_Sum = np.zeros(3,dtype=float)
for Atom in Mol.Atom_List:
Atom.unwrapped_position = Atom.position + np.multiply(self.Box_Dim, Atom.image_flags)
Mass_Weighted_Sum += Polymer.Mass[Atom.Type]*Atom.unwrapped_position
Mol.COM = Mass_Weighted_Sum/Mol.MW
return
def Compute_Tangent_Correlation(self):
TangentCorrelation = []
for Mol in self.Mol_List:
MolTangentCorrelation = []
RelevantAtoms = [Atom for Atom in Mol.Atom_List.tolist() if ((Atom.Mass > 2.) and (Atom.Mass < 196))]
# print "mass of second atom is: " + str(Mol.Atom_List[1].Mass)
initialvector = RelevantAtoms[1].position-RelevantAtoms[0].position
initialvector /= np.linalg.norm(initialvector)
lastpos = RelevantAtoms[0].position
for Atom in RelevantAtoms[1:]:
# print "adding new pos: " + str(Atom.position)
newpos = Atom.position
newvector = newpos-lastpos
newvector /= np.linalg.norm(newvector)
# print "tangent correlation is: " + str(self.Tangent_Correlation(latestpos[0],latestpos[1],newpos))
MolTangentCorrelation.append(np.dot(initialvector,newvector))
lastpos =newpos
# print "Mol Tangent Correlation: " + str(np.asarray(MolTangentCorrelation)) + " with mass"
TangentCorrelation.append(np.asarray(MolTangentCorrelation))
TangentCorrelation = np.asarray(TangentCorrelation)
# print "TangentCorrelation is: " + str(TangentCorrelation)
TangentCorrelation = np.mean(TangentCorrelation, axis = 0)
# print "TangentCorrelation is: " + str(TangentCorrelation)
return TangentCorrelation
def carbonDensity_Hist(self, numbins = 200):
Z_pos = []
Z_max = []
theta = []
N = 0
for Mol in self.Mol_List:
mol_z = []
for Atom in Mol.Atom_List:
if Atom.Mass == 12.011:
# print "found Carbon"
N += 1
Z_pos.append(Atom.position[2])
mol_z.append(Atom.position[2])
try:
Z_max.append(np.asarray(mol_z).max())
except:
continue
# Z_max_av = np.asarray(Z_max).mean()
# Z_max_std = np.asarray(Z_max).std()
n, bins = np.histogram(Z_pos, bins= numbins, range=(0.07,0.3))
return n/self.numCarbon, bins*100-7.6
# return Zn, Zbins, Z_max_av, Z_max_std
def get_net_dipole(self, molclass, molName):
# partial_charges = OPLS.get_partial_charges(molclass, molName)
partial_charges = [(0,.32), (0,-.64)]
print partial_charges
net_dipole = np.zeros(3)
# print pc
# splicing out gold surface
for mol in self.Mol_List:
for atom in mol.Atom_List:
if atom.Element == "Au":
continue
else:
partial_charge = partial_charges[atom.Type-1][1]
# print atom.position
# print partial_charge
dipole_moment = partial_charge*atom.position
# print dipole_moment
net_dipole = net_dipole+dipole_moment
mol.dipoleMoment = mol.dipoleMoment+dipole_moment
print "Net dipole is: ..." + str(net_dipole)
# return net_dipole
# for mol in self.Mol_List[:-1]:
# if (np.dot(mol.dipoleMoment,net_dipole)/(np.linalg.norm(mol.dipoleMoment)*np.linalg.norm(net_dipole)) < -.9):
# print "alert!"
# print mol.dipoleMoment
# for atom in mol.Atom_List:
# print atom.Element, str(atom.position)
# # print net_dipole
# break
plt.hist([np.dot(mol.dipoleMoment,net_dipole)/(np.linalg.norm(mol.dipoleMoment)*np.linalg.norm(net_dipole)) for mol in self.Mol_List[:-1]], bins=100)
print os.getcwd()
plt.savefig(molclass+"_"+molName+"_dipoleDistribution.png")
print "saved!"
plt.clf()
return net_dipole