Beispiel #1
0
    def __init__(self, atoms, resInfo=None, options=None):
        """
        Constructer of chain object
        """
        self.chainID        = atoms[ atoms["keys"][0] ][0].chainID
        self.alignment      = None
        self.residues       = []
        self.configurations = []
        self.last_residue   = None

        if options.verbose == True:
          print("constructing chain %c (atoms: configurations)" % (self.chainID))

        # creating the 'residues'
        for key in atoms["keys"]:
          myResidue = Residue(atoms[key], resInfo=resInfo)
          if myResidue.checked():
            self.last_residue = myResidue
            self.residues.append(myResidue)

        # setting up list of configuration keys in this chain
        for residue in self.residues:
          for key in residue.configurations:
            if key not in self.configurations:
              self.configurations.append(key)

        # checking and correcting C-terminus and N-terminus
        self.addNTerminus(resInfo=resInfo)
        self.addCTerminus(resInfo=resInfo)
Beispiel #2
0
    def __init__(self, atoms, resInfo=None, options=None):
        """
        Constructer of chain object
        """
        self.chainID = atoms[atoms["keys"][0]][0].chainID
        self.alignment = None
        self.residues = []
        self.configurations = []
        self.last_residue = None

        if options.verbose == True:
            pka_print("constructing chain %c (atoms: configurations)" %
                      (self.chainID))

        # creating the 'residues'
        for key in atoms["keys"]:
            myResidue = Residue(atoms[key], resInfo=resInfo)
            if myResidue.checked():
                self.last_residue = myResidue
                self.residues.append(myResidue)

        # setting up list of configuration keys in this chain
        for residue in self.residues:
            for key in residue.configurations:
                if key not in self.configurations:
                    self.configurations.append(key)

        # checking and correcting C-terminus and N-terminus
        self.addNTerminus(resInfo=resInfo)
        self.addCTerminus(resInfo=resInfo)
Beispiel #3
0
 def __init__(self, file_name):
     '''
     Protein class constructor
     Receives the file from which it is to be read. It needs to be in pdb or gro formats.
     Proteins must be ungapped (all resiude numbers must be consecutive).
     Only standard residues are considered.
     '''
     super(Protein, self).__init__()
     ext = file_name.split('.')[-1].lower()
     if ext == 'pdb':
         with open(fileName, 'r') as f:
             fileContent = f.read().split('\n')
         for line in fileContent:
             if line[0:6] in ['TER   ', 'END   ']:
                 return None
             elif line[0:6] == 'ATOM  ':
                 index = int(line[6:11])
                 name = line[12:16].strip()
                 resName = line[17:20].strip()
                 if res_name in ['HIP', 'HIE', 'HID']:
                     res_name = 'HIS'
                 assert res_name in AMINO_ACID_NAMES, \
                         "Only standard residues are considered."
                 resId = int(line[22:26])
                 x = float(line[30:38])
                 y = float(line[38:46])
                 z = float(line[46:54])
                 if resId > 0:
                     try:
                         self.addResidue(Residue(resId, resName))
                     except AssertionError:
                         pass
                     self.addAtom(Atom(index, name, x, y, z), resId)
         q = [x for x in self if x != None]
         assert None not in self[self.index(q[0]):self.index(q[-1])+1], \
                 "Protein contains gaps."
     elif ext == 'gro':
         with open(file_name, 'r') as read_file:
             file_content = read_file.read().split('\n')
         number_of_atoms = int(file_content[1])
         for index in range(number_of_atoms):
             line = file_content[2 + index].split()
             index = int(line[2])
             name = line[1]
             res_name = line[0][-3:]
             res_id = int(line[0][:-3])
             pos_x = float(line[3]) * 10
             pos_y = float(line[4]) * 10
             pos_z = float(line[5]) * 10
             try:
                 self.add_residue(Residue(res_id, res_name))
             except AssertionError:
                 pass
             self.add_atom(Atom(index, name, (pos_x, pos_y, pos_z)), res_id)
     else:
         raise NameError('Unknown file extension')
     return None
    def generate_residue_sounds(self):
        # settings for the residue
        d = 0.2
        df = 50.
        g = 200.
        m = 0.9
        ns = [9, 10, 11]
        dfs = np.arange(-6 + 1, 6) * df

        for n in ns:
            for df in dfs:
                sound = Residue(n, df, m, g)
                print str(sound)
                sound.save_to_wav(self.fs, d)
