def SumTest():
fa1 = [4.3, 9.1, 5]
fa2 = [7.4, 8.9, 9, 1.2]
fa1 = basetypes.Sum(fa1, fa2)
for f in range(len(fa1)):
print(str(fa1[f]))
print('')
tf = basetypes.Sum(fa2)
print(str(tf))
print('')
ia = [4, 9, 5]
f = basetypes.Sum(ia)
print(str(f))
print('')
ca = []
c = basetypes.TCoord(3, 7, 4)
ca.append(c)
c = basetypes.TCoord(5, 1, 6)
ca.append(c)
c = basetypes.TCoord(2, 2, 1)
ca.append(c)
c = basetypes.Sum(ca)
print(str(c[0]) + ' ' + str(c[1]) + ' ' + str(c[2]))
def Rotate(v1, v2):
if isinstance(v1, basetypes.TCoord):
if isinstance(v2, TRotMatrix):
# First function
# Return TCoord
return basetypes.TCoord(v2[0, 0] * v1[0] + v2[0, 1] * v1[1] + v2[0, 2] * v1[2],
v2[1, 0] * v1[0] + v2[1, 1] * v1[1] + v2[1, 2] * v1[2],
v2[2, 0] * v1[0] + v2[2, 1] * v1[1] + v2[2, 2] * v1[2])
else:
# Third function
conjugate = Conjugated(v2)
tmp = Quaternion(0, v1[0], v1[1], v1[2])
tmp = Multiply(v2, tmp)
tmp = Multiply(tmp, conjugate)
# Return TCoord
return basetypes.TCoord(tmp[1], tmp[2], tmp[3])
else:
Result = []
if isinstance(v2, TRotMatrix):
# Second function
for f in range(len(v1)):
Result.append(Rotate(v1[f], v2))
else:
# Fourth function
conjugate = Conjugated(v2)
for f in range(len(v1)):
tmp = Quaternion(0, v1[f][0], v1[f][1], v1[f][2])
tmp = Multiply(v2, tmp)
tmp = Multiply(tmp, conjugate)
Result.append(basetypes.TCoord(tmp[1], tmp[2], tmp[3]))
# Return TCoords
return Result
def MultiplyTest():
c = basetypes.TCoord(0, 1, 2)
c = geomutils.Multiply(c, 2)
print(str(c[0]) + ' ' + str(c[1]) + ' ' + str(c[2]))
print('')
fa = [3.0, 6.0, 4.0]
fa = geomutils.Multiply(fa, 2)
for f in range(len(fa)):
print(str(fa[f]))
print('')
ca = []
c = basetypes.TCoord(3, 8, 1)
ca.append(c)
c = basetypes.TCoord(6, 4, 6)
ca.append(c)
c = basetypes.TCoord(0, 2, 5)
ca.append(c)
ca = geomutils.Multiply(ca, 2)
for f in range(len(ca)):
print(str(ca[f][0]) + ' ' + str(ca[f][1]) + ' ' + str(ca[f][2]))
print('')
q1 = geomutils.TQuaternion(2, 4, 3, 5)
q2 = geomutils.TQuaternion(1, 3, 5, 2)
q1 = geomutils.Multiply(q1, q2)
print(str(q1[0]) + ' ' + str(q1[1]) + ' ' + str(q1[2]) + ' ' + str(q1[3]))
print('')
r1 = geomutils.TRotMatrix(2, 4, 5, 3, 1, 1, 3, 2, 2)
r2 = geomutils.TRotMatrix(3, 1, 1, 2, 5, 5, 4, 2, 3)
r1 = geomutils.Multiply(r1, r2)
print(str(r1[0, 0]) + ' ' + str(r1[0, 1]) + ' ' + str(r1[0, 2]) + '\n' + str(r1[1, 0]) + ' ' + str(r1[1, 1]) + ' '
+ str(r1[1, 2]) + '\n' + str(r1[2, 0]) + ' ' + str(r1[2, 1]) + ' ' + str(r1[2, 2]))
def Add(v1, v2):
if isinstance(v1, basetypes.TCoord):
if isinstance(v2, basetypes.TCoord):
# Second function
# Return TCoord
return basetypes.TCoord(v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2])
elif isinstance(v2, list):
# Third function
Result = []
for f in range(len(v2)):
Result.append(Add(v1, v2[f]))
# Return TCoords
return Result
else:
# First function
return basetypes.TCoord(v1[0] + v2, v1[1] + v2, v1[2] + v2)
else:
if isinstance(v2, list):
# Fifth function
Result = []
for f in range(len(v2)):
Result.append(Add(v1[f], v2[f]))
# Return TCoords
return Result
else:
# Fourth function
Result = []
for f in range(len(v1)):
Result.append(v1[f] + v2)
# Return TFloats
return Result
def InContactTest():
c1 = basetypes.TCuboid(basetypes.TCoord(3, 6, 9), basetypes.TCoord(1, 5, 7))
c2 = basetypes.TCuboid(basetypes.TCoord(6, 7, 3), basetypes.TCoord(7, 3, 2))
print(basetypes.InContact(c1, c2))
c2[1][0] = 9
c2[1][1] = 9
c2[1][2] = 9
c1[1][0] = 9
c1[1][1] = 9
c1[1][2] = 9
print(basetypes.InContact(c1, c2))
def RotAndPlaceTest():
m = geomutils.TRotMatrix(5.6, 4.0, 8.2, 5.8, 3.3, 6.2, 7.4, 9.1, 1.3)
p = basetypes.TCoord(3.6, 6.4, 2.5)
v = basetypes.TCoord(4.7, 2.2, 0.4)
v = geomutils.RotAndPlace(m, p, v)
print(str(v[0]) + ' ' + str(v[1]) + ' ' + str(v[2]))
print('')
va = [basetypes.TCoord(4.8, 4.1, 6.0), basetypes.TCoord(0.6, 3.8, 7.2), basetypes.TCoord(4.1, 6.6, 8.0)]
geomutils.RotAndPlace(m, p, va)
for f in range(len(va)):
print(str(va[f][0]) + ' ' + str(va[f][1]) + ' ' + str(va[f][2]))
def ConcatenateTest():
a1 = []
a2 = []
for x in range(5):
c = basetypes.TCoord(x, x, x)
a1.append(c)
for x in range(8, 11):
c = basetypes.TCoord(x, x, x)
a2.append(c)
a1 = basetypes.Concatenate(a1, a2)
for x in range(len(a1)):
print(str(a1[x][0]) + ' ' + str(a1[x][1]) + ' ' + str(a1[x][2]))
def RotateTest():
c = basetypes.TCoord(1, 2, 3)
r = geomutils.TRotMatrix(4, 3, 1, 5, 2, 3, 5, 3, 1)
c = geomutils.Rotate(c, r)
print(str(c[0]) + ' ' + str(c[1]) + ' ' + str(c[2]))
print('')
ca = []
c = basetypes.TCoord(3, 8, 1)
ca.append(c)
c = basetypes.TCoord(6, 4, 6)
ca.append(c)
c = basetypes.TCoord(0, 2, 5)
ca.append(c)
ca = geomutils.Rotate(ca, r)
for f in range(len(ca)):
print(str(ca[f][0]) + ' ' + str(ca[f][1]) + ' ' + str(ca[f][2]))
print('')
q = geomutils.TQuaternion(2, 3, 1, 4)
c = basetypes.TCoord(1, 2, 3)
c = geomutils.Rotate(c, q)
print(str(c[0]) + ' ' + str(c[1]) + ' ' + str(c[2]))
print('')
ca = []
c = basetypes.TCoord(3, 8, 1)
ca.append(c)
c = basetypes.TCoord(6, 4, 6)
ca.append(c)
c = basetypes.TCoord(0, 2, 5)
ca.append(c)
ca = geomutils.Rotate(ca, q)
for f in range(len(ca)):
print(str(ca[f][0]) + ' ' + str(ca[f][1]) + ' ' + str(ca[f][2]))
def DistanceTest():
c = basetypes.TCoord(3, 8, 1)
c1 = basetypes.TCoord(4, 5, 2)
d = geomutils.Distance(c, c1)
print(d)
print('')
ca = []
ca1 = []
c = basetypes.TCoord(5, 1, 1)
ca.append(c)
c = basetypes.TCoord(4, 6, 8)
ca.append(c)
c = basetypes.TCoord(1, 2, 1)
ca.append(c)
c = basetypes.TCoord(4, 3, 5)
ca1.append(c)
c = basetypes.TCoord(2, 0, 6)
ca1.append(c)
c = basetypes.TCoord(7, 3, 6)
ca1.append(c)
da = geomutils.Distance(ca, ca1)
for f in range(len(da)):
print(da[f])
print('')
q1 = geomutils.TQuaternion(4, 2, 1, 3)
q2 = geomutils.TQuaternion(2, 2, 3, 1)
d = geomutils.Distance(q1, q2)
print(d)
def __init__(self):
self.FBaseRotation = geomutils.BuildRotation(basetypes.TCoord(0, 0, 0),
geomutils.MCXYZRotation)
self.FCGMinimizer = cgradient.TCGMinimiser()
self.FCGMinimizer.FGetValue = self.Evaluate
self.FCGMinimizer.FGetValueAndDerivative = self.EvaluateAndDerive
self.FFixed = []
self.FMobile = []
self.FPositions = []
self.FDerivs = []
self.FRotation = basetypes.TCoord()
self.FTranslation = basetypes.TCoord()
self.FCenterVec = basetypes.TCoord()
self.FRmsd = 0
def GoldenSpiralPoints(Num):
Result = []
inc = 3.6 / math.sqrt(Num)
phi = 0
Result.append(basetypes.TCoord(0, 0, -1))
for k in range(1, Num - 1):
z = -1 + 2 * k / (Num - 1)
r = math.sqrt(1 - z * z)
phi = phi + inc / r
Result.append(basetypes.TCoord(
math.cos(phi) * r,
math.sin(phi) * r, z))
Result.append(basetypes.TCoord(0, 0, 1))
# Return TCoords
return Result
def EulerSampleZYX(ZSteps):
# Get ZSteps^2 points uniformly distributed around a sphere
Result = []
for z in range(ZSteps):
qz = geomutils.RotationQuaternion(basetypes.TCoord(0, 0, 1),
2 * geomutils.PI / ZSteps * z)
for y in range(ZSteps):
qy = geomutils.RotationQuaternion(basetypes.TCoord(0, 1, 0),
2 * geomutils.PI / ZSteps * y)
for x in range(int(ZSteps / 2) - 1):
qx = geomutils.RotationQuaternion(
basetypes.TCoord(1, 0, 0), 2 * geomutils.PI / ZSteps * x)
Result.append(
geomutils.Multiply(geomutils.Multiply(qz, qy), qx))
# Return TQuaternions
return Result
def Multiply(v1, v2):
if isinstance(v1, basetypes.TCoord):
# First function
# Return TCoord
return basetypes.TCoord(v1[0] * v2, v1[1] * v2, v1[2] * v2)
elif isinstance(v1, TQuaternion):
# Fourth function
# Return TQuaternion
return TQuaternion(v1[0] * v2[0] - v1[1] * v2[1] - v1[2] * v2[2] - v1[3] * v2[3],
v1[0] * v2[1] + v1[1] * v2[0] + v1[2] * v2[3] - v1[3] * v2[2],
v1[0] * v2[2] - v1[1] * v2[3] + v1[2] * v2[0] + v1[3] * v2[1],
v1[0] * v2[3] + v1[1] * v2[2] - v1[2] * v2[1] + v1[3] * v2[0])
elif isinstance(v1, TRotMatrix):
# Fifth function
Result = TRotMatrix()
for f in range(3):
for g in range(3):
Result[f, g] = v1[f, 0] * v2[0, g] + v1[f, 1] * v2[1, g] + v1[f, 2] * v2[2, g]
# Return TRotMatrix
return Result
elif isinstance(v1[0], basetypes.TCoord):
# Third function
Result = []
for f in range(len(v1)):
Result.append(Multiply(v1[f], v2))
# Return TCoords
return Result
else:
# Second function
Result = []
for f in range(len(v1)):
Result.append(v1[f] * v2)
# Return TFloats
return Result
def __init__(self, Points, GridStep, Rads=None):
assert Points is not None, 'Empty points array for hashing'
assert GridStep > 1e-6, 'GridStep too small'
self.FShiftToGrid = basetypes.TCoord()
self.FPoints = []
self.FRads = []
self.FHashGrid = []
self.FHighX = 0
self.FHighY = 0
self.FHighZ = 0
self.FInvGridStep = 1 / GridStep
self.Setup(Points, GridStep, Rads)
self.FHashGrid = []
for x in range(self.FHighX + 1):
self.FHashGrid.append([])
for y in range(self.FHighY + 1):
self.FHashGrid[x].append([])
for z in range(self.FHighZ + 1):
self.FHashGrid[x][y].append([])
for f in range(len(Points)):
c = geomutils.Add(Points[f], self.FShiftToGrid)
x = math.trunc(c[0] * self.FInvGridStep)
y = math.trunc(c[1] * self.FInvGridStep)
z = math.trunc(c[2] * self.FInvGridStep)
self.FHashGrid[x][y][z].append(f)
def ReadShapeInfo(Parent, NodeName, ShapeInfo):
shapenode = Parent.find(NodeName)
for f in range(len(shapenode.xpath(".//*"))):
atomnode = shapenode.xpath(".//*")[f]
ShapeInfo.Coords.append(basetypes.TCoord(float(atomnode.attrib['X']), float(atomnode.attrib['Y']),
float(atomnode.attrib['Z'])))
ShapeInfo.Rads.append(int(atomnode.attrib['R']))
def BuildBaseGrid(self):
# Adjust coordinates
maxrad = basetypes.Max(basetypes.Max(self.FRads), self.FResolution)
# Translate and size guaranteeing one layer of empty grid cells
self.FTransVec = basetypes.Min(self.FCoords)
self.FTransVec = geomutils.Add(geomutils.Simmetric(self.FTransVec),
maxrad + self.FResolution)
self.FCoords = geomutils.Add(self.FTransVec, self.FCoords)
top = geomutils.Add(basetypes.Max(self.FCoords),
maxrad + 1.5 * self.FResolution)
self.FBase.Grid = []
for f in range(round(top[0] / self.FResolution)):
self.FBase.Grid.append([])
for g in range(round(top[1] / self.FResolution)):
self.FBase.Grid[f].append([])
zline = []
for f in range(round(top[2] / self.FResolution)):
zline.append(0)
self.FBase.ZMax = len(zline) - 1
hash = geomhash.TGeomHasher(self.FCoords, maxrad, self.FRads)
halfres = 0.5 * self.FResolution
xyzpoint = basetypes.TCoord()
for x in range(len(self.FBase.Grid)):
xyzpoint[0] = x * self.FResolution + halfres
for y in range(len(self.FBase.Grid[x])):
xyzpoint[1] = y * self.FResolution + halfres
for z in range(len(zline)):
xyzpoint[2] = z * self.FResolution + halfres
if hash.IsInnerPoint(xyzpoint):
zline[z] = 1
else:
zline[z] = 0
self.FBase.Grid[x][y] = IntegersToLine(zline)
def CrossProduct(v1, v2):
Result = basetypes.TCoord()
Result[0] = v1[1] * v2[2] - v1[2] * v2[1]
Result[1] = v1[2] * v2[0] - v1[0] * v2[2]
Result[2] = v1[0] * v2[1] - v1[1] * v2[0]
# Return TCoord
return Result
def MidPoint(Coords):
Result = basetypes.TCoord()
for f in range(len(Coords)):
Result = Add(Result, Coords[f])
Result = Multiply(Result, 1 / len(Coords))
# Return TCoord
return Result
def AddModel(self, Score, X, Y, Z):
if Score > self.FMinOverlap:
ix1 = 0
while self.FModels[ix1].OverlapScore >= Score:
ix1 = ix1 + 1
# This must stop if Score>FMinOverlap
if self.FLastModel < len(self.FModels) - 1:
self.FLastModel = self.FLastModel + 1
ix2 = self.FLastModel
while ix2 > ix1:
self.FModels[ix2].OverlapScore = self.FModels[ix2 -
1].OverlapScore
self.FModels[ix2].TransVec = self.FModels[ix2 - 1].TransVec
self.FModels[ix2].Rotation = self.FModels[ix2 - 1].Rotation
ix2 = ix2 - 1
self.FModels[ix1].OverlapScore = Score
self.FModels[ix1].TransVec = geomutils.Add(
self.ProbeGridTransVec,
basetypes.TCoord(X * self.GridScale, Y * self.GridScale,
Z * self.GridScale))
self.FModels[ix1].Rotation = self.CurrentRotation
if self.FLastModel == len(self.FModels) - 1:
self.FMinOverlap = self.FModels[self.FLastModel].OverlapScore
# Return Integer
return self.FMinOverlap
def RemoveFromArrayTest():
lnum = [0.01, 1.01, 2.01, 3.01, 4.01, 5.01, 6.01, 7.01, 8.01, 9.01, 10.01]
lstr = []
lcrd = []
for x in range(11):
lstr.append('banana' + str(x))
c = basetypes.TCoord(x, x, x)
lcrd.append(c)
basetypes.RemoveFromArray(5, lnum)
basetypes.RemoveFromArray(6, lcrd)
basetypes.RemoveFromArray(8, lstr)
for x in range(len(lnum)):
print(str(lnum[x]))
for x in range(len(lcrd)):
print(str(lcrd[x][0]) + ' ' + str(lcrd[x][1]) + ' ' + str(lcrd[x][2]))
for x in range(len(lstr)):
print(str(lstr[x]))
print('')
olist = []
for x in range(11):
olist.append(x)
rlist = [5, 6, 7, 2, 11]
basetypes.RemoveFromArray(rlist, olist)
for x in range(len(olist)):
print(str(olist[x]))
def GetPdbAtom(self, s, OldChain):
ChainID = stringutils.GetString(s, 22, 22)
if ChainID is not OldChain:
self.FChainCount = self.FChainCount + 1
OldChain = ChainID
Coords = basetypes.TCoord(stringutils.GetFloat(s, 31, 38), stringutils.GetFloat(s, 39, 46),
stringutils.GetFloat(s, 47, 54))
Element = stringutils.GetString(s, 77, 78)
# Sometimes charge comes right after the element name
if (len(Element) > 1) and not (Element[1].isalpha()):
Element = Element[0]
# Return TPDBAtom (and string in Python)
return TPDBAtom(False, # IsHet
stringutils.GetInteger(s, 7, 11), # Serial
stringutils.Deblank(stringutils.GetString(s, 13, 16)), # AtomName
stringutils.GetString(s, 17, 17), # AltLoc
stringutils.GetString(s, 18, 20), # ResName
ChainID, # ChainID
stringutils.GetInteger(s, 23, 26), # ResSeq
stringutils.GetString(s, 27, 27), # ICode
Coords, # Coords
stringutils.GetFloat(s, 55, 60), # Occupancy
stringutils.GetFloat(s, 55, 66), # OccTemp
stringutils.GetFloat(s, 61, 66), # Temp
Element, # Element
'', # Charge
self.FModelCount, # ModelNum
self.FChainCount), OldChain # ChainNum
def Subtract(v1, v2):
if isinstance(v1, basetypes.TCoord):
if isinstance(v2, basetypes.TCoord):
# Second function
# Return TCoord
return basetypes.TCoord(v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2])
else:
# First function
# Return TCoord
return basetypes.TCoord(v1[0] - v2, v1[1] - v2, v1[2] - v2)
else:
# Third function
Result = []
for f in range(len(v1)):
Result.append(Subtract(v1[f], v2))
# Return TCoords
return Result
def FirstTranslation(self, InitialPoint):
FF = basetypes.TCoord()
for f in range(len(self.FFixed)):
FF = geomutils.Add(FF, self.FFixed[f])
if len(self.FFixed) > 0:
FF = geomutils.Multiply(FF, 1 / len(self.FFixed))
for f in range(3):
InitialPoint[f + 3] = FF[f]
def NormalizeTest():
c = basetypes.TCoord(3.6, 6.2, 8.7)
geomutils.Normalize(c)
print(str(c[0]) + ' ' + str(c[1]) + ' ' + str(c[2]))
q = geomutils.TQuaternion(2.7, 7.2, 6.4, 7.0)
geomutils.Normalize(q)
print(str(q[0]) + ' ' + str(q[1]) + ' ' + str(q[2]) + ' ' + str(q[3]))
def __init__(self, NumModels, MinOverlap, DockModels):
self.FModels = []
for f in range(NumModels):
if f < len(DockModels):
self.FModels.append(DockModels[f])
else:
self.FModels.append(
docktasks.TDockModel(basetypes.TCoord(),
geomutils.IdentityQuaternion, -1))
self.FLastModel = len(DockModels) - 1
if self.FLastModel >= 0:
self.FMinOverlap = basetypes.Min(
self.FModels[self.FLastModel].OverlapScore, MinOverlap)
else:
self.FMinOverlap = MinOverlap
self.CurrentRotation = geomutils.TQuaternion()
self.GridScale = 0.0
self.ProbeGridTransVec = basetypes.TCoord()
def TranslateToTarget(self):
c = basetypes.TCoord(
(self.FDomainGrid.Block.XOffset +
self.FDomainGrid.Block.ProbeEndX / 2) * self.FProbe.FResolution,
(self.FDomainGrid.Block.YOffset +
self.FDomainGrid.Block.ProbeEndY / 2) * self.FProbe.FResolution,
(self.FDomainGrid.Block.ZOffset +
self.FDomainGrid.Block.ProbeEndZ / 2) * self.FProbe.FResolution)
return geomutils.Subtract(c, self.FTarget.TransVec)
def GetDerivatives(self, Deriv):
XVector = basetypes.TCoord(1, 0, 0)
YVector = basetypes.TCoord(0, 1, 0)
ZVector = basetypes.TCoord(0, 0, 1)
self.FBaseRotation = self.CurrentRotation()
self.FRotation = basetypes.TCoord()
TDeriv = self.Shear()
Pivot = self.FTranslation
Axis = XVector
RDeriv = basetypes.TCoord()
RDeriv[0] = self.Torsion(Pivot, Axis)
Axis = YVector
RDeriv[1] = self.Torsion(Pivot, Axis)
Axis = ZVector
RDeriv[2] = self.Torsion(Pivot, Axis)
for f in range(3):
Deriv[f] = RDeriv[f]
Deriv[f + 3] = TDeriv[f]
def ImportConstraints(self, Constraints, ProbeRot, ProbeAxis):
for f in range(len(Constraints)):
if Constraints[f].ConstraintType is docktasks.CEuclideanDistance:
self.EuclideanDistanceConstraint(
Constraints[f].TargetPoints,
geomutils.Rotate(Constraints[f].ProbePouints, ProbeRot),
Constraints[f].Distance)
elif Constraints[f].ConstraintType is docktasks.CNormalPlane:
self.PlaneConstraint(basetypes.TCoord(), ProbeAxis,
Constraints[f].Distance)
def AddToArrayTest():
a = []
for x in range(10):
basetypes.AddToArray('banana' + str(x), a)
print(a[x])
ca = []
for x in range(10):
c = basetypes.TCoord(x, x, x)
basetypes.AddToArray(c, ca)
print(str(ca[x][0]) + ' ' + str(ca[x][1]) + ' ' + str(ca[x][2]))
def MaxTest():
fa = [4.3, 9.1, 5]
tf = basetypes.Max(fa)
print(str(tf))
print('')
ia = [4, 9, 5]
f = basetypes.Max(ia)
print(str(f))
print('')
ca = []
c = basetypes.TCoord(3, 7, 4)
ca.append(c)
c = basetypes.TCoord(5, 1, 6)
ca.append(c)
c = basetypes.TCoord(2, 2, 9)
ca.append(c)
c = basetypes.Max(ca)
print(str(c[0]) + ' ' + str(c[1]) + ' ' + str(c[2]))
print('')
m = [[5, 2, 7], [4, 1, 9], [3, 7, 3]]
tf = basetypes.Max(m)
print(str(tf))
print('')
f = 4
i = 5
f = basetypes.Max(f, i)
print(str(f))
print('')
tf = 4.5
tf2 = 5.1
tf = basetypes.Max(tf, tf2)
print(str(tf))
print('')
c = basetypes.TCoord(4, 5, 9)
c2 = basetypes.TCoord(5, 7, 6)
c = basetypes.Max(c, c2)
print(str(c[0]) + ' ' + str(c[1]) + ' ' + str(c[2]))
