Exemplo n.º 1
0
    def getMolecule(self, molInd):

        molecules = []
        if molInd == len(self.molIndex) - 1:
            lastLine = -1
        else:
            lastLine = self.molIndex[molInd + 1]
        # lines fotr that molecule
        lines = self.allLines[self.molIndex[molInd]:lastLine]
        lineIndex = 0
        atomsSeen = {}  # dict of atom types and number of atoms seen

        # parser header
        molName = lines[lineIndex].strip()
        lineIndex += 3

        # create molecule
        mol = Protein(name=molName)
        mol.info = lines[lineIndex + 1]
        mol.comment = lines[lineIndex + 1]
        #self.mol.parser = self
        chain = Chain(id='1', parent=mol, top=mol)
        res = Residue(type='UNK', number='1', parent=chain, top=mol)
        mol.levels = [Protein, Chain, Residue, Atom]

        # parse count line
        line = lines[lineIndex]
        assert line[
            33:
            39] == " V2000", "Format error: only V2000 is suported, got %s" % line[
                33:39]
        nba = int(line[0:3])  # number of atoms
        nbb = int(line[3:6])  # number of bonds
        nbal = int(line[6:9])  # number of atom lists
        ccc = int(line[12:15])  # chiral flag: 0=not chiral, 1=chiral
        sss = int(line[15:18])  # number of stext entries
        lineIndex += 1

        # parse atoms
        for anum in range(nba):
            line = lines[lineIndex]
            element = line[31:34].strip()
            if element in atomsSeen:
                atomsSeen[element] += 1
            else:
                atomsSeen[element] = 1
            atom = Atom(name='%s_%s' % (element, atomsSeen[element]),
                        parent=res,
                        chemicalElement=element,
                        top=mol)

            atom._coords = [[
                float(line[0:10]),
                float(line[10:20]),
                float(line[20:30])
            ]]
            atom._charges['sdf'] = int(line[35:38])
            atom.chargeSet = 'sdf'
            mol.allAtoms.append(atom)

            atom.massDiff = int(line[34:36])
            atom.stereo = int(line[38:41])
            atom.hcount = line[41:44]
            atom.valence = int(line[47:50])
            atom.hetatm = 1
            atom.occupancy = 0.0
            atom.temperatureFactor = 0.0
            lineIndex += 1

        # parse bonds
        for bnum in range(nba):
            line = lines[lineIndex]
            at1 = mol.allAtoms[int(line[0:3]) - 1]
            at2 = mol.allAtoms[int(line[3:6]) - 1]
            if at1.isBonded(at2): continue
            bond = Bond(at1, at2, check=0)

            bond.bondOrder = int(line[6:9])
            #1 = Single, 2 = Double,
            #3 = Triple, 4 = Aromatic,
            #5 = Single or Double,
            #6 = Single or Aromatic,
            #7 = Double or Aromatic, 8 = Any

            bond.stereo = int(line[9:12])
            #Single bonds: 0 = not stereo,
            #1 = Up, 4 = Either,
            #6 = Down, Double bonds: 0 = Use x-, y-, z-coords
            #from atom block to determine cis or trans,
            #3 = Cis or trans (either) double bond

            bond.topo = int(line[15:18])
            # 0 = Either, 1 = Ring, 2 = Chain

            try:
                bond.ReactionCenter = int(line[18:21])
            except ValueError:
                bond.ReactionCenter = 0
            #0 = unmarked, 1 = a center, -1 = not a center,
            #Additional: 2 = no change,
            #4 = bond made/broken,
            #8 = bond order changes
            #12 = 4+8 (both made/broken and changes);
            #5 = (4 + 1), 9 = (8 + 1), and 13 = (12 + 1)

        # "M END" and properties are not parsed at this point
        self.mol = mol
        mname = mol.name
        strRpr = mname + ':::'
        mol.allAtoms.setStringRepr(strRpr)
        strRpr = mname + ':'
        mol.chains.setStringRepr(strRpr)
        for c in mol.chains:
            cname = c.id
            strRpr = mname + ':' + cname + ':'
            c.residues.setStringRepr(strRpr)
            for r in c.residues:
                rname = r.name
                strRpr = mname + ':' + cname + ':' + rname + ':'
                r.atoms.setStringRepr(strRpr)
        molList = mol.setClass()
        molList.append(mol)
        mol.parser = self
        for n in molList.name:
            name = n + ','
        name = name[:-1]
        molList.setStringRepr(name)
        strRpr = name + ':::'
        molList.allAtoms.setStringRepr(strRpr)

        return molList