def find_common_residues(structures, save_file):
    if 1 == 2:
        with open(safe_file, "rb") as f:
            common_residues = pickle.load(f)
        return common_residues
    else:
        all_residues = []
        for structure in structures:
            structure_residues = set()
            top = md.load(structure).topology
            for residue in top.residues:
                if residue.is_protein:
                    res = Residue(resSeq=residue.resSeq,
                                  chain_id=residue.chain.id,
                                  res_name="%s%d" %
                                  (residue.name, residue.resSeq))
                    #res = Residue(resSeq = residue.resSeq)
                    structure_residues.add(res)
            all_residues.append(structure_residues)
        common_residues = list(set.intersection(*all_residues))
        print((sorted([r.resSeq for r in common_residues])))
        print(("There are %d common residues between input structures" %
               len(common_residues)))
        import pickle
        with open(save_file, "wb") as f:
            pickle.dump(common_residues, f)

        return common_residues
Beispiel #6
0
    def __init__(self):
        """ Takes a filename and initializes the self.residue_table list
            with the contents of a residue table file
        """

        self.residue_table = {}

        residue_list = data.aminoacids.buildTable()

        for r in residue_list:
            res = Residue(r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7])
            self.residue_table[res.letterCode3] = res
Beispiel #7
0
 def addCTerminus(self, resInfo=None):
     """
     Creating a C-terminus residue for this chain and adding it to 'residues' list
     """
     last_residue = None
     for residue in self.residues:
         if residue.type == "amino-acid":
             last_residue = residue
     if last_residue != None:
         atoms = last_residue.checkOXT()
         Cterminus = Residue(atoms, resName="C- ", resInfo=resInfo)
         self.residues.append(Cterminus)
Beispiel #8
0
 def addNTerminus(self, resInfo=None):
     """
     Creating a N-terminus residue for this chain and adding it to 'residues' list
     """
     atom = None
     for residue in self.residues:
         if residue.type == "amino-acid":
             atom = residue.getAtom(name="N")
             break
     if atom != None:
         Nterminus = Residue([atom], resName="N+ ", resInfo=resInfo)
         self.residues.append(Nterminus)
Beispiel #9
0
    def LoadFromFile(fname):
        from residue import Residue
        from atom import Atom

        def parse_pdb_line(s):
            # atname, resname, resid, xyz
            return s[12:16].strip(), \
                   s[17:21].strip(), \
                   int(s[22:26]), \
                   np.array([s[i:i+8] for i in (30,38,46)], dtype=float)
        rindex = 0
        pivot = None
        atoms = [None]
        is_head = True
        molecule = Molecule('mol')
        with open(fname, 'r') as fin:
            for line in fin:
                if line.startswith('TITLE'):
                    molecule.name = line[5:].strip()
                elif line.startswith('ATOM'):
                    atname,resname,resid,xyz = parse_pdb_line(line)
                    if is_head or (resid != rindex):
                        residue = Residue(resname)
                        molecule.append_residue(residue, is_head)
                        is_head = False
                        rindex = resid
                    atom = Atom(atname, xyz)
                    atoms.append(atom)
                    residue.append_atom(atom)
                elif line.startswith('TER'):
                    is_head = True
                elif line.startswith('CONECT'):
                    idxs = map(int, line[6:].split())
                    pivot = atoms[idxs[0]]
                    for i in idxs[1:]:
                        pivot.connect_to(atoms[i])
        auto_setup = pivot is None
        molecule.compile(auto_setup=auto_setup)
        return molecule
 def __init__(self, sequence):
     ## a. parse the sequence.
     match_pattern = re.compile(r'([A-Z])(?:\((\w+)\))?') # Use non-capturing group
     seq_list = match_pattern.findall(sequence)
     self.mass = 0.0
     self.seq = []
     for item in seq_list:
         res = Residue()
         res.bySymbol(item[0])
         if item[1] != '':
             mod = Modification(item[1])
     # Update!!! The mod mass should not be integrated into residue mass.
     #res.mass += mod.mass 
             self.seq.append([res, [mod]])
     # Update!!! The mod mass is appended to the precursor directly.
             self.mass += mod.mass
         else:
             self.seq.append([res, []])
         self.mass += res.mass
     self.length = len(self.seq)
         
     self.mass += Composition("H2O").mass 
