Exemple #1
0
  def __init__(self,
      pdb_hierarchy,
      nontrans_only=False,
      out=sys.stdout,
      quiet=True):
    validation.__init__(self)
    self.residue_count = [0, 0]
    #[OMEGA_GENERAL, OMEGA_PRO]
    self.omega_count = [[0,0,0], [0,0,0]]
    #[OMEGA_GENERAL, OMEGA_PRO], then
    #[OMEGALYZE_TRANS, OMEGALYZE_CIS, OMEGALYZE_TWISTED]

    from mmtbx.validation import utils
    from scitbx.array_family import flex
    self._outlier_i_seqs = flex.size_t()
    pdb_atoms = pdb_hierarchy.atoms()
    all_i_seqs = pdb_atoms.extract_i_seq()
    if all_i_seqs.all_eq(0):
      pdb_atoms.reset_i_seq()
    use_segids = utils.use_segids_in_place_of_chainids(
      hierarchy=pdb_hierarchy)

    prev_rezes, next_rezes = None, None
    prev_resid = None
    cur_resseq = None
    next_resseq = None
    for model in pdb_hierarchy.models():
      for chain in model.chains():
        prev_rezes, next_rezes = None, None
        prev_resid = None
        cur_resseq = None
        next_resseq = None
        if use_segids:
          chain_id = utils.get_segid_as_chainid(chain=chain)
        else:
          chain_id = chain.id
        residues = list(chain.residue_groups())
        for i, residue_group in enumerate(residues):
          # The reason I pass lists of atom_groups to get_phi and get_psi is to
          # deal with the particular issue where some residues have an A alt
          # conf that needs some atoms from a "" alt conf to get calculated
          # correctly.  See 1jxt.pdb for examples.  This way I can search both
          # the alt conf atoms and the "" atoms if necessary.
          prev_atom_list, next_atom_list, atom_list = None, None, None
          if cur_resseq is not None:
            prev_rezes = rezes
            prev_resseq = cur_resseq
          rezes = construct_residues(residues[i])
          cur_resseq = residue_group.resseq_as_int()
          cur_icode = residue_group.icode.strip()
          if (i > 0):
            #check for insertion codes
            if (cur_resseq == residues[i-1].resseq_as_int()) :
              if (cur_icode == '') and (residues[i-1].icode.strip() == '') :
                continue
            elif (cur_resseq != (residues[i-1].resseq_as_int())+1):
              continue
          for atom_group in residue_group.atom_groups():
            alt_conf = atom_group.altloc
            if rezes is not None:
              atom_list = rezes.get(alt_conf)
            if prev_rezes is not None:
              prev_atom_list = prev_rezes.get(alt_conf)
              if (prev_atom_list is None):
                prev_keys = sorted(prev_rezes.keys())
                prev_atom_list = prev_rezes.get(prev_keys[0])
            omega=get_omega(prev_atom_list, atom_list)
            highest_mc_b = get_highest_mc_b(prev_atom_list, atom_list)
            if omega is not None:
              resname = atom_group.resname[0:3]
              coords = get_center(atom_group)
              if resname == "PRO":
                res_type = OMEGA_PRO
              else:
                res_type = OMEGA_GENERAL
              self.residue_count[res_type] += 1
              omega_type = find_omega_type(omega)
              is_nontrans = False
              if omega_type == OMEGALYZE_CIS or omega_type == OMEGALYZE_TWISTED:
                self.n_outliers += 1
                is_nontrans = True
              self.omega_count[res_type][omega_type] += 1
              markup_atoms = [None, None, None, None] #for kinemage markup
              if is_nontrans:
                for a in prev_atom_list:
                  if a is None: continue
                  a_ = atom(pdb_atom=a)
                  if a.name.strip() == "CA":
                    markup_atoms[0] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                  elif a.name.strip() == "C":
                    markup_atoms[1] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                for a in atom_list:
                  if a is None: continue
                  a_ = atom(pdb_atom=a)
                  if a.name.strip() == "N":
                    markup_atoms[2] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                  elif a.name.strip() == "CA":
                    markup_atoms[3] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                #------------
              #prevres=residues[i-1]
              #find prev res identities for printing
              prev_alts = []
              prev_resnames = {}
              for ag in residues[i-1].atom_groups():
                prev_alts.append(ag.altloc)
                prev_resnames[ag.altloc] = ag.resname
              if alt_conf in prev_alts:
                prev_altloc = alt_conf
              else:
                if len(prev_alts) > 1:
                  prev_altloc = prev_alts[1]
                else:
                  prev_altloc = prev_alts[0]
              prev_resname = prev_resnames[prev_altloc]
              #done finding prev res identities
              result = omega_result(
                chain_id=chain_id,
                resseq=residue_group.resseq,
                icode=residue_group.icode,
                resname=atom_group.resname,
                altloc=atom_group.altloc,
                prev_resseq=residues[i-1].resseq,
                prev_icode=residues[i-1].icode,
                prev_resname=prev_resname,
                prev_altloc=prev_altloc,
                segid=None,
                omega=omega,
                omega_type=omega_type,
                res_type=res_type,
                is_nontrans=is_nontrans,
                outlier=is_nontrans,
                highest_mc_b=highest_mc_b,
                xyz=coords,
                markup_atoms=markup_atoms)
              if is_nontrans or not nontrans_only: #(not nontrans_only or is_nontrans)
                self.results.append(result)
              if is_nontrans:
                i_seqs = atom_group.atoms().extract_i_seq()
                assert (not i_seqs.all_eq(0)) #This assert copied from ramalyze
                self._outlier_i_seqs.extend(i_seqs)