Exemplo n.º 2
0
    def parse( self, objClass=Protein ):
        if self.allLines is None and self.filename:
            self.readFile()
            if self.allLines is None or len(self.allLines)==0:
                return

        mol = Protein()
        self.mol = mol
        molList = mol.setClass()
        molList.append( mol )
        current_residue_number = None
        current_chain = None
        current_residue = None
        number_of_atoms = int(self.allLines[1][:5])

        self.configureProgressBar( init=1, mode='increment', 
                                  authtext='parse atoms', max=number_of_atoms )
        
        
        current_chain = Chain( id='GRO',)
        #FIX this: The existence of allAtoms attribute (and the fact that it is an empty set rather than all atoms in the chain) causes getNodesByMolecule() to return wrong values
        if hasattr(current_chain, "allAtoms"):
            del(current_chain.allAtoms)
        #current_chain = Chain( id='GRO',parent = mol)
        mol.adopt( current_chain, setChildrenTop=1 )
         
        for index in range( 2,number_of_atoms+2 ):              
            residue_number = int(self.allLines[index][:5])
            if residue_number!=current_residue_number:# 
                #current_chain should adopt the current residue if there is one
                #create new residue
                res_type = self.allLines[index][5:10]
                residue_type = res_type.split(' ')[0]
                
                current_residue = Residue( type=residue_type, number=residue_number )
                current_residue_number = residue_number
                if current_residue is not None:    #REMEMBER TO ADOPT THE LAST ONE!!!
                     
                    current_chain.adopt( current_residue, setChildrenTop=1 )
                            
            n = self.allLines[index][10:15]
            name = n.split(' ')[-1]
            element = name 
            
            if element in babel_elements.keys():
                element = element

            else:
                 
                if residue_type == "System" or residue_type == "SOL":                 
                    #if element[1] == 'W':
                    #          element = 'H'
                        #   group is treated as one particle
                    #else:
                    element = element[0]

                elif element[:2] == 'Me':
                    element = 'C'
                else:
                    element = element[0]
                
            #if len(element)>1:
            #    if type(element[1]) == types.StringType:
            #        
            #        if element[1] == element[1].lower():
            #            element =element
            #        else:
            #            element = element[0]
            #            
            #    else:    
            #        element = element[0]
                
            atom = Atom( name, current_residue, element, top=mol )
            c =  self.allLines[index][15:20]
            cx = self.allLines[index][20:28] 
            cy = self.allLines[index][28:36]
            cz = self.allLines[index][36:44]
            
            x = float(cx)*10
            y = float(cy)*10
            z = float(cz)*10
            atom._coords = [[x, y, z]]
             
            atom._charges = []
            atom.segID =  mol.name   
            atom.normalname = name
            atom.number = int(self.allLines[index][15:20])
            atom.elementType = name[0]
            mol.atmNum[atom.number] = atom
            atom.altname = None    
            atom.hetatm = 0
        mol.name = os.path.split(os.path.splitext(self.filename)[0])[-1]
        mol.allAtoms = mol.chains.residues.atoms
        mol.parser = self
        mol.levels = [Protein, Chain, Residue, Atom]
        name = ''
        for n in molList.name:
            name = n + ','
        name = name[:-1]
        molList.setStringRepr( name )
        strRpr = name + ':::'
        molList.allAtoms.setStringRepr( strRpr )
        for m in molList:
            mname = m.name
            strRpr = mname + ':::'
            m.allAtoms.setStringRepr( strRpr )
            strRpr = mname + ':'
            m.chains.setStringRepr( strRpr )
            for c in m.chains:
                cname = c.id
                strRpr = mname + ':' + cname + ':'
                c.residues.setStringRepr( strRpr )
                for r in c.residues:
                    rname = r.name
                    strRpr = mname + ':' + cname + ':' + rname + ':'
                    r.atoms.setStringRepr( strRpr )        
        return molList