Beispiel #11
0
    def load_fragments():
        from residue import Residue
        import os

        ref = Residue('REF')
        ref.append_atom(Atom( 'N', [0.000,  0.300, 0.000]))
        ref.append_atom(Atom('CA', [1.181, -0.540, 0.000]))
        ref.append_atom(Atom( 'C', [2.440,  0.300, 0.000]))
        
        # load all residues
        this_dir, this_filename = os.path.split(__file__)
        DATA_PATH = os.path.join(this_dir, "static", "residues.pdb")
        
        residue_container = Molecule.LoadFromFile(DATA_PATH)
        for fragment in residue_container.iter_residues():
            fit(ref, ('N','CA','C'), fragment, ('N','CA','C'))
            FragmentProvider.FRAGMENTS[fragment.name] = fragment
Beispiel #12
0
def convert_list_to_resobject_list(contact_residues):
    resobject_list = []
    for residue in contact_residues:
        new_residue = Residue(resSeq=residue[1], chain_id=residue[0])
        resobject_list.append(new_residue)
    return (resobject_list)
Beispiel #13
0
    def update(self, **kwargs):
        """Rebuild hierarchical view of atoms.  This method is called at 
        instantiation, but can be used to rebuild the hierarchical view 
        when attributes of atoms change."""
        
        array = np.array
        atoms = self._atoms
        if isinstance(atoms, AtomGroup):
            ag = atoms
            _indices = np.arange(ag._n_atoms)
            selstr = False
        else:
            ag = atoms.getAtomGroup()
            _indices = atoms._indices
            selstr = atoms.getSelstr()
        
        acsi = self._atoms.getACSIndex()
        
        n_atoms = len(ag)
        self._dict = _dict = dict()
        self._chains = _chains = list()
        self._residues = _residues = list()
        self._segments = _segments = list()

        segindex = -1
        segindices = np.zeros(n_atoms, int)
        chindex = -1
        chindices = np.zeros(n_atoms, int)
        resindex = -1
        resindices = np.zeros(n_atoms, int)
        
        sgnms = ag._getSegnames()
        if sgnms is None:
            _segments = None
        else:
            if selstr:
                sgnms = sgnms[_indices]
            unique = np.unique(sgnms)
            s = sgnms[0]
            if len(unique) == 1:
                if  s != '':
                    segment = Segment(ag, _indices, acsi=acsi, unique=True, 
                                      selstr=selstr)
                    _dict[s] = segment
                    _segments.append(segment)
                    LOGGER.info('Hierarchical view contains segments.')
                else: 
                    _segments = None
            else:
                ps = None
                for i, s in enumerate(sgnms):
                    if s == ps or s in _dict:
                        continue
                    ps = s
                    segindex += 1
                    idx = _indices[i:][sgnms[i:] == s]
                    segment = Segment(ag, idx, acsi=acsi, unique=True, 
                                       selstr=selstr)
                    segindices[idx] = segindex
                    _dict[s] = segment
                    _segments.append(segment)
                LOGGER.info('Hierarchical view contains segments.')

        chids = ag._getChids()
        if chids is None:
            _chains = None
        else:
            if selstr:
                chids = chids[_indices]
            if _segments is None:
                if len(np.unique(chids)) == 1:
                    chain = Chain(ag, _indices, acsi=acsi, unique=True)
                    _dict[(None, chids[0] or None)] = chain
                    _chains.append(chain)
                else:
                    pc = None
                    for i, c in enumerate(chids):
                        if c == pc or (None, c) in _dict:
                            continue
                        pc = c
                        chindex += 1
                        idx = _indices[i:][chids[i:] == c]
                        chain = Chain(ag, idx, acsi=acsi, unique=True)
                        chindices[idx] = chindex
                        _dict[(None, c)] = chain
                        _chains.append(chain)
            else:
                pc = chids[0]
                ps = sgnms[0]
                _i = 0
                for i, c in enumerate(chids):
                    s = sgnms[i]
                    if c == pc and s == ps:
                        continue
                    s_c = (ps, pc or None)
                    chain = _dict.get(s_c)
                    if chain is None:
                        segment = _dict[ps]
                        chindex += 1
                        idx = _indices[_i:i]
                        chain = Chain(ag, idx, acsi=acsi, segment=segment, 
                                       unique=True)
                        chindices[idx] = chindex
                        _dict[s_c] = chain
                        segment._dict[pc] = len(segment._list)
                        segment._list.append(chain)
                        _chains.append(chain)
                    else:
                        idx = _indices[_i:i]
                        chindices[idx] = chain._indices[0]
                        chain._indices = np.concatenate((chain._indices, idx))
                    pc = c
                    ps = s
                    _i = i
                s_c = (ps, pc or None)
                chain = _dict.get(s_c)
                idx = _indices[_i:]
                if chain is None:
                    segment = _dict[ps]
                    chindex += 1
                    chindices[idx] = chindex
                    chain = Chain(ag, idx, acsi=acsi, segment=segment, 
                                   unique=True)
                    _dict[s_c] = chain
                    segment._dict[pc] = len(segment._list)
                    segment._list.append(chain)
                    _chains.append(chain)
                else:
                    chindices[idx] = chain._indices[0]
                    chain._indices = np.concatenate((chain._indices, idx)) 
        
        if kwargs.get('chain') == True:
            return
    
        rnums = ag._getResnums()
        if rnums is None:
            raise ValueError('resnums are not set')
        if selstr:
            rnums = rnums[_indices]
        nones = None
        if _segments is None:
            if nones is None:
                nones = [None] * len(rnums)
            sgnms = nones
        if _chains is None:
            if nones is None:
                nones = [None] * len(rnums)
            chids = nones
        icods = ag._getIcodes()
        if icods is None:
            if nones is None:
                nones = [None] * len(rnums)
            icods = nones
        elif selstr:
                icods = icods[_indices]

        pr = rnums[0]
        pi = icods[0] or None          
        pc = chids[0]
        ps = sgnms[0] or None
        _j = 0
        for j, r in enumerate(rnums):
            i = icods[j] or None
            c = chids[j] or None
            s = sgnms[j]
            if r != pr or i != pi or c != pc or s != ps:
                s_c_r_i = (ps, pc, pr, pi)
                res = _dict.get(s_c_r_i)
                if res is None:
                    chain = _dict.get((ps, pc))
                    resindex += 1
                    idx = _indices[_j:j]
                    res = Residue(ag, idx, acsi=acsi, chain=chain, 
                                   unique=True, selstr=selstr)
                    resindices[idx] = resindex
                    if chain is not None:
                        chain._dict[(pr, pi)] = len(chain._list)
                        chain._list.append(res)
                    _residues.append(res)
                    _dict[s_c_r_i] = res
                else:
                    res._indices = np.concatenate((res._indices, 
                                                   _indices[_j:j]))
                ps = s
                pc = c
                pr = r
                pi = i
                _j = j 
        s_c_r_i = (ps, pc, pr, pi)
        res = _dict.get(s_c_r_i)
        idx = _indices[_j:]
        if res is None:
            chain = _dict.get((ps, pc))
            resindex += 1
            res = Residue(ag, idx, acsi=acsi, chain=chain, unique=True, 
                           selstr=selstr)
            resindices[idx] = resindex
            if chain is not None:
                chain._dict[(pr, pi)] = len(chain._list)
                chain._list.append(res)
            _residues.append(res)
            _dict[s_c_r_i] = res
        else:
            resindices[idx] = res._indices[0]
            res._indices = np.concatenate((res._indices, idx))
        
        ag._data['segindices'] = segindices
        ag._data['chindices'] = chindices
        ag._data['resindices'] = resindices