Exemple #2
0
  def __init__(self,
      pdb_hierarchy,
      nontrans_only=False,
      out=sys.stdout,
      quiet=True):
    validation.__init__(self)
    self.residue_count = [0, 0]
    #[OMEGA_GENERAL, OMEGA_PRO]
    self.omega_count = [[0,0,0], [0,0,0]]
    #[OMEGA_GENERAL, OMEGA_PRO], then
    #[OMEGALYZE_TRANS, OMEGALYZE_CIS, OMEGALYZE_TWISTED]

    from mmtbx.validation import utils
    from scitbx.array_family import flex
    self._outlier_i_seqs = flex.size_t()
    pdb_atoms = pdb_hierarchy.atoms()
    all_i_seqs = pdb_atoms.extract_i_seq()
    if all_i_seqs.all_eq(0):
      pdb_atoms.reset_i_seq()
    use_segids = utils.use_segids_in_place_of_chainids(
      hierarchy=pdb_hierarchy)

    prev_rezes, next_rezes = None, None
    prev_resid = None
    cur_resseq = None
    next_resseq = None
    for model in pdb_hierarchy.models():
      for chain in model.chains():
        prev_rezes, next_rezes = None, None
        prev_resid = None
        cur_resseq = None
        next_resseq = None
        if use_segids:
          chain_id = utils.get_segid_as_chainid(chain=chain)
        else:
          chain_id = chain.id
        residues = list(chain.residue_groups())
        for i, residue_group in enumerate(residues):
          # The reason I pass lists of atom_groups to get_phi and get_psi is to
          # deal with the particular issue where some residues have an A alt
          # conf that needs some atoms from a "" alt conf to get calculated
          # correctly.  See 1jxt.pdb for examples.  This way I can search both
          # the alt conf atoms and the "" atoms if necessary.
          prev_atom_list, next_atom_list, atom_list = None, None, None
          if cur_resseq is not None:
            prev_rezes = rezes
            prev_resseq = cur_resseq
          rezes = construct_residues(residues[i])
          cur_resseq = residue_group.resseq_as_int()
          cur_icode = residue_group.icode.strip()
          if (i > 0):
            #check for insertion codes
            if (cur_resseq == residues[i-1].resseq_as_int()) :
              if (cur_icode == '') and (residues[i-1].icode.strip() == '') :
                continue
            elif (cur_resseq != (residues[i-1].resseq_as_int())+1):
              continue
          for atom_group in residue_group.atom_groups():
            alt_conf = atom_group.altloc
            if rezes is not None:
              atom_list = rezes.get(alt_conf)
            if prev_rezes is not None:
              prev_atom_list = prev_rezes.get(alt_conf)
              if (prev_atom_list is None):
                prev_keys = sorted(prev_rezes.keys())
                prev_atom_list = prev_rezes.get(prev_keys[0])
            omega=get_omega(prev_atom_list, atom_list)
            highest_mc_b = get_highest_mc_b(prev_atom_list, atom_list)
            if omega is not None:
              resname = atom_group.resname[0:3]
              coords = get_center(atom_group)
              if resname == "PRO":
                res_type = OMEGA_PRO
              else:
                res_type = OMEGA_GENERAL
              self.residue_count[res_type] += 1
              omega_type = find_omega_type(omega)
              is_nontrans = False
              if omega_type == OMEGALYZE_CIS or omega_type == OMEGALYZE_TWISTED:
                self.n_outliers += 1
                is_nontrans = True
              self.omega_count[res_type][omega_type] += 1
              markup_atoms = [None, None, None, None] #for kinemage markup
              if is_nontrans:
                for a in prev_atom_list:
                  if a is None: continue
                  a_ = atom(pdb_atom=a)
                  if a.name.strip() == "CA":
                    markup_atoms[0] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                  elif a.name.strip() == "C":
                    markup_atoms[1] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                for a in atom_list:
                  if a is None: continue
                  a_ = atom(pdb_atom=a)
                  if a.name.strip() == "N":
                    markup_atoms[2] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                  elif a.name.strip() == "CA":
                    markup_atoms[3] = kin_atom(
                      id_str=a_.atom_group_id_str(),xyz=a_.xyz)
                #------------
              #prevres=residues[i-1]
              #find prev res identities for printing
              prev_alts = []
              prev_resnames = {}
              for ag in residues[i-1].atom_groups():
                prev_alts.append(ag.altloc)
                prev_resnames[ag.altloc] = ag.resname
              if alt_conf in prev_alts:
                prev_altloc = alt_conf
              else:
                if len(prev_alts) > 1:
                  prev_altloc = prev_alts[1]
                else:
                  prev_altloc = prev_alts[0]
              prev_resname = prev_resnames[prev_altloc]
              #done finding prev res identities
              result = omega_result(
                chain_id=chain_id,
                resseq=residue_group.resseq,
                icode=residue_group.icode,
                resname=atom_group.resname,
                altloc=atom_group.altloc,
                prev_resseq=residues[i-1].resseq,
                prev_icode=residues[i-1].icode,
                prev_resname=prev_resname,
                prev_altloc=prev_altloc,
                segid=None,
                omega=omega,
                omega_type=omega_type,
                res_type=res_type,
                is_nontrans=is_nontrans,
                outlier=is_nontrans,
                highest_mc_b=highest_mc_b,
                xyz=coords,
                markup_atoms=markup_atoms)
              if is_nontrans or not nontrans_only: #(not nontrans_only or is_nontrans)
                self.results.append(result)
              if is_nontrans:
                i_seqs = atom_group.atoms().extract_i_seq()
                assert (not i_seqs.all_eq(0)) #This assert copied from ramalyze
                self._outlier_i_seqs.extend(i_seqs)
 def __init__ (self,
     pdb_hierarchy,
     outliers_only=False,
     show_errors=False,
     out=sys.stdout,
     quiet=False) :
   validation.__init__(self)
   self.n_allowed = 0
   self.n_favored = 0
   self.n_type = [ 0 ] * 6
   from mmtbx.validation import utils
   import mmtbx.rotamer
   from mmtbx.rotamer import ramachandran_eval
   from scitbx.array_family import flex
   self._outlier_i_seqs = flex.size_t()
   pdb_atoms = pdb_hierarchy.atoms()
   all_i_seqs = pdb_atoms.extract_i_seq()
   if (all_i_seqs.all_eq(0)) :
     pdb_atoms.reset_i_seq()
   use_segids = utils.use_segids_in_place_of_chainids(
     hierarchy=pdb_hierarchy)
   analysis = ""
   output_list = []
   r = ramachandran_eval.RamachandranEval()
   prev_rezes, next_rezes = None, None
   prev_resid = None
   cur_resseq = None
   next_resseq = None
   for model in pdb_hierarchy.models():
     for chain in model.chains():
       if use_segids:
         chain_id = utils.get_segid_as_chainid(chain=chain)
       else:
         chain_id = chain.id
       residues = list(chain.residue_groups())
       for i, residue_group in enumerate(residues):
         # The reason I pass lists of atom_groups to get_phi and get_psi is to
         # deal with the particular issue where some residues have an A alt
         # conf that needs some atoms from a "" alt conf to get calculated
         # correctly.  See 1jxt.pdb for examples.  This way I can search both
         # the alt conf atoms and the "" atoms if necessary.
         prev_atom_list, next_atom_list, atom_list = None, None, None
         if cur_resseq is not None:
           prev_rezes = rezes
           prev_resseq = cur_resseq
         rezes = construct_complete_residues(residues[i])
         cur_resseq = residue_group.resseq_as_int()
         cur_icode = residue_group.icode.strip()
         if (i > 0):
           #check for insertion codes
           if (cur_resseq == residues[i-1].resseq_as_int()) :
             if (cur_icode == '') and (residues[i-1].icode.strip() == '') :
               continue
           elif (cur_resseq != (residues[i-1].resseq_as_int())+1):
             continue
         if (i < len(residues)-1):
           #find next residue
           if residue_group.resseq_as_int() == \
              residues[i+1].resseq_as_int():
             if (cur_icode == '') and (residues[i+1].icode.strip() == '') :
               continue
           elif residue_group.resseq_as_int() != \
              (residues[i+1].resseq_as_int())-1:
             continue
           next_rezes = construct_complete_residues(residues[i+1])
           next_resid = residues[i+1].resseq_as_int()
         else:
           next_rezes = None
           next_resid = None
         for atom_group in residue_group.atom_groups():
           alt_conf = atom_group.altloc
           if rezes is not None:
             atom_list = rezes.get(alt_conf)
           if prev_rezes is not None:
             prev_atom_list = prev_rezes.get(alt_conf)
             if (prev_atom_list is None):
               prev_keys = sorted(prev_rezes.keys())
               prev_atom_list = prev_rezes.get(prev_keys[0])
           if next_rezes is not None:
             next_atom_list = next_rezes.get(alt_conf)
             if (next_atom_list is None):
               next_keys = sorted(next_rezes.keys())
               next_atom_list = next_rezes.get(next_keys[0])
           phi = get_phi(prev_atom_list, atom_list)
           psi = get_psi(atom_list, next_atom_list)
           coords = get_center(atom_group)
           if (phi is not None and psi is not None):
             res_type = RAMA_GENERAL
             self.n_total += 1
             if (atom_group.resname[0:3] == "GLY"):
               res_type = RAMA_GLYCINE
             elif (atom_group.resname[0:3] == "PRO"):
               is_cis = is_cis_peptide(prev_atom_list, atom_list)
               if is_cis:
                 res_type = RAMA_CISPRO
               else:
                 res_type = RAMA_TRANSPRO
             elif (isPrePro(residues, i)):
               res_type = RAMA_PREPRO
             elif (atom_group.resname[0:3] == "ILE" or \
                   atom_group.resname[0:3] == "VAL"):
               res_type = RAMA_ILE_VAL
             self.n_type[res_type] += 1
             value = r.evaluate(res_types[res_type], [phi, psi])
             ramaType = self.evaluateScore(res_type, value)
             is_outlier = ramaType == RAMALYZE_OUTLIER
             c_alphas = None
             # XXX only save kinemage data for outliers
             if is_outlier :
               c_alphas = []
               for atoms in [prev_atom_list, atom_list, next_atom_list] :
                 for a in atoms :
                   if (a.name.strip() == "CA") :
                     a_ = atom(pdb_atom=a)
                     c_alphas.append(c_alpha(
                       id_str=a_.atom_group_id_str(),
                       xyz=a_.xyz))
               assert (len(c_alphas) == 3)
             result = ramachandran(
               chain_id=chain_id,
               resseq=residue_group.resseq,
               icode=residue_group.icode,
               resname=atom_group.resname,
               altloc=atom_group.altloc,
               segid=None, # XXX ???
               phi=phi,
               psi=psi,
               rama_type=ramaType,
               res_type=res_type,
               score=value*100,
               outlier=is_outlier,
               xyz=coords,
               c_alphas=c_alphas)
             if (not outliers_only or is_outlier) :
               self.results.append(result)
             if is_outlier :
               i_seqs = atom_group.atoms().extract_i_seq()
               assert (not i_seqs.all_eq(0))
               self._outlier_i_seqs.extend(i_seqs)
   out_count, out_percent = self.get_outliers_count_and_fraction()
   fav_count, fav_percent = self.get_favored_count_and_fraction()
   self.out_percent = out_percent * 100.0
   self.fav_percent = fav_percent * 100.0