def GenerateTopologicalTorsionsFingerprints(Mols):
"""Generate TopologicalTorsions fingerprints."""
MiscUtil.PrintInfo("\nGenerating TopologicalTorsions fingerprints...")
UseChirality = OptionsInfo["FingerprintsParams"]["TopologicalTorsions"][
"UseChirality"]
if OptionsInfo["GenerateBitVectFingerints"]:
FPSize = 2048
BitsPerHash = 4
MolsFingerprints = [
rdMolDescriptors.GetHashedTopologicalTorsionFingerprintAsBitVect(
Mol,
includeChirality=UseChirality,
nBits=FPSize,
nBitsPerEntry=BitsPerHash) for Mol in Mols
]
else:
# Generate LongSparseIntVect fingerprint...
MolsFingerprints = [
rdMolDescriptors.GetTopologicalTorsionFingerprint(
Mol, includeChirality=UseChirality) for Mol in Mols
]
return MolsFingerprints
def ProcessSimilarityMetricParameter():
"""Process specified similarity metric value."""
SimilarityInfoMap = {}
CanonicalNameMap = {}
for SimilarityFunctionInfo in DataStructs.similarityFunctions:
Name = SimilarityFunctionInfo[0]
Function = SimilarityFunctionInfo[1]
SimilarityInfoMap[Name] = Function
CanonicalName = Name.lower()
CanonicalNameMap[CanonicalName] = Name
SpecifiedCanonicalName = OptionsInfo["SimilarityMetric"].lower()
SimilarityFunction = None
if SpecifiedCanonicalName in CanonicalNameMap:
SimilarityName = CanonicalNameMap[SpecifiedCanonicalName]
SimilarityFunction = SimilarityInfoMap[SimilarityName]
else:
MiscUtil.PrintError(
"Similarity metric name, %s, is not a valid name. " %
OptionsInfo["SimilarityMetric"])
OptionsInfo["SimilarityMetric"] = SimilarityName
OptionsInfo["SimilarityFunction"] = SimilarityFunction
# RDKit similarity functions, besides Dice and Tanimoto, are not able to handle int bit vectors...
GenerateBitVectFingerints = False
if not re.match("^(Tanimoto|Dice)$", SimilarityName, re.I):
GenerateBitVectFingerints = True
OptionsInfo["GenerateBitVectFingerints"] = GenerateBitVectFingerints
def GenerateMorganFeaturesFingerprints(Mols):
"""Generate MorganFeatures fingerprints."""
MiscUtil.PrintInfo("\nGenerating MorganFeatures fingerprints...")
# Setup fingerprints parameters...
Radius = OptionsInfo["FingerprintsParams"]["MorganFeatures"]["Radius"]
UseChirality = OptionsInfo["FingerprintsParams"]["MorganFeatures"][
"UseChirality"]
UseFeatures = True
if OptionsInfo["GenerateBitVectFingerints"]:
# Generate ExplicitBitVect fingerprints...
FPSize = 2048
MolsFingerprints = [
rdMolDescriptors.GetMorganFingerprintAsBitVect(
Mol,
Radius,
useFeatures=UseFeatures,
useChirality=UseChirality,
nBits=FPSize) for Mol in Mols
]
else:
# Generate UIntSparseIntVect fingerprints...
MolsFingerprints = [
rdMolDescriptors.GetMorganFingerprint(Mol,
Radius,
useFeatures=UseFeatures,
useChirality=UseChirality)
for Mol in Mols
]
return MolsFingerprints
def GeneratePathLengthFingerprints(Mols):
"""Generate PathLength fingerprints."""
MiscUtil.PrintInfo("\nGenerating PathLength fingerprints ...")
MinPath = OptionsInfo["FingerprintsParams"]["PathLength"]["MinPath"]
MaxPath = OptionsInfo["FingerprintsParams"]["PathLength"]["MaxPath"]
FPSize = OptionsInfo["FingerprintsParams"]["PathLength"]["FPSize"]
BitsPerHash = OptionsInfo["FingerprintsParams"]["PathLength"][
"BitsPerHash"]
UseHs = False
TargetDensity = 0.3
MinSize = 54
# Generate ExplicitBitVect fingerprints...
MolsFingerprints = [
FingerprintMols.FingerprintMol(Mol,
minPath=MinPath,
maxPath=MaxPath,
fpSize=FPSize,
bitsPerHash=BitsPerHash,
useHs=UseHs,
tgtDensity=TargetDensity,
minSize=MinSize) for Mol in Mols
]
return MolsFingerprints
def GetFormattedPropertyValue(Selection, Name):
"""Calculate and return a formatted property value. """
Quiet = OptionsInfo["Quiet"]
Precision = OptionsInfo["Precision"]
Value = None
if re.match("^CenterOfMass$", Name, re.I):
Value = PyMOLUtil.CalculateCenterOfMass(Selection, Quiet)
elif re.match("^MolecularWeight$", Name, re.I):
Value = pymol.util.compute_mass(Selection, implicit = False, quiet = Quiet)
elif re.match("^MolecularSurfaceArea$", Name, re.I):
Value = pymol.util.get_area(Selection, -1, 0, quiet = Quiet)
elif re.match("^SumOfFormalCharges$", Name, re.I):
Value = pymol.util.sum_formal_charges(Selection, quiet = Quiet)
elif re.match("^SumOfPartialCharges$", Name, re.I):
Value = pymol.util.sum_partial_charges(Selection, quiet = Quiet)
elif re.match("^SolventAccessibleSurfaceArea$", Name, re.I):
Value = pymol.util.get_sasa(Selection, quiet = Quiet)
else:
MiscUtil.PrintError("The property name specified, %s, using \"-m, --mode\" option is not a valid name." % Name)
if Value is None:
FormattedValue = "NA"
else:
if type(Value) is list:
FormattedValues = []
for ListElement in Value:
FormattedListElement = "%.*f" % (Precision, ListElement)
FormattedValues.append(FormattedListElement)
FormattedValue = " ".join(FormattedValues)
else:
FormattedValue = "%.*f" % (Precision, Value)
return FormattedValue
def GenerateAtomPairsFingerprints(Mols):
"""Generate AtomPairs fingerprints."""
MiscUtil.PrintInfo("\nGenerating AtomPairs fingerprints...")
MinLength = OptionsInfo["FingerprintsParams"]["AtomPairs"]["MinLength"]
MaxLength = OptionsInfo["FingerprintsParams"]["AtomPairs"]["MaxLength"]
UseChirality = OptionsInfo["FingerprintsParams"]["AtomPairs"][
"UseChirality"]
if OptionsInfo["GenerateBitVectFingerints"]:
# Generate ExplicitBitVect fingerprints...
FPSize = 2048
BitsPerHash = 4
MolsFingerprints = [
rdMolDescriptors.GetHashedAtomPairFingerprintAsBitVect(
Mol,
minLength=MinLength,
maxLength=MaxLength,
includeChirality=UseChirality,
nBits=FPSize,
nBitsPerEntry=BitsPerHash) for Mol in Mols
]
else:
# Generate IntSparseIntVect fingerprints...
MolsFingerprints = [
rdMolDescriptors.GetAtomPairFingerprint(
Mol,
minLength=MinLength,
maxLength=MaxLength,
includeChirality=UseChirality) for Mol in Mols
]
return MolsFingerprints
def GetPocketSelectionResiduesInfo(MolName, ChainID, LigandResName,
LigandResNum, PocketDistanceCutoff,
SelectionType):
"""Get pocket residues info for a specified selection type. """
SelectionInfo = None
if re.match("^Pockets$", SelectionType, re.I):
SelectionInfo = PyMOLUtil.GetPocketPolymerResiduesInfo(
MolName, ChainID, LigandResName, LigandResNum,
PocketDistanceCutoff)
elif re.match("^PocketSolvents$", SelectionType, re.I):
SelectionInfo = PyMOLUtil.GetPocketSolventResiduesInfo(
MolName, ChainID, LigandResName, LigandResNum,
PocketDistanceCutoff)
elif re.match("^PocketInorganics$", SelectionType, re.I):
SelectionInfo = PyMOLUtil.GetPocketInorganicResiduesInfo(
MolName, ChainID, LigandResName, LigandResNum,
PocketDistanceCutoff)
else:
MiscUtil.PrintError(
"Failed to retrieve pocket residues information: Selection type %s is not valid..."
% SelectionType)
return SelectionInfo
def ListFileInfo(Infile):
"""List information for macromolecules in a file."""
FileDir, FileName, FileExt = MiscUtil.ParseFileName(Infile)
MolName = FileName
# Load infile...
pymol.cmd.load(Infile, MolName)
ChainIDs = PyMOLUtil.GetChains(MolName)
ListHeaderInfo(Infile)
ListChainsInfo(MolName, ChainIDs)
ListChainsResiduesInfo(MolName, ChainIDs)
ListLigandsInfo(MolName, ChainIDs)
ListSolventsInfo(MolName, ChainIDs)
ListInorganicsInfo(MolName, ChainIDs)
ListPocketsInfo(MolName, ChainIDs)
ListBoundingBoxInfo(MolName)
# Delete infile object...
pymol.cmd.delete(MolName)
ListFileSizeAndModificationInfo(Infile)
def GenerateSinglePlotFile():
"""Generate a single plot file containg all four types of Ramachandran plots."""
Outfile = OptionsInfo["Outfile"]
MiscUtil.PrintInfo("\nGenerating output file %s..." % (Outfile))
SetupFontFamily()
# Setup figure...
PlotFigure, Axes = plt.subplots(2,
2,
figsize=(OptionsInfo["FigWidth"],
OptionsInfo["FigHeight"]),
dpi=OptionsInfo["FigDPI"])
PlotAxes = [Axis for RowAxes in Axes for Axis in RowAxes]
# Adjust space between subplots...
plt.subplots_adjust(left=0.1,
right=0.9,
bottom=0.1,
top=0.9,
wspace=0.3,
hspace=0.25)
for PlotIndex, PlotType in enumerate(
OptionsInfo["PlotTypesInfo"]["Types"]):
DrawPlot(PlotAxes[PlotIndex], PlotType)
# Save figure...
plt.savefig(Outfile)
def WriteTableHeaderRow(Writer, ValidMols):
"""Write out table header row."""
if not OptionsInfo["TableHeader"]:
return
TableHeaderStyle = OptionsInfo["TableHeaderStyle"]
if TableHeaderStyle is None:
Writer.write(""" <thead>\n""")
Writer.write(""" <tr>\n""")
elif re.match("^(thead|table)", TableHeaderStyle):
Writer.write(""" <thead class="%s">\n""" % TableHeaderStyle)
Writer.write(""" <tr>\n""")
else:
Writer.write(""" <thead>\n""")
Writer.write(""" <tr bgcolor="%s"\n""" % TableHeaderStyle)
if OptionsInfo["CounterCol"]:
Writer.write(""" <th></th>\n""")
# Write out rest of the column headers...
MolCount = len(ValidMols)
ColCount = GetColCount(MolCount)
for ColIndex in range(0, ColCount):
ColLabel = MiscUtil.GetExcelStyleColumnLabel(ColIndex + 1)
Writer.write(""" <th>%s</th>\n""" % ColLabel)
Writer.write(""" </tr>\n""")
Writer.write(""" </thead>\n""")
def ProcessClusteringMethodParameter():
"""Process specified clustering method parameter."""
OptionsInfo["SpecifiedHierarchicalClusteringMethod"] = ""
OptionsInfo["SpecifiedHierarchicalClusteringMethodID"] = ""
if re.match("^Butina$", OptionsInfo["ClusteringMethod"], re.I):
# Nothing to process...
return
# Setup a canonical cluster method name map..
ClusteringMethodInfoMap = {}
CanonicalClusteringMethodNameMap = {}
for Name in sorted(rdSimDivPickers.ClusterMethod.names):
NameID = rdSimDivPickers.ClusterMethod.names[Name]
ClusteringMethodInfoMap[Name] = NameID
CanonicalName = Name.lower()
CanonicalClusteringMethodNameMap[CanonicalName] = Name
CanonicalName = OptionsInfo["ClusteringMethod"].lower()
if not CanonicalName in CanonicalClusteringMethodNameMap:
MiscUtil.PrintError(
"The clustering method, %s, specified using \"-c, --clusteringMethod\" option is not a valid name."
% (OptionsInfo["ClusteringMethod"]))
SpecifiedHierarchicalClusteringMethodName = CanonicalClusteringMethodNameMap[
CanonicalName]
OptionsInfo[
"SpecifiedHierarchicalClusteringMethod"] = SpecifiedHierarchicalClusteringMethodName
OptionsInfo[
"SpecifiedHierarchicalClusteringMethodID"] = ClusteringMethodInfoMap[
SpecifiedHierarchicalClusteringMethodName]
def GetSelectionResiduesInfo(MolName, ChainID, SelectionType):
"""Get residues info for a specified selection type. """
SelectionInfo = None
SelectionLabel = None
if re.match("^Ligands$", SelectionType, re.I):
SelectionLabel = "ligand"
SelectionInfo = PyMOLUtil.GetLigandResiduesInfo(MolName, ChainID)
elif re.match("^Solvents$", SelectionType, re.I):
SelectionLabel = "solvent"
SelectionInfo = PyMOLUtil.GetSolventResiduesInfo(MolName, ChainID)
elif re.match("^Inorganics$", SelectionType, re.I):
SelectionLabel = "inorganic"
SelectionInfo = PyMOLUtil.GetInorganicResiduesInfo(MolName, ChainID)
elif re.match("^Chains$", SelectionType, re.I):
SelectionLabel = "polymer chain"
SelectionInfo = PyMOLUtil.GetPolymerResiduesInfo(MolName, ChainID)
elif re.match("^NonStandardAminoAcids$", SelectionType, re.I):
SelectionLabel = "non-standard amino acids"
SelectionInfo = PyMOLUtil.GetAminoAcidResiduesInfo(
MolName, ChainID, "NonStandard")
else:
MiscUtil.PrintError(
"Failed to retrieve residues information: Selection type %s is not valid..."
% SelectionType)
return SelectionInfo, SelectionLabel
def EmbedMolecule(Mol, MolNum=None):
"Embed conformations"
ConfIDs = []
MaxConfs = OptionsInfo["MaxConfs"]
RandomSeed = OptionsInfo["RandomSeed"]
EnforceChirality = OptionsInfo["EnforceChirality"]
UseExpTorsionAnglePrefs = OptionsInfo["UseExpTorsionAnglePrefs"]
UseBasicKnowledge = OptionsInfo["UseBasicKnowledge"]
try:
ConfIDs = AllChem.EmbedMultipleConfs(
Mol,
numConfs=MaxConfs,
randomSeed=RandomSeed,
enforceChirality=EnforceChirality,
useExpTorsionAnglePrefs=UseExpTorsionAnglePrefs,
useBasicKnowledge=UseBasicKnowledge)
except ValueError as ErrMsg:
if not OptionsInfo["QuietMode"]:
MolName = RDKitUtil.GetMolName(Mol, MolNum)
MiscUtil.PrintWarning("Embedding failed for molecule %s:\n%s\n" %
(MolName, ErrMsg))
ConfIDs = []
return ConfIDs
def WorkerProcess(EncodedMolInfo):
"""Process data for a worker process."""
MolIndex, EncodedMol = EncodedMolInfo
CalcStatus = False
ConfID = None
Energy = None
if EncodedMol is None:
return [MolIndex, None, CalcStatus, ConfID, Energy]
Mol = RDKitUtil.MolFromBase64EncodedMolString(EncodedMol)
if RDKitUtil.IsMolEmpty(Mol):
if not OptionsInfo["QuietMode"]:
MolName = RDKitUtil.GetMolName(Mol, (MolIndex + 1))
MiscUtil.PrintWarning("Ignoring empty molecule: %s" % MolName)
return [MolIndex, None, CalcStatus, ConfID, Energy]
Mol, CalcStatus, ConfID, Energy = MinimizeMoleculeOrConformers(
Mol, (MolIndex + 1))
return [
MolIndex,
RDKitUtil.MolToBase64EncodedMolString(
Mol,
PropertyPickleFlags=Chem.PropertyPickleOptions.MolProps
| Chem.PropertyPickleOptions.PrivateProps), CalcStatus, ConfID,
Energy
]
def GetEnergy(Mol, ConfID=None):
"Calculate energy."
Status = True
Energy = None
if ConfID is None:
ConfID = -1
if OptionsInfo["UseUFF"]:
UFFMoleculeForcefield = AllChem.UFFGetMoleculeForceField(Mol,
confId=ConfID)
if UFFMoleculeForcefield is None:
Status = False
else:
Energy = UFFMoleculeForcefield.CalcEnergy()
elif OptionsInfo["UseMMFF"]:
MMFFMoleculeProperties = AllChem.MMFFGetMoleculeProperties(
Mol, mmffVariant=OptionsInfo["MMFFVariant"])
MMFFMoleculeForcefield = AllChem.MMFFGetMoleculeForceField(
Mol, MMFFMoleculeProperties, confId=ConfID)
if MMFFMoleculeForcefield is None:
Status = False
else:
Energy = MMFFMoleculeForcefield.CalcEnergy()
else:
MiscUtil.PrintError(
"Couldn't retrieve conformer energy: Specified forcefield, %s, is not supported"
% OptionsInfo["ForceField"])
return (Status, Energy)
def PerformButinaClustering(Mols, MolsFingerprints):
"""Perform clustering using Butina methodology."""
MiscUtil.PrintInfo(
"\nClustering molecules using Butina methodology and %s similarity metric..."
% OptionsInfo["SimilarityMetric"])
FingerprintsCount = len(MolsFingerprints)
DistanceCutoff = 1 - OptionsInfo["ButinaSimilarityCutoff"]
Reordering = OptionsInfo["ButinaReordering"]
DistanceMatrix = GenerateLowerTriangularDistanceMatrix(MolsFingerprints)
ClusteredMolIndices = Butina.ClusterData(DistanceMatrix,
FingerprintsCount,
DistanceCutoff,
reordering=Reordering,
isDistData=True)
MolsClusters = []
for Cluster in ClusteredMolIndices:
MolsCluster = [Mols[MolIndex] for MolIndex in Cluster]
MolsClusters.append(MolsCluster)
return MolsClusters
def RetrieveOptions():
"""Retrieve command line arguments and options"""
# Get options...
global Options
Options = docopt(_docoptUsage_)
# Set current working directory to the specified directory...
WorkingDir = Options["--workingdir"]
if WorkingDir:
os.chdir(WorkingDir)
# Handle examples option...
if "--examples" in Options and Options["--examples"]:
MiscUtil.PrintInfo(MiscUtil.GetExamplesTextFromDocOptText(_docoptUsage_))
sys.exit(0)
def ValidateOptions():
"""Validate option values"""
MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "pdb")
MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
Options["--infile"],
"-o, --outfile",
Options["--outfile"])
MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
"pdb")
MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
Options["--outfile"],
"--overwrite",
Options["--overwrite"])
def InitializeWorkerProcess(*EncodedArgs):
"""Initialize data for a worker process."""
global Options, OptionsInfo
MiscUtil.PrintInfo("Starting process (PID: %s)..." % os.getpid())
# Decode Options and OptionInfo...
Options = MiscUtil.ObjectFromBase64EncodedString(EncodedArgs[0])
OptionsInfo = MiscUtil.ObjectFromBase64EncodedString(EncodedArgs[1])
# Decode PAINSPatternMols...
OptionsInfo["PAINSPatternMols"] = [
RDKitUtil.MolFromBase64EncodedMolString(EncodedMol)
for EncodedMol in OptionsInfo["EncodedPAINSPatternMols"]
]
def WorkerProcess(EncodedMolInfo):
"""Process data for a worker process."""
MolIndex, EncodedMol = EncodedMolInfo
if EncodedMol is None:
return [MolIndex, None, False, None]
Mol = RDKitUtil.MolFromBase64EncodedMolString(EncodedMol)
if RDKitUtil.IsMolEmpty(Mol):
MolName = RDKitUtil.GetMolName(Mol, (MolIndex + 1))
MiscUtil.PrintWarning("Ignoring empty molecule: %s" % MolName)
return [MolIndex, None, False, None]
MolWithHs = Chem.AddHs(Mol)
EncodedMolWithHs = RDKitUtil.MolToBase64EncodedMolString(
MolWithHs,
PropertyPickleFlags=Chem.PropertyPickleOptions.MolProps
| Chem.PropertyPickleOptions.PrivateProps)
# Retrieve charges...
CalcStatus, PartialCharges = CalculateMolPartialCharges(
MolWithHs, (MolIndex + 1))
return [MolIndex, EncodedMolWithHs, CalcStatus, PartialCharges]
def CalculateMolPartialCharges(Mol, MolCount):
"""Calculate partial atomic charges for a molecule."""
PartialCharges = []
if OptionsInfo["MMFFChargesMode"]:
if AllChem.MMFFHasAllMoleculeParams(Mol):
MMFFProp = AllChem.MMFFGetMoleculeProperties(Mol)
PartialCharges = [
MMFFProp.GetMMFFPartialCharge(AtomIndex)
for AtomIndex in range(Mol.GetNumAtoms())
]
else:
MolName = RDKitUtil.GetMolName(Mol, MolCount)
MiscUtil.PrintWarning(
"Failed to calculate MMFF partial charges for molecule, %s: Missing forcefield parameters"
% MolName)
return (False, PartialCharges)
else:
rdPartialCharges.ComputeGasteigerCharges(
Mol,
nIter=OptionsInfo["NumIters"],
throwOnParamFailure=OptionsInfo["AllowParamFailure"])
PartialCharges = [
Atom.GetProp("_GasteigerCharge") for Atom in Mol.GetAtoms()
]
# Format charges...
PartialCharges = [
"%.*f" % (OptionsInfo["Precision"], float(Value))
for Value in PartialCharges
]
return (True, PartialCharges)
def ProcessChainIDs():
"""Process specified chain IDs for infile."""
MiscUtil.PrintInfo(
"\nProcessing specified chain IDs for input file %s..." %
OptionsInfo["Infile"])
ChainsAndLigandsInfo = OptionsInfo["ChainsAndLigandsInfo"]
SpecifiedChainsAndLigandsInfo = PyMOLUtil.ProcessChainsAndLigandsOptionsInfo(
ChainsAndLigandsInfo, "-c, --chainIDs", OptionsInfo["ChainIDs"], None,
None)
OptionsInfo[
"SpecifiedChainsAndLigandsInfo"] = SpecifiedChainsAndLigandsInfo
MiscUtil.PrintInfo("Specified chain IDs: %s" %
(", ".join(SpecifiedChainsAndLigandsInfo["ChainIDs"])))
def ProcessOptions():
"""Process and validate command line arguments and options"""
MiscUtil.PrintInfo("Processing options...")
# Validate options...
ValidateOptions()
OptionsInfo["AlignMethod"] = Options["--alignMethod"].lower()
OptionsInfo["AlignMode"] = Options["--alignMode"]
OptionsInfo["Infiles"] = Options["--infiles"]
OptionsInfo["InfilesNames"] = Options["--infileNames"]
OptionsInfo["AlignRefFile"] = Options["--alignRefFile"]
if re.match("^FirstInputFile$", Options["--alignRefFile"], re.I):
OptionsInfo["RefFileName"] = OptionsInfo["InfilesNames"][0]
else:
OptionsInfo["RefFileName"] = Options["--alignRefFile"]
OptionsInfo["OutSuffix"] = Options["--outSuffix"]
OptionsInfo["Overwrite"] = Options["--overwrite"]
RetrieveInfilesInfo()
RetrieveRefFileInfo()
def ProcessSimilarityMetricParameter():
"""Process specified similarity metric value."""
SimilarityInfoMap = {}
CanonicalNameMap = {}
for SimilarityFunctionInfo in DataStructs.similarityFunctions:
Name = SimilarityFunctionInfo[0]
Function = SimilarityFunctionInfo[1]
SimilarityInfoMap[Name] = Function
CanonicalName = Name.lower()
CanonicalNameMap[CanonicalName] = Name
SpecifiedCanonicalName = OptionsInfo["SimilarityMetric"].lower()
SimilarityFunction = None
if SpecifiedCanonicalName in CanonicalNameMap:
SimilarityName = CanonicalNameMap[SpecifiedCanonicalName]
SimilarityFunction = SimilarityInfoMap[SimilarityName]
else:
MiscUtil.PrintError(
"Similarity metric name, %s, is not a valid name. " %
OptionsInfo["SimilarityMetric"])
OptionsInfo["SimilarityMetric"] = SimilarityName
OptionsInfo["SimilarityFunction"] = SimilarityFunction
def WriteLigandFile(MolName, ChainID, LigandID, LigandFile):
"""Write ligand file."""
MiscUtil.PrintInfo("\nGenerating output file %s..." % LigandFile)
LigandName = "%s_Chain%s_%s" % (MolName, ChainID, LigandID)
LigandSelection = "(%s and (chain %s) and organic and (resn %s))" % (
MolName, ChainID, LigandID)
MiscUtil.PrintInfo("Ligand selection: %s" % LigandSelection)
pymol.cmd.create(LigandName, LigandSelection)
pymol.cmd.save(LigandFile, LigandSelection)
pymol.cmd.delete(LigandName)
if not os.path.exists(LigandFile):
MiscUtil.PrintWarning("Failed to generate ligand file, %s..." %
(LigandFile))
def RetrieveMolecules():
"""Retrieve molecules."""
Infile = OptionsInfo["Infile"]
# Read molecules...
MiscUtil.PrintInfo("\nReading file %s..." % Infile)
OptionsInfo["InfileParams"]["AllowEmptyMols"] = False
ValidMols, MolCount, ValidMolCount = RDKitUtil.ReadAndValidateMolecules(
Infile, **OptionsInfo["InfileParams"])
MiscUtil.PrintInfo("Total number of molecules: %d" % MolCount)
MiscUtil.PrintInfo("Number of valid molecules: %d" % ValidMolCount)
MiscUtil.PrintInfo("Number of ignored molecules: %d" %
(MolCount - ValidMolCount))
return ValidMols
def CheckPresenceOfValidLigandIDs(ChainsAndLigandsInfo,
SpecifiedChainsAndLigandsInfo):
"""Check presence of valid ligand IDs."""
MiscUtil.PrintInfo("\nSpecified chain IDs: %s" %
(", ".join(SpecifiedChainsAndLigandsInfo["ChainIDs"])))
for ChainID in SpecifiedChainsAndLigandsInfo["ChainIDs"]:
if len(SpecifiedChainsAndLigandsInfo["LigandIDs"][ChainID]):
MiscUtil.PrintInfo(
"Chain ID: %s; Specified LigandIDs: %s" % (ChainID, ", ".join(
SpecifiedChainsAndLigandsInfo["LigandIDs"][ChainID])))
else:
MiscUtil.PrintInfo("Chain IDs: %s; Specified LigandIDs: None" %
(ChainID))
MiscUtil.PrintWarning(
"No valid ligand IDs found for chain ID, %s." % (ChainID))
def CalculatePhiPsiAngles():
"""Calculate phi and psi angles for macromolecules containing amino acids."""
SetupOutputFiles()
WriteColumnLabels()
Infile = OptionsInfo["Infile"]
MolName = OptionsInfo["InfileRoot"]
MiscUtil.PrintInfo("\nCalculating phi and psi torsion angles for input file %s..." % Infile)
# Load infile
pymol.cmd.load(Infile, MolName)
OutDelim = OptionsInfo["OutDelim"]
Precision = OptionsInfo["Precision"]
# Go over specified chain IDs..
for ChainID in OptionsInfo["SpecifiedChainsAndLigandsInfo"]["ChainIDs"]:
# Write out information for combined file...
PhiPsiInfo = PyMOLUtil.GetPhiPsiResiduesInfo(MolName, ChainID, Categorize = True)
OptionsInfo["OutfileResCount"] += len(PhiPsiInfo["ResNums"])
WritePhiPsiInfo(OptionsInfo["OutFH"], MolName, ChainID, PhiPsiInfo, OutDelim, Precision)
# Write out information for category fies...
if OptionsInfo["MultipleOutFiles"]:
PhiPsiInfoList = []
GeneralPhiPsiInfo, GlycinePhiPsiInfo, ProlinePhiPsiInfo, PreProlinePhiPsiInfo = PyMOLUtil.GetPhiPsiCategoriesResiduesInfo(MolName, ChainID)
PhiPsiInfoList.extend([GeneralPhiPsiInfo, GlycinePhiPsiInfo, ProlinePhiPsiInfo, PreProlinePhiPsiInfo])
for Index, Category in enumerate(OptionsInfo["Categories"]):
OptionsInfo["CategoriesResCount"][Category] += len(PhiPsiInfoList[Index]["ResNums"])
WritePhiPsiInfo(OptionsInfo["CategoriesOutFHs"][Category], MolName, ChainID, PhiPsiInfoList[Index], OutDelim, Precision)
# Delete MolName object
pymol.cmd.delete(MolName)
# Close all files...
CloseOutputFiles()
# List number of phi and psi angles in output files...
MiscUtil.PrintInfo("\nNumber of phi and psi angles in output file %s: %d" % (OptionsInfo["Outfile"], OptionsInfo["OutfileResCount"]))
if OptionsInfo["MultipleOutFiles"]:
MiscUtil.PrintInfo("")
for Index, Category in enumerate(OptionsInfo["Categories"]):
MiscUtil.PrintInfo("Number of phi and psi angles in output file %s: %d" % (OptionsInfo["CategoriesOutfiles"][Category], OptionsInfo["CategoriesResCount"][Category]))
def ValidateOptions():
"""Validate option values"""
MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "sdf sd smi txt csv tsv")
MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"], "sdf sd smi")
MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile", Options["--infile"], "-o, --outfile", Options["--outfile"])
MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"], "GraphFrameworks AtomicFrameworks")
MiscUtil.ValidateOptionTextValue("-r, --removeDuplicates", Options["--removeDuplicates"], "yes no")
MiscUtil.ValidateOptionTextValue("-s, --sort", Options["--sort"], "yes no")
MiscUtil.ValidateOptionTextValue("--sortOrder", Options["--sortOrder"], "ascending descending")
MiscUtil.ValidateOptionTextValue("--useChirality", Options["--useChirality"], "yes no")
def CheckOptionTableClassColorValues(OptionName, ColorsList):
"""Check names of table color classes and issue a warning for unknown names."""
TableClassColors = ["thead-dark", "thead-light", "table-primary", "table-success", "table-danger", "table-info", "table-warning", "table-active", "table-secondary", "table-light", "table-dark", "bg-primary", "bg-success", "bg-danger", "bg-info", "bg-warning", "bg-secondary", "bg-dark", "bg-light"]
for Color in ColorsList:
if not Color in TableClassColors:
MiscUtil.PrintWarning("The color class name, %s, specified using option \"%s\" appears to be a unknown name..." % (Color, OptionName))