Beispiel #14
0
    def update(self, **kwargs):
        """Update (or build) hierarchical view of atoms.  This method is called 
        at instantiation, but can be used to rebuild the hierarchical view when
        attributes of atoms change."""

        atoms = self._atoms
        if isinstance(atoms, AtomGroup):
            ag = atoms
            selstr = False
            _indices = arange(atoms._n_atoms)
        else:
            ag = atoms.getAtomGroup()
            _indices = atoms._getIndices()
            selstr = atoms.getSelstr()

        set_indices = False
        if atoms == ag:
            set_indices = True
        
        _dict = dict()
        _residues = list()
        _segments = list()
        _chains = list()

        # also set the attributes, so that when no segments or chains 
        # are available, num/iter methods won't raise exceptions
        self._dict = _dict
        self._residues = _residues
        self._segments = _segments
        self._chains = _chains 
        
        acsi = atoms.getACSIndex()
        n_atoms = len(ag)

        # identify segments
        if set_indices:
            segindex = -1
            segindices = zeros(n_atoms, int)
        sgnms = ag._getSegnames()
        if sgnms is None:
            _segments = None
        else:
            if selstr:
                sgnms = sgnms[_indices]
            s = sgnms[0]
            if len(unique(sgnms)) == 1:
                if  s != '':
                    segment = Segment(ag, _indices, acsi=acsi, unique=True, 
                                      selstr=selstr)
                    _dict[s] = segment
                    _segments.append(segment)
                    LOGGER.info('Hierarchical view contains segments.')
                else: 
                    _segments = None
            else:
                ps = None       # previous segment name 
                for i, s in enumerate(sgnms):
                    if s == ps or s in _dict:
                        continue
                    ps = s
                    idx = _indices[i:][sgnms[i:] == s]
                    segment = Segment(ag, idx, acsi=acsi, unique=True, 
                                       selstr=selstr)
                    if set_indices:
                        segindex += 1
                        segindices[idx] = segindex
                    _dict[s] = segment
                    _segments.append(segment)
                LOGGER.info('Hierarchical view contains segments.')

        if set_indices:
            ag._data['segindices'] = segindices
            chindex = -1
            chindices = zeros(n_atoms, int)

        # identify chains
        chids = ag._getChids()
        if chids is None:
            _chains = None
        else:
            if selstr:
                chids = chids[_indices]
            if _segments is None:
                if len(unique(chids)) == 1:
                    chain = Chain(ag, _indices, acsi=acsi, unique=True,
                                  selstr=selstr)
                    _dict[(None, chids[0] or None)] = chain
                    _chains.append(chain)
                else:
                    pc = None
                    for i, c in enumerate(chids):
                        if c == pc or (None, c) in _dict:
                            continue
                        pc = c
                        idx = _indices[i:][chids[i:] == c]
                        chain = Chain(ag, idx, acsi=acsi, unique=True,
                                      selstr=selstr)
                        if set_indices:
                            chindex += 1
                            chindices[idx] = chindex
                        _dict[(None, c)] = chain
                        _chains.append(chain)
            else:
                pc = chids[0]
                ps = sgnms[0]
                _i = 0
                for i, c in enumerate(chids):
                    s = sgnms[i]
                    if c == pc and s == ps:
                        continue
                    s_c = (ps, pc or None)
                    chain = _dict.get(s_c)
                    if chain is None:
                        segment = _dict[ps]
                        idx = _indices[_i:i]
                        chain = Chain(ag, idx, acsi=acsi, segment=segment, 
                                       unique=True, selstr=selstr)
                        if set_indices:
                            chindex += 1
                            chindices[idx] = chindex
                        _dict[s_c] = chain
                        _chains.append(chain)
                    else:
                        idx = _indices[_i:i]
                        chindices[idx] = chain._indices[0]
                        chain._indices = concatenate((chain._indices, idx))
                    pc = c
                    ps = s
                    _i = i
                s_c = (ps, pc or None)
                chain = _dict.get(s_c)
                idx = _indices[_i:]
                if chain is None:
                    segment = _dict[ps]
                    if set_indices:
                        chindex += 1
                        chindices[idx] = chindex
                    chain = Chain(ag, idx, acsi=acsi, segment=segment, 
                                   unique=True, selstr=selstr)
                    _dict[s_c] = chain
                    _chains.append(chain)
                else:
                    if set_indices:
                        chindices[idx] = chain._indices[0]
                    chain._indices = concatenate((chain._indices, idx)) 

        if set_indices:
            ag._data['chindices'] = chindices
        if kwargs.get('chain') == True:
            return
    
        if set_indices:
            resindex = -1
            resindices = zeros(n_atoms, int)
    
        rnums = ag._getResnums()
        if rnums is None:
            raise ValueError('resnums are not set')
        if selstr:
            rnums = rnums[_indices]
        nones = None
        if _segments is None:
            if nones is None:
                nones = [None] * len(rnums)
            sgnms = nones
        if _chains is None:
            if nones is None:
                nones = [None] * len(rnums)
            chids = nones
        icods = ag._getIcodes()
        if icods is None:
            if nones is None:
                nones = [None] * len(rnums)
            icods = nones
        elif selstr:
                icods = icods[_indices]

        pr = rnums[0]
        pi = icods[0] or None          
        pc = chids[0]
        ps = sgnms[0]
        _j = 0
        _append = _residues.append
        _get = _dict.get
        _set = _dict.__setitem__
        for j, r in enumerate(rnums):
            i = icods[j] or None
            c = chids[j]
            s = sgnms[j]
            if r != pr or i != pi or c != pc or s != ps:
                s_c_r_i = (ps, pc, pr, pi)
                res = _get(s_c_r_i)
                if res is None:
                    chain = _get((ps, pc))
                    idx = _indices[_j:j]
                    res = Residue(ag, idx, acsi=acsi, chain=chain, 
                                   unique=True, selstr=selstr)
                    if set_indices:
                        resindex += 1
                        resindices[idx] = resindex
                    _append(res)
                    _set(s_c_r_i, res)
                else:
                    res._indices = concatenate((res._indices, _indices[_j:j]))
                ps = s
                pc = c
                pr = r
                pi = i
                _j = j 
        s_c_r_i = (ps, pc, pr, pi)
        res = _get(s_c_r_i)
        idx = _indices[_j:]
        if res is None:
            chain = _get((ps, pc))
            res = Residue(ag, idx, acsi=acsi, chain=chain, unique=True, 
                           selstr=selstr)
            if set_indices:
                resindex += 1
                resindices[idx] = resindex
            _append(res)
            _set(s_c_r_i, res)
        else:
            if set_indices:
                resindices[idx] = res._indices[0]
            res._indices = concatenate((res._indices, idx))
        
        if set_indices:
            ag._data['resindices'] = resindices
