def read_mmcif_to_biopython(path): """Read in mmcif protein structure and report its Biopython structure Args: path (str): Path to the mmcif file. Raises: ValueError: In case _atom_site table is not present in the file. Returns: Bio.PDB.Structure.Structure: BioPython PDB structure """ if not os.path.isfile(path): raise IOError("File {} not found".format(path)) structure_builder = StructureBuilder() parsed = MMCIF2Dict().parse(path) file_name = os.path.basename(path).split(".")[0] structure_id = next((x for x in parsed), file_name).lower() structure_builder.init_structure(structure_id) try: perceived_atom_site = list(parsed.values())[0]["_atom_site"] _atom_site = _trim_models(perceived_atom_site) _parse_atom_site_biopython(_atom_site, structure_builder) except KeyError: raise ValueError("The cif file does not contain _atom_site record") return structure_builder.get_structure()
def pdb_writer(graph, results, dir_name="templates"): PDB_CODE = graph.protein_name structure = graph.structure path = "%s/%s/" % (dir_name, PDB_CODE) if len(results) > 0: if not os.path.exists(path): os.makedirs(path) else: print 'No results' return top = min(NUM_OF_RESULTS_TO_SAVE, len(results)) i = 0 for key, value in results[:top]: # TODO - save as different chains sb = StructureBuilder() sb.init_structure(PDB_CODE) sb.init_model(0) sb.init_chain('X') for node_id in key[0]: for res in graph.nodes[node_id].residues: sb.init_seg(res.get_segid()) sb.init_residue(res.get_resname(), res.get_id()[0], res.get_id()[1], res.get_id()[2]) for atom in res: sb.init_atom(atom.get_name(), atom.get_coord(), atom.get_bfactor(), atom.get_occupancy(), atom.get_altloc(), atom.get_fullname()) sb.init_chain('Y') for node_id in key[1]: for res in graph.nodes[node_id].residues: sb.init_residue(res.get_resname(), res.get_id()[0], res.get_id()[1], res.get_id()[2]) for atom in res: sb.init_atom(atom.get_name(), atom.get_coord(), atom.get_bfactor(), atom.get_occupancy(), atom.get_altloc(), atom.get_fullname()) filename = path + "interface%d.pdb" % (i) io = PDBIO() io.set_structure(sb.get_structure()) io.save(filename) i += 1 return 1
def residues_to_struct(name_residues_list, structID): """ Build a structure from a list of (chain name, residues) - each as a chain. """ builder = StructureBuilder() builder.init_structure(structID) builder.init_model(0) for (name, residues) in name_residues_list: builder.init_chain(name) for res in residues: builder.chain.add(res) return builder.get_structure()
def coarse_grain(self, cg_type="CA_TRACE"): """ Reduces the protein structure complexity to a few (pseudo-)atoms per residue. Parameters: - cg_type: CA_TRACE (Ca-only) [Default] ENCAD_3P (CA, O, SC Beads) MARTINI (CA, O, SC Beads) Returns a new structure object. """ # Import CG Types import CG_Models CG_Library = { "CA_TRACE": CG_Models.CA_TRACE, "ENCAD_3P": CG_Models.ENCAD_3P, "MARTINI": CG_Models.MARTINI } CG_Method = CG_Library[cg_type] # Creates a brand new structure object from Bio.PDB.StructureBuilder import StructureBuilder structure_builder = StructureBuilder() cg_id = "CG_" + self.id structure_builder.init_structure(cg_id) structure_builder.init_seg(' ') # Empty SEGID for model in self: structure_builder.init_model(model.id) for chain in model: structure_builder.init_chain(chain.id) cur_chain = structure_builder.chain for residue in chain: cg_residue = CG_Method(residue) cur_chain.add(cg_residue) cg_structure = structure_builder.get_structure() return cg_structure
class XBGFParser: def __init__(self, PERMISSIVE=1, structure_builder=None): if structure_builder != None: self.structure_builder = structure_builder else: self.structure_builder = StructureBuilder() self.PERMISSIVE = PERMISSIVE # public interface def parse(self, id, file): self.structure_builder.init_structure(id) if isinstance(file, basestring): file=open(file) self.charges = dict() self.chain_suffix = 0 self._parse(file.readlines()) self.structure = self.structure_builder.get_structure() return self._process_structure() # private methods def _parse(self, lines): self.structure_builder.init_model(0) self.structure_builder.init_seg("") self.current_chain_id = None self.current_residue_id = None self.current_resname = None for i in range(0, len(lines)): self.line_counter = i + 1 self.structure_builder.set_line_counter(self.line_counter) line = lines[i] if line[0:6] == 'ATOM ': self._update_atom(line) def _update_chain(self, line): chain_id = self._extract_chain(line) if self.current_chain_id != chain_id: try: self.structure_builder.init_chain(chain_id) self.current_chain_id = chain_id self.current_residue_id = None self.current_resname = None except PDBConstructionException, message: self._handle_PDB_exception(message)
class XBGFParser: def __init__(self, PERMISSIVE=1, structure_builder=None): if structure_builder != None: self.structure_builder = structure_builder else: self.structure_builder = StructureBuilder() self.PERMISSIVE = PERMISSIVE # public interface def parse(self, id, file): self.structure_builder.init_structure(id) if isinstance(file, basestring): file = open(file) self.charges = dict() self.chain_suffix = 0 self._parse(file.readlines()) self.structure = self.structure_builder.get_structure() return self._process_structure() # private methods def _parse(self, lines): self.structure_builder.init_model(0) self.structure_builder.init_seg("") self.current_chain_id = None self.current_residue_id = None self.current_resname = None for i in range(0, len(lines)): self.line_counter = i + 1 self.structure_builder.set_line_counter(self.line_counter) line = lines[i] if line[0:6] == 'ATOM ': self._update_atom(line) def _update_chain(self, line): chain_id = self._extract_chain(line) if self.current_chain_id != chain_id: try: self.structure_builder.init_chain(chain_id) self.current_chain_id = chain_id self.current_residue_id = None self.current_resname = None except PDBConstructionException, message: self._handle_PDB_exception(message)
class FastMMCIFParser(object): """Parse an MMCIF file and return a Structure object.""" def __init__(self, structure_builder=None, QUIET=False): """Create a FastMMCIFParser object. The mmCIF parser calls a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the parser object itself, but if the user provides his/her own StructureBuilder object, the latter is used instead. The main difference between this class and the regular MMCIFParser is that only 'ATOM' and 'HETATM' lines are parsed here. Use if you are interested only in coordinate information. Arguments: - structure_builder - an optional user implemented StructureBuilder class. - QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be suppressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the mmCIF file! """ if structure_builder is not None: self._structure_builder = structure_builder else: self._structure_builder = StructureBuilder() self.line_counter = 0 self.build_structure = None self.QUIET = bool(QUIET) # Public methods def get_structure(self, structure_id, filename): """Return the structure. Arguments: - structure_id - string, the id that will be used for the structure - filename - name of the mmCIF file OR an open filehandle """ with warnings.catch_warnings(): if self.QUIET: warnings.filterwarnings("ignore", category=PDBConstructionWarning) with as_handle(filename) as handle: self._build_structure(structure_id, handle) return self._structure_builder.get_structure() # Private methods def _build_structure(self, structure_id, filehandle): # two special chars as placeholders in the mmCIF format # for item values that cannot be explicitly assigned # see: pdbx/mmcif syntax web page _unassigned = set(('.', '?')) # Read only _atom_site. and atom_site_anisotrop entries read_atom, read_aniso = False, False _fields, _records = [], [] _anisof, _anisors = [], [] for line in filehandle: if line.startswith('_atom_site.'): read_atom = True _fields.append(line.strip()) elif line.startswith('_atom_site_anisotrop.'): read_aniso = True _anisof.append(line.strip()) elif read_atom and line.startswith('#'): read_atom = False elif read_aniso and line.startswith('#'): read_aniso = False elif read_atom: _records.append(line.strip()) elif read_aniso: _anisors.append(line.strip()) # Dumping the shlex module here since this particular # category should be rather straightforward. # Quite a performance boost.. _record_tbl = zip(*map(str.split, _records)) _anisob_tbl = zip(*map(str.split, _anisors)) mmcif_dict = dict(zip(_fields, _record_tbl)) mmcif_dict.update(dict(zip(_anisof, _anisob_tbl))) # Build structure object atom_id_list = mmcif_dict["_atom_site.label_atom_id"] residue_id_list = mmcif_dict["_atom_site.label_comp_id"] try: element_list = mmcif_dict["_atom_site.type_symbol"] except KeyError: element_list = None chain_id_list = mmcif_dict["_atom_site.auth_asym_id"] x_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_x"]] y_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_y"]] z_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_z"]] alt_list = mmcif_dict["_atom_site.label_alt_id"] icode_list = mmcif_dict["_atom_site.pdbx_PDB_ins_code"] b_factor_list = mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list = mmcif_dict["_atom_site.occupancy"] fieldname_list = mmcif_dict["_atom_site.group_PDB"] try: serial_list = [int(n) for n in mmcif_dict["_atom_site.pdbx_PDB_model_num"]] except KeyError: # No model number column serial_list = None except ValueError: # Invalid model number (malformed file) raise PDBConstructionException("Invalid model number") try: aniso_u11 = mmcif_dict["_atom_site_anisotrop.U[1][1]"] aniso_u12 = mmcif_dict["_atom_site_anisotrop.U[1][2]"] aniso_u13 = mmcif_dict["_atom_site_anisotrop.U[1][3]"] aniso_u22 = mmcif_dict["_atom_site_anisotrop.U[2][2]"] aniso_u23 = mmcif_dict["_atom_site_anisotrop.U[2][3]"] aniso_u33 = mmcif_dict["_atom_site_anisotrop.U[3][3]"] aniso_flag = 1 except KeyError: # no anisotropic B factors aniso_flag = 0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list = mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list = mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id = None current_residue_id = None current_resname = None structure_builder = self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_seg(" ") # Historically, Biopython PDB parser uses model_id to mean array index # so serial_id means the Model ID specified in the file current_model_id = -1 current_serial_id = -1 for i in range(0, len(atom_id_list)): # set the line_counter for 'ATOM' lines only and not # as a global line counter found in the PDBParser() # this number should match the '_atom_site.id' index in the MMCIF structure_builder.set_line_counter(i) x = x_list[i] y = y_list[i] z = z_list[i] resname = residue_id_list[i] chainid = chain_id_list[i] altloc = alt_list[i] if altloc in _unassigned: altloc = " " int_resseq = int(seq_id_list[i]) icode = icode_list[i] if icode in _unassigned: icode = " " name = atom_id_list[i].strip('"') # Remove occasional " from quoted atom names (e.g. xNA) # occupancy & B factor try: tempfactor = float(b_factor_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing B factor") try: occupancy = float(occupancy_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing occupancy") fieldname = fieldname_list[i] if fieldname == "HETATM": hetatm_flag = "H" else: hetatm_flag = " " resseq = (hetatm_flag, int_resseq, icode) if serial_list is not None: # model column exists; use it serial_id = serial_list[i] if current_serial_id != serial_id: # if serial changes, update it and start new model current_serial_id = serial_id current_model_id += 1 structure_builder.init_model(current_model_id, current_serial_id) current_chain_id = None current_residue_id = None current_resname = None else: # no explicit model column; initialize single model structure_builder.init_model(current_model_id) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = None current_resname = None if current_residue_id != resseq or current_resname != resname: current_residue_id = resseq current_resname = resname structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord = numpy.array((x, y, z), 'f') element = element_list[i] if element_list else None structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name, element=element) if aniso_flag == 1 and i < len(aniso_u11): u = (aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i]) mapped_anisou = [float(_) for _ in u] anisou_array = numpy.array(mapped_anisou, 'f') structure_builder.set_anisou(anisou_array)
class PDBParser(object): """ Parse a PDB file and return a Structure object. """ def __init__(self, PERMISSIVE=True, get_header=False, structure_builder=None, QUIET=False): """ The PDB parser call a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the PDBParser object itself, but if the user provides his own StructureBuilder object, the latter is used instead. Arguments: o PERMISSIVE - Evaluated as a Boolean. If false, exceptions in constructing the SMCRA data structure are fatal. If true (DEFAULT), the exceptions are caught, but some residues or atoms will be missing. THESE EXCEPTIONS ARE DUE TO PROBLEMS IN THE PDB FILE!. o structure_builder - an optional user implemented StructureBuilder class. o QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be supressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the PDB file! """ if structure_builder != None: self.structure_builder = structure_builder else: self.structure_builder = StructureBuilder() self.header = None self.trailer = None self.line_counter = 0 self.PERMISSIVE = bool(PERMISSIVE) self.QUIET = bool(QUIET) # Public methods def get_structure(self, id, file): """Return the structure. Arguments: o id - string, the id that will be used for the structure o file - name of the PDB file OR an open filehandle """ if self.QUIET: warning_list = warnings.filters[:] warnings.filterwarnings('ignore', category=PDBConstructionWarning) self.header = None self.trailer = None # Make a StructureBuilder instance (pass id of structure as parameter) self.structure_builder.init_structure(id) with as_handle(file) as handle: self._parse(handle.readlines()) self.structure_builder.set_header(self.header) # Return the Structure instance structure = self.structure_builder.get_structure() if self.QUIET: warnings.filters = warning_list return structure def get_header(self): "Return the header." return self.header def get_trailer(self): "Return the trailer." return self.trailer # Private methods def _parse(self, header_coords_trailer): "Parse the PDB file." # Extract the header; return the rest of the file self.header, coords_trailer = self._get_header(header_coords_trailer) # Parse the atomic data; return the PDB file trailer self.trailer = self._parse_coordinates(coords_trailer) def _get_header(self, header_coords_trailer): "Get the header of the PDB file, return the rest." structure_builder = self.structure_builder i = 0 for i in range(0, len(header_coords_trailer)): structure_builder.set_line_counter(i + 1) line = header_coords_trailer[i] record_type = line[0:6] if (record_type == 'ATOM ' or record_type == 'HETATM' or record_type == 'MODEL '): break header = header_coords_trailer[0:i] # Return the rest of the coords+trailer for further processing self.line_counter = i coords_trailer = header_coords_trailer[i:] header_dict = _parse_pdb_header_list(header) return header_dict, coords_trailer def _parse_coordinates(self, coords_trailer): "Parse the atomic data in the PDB file." local_line_counter = 0 structure_builder = self.structure_builder current_model_id = 0 # Flag we have an open model model_open = 0 current_chain_id = None current_segid = None current_residue_id = None current_resname = None for i in range(0, len(coords_trailer)): line = coords_trailer[i] record_type = line[0:6] global_line_counter = self.line_counter + local_line_counter + 1 structure_builder.set_line_counter(global_line_counter) if (record_type == 'ATOM ' or record_type == 'HETATM'): # Initialize the Model - there was no explicit MODEL record if not model_open: structure_builder.init_model(current_model_id) current_model_id += 1 model_open = 1 fullname = line[12:16] # get rid of whitespace in atom names split_list = fullname.split() if len(split_list) != 1: # atom name has internal spaces, e.g. " N B ", so # we do not strip spaces name = fullname else: # atom name is like " CA ", so we can strip spaces name = split_list[0] altloc = line[16:17] resname = line[17:20] chainid = line[21:22] try: serial_number = int(line[6:11]) except: serial_number = 0 resseq = int(line[22:26].split()[0]) # sequence identifier icode = line[26:27] # insertion code if record_type == 'HETATM': # hetero atom flag if resname == "HOH" or resname == "WAT": hetero_flag = "W" else: hetero_flag = "H" else: hetero_flag = " " residue_id = (hetero_flag, resseq, icode) # atomic coordinates try: x = float(line[30:38]) y = float(line[38:46]) z = float(line[46:54]) except: #Should we allow parsing to continue in permissive mode? #If so what coordindates should we default to? Easier to abort! raise PDBConstructionException(\ "Invalid or missing coordinate(s) at line %i." \ % global_line_counter) coord = numpy.array((x, y, z), 'f') # occupancy & B factor try: occupancy = float(line[54:60]) except: self._handle_PDB_exception("Invalid or missing occupancy", global_line_counter) occupancy = 0.0 #Is one or zero a good default? try: bfactor = float(line[60:66]) except: self._handle_PDB_exception("Invalid or missing B factor", global_line_counter) bfactor = 0.0 #The PDB use a default of zero if the data is missing segid = line[72:76] element = line[76:78].strip() if current_segid != segid: current_segid = segid structure_builder.init_seg(current_segid) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException, message: self._handle_PDB_exception(message, global_line_counter) elif current_residue_id != residue_id or current_resname != resname: current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException, message: self._handle_PDB_exception(message, global_line_counter) # init atom try: structure_builder.init_atom(name, coord, bfactor, occupancy, altloc, fullname, serial_number, element) except PDBConstructionException, message: self._handle_PDB_exception(message, global_line_counter)
class PDBP_read(object): def __init__(self, get_header=False, structure_builder=None, PERMISSIVE=True): """arguments: PERMISSIVE, Evaluated as a Boolean. If ture, the exception are caught, some residues or atoms will be missing.THESE EXCEPTIONS ARE DUE TO PROBLEMS IN THE PDB FILE! structure_builder, an optional user implemented StructureBuilder class. """ #get a structure_builder class if structure_builder is not None: self.structure_builder = structure_builder else: self.structure_builder = StructureBuilder() self.header = None self.trailer = None self.line_counter = 0 self.PERMISSIVE = bool(PERMISSIVE) def get_structure(self, id, file): """return the structure. argurements: -id - the name of the sturecture -file - pdb filename """ self.header = None self.trailer = None #make a StructureBuilder instance self.structure_builder.init_structure(id) if file[-2:] == 'gz': #try: #with open(file,'r+',encoding='utf-8') as handle: #self._parse(handle.readlines()) with gzip.open(file, 'r') as handle: #######按照行读取pdb文件 self._parse(handle.read().decode("utf-8").split('\n')) else: try: with open(file, 'r') as handle: self._parse(handle.readlines()) except Exception: print("%s cannot be open!" % (file)) #exit() #??????? self.structure_builder.set_header(self.header) # return the structure instance structure = self.structure_builder.get_structure() return structure def get_header(self): """return the header""" return self.header def get_trailer(self): """return the trailer""" return self.trailer #private methods def _parse(self, header_coords_trailer): """parser the pdb file(private)""" self.coords_trailer = self._get_header(header_coords_trailer) ## parse the atomicdata; return the pdb file triler self.trailer = self._parse_coordinates(self.coords_trailer) def _get_header(self, header_coords_trailer): """get the header of the pdb file""" structure_builder = self.structure_builder i = 0 line_nums = len(header_coords_trailer) ''' for index, line in enumerate(header_coords_trailer): print(index, line) print(line_nums, type(header_coords_trailer)) ''' for i in range(0, line_nums): structure_builder.set_line_counter(i + 1) line = header_coords_trailer[i] record_type = line[0:6] if record_type == "ATOM " or record_type == "HETATM" or record_type == "MODEL ": break #header = header_coords_trailer[0:i] #return the rest of the coodstrailer self.line_counter = i coords_trailer = header_coords_trailer[i:] #header_dict = self._parse_pdb_header_list(header) return coords_trailer def _parse_coordinates(self, coords_trailer): """parse the atomic data in teh PDB file """ local_line_counter = 0 #n=0 structure_builder = self.structure_builder current_model_id = 0 # Flag we have an open model model_open = 0 current_chain_id = None current_segid = None current_residue_id = None current_resname = None lines_num1 = len(coords_trailer) for i in range(0, lines_num1): line = coords_trailer[i].rstrip('\n') record_type = line[0:6] global_line_counter = self.line_counter + local_line_counter + 1 # the all lines nums include header coods and trailer structure_builder.set_line_counter(global_line_counter) if record_type == "ATOM ": #or record_type == "HETATM": #Initialize the Model - there was no explicit MODEL record if not model_open: structure_builder.init_model(current_model_id) current_model_id += 1 model_open = 1 fullname = line[12:16] # get rid of whitespace in atom names split_list = fullname.split() if len(split_list) != 1: # a atom has several species, eg "N B" name = fullname else: #eg: "CA" name = split_list[0] altloc = line[16] resname = line[17:20] chainid = line[21] try: serial_number = int(line[6:11]) except Exception: serial_number = 0 resseq = int(line[22:26].split()[0]) icode = line[26] if record_type == "HETATM": if resname == "HOH" or resname == "WAT": hetero_flag = "W" else: hetero_flag = "H" else: hetero_flag = " " residue_id = (hetero_flag, resseq, icode) try: x = float(line[30:38]) y = float(line[38:46]) z = float(line[46:54]) except Exception: raise PDBConstructionException( "Invalid or missing coordinate(s) at line %i." % global_line_counter) coord = numpy.array((x, y, z), "f") try: occupancy = float(line[54:60]) except Exception: self._handle_PDB_exception("Invalid or missing occupancy", global_line_counter) #occupancy = None # Rather than arbitrary zero or one occupancy = None # Rather than arbitrary zero or one if occupancy is not None and occupancy < 0: warnings.warn("Negative occupancy in one or more atoms", PDBConstructionWarning) try: bfactor = float(line[60:66]) except Exception: self._handle_PDB_exception("Invalid or missing B factor", global_line_counter) bfactor = 0.0 # The PDB use a default of zero if the data is missing segid = line[72:76] element = line[76:78].strip().upper() if current_segid != segid: current_segid = segid structure_builder.init_seg(current_segid) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) elif current_residue_id != residue_id or current_resname != resname: current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) # init atom try: structure_builder.init_atom(name, coord, bfactor, occupancy, altloc, fullname, serial_number, element) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) elif record_type == "MODEL ": try: serial_num = int(line[10:14]) except Exception: self._handle_PDB_exception( "Invalid or missing model serial number", global_line_counter) serial_num = 0 structure_builder.init_model(current_model_id, serial_num) current_model_id += 1 model_open = 1 current_chain_id = None current_residue_id = None elif record_type == "END " or record_type == "CONECT": # End of atomic data, return the trailer self.line_counter += local_line_counter return coords_trailer[local_line_counter:] elif record_type == "ENDMDL": model_open = 0 current_chain_id = None current_residue_id = None elif record_type == "SIGUIJ": # standard deviation of anisotropic B factor siguij = [ float(x) for x in (line[28:35], line[35:42], line[42:49], line[49:56], line[56:63], line[63:70]) ] # U sigma's are scaled by 10^4 siguij_array = (numpy.array(siguij, "f") / 10000.0).astype("f") structure_builder.set_siguij(siguij_array) elif record_type == "SIGATM": # standard deviation of atomic positions sigatm = [ float(x) for x in (line[30:38], line[38:45], line[46:54], line[54:60], line[60:66]) ] sigatm_array = numpy.array(sigatm, "f") structure_builder.set_sigatm(sigatm_array) local_line_counter += 1 # EOF (does not end in END or CONECT) self.line_counter = self.line_counter + local_line_counter return [] #info = (resname, resseq, serial_number,fullname, coord) #yield info def _handle_PDB_exception(self, message, line_counter): message = "%s at line %i." % (message, line_counter) if self.PERMISSIVE: # just print a warning - some residues/atoms may be missing warnings.warn( "PDBConstructionException: %s\n" "Exception ignored.\n" "Some atoms or residues may be missing in the data structure." % message, PDBConstructionWarning) else: # exceptions are fatal - raise again with new message (including line nr) raise PDBConstructionException(message)
class FastMMCIFParser(object): """Parse an MMCIF file and return a Structure object.""" def __init__(self, structure_builder=None, QUIET=False): """Create a FastMMCIFParser object. The mmCIF parser calls a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the parser object itself, but if the user provides his/her own StructureBuilder object, the latter is used instead. The main difference between this class and the regular MMCIFParser is that only 'ATOM' and 'HETATM' lines are parsed here. Use if you are interested only in coordinate information. Arguments: - structure_builder - an optional user implemented StructureBuilder class. - QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be suppressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the mmCIF file! """ if structure_builder is not None: self._structure_builder = structure_builder else: self._structure_builder = StructureBuilder() self.line_counter = 0 self.build_structure = None self.QUIET = bool(QUIET) # Public methods def get_structure(self, structure_id, filename): """Return the structure. Arguments: - structure_id - string, the id that will be used for the structure - filename - name of the mmCIF file OR an open filehandle """ with warnings.catch_warnings(): if self.QUIET: warnings.filterwarnings("ignore", category=PDBConstructionWarning) with as_handle(filename) as handle: self._build_structure(structure_id, handle) return self._structure_builder.get_structure() # Private methods def _build_structure(self, structure_id, filehandle): # two special chars as placeholders in the mmCIF format # for item values that cannot be explicitly assigned # see: pdbx/mmcif syntax web page _unassigned = set(('.', '?')) # Read only _atom_site. and atom_site_anisotrop entries read_atom, read_aniso = False, False _fields, _records = [], [] _anisof, _anisors = [], [] for line in filehandle: if line.startswith('_atom_site.'): read_atom = True _fields.append(line.strip()) elif line.startswith('_atom_site_anisotrop.'): read_aniso = True _anisof.append(line.strip()) elif read_atom and line.startswith('#'): read_atom = False elif read_aniso and line.startswith('#'): read_aniso = False elif read_atom: _records.append(line.strip()) elif read_aniso: _anisors.append(line.strip()) # Dumping the shlex module here since this particular # category should be rather straightforward. # Quite a performance boost.. _record_tbl = zip(*map(str.split, _records)) _anisob_tbl = zip(*map(str.split, _anisors)) mmcif_dict = dict(zip(_fields, _record_tbl)) mmcif_dict.update(dict(zip(_anisof, _anisob_tbl))) # Build structure object atom_id_list = mmcif_dict["_atom_site.label_atom_id"] residue_id_list = mmcif_dict["_atom_site.label_comp_id"] try: element_list = mmcif_dict["_atom_site.type_symbol"] except KeyError: element_list = None seq_id_list = mmcif_dict["_atom_site.label_seq_id"] chain_id_list = mmcif_dict["_atom_site.auth_asym_id"] x_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_x"]] y_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_y"]] z_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_z"]] alt_list = mmcif_dict["_atom_site.label_alt_id"] icode_list = mmcif_dict["_atom_site.pdbx_PDB_ins_code"] b_factor_list = mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list = mmcif_dict["_atom_site.occupancy"] fieldname_list = mmcif_dict["_atom_site.group_PDB"] try: serial_list = [int(n) for n in mmcif_dict["_atom_site.pdbx_PDB_model_num"]] except KeyError: # No model number column serial_list = None except ValueError: # Invalid model number (malformed file) raise PDBConstructionException("Invalid model number") try: aniso_u11 = mmcif_dict["_atom_site.aniso_U[1][1]"] aniso_u12 = mmcif_dict["_atom_site.aniso_U[1][2]"] aniso_u13 = mmcif_dict["_atom_site.aniso_U[1][3]"] aniso_u22 = mmcif_dict["_atom_site.aniso_U[2][2]"] aniso_u23 = mmcif_dict["_atom_site.aniso_U[2][3]"] aniso_u33 = mmcif_dict["_atom_site.aniso_U[3][3]"] aniso_flag = 1 except KeyError: # no anisotropic B factors aniso_flag = 0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list = mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list = mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id = None current_residue_id = None current_resname = None structure_builder = self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_seg(" ") # Historically, Biopython PDB parser uses model_id to mean array index # so serial_id means the Model ID specified in the file current_model_id = -1 current_serial_id = -1 for i in range(0, len(atom_id_list)): # set the line_counter for 'ATOM' lines only and not # as a global line counter found in the PDBParser() # this number should match the '_atom_site.id' index in the MMCIF structure_builder.set_line_counter(i) x = x_list[i] y = y_list[i] z = z_list[i] resname = residue_id_list[i] chainid = chain_id_list[i] altloc = alt_list[i] if altloc in _unassigned: altloc = " " int_resseq = int(seq_id_list[i]) icode = icode_list[i] if icode in _unassigned: icode = " " name = atom_id_list[i].strip('"') # Remove occasional " from quoted atom names (e.g. xNA) # occupancy & B factor try: tempfactor = float(b_factor_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing B factor") try: occupancy = float(occupancy_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing occupancy") fieldname = fieldname_list[i] if fieldname == "HETATM": hetatm_flag = "H" else: hetatm_flag = " " resseq = (hetatm_flag, int_resseq, icode) if serial_list is not None: # model column exists; use it serial_id = serial_list[i] if current_serial_id != serial_id: # if serial changes, update it and start new model current_serial_id = serial_id current_model_id += 1 structure_builder.init_model(current_model_id, current_serial_id) current_chain_id = None current_residue_id = None current_resname = None else: # no explicit model column; initialize single model structure_builder.init_model(current_model_id) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = None current_resname = None if current_residue_id != resseq or current_resname != resname: current_residue_id = resseq current_resname = resname structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord = numpy.array((x, y, z), 'f') element = element_list[i] if element_list else None structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name, element=element) if aniso_flag == 1: u = (aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i]) mapped_anisou = [float(x) for x in u] anisou_array = numpy.array(mapped_anisou, 'f') structure_builder.set_anisou(anisou_array)
def read_PIC(file: TextIO, verbose: bool = False) -> Structure: """Load Protein Internal Coordinate (.pic) data from file. PIC file format: - comment lines start with # - (optional) PDB HEADER record - idcode and deposition date recommended but optional - deposition date in PDB format or as changed by Biopython - (optional) PDB TITLE record - repeat: - Biopython Residue Full ID - sets residue IDs of returned structure - (optional) PDB N, CA, C ATOM records for chain start - (optional) PIC Hedra records for residue - (optional) PIC Dihedra records for residue - (optional) BFAC records listing AtomKeys and b-factors An improvement would define relative positions for HOH (water) entries. N.B. dihedron (i-1)C-N-CA-CB is ignored in assembly if O exists. C-beta is by default placed using O-C-CA-CB, but O is missing in some PDB file residues, which means the sidechain cannot be placed. The alternate CB path (i-1)C-N-CA-CB is provided to circumvent this, but if this is needed then it must be adjusted in conjunction with PHI ((i-1)C-N-CA-C) as they overlap. (i-1)C-N-CA-CB is included by default in .pic files for consistency and informational (e.g. statistics gathering) purposes, as otherwise the dihedron would only appear in the few cases it is needed for. :param Bio.File file: file name or handle :param bool verbose: complain when lines not as expected :returns: Biopython Structure object, Residues with .internal_coord attributes but no coordinates except for chain start N, CA, C atoms if supplied, **OR** None on parse fail (silent unless verbose=True) """ pdb_hdr_re = re.compile( r"^HEADER\s{4}(?P<cf>.{1,40})" r"(?:\s+(?P<dd>\d\d\d\d-\d\d-\d\d|\d\d-\w\w\w-\d\d))?" r"(?:\s+(?P<id>[0-9A-Z]{4}))?\s*$") # ^\('(?P<pid>\w*)',\s(?P<mdl>\d+),\s'(?P<chn>\w)',\s\('(?P<het>\s|[\w-]+)',\s(?P<pos>\d+),\s'(?P<icode>\s|\w)'\)\)\s(?P<res>[A-Z]{3})\s(\[(?P<segid>[a-zA-z\s]{4})\])?\s*$ pdb_ttl_re = re.compile(r"^TITLE\s{5}(?P<ttl>.+)\s*$") biop_id_re = re.compile(r"^\('(?P<pid>[^\s]*)',\s(?P<mdl>\d+),\s" r"'(?P<chn>\s|\w)',\s\('(?P<het>\s|[\w\s-]+)" r"',\s(?P<pos>-?\d+),\s'(?P<icode>\s|\w)'\)\)" r"\s+(?P<res>[\w]{1,3})" r"(\s\[(?P<segid>[a-zA-z\s]+)\])?" r"\s*$") pdb_atm_re = re.compile(r"^ATOM\s\s(?:\s*(?P<ser>\d+))\s(?P<atm>[\w\s]{4})" r"(?P<alc>\w|\s)(?P<res>[\w]{3})\s(?P<chn>.)" r"(?P<pos>[\s\-\d]{4})(?P<icode>[A-Za-z\s])\s\s\s" r"(?P<x>[\s\-\d\.]{8})(?P<y>[\s\-\d\.]{8})" r"(?P<z>[\s\-\d\.]{8})(?P<occ>[\s\d\.]{6})" r"(?P<tfac>[\s\d\.]{6})\s{6}" r"(?P<segid>[a-zA-z\s]{4})(?P<elm>.{2})" r"(?P<chg>.{2})?\s*$") bfac_re = re.compile(r"^BFAC:\s([^\s]+\s+[\-\d\.]+)" r"\s*([^\s]+\s+[\-\d\.]+)?" r"\s*([^\s]+\s+[\-\d\.]+)?" r"\s*([^\s]+\s+[\-\d\.]+)?" r"\s*([^\s]+\s+[\-\d\.]+)?") bfac2_re = re.compile(r"([^\s]+)\s+([\-\d\.]+)") struct_builder = StructureBuilder() # init empty header dict # - could use to parse HEADER and TITLE lines except # deposition_date format changed from original PDB header header_dict = _parse_pdb_header_list([]) curr_SMCS = [None, None, None, None] # struct model chain seg SMCS_init = [ struct_builder.init_structure, struct_builder.init_model, struct_builder.init_chain, struct_builder.init_seg, ] sb_res = None with as_handle(file, mode="r") as handle: for aline in handle.readlines(): if aline.startswith("#"): pass # skip comment lines elif aline.startswith("HEADER "): m = pdb_hdr_re.match(aline) if m: header_dict["head"] = m.group("cf") # classification header_dict["idcode"] = m.group("id") header_dict["deposition_date"] = m.group("dd") elif verbose: print("Reading pic file", file, "HEADER parse fail: ", aline) elif aline.startswith("TITLE "): m = pdb_ttl_re.match(aline) if m: header_dict["name"] = m.group("ttl").strip() # print('TTL: ', m.group('ttl').strip()) elif verbose: print("Reading pic file", file, "TITLE parse fail:, ", aline) elif aline.startswith("("): # Biopython ID line for Residue m = biop_id_re.match(aline) if m: # check SMCS = Structure, Model, Chain, SegID segid = m.group(9) if segid is None: segid = " " this_SMCS = [ m.group(1), int(m.group(2)), m.group(3), segid ] if curr_SMCS != this_SMCS: # init new SMCS level as needed for i in range(4): if curr_SMCS[i] != this_SMCS[i]: SMCS_init[i](this_SMCS[i]) curr_SMCS[i] = this_SMCS[i] if 0 == i: # 0 = init structure so add header struct_builder.set_header(header_dict) elif 1 == i: # new model means new chain and new segid curr_SMCS[2] = curr_SMCS[3] = None struct_builder.init_residue( m.group("res"), m.group("het"), int(m.group("pos")), m.group("icode"), ) sb_res = struct_builder.residue if 2 == sb_res.is_disordered(): for r in sb_res.child_dict.values(): if not r.internal_coord: sb_res = r break sb_res.internal_coord = IC_Residue(sb_res) # print('res id:', m.groupdict()) # print(report_IC(struct_builder.get_structure())) else: if verbose: print("Reading pic file", file, "residue ID parse fail: ", aline) return None elif aline.startswith("ATOM "): m = pdb_atm_re.match(aline) if m: if sb_res is None: # ATOM without res spec already loaded, not a pic file if verbose: print( "Reading pic file", file, "ATOM without residue configured:, ", aline, ) return None if sb_res.resname != m.group("res") or sb_res.id[1] != int( m.group("pos")): if verbose: print( "Reading pic file", file, "ATOM not in configured residue (", sb_res.resname, str(sb_res.id), "):", aline, ) return None coord = numpy.array( (float(m.group("x")), float( m.group("y")), float(m.group("z"))), "f", ) struct_builder.init_atom( m.group("atm").strip(), coord, float(m.group("tfac")), float(m.group("occ")), m.group("alc"), m.group("atm"), int(m.group("ser")), m.group("elm").strip(), ) # print('atom: ', m.groupdict()) # elif verbose: # print("Reading pic file", file, "ATOM parse fail:", aline) elif aline.startswith("BFAC: "): m = bfac_re.match(aline) if m: for bfac_pair in m.groups(): if bfac_pair is not None: m2 = bfac2_re.match(bfac_pair) if m2 and sb_res is not None and sb_res.internal_coord: rp = sb_res.internal_coord rp.bfactors[m2.group(1)] = float(m2.group(2)) # else: # print('Reading pic file', file, 'B-factor line fail: ', aline) else: m = Edron.edron_re.match(aline) if m and sb_res is not None: sb_res.internal_coord.load_PIC(m.groupdict()) elif m: print( "PIC file: ", file, " error: no residue info before reading (di/h)edron data: ", aline, ) return None elif aline.strip(): if verbose: print("Reading PIC file", file, "parse fail on: .", aline, ".") return None struct = struct_builder.get_structure() for chn in struct.get_chains(): chnp = chn.internal_coord = IC_Chain(chn) # done in IC_Chain init : chnp.set_residues() chnp.link_residues() chnp.init_edra() # print(report_PIC(struct_builder.get_structure())) return struct
class MMCIFParser(object): def get_structure(self, structure_id, filename): self._mmcif_dict = MMCIF2Dict(filename) self._structure_builder = StructureBuilder() self._build_structure(structure_id) return self._structure_builder.get_structure() def _build_structure(self, structure_id): mmcif_dict = self._mmcif_dict atom_id_list = mmcif_dict["_atom_site.label_atom_id"] residue_id_list = mmcif_dict["_atom_site.label_comp_id"] try: element_list = mmcif_dict["_atom_site.type_symbol"] except KeyError: element_list = None seq_id_list = mmcif_dict["_atom_site.label_seq_id"] chain_id_list = mmcif_dict["_atom_site.label_asym_id"] x_list = map(float, mmcif_dict["_atom_site.Cartn_x"]) y_list = map(float, mmcif_dict["_atom_site.Cartn_y"]) z_list = map(float, mmcif_dict["_atom_site.Cartn_z"]) alt_list = mmcif_dict["_atom_site.label_alt_id"] b_factor_list = mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list = mmcif_dict["_atom_site.occupancy"] fieldname_list = mmcif_dict["_atom_site.group_PDB"] try: serial_list = [ int(n) for n in mmcif_dict["_atom_site.pdbx_PDB_model_num"] ] except KeyError: # No model number column serial_list = None except ValueError: # Invalid model number (malformed file) raise PDBConstructionException("Invalid model number") try: aniso_u11 = mmcif_dict["_atom_site.aniso_U[1][1]"] aniso_u12 = mmcif_dict["_atom_site.aniso_U[1][2]"] aniso_u13 = mmcif_dict["_atom_site.aniso_U[1][3]"] aniso_u22 = mmcif_dict["_atom_site.aniso_U[2][2]"] aniso_u23 = mmcif_dict["_atom_site.aniso_U[2][3]"] aniso_u33 = mmcif_dict["_atom_site.aniso_U[3][3]"] aniso_flag = 1 except KeyError: # no anisotropic B factors aniso_flag = 0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list = mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list = mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id = None current_residue_id = None structure_builder = self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_seg(" ") # Historically, Biopython PDB parser uses model_id to mean array index # so serial_id means the Model ID specified in the file current_model_id = 0 current_serial_id = 0 for i in xrange(0, len(atom_id_list)): x = x_list[i] y = y_list[i] z = z_list[i] resname = residue_id_list[i] chainid = chain_id_list[i] altloc = alt_list[i] if altloc == ".": altloc = " " resseq = seq_id_list[i] name = atom_id_list[i] tempfactor = b_factor_list[i] occupancy = occupancy_list[i] fieldname = fieldname_list[i] if fieldname == "HETATM": hetatm_flag = "H" else: hetatm_flag = " " if serial_list is not None: # model column exists; use it serial_id = serial_list[i] if current_serial_id != serial_id: # if serial changes, update it and start new model current_serial_id = serial_id structure_builder.init_model(current_model_id, current_serial_id) current_model_id += 1 else: # no explicit model column; initialize single model structure_builder.init_model(current_model_id) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = resseq icode, int_resseq = self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) elif current_residue_id != resseq: current_residue_id = resseq icode, int_resseq = self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord = numpy.array((x, y, z), 'f') element = element_list[i] if element_list else None structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name, element=element) if aniso_flag == 1: u = (aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i]) mapped_anisou = map(float, u) anisou_array = numpy.array(mapped_anisou, 'f') structure_builder.set_anisou(anisou_array) # Now try to set the cell try: a = float(mmcif_dict["_cell.length_a"]) b = float(mmcif_dict["_cell.length_b"]) c = float(mmcif_dict["_cell.length_c"]) alpha = float(mmcif_dict["_cell.angle_alpha"]) beta = float(mmcif_dict["_cell.angle_beta"]) gamma = float(mmcif_dict["_cell.angle_gamma"]) cell = numpy.array((a, b, c, alpha, beta, gamma), 'f') spacegroup = mmcif_dict["_symmetry.space_group_name_H-M"] spacegroup = spacegroup[1:-1] # get rid of quotes!! if spacegroup == None: raise Exception structure_builder.set_symmetry(spacegroup, cell) except: pass # no cell found, so just ignore def _get_icode(self, resseq): """Tries to return the icode. In MMCIF files this is just part of resseq! In PDB files, it's a separate field.""" last_resseq_char = resseq[-1] if last_resseq_char in ascii_letters: icode = last_resseq_char int_resseq = int(resseq[0:-1]) else: icode = " " int_resseq = int(resseq) return icode, int_resseq
class PDBParser(object): """ Parse a PDB file and return a Structure object. """ def __init__(self, PERMISSIVE=True, get_header=False, structure_builder=None, QUIET=False): """ The PDB parser call a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the PDBParser object itself, but if the user provides his/her own StructureBuilder object, the latter is used instead. Arguments: o PERMISSIVE - Evaluated as a Boolean. If false, exceptions in constructing the SMCRA data structure are fatal. If true (DEFAULT), the exceptions are caught, but some residues or atoms will be missing. THESE EXCEPTIONS ARE DUE TO PROBLEMS IN THE PDB FILE!. o structure_builder - an optional user implemented StructureBuilder class. o QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be suppressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the PDB file! """ if structure_builder is not None: self.structure_builder = structure_builder else: self.structure_builder = StructureBuilder() self.header = None self.trailer = None self.line_counter = 0 self.PERMISSIVE = bool(PERMISSIVE) self.QUIET = bool(QUIET) # Public methods def get_structure(self, id, file): """Return the structure. Arguments: o id - string, the id that will be used for the structure o file - name of the PDB file OR an open filehandle """ if self.QUIET: warning_list = warnings.filters[:] warnings.filterwarnings("ignore", category=PDBConstructionWarning) self.header = None self.trailer = None # Make a StructureBuilder instance (pass id of structure as parameter) self.structure_builder.init_structure(id) with as_handle(file) as handle: self._parse(handle.readlines()) self.structure_builder.set_header(self.header) # Return the Structure instance structure = self.structure_builder.get_structure() if self.QUIET: warnings.filters = warning_list return structure def get_header(self): "Return the header." return self.header def get_trailer(self): "Return the trailer." return self.trailer # Private methods def _parse(self, header_coords_trailer): "Parse the PDB file." # Extract the header; return the rest of the file self.header, coords_trailer = self._get_header(header_coords_trailer) # Parse the atomic data; return the PDB file trailer self.trailer = self._parse_coordinates(coords_trailer) def _get_header(self, header_coords_trailer): "Get the header of the PDB file, return the rest." structure_builder = self.structure_builder i = 0 for i in range(0, len(header_coords_trailer)): structure_builder.set_line_counter(i + 1) line = header_coords_trailer[i] record_type = line[0:6] if record_type == "ATOM " or record_type == "HETATM" or record_type == "MODEL ": break header = header_coords_trailer[0:i] # Return the rest of the coords+trailer for further processing self.line_counter = i coords_trailer = header_coords_trailer[i:] header_dict = _parse_pdb_header_list(header) return header_dict, coords_trailer def _parse_coordinates(self, coords_trailer): "Parse the atomic data in the PDB file." local_line_counter = 0 structure_builder = self.structure_builder current_model_id = 0 # Flag we have an open model model_open = 0 current_chain_id = None current_segid = None current_residue_id = None current_resname = None for i in range(0, len(coords_trailer)): line = coords_trailer[i] record_type = line[0:6] global_line_counter = self.line_counter + local_line_counter + 1 structure_builder.set_line_counter(global_line_counter) if record_type == "ATOM " or record_type == "HETATM": # Initialize the Model - there was no explicit MODEL record if not model_open: structure_builder.init_model(current_model_id) current_model_id += 1 model_open = 1 fullname = line[12:16] # get rid of whitespace in atom names split_list = fullname.split() if len(split_list) != 1: # atom name has internal spaces, e.g. " N B ", so # we do not strip spaces name = fullname else: # atom name is like " CA ", so we can strip spaces name = split_list[0] altloc = line[16] resname = line[17:20] chainid = line[21] try: serial_number = int(line[6:11]) except: serial_number = 0 resseq = int(line[22:26].split()[0]) # sequence identifier icode = line[26] # insertion code if record_type == "HETATM": # hetero atom flag if resname == "HOH" or resname == "WAT": hetero_flag = "W" else: hetero_flag = "H" else: hetero_flag = " " residue_id = (hetero_flag, resseq, icode) # atomic coordinates try: x = float(line[30:38]) y = float(line[38:46]) z = float(line[46:54]) except: # Should we allow parsing to continue in permissive mode? # If so, what coordinates should we default to? Easier to abort! raise PDBConstructionException("Invalid or missing coordinate(s) at line %i." % global_line_counter) coord = numpy.array((x, y, z), "f") # occupancy & B factor try: occupancy = float(line[54:60]) except: self._handle_PDB_exception("Invalid or missing occupancy", global_line_counter) occupancy = None # Rather than arbitrary zero or one try: bfactor = float(line[60:66]) except: self._handle_PDB_exception("Invalid or missing B factor", global_line_counter) bfactor = 0.0 # The PDB use a default of zero if the data is missing segid = line[72:76] element = line[76:78].strip() if current_segid != segid: current_segid = segid structure_builder.init_seg(current_segid) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException, message: self._handle_PDB_exception(message, global_line_counter) elif current_residue_id != residue_id or current_resname != resname: current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException, message: self._handle_PDB_exception(message, global_line_counter) # init atom try: structure_builder.init_atom(name, coord, bfactor, occupancy, altloc, fullname, serial_number, element) except PDBConstructionException, message: self._handle_PDB_exception(message, global_line_counter)
class PDBParser(object): """Parse a PDB file and return a Structure object.""" def __init__(self, PERMISSIVE=True, get_header=False, structure_builder=None, QUIET=False): """Create a PDBParser object. The PDB parser call a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the PDBParser object itself, but if the user provides his/her own StructureBuilder object, the latter is used instead. Arguments: - PERMISSIVE - Evaluated as a Boolean. If false, exceptions in constructing the SMCRA data structure are fatal. If true (DEFAULT), the exceptions are caught, but some residues or atoms will be missing. THESE EXCEPTIONS ARE DUE TO PROBLEMS IN THE PDB FILE!. - get_header - unused argument kept for historical compatibilty. - structure_builder - an optional user implemented StructureBuilder class. - QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be suppressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the PDB file! """ # get_header is not used but is left in for API compatibility if structure_builder is not None: self.structure_builder = structure_builder else: self.structure_builder = StructureBuilder() self.header = None self.trailer = None self.line_counter = 0 self.PERMISSIVE = bool(PERMISSIVE) self.QUIET = bool(QUIET) # Public methods def get_structure(self, id, file): """Return the structure. Arguments: - id - string, the id that will be used for the structure - file - name of the PDB file OR an open filehandle """ with warnings.catch_warnings(): if self.QUIET: warnings.filterwarnings("ignore", category=PDBConstructionWarning) self.header = None self.trailer = None # Make a StructureBuilder instance (pass id of structure as parameter) self.structure_builder.init_structure(id) with as_handle(file, mode="rU") as handle: lines = handle.readlines() if not lines: raise ValueError("Empty file.") self._parse(lines) self.structure_builder.set_header(self.header) # Return the Structure instance structure = self.structure_builder.get_structure() return structure def get_header(self): """Return the header.""" return self.header def get_trailer(self): """Return the trailer.""" return self.trailer # Private methods def _parse(self, header_coords_trailer): """Parse the PDB file (PRIVATE).""" # Extract the header; return the rest of the file self.header, coords_trailer = self._get_header(header_coords_trailer) # Parse the atomic data; return the PDB file trailer self.trailer = self._parse_coordinates(coords_trailer) def _get_header(self, header_coords_trailer): """Get the header of the PDB file, return the rest (PRIVATE).""" structure_builder = self.structure_builder i = 0 for i in range(0, len(header_coords_trailer)): structure_builder.set_line_counter(i + 1) line = header_coords_trailer[i] record_type = line[0:6] if record_type in ("ATOM ", "HETATM", "MODEL "): break header = header_coords_trailer[0:i] # Return the rest of the coords+trailer for further processing self.line_counter = i coords_trailer = header_coords_trailer[i:] header_dict = _parse_pdb_header_list(header) return header_dict, coords_trailer def _parse_coordinates(self, coords_trailer): """Parse the atomic data in the PDB file (PRIVATE).""" local_line_counter = 0 structure_builder = self.structure_builder current_model_id = 0 # Flag we have an open model model_open = 0 current_chain_id = None current_segid = None current_residue_id = None current_resname = None for i in range(0, len(coords_trailer)): line = coords_trailer[i].rstrip("\n") record_type = line[0:6] global_line_counter = self.line_counter + local_line_counter + 1 structure_builder.set_line_counter(global_line_counter) if record_type == "ATOM " or record_type == "HETATM": # Initialize the Model - there was no explicit MODEL record if not model_open: structure_builder.init_model(current_model_id) current_model_id += 1 model_open = 1 fullname = line[12:16] # get rid of whitespace in atom names split_list = fullname.split() if len(split_list) != 1: # atom name has internal spaces, e.g. " N B ", so # we do not strip spaces name = fullname else: # atom name is like " CA ", so we can strip spaces name = split_list[0] altloc = line[16] resname = line[17:20] chainid = line[21] try: serial_number = int(line[6:11]) except Exception: serial_number = 0 resseq = int(line[22:26].split()[0]) # sequence identifier icode = line[26] # insertion code if record_type == "HETATM": # hetero atom flag if resname == "HOH" or resname == "WAT": hetero_flag = "W" else: hetero_flag = "H" else: hetero_flag = " " residue_id = (hetero_flag, resseq, icode) # atomic coordinates try: x = float(line[30:38]) y = float(line[38:46]) z = float(line[46:54]) except Exception: # Should we allow parsing to continue in permissive mode? # If so, what coordinates should we default to? Easier to abort! raise PDBConstructionException( "Invalid or missing coordinate(s) at line %i." % global_line_counter) coord = numpy.array((x, y, z), "f") # occupancy & B factor try: occupancy = float(line[54:60]) except Exception: self._handle_PDB_exception("Invalid or missing occupancy", global_line_counter) occupancy = None # Rather than arbitrary zero or one if occupancy is not None and occupancy < 0: # TODO - Should this be an error in strict mode? # self._handle_PDB_exception("Negative occupancy", # global_line_counter) # This uses fixed text so the warning occurs once only: warnings.warn( "Negative occupancy in one or more atoms", PDBConstructionWarning, ) try: bfactor = float(line[60:66]) except Exception: self._handle_PDB_exception("Invalid or missing B factor", global_line_counter) bfactor = 0.0 # PDB uses a default of zero if missing segid = line[72:76] element = line[76:78].strip().upper() if current_segid != segid: current_segid = segid structure_builder.init_seg(current_segid) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) elif current_residue_id != residue_id or current_resname != resname: current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) # init atom try: structure_builder.init_atom( name, coord, bfactor, occupancy, altloc, fullname, serial_number, element, ) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) elif record_type == "ANISOU": anisou = [ float(x) for x in ( line[28:35], line[35:42], line[43:49], line[49:56], line[56:63], line[63:70], ) ] # U's are scaled by 10^4 anisou_array = (numpy.array(anisou, "f") / 10000.0).astype("f") structure_builder.set_anisou(anisou_array) elif record_type == "MODEL ": try: serial_num = int(line[10:14]) except Exception: self._handle_PDB_exception( "Invalid or missing model serial number", global_line_counter) serial_num = 0 structure_builder.init_model(current_model_id, serial_num) current_model_id += 1 model_open = 1 current_chain_id = None current_residue_id = None elif record_type == "END " or record_type == "CONECT": # End of atomic data, return the trailer self.line_counter += local_line_counter return coords_trailer[local_line_counter:] elif record_type == "ENDMDL": model_open = 0 current_chain_id = None current_residue_id = None elif record_type == "SIGUIJ": # standard deviation of anisotropic B factor siguij = [ float(x) for x in ( line[28:35], line[35:42], line[42:49], line[49:56], line[56:63], line[63:70], ) ] # U sigma's are scaled by 10^4 siguij_array = (numpy.array(siguij, "f") / 10000.0).astype("f") structure_builder.set_siguij(siguij_array) elif record_type == "SIGATM": # standard deviation of atomic positions sigatm = [ float(x) for x in ( line[30:38], line[38:45], line[46:54], line[54:60], line[60:66], ) ] sigatm_array = numpy.array(sigatm, "f") structure_builder.set_sigatm(sigatm_array) local_line_counter += 1 # EOF (does not end in END or CONECT) self.line_counter = self.line_counter + local_line_counter return [] def _handle_PDB_exception(self, message, line_counter): """Handle exception (PRIVATE). This method catches an exception that occurs in the StructureBuilder object (if PERMISSIVE), or raises it again, this time adding the PDB line number to the error message. """ message = "%s at line %i." % (message, line_counter) if self.PERMISSIVE: # just print a warning - some residues/atoms may be missing warnings.warn( "PDBConstructionException: %s\n" "Exception ignored.\n" "Some atoms or residues may be missing in the data structure." % message, PDBConstructionWarning, ) else: # exceptions are fatal - raise again with new message (including line nr) raise PDBConstructionException(message)
# Convert SS to bfactor code sscode = ss_to_code[sstype] # Coarse grain residue residue_restraints, beads = MARTINI(residue) structure_builder.init_residue(residue.resname, residue.id[0], residue.id[1], residue.id[2]) # Populate residue for name, coord in beads: structure_builder.init_atom(name, coord, sscode, 1.00, " ", name, nbeads, "C") nbeads += 1 # Save restraints tbl_cg_to_aa.extend(residue_restraints) cg_model = structure_builder.get_structure() # output sequence and ss information print("%s:\t" % chain.id, aa_seq) print("%s:\t" % chain.id, martini_types) print("%s:\t" % chain.id, ''.join(map(lambda x: str(ss_to_code[x]), martini_types))) # Write coarse grained structure io.set_structure(cg_model) io.save('%s_cg.pdb' % (pdbf_path[:-4]), write_end=1) # Write Restraints tbl_file = open('%s_cg_to_aa.tbl' % pdbf_path[:-4], 'w') tbl_file.write('\n'.join(tbl_cg_to_aa)) tbl_file.close()
class MMCIFParser(object): def get_structure(self, structure_id, filename): self._mmcif_dict=MMCIF2Dict(filename) self._structure_builder=StructureBuilder() self._build_structure(structure_id) return self._structure_builder.get_structure() def _build_structure(self, structure_id): mmcif_dict=self._mmcif_dict atom_id_list=mmcif_dict["_atom_site.label_atom_id"] residue_id_list=mmcif_dict["_atom_site.label_comp_id"] try: element_list = mmcif_dict["_atom_site.type_symbol"] except KeyError: element_list = None seq_id_list=mmcif_dict["_atom_site.label_seq_id"] chain_id_list=mmcif_dict["_atom_site.label_asym_id"] x_list=map(float, mmcif_dict["_atom_site.Cartn_x"]) y_list=map(float, mmcif_dict["_atom_site.Cartn_y"]) z_list=map(float, mmcif_dict["_atom_site.Cartn_z"]) alt_list=mmcif_dict["_atom_site.label_alt_id"] b_factor_list=mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list=mmcif_dict["_atom_site.occupancy"] fieldname_list=mmcif_dict["_atom_site.group_PDB"] try: serial_list = [int(n) for n in mmcif_dict["_atom_site.pdbx_PDB_model_num"]] except KeyError: # No model number column serial_list = None except ValueError: # Invalid model number (malformed file) raise PDBConstructionException("Invalid model number") try: aniso_u11=mmcif_dict["_atom_site.aniso_U[1][1]"] aniso_u12=mmcif_dict["_atom_site.aniso_U[1][2]"] aniso_u13=mmcif_dict["_atom_site.aniso_U[1][3]"] aniso_u22=mmcif_dict["_atom_site.aniso_U[2][2]"] aniso_u23=mmcif_dict["_atom_site.aniso_U[2][3]"] aniso_u33=mmcif_dict["_atom_site.aniso_U[3][3]"] aniso_flag=1 except KeyError: # no anisotropic B factors aniso_flag=0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list=mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list=mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id=None current_residue_id=None structure_builder=self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_seg(" ") # Historically, Biopython PDB parser uses model_id to mean array index # so serial_id means the Model ID specified in the file current_model_id = 0 current_serial_id = 0 for i in xrange(0, len(atom_id_list)): x=x_list[i] y=y_list[i] z=z_list[i] resname=residue_id_list[i] chainid=chain_id_list[i] altloc=alt_list[i] if altloc==".": altloc=" " resseq=seq_id_list[i] name=atom_id_list[i] # occupancy & B factor try: tempfactor=float(b_factor_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing B factor") try: occupancy=float(occupancy_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing occupancy") fieldname=fieldname_list[i] if fieldname=="HETATM": hetatm_flag="H" else: hetatm_flag=" " if serial_list is not None: # model column exists; use it serial_id = serial_list[i] if current_serial_id != serial_id: # if serial changes, update it and start new model current_serial_id = serial_id structure_builder.init_model(current_model_id, current_serial_id) current_model_id += 1 else: # no explicit model column; initialize single model structure_builder.init_model(current_model_id) if current_chain_id!=chainid: current_chain_id=chainid structure_builder.init_chain(current_chain_id) current_residue_id=resseq icode, int_resseq=self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) elif current_residue_id!=resseq: current_residue_id=resseq icode, int_resseq=self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord=numpy.array((x, y, z), 'f') element = element_list[i] if element_list else None structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name, element=element) if aniso_flag==1: u=(aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i]) mapped_anisou=map(float, u) anisou_array=numpy.array(mapped_anisou, 'f') structure_builder.set_anisou(anisou_array) # Now try to set the cell try: a=float(mmcif_dict["_cell.length_a"]) b=float(mmcif_dict["_cell.length_b"]) c=float(mmcif_dict["_cell.length_c"]) alpha=float(mmcif_dict["_cell.angle_alpha"]) beta=float(mmcif_dict["_cell.angle_beta"]) gamma=float(mmcif_dict["_cell.angle_gamma"]) cell=numpy.array((a, b, c, alpha, beta, gamma), 'f') spacegroup=mmcif_dict["_symmetry.space_group_name_H-M"] spacegroup=spacegroup[1:-1] # get rid of quotes!! if spacegroup is None: raise Exception structure_builder.set_symmetry(spacegroup, cell) except: pass # no cell found, so just ignore def _get_icode(self, resseq): """Tries to return the icode. In MMCIF files this is just part of resseq! In PDB files, it's a separate field.""" last_resseq_char=resseq[-1] if last_resseq_char in ascii_letters: icode=last_resseq_char int_resseq=int(resseq[0:-1]) else: icode=" " int_resseq=int(resseq) return icode, int_resseq
class MMCIFParser: """Parse a mmCIF file and return a Structure object.""" def __init__(self, structure_builder=None, QUIET=False): """Create a PDBParser object. The mmCIF parser calls a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the MMCIParser object itself, but if the user provides his/her own StructureBuilder object, the latter is used instead. Arguments: - structure_builder - an optional user implemented StructureBuilder class. - QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be suppressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the mmCIF file! """ if structure_builder is not None: self._structure_builder = structure_builder else: self._structure_builder = StructureBuilder() self.header = None # self.trailer = None self.line_counter = 0 self.build_structure = None self.QUIET = bool(QUIET) # Public methods def get_structure(self, structure_id, filename): """Return the structure. Arguments: - structure_id - string, the id that will be used for the structure - filename - name of mmCIF file, OR an open text mode file handle """ with warnings.catch_warnings(): if self.QUIET: warnings.filterwarnings("ignore", category=PDBConstructionWarning) self._mmcif_dict = MMCIF2Dict(filename) self._build_structure(structure_id) self._structure_builder.set_header(self._get_header()) return self._structure_builder.get_structure() # Private methods def _mmcif_get(self, key, dict, deflt): if key in dict: rslt = dict[key][0] if "?" != rslt: return rslt return deflt def _update_header_entry(self, target_key, keys): md = self._mmcif_dict for key in keys: val = md.get(key) try: item = val[0] except (TypeError, IndexError): continue if item != "?": self.header[target_key] = item break def _get_header(self): self.header = { "name": "", "head": "", "idcode": "", "deposition_date": "", "structure_method": "", "resolution": 0.0, } self._update_header_entry( "idcode", ["_entry_id", "_exptl.entry_id", "_struct.entry_id"]) self._update_header_entry("name", ["_struct.title"]) self._update_header_entry( "head", ["_struct_keywords.pdbx_keywords", "_struct_keywords.text"]) self._update_header_entry( "deposition_date", ["_pdbx_database_status.recvd_initial_deposition_date"]) self._update_header_entry("structure_method", ["_exptl.method"]) self._update_header_entry( "resolution", ["_refine.ls_d_res_high", "_refine_hist.d_res_high"]) self.header["resolution"] = float(self.header["resolution"]) return self.header def _build_structure(self, structure_id): # two special chars as placeholders in the mmCIF format # for item values that cannot be explicitly assigned # see: pdbx/mmcif syntax web page _unassigned = {".", "?"} mmcif_dict = self._mmcif_dict atom_id_list = mmcif_dict["_atom_site.label_atom_id"] residue_id_list = mmcif_dict["_atom_site.label_comp_id"] try: element_list = mmcif_dict["_atom_site.type_symbol"] except KeyError: element_list = None chain_id_list = mmcif_dict["_atom_site.auth_asym_id"] x_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_x"]] y_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_y"]] z_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_z"]] alt_list = mmcif_dict["_atom_site.label_alt_id"] icode_list = mmcif_dict["_atom_site.pdbx_PDB_ins_code"] b_factor_list = mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list = mmcif_dict["_atom_site.occupancy"] fieldname_list = mmcif_dict["_atom_site.group_PDB"] try: serial_list = [ int(n) for n in mmcif_dict["_atom_site.pdbx_PDB_model_num"] ] except KeyError: # No model number column serial_list = None except ValueError: # Invalid model number (malformed file) raise PDBConstructionException("Invalid model number") try: aniso_u11 = mmcif_dict["_atom_site_anisotrop.U[1][1]"] aniso_u12 = mmcif_dict["_atom_site_anisotrop.U[1][2]"] aniso_u13 = mmcif_dict["_atom_site_anisotrop.U[1][3]"] aniso_u22 = mmcif_dict["_atom_site_anisotrop.U[2][2]"] aniso_u23 = mmcif_dict["_atom_site_anisotrop.U[2][3]"] aniso_u33 = mmcif_dict["_atom_site_anisotrop.U[3][3]"] aniso_flag = 1 except KeyError: # no anisotropic B factors aniso_flag = 0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list = mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list = mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id = None current_residue_id = None current_resname = None structure_builder = self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_seg(" ") # Historically, Biopython PDB parser uses model_id to mean array index # so serial_id means the Model ID specified in the file current_model_id = -1 current_serial_id = -1 for i in range(0, len(atom_id_list)): # set the line_counter for 'ATOM' lines only and not # as a global line counter found in the PDBParser() # this number should match the '_atom_site.id' index in the MMCIF structure_builder.set_line_counter(i) x = x_list[i] y = y_list[i] z = z_list[i] resname = residue_id_list[i] chainid = chain_id_list[i] altloc = alt_list[i] if altloc in _unassigned: altloc = " " int_resseq = int(seq_id_list[i]) icode = icode_list[i] if icode in _unassigned: icode = " " name = atom_id_list[i] # occupancy & B factor try: tempfactor = float(b_factor_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing B factor") try: occupancy = float(occupancy_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing occupancy") fieldname = fieldname_list[i] if fieldname == "HETATM": if resname == "HOH" or resname == "WAT": hetatm_flag = "W" else: hetatm_flag = "H" else: hetatm_flag = " " resseq = (hetatm_flag, int_resseq, icode) if serial_list is not None: # model column exists; use it serial_id = serial_list[i] if current_serial_id != serial_id: # if serial changes, update it and start new model current_serial_id = serial_id current_model_id += 1 structure_builder.init_model(current_model_id, current_serial_id) current_chain_id = None current_residue_id = None current_resname = None else: # no explicit model column; initialize single model structure_builder.init_model(current_model_id) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = None current_resname = None if current_residue_id != resseq or current_resname != resname: current_residue_id = resseq current_resname = resname structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord = numpy.array((x, y, z), "f") element = element_list[i].upper() if element_list else None structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name, element=element) if aniso_flag == 1 and i < len(aniso_u11): u = ( aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i], ) mapped_anisou = [float(_) for _ in u] anisou_array = numpy.array(mapped_anisou, "f") structure_builder.set_anisou(anisou_array) # Now try to set the cell try: a = float(mmcif_dict["_cell.length_a"][0]) b = float(mmcif_dict["_cell.length_b"][0]) c = float(mmcif_dict["_cell.length_c"][0]) alpha = float(mmcif_dict["_cell.angle_alpha"][0]) beta = float(mmcif_dict["_cell.angle_beta"][0]) gamma = float(mmcif_dict["_cell.angle_gamma"][0]) cell = numpy.array((a, b, c, alpha, beta, gamma), "f") spacegroup = mmcif_dict["_symmetry.space_group_name_H-M"][0] spacegroup = spacegroup[1:-1] # get rid of quotes!! if spacegroup is None: raise Exception structure_builder.set_symmetry(spacegroup, cell) except Exception: pass # no cell found, so just ignore
def pdb_extract(structure, **kwargs): # model to extract from pdb extract_model = None if not 'model' in kwargs else kwargs['model'] new_model_id = -1 if not 'new_model' in kwargs else kwargs['new_model'] extract_chain = None if not 'chain' in kwargs else kwargs['chain'] first_res = None if not 'first_res' in kwargs else kwargs['first_res'] last_res = None if not 'last_res' in kwargs else kwargs['last_res'] new_first_res = None if not 'new_first_res' in kwargs else kwargs[ 'new_first_res'] gap_count = 0 if not 'gap_count' in kwargs else kwargs['gap_count'] water_id = None if not 'water' in kwargs else kwargs['water'] model_rebumber_flag = bool((extract_model is not None) or new_model_id >= 0) res_renumber_flag = bool(first_res or last_res or new_first_res or gap_count) structure_builder = StructureBuilder() structure_builder.init_structure('pdb_extract') structure_builder.set_line_counter(0) line_counter = 0 start_resseq_by_default = 1 if not new_first_res else new_first_res for model in structure: if model_rebumber_flag and \ ( extract_model is not None ) and model.get_id() != extract_model: continue if model_rebumber_flag and new_model_id >= 0: this_model_id = new_model_id new_model_id += 1 else: this_model_id = model.get_id() structure_builder.init_model(this_model_id, this_model_id) for chain in model: if extract_chain and chain.get_id() != extract_chain: continue structure_builder.init_seg(' ') structure_builder.init_chain(chain.get_id()) resdict = {} if res_renumber_flag: # first_res = res_range_tuple[0] # last_res = res_range_tuple[1] resdict['before'] = select_residues_from_chain( chain, first_res=first_res, gap_count=gap_count) resdict['hit'] = select_residues_from_chain( chain, first_res=first_res, last_res=last_res) resdict['after'] = select_residues_from_chain( chain, last_res=last_res, gap_count=gap_count) else: resdict['before'] = [] resdict['hit'] = chain.get_list() resdict['after'] = [] new_resseq = start_resseq_by_default - len(resdict['before']) resdict['water'] = chain_water_id(chain, water_id) for key in ['before', 'hit', 'after', 'water']: for residue in resdict[key]: if res_renumber_flag: new_resid = ' ', new_resseq, ' ' else: new_resid = residue.get_id() structure_builder.init_residue(residue.get_resname(), *new_resid) residue_atoms = None if key == 'before': residue_atoms = [atom for atom in residue if \ (atom.get_name() == 'C' or atom.get_name() == 'O')] elif key == 'hit' or key == 'water': residue_atoms = residue.get_list() elif key == 'after': residue_atoms = [atom for atom in residue if \ (atom.get_name() == 'N' or atom.get_name() == 'HN')] for atom in residue_atoms: structure_builder.init_atom(atom.get_name(), atom.get_coord(), atom.get_bfactor(), atom.get_occupancy(), atom.get_altloc(), atom.get_fullname()) structure_builder.set_line_counter(line_counter) line_counter += 1 new_resseq += 1 if key == 'water' and gap_count and len( resdict['after']) != gap_count: new_resseq += gap_count - len(resdict['after']) out_structure = structure_builder.get_structure() return out_structure
def read_PIC( file: TextIO, verbose: bool = False, quick: bool = False, defaults: bool = False, ) -> Structure: """Load Protein Internal Coordinate (.pic) data from file. PIC file format: - comment lines start with # - (optional) PDB HEADER record - idcode and deposition date recommended but optional - deposition date in PDB format or as changed by Biopython - (optional) PDB TITLE record - repeat: - Biopython Residue Full ID - sets residue IDs of returned structure - (optional) PDB N, CA, C ATOM records for chain start - (optional) PIC Hedra records for residue - (optional) PIC Dihedra records for residue - (optional) BFAC records listing AtomKeys and b-factors An improvement would define relative positions for HOH (water) entries. Defaults will be supplied for any value if defaults=True. Default values are supplied in ic_data.py, but structures degrade quickly with any deviation from true coordinates. Experiment with :data:`Bio.PDB.internal_coords.IC_Residue.pic_flags` options to :func:`write_PIC` to verify this. N.B. dihedron (i-1)C-N-CA-CB is ignored in assembly if O exists. C-beta is by default placed using O-C-CA-CB, but O is missing in some PDB file residues, which means the sidechain cannot be placed. The alternate CB path (i-1)C-N-CA-CB is provided to circumvent this, but if this is needed then it must be adjusted in conjunction with PHI ((i-1)C-N-CA-C) as they overlap (see :meth:`.bond_set` and :meth:`.bond_rotate` to handle this automatically). :param Bio.File file: :func:`.as_handle` file name or handle :param bool verbose: complain when lines not as expected :param bool quick: don't check residues for all dihedra (no default values) :param bool defaults: create di/hedra as needed from reference database. Amide proton created if 'H' is in IC_Residue.accept_atoms :returns: Biopython Structure object, Residues with .internal_coord attributes but no coordinates except for chain start N, CA, C atoms if supplied, **OR** None on parse fail (silent unless verbose=True) """ proton = "H" in IC_Residue.accept_atoms pdb_hdr_re = re.compile( r"^HEADER\s{4}(?P<cf>.{1,40})" r"(?:\s+(?P<dd>\d\d\d\d-\d\d-\d\d|\d\d-\w\w\w-\d\d))?" r"(?:\s+(?P<id>[0-9A-Z]{4}))?\s*$") pdb_ttl_re = re.compile(r"^TITLE\s{5}(?P<ttl>.+)\s*$") biop_id_re = re.compile(r"^\('(?P<pid>[^\s]*)',\s(?P<mdl>\d+),\s" r"'(?P<chn>\s|\w)',\s\('(?P<het>\s|[\w\s-]+)" r"',\s(?P<pos>-?\d+),\s'(?P<icode>\s|\w)'\)\)" r"\s+(?P<res>[\w]{1,3})" r"(\s\[(?P<segid>[a-zA-z\s]+)\])?" r"\s*$") pdb_atm_re = re.compile(r"^ATOM\s\s(?:\s*(?P<ser>\d+))\s(?P<atm>[\w\s]{4})" r"(?P<alc>\w|\s)(?P<res>[\w]{3})\s(?P<chn>.)" r"(?P<pos>[\s\-\d]{4})(?P<icode>[A-Za-z\s])\s\s\s" r"(?P<x>[\s\-\d\.]{8})(?P<y>[\s\-\d\.]{8})" r"(?P<z>[\s\-\d\.]{8})(?P<occ>[\s\d\.]{6})" r"(?P<tfac>[\s\d\.]{6})\s{6}" r"(?P<segid>[a-zA-z\s]{4})(?P<elm>.{2})" r"(?P<chg>.{2})?\s*$") bfac_re = re.compile(r"^BFAC:\s([^\s]+\s+[\-\d\.]+)" r"\s*([^\s]+\s+[\-\d\.]+)?" r"\s*([^\s]+\s+[\-\d\.]+)?" r"\s*([^\s]+\s+[\-\d\.]+)?" r"\s*([^\s]+\s+[\-\d\.]+)?") bfac2_re = re.compile(r"([^\s]+)\s+([\-\d\.]+)") struct_builder = StructureBuilder() # init empty header dict # - could use to parse HEADER and TITLE lines except # deposition_date format changed from original PDB header header_dict = _parse_pdb_header_list([]) curr_SMCS = [None, None, None, None] # struct model chain seg SMCS_init = [ struct_builder.init_structure, struct_builder.init_model, struct_builder.init_chain, struct_builder.init_seg, ] sb_res = None rkl = None sb_chain = None sbcic = None sbric = None akc = {} hl12 = {} ha = {} hl23 = {} da = {} bfacs = {} orphan_aks = set() # [] tr = [] # this residue pr = [] # previous residue def akcache(akstr: str) -> AtomKey: """Maintain dictionary of AtomKeys seen while reading this PIC file.""" # akstr: full AtomKey string read from .pic file, includes residue info try: return akc[akstr] except (KeyError): ak = akc[akstr] = AtomKey(akstr) return ak def link_residues(ppr: List[Residue], pr: List[Residue]) -> None: """Set next and prev links between i-1 and i-2 residues.""" for p_r in pr: pric = p_r.internal_coord for p_p_r in ppr: ppric = p_p_r.internal_coord if p_r.id[0] == " ": # not heteroatoms if pric not in ppric.rnext: ppric.rnext.append(pric) if p_p_r.id[0] == " ": if ppric not in pric.rprev: pric.rprev.append(ppric) def process_hedron( a1: str, a2: str, a3: str, l12: str, ang: str, l23: str, ric: IC_Residue, ) -> Tuple: """Create Hedron on current (sbcic) Chain.internal_coord.""" ek = (akcache(a1), akcache(a2), akcache(a3)) atmNdx = AtomKey.fields.atm accpt = IC_Residue.accept_atoms if not all(ek[i].akl[atmNdx] in accpt for i in range(3)): return hl12[ek] = float(l12) ha[ek] = float(ang) hl23[ek] = float(l23) sbcic.hedra[ek] = ric.hedra[ek] = h = Hedron(ek) h.cic = sbcic ak_add(ek, ric) return ek def default_hedron(ek: Tuple, ric: IC_Residue) -> None: """Create Hedron based on same rdh_class hedra in ref database. Adds Hedron to current Chain.internal_coord, see ic_data for default values and reference database source. """ aks = [] hkey = None atmNdx = AtomKey.fields.atm resNdx = AtomKey.fields.resname resPos = AtomKey.fields.respos aks = [ek[i].akl for i in range(3)] atpl = tuple([aks[i][atmNdx] for i in range(3)]) res = aks[0][resNdx] if (aks[0][resPos] != aks[2][resPos] # hedra crosses amide bond so not reversed or atpl == ("N", "CA", "C") # or chain start tau or atpl in ic_data_backbone # or found forward hedron in ic_data or (res not in ["A", "G"] and atpl in ic_data_sidechains[res])): hkey = ek rhcl = [aks[i][resNdx] + aks[i][atmNdx] for i in range(3)] try: dflts = hedra_defaults["".join(rhcl)][0] except KeyError: if aks[0][resPos] == aks[1][resPos]: rhcl = [aks[i][resNdx] + aks[i][atmNdx] for i in range(2)] rhc = "".join(rhcl) + "X" + aks[2][atmNdx] else: rhcl = [ aks[i][resNdx] + aks[i][atmNdx] for i in range(1, 3) ] rhc = "X" + aks[0][atmNdx] + "".join(rhcl) dflts = hedra_defaults[rhc][0] else: # must be reversed or fail hkey = ek[::-1] rhcl = [aks[i][resNdx] + aks[i][atmNdx] for i in range(2, -1, -1)] dflts = hedra_defaults["".join(rhcl)][0] process_hedron( str(hkey[0]), str(hkey[1]), str(hkey[2]), dflts[0], dflts[1], dflts[2], ric, ) if verbose: print(f" default for {ek}") def hedra_check(dk: str, ric: IC_Residue) -> None: """Confirm both hedra present for dihedron key, use default if set.""" if dk[0:3] not in sbcic.hedra and dk[2::-1] not in sbcic.hedra: if defaults: default_hedron(dk[0:3], ric) else: print(f"{dk} missing h1") if dk[1:4] not in sbcic.hedra and dk[3:0:-1] not in sbcic.hedra: if defaults: default_hedron(dk[1:4], ric) else: print(f"{dk} missing h2") def process_dihedron(a1: str, a2: str, a3: str, a4: str, dangle: str, ric: IC_Residue) -> Set: """Create Dihedron on current Chain.internal_coord.""" ek = ( akcache(a1), akcache(a2), akcache(a3), akcache(a4), ) atmNdx = AtomKey.fields.atm accpt = IC_Residue.accept_atoms if not all(ek[i].akl[atmNdx] in accpt for i in range(4)): return da[ek] = float(dangle) sbcic.dihedra[ek] = ric.dihedra[ek] = d = Dihedron(ek) d.cic = sbcic if not quick: hedra_check(ek, ric) ak_add(ek, ric) return ek def default_dihedron(ek: List, ric: IC_Residue) -> None: """Create Dihedron based on same residue class dihedra in ref database. Adds Dihedron to current Chain.internal_coord, see ic_data for default values and reference database source. """ atmNdx = AtomKey.fields.atm resNdx = AtomKey.fields.resname resPos = AtomKey.fields.respos rdclass = "" dclass = "" for ak in ek: dclass += ak.akl[atmNdx] rdclass += ak.akl[resNdx] + ak.akl[atmNdx] if dclass == "NCACN": rdclass = rdclass[0:7] + "XN" elif dclass == "CACNCA": rdclass = "XCAXC" + rdclass[5:] elif dclass == "CNCAC": rdclass = "XC" + rdclass[2:] if rdclass in dihedra_primary_defaults: process_dihedron( str(ek[0]), str(ek[1]), str(ek[2]), str(ek[3]), dihedra_primary_defaults[rdclass][0], ric, ) if verbose: print(f" default for {ek}") elif rdclass in dihedra_secondary_defaults: primAngle, offset = dihedra_secondary_defaults[rdclass] rname = ek[2].akl[resNdx] rnum = int(ek[2].akl[resPos]) paKey = None if primAngle == ("N", "CA", "C", "N") and ek[0].ric.rnext != []: paKey = [ AtomKey((rnum, None, rname, primAngle[x], None, None)) for x in range(3) ] rnext = ek[0].ric.rnext paKey.append( AtomKey(( rnext[0].rbase[0], None, rnext[0].rbase[2], "N", None, None, ))) paKey = tuple(paKey) elif primAngle == ("CA", "C", "N", "CA"): prname = pr.akl[0][resNdx] prnum = pr.akl[0][resPos] paKey = [ AtomKey(prnum, None, prname, primAngle[x], None, None) for x in range(0, 2) ] paKey.add([ AtomKey((rnum, None, rname, primAngle[x], None, None)) for x in range(2, 4) ]) paKey = tuple(paKey) else: paKey = tuple( AtomKey((rnum, None, rname, atm, None, None)) for atm in primAngle) if paKey in da: process_dihedron( str(ek[0]), str(ek[1]), str(ek[2]), str(ek[3]), da[paKey] + dihedra_secondary_defaults[rdclass][1], ric, ) if verbose: print(f" secondary default for {ek}") elif rdclass in dihedra_secondary_xoxt_defaults: if primAngle == ("C", "N", "CA", "C"): # primary for alt cb # no way to trigger alt cb with default=True # because will generate default N-CA-C-O prname = pr.akl[0][resNdx] prnum = pr.akl[0][resPos] paKey = [ AtomKey(prnum, None, prname, primAngle[0], None, None) ] paKey.add([ AtomKey((rnum, None, rname, primAngle[x], None, None)) for x in range(1, 4) ]) paKey = tuple(paKey) else: primAngle, offset = dihedra_secondary_xoxt_defaults[ rdclass] rname = ek[2].akl[resNdx] rnum = int(ek[2].akl[resPos]) paKey = tuple( AtomKey((rnum, None, rname, atm, None, None)) for atm in primAngle) if paKey in da: process_dihedron( str(ek[0]), str(ek[1]), str(ek[2]), str(ek[3]), da[paKey] + offset, ric, ) if verbose: print(f" oxt default for {ek}") else: print(f"missing primary angle {paKey} {primAngle} to " f"generate {rnum}{rname} {rdclass}") else: print( f"missing {ek} -> {rdclass} ({dclass}) not found in primary or" " secondary defaults") def dihedra_check(ric: IC_Residue) -> None: """Look for required dihedra in residue, generate defaults if set.""" # rnext should be set def ake_recurse(akList: List) -> List: """Bulid combinatorics of AtomKey lists.""" car = akList[0] if len(akList) > 1: retList = [] for ak in car: cdr = akList[1:] rslt = ake_recurse(cdr) for r in rslt: r.insert(0, ak) retList.append(r) return retList else: if len(car) == 1: return [list(car)] else: retList = [[ak] for ak in car] return retList def ak_expand(eLst: List) -> List: """Expand AtomKey list with altlocs, all combinatorics.""" retList = [] for edron in eLst: newList = [] for ak in edron: rslt = ak.ric.split_akl([ak]) rlst = [r[0] for r in rslt] if rlst != []: newList.append(rlst) else: newList.append([ak]) rslt = ake_recurse(newList) for r in rslt: retList.append(r) return retList # dihedra_check processing starts here # generate the list of dihedra this residue should have chkLst = [] sN, sCA, sC = AtomKey(ric, "N"), AtomKey(ric, "CA"), AtomKey(ric, "C") sO, sCB, sH = AtomKey(ric, "O"), AtomKey(ric, "CB"), AtomKey(ric, "H") if ric.rnext != []: for rn in ric.rnext: nN, nCA, nC = ( AtomKey(rn, "N"), AtomKey(rn, "CA"), AtomKey(rn, "C"), ) # intermediate residue, need psi, phi, omg chkLst.append((sN, sCA, sC, nN)) # psi chkLst.append((sCA, sC, nN, nCA)) # omg i+1 chkLst.append((sC, nN, nCA, nC)) # phi i+1 else: chkLst.append((sN, sCA, sC, AtomKey(ric, "OXT"))) # psi rn = "(no rnext)" chkLst.append((sN, sCA, sC, sO)) # locate backbone O if ric.lc != "G": chkLst.append((sO, sC, sCA, sCB)) # locate CB if ric.rprev != [] and ric.lc != "P" and proton: chkLst.append((sC, sCA, sN, sH)) # amide proton try: for edron in ic_data_sidechains[ric.lc]: if len(edron) > 3: # dihedra only if all(not atm[0] == "H" for atm in edron): akl = [AtomKey(ric, atm) for atm in edron[0:4]] chkLst.append(akl) except KeyError: pass # now compare generated list to ric.dihedra, get defaults if set. chkLst = ak_expand(chkLst) altloc_ndx = AtomKey.fields.altloc for dk in chkLst: if tuple(dk) in ric.dihedra: pass elif sH in dk: pass # ignore missing hydrogens elif all(atm.akl[altloc_ndx] is None for atm in dk): if defaults: default_dihedron(dk, ric) else: if verbose: print(f"{ric}-{rn} missing {dk}") else: # print(f"skip {ek}") pass # ignore missing combinatoric of altloc atoms # need more here? def ak_add(ek: set, ric: IC_Residue) -> None: """Allocate edron key AtomKeys to current residue as appropriate. A hedron or dihedron may span a backbone amide bond, this routine allocates atoms in the (h/di)edron to the ric residue or saves them for a residue yet to be processed. :param set ek: AtomKeys in edron :param IC_Residue ric: current residue to assign AtomKeys to """ res = ric.residue reskl = ( str(res.id[1]), (None if res.id[2] == " " else res.id[2]), ric.lc, ) for ak in ek: if ak.ric is None: sbcic.akset.add(ak) if ak.akl[0:3] == reskl: ak.ric = ric ric.ak_set.add(ak) else: orphan_aks.add(ak) def finish_chain() -> None: """Do last rnext, rprev links and process chain edra data.""" link_residues(pr, tr) # check/confirm completeness if not quick: for r in pr: dihedra_check(r.internal_coord) for r in tr: dihedra_check(r.internal_coord) if ha != {}: sha = {k: ha[k] for k in sorted(ha)} shl12 = {k: hl12[k] for k in sorted(hl12)} shl23 = {k: hl23[k] for k in sorted(hl23)} sbcic._hedraDict2chain(shl12, sha, shl23, da, bfacs) # read_PIC processing starts here: with as_handle(file, mode="r") as handle: for line in handle.readlines(): if line.startswith("#"): pass # skip comment lines elif line.startswith("HEADER "): m = pdb_hdr_re.match(line) if m: header_dict["head"] = m.group("cf") # classification header_dict["idcode"] = m.group("id") header_dict["deposition_date"] = m.group("dd") elif verbose: print("Reading pic file", file, "HEADER parse fail: ", line) elif line.startswith("TITLE "): m = pdb_ttl_re.match(line) if m: header_dict["name"] = m.group("ttl").strip() # print('TTL: ', m.group('ttl').strip()) elif verbose: print("Reading pic file", file, "TITLE parse fail:, ", line) elif line.startswith("("): # Biopython ID line for Residue m = biop_id_re.match(line) if m: # check SMCS = Structure, Model, Chain, SegID segid = m.group(9) if segid is None: segid = " " this_SMCS = [ m.group(1), int(m.group(2)), m.group(3), segid, ] if curr_SMCS != this_SMCS: if curr_SMCS[:3] != this_SMCS[:3] and ha != {}: # chain change so process current chain data finish_chain() akc = {} # atomkey cache, used by akcache() hl12 = {} # hedra key -> len12 ha = {} # -> hedra angle hl23 = {} # -> len23 da = {} # dihedra key -> angle value bfacs = {} # atomkey string -> b-factor # init new Biopython SMCS level as needed for i in range(4): if curr_SMCS[i] != this_SMCS[i]: SMCS_init[i](this_SMCS[i]) curr_SMCS[i] = this_SMCS[i] if i == 0: # 0 = init structure so add header struct_builder.set_header(header_dict) elif i == 1: # new model means new chain and new segid curr_SMCS[2] = curr_SMCS[3] = None elif i == 2: # new chain so init internal_coord sb_chain = struct_builder.chain sbcic = sb_chain.internal_coord = IC_Chain( sb_chain) struct_builder.init_residue( m.group("res"), m.group("het"), int(m.group("pos")), m.group("icode"), ) sb_res = struct_builder.residue if sb_res.id[0] != " ": # skip hetatm continue if 2 == sb_res.is_disordered(): for r in sb_res.child_dict.values(): if not r.internal_coord: sb_res = r break # added to disordered res tr.append(sb_res) else: # new res so fix up previous residue as feasible link_residues(pr, tr) if not quick: for r in pr: # create di/hedra if default for residue i-1 # just linked dihedra_check(r.internal_coord) pr = tr tr = [sb_res] sbric = sb_res.internal_coord = IC_Residue( sb_res) # no atoms so no rak sbric.cic = sbcic rkl = ( str(sb_res.id[1]), (None if sb_res.id[2] == " " else sb_res.id[2]), sbric.lc, ) sbcic.ordered_aa_ic_list.append(sbric) # update AtomKeys w/o IC_Residue references, in case # chain ends before di/hedra sees them (2XHE test case) for ak in orphan_aks: if ak.akl[0:3] == rkl: ak.ric = sbric sbric.ak_set.add(ak) # may need altoc support here orphan_aks = set( filter(lambda ak: ak.ric is None, orphan_aks)) else: if verbose: print( "Reading pic file", file, "residue ID parse fail: ", line, ) return None elif line.startswith("ATOM "): m = pdb_atm_re.match(line) if m: if sb_res is None: # ATOM without res spec already loaded, not a pic file if verbose: print( "Reading pic file", file, "ATOM without residue configured:, ", line, ) return None if sb_res.resname != m.group("res") or sb_res.id[1] != int( m.group("pos")): if verbose: print( "Reading pic file", file, "ATOM not in configured residue (", sb_res.resname, str(sb_res.id), "):", line, ) return None coord = numpy.array( ( float(m.group("x")), float(m.group("y")), float(m.group("z")), ), "f", ) struct_builder.init_atom( m.group("atm").strip(), coord, float(m.group("tfac")), float(m.group("occ")), m.group("alc"), m.group("atm"), int(m.group("ser")), m.group("elm").strip(), ) # reset because prev does not link to this residue # (chainBreak) pr = [] elif line.startswith("BFAC: "): m = bfac_re.match(line) if m: for bfac_pair in m.groups(): if bfac_pair is not None: m2 = bfac2_re.match(bfac_pair) bfacs[m2.group(1)] = float(m2.group(2)) # else: # print f"Reading pic file {file} B-factor fail: {line}" else: m = Edron.edron_re.match(line) if m and sb_res is not None: if m["a4"] is None: process_hedron( m["a1"], m["a2"], m["a3"], m["len12"], m["angle"], m["len23"], sb_res.internal_coord, ) else: process_dihedron( m["a1"], m["a2"], m["a3"], m["a4"], float(m["dihedral"]), sb_res.internal_coord, ) elif m: print( "PIC file: ", file, " error: no residue info before reading (di/h)edron: ", line, ) return None elif line.strip(): if verbose: print( "Reading PIC file", file, "parse fail on: .", line, ".", ) return None # reached end of input finish_chain() # print(report_PIC(struct_builder.get_structure())) return struct_builder.get_structure()
class MMCIFParser: def get_structure(self, structure_id, filename): self._mmcif_dict = MMCIF2Dict(filename) self._structure_builder = StructureBuilder() self._build_structure(structure_id) return self._structure_builder.get_structure() def _build_structure(self, structure_id): mmcif_dict = self._mmcif_dict atom_id_list = mmcif_dict["_atom_site.label_atom_id"] residue_id_list = mmcif_dict["_atom_site.label_comp_id"] seq_id_list = mmcif_dict["_atom_site.label_seq_id"] chain_id_list = mmcif_dict["_atom_site.label_asym_id"] x_list = map(float, mmcif_dict["_atom_site.Cartn_x"]) y_list = map(float, mmcif_dict["_atom_site.Cartn_y"]) z_list = map(float, mmcif_dict["_atom_site.Cartn_z"]) alt_list = mmcif_dict["_atom_site.label_alt_id"] b_factor_list = mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list = mmcif_dict["_atom_site.occupancy"] fieldname_list = mmcif_dict["_atom_site.group_PDB"] try: aniso_u11 = mmcif_dict["_atom_site.aniso_U[1][1]"] aniso_u12 = mmcif_dict["_atom_site.aniso_U[1][2]"] aniso_u13 = mmcif_dict["_atom_site.aniso_U[1][3]"] aniso_u22 = mmcif_dict["_atom_site.aniso_U[2][2]"] aniso_u23 = mmcif_dict["_atom_site.aniso_U[2][3]"] aniso_u33 = mmcif_dict["_atom_site.aniso_U[3][3]"] aniso_flag = 1 except KeyError: # no anisotropic B factors aniso_flag = 0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list = mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list = mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id = None current_residue_id = None current_model_id = 0 structure_builder = self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_model(current_model_id) structure_builder.init_seg(" ") for i in xrange(0, len(atom_id_list)): x = x_list[i] y = y_list[i] z = z_list[i] resname = residue_id_list[i] chainid = chain_id_list[i] altloc = alt_list[i] if altloc == ".": altloc = " " resseq = seq_id_list[i] name = atom_id_list[i] tempfactor = b_factor_list[i] occupancy = occupancy_list[i] fieldname = fieldname_list[i] if fieldname == "HETATM": hetatm_flag = "H" else: hetatm_flag = " " if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = resseq icode, int_resseq = self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) elif current_residue_id != resseq: current_residue_id = resseq icode, int_resseq = self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord = numpy.array((x, y, z), 'f') structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name) if aniso_flag == 1: u = (aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i]) mapped_anisou = map(float, u) anisou_array = numpy.array(mapped_anisou, 'f') structure_builder.set_anisou(anisou_array) # Now try to set the cell try: a = float(mmcif_dict["_cell.length_a"]) b = float(mmcif_dict["_cell.length_b"]) c = float(mmcif_dict["_cell.length_c"]) alpha = float(mmcif_dict["_cell.angle_alpha"]) beta = float(mmcif_dict["_cell.angle_beta"]) gamma = float(mmcif_dict["_cell.angle_gamma"]) cell = numpy.array((a, b, c, alpha, beta, gamma), 'f') spacegroup = mmcif_dict["_symmetry.space_group_name_H-M"] spacegroup = spacegroup[1:-1] # get rid of quotes!! if spacegroup == None: raise Exception structure_builder.set_symmetry(spacegroup, cell) except: pass # no cell found, so just ignore def _get_icode(self, resseq): """Tries to return the icode. In MMCIF files this is just part of resseq! In PDB files, it's a separate field.""" last_resseq_char = resseq[-1] if last_resseq_char in letters: icode = last_resseq_char int_resseq = int(resseq[0:-1]) else: icode = " " int_resseq = int(resseq) return icode, int_resseq
class MMCIFParser(object): """Parse a PDB file and return a Structure object.""" def __init__(self, structure_builder=None, QUIET=False): """Create a PDBParser object. The PDB parser call a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the MMCIParser object itself, but if the user provides his/her own StructureBuilder object, the latter is used instead. Arguments: - structure_builder - an optional user implemented StructureBuilder class. - QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be suppressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the PDB file! """ if structure_builder is not None: self._structure_builder = structure_builder else: self._structure_builder = StructureBuilder() # self.header = None # self.trailer = None self.line_counter = 0 self.build_structure = None self.QUIET = bool(QUIET) # Public methods def get_structure(self, structure_id, filename): """Return the structure. Arguments: - structure_id - string, the id that will be used for the structure - filename - name of the mmCIF file OR an open filehandle """ with warnings.catch_warnings(): if self.QUIET: warnings.filterwarnings("ignore", category=PDBConstructionWarning) self._mmcif_dict = MMCIF2Dict(filename) self._build_structure(structure_id) return self._structure_builder.get_structure() # Private methods def _build_structure(self, structure_id): mmcif_dict = self._mmcif_dict atom_id_list = mmcif_dict["_atom_site.label_atom_id"] residue_id_list = mmcif_dict["_atom_site.label_comp_id"] try: element_list = mmcif_dict["_atom_site.type_symbol"] except KeyError: element_list = None seq_id_list = mmcif_dict["_atom_site.label_seq_id"] chain_id_list = mmcif_dict["_atom_site.label_asym_id"] x_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_x"]] y_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_y"]] z_list = [float(x) for x in mmcif_dict["_atom_site.Cartn_z"]] alt_list = mmcif_dict["_atom_site.label_alt_id"] icode_list = mmcif_dict["_atom_site.pdbx_PDB_ins_code"] b_factor_list = mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list = mmcif_dict["_atom_site.occupancy"] fieldname_list = mmcif_dict["_atom_site.group_PDB"] try: serial_list = [int(n) for n in mmcif_dict["_atom_site.pdbx_PDB_model_num"]] except KeyError: # No model number column serial_list = None except ValueError: # Invalid model number (malformed file) raise PDBConstructionException("Invalid model number") try: aniso_u11 = mmcif_dict["_atom_site.aniso_U[1][1]"] aniso_u12 = mmcif_dict["_atom_site.aniso_U[1][2]"] aniso_u13 = mmcif_dict["_atom_site.aniso_U[1][3]"] aniso_u22 = mmcif_dict["_atom_site.aniso_U[2][2]"] aniso_u23 = mmcif_dict["_atom_site.aniso_U[2][3]"] aniso_u33 = mmcif_dict["_atom_site.aniso_U[3][3]"] aniso_flag = 1 except KeyError: # no anisotropic B factors aniso_flag = 0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list = mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list = mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id = None current_residue_id = None structure_builder = self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_seg(" ") # Historically, Biopython PDB parser uses model_id to mean array index # so serial_id means the Model ID specified in the file current_model_id = -1 current_serial_id = 0 for i in range(0, len(atom_id_list)): # set the line_counter for 'ATOM' lines only and not # as a global line counter found in the PDBParser() # this number should match the '_atom_site.id' index in the MMCIF structure_builder.set_line_counter(i) x = x_list[i] y = y_list[i] z = z_list[i] resname = residue_id_list[i] chainid = chain_id_list[i] altloc = alt_list[i] if altloc == ".": altloc = " " resseq = seq_id_list[i] icode = icode_list[i] if icode == "?": icode = " " name = atom_id_list[i] # occupancy & B factor try: tempfactor = float(b_factor_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing B factor") try: occupancy = float(occupancy_list[i]) except ValueError: raise PDBConstructionException("Invalid or missing occupancy") fieldname = fieldname_list[i] if fieldname == "HETATM": hetatm_flag = "H" else: hetatm_flag = " " if serial_list is not None: # model column exists; use it serial_id = serial_list[i] if current_serial_id != serial_id: # if serial changes, update it and start new model current_serial_id = serial_id current_model_id += 1 structure_builder.init_model(current_model_id, current_serial_id) current_chain_id = None current_residue_id = None else: # no explicit model column; initialize single model structure_builder.init_model(current_model_id) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) if current_residue_id != resseq: current_residue_id = resseq int_resseq = int(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord = numpy.array((x, y, z), 'f') element = element_list[i] if element_list else None structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name, element=element) if aniso_flag == 1: u = (aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i]) mapped_anisou = [float(x) for x in u] anisou_array = numpy.array(mapped_anisou, 'f') structure_builder.set_anisou(anisou_array) # Now try to set the cell try: a = float(mmcif_dict["_cell.length_a"]) b = float(mmcif_dict["_cell.length_b"]) c = float(mmcif_dict["_cell.length_c"]) alpha = float(mmcif_dict["_cell.angle_alpha"]) beta = float(mmcif_dict["_cell.angle_beta"]) gamma = float(mmcif_dict["_cell.angle_gamma"]) cell = numpy.array((a, b, c, alpha, beta, gamma), 'f') spacegroup = mmcif_dict["_symmetry.space_group_name_H-M"] spacegroup = spacegroup[1:-1] # get rid of quotes!! if spacegroup is None: raise Exception structure_builder.set_symmetry(spacegroup, cell) except Exception: pass # no cell found, so just ignore
class MMCIFParser(object): def get_structure(self, structure_id, filename): self._mmcif_dict=MMCIF2Dict(filename) self._structure_builder=StructureBuilder() self._build_structure(structure_id) return self._structure_builder.get_structure() def _build_structure(self, structure_id): mmcif_dict=self._mmcif_dict atom_id_list=mmcif_dict["_atom_site.label_atom_id"] residue_id_list=mmcif_dict["_atom_site.label_comp_id"] seq_id_list=mmcif_dict["_atom_site.label_seq_id"] chain_id_list=mmcif_dict["_atom_site.label_asym_id"] x_list=map(float, mmcif_dict["_atom_site.Cartn_x"]) y_list=map(float, mmcif_dict["_atom_site.Cartn_y"]) z_list=map(float, mmcif_dict["_atom_site.Cartn_z"]) alt_list=mmcif_dict["_atom_site.label_alt_id"] b_factor_list=mmcif_dict["_atom_site.B_iso_or_equiv"] occupancy_list=mmcif_dict["_atom_site.occupancy"] fieldname_list=mmcif_dict["_atom_site.group_PDB"] try: aniso_u11=mmcif_dict["_atom_site.aniso_U[1][1]"] aniso_u12=mmcif_dict["_atom_site.aniso_U[1][2]"] aniso_u13=mmcif_dict["_atom_site.aniso_U[1][3]"] aniso_u22=mmcif_dict["_atom_site.aniso_U[2][2]"] aniso_u23=mmcif_dict["_atom_site.aniso_U[2][3]"] aniso_u33=mmcif_dict["_atom_site.aniso_U[3][3]"] aniso_flag=1 except KeyError: # no anisotropic B factors aniso_flag=0 # if auth_seq_id is present, we use this. # Otherwise label_seq_id is used. if "_atom_site.auth_seq_id" in mmcif_dict: seq_id_list=mmcif_dict["_atom_site.auth_seq_id"] else: seq_id_list=mmcif_dict["_atom_site.label_seq_id"] # Now loop over atoms and build the structure current_chain_id=None current_residue_id=None current_model_id=0 structure_builder=self._structure_builder structure_builder.init_structure(structure_id) structure_builder.init_model(current_model_id) structure_builder.init_seg(" ") for i in xrange(0, len(atom_id_list)): x=x_list[i] y=y_list[i] z=z_list[i] resname=residue_id_list[i] chainid=chain_id_list[i] altloc=alt_list[i] if altloc==".": altloc=" " resseq=seq_id_list[i] name=atom_id_list[i] tempfactor=b_factor_list[i] occupancy=occupancy_list[i] fieldname=fieldname_list[i] if fieldname=="HETATM": hetatm_flag="H" else: hetatm_flag=" " if current_chain_id!=chainid: current_chain_id=chainid structure_builder.init_chain(current_chain_id) current_residue_id=resseq icode, int_resseq=self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) elif current_residue_id!=resseq: current_residue_id=resseq icode, int_resseq=self._get_icode(resseq) structure_builder.init_residue(resname, hetatm_flag, int_resseq, icode) coord=numpy.array((x, y, z), 'f') structure_builder.init_atom(name, coord, tempfactor, occupancy, altloc, name) if aniso_flag==1: u=(aniso_u11[i], aniso_u12[i], aniso_u13[i], aniso_u22[i], aniso_u23[i], aniso_u33[i]) mapped_anisou=map(float, u) anisou_array=numpy.array(mapped_anisou, 'f') structure_builder.set_anisou(anisou_array) # Now try to set the cell try: a=float(mmcif_dict["_cell.length_a"]) b=float(mmcif_dict["_cell.length_b"]) c=float(mmcif_dict["_cell.length_c"]) alpha=float(mmcif_dict["_cell.angle_alpha"]) beta=float(mmcif_dict["_cell.angle_beta"]) gamma=float(mmcif_dict["_cell.angle_gamma"]) cell=numpy.array((a, b, c, alpha, beta, gamma), 'f') spacegroup=mmcif_dict["_symmetry.space_group_name_H-M"] spacegroup=spacegroup[1:-1] # get rid of quotes!! if spacegroup==None: raise Exception structure_builder.set_symmetry(spacegroup, cell) except: pass # no cell found, so just ignore def _get_icode(self, resseq): """Tries to return the icode. In MMCIF files this is just part of resseq! In PDB files, it's a separate field.""" last_resseq_char=resseq[-1] if last_resseq_char in letters: icode=last_resseq_char int_resseq=int(resseq[0:-1]) else: icode=" " int_resseq=int(resseq) return icode, int_resseq
class PDBParser(object): """Parse a PDB file and return a Structure object.""" def __init__(self, PERMISSIVE=True, get_header=False, structure_builder=None, QUIET=False): """Create a PDBParser object. The PDB parser call a number of standard methods in an aggregated StructureBuilder object. Normally this object is instanciated by the PDBParser object itself, but if the user provides his/her own StructureBuilder object, the latter is used instead. Arguments: - PERMISSIVE - Evaluated as a Boolean. If false, exceptions in constructing the SMCRA data structure are fatal. If true (DEFAULT), the exceptions are caught, but some residues or atoms will be missing. THESE EXCEPTIONS ARE DUE TO PROBLEMS IN THE PDB FILE!. - structure_builder - an optional user implemented StructureBuilder class. - QUIET - Evaluated as a Boolean. If true, warnings issued in constructing the SMCRA data will be suppressed. If false (DEFAULT), they will be shown. These warnings might be indicative of problems in the PDB file! """ if structure_builder is not None: self.structure_builder = structure_builder else: self.structure_builder = StructureBuilder() self.header = None self.trailer = None self.line_counter = 0 self.PERMISSIVE = bool(PERMISSIVE) self.QUIET = bool(QUIET) # Public methods def get_structure(self, id, file): """Return the structure. Arguments: - id - string, the id that will be used for the structure - file - name of the PDB file OR an open filehandle """ with warnings.catch_warnings(): if self.QUIET: warnings.filterwarnings("ignore", category=PDBConstructionWarning) self.header = None self.trailer = None # Make a StructureBuilder instance (pass id of structure as parameter) self.structure_builder.init_structure(id) with as_handle(file, mode='rU') as handle: self._parse(handle.readlines()) self.structure_builder.set_header(self.header) # Return the Structure instance structure = self.structure_builder.get_structure() return structure def get_header(self): """Return the header.""" return self.header def get_trailer(self): """Return the trailer.""" return self.trailer # Private methods def _parse(self, header_coords_trailer): """Parse the PDB file (PRIVATE).""" # Extract the header; return the rest of the file self.header, coords_trailer = self._get_header(header_coords_trailer) # Parse the atomic data; return the PDB file trailer self.trailer = self._parse_coordinates(coords_trailer) def _get_header(self, header_coords_trailer): """Get the header of the PDB file, return the rest (PRIVATE).""" structure_builder = self.structure_builder i = 0 for i in range(0, len(header_coords_trailer)): structure_builder.set_line_counter(i + 1) line = header_coords_trailer[i] record_type = line[0:6] if record_type == "ATOM " or record_type == "HETATM" or record_type == "MODEL ": break header = header_coords_trailer[0:i] # Return the rest of the coords+trailer for further processing self.line_counter = i coords_trailer = header_coords_trailer[i:] header_dict = _parse_pdb_header_list(header) return header_dict, coords_trailer def _parse_coordinates(self, coords_trailer): """Parse the atomic data in the PDB file (PRIVATE).""" local_line_counter = 0 structure_builder = self.structure_builder current_model_id = 0 # Flag we have an open model model_open = 0 current_chain_id = None current_segid = None current_residue_id = None current_resname = None for i in range(0, len(coords_trailer)): line = coords_trailer[i].rstrip('\n') record_type = line[0:6] global_line_counter = self.line_counter + local_line_counter + 1 structure_builder.set_line_counter(global_line_counter) if record_type == "ATOM " or record_type == "HETATM": # Initialize the Model - there was no explicit MODEL record if not model_open: structure_builder.init_model(current_model_id) current_model_id += 1 model_open = 1 fullname = line[12:16] # get rid of whitespace in atom names split_list = fullname.split() if len(split_list) != 1: # atom name has internal spaces, e.g. " N B ", so # we do not strip spaces name = fullname else: # atom name is like " CA ", so we can strip spaces name = split_list[0] altloc = line[16] resname = line[17:20] chainid = line[21] try: serial_number = int(line[6:11]) except Exception: serial_number = 0 resseq = int(line[22:26].split()[0]) # sequence identifier icode = line[26] # insertion code if record_type == "HETATM": # hetero atom flag if resname == "HOH" or resname == "WAT": hetero_flag = "W" else: hetero_flag = "H" else: hetero_flag = " " residue_id = (hetero_flag, resseq, icode) # atomic coordinates try: x = float(line[30:38]) y = float(line[38:46]) z = float(line[46:54]) except Exception: # Should we allow parsing to continue in permissive mode? # If so, what coordinates should we default to? Easier to abort! raise PDBConstructionException("Invalid or missing coordinate(s) at line %i." % global_line_counter) coord = numpy.array((x, y, z), "f") # occupancy & B factor try: occupancy = float(line[54:60]) except Exception: self._handle_PDB_exception("Invalid or missing occupancy", global_line_counter) occupancy = None # Rather than arbitrary zero or one if occupancy is not None and occupancy < 0: # TODO - Should this be an error in strict mode? # self._handle_PDB_exception("Negative occupancy", # global_line_counter) # This uses fixed text so the warning occurs once only: warnings.warn("Negative occupancy in one or more atoms", PDBConstructionWarning) try: bfactor = float(line[60:66]) except Exception: self._handle_PDB_exception("Invalid or missing B factor", global_line_counter) bfactor = 0.0 # The PDB use a default of zero if the data is missing segid = line[72:76] element = line[76:78].strip().upper() if current_segid != segid: current_segid = segid structure_builder.init_seg(current_segid) if current_chain_id != chainid: current_chain_id = chainid structure_builder.init_chain(current_chain_id) current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) elif current_residue_id != residue_id or current_resname != resname: current_residue_id = residue_id current_resname = resname try: structure_builder.init_residue(resname, hetero_flag, resseq, icode) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) # init atom try: structure_builder.init_atom(name, coord, bfactor, occupancy, altloc, fullname, serial_number, element) except PDBConstructionException as message: self._handle_PDB_exception(message, global_line_counter) elif record_type == "ANISOU": anisou = [float(x) for x in (line[28:35], line[35:42], line[43:49], line[49:56], line[56:63], line[63:70])] # U's are scaled by 10^4 anisou_array = (numpy.array(anisou, "f") / 10000.0).astype("f") structure_builder.set_anisou(anisou_array) elif record_type == "MODEL ": try: serial_num = int(line[10:14]) except Exception: self._handle_PDB_exception("Invalid or missing model serial number", global_line_counter) serial_num = 0 structure_builder.init_model(current_model_id, serial_num) current_model_id += 1 model_open = 1 current_chain_id = None current_residue_id = None elif record_type == "END " or record_type == "CONECT": # End of atomic data, return the trailer self.line_counter += local_line_counter return coords_trailer[local_line_counter:] elif record_type == "ENDMDL": model_open = 0 current_chain_id = None current_residue_id = None elif record_type == "SIGUIJ": # standard deviation of anisotropic B factor siguij = [float(x) for x in (line[28:35], line[35:42], line[42:49], line[49:56], line[56:63], line[63:70])] # U sigma's are scaled by 10^4 siguij_array = (numpy.array(siguij, "f") / 10000.0).astype("f") structure_builder.set_siguij(siguij_array) elif record_type == "SIGATM": # standard deviation of atomic positions sigatm = [float(x) for x in (line[30:38], line[38:45], line[46:54], line[54:60], line[60:66])] sigatm_array = numpy.array(sigatm, "f") structure_builder.set_sigatm(sigatm_array) local_line_counter += 1 # EOF (does not end in END or CONECT) self.line_counter = self.line_counter + local_line_counter return [] def _handle_PDB_exception(self, message, line_counter): """Handle exception (PRIVATE). This method catches an exception that occurs in the StructureBuilder object (if PERMISSIVE), or raises it again, this time adding the PDB line number to the error message. """ message = "%s at line %i." % (message, line_counter) if self.PERMISSIVE: # just print a warning - some residues/atoms may be missing warnings.warn("PDBConstructionException: %s\n" "Exception ignored.\n" "Some atoms or residues may be missing in the data structure." % message, PDBConstructionWarning) else: # exceptions are fatal - raise again with new message (including line nr) raise PDBConstructionException(message)
def read_PIC(file): """Load Protein Internal Coordinate (PIC) data from file. PIC file format: # comment lines start with # (optional) PDB HEADER record - idcode and deposition date recommended but optional - deposition date in PDB format or as changed by Biopython (optional) PDB TITLE record repeat: Biopython Residue Full ID - sets ID of returned structure (optional) PDB ATOM records for chain start N, CA, C PIC Hedra records for residue PIC Dihedra records for residue :param Bio.File file: file name or handle :returns: Biopython Structure object, Residues with .pic attributes but no coordinates except for chain start N, CA, C atoms if supplied, or None on parse fail (silent, no exception rasied) """ pdb_hdr_re = re.compile( r'^HEADER\s{4}(?P<cf>.{1,40})' r'(?:\s+(?P<dd>\d\d\d\d-\d\d-\d\d|\d\d-\w\w\w-\d\d))?' r'(?:\s+(?P<id>[0-9A-Z]{4}))?\s*$', ) # ^\('(?P<pid>\w*)',\s(?P<mdl>\d+),\s'(?P<chn>\w)',\s\('(?P<het>\s|[\w-]+)',\s(?P<pos>\d+),\s'(?P<icode>\s|\w)'\)\)\s(?P<res>[A-Z]{3})\s(\[(?P<segid>[a-zA-z\s]{4})\])?\s*$ pdb_ttl_re = re.compile(r'^TITLE\s{5}(?P<ttl>.+)\s*$') biop_id_re = re.compile(r"^\('(?P<pid>\w*)',\s(?P<mdl>\d+),\s" r"'(?P<chn>\s|\w)',\s\('(?P<het>\s|[\w\s-]+)" r"',\s(?P<pos>-?\d+),\s'(?P<icode>\s|\w)'\)\)" r'\s+(?P<res>[\w]{1,3})' r'(\s\[(?P<segid>[a-zA-z\s]+)\])?' r'\s*$') pdb_atm_re = re.compile(r'^ATOM\s\s(?:\s*(?P<ser>\d+))\s(?P<atm>[\w\s]{4})' r'(?P<alc>\w|\s)(?P<res>[\w]{3})\s(?P<chn>.)' r'(?P<pos>[\s\-\d]{4})(?P<icode>[A-Za-z\s])\s\s\s' r'(?P<x>[\s\-\d\.]{8})(?P<y>[\s\-\d\.]{8})' r'(?P<z>[\s\-\d\.]{8})(?P<occ>[\s\d\.]{6})' r'(?P<tfac>[\s\d\.]{6})\s{6}' r'(?P<segid>[a-zA-z\s]{4})(?P<elm>.{2})' r'(?P<chg>.{2})?\s*$') bfac_re = re.compile(r'^BFAC:\s([^\s]+\s+[\-\d\.]+)' r'\s*([^\s]+\s+[\-\d\.]+)?' r'\s*([^\s]+\s+[\-\d\.]+)?' r'\s*([^\s]+\s+[\-\d\.]+)?' r'\s*([^\s]+\s+[\-\d\.]+)?') bfac2_re = re.compile(r'([^\s]+)\s+([\-\d\.]+)') struct_builder = StructureBuilder() # init empty header dict # - could use to parse HEADER and TITLE lines except # deposition_date format changed from original PDB header header_dict = _parse_pdb_header_list([]) curr_SMCS = [None, None, None, None] # struct model chain seg SMCS_init = [ struct_builder.init_structure, struct_builder.init_model, struct_builder.init_chain, struct_builder.init_seg ] sb_res = None with as_handle(file, mode='r') as handle: for aline in handle.readlines(): if aline.startswith('#'): pass # skip comment lines elif aline.startswith('HEADER '): m = pdb_hdr_re.match(aline) if m: header_dict['head'] = m.group('cf') # classification header_dict['idcode'] = m.group('id') header_dict['deposition_date'] = m.group('dd') else: print('Reading pic file', file, 'HEADER fail: ', aline) pass elif aline.startswith('TITLE '): m = pdb_ttl_re.match(aline) if m: header_dict['name'] = m.group('ttl').strip() # print('TTL: ', m.group('ttl').strip()) else: print('Reading pic file', file, 'TITLE fail:, ', aline) elif aline.startswith('('): # Biopython ID line for Residue m = biop_id_re.match(aline) if m: # check SMCS = Structure, Model, Chain, SegID segid = m.group(9) if segid is None: segid = ' ' this_SMCS = [ m.group(1), int(m.group(2)), m.group(3), segid ] if curr_SMCS != this_SMCS: # init new SMCS level as needed for i in range(4): if curr_SMCS[i] != this_SMCS[i]: SMCS_init[i](this_SMCS[i]) curr_SMCS[i] = this_SMCS[i] if 0 == i: # 0 = init structure so add header struct_builder.set_header(header_dict) elif 1 == i: # new model means new chain and new segid curr_SMCS[2] = curr_SMCS[3] = None struct_builder.init_residue(m.group('res'), m.group('het'), int(m.group('pos')), m.group('icode')) sb_res = struct_builder.residue if 2 == sb_res.is_disordered(): for r in sb_res.child_dict.values(): if not hasattr(r, 'internal_coord'): sb_res = r break sb_res.internal_coord = IC_Residue(sb_res) # print('res id:', m.groupdict()) # print(report_PIC(struct_builder.get_structure())) else: print('Reading pic file', file, 'residue fail: ', aline) elif aline.startswith('ATOM '): m = pdb_atm_re.match(aline) if m: if sb_res is None: # ATOM without res spec already loaded, not a pic file print('no sb_res - not pic file', aline) return None if (sb_res.resname != m.group('res') or sb_res.id[1] != int(m.group('pos'))): # TODO: better exception here? raise Exception( 'pic ATOM read confusion: %s %s %s' % (sb_res.resname, str(sb_res.id), aline)) coord = numpy.array( (float(m.group('x')), float( m.group('y')), float(m.group('z'))), "f") struct_builder.init_atom( m.group('atm').strip(), coord, float(m.group('tfac')), float(m.group('occ')), m.group('alc'), m.group('atm'), int(m.group('ser')), m.group('elm').strip()) # print('atom: ', m.groupdict()) else: print('Reading pic file', file, 'ATOM fail: ', aline) elif aline.startswith('BFAC: '): m = bfac_re.match(aline) if m: for bfac_pair in m.groups(): if bfac_pair is not None: m2 = bfac2_re.match(bfac_pair) if (m2 and sb_res is not None and hasattr(sb_res, 'internal_coord')): rp = sb_res.internal_coord rp.bfactors[m2.group(1)] = float(m2.group(2)) else: m = Edron.edron_re.match(aline) if m: sb_res.internal_coord.load_PIC(m.groupdict()) elif aline.strip(): print('Reading PIC file', file, 'parse fail on: .', aline, '.') return None struct = struct_builder.get_structure() for chn in struct.get_chains(): chnp = chn.internal_coord = IC_Chain(chn) # done in IC_Chain init : chnp.set_residues() chnp.link_residues() chnp.render_dihedra() # print(report_PIC(struct_builder.get_structure())) return struct