def main(): # checks whether program is used correctly check() best_fold_points = 0 # makes user input into the protein class protein = Protein(argv[1]) # checks whether current option is better than all previous ones options = Option(protein.length) field = Field(protein.length, protein.sequence) best_fold = options.options[0] # ### while(not_all_options): # # creates field and fold based on the protein and the current option for option in options.options: if (field.fill_field(protein.sequence, option)): # check wether current fold is the best and remembers it if it is if int(fold_points(field, protein.errorpoint)) > int(best_fold_points): best_fold_points = fold_points(field, protein.errorpoint) best_fold = option field.clear_field(protein.length) field.x_cdn = protein.length - 1 field.y_cdn = protein.length # prints best_fold_points and best_fold and current field print(best_fold_points) print(best_fold) field.fill_field(protein.sequence, best_fold) for line in field.field: print(line)
def best_of_experiments(acids_sequence, n, m, folding=None): """Take a sequence of acids. Give it a certain folding. Try to fold the protein m times to improve this folding. Print the resulting score. Repeat this n times. Return the best result. """ print('Start folding:', folding) best_score = 1 for _ in range(n): protein = Protein(acids_sequence) if folding == 'cube_folding': if not Algorithms.cube_folding(protein, shift='', d3=True): print("failed to get a cube folding as start") continue elif folding == 'random_folding': if not Algorithms.random_folding(protein): print("failed to get a random folding as start") continue start_score = Algorithms.score(protein) if not Algorithms.fold_n_times(m, protein): print("failed to fold n times") end_score = Algorithms.score(protein) if end_score < best_score: best_score = end_score best_result = [acid.copy() for acid in protein.acids] print( 'Start with score:\t{}\t\tEnd with score:\t{}\t\tBest score:\t{}'. format(start_score, end_score, best_score)) protein.acids = best_result return protein
def construct_protein_list(file_name): proteins_list = [] input_data = genfromtxt(file_name, dtype=None, delimiter=';', names=True) for line in input_data: current_protein = Protein(id=b2str(line['pdb']), azole=b2str(line['azole']), azole_group=str(line['azole_group'])) proteins_list.append(current_protein) return proteins_list
def read_pdb(self, pdb): self.clear() chain_id = '-' res_num = None res_insert = ' ' is_last_chain_protein = False for line in open(pdb, 'r').readlines(): if line.startswith("ATOM"): atom = AtomFromPdbLine(line) if not is_last_chain_protein or chain_id != atom.chain_id: protein = Protein() protein.id = atom.chain_id chain_id = protein.id self.append_chain(protein) is_last_chain_protein = True res_num = None if (res_num != atom.res_num) or (res_insert != atom.res_insert): residue = Residue(atom.res_type, atom.chain_id, atom.res_num, atom.res_insert) residue.chain_id = chain_id protein.append_residue_no_renum(residue) res_num = atom.res_num res_insert = atom.res_insert protein.insert_atom(-1, atom) if line.startswith("HETATM"): atom = AtomFromPdbLine(line) if res_num != atom.res_num or chain_id != atom.chain_id: mol = Polymer() residue = Residue(atom.res_type, atom.chain_id, atom.res_num) residue.chain_id = atom.chain_id mol.append_residue_no_renum(residue) mol.id = atom.chain_id self.append_chain(mol) res_num = atom.res_num chain_id = atom.chain_id last_chain_is_polymer = False mol.insert_atom(0, atom) if line.startswith("TER"): chain_id = '-' if line.startswith("ENDMDL"): break
def main(): # checks whether program is used correctly check() # makes user input into the protein class protein = Protein(argv[1]) # folds protein for testing if len(protein.current_option) > 6: protein.current_option[1] = "up" protein.current_option[2] = "up" protein.current_option[3] = "left" protein.current_option[4] = "left" protein.current_option[5] = "down" protein.current_option[6] = "down" # checks whether current option is better than all previous ones options = Option(protein.length) # for option in options: option
def branch_n_bound(p_string, prob_above_avg, prob_below_avg, dimension, matrix_size): ''' This algorithm will fold a protein using a probability based version of the Branch and Bound algorithm. If the probabilities for pruning are set to 1 and 1, this algorithm behaves as a depth-first alhorithm and searches the whole statespace for the best solution. ''' # Set global variables global protein_string, prob_below_average, prob_above_average, length_total, energy_min_all, energy_min_partial prob_below_average = prob_below_avg prob_above_average = prob_above_avg protein_string = p_string length_total = len(protein_string) # Initialize global dictionaries global energy_counter, matrix_sizes, energy_tracker energy_tracker = [{} for i in range(length_total)] energy_counter = {} matrix_sizes = {} # Create a protein object with a specific matrix size protein = Protein(matrix_size, dimension) # Initialize energy variable that keeps the lowest energy for a complete protein energy_min_all = 1 # Initialize energy variable that keeps the lowest energy for a protein of each length energy_min_partial = [0] * length_total # Place first two amino acids protein.place_first_two(protein_string) previous_location = protein.last_acid # Call next_acid function to place a new amino acid next_acid(protein, previous_location) print(energy_tracker) print(energy_counter) print(sum(energy_counter.values())) if protein_min: return protein_min, energy_counter, matrix_sizes else: exit("Error: No protein 'protein_min' to return")
def beamsearch(p_string, width, dimension, matrix_size): ''' Runs a Beam Search algorithm with a predetermined width which determies how many proteins are kept at each new generation. The best conformation, the one that has the lowest energy, is saved and returned along with a dictionary of all energy counts and the minimal matrix sizes for the folded protein. ''' # Set global variables global best_nodes, protein_length, protein_string, energy_counter, proteins, B_width, matrix_sizes, initial_protein protein_string = p_string protein_length = len(protein_string) B_width = width # Create a protein object with a specific matrix size initial_protein = Protein(matrix_size, dimension) # Place the first two amino acids initial_protein.place_first_two(protein_string) previous_location = [initial_protein.last_acid] # Initialize dictionaries energy_counter = {} matrix_sizes = {} # Initialize the proteins dictionary that keeps track of the protein objects proteins = {} for i in range(B_width): proteins[i] = initial_protein # Start the search find_possibilities(previous_location) # Take the top protein as best protein protein_min = proteins[0] energy_min = protein_min.energy if protein_min: return protein_min, energy_counter, matrix_sizes else: exit("Error: No protein 'protein_min' to return")
def dock(): time.sleep(1) return make_response(jsonify({"affinity": -7.5})) data = json.loads(request.data) directory = "proteins/" + str(data['protein']) + "/Structures/" + str( data['structure']) p1 = None for el in os.listdir(directory): extension = None if el.__contains__('.txt') or el.__contains__('.conf'): extension = el # directory for the conf.txt prtdir = directory + "/" + str(extension) # if to get rid of .ds-store and other weird files if extension is not None: p1 = Protein(prtdir) affinity = Setup.dock(p1, str(app.instance_path) + str(data['ligand'])) obj = {"affinity": affinity} return make_response(jsonify(obj))
def csv_loader(path, filename): ''' Args: filename: Name of the file being loaded. obj: Optional value indicating is the .csv being loaded to protein objects. Returns: array: Array of protein objects or values. Raises: ''' df = pd.read_csv(path + filename) array = [] for val in df.values: protein = Protein(val[0], val[1]) if len( protein.get_splitted_ec_number() ) > 0: #this is to take care i.e. 'n2' -numbers, they will have the 'n' removed array.append(protein) return array
def read_uniprot_sequence(): ''' Returns: connection_array: protein_array: ''' file = 'uniprot_sprot.dat' #counter = 0 #temporary for testing, no need to read the whole file yet protein_array = [] ec_array = [] connection_array = [] for record in SwissProt.parse(open(file)): if 'EC=' in record.description: #counter += 1 #sequence is the string of the primary sequence #given by the markers of the residues print(record.sequence) #print(record.accessions) #holds the uniprot ids #description consists of ';' separated parts print(record.description) tokens = record.description.split(';') for token in tokens: if 'EC=' in token: parts = token.split('=') #split header ec_parts = parts[1].split(' ') #split additional content if ec_parts[0] not in ec_array: print('EC: ', ec_parts[0]) #print EC number as a string ec_array.append(ec_parts[0]) connection_array.append( [ec_parts[0], record.accessions[0]]) protein_array.append( Protein(ec_parts[0], record.accessions[0])) #if counter >= 10000: # break return connection_array, protein_array
def setupProtein(proteinToUse, structure): # searching through the proteins directory to find the protein the user wants to dock to for i in os.listdir("proteins"): if i.lower() == proteinToUse.lower(): directory = "proteins/" + i + "/Structures" print("We have found the directory and it is for the protein --> " + i) if directory is None: print("Couldn't find directory") # should return to the API with null or something if the protein files don't exist exit(0) # now searching through and creating protein array for i in os.listdir(directory): extension = None loc = os.listdir(directory + "/" + i) for el in loc: if el.__contains__('.txt') or el.__contains__('.conf'): extension = el # directory for the conf.txt prtdir = directory + "/" + i + "/" + str(extension) # if to get rid of .ds-store and other weird files if extension is not None: p1 = Protein(prtdir, directory + "/" + i + "/", i)
def random_walk(protein_string, N_tries, dimension, matrix_size): ''' Runs a random walk algorithm in which N_tries proteins are randomly created from a string of amino acid types. The best conformation, the one that has the lowest energy, is saved and returned along with a dictionary of all N_tries energy counts and the minimal matrix sizes for the folded protein. ''' # Create a protein object with a specific matrix size protein = Protein(matrix_size, dimension) # Place the first two amino acids protein.place_first_two(protein_string) location = protein.last_acid energy_min = 1 energy_counter = {} matrix_sizes = {} # Try to fold N_tries proteins for i in range(N_tries): # Print an update for every 1000th protein if (i + 1) % 1000 == 0: print(f"{i + 1}th protein folded") # Remove acids until only the first two are left while protein.length > 2: protein.remove_acid(0) # Run the next random walk solution_found, protein = walk(protein, protein_string, location) while not solution_found: while protein.length > 2: protein.remove_acid(0) solution_found, protein = walk(protein, protein_string, location) # When a complete protein has been created, get its energy if solution_found: energy = protein.energy # When its energy is the lowest energy yet, save the protein object if energy < energy_min: energy_min = energy protein_min = copy.deepcopy(protein) print(f"New minimum energy found: {energy_min}") # Add the energy to a dictionary counter energy_counter[energy] = energy_counter.get(energy, 0) + 1 # Determine the smallest matrix size needed for this protein min_matrix_size = protein.smallest_matrix() matrix_sizes[energy] = matrix_sizes.get(energy, {}) matrix_sizes[energy][min_matrix_size] = matrix_sizes[energy].get( min_matrix_size, 0) + 1 if protein_min: return protein_min, energy_counter, matrix_sizes else: exit("Error: No protein 'protein_min' to return")
def __init__(self, trajfile, indexfile, distance_criteria, outputfile, thickness, simplethickness, insertion, printnatoms): """Instanciates a Trajectory object and checks some input the consistency of the input arguments Requires: trajfile indexfile outputfile thickness insertion Ensures: The input arguments are correctly assigned to the attributes, considering the help messages provided to the user """ self._trajfile = trajfile self._indexfile = indexfile self._distance_criteria = distance_criteria if outputfile: self._outputfile = outputfile else: self._outputfile = None self._printnatoms = printnatoms self._thickness = thickness self._simplethickness = simplethickness if thickness and simplethickness: raise IOError( 'Incompatible arguments: simplethickness and thickness.') if thickness: self._thicknessOutput1 = '' self._thicknessOutput2 = '' nargs_thickness = len(thickness) if nargs_thickness < 2: raise IOError('The thickness argument should have at least 2' ' fields (the window size and step)') elif nargs_thickness > 5: raise IOError('The thickness argument should have at most 5 ' 'fields (the window size, step, minimum and ' 'and maximum values)') elif simplethickness: self._thicknessOutput = '' self._insertion = insertion if insertion: self._insertionOutput = '' nargs_insertion = len(insertion) if insertion[0] == 'closest' or \ insertion[0] == 'average': if nargs_insertion == 1: self._insertion_window = insertion[0] else: print 'Warning: Extra arguments have been '\ 'submitted and will be ignored' elif insertion[0] == 'zero': if nargs_insertion == 2: self._insertion_window = insertion[0] elif nargs_insertion == 1: raise IOError( 'Cutoff missing. The center of the ' 'membrane requires the definition of a cutoff ' 'beyond which bulk properties are assumed.') else: print 'Warning: Extra arguments have been '\ 'submitted and will be ignored' else: if nargs_insertion < 2: raise IOError('The insertion argument requires ' 'at least 2 fields (window_size and step)') elif nargs_insertion > 5: raise IOError('The insertion argument should ' 'have at most 5 fields') self._curtime = None self._box = None self._protein = Protein() self._CoI = Protein() self._membrane = Membrane() self.loadIndex() proteinCounter = 0 coiCounter = 0 for i in self._protein.getAtomsNumbers(): proteinCounter += 1 for i in self._CoI.getAtoms(): coiCounter += 1 if self._insertion and coiCounter < 1: raise IOError('The provided index file should have at least one ' 'atom belonging to the Center_of_Interest group') elif self._thickness and proteinCounter < 1: raise IOError('The provided index file should have at least one ' 'atom belonging to the Protein group') top_memb_size = len(self._membrane.getLeafletAtoms('one')) bottom_memb_size = len(self._membrane.getLeafletAtoms('two')) if top_memb_size < 1 or bottom_memb_size < 1: raise IOError('The provided index file should have at least one ' 'atom in both Monolayer1 and ' 'Monolayer2 groups') if not insertion and not (thickness or simplethickness): raise IOError('This script can calculate thickness and insertion ' 'provided you use the -thickness or -insertion ' 'arguments respectively')
#!/usr/bin/env python import sys import requests as sender from flask import Flask, abort, request import json import threading from protein import Protein # Globals app = Flask(__name__) p = Protein( "NC_000852,NC_007346,NC_008724,NC_009899,NC_014637,NC_020104,NC_023423,NC_023640,NC_023719,NC_027867" ) # Design # ------ # bio-engine (port 7000) web-app (ports 8000-) # | | # | (open port) # | <---- POST (sequence) -------- | # | ----- PUT (found protein) ---> | # | ----- PUT (found protein) ---> | # | ----- DELETE (finished) -----> | # | (close port) def match_provider(port, sequence): protein_codes = p.get_code_list()
for atom2 in atom2atom[atom1]: res2 = atom2.residue if res2 != res1: try: res2res[res1].add(res2) except KeyError: res2res[res1] = set([res2]) ret = sum([len(res2res[x]) for x in res2res.keys()])/2, \ avg_coord_num(res2res) # print 'DEBUG: csuAvgCoordNum end. Returning '+str(ret) return ret #def picContactNumber(protein): # raise NotImplementedError if __name__ == "__main__": import sys if len(sys.argv) == 1 or '-h' in sys.argv: print "Usage: python coordNum.py pdbFileName1 [pdbFileName2 ...]" else: #print "Protein name\tContact Number (Marek)\tAvg Coord Number \ # (Marek)\tContact Number (CSU)\tAvg Coord Number (CSU)" for f in sys.argv[1:]: p = Protein(f) name = f.split('/')[-2].split('.')[0] marek = marek_avg_coord_num(p) csu = csu_avg_coord_num(p, total_layers = 14) print '%(n)5s %(ncm)3d %(cnm)6.3f %(ncc)3d %(cnc)6.3f' % \ {'n': name, 'ncm': marek[0], 'cnm': marek[1], \ 'ncc': csu[0], 'cnc': csu[1]}
def Loadpdb(pdb=None, hetatm=True, verbose=False): try: assert (pdb != None) #Check if filehandle to PDB file is passed except AssertionError: sys.exit( "**No filehandle passed**. Pass a filehandle (to a pdb file) as an argument to Loadpdb. " ) AtomNumber = 0 #Keeps track of atom indices (assigned in the order atoms listed i input file) mol_data = { } #Key: molid; Keep track of different molecules (different chains or molecule type) in input structure check_het = False #To keep track of new Hetero residue first_res = True #To identify molecule type of every molecule in input structure and accordingly define Molecule object. Prev_res = 0 # to keep track of residue change in HETATM section; a new Molecule object is assigned for every residue. Prev_chain = 'a' # to keep track of chain change in HETATM section '''Load the PDB structure file''' for line in pdb: if line[0:4] == "ATOM" and line[12:16].upper().strip() not in ["OXT"]: AtomNumber += 1 AtomName, ResName, Chain, ResNo, CordX, CordY, CordZ, Occ, Bfac = Pdbcordsec( line) atm = Atom(AtomName, AtomNumber, ResName, Chain, ResNo, CordX, CordY, CordZ) if first_res: #Initialize mol for new chain or molecule if ResName.lower() in Mol_types['protein']: mol = Protein() elif ResName.lower() in Mol_types['ligand']: mol = Ligand() else: print "*** Unrecognized residue name: " + ResName + " ***.\n Cannot initialize Molecule object." sys.exit( "In file configstruc.py: Add missing residue name(" + ResName + ") to appropriate molecule in Mol_types") first_res = False mol.AddToResidue(atom=atm, occ=Occ, bfac=Bfac) mol.atmidx.append(AtomNumber) elif line[0:3] == "TER": mol_data[Molecule.molid] = deepcopy( mol) #copy mol object into dictionary first_res = True # mol object will be initialized to molecule type of next molecule elif line[0:6] == "HETATM" and hetatm == True: AtomNumber += 1 AtomName, ResName, Chain, ResNo, CordX, CordY, CordZ, Occ, Bfac = Pdbcordsec( line) atm = Atom(AtomName, AtomNumber, ResName, Chain, ResNo, CordX, CordY, CordZ) #Check for new molecule if ( ResNo != Prev_res or Prev_chain != Chain ) and check_het == True: #For first HETATM check_het is always False mol_data[Molecule.molid] = deepcopy( mol) #copy mol object into dictionary first_res = True #Initialize mol for new chain or molecule if first_res: if ResName.lower() in Mol_types['ligand']: mol = Ligand() else: print "*** Unrecognized residue name: " + ResName + " ***.\n Cannot initialize Ligand object." sys.exit( "In file configstruc.py: Add missing residue name (" + ResName + ") to ligand molecule in Mol_types") first_res = False mol.AddToResidue(atom=atm, occ=Occ, bfac=Bfac) mol.atmidx.append(AtomNumber) if Prev_res == 0: check_het = True Prev_res = ResNo Prev_chain = Chain if hetatm: #If HETATM record was added; append the last hetero residue object to mol_data mol_data[Molecule.molid] = deepcopy( mol) #copy mol object into dictionary if verbose: print "Number of molecules in input file: ", len(mol_data), "\n" #Update mol_data[molid].nor, mol_data[molid].resids, and check for chain breaks in non-ligand molecules for key in sorted(mol_data): if verbose: print "Molid:", key, "Molecule_Type:", mol_data[key].molecule_type( ) if mol_data[key].molecule_type().lower() != 'ligand': mol_data[key].resids = sorted(mol_data[key].residue) mol_data[key].nor = len(mol_data[key].resids) #Check for chain breaks in protein resids_diff = numpy.array(mol_data[key].resids[1:]) - numpy.array( mol_data[key].resids[:-1]) if mol_data[key].nor != (numpy.sum(resids_diff) + 1): break_indices = numpy.where(resids_diff > 1) print "Chain break encountered in molecule", key, "at residue positions: " for res in break_indices[0]: print mol_data[key].resids[res], print "\n" return mol_data
parser.add_argument('--f', type=int, default=10, help='parameter for the simplification of points mesh') parser.add_argument('--T', type=float, default=0.9, help='ligandability threshold') parser.add_argument('--batch', type=int, default=32, help='batch size') parser.add_argument('--voxel_size', type=float, default=1.0, help='size of voxel in angstrom') parser.add_argument('--protonate', action='store_true', help='whether to protonate or not the input protein') parser.add_argument('--expand', action='store_true', help='whether to expand on residue level the extracted binding sites') parser.add_argument('--discard_points', action='store_true', help='whether to output or not the computed surface points') return parser.parse_args() args = parse_args() if not os.path.exists(args.prot_file): raise IOError('%s does not exist.' % args.prot_file) if not os.path.exists(args.model_path): raise IOError('%s does not exist.' % args.model_path) if not os.path.exists(args.output): os.makedirs(args.output) prot = Protein(args.prot_file,args.protonate,args.expand,args.f,args.output, args.discard_points) nn = Network(args.model_path,args.model,args.voxel_size) lig_scores = nn.get_lig_scores(prot,args.batch) extractor = Bsite_extractor(args.T) extractor.extract_bsites(prot,lig_scores)
else: dir_path = sys.argv[1] if not os.path.exists(dir_path): raise RuntimeError("Folder path does not exist") proteins = [] for filename in os.listdir(dir_path): if filename.endswith(".pdb"): protein_name = filename[0:4] protein_data = open(os.path.join(dir_path, filename), 'r', encoding="utf8", errors='ignore') proteins.append(Protein(protein_name, protein_data)) protein_data.close() # ----------------------------------------------------------------------------------------------------------------- # DECLARATION CODES START HERE # ----------------------------------------------------------------------------------------------------------------- count = 1 count_mse = 0 probable_h_bond = [] excluded_h_bond = [] pdb = [] b_factors = [] control_b_factors = [] distances1 = [] angles1 = []
# -*- coding: utf-8 -*- """ Created on Wed Feb 28 17:00:23 2018 @author: HOS """ from numpy import * from protein import Protein from grid import Grid import matplotlib.pyplot as plt N = 18 d = 15 Prt = Protein(d, N) Grid = Grid(d, N, Prt) #folding for i in range(30): Prt.tryRotate() Grid.update() #Grid.easyPlot() Grid.showOff()
def dock(self): #setup tables with distances, errors and weights expDistances = [] expErrors = [] weights = [] constraintNames = [] for restraint in self.restraints: constraintNames.append( "%s-%s" % (restraint["anchorAname"], restraint["anchorBname"])) expDistances.append(restraint["distance"]) expErrors.append(restraint["width"]) weights.append(restraint["weight"]) expDistances = numpy.array(expDistances) expErrors = numpy.array(expErrors) weights = numpy.array(weights) # setup Proteins anchorAcoords = [] for restraint in self.restraints: anchorAcoords.append(restraint["anchorAcoord"]) proteinAname = self.restraints[0]["proteinAname"] anchorAcalphas = self.restraints[0]["proteinAcalpha"] proteinA = Protein(anchorAcoords, anchorAcalphas, proteinAname) anchorBcoords = [] for restraint in self.restraints: anchorBcoords.append(restraint["anchorBcoord"]) proteinBname = self.restraints[0]["proteinBname"] anchorBcalphas = self.restraints[0]["proteinBcalpha"] proteinB = Protein(anchorBcoords, anchorBcalphas, proteinBname) # move both to origin proteinA.moveToOrigin(proteinA.labelAtomsCog) proteinB.moveToOrigin(proteinB.labelAtomsCog) ####### # evolve ####### zeroChromosome = Chromosome("None") zeroChromosome.genes = numpy.array([0, 0, 0, 0, 0, 0]) # setup populations print "setting up populations..." populations = [] for i in range(0, self.numberOfPopulations): if self.symmetry == "C2": population = Population(self.numberOfChromosomes, "C2") elif self.symmetry == "None": population = Population(self.numberOfChromosomes, "None") population.name = "%i" % (i + 1) populations.append(population) # put them into an environment and evolve environment1 = Environment(populations, proteinA, proteinB, expDistances, expErrors, weights, False, False, False) environment1.constraintNames = constraintNames #environment1.applySelectionPressure() #for population in environment1.populations: # population.log += population.chromosomes[0].printChromosomeWithoutClashes() self.processes = [] resultQueue = multiprocessing.Queue() progressQueue = multiprocessing.Queue() numberOfProcesses = len(environment1.populations) for idx, population in enumerate(environment1.populations): environment = copy.deepcopy(environment1) p = multiprocessing.Process(target=self.worker1, args=(environment, idx, resultQueue, progressQueue)) p.start() self.processes.append(p) cycles = 0 maxCycles = numberOfProcesses * (self.numberOfGenerations + self.numberOfRigidBodyCycles) #while True: # cycles += progressQueue.get() # progress = cycles/(numberOfProcesses*(self.numberOfGenerations+self.numberOfRigidBodyCycles)) # #send message to main thread # wx.CallAfter(pub.sendMessage, "docking.update", progress=progress) # if cycles >= maxCycles: # break resultsList = [resultQueue.get() for p in self.processes] for p in self.processes: p.join() environment1.populations = resultsList # create solutions print "" print "Solutions:" nonClashingSolution = 1 clashingSolution = 1 for population in environment1.populations: #createPseudoatom(self.labelPositionsProteinB, "tmpSolution-labels", 1) tmpProtein = Protein(proteinB.originalLabelAtoms, proteinB.originalLabelAtoms, "tmpSolution-labels") solution = population.chromosomes[0] # print solution.printChromosomeWithClashes() if solution.clashes <= 5: nameOfSolution = "%s-%i_sol-%i" % (self.objectPrefix, self.dockingRunNumber, nonClashingSolution) solution.name = nameOfSolution proteinB.moveInPymol(nameOfSolution, solution, 1) #tmpProtein.moveInPymol("%s-labels" % nameOfSolution, solution, 1) cmd.translate(list(proteinA.labelAtomsCog.reshape(-1, )), nameOfSolution, 1, 0, None) #cmd.translate(list(proteinA.labelAtomsCog.reshape(-1,)), "%s-labels" % nameOfSolution, 1, 0, None) nonClashingSolution += 1 elif solution.clashes > 5: nameOfSolution = "%s-%i_clash-%i" % ( self.objectPrefix, self.dockingRunNumber, clashingSolution) solution.name = nameOfSolution proteinB.moveInPymol(nameOfSolution, solution, 1) #tmpProtein.moveInPymol("%s-labels" % nameOfSolution, solution, 1) cmd.translate(list(proteinA.labelAtomsCog.reshape(-1, )), nameOfSolution, 1, 0, None) #cmd.translate(list(proteinA.labelAtomsCog.reshape(-1,)), "%s-labels" % nameOfSolution, 1, 0, None) clashingSolution += 1 cmd.group("%s-%i" % (self.objectPrefix, self.dockingRunNumber), "%s-%i*" % (self.objectPrefix, self.dockingRunNumber)) #cmd.set_view(myView) return environment1, self.settings
args = parse_args() if not os.path.exists(args.dataset_file): raise IOError('%s does not exist.' % args.dataset_file) if not os.path.exists(args.protein_path): raise IOError('%s does not exist.' % args.protein_path) if not os.path.exists(args.model_path): raise IOError('%s does not exist.' % args.model_path) if not os.path.exists(args.output): os.makedirs(args.output) with open(args.dataset_file, 'r') as f: lines = f.readlines() protein_names = [line[:-1] for line in lines] for prot in protein_names: protein = Protein(os.path.join(args.protein_path, prot + '.pdb'), args.protonate, args.expand, args.f, args.output, args.discard_points) nn = Network(args.model_path, args.model, args.voxel_size) lig_scores = nn.get_lig_scores(protein, args.batch) extractor = Bsite_extractor(args.T) extractor.extract_bsites(protein, lig_scores)
def dock(self): #setup tables with distances, errors and weights expDistances = [] expErrors = [] weights = [] constraintNames = [] for restraint in self.restraints: constraintNames.append("%s-%s"%(restraint["anchorAname"], restraint["anchorBname"])) expDistances.append(restraint["distance"]) expErrors.append(restraint["width"]) weights.append(restraint["weight"]) expDistances = numpy.array(expDistances) expErrors = numpy.array(expErrors) weights = numpy.array(weights) # setup Proteins anchorAcoords = [] for restraint in self.restraints: anchorAcoords.append(restraint["anchorAcoord"]) proteinAname = self.restraints[0]["proteinAname"] anchorAcalphas = self.restraints[0]["proteinAcalpha"] proteinA = Protein(anchorAcoords, anchorAcalphas, proteinAname) anchorBcoords = [] for restraint in self.restraints: anchorBcoords.append(restraint["anchorBcoord"]) proteinBname = self.restraints[0]["proteinBname"] anchorBcalphas = self.restraints[0]["proteinBcalpha"] proteinB = Protein(anchorBcoords, anchorBcalphas, proteinBname) # move both to origin proteinA.moveToOrigin(proteinA.labelAtomsCog) proteinB.moveToOrigin(proteinB.labelAtomsCog) # setup populations print "Starting..." populations = [] for i in range(0, self.numberOfPopulations): if self.symmetry != "None": population = Population(self.numberOfChromosomes, self.symmetry) elif self.symmetry == "None": population = Population(self.numberOfChromosomes, "None") population.name = "%i" % (i + 1) populations.append(population) # put them into an environment and evolve environment1 = Environment(populations, proteinA, proteinB, expDistances, expErrors, weights, self.scoreClashes) environment1.constraintNames = constraintNames self.processes = [] resultQueue = multiprocessing.Queue() progressQueue = multiprocessing.Queue() numberOfProcesses = len(environment1.populations) if os.name != "nt": for idx, population in enumerate(environment1.populations): environment = copy.deepcopy(environment1) p = multiprocessing.Process(target = self.worker, args = (environment, idx, resultQueue, progressQueue)) p.start() self.processes.append(p) cycles = 0 maxCycles = numberOfProcesses * (self.numberOfGenerations + self.numberOfRigidBodyCycles) while True: cycles += progressQueue.get() progress = cycles/(numberOfProcesses*(self.numberOfGenerations+self.numberOfRigidBodyCycles)) #send message to main thread wx.CallAfter(pub.sendMessage, "docking.update", progress=progress) if cycles >= maxCycles: break resultsList = [resultQueue.get() for p in self.processes] for p in self.processes: p.join() environment1.populations = resultsList else: print "Windows... Using 1 core." self.worker(environment1, -1, resultQueue, progressQueue) self.abort = False # name solutions nonClashingSolution = 1 clashingSolution = 1 for population in environment1.populations: solution = population.chromosomes[0] if solution.clashes <= 5: nameOfSolution = "%s-%i_sol-%i" % (self.objectPrefix, self.dockingRunNumber, nonClashingSolution) solution.name = nameOfSolution nonClashingSolution += 1 elif solution.clashes > 5: nameOfSolution = "%s-%i_clash-%i" % (self.objectPrefix, self.dockingRunNumber, clashingSolution) solution.name = nameOfSolution clashingSolution += 1 return environment1, self.settings
def greedy(protein_string, look_aheads, N_tries, dimension, matrix_size): ''' Runs a Greedy look-ahead algorithm in which N_tries proteins are randomly created from a string of amino acid types. The best conformation, the one that has the lowest energy, is saved and returned along with a dictionary of all energy counts and the minimal matrix sizes for the folded protein. ''' # Create a protein object with a specific matrix size protein = Protein(matrix_size, dimension) # Place the first two amino acids protein.place_first_two(protein_string) location = protein.last_acid energy_min = 1 energy_counter = {} matrix_sizes = {} # Try to fold N_tries protein greedy like for i in range(N_tries): if (i + 1) % 1 == 0: print(f"{i + 1}th protein folded") # Remove acids until only the first two are left while protein.length > 2: protein.remove_acid(0) solution_found, protein = greedy_fold(protein, protein_string, look_aheads) while not solution_found: while protein.length > 2: protein.remove_acid(0) solution_found, protein = greedy_fold(protein, protein_string, look_aheads) # When a protein is created save its energy if solution_found: energy = protein.energy # When its energy is lower than lowest energy found, save the protein if energy < energy_min: energy_min = energy protein_min = copy.deepcopy(protein) print(f"New minimum energy found: {energy_min}") # Update the dictonary for histogram of solutions energy_counter[energy] = energy_counter.get(energy, 0) + 1 # Determine the smallest matrix size needed for this protein min_matrix_size = protein.smallest_matrix() matrix_sizes[energy] = matrix_sizes.get(energy, {}) matrix_sizes[energy][min_matrix_size] = matrix_sizes[energy].get( min_matrix_size, 0) + 1 if protein_min: return protein_min, energy_counter, matrix_sizes else: exit("Error: No protein 'protein_min' to return")
def Loadpdb(pdb=None, hetatm= True, verbose=False): try: assert(pdb != None) #Check if filehandle to PDB file is passed except AssertionError: sys.exit("**No filehandle passed**. Pass a filehandle (to a pdb file) as an argument to Loadpdb.") AtomNumber=0 #Keeps track of atom indices (assigned in the order atoms listed in input file) mol_data={} #Key: molid; Value: Molecule_Type Object; Keep track of different molecules (different chains or molecule type) in input structure first_res =True #To identify molecule type of every molecule in input structure and accordingly define Molecule object. Prev_res=0 # to keep track of residue change Prev_chain='aa' # to keep track of chain change in HETATM section atmTohet = True #To determine transition from ATOM to HETATM record frame_tag = '' # To keep track of multi-frame entry (multiple entry for same molecule type with same chain id) '''Load the PDB structure file''' for line in pdb: if line[0:4]=="ATOM" and line[12:16].upper().strip() not in ["OXT"]: AtomNumber+=1 AtomName, ResName, Chain, ResNo, CordX, CordY, CordZ, Occ, Bfac = Pdbcordsec(line) atm = Atom(AtomName, AtomNumber, ResName, Chain, ResNo, CordX, CordY, CordZ) #Check for unrecognized residue and new molecule if not first_res: if ResName.lower() not in Mol_types['protein'] + Mol_types['lipid'] + Mol_types['ligand']: print "*** Unrecognized residue name: "+ ResName+ " ***.\nAdded %s as Ligand." % ResName sys.exit("In file configstruc.py: Add missing residue name("+ ResName+ ") to appropriate molecule in Mol_types") if ResNo != Prev_res or (Prev_chain != Chain and mol.molecule_type().lower()=='ligand'): if mol.molecule_type().lower()=='ligand': mol_data[Molecule.molid] = deepcopy(mol) #copy mol object into dictionary first_res = True elif Prev_chain != Chain or ResName.lower() not in Mol_types[mol.molecule_type().lower()]: #Either Chain is different or New residue doesn't belong to current molecule type mol_data[Molecule.molid] = deepcopy(mol) #copy mol object into dictionary first_res = True elif frame_tag.lower() in ['endmdl', 'ter', 'end'] and Prev_chain == Chain: #Different molecule (of same molecule type) with same chain id; as in trajectory frames mol_data[Molecule.molid] = deepcopy(mol) #copy mol object into dictionary first_res = True if first_res: #Initialize mol for new chain or molecule if ResName.lower() in Mol_types['protein']: mol = Protein() elif ResName.lower() in Mol_types['lipid']: mol = Lipid() elif ResName.lower() in Mol_types['ligand']: mol = Ligand() else: print "*** Unrecognized residue name: "+ ResName+ " ***.\n Cannot initialize Molecule object." sys.exit("In file configstruc.py: Add missing residue name("+ ResName+ ") to appropriate molecule in Mol_types") first_res = False frame_tag = '' mol.AddToResidue(atom=atm, occ=Occ, bfac=Bfac) mol.atmidx.append(AtomNumber) Prev_res= ResNo Prev_chain=Chain elif line[0:6]=="HETATM" and hetatm == True: if atmTohet: mol_data[Molecule.molid] = deepcopy(mol) #copy mol object into dictionary first_res = True atmTohet = False AtomNumber+=1 AtomName, ResName, Chain, ResNo, CordX, CordY, CordZ, Occ, Bfac = Pdbcordsec(line) atm = Atom(AtomName, AtomNumber, ResName, Chain, ResNo, CordX, CordY, CordZ) #Check for new ligand molecule if not first_res and (ResNo != Prev_res or Prev_chain != Chain): mol_data[Molecule.molid] = deepcopy(mol) #copy mol object into dictionary first_res = True #Initialize mol for new chain or molecule if first_res: if ResName.lower() in Mol_types['ligand']: mol = Ligand() else: print "*** Unrecognized residue name: "+ ResName+ " ***.\n Cannot initialize Ligand object." sys.exit("In file configstruc.py: Add missing residue name ("+ ResName+ ") to ligand molecule in Mol_types") first_res = False mol.AddToResidue(atom=atm, occ=Occ, bfac=Bfac) mol.atmidx.append(AtomNumber) Prev_res= ResNo Prev_chain=Chain elif line[0:3].lower() in ["ter", "end"] or line[0:6].lower() == "endmdl": frame_tag = line[0:3] #append the last mol object to mol_data mol_data[Molecule.molid] = deepcopy(mol) #copy mol object into dictionary if verbose: print "Number of molecules in input file: ", len(mol_data), "\n" #Update mol_data[molid].nor, mol_data[molid].resids, and check for chain breaks in non-ligand molecules for key in sorted(mol_data): if verbose: print "Molid:", key,"Molecule_Type:",mol_data[key].molecule_type() mol_data[key].resids = sorted(mol_data[key].residue) mol_data[key].nor = len(mol_data[key].resids) if mol_data[key].molecule_type().lower() != 'ligand': #Check for chain breaks in non-ligand molecule resids_diff=numpy.array(mol_data[key].resids[1:]) - numpy.array(mol_data[key].resids[:-1]) if mol_data[key].nor != (numpy.sum(resids_diff)+1): break_indices = numpy.where(resids_diff > 1) print "Chain break encountered in molecule",key, "at residue positions: " for res in break_indices[0]: print mol_data[key].resids[res], print "\n" mol_data[key].chain_break = True return mol_data
from protein import Protein, trypsin from measurement import read_mgf import pandas as pd from multiprocessing import Pool OVA = "GSIGAASMEFCFDVFKELKVHHANENIFYCPIAIMSALAMVYLGAKDSTRTQINKVVRFDKLPGFGDSIEAQCGTSVNVHSSLRDILNQITKPNDVYSFSLASRLYAEERYPILPEYLQCVKELYRGGLEPINFQTAADQARELINSWVESQTNGIIRNVLQPSSVDSQTAMVLVNAIVFKGLWEKAFKDEDTQAMPFRVTEQESKPVQMMYQIGLFRVASMASEKMKILELPFASGTMSMLVLLPDEVSGLEQLESIINFEKLTEWTSSNVMEERKIKVYLPRMKMEEKYNLTSVLMAMGITDVFSSSANLSGISSAESLKISQAVHAAHAEINEAGREVVGSAEAGVDAASVSEEFRADHPFLFCIKHIATNAVLFFGRCVSP" LYS = "KVFGRCELAAAMKRHGLDNYRGYSLGNWVCAAKFESNFNTQATNRNTDGSTDYGILQINSRWWCNDGRTPGSRNLCNIPCSALLSSDITASVNCAKKIVSDGNGMNAWVAWRNRCKGTDVQAWIRGCRL" BSA = "DTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFDEHVKLVNELTEFAKTCVADESHAGCEKSLHTLFGDELCKVASLRETYGDMADCCEKQEPERNECFLSHKDDSPDLPKLKPDPNTLCDEFKADEKKFWGKYLYEIARRHPYFYAPELLYYANKYNGVFQECCQAEDKGACLLPKIETMREKVLTSSARQRLRCASIQKFGERALKAWSVARLSQKFPKAEFVEVTKLVTDLTKVHKECCHGDLLECADDRADLAKYICDNQDTISSKLKECCDKPLLEKSHCIAEVEKDAIPENLPPLTADFAEDKDVCKNYQEAKDAFLGSFLYEYSRRHPEYAVSVLLRLAKEYEATLEECCAKDDPHACYSTVFDKLKHLVDEPQNLIKQNCDQFEKLGEYGFQNALIVRYTRKVPQVSTPTLVEVSRSLGKVGTRCCTKPESERMPCTEDYLSLILNRLCVLHEKTPVSEKVTKCCTESLVNRRPCFSALTPDETYVPKAFDEKLFTFHADICTLPDTEKQIKKQTALVELLKHKPKATEEQLKTVMENFVAFVDKCCAADDKEACFAVEGPKLVVSTQTALA" # LYS můstky # VFGRCELAAA + WIRGCRL # GNWVCAAKFE + WRNRCKGTDV # SRWWCNDGRT + CNIPCSALLS # SRNLCNIPCS + ASVNCAKKIV protein = Protein(LYS) peptides = list(protein.digest(trypsin)) measurements = list(read_mgf("../data/mgf/190318_LYS_RAT_50x_05.mgf")) # Protein Pilot # Paragon # AA tagy ze spektra soft_err_ppm = 50 hard_err_ppm = 10 result = [] peps_with_threshold = [(pep, (hard_err_ppm / 1e6) * pep.total_mz) for pep in peptides] for i, m in enumerate(measurements): if i % 500 == 0: print(f"Done: {i}")
import pickle from lxml import etree from protein import Protein # Goes through the Swissprot database xml and parses all the relevant data prefix = "{http://uniprot.org/uniprot}" proteins = [] for event, element in etree.iterparse("in/uniprot_sprot.xml", tag=prefix + "entry"): prot = Protein() nonEukaryotProtein = False for child in element.getchildren(): if nonEukaryotProtein: break # Gets Uniprot ID # The xml lists old IDs as well, only the first one is relevant and the rest are ignored if child.tag == prefix + "accession": if not prot.uniprot_id: prot.uniprot_id.add(child.text) # Gets names elif child.tag.endswith("protein"): for entry in child.getchildren(): if entry.tag == prefix + "recommendedName" or entry.tag == prefix + "alternativeName":
def main(argv=None): # IGNORE:C0111 '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Created by Kyle Monson on %s. Copyright 2015 Pacific Northwest National Laboratory. All rights reserved. Licensed under the Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % (program_shortdesc, str(__date__)) try: # Setup argument parser parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) parser.add_argument("-v", "--verbose", dest="verbose", action="count", help="set verbosity level [default: %(default)s]") parser.add_argument('-V', '--version', action='version', version=program_version_message) parser.add_argument(dest="input", help="path to input folder", metavar="input_path") parser.add_argument(dest="output", help="paths to output folder", metavar="output_path") parser.add_argument( "--test", action='store_true', default=False, help="Run basic sanity tests using selected input.") parser.add_argument("--dump-state", action='store_true', default=False, help="Dump state to state.txt in output.") # Process arguments args = parser.parse_args() input_path = args.input output_path = args.output verbose = args.verbose dump_state = args.dump_state if verbose > 0: print("Verbose mode on") try: if verbose > 0: print("Creating output directory") os.makedirs(output_path) except os.error: if verbose > 0: print("Output directory already exists.") interaction_filepath = os.path.join(input_path, INTERACTION_BASE_FILENAME) background_filepath = os.path.join(input_path, BACKGROUND_BASE_FILENAME) desolvation_filepath = os.path.join(input_path, DESOLVATION_BASE_FILENAME) with open(interaction_filepath) as interaction_file, \ open(background_filepath) as background_file, \ open(desolvation_filepath) as desolvation_file: protein = Protein(interaction_file, desolvation_file, background_file) state_file = None if dump_state: state_file = open(os.path.join(output_path, "state.txt"), 'w') start = datetime.now() curves = get_titration_curves(protein.protein_complex, state_file) end = datetime.now() delta = end - start delta_seconds = delta.total_seconds() with open(os.path.join(output_path, "timing.txt"), 'a') as timing_file: timing_file.write(str(delta_seconds) + '\n') if dump_state: state_file.close() create_output(output_path, curves) #pprint(dict(curves)) if args.test: import tests #tests.test_normalize(protein) #tests.test_stuff(protein) #tests.test_adding_ph(protein) return 0 except KeyboardInterrupt, e: ### handle keyboard interrupt ### if DEBUG: raise (e) return 0