Beispiel #15
0
  resobject_list = []
  for residue in contact_residues:
    new_residue = Residue(resSeq = residue[1], chain_id = residue[0])
    resobject_list.append(new_residue)
  return(resobject_list)

#CHOOSE RESIDUES:

bp_4dkl = md.load("/home/enf/md_simulations/MOR/4dkl_bp_6pt6.pdb")
bp_5c1m = md.load("/home/enf/md_simulations/MOR/5c1m_bp_6pt6.pdb")
bp_4dkl_residues = set([r.resSeq for r in bp_4dkl.topology.residues if r.is_protein])
bp_5c1m_residues = set([r.resSeq for r in bp_4dkl.topology.residues if r.is_protein])
bp_residues = sorted(list(bp_4dkl_residues | bp_5c1m_residues))
bp_residue_objects = convert_list_to_resobject_list([("R", i) for i in bp_residues])

cutoff = 1.
feature_name = "bp_residues_4dkl_5c1m_under_cutoff%dA" %(int(10*cutoff))

common_residues_pkl = get_common_residues_pkl(base)
contact_residues = find_common_residues([inactive_dir, active_dir, simulation_structure], common_residues_pkl)
contact_resSeq = [r.resSeq for r in contact_residues]

bfna_resobj = Residue(resSeq = 601, res_name = "BF0")
_, bp_4dkl_residues = find_binding_pocket_residues(bfna_resobj, contact_residues, inactive_dir, cutoff=cutoff)
bu72_resobj = Residue(resSeq = 401, res_name = "4VO")
_, bp_5c1m_residues = find_binding_pocket_residues(bu72_resobj, contact_residues, active_dir, cutoff=cutoff)
bp_residue_objects = sorted(list(set(bp_4dkl_residues) | set(bp_5c1m_residues)))