Exemplo n.º 3
0
    def parse(self, objClass=Protein):
        """Parses mmCIF dictionary (self.mmCIF_dict) into MolKit object"""
        if self.allLines is None and self.filename:
            self.readFile()
            if self.allLines is None or len(self.allLines) == 0:
                return
            self.mmCIF2Dict()
        type_symbol = None
        B_iso_or_equiv = None
        mmCIF_dict = self.mmCIF_dict
        fileName, fileExtension = os.path.splitext(self.filename)
        molName = os.path.basename(fileName)
        if mmCIF_dict.has_key('_entry.id'):
            molName = mmCIF_dict['_entry.id']
        if mmCIF_dict.has_key('_atom_site.id'):
            #The description of the data names can be found in the following link
            #http://mmcif.pdb.org/dictionaries/mmcif_pdbx.dic/Items
            ids = mmCIF_dict['_atom_site.id']  #1 number
            group_PDB = mmCIF_dict['_atom_site.group_PDB']  #2 atom/hetatm

            atom_id = mmCIF_dict['_atom_site.label_atom_id']  #3 name

            comp_id = mmCIF_dict['_atom_site.label_comp_id']  #4 residue type
            label_asym_id = mmCIF_dict['_atom_site.label_asym_id']  #5 chain
            #Note: chain ID from mmCIF file might be different from PDB file
            seq_id = mmCIF_dict['_atom_site.label_seq_id']  #6 residue number
            x_coords = mmCIF_dict['_atom_site.Cartn_x']  #7 xcoord
            y_coords = mmCIF_dict['_atom_site.Cartn_y']  #8 ycoord
            z_coords = mmCIF_dict['_atom_site.Cartn_z']  #9 zcoord
            occupancy = mmCIF_dict['_atom_site.occupancy']  #10
            B_iso_or_equiv = mmCIF_dict['_atom_site.B_iso_or_equiv']  #11
            type_symbol = mmCIF_dict['_atom_site.type_symbol']

        elif mmCIF_dict.has_key('_atom_site_label'):
            #ftp://ftp.iucr.org/pub/cif_core.dic
            atom_id = mmCIF_dict['_atom_site_label']
            len_atoms = len(atom_id)
            ids = range(len_atoms)

            group_PDB = len_atoms * ['HETATM']
            comp_id = len_atoms * ["CIF"]
            label_asym_id = len_atoms * ['1']
            seq_id = len_atoms * [1]

            from mglutil.math.crystal import Crystal
            a = mmCIF_dict['_cell.length_a'] = float(
                mmCIF_dict['_cell_length_a'].split('(')[0])
            b = mmCIF_dict['_cell.length_b'] = float(
                mmCIF_dict['_cell_length_b'].split('(')[0])
            c = mmCIF_dict['_cell.length_c'] = float(
                mmCIF_dict['_cell_length_c'].split('(')[0])
            alpha = mmCIF_dict['_cell.angle_alpha'] = float(
                mmCIF_dict['_cell_angle_alpha'].split('(')[0])
            beta = mmCIF_dict['_cell.angle_beta'] = float(
                mmCIF_dict['_cell_angle_beta'].split('(')[0])
            gamma = mmCIF_dict['_cell.angle_gamma'] = float(
                mmCIF_dict['_cell_angle_gamma'].split('(')[0])
            cryst = Crystal((a, b, c), (alpha, beta, gamma))
            x = []
            for item in mmCIF_dict['_atom_site_fract_x']:
                x.append(float(item.split('(')[0]))
            y = []
            for item in mmCIF_dict['_atom_site_fract_y']:
                y.append(float(item.split('(')[0]))
            z = []
            for item in mmCIF_dict['_atom_site_fract_z']:
                z.append(float(item.split('(')[0]))

            x_coords = []
            y_coords = []
            z_coords = []
            B_iso_or_equiv = []
            for i in ids:
                trans = cryst.toCartesian([x[i], y[i], z[i]])

                x_coords.append(trans[0])
                y_coords.append(trans[1])
                z_coords.append(trans[2])
                if mmCIF_dict.has_key('_atom_site_U_iso_or_equiv'):
                    B_iso_or_equiv.append(
                        mmCIF_dict['_atom_site_U_iso_or_equiv'][i].split(
                            '(')[0])
            if mmCIF_dict.has_key('_atom_site_type_symbol'):
                type_symbol = mmCIF_dict['_atom_site_type_symbol']
            if mmCIF_dict.has_key('_atom_site_occupancy'):
                occupancy = mmCIF_dict['_atom_site_occupancy']
            if mmCIF_dict.has_key('_chemical_name_common'):
                molName = mmCIF_dict['_chemical_name_common']
            elif mmCIF_dict.has_key('_chemical_name_mineral'):
                molName = mmCIF_dict['_chemical_name_mineral']

            if mmCIF_dict.has_key('_symmetry_space_group_name_H-M'):
                mmCIF_dict['_symmetry.space_group_name_H-M'] = mmCIF_dict[
                    '_symmetry_space_group_name_H-M']
        else:
            print 'No _atom_site.id or _atom_site_label record is available in %s' % self.filename
            return None

        mol = Protein()
        self.mol = mol
        self.mol.allAtoms = AtomSet([])
        molList = mol.setClass()
        molList.append(mol)
        current_chain_id = None
        current_residue_number = None
        current_chain = None
        current_residue = None

        number_of_atoms = len(ids)

        self.configureProgressBar(init=1,
                                  mode='increment',
                                  authtext='parse atoms',
                                  max=number_of_atoms)
        for index in range(number_of_atoms):
            #make a new atom for the current index
            chain_id = label_asym_id[index]
            if chain_id != current_chain_id:  #make a new chain
                #molecule should adopt the current chain if there is one
                current_chain = Chain(id=chain_id)
                # FIXME: current_chain should not have allAtoms attribute
                delattr(current_chain, "allAtoms")
                current_chain_id = chain_id

                if current_chain is not None:  #REMEMBER TO ADOPT THE LAST ONE!!!
                    mol.adopt(current_chain, setChildrenTop=1)
            residue_number = seq_id[index]

            if residue_number != current_residue_number or chain_id != label_asym_id[
                    index - 1]:  #make a new chain:
                #current_chain should adopt the current residue if there is one
                #create new residue
                residue_type = comp_id[index]
                current_residue = Residue(type=residue_type,
                                          number=residue_number)
                current_residue_number = residue_number
                if current_residue is not None:  #REMEMBER TO ADOPT THE LAST ONE!!!
                    current_chain.adopt(current_residue, setChildrenTop=1)

            name = atom_id[index]
            if type_symbol:
                element = type_symbol[index]
            else:
                element = None
            atom = Atom(name, current_residue, element, top=mol)
            atom._coords = [[
                float(x_coords[index]),
                float(y_coords[index]),
                float(z_coords[index])
            ]]
            atom._charges = {}
            atom.segID = mol.name
            atom.normalname = name
            atom.number = int(ids[index])
            mol.atmNum[atom.number] = atom
            atom.occupancy = float(occupancy[index])
            if B_iso_or_equiv:
                atom.temperatureFactor = float(B_iso_or_equiv[index])
            atom.altname = None
            atom.hetatm = 0
            if group_PDB[index] == 'HETATM':
                atom.hetatm = 1
            self.updateProgressBar()

        self.parse_MMCIF_CELL()
        try:
            self.parse_MMCIF_HYDBND()
        except:
            print >> sys.stderr, "Parsing Hydrogen Bond Record Failed in", self.filename

        mol.name = molName
        mol.allAtoms = mol.chains.residues.atoms

        mol.parser = self
        mol.levels = [Protein, Chain, Residue, Atom]
        name = ''
        for n in molList.name:
            name = n + ','
        name = name[:-1]
        molList.setStringRepr(name)
        strRpr = name + ':::'
        molList.allAtoms.setStringRepr(strRpr)
        for m in molList:
            mname = m.name
            strRpr = mname + ':::'
            m.allAtoms.setStringRepr(strRpr)
            strRpr = mname + ':'
            m.chains.setStringRepr(strRpr)
            for c in m.chains:
                cname = c.id
                strRpr = mname + ':' + cname + ':'
                c.residues.setStringRepr(strRpr)
                for r in c.residues:
                    rname = r.name
                    strRpr = mname + ':' + cname + ':' + rname + ':'
                    r.atoms.setStringRepr(strRpr)
        self.buildBonds()
        return molList
