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))