#bp_residue_objects = [res for res in bp_residue_objects if res.resSeq in contact_resSeq]

    def getStubs(self):
        """returns a list of dicts with peptide and stub glycopeptide ions """
        for i in self.pep_seq:
            res = Residue()
            res.bySymbol(i)
            if i == 'C':
                self.mass += Carbamidomethyl
            self.mass += res.mass

        if self.mod_type == "Deamidated":
            self.mass += (Deamidation * self.n_mod)
        elif self.mod_type == '':
            pass
        stubs =[]
        
        stubs.append({"key":"peptide", "mass":  (self.mass + Proton)})
        
        
        
        sites = self.glyco_num
        
        if sites == 0 :
            pass
        elif sites>0:
            if self.dHex==0:
                for i in range(1,sites+1,1):
                    
                    for j in range(1,3,1):
                        if j ==1:
                            key = "pep+"+str(j)+"HexNAc+"+"0Hexose"+"-"+str(i)+"sites"
                            mass = self.mass+Proton+(i*(j*HexNAc))
                            #print key, mass
                            stubs.append({"key":key,"mass": mass})

                        elif (j == 2):
                            for k in range(0,4,1):
                                key = "pep+"+str(j)+"HexNAc+"+str(k)+"Hexose"+"-"+str(i)+"sites"
                                mass = self.mass+Proton+(i*((j*HexNAc)+(k*Hex)))
                                #print key, mass
                                stubs.append({"key":key,"mass": mass})
                                
                        else:
                            pass
                        

            elif self.dHex>0:
                for i in range(1,sites+1,1):
                    
                    for j in range(1,3,1):
                        if j ==1:
                            key = "pep+"+str(j)+"HexNAc+"+"0Hexose"+"-"+str(i)+"sites"
                            mass = self.mass+Proton+(i*(j*HexNAc))
                            #print key, mass
                            stubs.append({"key":key,"mass": mass})
                        
                        if (j == 2):
                            for l in range (0,2,1):
                                for k in range(0,4,1):
                                    key = "pep+"+str(j)+"HexNAc+"+str(k)+"Hexose"+str(l)+"dHex"+"-"+str(i)+"sites"
                                    mass = self.mass+Proton+(i*((j*HexNAc)+(k*Hex)+(l*dHex)))
                                    #print key, mass
                                    stubs.append({"key":key,"mass": mass})
                                                           
                        else:
                            pass
                        j +=1

        return stubs