Exemplo n.º 4
0
    def parse(self, objClass=Protein):
        """Parses mmCIF dictionary (self.mmCIF_dict) into MolKit object"""
        if self.allLines is None and self.filename:
            self.readFile()
            if self.allLines is None or len(self.allLines)==0:
                return
            self.mmCIF2Dict()
        type_symbol = None
        B_iso_or_equiv = None
        mmCIF_dict = self.mmCIF_dict
        fileName, fileExtension = os.path.splitext(self.filename)
        molName = os.path.basename(fileName)
        if mmCIF_dict.has_key('_entry.id'):
            molName = mmCIF_dict['_entry.id']
        if mmCIF_dict.has_key('_atom_site.id'):
            #The description of the data names can be found in the following link
            #http://mmcif.pdb.org/dictionaries/mmcif_pdbx.dic/Items   
            ids = mmCIF_dict['_atom_site.id'] #1 number
            group_PDB = mmCIF_dict['_atom_site.group_PDB']          #2 atom/hetatm
            
            atom_id = mmCIF_dict['_atom_site.label_atom_id']  #3 name

            comp_id = mmCIF_dict['_atom_site.label_comp_id']  #4 residue type
            label_asym_id = mmCIF_dict['_atom_site.label_asym_id']  #5 chain 
            #Note: chain ID from mmCIF file might be different from PDB file
            seq_id = mmCIF_dict['_atom_site.label_seq_id']    #6 residue number
            x_coords = mmCIF_dict['_atom_site.Cartn_x']             #7 xcoord
            y_coords = mmCIF_dict['_atom_site.Cartn_y']             #8 ycoord
            z_coords = mmCIF_dict['_atom_site.Cartn_z']             #9 zcoord
            occupancy = mmCIF_dict['_atom_site.occupancy']          #10    
            B_iso_or_equiv = mmCIF_dict['_atom_site.B_iso_or_equiv']#11
            type_symbol = mmCIF_dict['_atom_site.type_symbol']
            
                
        elif mmCIF_dict.has_key('_atom_site_label'):
            #ftp://ftp.iucr.org/pub/cif_core.dic
            atom_id = mmCIF_dict['_atom_site_label']
            len_atoms = len(atom_id)
            ids = range(len_atoms)
            
            group_PDB = len_atoms*['HETATM']
            comp_id = len_atoms*["CIF"]
            label_asym_id = len_atoms*['1']
            seq_id = len_atoms*[1]
            
            from mglutil.math.crystal import Crystal
            a = mmCIF_dict['_cell.length_a'] = float(mmCIF_dict['_cell_length_a'].split('(')[0])
            b = mmCIF_dict['_cell.length_b'] = float(mmCIF_dict['_cell_length_b'].split('(')[0])
            c = mmCIF_dict['_cell.length_c'] = float(mmCIF_dict['_cell_length_c'].split('(')[0])
            alpha = mmCIF_dict['_cell.angle_alpha'] = float(mmCIF_dict['_cell_angle_alpha'].split('(')[0])
            beta = mmCIF_dict['_cell.angle_beta'] = float(mmCIF_dict['_cell_angle_beta'].split('(')[0])
            gamma = mmCIF_dict['_cell.angle_gamma'] = float(mmCIF_dict['_cell_angle_gamma'].split('(')[0])
            cryst = Crystal((a, b, c), (alpha, beta, gamma))
            x = []
            for item in mmCIF_dict['_atom_site_fract_x']:
                x.append(float(item.split('(')[0]))
            y = []
            for item in mmCIF_dict['_atom_site_fract_y']:
                y.append(float(item.split('(')[0]))
            z = []
            for item in mmCIF_dict['_atom_site_fract_z']:
                z.append(float(item.split('(')[0]))
                
            x_coords = []
            y_coords = []
            z_coords = []
            B_iso_or_equiv = []
            for i in ids:
                trans = cryst.toCartesian([x[i], y[i], z[i]])
                
                x_coords.append(trans[0]) 
                y_coords.append(trans[1])
                z_coords.append(trans[2])
                if mmCIF_dict.has_key('_atom_site_U_iso_or_equiv'):
                    B_iso_or_equiv.append(mmCIF_dict['_atom_site_U_iso_or_equiv'][i].split('(')[0])
            if mmCIF_dict.has_key('_atom_site_type_symbol'):
                type_symbol = mmCIF_dict['_atom_site_type_symbol']
            if mmCIF_dict.has_key('_atom_site_occupancy'):
                occupancy = mmCIF_dict['_atom_site_occupancy']
            if mmCIF_dict.has_key('_chemical_name_common'):   
                molName = mmCIF_dict['_chemical_name_common']
            elif mmCIF_dict.has_key('_chemical_name_mineral'):
                molName = mmCIF_dict['_chemical_name_mineral']
                                
            if mmCIF_dict.has_key('_symmetry_space_group_name_H-M'):   
                mmCIF_dict['_symmetry.space_group_name_H-M'] = mmCIF_dict['_symmetry_space_group_name_H-M']
        else:
            print 'No _atom_site.id or _atom_site_label record is available in %s' % self.filename
            return  None  
        
        mol = Protein()
        self.mol = mol
        self.mol.allAtoms = AtomSet([])
        molList = mol.setClass()
        molList.append( mol )
        current_chain_id = None
        current_residue_number = None
        current_chain = None
        current_residue = None
        
        number_of_atoms = len(ids)

        self.configureProgressBar(init=1, mode='increment', 
                                  authtext='parse atoms', max=number_of_atoms)
        for index in range(number_of_atoms):              
            #make a new atom for the current index
            chain_id = label_asym_id[index]
            if chain_id != current_chain_id:         #make a new chain
                #molecule should adopt the current chain if there is one
                current_chain = Chain(id=chain_id)
                # FIXME: current_chain should not have allAtoms attribute
                delattr(current_chain, "allAtoms")
                current_chain_id = chain_id
                
                if current_chain is not None:    #REMEMBER TO ADOPT THE LAST ONE!!!
                    mol.adopt(current_chain, setChildrenTop=1)                    
            residue_number = seq_id[index]   

            if residue_number != current_residue_number or chain_id != label_asym_id[index-1]:         #make a new chain:
                #current_chain should adopt the current residue if there is one
                #create new residue
                residue_type = comp_id[index]
                current_residue = Residue(type=residue_type, number=residue_number)
                current_residue_number = residue_number
                if current_residue is not None:    #REMEMBER TO ADOPT THE LAST ONE!!!
                    current_chain.adopt(current_residue, setChildrenTop=1)
                
            
            name = atom_id[index]
            if type_symbol:
                element = type_symbol[index]
            else:
                element = None
            atom = Atom( name, current_residue, element, top=mol )
            atom._coords = [[float(x_coords[index]), float(y_coords[index]), float(z_coords[index])]]
            atom._charges = {}
            atom.segID =  mol.name   
            atom.normalname = name
            atom.number = int(ids[index])
            mol.atmNum[atom.number] = atom
            atom.occupancy = float(occupancy[index])
            if B_iso_or_equiv:
                atom.temperatureFactor = float(B_iso_or_equiv[index])
            atom.altname = None    
            atom.hetatm = 0
            if group_PDB[index]=='HETATM':
                atom.hetatm = 1
            self.updateProgressBar()
                           
        self.parse_MMCIF_CELL()
        try:
            self.parse_MMCIF_HYDBND()       
        except:
             print >>sys.stderr,"Parsing Hydrogen Bond Record Failed in",self.filename
               
        mol.name = molName
        mol.allAtoms = mol.chains.residues.atoms
        
        mol.parser = self
        mol.levels = [Protein, Chain, Residue, Atom]
        name = ''
        for n in molList.name:
            name = n + ','
        name = name[:-1]
        molList.setStringRepr(name)
        strRpr = name + ':::'
        molList.allAtoms.setStringRepr(strRpr)
        for m in molList:
            mname = m.name
            strRpr = mname + ':::'
            m.allAtoms.setStringRepr(strRpr)
            strRpr = mname + ':'
            m.chains.setStringRepr(strRpr)
            for c in m.chains:
                cname = c.id
                strRpr = mname + ':' + cname + ':'
                c.residues.setStringRepr(strRpr)
                for r in c.residues:
                    rname = r.name
                    strRpr = mname + ':' + cname + ':' + rname + ':'
                    r.atoms.setStringRepr(strRpr)                            
        self.buildBonds()
        return molList
