def boundarycompute(self):
try:
return self.boundary
except:
if self[0].str2[6:9] != 'GLY':
atoms = self.findatoms([" N "," C "," CA "," O "," OT1", " CB "])
else:
atoms = self.findatoms([" N "," C "," CA "," O "," OT1", " HA2"])
atoms.remove(0)
posterm = vector.Nlocation(atoms[1].coords(),atoms[2].coords(),atoms[3].coords())
axis = vector.translate(vector.minus(atoms[0].coords()))(posterm)
N1 = vector.unit(axis)
length = vector.norm(axis)
N2 = vector.unit(vector.translate(vector.minus(atoms[2].coords()))(atoms[4].coords()))
self.boundary = [atoms[0].coords(), N1, N2, length]
return self.boundary
def circleArcAroundPivot(pivot, start, end):
pivotToStart = vector.translate(vector.minus(pivot))(start)
pivotToEnd = vector.translate(vector.minus(pivot))(end)
normalToPlane = vector.crossproduct(pivotToStart,pivotToEnd)
firstRadialDirection = vector.crossproduct(normalToPlane, pivotToStart)
planeCoefficients = pivotToEnd
def dotByPlaneCoefficients(vec):
output = 0
for i in range(0,3):
output += planeCoefficients[i] * vec[i]
return output
t = (dotByPlaneCoefficients(end) - dotByPlaneCoefficients(start))/(dotByPlaneCoefficients(firstRadialDirection))
center = vector.translate(start)(vector.scale(firstRadialDirection,t))
return circleArc(center, start, end)
def circleArcAroundPivotClosestPieces(pivot, start, end, smoothingFactor):
pivotToStart = vector.translate(vector.minus(pivot))(start)
pivotToEnd = vector.translate(vector.minus(pivot))(end)
smallerNorm = min(vector.norm(pivotToStart),vector.norm(pivotToEnd))
def findActualEndPoint(vec):
unitVec = vector.unit(vec)
return vector.translate(pivot)(vector.scale(vector.unit(vec),smallerNorm*smoothingFactor))
circularPart = circleArcAroundPivot(pivot,findActualEndPoint(pivotToStart),findActualEndPoint(pivotToEnd))
#FIX!!
if smallerNorm == vector.norm(pivotToStart):
output = circularPart
if smallerNorm != vector.norm(pivotToEnd):
output.attachPartial(1, cutSegment(pivot, end, smallerNorm * smoothingFactor / vector.norm(pivotToEnd), smoothingFactor))
else:
output = cutSegment(start, pivot, 1 - smoothingFactor, 1 - smallerNorm * smoothingFactor / vector.norm(pivotToStart))
output.attachPartial(1, circularPart)
return output
def d(t):
currentPoint = Wmap.ev(0)[0]
currentLocationOnRnew = Rnew.projectOntoAxis(currentPoint)
for x in pointsOnWmap:
thisLocationOnRnew = Rnew.projectOntoAxis(x)
if thisLocationOnRnew >= currentLocationOnRnew:
if thisLocationOnRnew <= t:
currentLocationOnRnew = thisLocationOnRnew
currentPoint = x
return vector.vectorToAngle(vector.unit(vector.translate(vector.minus(Rnew.ev(currentLocationOnRnew)[0]))(currentPoint)))
def circleArc(center, start, end):
radToStart = vector.translate(vector.minus(center))(start)
radToEnd = vector.translate(vector.minus(center))(end)
radiusSquared = vector.norm(radToStart)*vector.norm(radToEnd)
radius = math.sqrt(radiusSquared)
innerProductValue = vector.innerproduct(radToStart, radToEnd)
angle = math.acos(innerProductValue/radiusSquared)
firstUnitRadial = vector.unit(radToStart)
secondUnitRadial = vector.unit(vector.translate(vector.scale(radToStart,-innerProductValue/radiusSquared))(radToEnd))
def CN(t):
point = vector.translate(center)(vector.translate(vector.scale(firstUnitRadial,radius*math.cos(t/radius)))(vector.scale(secondUnitRadial,radius*math.sin(t/radius))))
tangent = vector.translate(vector.scale(firstUnitRadial,-math.sin(t/radius)))(vector.scale(secondUnitRadial,math.cos(t/radius)))
output = [point,tangent]
#output.append([math.cos(t/radius),math.sin(t/radius),0])
return output
return TwistingAxis(angle*radius,CN)
def boundarycompute(self):
try:
return self.boundary
except:
if self[0].str2[6:9] != 'GLY':
atoms = self.findatoms(
[" N ", " C ", " CA ", " O ", " OT1", " CB "])
else:
atoms = self.findatoms(
[" N ", " C ", " CA ", " O ", " OT1", " HA2"])
atoms.remove(0)
posterm = vector.Nlocation(atoms[1].coords(), atoms[2].coords(),
atoms[3].coords())
axis = vector.translate(vector.minus(atoms[0].coords()))(posterm)
N1 = vector.unit(axis)
length = vector.norm(axis)
N2 = vector.unit(
vector.translate(vector.minus(atoms[2].coords()))(
atoms[4].coords()))
self.boundary = [atoms[0].coords(), N1, N2, length]
return self.boundary
def makeArray(self, dim1, dim2, distance1, distance2, antiparallel):
for i in range(0,dim1):
for j in range(0,dim2):
if i == 0 and j == 0:
output = copy.deepcopy(self)
else:
current = copy.deepcopy(self)
if antiparallel and ((i + j)% 2 == 1):
current.reverseOrbs()
pointrigidMotion = vector.translate([i*distance1,j*distance2,0])
current.moveOrbs([pointrigidMotion, lambda x: x])
output.overlay(current)
return output
def smoothedPieceWiseLinearFullFunctionality(points, mapFromSpaceToTime, Wnew, smoothingFactor = 0.33):
if len(points) < 2:
print("Error: only " + str(len(points)) + " points supplied to smoothedPieceWiseLinear")
return
currentPoints = copy.deepcopy(points)
numPoints = len(currentPoints)
attachElements = [cutSegment(points[0],points[1],0,smoothingFactor)]
for i in range(0,numPoints - 2):
lastToPivot = vector.translate(vector.minus(points[i]))(points[i+1])
pivotToNext = vector.translate(vector.minus(points[i+1]))(points[i+2])
angle = vector.innerproduct(lastToPivot, pivotToNext)/(vector.norm(lastToPivot)*vector.norm(pivotToNext))
collinear = (abs(angle) < 0.001)
if collinear:
attachElements.append(cutSegment(points[i],points[i+1],smoothingFactor,1))
attachElements.append(cutSegment(points[i+1],points[i+2],1,smoothingFactor))
else:
attachElements.append(cutSegment(points[i],points[i+1],smoothingFactor,1-smoothingFactor))
attachElements.append(circleArcAroundPivotClosestPieces(points[i+1],points[i],points[i+2],smoothingFactor))
attachElements.append(cutSegment(points[-2],points[-1],smoothingFactor,1))
def iteratedAttach(start, end):
if start < end:
midpoint = (start + end)/2
iteratedAttach(start, midpoint)
iteratedAttach(midpoint + 1, end)
attachElements[start].attachPartial(1, attachElements[midpoint + 1])
iteratedAttach(0, len(attachElements)-1)
Wmap = attachElements[0]
produceN2 = lambda x : vector.unit(vector.orthogonalComponent(vector.translate(vector.minus(Wnew.ev(mapFromSpaceToTime(x[0]))[0]))(x[0]),x[1]))
appendN2 = lambda x: [x[0],x[1],produceN2(x)]
Wmap.CN = compose(appendN2,Wmap.CN)
return [Wmap, Wnew, lambda t: mapFromSpaceToTime(Wmap.ev(t)[0])]
def segment(start, end):
startToEnd = vector.translate(vector.minus(start))(end)
distance = vector.norm(startToEnd)
try:
tng = vector.unit(startToEnd)
def CN(t):
output = [vector.translate(start)(vector.scale(tng,t)),tng]
#output.append(normal)
return output
except:
def CN(t):
output = [start, [0,0,0]]
return TwistingAxis(distance, CN)
def translate(self, x, y, z):
self.vertices = vector.translate(self.vertices, x, y, z)
self.invalidate_bounding_box()
self.modified = True
def ev(self, t):
return [vector.translate(vector.scale(self.tng,t))(self.start),self.tng,[0,0,0]]
def CN(t):
point = vector.translate(center)(vector.translate(vector.scale(firstUnitRadial,radius*math.cos(t/radius)))(vector.scale(secondUnitRadial,radius*math.sin(t/radius))))
tangent = vector.translate(vector.scale(firstUnitRadial,-math.sin(t/radius)))(vector.scale(secondUnitRadial,math.cos(t/radius)))
output = [point,tangent]
#output.append([math.cos(t/radius),math.sin(t/radius),0])
return output
def findActualEndPoint(vec):
unitVec = vector.unit(vec)
return vector.translate(pivot)(vector.scale(vector.unit(vec),smallerNorm*smoothingFactor))
def CN(t):
output = [vector.translate(start)(vector.scale(tng,t)),tng]
#output.append(normal)
return output
def cutSegment(start, end, startScale, endScale):
segStart = vector.translate(start)(vector.scale(vector.translate(vector.minus(start))(end),startScale))
segEnd = vector.translate(start)(vector.scale(vector.translate(vector.minus(start))(end),endScale))
return segment(segStart, segEnd)
