def initialiseParameters(self):
BBG.initialiseParameters(self)
self.numResiduesAlphaHelix = self.getParam('numResiduesAlphaHelix')
self.lengthPerResidueAlpha = self.getParam('lengthPerResidueAlpha')
self.lengthPerResidueBeta = self.getParam('lengthPerResidueBeta')
self.terminiSeparation = self.getParam('terminiSeparation')
self.numBetaSheets = self.getParam('numBetaSheets')
self.numBetaStrands = self.getParam('numBetaStrands')
self.betaStrandLength = self.getParam('betaStrandLength')
self.betaSheetRx = self.getParam('betaSheetRx')
self.betaSheetRy = self.getParam('betaSheetRy')
self.betaSheetRz = self.getParam('betaSheetRz')
self.alphaBetaSeparation = self.getParam('alphaBetaSeparation')
self.alphaHelixAtomName = self.getParam('alphaHelixAtomName')
self.betaStrandAtomName = self.getParam('betaStrandAtomName')
self.coilAtomName = self.getParam('coilAtomName')
self.BSG = BSG(self.paramFilename)
self.AHG = PBG(self.paramFilename)
self.PHG = PHG(self.paramFilename)
self.USP = NBB(self.paramFilename)
self.SPEBBG = SPEBBG(self.paramFilename)
if self.noLoadErrors == False:
print "Critical Parameters are undefined for Spidroin Object"
sys.exit()
def initialiseParameters(self):
BBG.initialiseParameters(self)
# N terminal PDB information and directors
self.NTerminalFilename = self.getParam('NTerminalFilename')
NTerminalDirector = self.getParam('NTerminalDirector')
NTerminalDirector = np.array(
[component for component in NTerminalDirector[0]])
self.NTermDirectorHat = NTerminalDirector / np.linalg.norm(
NTerminalDirector)
self.NTermRot = self.getParam('NTermRot') * np.pi / 180
# C terminal PDB information and directors
self.CTerminalFilename = self.getParam('CTerminalFilename')
CTerminalDirector = self.getParam('CTerminalDirector')
CTerminalDirector = np.array(
[component for component in CTerminalDirector[0]])
self.CTermDirectorHat = CTerminalDirector / np.linalg.norm(
CTerminalDirector)
self.CTermRot = self.getParam('CTermRot') * np.pi / 180
# Over all parameters used to describe the shape and size of the spidroin packing envelope.
self.spidroinTerminusSeparation = self.getParam(
'spidroinTerminusSeparation')
self.SpidroinFrustumMaxRadius = self.getParam(
'SpidroinFrustumMaxRadius')
self.SpidroinFrustumMinRadius = self.getParam(
'SpidroinFrustumMinRadius')
self.SpidroinFrustumZ1 = 0.0
self.SpidroinFrustumZ2 = self.getParam('SpidroinFrustumZ2')
self.ellipseRX = self.getParam('ellipseRX')
self.ellipseRY = self.getParam('ellipseRY')
self.ellipseRZ = self.getParam('ellipseRZ')
self.CNbondLength = self.getParam('CNbondLength')
self.CCbondLength = self.getParam('CCbondLength')
self.omega = self.getParam('omega')
self.angleN = self.getParam('angleN')
self.psi = self.getParam('psi')
self.angleC = self.getParam('angleC')
self.phi = self.getParam('phi')
self.angleC = self.getParam('angleC')
self.dumpInterimFiles = self.getParam('dumpInterimFiles')
self.verbose = self.getParam('verbose')
# for colouring regions distinct colours in blender:
self.NTerminalAtomName = self.getParam('NTerminalAtomName')
self.CTerminalAtomName = self.getParam('CTerminalAtomName')
self.spidroinHairpinAtomName = self.getParam('spidroinHairpinAtomName')
self.spidroinAtomName = self.getParam('spidroinAtomName')
# create instances of all the building block generators that we will need.
self.SpidroinCoilGen = SHGen(self.paramFilename)
self.CTerminusGen = PDBGen(self.CTerminalFilename)
self.NTerminusGen = PDBGen(self.NTerminalFilename)
if self.noLoadErrors == False:
print "Critical Parameters are undefined for Spidroin Object"
sys.exit()
def initialiseParameters(self):
# ensure parent initialisation takes place and core values are initialised
BBG.initialiseParameters(self)
self.maxNumPackMoves = self.getParam("maxNumPackMoves")
self.packT = self.getParam("packT")
self.verbose = self.getParam("verbose")
if self.noLoadErrors == False:
print "Critical Parameters are undefined for SpacePack object"
sys.exit()
def initialiseParameters(self):
BBG.initialiseParameters(self)
self.spidroinSpecies1FName = self.getParam('spidroinSpecies1.xyz')
self.spidroinSpecies2FName = self.getParam('spidroinSpecies2.xyz')
self.ellipsoidPack = SPEBBG(self.paramFilename)
self.species2AltitudeBoost = self.getParam('species2AltitudeBoost')
if self.noLoadErrors == False:
print "Critical Parameters are undefined for Spidroin Object"
sys.exit()
def initialiseParameters(self):
# ensure parent initialisation takes place and core values are initialised
BBG.initialiseParameters(self)
self.particleName = self.getParam('particleName')
self.foldingTemp = self.getParam('foldingTemp')
self.maxNumFoldingMoves = self.getParam('maxNumFoldingMoves')
self.dumpInterimFiles = self.getParam('dumpInterimFiles')
if self.noLoadErrors == False:
print "Critical Parameters are undefined for constrained polymer object"
sys.exit()
def initialiseParameters(self):
# ensure parent initialisation takes place and core values are initialised
BBG.initialiseParameters(self)
self.particleName = self.getParam('particleName')
self.numCrankShaftMoves = self.getParam('numCrankShaftMoves')
self.stubbornGroupLife = self.getParam('stubbornGroupLife')
self.stubbornCranks = self.getParam('stubbornCranks')
if self.noLoadErrors == False:
print "Critical Parameters are undefined for constrained polymer object"
sys.exit()
def initialiseParameters(self):
# ensure parent initialisation takes place and core values are initialised
BBG.initialiseParameters(self)
self.particleName = self.getParam('particleName')
self.CPPBBG = CPPBBG(self.paramFilename)
self.VPCBBG = VPCBBG(self.paramFilename)
if self.noLoadErrors == False:
print("Critical Parameters are undefined for constrained polymer object")
sys.exit()
def initialiseParameters(self):
# ensure parent initialisation takes place and core values are initialised
BBG.initialiseParameters(self)
self.compressionScaleFactor = self.getParam('compressionScaleFactor')
self.maxNumAttempts = self.getParam('maxNumAttempts')
self.maxLivesPerNewNode = self.getParam('maxLivesPerNewNode')
self.maxLivesPerTwoNodes = self.getParam('maxLivesPerTwoNodes')
self.particleName = self.getParam('particleName')
if self.noLoadErrors == False:
print "Critical Parameters are undefined for constrained polymer object"
sys.exit()
def generateBuildingBlock(self,
numPoints,
pointA,
pointB,
minDist,
bondLength,
pointsToAvoid=[],
envelope="None"):
self.numPoints = numPoints
self.pointA = pointA
self.pointB = pointB
self.baseLength = np.linalg.norm(pointA - pointB)
self.bondLength = float(bondLength)
self.minDist = minDist
self.pointA = np.array([-self.baseLength / 2, 0.0, 0.0])
self.pointB = np.array([self.baseLength / 2, 0.0, 0.0])
self.pointsToAvoid = pointsToAvoid
self.envelope = envelope.split()
# generate the transformation information from building block to pointA and pointB
self.labDirector, self.labRefPoint, self.labRotation = self.computeTransform(
)
# convert the pointsToAvoid information from the labFrame to the block frame
self.pointsToAvoid = self.transformFromLabFrameToBlockFrame(
self.labDirector, self.labRefPoint, self.labRotation,
pointsToAvoid)
fIO.saveXYZ([self.pointA, self.pointB], 'S', 'endPoints.xyz')
return BBG.generateBuildingBlock(self, numPoints)
def generateBuildingBlock( self,
numPoints,
startPoints,
endPoints,
alpha1,
alpha2,
beta1,
beta2,
minDist,
bondLength,
pointsToAvoid=[]):
self.numPoints = numPoints
self.startPoints = startPoints
self.endPoints = endPoints
self.bondLength = bondLength
self.minDist = minDist
self.pointsToAvoid = pointsToAvoid
# use these ranges for the allowed dihedral and bond angles
# when it comes to the last point or couple of points at add,
# we can relax these contraints for one point, providing the bond length is ok.
self.alphaMin = min([alpha1 * np.pi/180, alpha2 * np.pi/180])
self.alphaMax = min([alpha1 * np.pi/180, alpha2 * np.pi/180])
self.betaMin = min([beta1 * np.pi/180, beta2 * np.pi/180])
self.betaMax = max([beta1 * np.pi/180, beta2 * np.pi/180])
# compute the overall polymerCompression that will result
self.MaxLength = (self.numPoints + 1) * bondLength
self.distAToB = np.linalg.norm(startPoints[-1] - endPoints[-1])
self.polymerCompression= self.compressionScaleFactor * self.distAToB/self.MaxLength
return BBG.generateBuildingBlock(self, numPoints)
def generateBuildingBlock( self,
numPoints,
pointA,
pointB,
minDist,
bondLength,
pointsToAvoid=[],
envelope="None"):
self.numPoints = numPoints
self.pointA = pointA
self.pointB = pointB
self.baseLength = np.linalg.norm(pointA - pointB)
self.bondLength = float(bondLength)
self.minDist = minDist
self.pointA = np.array([-self.baseLength/2, 0.0, 0.0])
self.pointB = np.array([self.baseLength/2, 0.0, 0.0])
self.pointsToAvoid = pointsToAvoid
self.envelope = envelope.split()
# generate the BuildingBlock reference point earlier than usual because
# we need the transformation for the pointsToAvoid input.
self.blockRefPoint = self.generateBuildingBlockRefPoint()
# generate the BuildingBlock director unit vector earlier than usual because
# we need the transformation for the pointsToAvoid input.
self.blockDirectorHat = self.generateBuildingBlockDirector()
# generate the transformation information from building block to pointA and pointB
self.labDirector, self.labRefPoint, self.labRotation = self.computeTransform()
# convert the pointsToAvoid information from the labFrame to the block frame
self.pointsToAvoid = self.transformFromLabFrameToBlockFrame(self.labDirector, self.labRefPoint, self.labRotation, pointsToAvoid)
return BBG.generateBuildingBlock(self, numPoints)
def generateBuildingBlock(self,
numStrands,
strandLength,
numLoopResidues,
minDist,
inStrandDirector,
crossStrandDirector,
offset,
parallel=True,
nameCA=False):
self.startPos = np.array([0.0, 0.0, 0.0])
self.numStrands = numStrands
self.numPoints = strandLength * 3 # number of points per strand.
self.strandLength = strandLength
self.numLoopResidues = numLoopResidues
self.minDist = minDist
self.inStrandDirectorHat = inStrandDirector / np.linalg.norm(
inStrandDirector)
self.crossStrandDirectorHat = crossStrandDirector / np.linalg.norm(
crossStrandDirector)
self.oStrandDirectorHat = np.cross(self.inStrandDirectorHat,
self.crossStrandDirectorHat)
self.offsetXYZ = offset[2] * self.inStrandDirectorHat + offset[
0] * self.crossStrandDirectorHat + offset[
1] * self.oStrandDirectorHat
self.parallel = parallel
self.nameCA = nameCA
return BBG.generateBuildingBlock(self, self.numPoints, minDist)
def generateBuildingBlock(self,
numBetasheets,
minDist,
longChain=False,
showBlockDirector=False,
nameByBuildingBlockType=True):
# compute number of residues needed in the chain.
# Full Short length including termini is 3129
# Full Long length including termini is 3779
#
if longChain:
self.numResiduesCoil = self.numResiduesLongChain
else:
self.numResiduesCoil = self.numResiduesShortChain
self.numPoints = self.numResiduesCoil * 3
self.numBetasheets = numBetasheets
self.inStrandDirectorHat = np.array([0.0, 0.0, 1.0])
self.crossStrandDirectorHat = np.array([1.0, 0.0, 0.0])
self.minDist = minDist
self.spidroinDirector = np.array([0.0, 0.0, 1.0])
self.spidroinRefPoint = np.array([0.0, 0.0, 0.0])
self.nameByBuildingBlockType = nameByBuildingBlockType
return BBG.generateBuildingBlock(self,
self.numPoints,
minDist,
showBlockDirector=showBlockDirector)
def generateBuildingBlock(self,
numPoints,
XRange,
YRange,
ZRange,
minDist,
visualiseEnvelope=(0, 20),
envelopeList=['None'],
pointsToAvoid=[]):
# XRange, YRange and ZRange are a pair of min and max points.
# Note the number of points
self.numPoints = numPoints
self.minDist = minDist
# specify the min and max of X
self.XRange = XRange
self.YRange = YRange
self.ZRange = ZRange
self.pointsToAvoid = pointsToAvoid
return BBG.generateBuildingBlock(
self,
numPoints,
minDist,
visualiseEnvelope=visualiseEnvelope,
envelopeList=envelopeList,
pointsToAvoid=pointsToAvoid,
)
def generateBuildingBlock(self, species, minDist, showBlockDirector=False):
self.species = species
dummyNumPoints = 0
self.minDist = minDist
self.spidroinDirector = np.array([0.0, 0.0, 1.0])
self.spidroinRefPoint = np.array([0.0, 0.0, 0.0])
return BBG.generateBuildingBlock(self, dummyNumPoints, minDist, showBlockDirector=showBlockDirector)
def generateBuildingBlock(self,
numStrands,
strandLength,
inStrandDirector,
crossStrandDirector,
offset,
polarity='NC',
parallel=True,
loopedEnds=True):
self.startPos = np.array([0.0, 0.0, 0.0])
self.numStrands = numStrands
self.numPoints = strandLength * 3 # number of points per strand.
self.strandLength = strandLength
self.inStrandDirectorHat = inStrandDirector / np.linalg.norm(
inStrandDirector)
self.crossStrandDirectorHat = crossStrandDirector / np.linalg.norm(
crossStrandDirector)
self.oStrandDirectorHat = np.cross(self.inStrandDirectorHat,
self.crossStrandDirectorHat)
self.offsetXYZ = offset[2] * self.inStrandDirectorHat + offset[
0] * self.crossStrandDirectorHat + offset[
1] * self.oStrandDirectorHat
self.polarity = polarity
self.parallel = parallel
self.loopEnds = loopedEnds
return BBG.generateBuildingBlock(self, self.numPoints)
def generateBuildingBlock(self, numSpidroinSpecies1, numSpidroinSpecies2,
numClustersInAggregate):
self.numSpidroinSpecies1 = numSpidroinSpecies1
self.numSpidroinSpecies2 = numSpidroinSpecies2
self.numPointsInCluster = numSpidroinSpecies1 + numSpidroinSpecies2
self.numClustersInAggregate = numClustersInAggregate
return BBG.generateBuildingBlock(self, self.numPointsInCluster,
self.minDist)
def initialiseParameters(self):
# ensure parent initialisation takes place and core values are initialised
BBG.initialiseParameters(self)
self.particleName = self.getParam('particleName')
self.foldingTemp = self.getParam('foldingTemp')
self.maxNumFoldingMoves = self.getParam('maxNumFoldingMoves')
self.dumpInterimFiles = self.getParam('dumpInterimFiles')
self.distEpsilon = self.getParam("distEpsilon")
self.distanceScale = self.getParam("distanceScale")
self.maxNumConnectingMoves = self.getParam("maxNumConnectingMoves")
self.springConstant = self.getParam("springConstant")
self.connectingTemp = self.getParam("connectingTemp")
self.beta = self.getParam("beta") * np.pi / 180.0
self.alpha = self.getParam("alpha") * np.pi / 180.0
if self.noLoadErrors == False:
print(
"Critical Parameters are undefined for constrained polymer object"
)
sys.exit()
def generateBuildingBlock(self,
XYZFileName,
showBlockDirector=False,
visualiseEnvelope=(0, 20, 'envelope.xyz'),
envelopeList=['None'],
pointsToAvoid=[]):
self.atomNameList, self.xyzList = fIO.loadXYZ(XYZFileName)
self.numPoints = len(self.atomNameList)
minDistDummy = 0.0
return BBG.generateBuildingBlock(self,
self.numPoints,
minDistDummy,
showBlockDirector=showBlockDirector)
def initialiseParameters(self):
BBG.initialiseParameters(self)
# Over all parameters used to describe the shape and size of the spidroin packing envelope.
self.spidroinSpecies1FName = self.getParam('spidroinSpecies1Filename')
self.spidroinSpecies2FName = self.getParam('spidroinSpecies2Filename')
self.terminalSeparation = self.getParam('terminalSeparation')
self.monomerRadius = self.getParam('monomerRadius')
self.clusterRX = self.getParam('clusterRX')
self.clusterRY = self.getParam('clusterRY')
self.clusterRZ = self.getParam('clusterRZ')
self.aggregateRX = self.getParam('aggregateRX')
self.aggregateRY = self.getParam('aggregateRY')
self.aggregateRZ = self.getParam('aggregateRZ')
self.minDist = self.getParam('minDist')
self.SPEBBG = SPEBBG(self.paramFilename)
self.VPESCPBBG = VPESCPBBG(self.paramFilename)
if self.noLoadErrors == False:
print "Critical Parameters are undefined for Spidroin Object"
sys.exit()
def initialiseParameters(self):
BBG.initialiseParameters(self)
# get the C Terminal information about dimers and monomers
self.CTermDiFilename = self.getParam('CTerminalFilenameDimer')
CTermDiCI = self.getParam('CTermDimerConnectorIndices')
self.CTermDiConnectorIndices = [[
CTermDiCI[0], CTermDiCI[1], CTermDiCI[2]
], [CTermDiCI[3], CTermDiCI[4], CTermDiCI[5]]]
self.CTermMonFilename = self.getParam('CTerminalFilenameMonomer')
CTermMonCI = self.getParam('CTermMonomerConnectorIndices')
self.CTermMonConnectorIndices = [[
CTermMonCI[0], CTermMonCI[1], CTermMonCI[2]
]]
# get the C Terminal information about dimers and monomers
self.NTermDiFilename = self.getParam('NTerminalFilenameDimer')
NTermDiCI = self.getParam('NTermDimerConnectorIndices')
self.NTermDiConnectorIndices = [[
NTermDiCI[0], NTermDiCI[1], NTermDiCI[2]
], [NTermDiCI[3], NTermDiCI[4], NTermDiCI[5]]]
# get the monomer information
self.NTermMonFilename = self.getParam('NTerminalFilenameMonomer')
NTermMonCI = self.getParam('NTermMonomerConnectorIndices')
self.NTermMonConnectorIndices = [[
NTermMonCI[0], NTermMonCI[1], NTermMonCI[2]
]]
self.NTermMonGen = PDBGen(self.NTermMonFilename)
self.NTermDiGen = PDBGen(self.NTermDiFilename)
self.CTermMonGen = PDBGen(self.CTermMonFilename)
self.CTermDiGen = PDBGen(self.CTermDiFilename)
if self.noLoadErrors == False:
print "Critical Parameters are undefined for Spidroin Object"
sys.exit()
def generateBuildingBlock(self,
backboneOnly=True,
director=None,
showBlockDirector=False,
nameCA=False):
self.backboneOnly = backboneOnly
self.backboneIndices = self.extractBackBoneIndices()
self.numPoints = len(self.backboneIndices)
self.nameCA = nameCA
self.director = director
self.dumpInterimFiles = 0
minDistDummy = 0.0
return BBG.generateBuildingBlock(self,
self.numPoints,
minDistDummy,
showBlockDirector=showBlockDirector)
def generateBuildingBlock(self,
numPoints,
pointA,
pointB,
minDist,
bondLength,
numCrankMoves,
pointsToAvoid=[],
visualiseEnvelope=(0, 20),
envelopeList=["None"],
angularRange=["None"],
startDirector=["None"]):
self.numPoints = numPoints
self.pointA = pointA
self.pointB = pointB
self.baseLength = np.linalg.norm(pointA - pointB)
self.bondLength = float(bondLength)
self.minDist = minDist
self.numCrankMoves = numCrankMoves
self.angularRange = angularRange
self.startDirector = startDirector
self.blockNames = self.generateBuildingBlockNames()
self.allowedList = self.generateAllowedList()
blockDirector = self.generateBuildingBlockDirector()
self.blockDirectorHat = blockDirector / np.linalg.norm(blockDirector)
self.blockRefPoint = self.generateBuildingBlockRefPoint()
self.parseEnvelopeList(envelopeList)
# from the points to avoid list only remember those that would pass the specified envelope test
self.pointsToAvoid = pointsToAvoid
# check starting points are legal or it's gonna be a long wait.
if not self.checkPointInBounds(self.pointA):
print("Error Warning: PointA out of bounds")
time.sleep(3)
if not self.checkPointInBounds(self.pointB):
print("Error Warning: PointB out of bounds")
time.sleep(3)
return BBG.generateBuildingBlock(self,
numPoints,
minDist,
envelopeList=envelopeList,
visualiseEnvelope=visualiseEnvelope,
pointsToAvoid=pointsToAvoid)
def generateBuildingBlock(self,
species,
minDist,
showBlockDirector=False,
sheared=False,
envelopeList=['None']):
self.species = species
self.sheared = sheared
dummyNumPoints = 0
self.minDist = minDist
self.spidroinDirector = np.array([0.0, 0.0, 1.0])
self.spidroinRefPoint = np.array([0.0, 0.0, 0.0])
return BBG.generateBuildingBlock(self,
dummyNumPoints,
minDist,
showBlockDirector=showBlockDirector,
envelopeList=envelopeList)
def generateBuildingBlock( self,
numPoints,
x1,
x2,
y1,
y2,
z1,
z2,
networkMinDist,
neighborRadius,
monomerMinDist,
bondLength,
curlyFactor,
coneAngle,
minAngle,
threshold,
maxNeighbours,
angularRange=['None'],
pointsToAvoid=[],
visualiseEnvelope=(0,20),
envelopeList=["None"]):
self.numPoints = numPoints
self.bondLength = float(bondLength)
self.networkMinDist = networkMinDist
self.neighborRadius = neighborRadius
self.monomerMinDist = monomerMinDist
self.x1 = x1
self.x2 = x2
self.y1 = y1
self.y2 = y2
self.z1 = z1
self.z2 = z2
self.coneAngle = coneAngle
self.minAngle = minAngle
self.threshold = threshold
self.maxNeighbours = maxNeighbours
self.curlyFactor = curlyFactor
self.pointsToAvoid = pointsToAvoid
self.visualiseEnvelope = visualiseEnvelope
self.envelopeList = envelopeList
self.angularRange = angularRange
return BBG.generateBuildingBlock(self, numPoints, networkMinDist, envelopeList=envelopeList, visualiseEnvelope=visualiseEnvelope, pointsToAvoid=pointsToAvoid)
def generateBuildingBlock(self,
startPos,
direction,
rotation,
alignDirectors=True,
showDirector=False,
nameByBuildingBlockType=True):
self.numPoints = 0
self.spidroinDirector = np.array([0.0, 0.0, 1.0])
self.spidroindRefPoint = np.array([0.0, 0.0, 0.0])
self.nameByBuildingBlockType = nameByBuildingBlockType
return BBG.generateBuildingBlock(self,
self.numPoints,
startPos,
direction,
rotation,
alignDirectors=alignDirectors,
showDirector=showDirector)
def generateBuildingBlock(self,
numPoints,
minDist,
envelopeList='[None]',
pointsToAvoid=[],
visualiseEnvelope=(0, 200, 'envelope.xyz'),
showBlockDirector=False,
defaultBlockRefPoint=None):
self.numPoints = numPoints
self.minDist = minDist
return BBG.generateBuildingBlock(
self,
numPoints,
minDist,
envelopeList=envelopeList,
pointsToAvoid=pointsToAvoid,
visualiseEnvelope=visualiseEnvelope,
showBlockDirector=showBlockDirector,
defaultBlockRefPoint=defaultBlockRefPoint)
def generateBuildingBlock(self,
numPoints,
pointA,
alpha1,
alpha2,
beta1,
beta2,
minDist,
bondLength,
pointsToAvoid=[],
visualiseEnvelope=(0, 20, 'envelope.xyz'),
envelopeList=["None"],
showBlockDirector=False,
SpaceCurveTransform=True):
self.numPoints = numPoints
self.pointA = pointA
self.bondLength = float(bondLength)
self.minDist = minDist
self.blockDirectorHat = np.array([0.0, 0.0, 1.0])
self.allowedList = self.generateAllowedList()
self.blockNames = self.generateBuildingBlockNames()
self.parseEnvelopeList(envelopeList)
self.alpha1 = min(alpha1 * np.pi / 180, alpha2 * np.pi / 180)
self.alpha2 = max(alpha1 * np.pi / 180, alpha2 * np.pi / 180)
self.beta1 = min(beta1 * np.pi / 180, beta2 * np.pi / 180)
self.beta2 = max(beta1 * np.pi / 180, beta2 * np.pi / 180)
self.pointsToAvoid = pointsToAvoid
self.SpaceCurveTransform = SpaceCurveTransform
# check starting points are legal or it's gonna be a long wait.
if not self.checkPointInBounds(self.pointA):
print("Error Warning: PointA out of bounds")
time.sleep(3)
return BBG.generateBuildingBlock(self,
numPoints,
minDist,
envelopeList=envelopeList,
visualiseEnvelope=visualiseEnvelope,
showBlockDirector=showBlockDirector,
pointsToAvoid=pointsToAvoid)
def generateBuildingBlock(self,
minDist,
species='SP1',
showBlockDirector=False):
self.species = species
self.minDist = minDist
if species == 'SP1':
self.numGUnits = self.SP1NumGUnits
self.numPQUnits = self.SP1NumGUnits
else:
self.numGUnits = self.SP2NumGUnits
self.numPQUnits = self.SP2NumGUnits + 1
self.numPoints = self.numGUnits * 3 + self.numPQUnits * 3
self.directorHat = np.array([0.0, 0.0, 1.0])
return BBG.generateBuildingBlock(self,
self.numPoints,
minDist,
showBlockDirector=showBlockDirector)
def generateBuildingBlock(self,
numResidues,
seedResidue=None,
showBlockDirector=False,
nameCA=False):
self.numResidues = numResidues
self.numPoints = numResidues * 3
self.directorHat = np.array([0.0, 0.0, 1.0])
self.nameCA = nameCA
self.seedResidue = seedResidue
if not seedResidue == None:
if not len(seedResidue) == 3:
print(
"Warning: Seed residue in peptide backbone generator is not 3 atoms long"
)
minDistDummy = 1.0
return BBG.generateBuildingBlock(self,
self.numPoints,
minDistDummy,
showBlockDirector=showBlockDirector)