Exemplo n.º 5
0
    def parse(self, objClass=Protein):
        if self.allLines is None and self.filename:
            self.readFile()
            if self.allLines is None or len(self.allLines) == 0:
                return

        mol = Protein()
        self.mol = mol
        molList = mol.setClass()
        molList.append(mol)
        current_residue_number = None
        current_chain = None
        current_residue = None
        number_of_atoms = int(self.allLines[1][:5])

        self.configureProgressBar(init=1,
                                  mode='increment',
                                  authtext='parse atoms',
                                  max=number_of_atoms)

        current_chain = Chain(id='GRO', )
        # FIX this: The existence of allAtoms attribute (and the fact that it is an empty set rather than all atoms in
        # the chain) causes getNodesByMolecule() to return wrong values
        if hasattr(current_chain, "allAtoms"):
            del current_chain.allAtoms
        # current_chain = Chain( id='GRO',parent = mol)
        mol.adopt(current_chain, setChildrenTop=1)

        for index in range(2, number_of_atoms + 2):
            residue_number = int(self.allLines[index][:5])
            if residue_number != current_residue_number:  #
                # current_chain should adopt the current residue if there is one
                # create new residue
                res_type = self.allLines[index][5:10]
                residue_type = res_type.split(' ')[0]

                current_residue = Residue(type=residue_type,
                                          number=residue_number)
                current_residue_number = residue_number
                if current_residue is not None:  # REMEMBER TO ADOPT THE LAST ONE!!!

                    current_chain.adopt(current_residue, setChildrenTop=1)

            n = self.allLines[index][10:15]
            name = n.split(' ')[-1]
            element = name

            if element in list(babel_elements.keys()):
                element = element

            else:

                if residue_type == "System" or residue_type == "SOL":
                    # if element[1] == 'W':
                    #          element = 'H'
                    #   group is treated as one particle
                    # else:
                    element = element[0]

                elif element[:2] == 'Me':
                    element = 'C'
                else:
                    element = element[0]

            # if len(element)>1:
            #    if type(element[1]) == types.StringType:
            #
            #        if element[1] == element[1].lower():
            #            element =element
            #        else:
            #            element = element[0]
            #
            #    else:
            #        element = element[0]

            atom = Atom(name, current_residue, element, top=mol)
            c = self.allLines[index][15:20]
            cx = self.allLines[index][20:28]
            cy = self.allLines[index][28:36]
            cz = self.allLines[index][36:44]

            x = float(cx) * 10
            y = float(cy) * 10
            z = float(cz) * 10
            atom._coords = [[x, y, z]]

            atom._charges = []
            atom.segID = mol.name
            atom.normalname = name
            atom.number = int(self.allLines[index][15:20])
            atom.elementType = name[0]
            mol.atmNum[atom.number] = atom
            atom.altname = None
            atom.hetatm = 0
        mol.name = os.path.split(os.path.splitext(self.filename)[0])[-1]
        mol.allAtoms = mol.chains.residues.atoms
        mol.parser = self
        mol.levels = [Protein, Chain, Residue, Atom]
        name = ''
        for n in molList.name:
            name = n + ','
        name = name[:-1]
        molList.setStringRepr(name)
        strRpr = name + ':::'
        molList.allAtoms.setStringRepr(strRpr)
        for m in molList:
            mname = m.name
            strRpr = mname + ':::'
            m.allAtoms.setStringRepr(strRpr)
            strRpr = mname + ':'
            m.chains.setStringRepr(strRpr)
            for c in m.chains:
                cname = c.id
                strRpr = mname + ':' + cname + ':'
                c.residues.setStringRepr(strRpr)
                for r in c.residues:
                    rname = r.name
                    strRpr = mname + ':' + cname + ':' + rname + ':'
                    r.atoms.setStringRepr(strRpr)
        return molList