docs: def _build_bonding_network(self):
          """
          Evaluates atoms per residue for missing and known bonded partners.
          Based on bond_amber.
          A better alternative would be to iterate over the entire list of residues and 
          use NeighborSearch to probe neighbors for atom X in residue i,  i-1 and i+1
          """
          
          self.bonds = {} # [Residue][Atom]: [ [missing],  [bonded] ]
          self.selection = {} # [Residue]: 'nrml'/'nter'/'cter'
          
          missing = 0
          
          for residue in self.nh_structure.get_residues():
              
              bond_dict = self.bonds[residue] = {}
              
              atom_dict = residue.child_dict
              atom_names = set(atom_dict.keys())
              
              # Pre-Populate Dictionary
              
              for name in atom_names:
                  bond_dict[name] = [ [],  [] ]
              
              # Define Template
              if atom_names.intersection(self.C_TERMINAL_ATOMS):
                  selection = 'cter'
              elif atom_names.intersection(self.N_TERMINAL_ATOMS):
                  selection = 'nter'
              else:
                  selection = 'nrml'
              
              tmpl = self.tmpl[selection]
              self.selection[residue] = selection # For place_hs
              
              # Iterate Template Bonds and record info
              
              if not tmpl.has_key(residue.resname):
                  raise ValueError("Unknown Residue Type: %s" %residue.resname)
              
              template_bonds = tmpl[residue.resname]['bonds']
              
              for bond in template_bonds.keys():
                  
                  a1,  a2 = bond
                  
                  if a1 in atom_names and not a2 in atom_names:
                      bond_dict[a1][0].append(a2)
                      missing += 1
                  elif a1 not in atom_names and a2 in atom_names:
                      bond_dict[a2][0].append(a1)
                      missing += 1
                  else: # 
                      bond_dict[a1][1].append(atom_dict[a2])
                      bond_dict[a2][1].append(atom_dict[a1])   
          
          return missing