Class Bio::PDB::Record
In: lib/bio/db/pdb/pdb.rb
Parent: Struct

The ancestor of every single PDB record class. It inherits Struct class. Basically, each line of a PDB file corresponds to an instance of each corresponding child class. If continuation exists, multiple lines may correspond to single instance.

Methods

Included Modules

DataType

Classes and Modules

Class Bio::PDB::Record::ANISOU
Class Bio::PDB::Record::ATOM
Class Bio::PDB::Record::HETATM
Class Bio::PDB::Record::Jrnl
Class Bio::PDB::Record::Remark1
Class Bio::PDB::Record::Remark2

Constants

HEADER = def_rec([ 11, 50, Pdb_String, :classification ], #Pdb_String(40) [ 51, 59, Pdb_Date, :depDate ], [ 63, 66, Pdb_IDcode, :idCode ]   HEADER record class
OBSLTE = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 12, 20, Pdb_Date, :repDate ], [ 22, 25, Pdb_IDcode, :idCode ], [ 32, 35, Pdb_IDcode, :rIdCode ], [ 37, 40, Pdb_IDcode, :rIdCode ], [ 42, 45, Pdb_IDcode, :rIdCode ], [ 47, 50, Pdb_IDcode, :rIdCode ], [ 52, 55, Pdb_IDcode, :rIdCode ], [ 57, 60, Pdb_IDcode, :rIdCode ], [ 62, 65, Pdb_IDcode, :rIdCode ], [ 67, 70, Pdb_IDcode, :rIdCode ]   OBSLTE record class
TITLE = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 11, 70, Pdb_String, :title ]   TITLE record class
CAVEAT = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 12, 15, Pdb_IDcode, :idcode ], [ 20, 70, Pdb_String, :comment ]   CAVEAT record class
COMPND = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 11, 70, Pdb_Specification_list, :compound ]   COMPND record class
SOURCE = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 11, 70, Pdb_Specification_list, :srcName ]   SOURCE record class
KEYWDS = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 11, 70, Pdb_List, :keywds ]   KEYWDS record class
EXPDTA = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 11, 70, Pdb_SList, :technique ]   EXPDTA record class
AUTHOR = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 11, 70, Pdb_List, :authorList ]   AUTHOR record class
REVDAT = def_rec([ 8, 10, Pdb_Integer, :modNum ], [ 11, 12, Pdb_Continuation, nil ], [ 14, 22, Pdb_Date, :modDate ], [ 24, 28, Pdb_String, :modId ], # Pdb_String(5) [ 32, 32, Pdb_Integer, :modType ], [ 40, 45, Pdb_LString(6), :record ], [ 47, 52, Pdb_LString(6), :record ], [ 54, 59, Pdb_LString(6), :record ], [ 61, 66, Pdb_LString(6), :record ]   REVDAT record class
SPRSDE = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 12, 20, Pdb_Date, :sprsdeDate ], [ 22, 25, Pdb_IDcode, :idCode ], [ 32, 35, Pdb_IDcode, :sIdCode ], [ 37, 40, Pdb_IDcode, :sIdCode ], [ 42, 45, Pdb_IDcode, :sIdCode ], [ 47, 50, Pdb_IDcode, :sIdCode ], [ 52, 55, Pdb_IDcode, :sIdCode ], [ 57, 60, Pdb_IDcode, :sIdCode ], [ 62, 65, Pdb_IDcode, :sIdCode ], [ 67, 70, Pdb_IDcode, :sIdCode ]   SPRSDE record class
JRNL = nil   ‘JRNL’ is defined below
REMARK = nil   ‘REMARK’ is defined below
DBREF = def_rec([ 8, 11, Pdb_IDcode, :idCode ], [ 13, 13, Pdb_Character, :chainID ], [ 15, 18, Pdb_Integer, :seqBegin ], [ 19, 19, Pdb_AChar, :insertBegin ], [ 21, 24, Pdb_Integer, :seqEnd ], [ 25, 25, Pdb_AChar, :insertEnd ], [ 27, 32, Pdb_String, :database ], #Pdb_LString [ 34, 41, Pdb_String, :dbAccession ], #Pdb_LString [ 43, 54, Pdb_String, :dbIdCode ], #Pdb_LString [ 56, 60, Pdb_Integer, :dbseqBegin ], [ 61, 61, Pdb_AChar, :idbnsBeg ], [ 63, 67, Pdb_Integer, :dbseqEnd ], [ 68, 68, Pdb_AChar, :dbinsEnd ]   DBREF record class
SEQADV = def_rec([ 8, 11, Pdb_IDcode, :idCode ], [ 13, 15, Pdb_Residue_name, :resName ], [ 17, 17, Pdb_Character, :chainID ], [ 19, 22, Pdb_Integer, :seqNum ], [ 23, 23, Pdb_AChar, :iCode ], [ 25, 28, Pdb_String, :database ], #Pdb_LString [ 30, 38, Pdb_String, :dbIdCode ], #Pdb_LString [ 40, 42, Pdb_Residue_name, :dbRes ], [ 44, 48, Pdb_Integer, :dbSeq ], [ 50, 70, Pdb_LString, :conflict ]   SEQADV record class
SEQRES = def_rec(#[ 9, 10, Pdb_Integer, :serNum ], [ 9, 10, Pdb_Continuation, nil ], [ 12, 12, Pdb_Character, :chainID ], [ 14, 17, Pdb_Integer, :numRes ], [ 20, 22, Pdb_Residue_name, :resName ], [ 24, 26, Pdb_Residue_name, :resName ], [ 28, 30, Pdb_Residue_name, :resName ], [ 32, 34, Pdb_Residue_name, :resName ], [ 36, 38, Pdb_Residue_name, :resName ], [ 40, 42, Pdb_Residue_name, :resName ], [ 44, 46, Pdb_Residue_name, :resName ], [ 48, 50, Pdb_Residue_name, :resName ], [ 52, 54, Pdb_Residue_name, :resName ], [ 56, 58, Pdb_Residue_name, :resName ], [ 60, 62, Pdb_Residue_name, :resName ], [ 64, 66, Pdb_Residue_name, :resName ], [ 68, 70, Pdb_Residue_name, :resName ]   SEQRES record class
MODRES = def_rec([ 8, 11, Pdb_IDcode, :idCode ], [ 13, 15, Pdb_Residue_name, :resName ], [ 17, 17, Pdb_Character, :chainID ], [ 19, 22, Pdb_Integer, :seqNum ], [ 23, 23, Pdb_AChar, :iCode ], [ 25, 27, Pdb_Residue_name, :stdRes ], [ 30, 70, Pdb_String, :comment ]   MODRS record class
HET = def_rec([ 8, 10, Pdb_LString(3), :hetID ], [ 13, 13, Pdb_Character, :ChainID ], [ 14, 17, Pdb_Integer, :seqNum ], [ 18, 18, Pdb_AChar, :iCode ], [ 21, 25, Pdb_Integer, :numHetAtoms ], [ 31, 70, Pdb_String, :text ]   HET record class
HETNAM = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 12, 14, Pdb_LString(3), :hetID ], [ 16, 70, Pdb_String, :text ]   HETNAM record class
HETSYN = def_rec([ 9, 10, Pdb_Continuation, nil ], [ 12, 14, Pdb_LString(3), :hetID ], [ 16, 70, Pdb_SList, :hetSynonyms ]   HETSYN record class
FORMUL = def_rec([ 9, 10, Pdb_Integer, :compNum ], [ 13, 15, Pdb_LString(3), :hetID ], [ 17, 18, Pdb_Integer, :continuation ], [ 19, 19, Pdb_Character, :asterisk ], [ 20, 70, Pdb_String, :text ]   FORMUL record class
HELIX = def_rec([ 8, 10, Pdb_Integer, :serNum ], #[ 12, 14, Pdb_LString(3), :helixID ], [ 12, 14, Pdb_StringRJ, :helixID ], [ 16, 18, Pdb_Residue_name, :initResName ], [ 20, 20, Pdb_Character, :initChainID ], [ 22, 25, Pdb_Integer, :initSeqNum ], [ 26, 26, Pdb_AChar, :initICode ], [ 28, 30, Pdb_Residue_name, :endResName ], [ 32, 32, Pdb_Character, :endChainID ], [ 34, 37, Pdb_Integer, :endSeqNum ], [ 38, 38, Pdb_AChar, :endICode ], [ 39, 40, Pdb_Integer, :helixClass ], [ 41, 70, Pdb_String, :comment ], [ 72, 76, Pdb_Integer, :length ]   HELIX record class
SHEET = def_rec([ 8, 10, Pdb_Integer, :strand ], #[ 12, 14, Pdb_LString(3), :sheetID ], [ 12, 14, Pdb_StringRJ, :sheetID ], [ 15, 16, Pdb_Integer, :numStrands ], [ 18, 20, Pdb_Residue_name, :initResName ], [ 22, 22, Pdb_Character, :initChainID ], [ 23, 26, Pdb_Integer, :initSeqNum ], [ 27, 27, Pdb_AChar, :initICode ], [ 29, 31, Pdb_Residue_name, :endResName ], [ 33, 33, Pdb_Character, :endChainID ], [ 34, 37, Pdb_Integer, :endSeqNum ], [ 38, 38, Pdb_AChar, :endICode ], [ 39, 40, Pdb_Integer, :sense ], [ 42, 45, Pdb_Atom, :curAtom ], [ 46, 48, Pdb_Residue_name, :curResName ], [ 50, 50, Pdb_Character, :curChainId ], [ 51, 54, Pdb_Integer, :curResSeq ], [ 55, 55, Pdb_AChar, :curICode ], [ 57, 60, Pdb_Atom, :prevAtom ], [ 61, 63, Pdb_Residue_name, :prevResName ], [ 65, 65, Pdb_Character, :prevChainId ], [ 66, 69, Pdb_Integer, :prevResSeq ], [ 70, 70, Pdb_AChar, :prevICode ]   SHEET record class
TURN = def_rec([ 8, 10, Pdb_Integer, :seq ], #[ 12, 14, Pdb_LString(3), :turnId ], [ 12, 14, Pdb_StringRJ, :turnId ], [ 16, 18, Pdb_Residue_name, :initResName ], [ 20, 20, Pdb_Character, :initChainId ], [ 21, 24, Pdb_Integer, :initSeqNum ], [ 25, 25, Pdb_AChar, :initICode ], [ 27, 29, Pdb_Residue_name, :endResName ], [ 31, 31, Pdb_Character, :endChainId ], [ 32, 35, Pdb_Integer, :endSeqNum ], [ 36, 36, Pdb_AChar, :endICode ], [ 41, 70, Pdb_String, :comment ]   TURN record class
SSBOND = def_rec([ 8, 10, Pdb_Integer, :serNum ], [ 12, 14, Pdb_LString(3), :pep1 ], # "CYS" [ 16, 16, Pdb_Character, :chainID1 ], [ 18, 21, Pdb_Integer, :seqNum1 ], [ 22, 22, Pdb_AChar, :icode1 ], [ 26, 28, Pdb_LString(3), :pep2 ], # "CYS" [ 30, 30, Pdb_Character, :chainID2 ], [ 32, 35, Pdb_Integer, :seqNum2 ], [ 36, 36, Pdb_AChar, :icode2 ], [ 60, 65, Pdb_SymOP, :sym1 ], [ 67, 72, Pdb_SymOP, :sym2 ]   SSBOND record class
LINK = def_rec([ 13, 16, Pdb_Atom, :name1 ], [ 17, 17, Pdb_Character, :altLoc1 ], [ 18, 20, Pdb_Residue_name, :resName1 ], [ 22, 22, Pdb_Character, :chainID1 ], [ 23, 26, Pdb_Integer, :resSeq1 ], [ 27, 27, Pdb_AChar, :iCode1 ], [ 43, 46, Pdb_Atom, :name2 ], [ 47, 47, Pdb_Character, :altLoc2 ], [ 48, 50, Pdb_Residue_name, :resName2 ], [ 52, 52, Pdb_Character, :chainID2 ], [ 53, 56, Pdb_Integer, :resSeq2 ], [ 57, 57, Pdb_AChar, :iCode2 ], [ 60, 65, Pdb_SymOP, :sym1 ], [ 67, 72, Pdb_SymOP, :sym2 ]   LINK record class
HYDBND = def_rec([ 13, 16, Pdb_Atom, :name1 ], [ 17, 17, Pdb_Character, :altLoc1 ], [ 18, 20, Pdb_Residue_name, :resName1 ], [ 22, 22, Pdb_Character, :Chain1 ], [ 23, 27, Pdb_Integer, :resSeq1 ], [ 28, 28, Pdb_AChar, :ICode1 ], [ 30, 33, Pdb_Atom, :nameH ], [ 34, 34, Pdb_Character, :altLocH ], [ 36, 36, Pdb_Character, :ChainH ], [ 37, 41, Pdb_Integer, :resSeqH ], [ 42, 42, Pdb_AChar, :iCodeH ], [ 44, 47, Pdb_Atom, :name2 ], [ 48, 48, Pdb_Character, :altLoc2 ], [ 49, 51, Pdb_Residue_name, :resName2 ], [ 53, 53, Pdb_Character, :chainID2 ], [ 54, 58, Pdb_Integer, :resSeq2 ], [ 59, 59, Pdb_AChar, :iCode2 ], [ 60, 65, Pdb_SymOP, :sym1 ], [ 67, 72, Pdb_SymOP, :sym2 ]   HYDBND record class
SLTBRG = def_rec([ 13, 16, Pdb_Atom, :atom1 ], [ 17, 17, Pdb_Character, :altLoc1 ], [ 18, 20, Pdb_Residue_name, :resName1 ], [ 22, 22, Pdb_Character, :chainID1 ], [ 23, 26, Pdb_Integer, :resSeq1 ], [ 27, 27, Pdb_AChar, :iCode1 ], [ 43, 46, Pdb_Atom, :atom2 ], [ 47, 47, Pdb_Character, :altLoc2 ], [ 48, 50, Pdb_Residue_name, :resName2 ], [ 52, 52, Pdb_Character, :chainID2 ], [ 53, 56, Pdb_Integer, :resSeq2 ], [ 57, 57, Pdb_AChar, :iCode2 ], [ 60, 65, Pdb_SymOP, :sym1 ], [ 67, 72, Pdb_SymOP, :sym2 ]   SLTBRG record class
CISPEP = def_rec([ 8, 10, Pdb_Integer, :serNum ], [ 12, 14, Pdb_LString(3), :pep1 ], [ 16, 16, Pdb_Character, :chainID1 ], [ 18, 21, Pdb_Integer, :seqNum1 ], [ 22, 22, Pdb_AChar, :icode1 ], [ 26, 28, Pdb_LString(3), :pep2 ], [ 30, 30, Pdb_Character, :chainID2 ], [ 32, 35, Pdb_Integer, :seqNum2 ], [ 36, 36, Pdb_AChar, :icode2 ], [ 44, 46, Pdb_Integer, :modNum ], [ 54, 59, Pdb_Real('6.2'), :measure ]   CISPEP record class
SITE = def_rec([ 8, 10, Pdb_Integer, :seqNum ], [ 12, 14, Pdb_LString(3), :siteID ], [ 16, 17, Pdb_Integer, :numRes ], [ 19, 21, Pdb_Residue_name, :resName1 ], [ 23, 23, Pdb_Character, :chainID1 ], [ 24, 27, Pdb_Integer, :seq1 ], [ 28, 28, Pdb_AChar, :iCode1 ], [ 30, 32, Pdb_Residue_name, :resName2 ], [ 34, 34, Pdb_Character, :chainID2 ], [ 35, 38, Pdb_Integer, :seq2 ], [ 39, 39, Pdb_AChar, :iCode2 ], [ 41, 43, Pdb_Residue_name, :resName3 ], [ 45, 45, Pdb_Character, :chainID3 ], [ 46, 49, Pdb_Integer, :seq3 ], [ 50, 50, Pdb_AChar, :iCode3 ], [ 52, 54, Pdb_Residue_name, :resName4 ], [ 56, 56, Pdb_Character, :chainID4 ], [ 57, 60, Pdb_Integer, :seq4 ], [ 61, 61, Pdb_AChar, :iCode4 ]   SITE record class
CRYST1 = def_rec([ 7, 15, Pdb_Real('9.3'), :a ], [ 16, 24, Pdb_Real('9.3'), :b ], [ 25, 33, Pdb_Real('9.3'), :c ], [ 34, 40, Pdb_Real('7.2'), :alpha ], [ 41, 47, Pdb_Real('7.2'), :beta ], [ 48, 54, Pdb_Real('7.2'), :gamma ], [ 56, 66, Pdb_LString, :sGroup ], [ 67, 70, Pdb_Integer, :z ]   CRYST1 record class
ORIGX1 = def_rec([ 11, 20, Pdb_Real('10.6'), :On1 ], [ 21, 30, Pdb_Real('10.6'), :On2 ], [ 31, 40, Pdb_Real('10.6'), :On3 ], [ 46, 55, Pdb_Real('10.5'), :Tn ]   ORIGX1 record class

ORIGXn n=1, 2, or 3

ORIGX2 = new_inherit(ORIGX1)   ORIGX2 record class
ORIGX3 = new_inherit(ORIGX1)   ORIGX3 record class
SCALE1 = def_rec([ 11, 20, Pdb_Real('10.6'), :Sn1 ], [ 21, 30, Pdb_Real('10.6'), :Sn2 ], [ 31, 40, Pdb_Real('10.6'), :Sn3 ], [ 46, 55, Pdb_Real('10.5'), :Un ]   SCALE1 record class

SCALEn n=1, 2, or 3

SCALE2 = new_inherit(SCALE1)   SCALE2 record class
SCALE3 = new_inherit(SCALE1)   SCALE3 record class
MTRIX1 = def_rec([ 8, 10, Pdb_Integer, :serial ], [ 11, 20, Pdb_Real('10.6'), :Mn1 ], [ 21, 30, Pdb_Real('10.6'), :Mn2 ], [ 31, 40, Pdb_Real('10.6'), :Mn3 ], [ 46, 55, Pdb_Real('10.5'), :Vn ], [ 60, 60, Pdb_Integer, :iGiven ]   MTRIX1 record class

MTRIXn n=1,2, or 3

MTRIX2 = new_inherit(MTRIX1)   MTRIX2 record class
MTRIX3 = new_inherit(MTRIX1)   MTRIX3 record class
TVECT = def_rec([ 8, 10, Pdb_Integer, :serial ], [ 11, 20, Pdb_Real('10.5'), :t1 ], [ 21, 30, Pdb_Real('10.5'), :t2 ], [ 31, 40, Pdb_Real('10.5'), :t3 ], [ 41, 70, Pdb_String, :text ]   TVECT record class
MODEL = def_rec([ 11, 14, Pdb_Integer, :serial ]   MODEL record class
ATOM = new_direct([ 7, 11, Pdb_Integer, :serial ], [ 13, 16, Pdb_Atom, :name ], [ 17, 17, Pdb_Character, :altLoc ], [ 18, 20, Pdb_Residue_name, :resName ], [ 22, 22, Pdb_Character, :chainID ], [ 23, 26, Pdb_Integer, :resSeq ], [ 27, 27, Pdb_AChar, :iCode ], [ 31, 38, Pdb_Real('8.3'), :x ], [ 39, 46, Pdb_Real('8.3'), :y ], [ 47, 54, Pdb_Real('8.3'), :z ], [ 55, 60, Pdb_Real('6.2'), :occupancy ], [ 61, 66, Pdb_Real('6.2'), :tempFactor ], [ 73, 76, Pdb_LString(4), :segID ], [ 77, 78, Pdb_LString(2), :element ], [ 79, 80, Pdb_LString(2), :charge ]   ATOM record class
SIGATM = def_rec([ 7, 11, Pdb_Integer, :serial ], [ 13, 16, Pdb_Atom, :name ], [ 17, 17, Pdb_Character, :altLoc ], [ 18, 20, Pdb_Residue_name, :resName ], [ 22, 22, Pdb_Character, :chainID ], [ 23, 26, Pdb_Integer, :resSeq ], [ 27, 27, Pdb_AChar, :iCode ], [ 31, 38, Pdb_Real('8.3'), :sigX ], [ 39, 46, Pdb_Real('8.3'), :sigY ], [ 47, 54, Pdb_Real('8.3'), :sigZ ], [ 55, 60, Pdb_Real('6.2'), :sigOcc ], [ 61, 66, Pdb_Real('6.2'), :sigTemp ], [ 73, 76, Pdb_LString(4), :segID ], [ 77, 78, Pdb_LString(2), :element ], [ 79, 80, Pdb_LString(2), :charge ]   SIGATM record class
ANISOU = def_rec([ 7, 11, Pdb_Integer, :serial ], [ 13, 16, Pdb_Atom, :name ], [ 17, 17, Pdb_Character, :altLoc ], [ 18, 20, Pdb_Residue_name, :resName ], [ 22, 22, Pdb_Character, :chainID ], [ 23, 26, Pdb_Integer, :resSeq ], [ 27, 27, Pdb_AChar, :iCode ], [ 29, 35, Pdb_Integer, :U11 ], [ 36, 42, Pdb_Integer, :U22 ], [ 43, 49, Pdb_Integer, :U33 ], [ 50, 56, Pdb_Integer, :U12 ], [ 57, 63, Pdb_Integer, :U13 ], [ 64, 70, Pdb_Integer, :U23 ], [ 73, 76, Pdb_LString(4), :segID ], [ 77, 78, Pdb_LString(2), :element ], [ 79, 80, Pdb_LString(2), :charge ]   ANISOU record class
SIGUIJ = def_rec([ 7, 11, Pdb_Integer, :serial ], [ 13, 16, Pdb_Atom, :name ], [ 17, 17, Pdb_Character, :altLoc ], [ 18, 20, Pdb_Residue_name, :resName ], [ 22, 22, Pdb_Character, :chainID ], [ 23, 26, Pdb_Integer, :resSeq ], [ 27, 27, Pdb_AChar, :iCode ], [ 29, 35, Pdb_Integer, :SigmaU11 ], [ 36, 42, Pdb_Integer, :SigmaU22 ], [ 43, 49, Pdb_Integer, :SigmaU33 ], [ 50, 56, Pdb_Integer, :SigmaU12 ], [ 57, 63, Pdb_Integer, :SigmaU13 ], [ 64, 70, Pdb_Integer, :SigmaU23 ], [ 73, 76, Pdb_LString(4), :segID ], [ 77, 78, Pdb_LString(2), :element ], [ 79, 80, Pdb_LString(2), :charge ]   SIGUIJ record class
TER = def_rec([ 7, 11, Pdb_Integer, :serial ], [ 18, 20, Pdb_Residue_name, :resName ], [ 22, 22, Pdb_Character, :chainID ], [ 23, 26, Pdb_Integer, :resSeq ], [ 27, 27, Pdb_AChar, :iCode ]   TER record class
HETATM = new_inherit(ATOM)   HETATM record class
ENDMDL = def_rec([ 2, 1, Pdb_Integer, :serial ] # dummy field (always 0)   ENDMDL record class
CONECT = def_rec([ 7, 11, Pdb_Integer, :serial ], [ 12, 16, Pdb_Integer, :serial ], [ 17, 21, Pdb_Integer, :serial ], [ 22, 26, Pdb_Integer, :serial ], [ 27, 31, Pdb_Integer, :serial ], [ 32, 36, Pdb_Integer, :serial ], [ 37, 41, Pdb_Integer, :serial ], [ 42, 46, Pdb_Integer, :serial ], [ 47, 51, Pdb_Integer, :serial ], [ 52, 56, Pdb_Integer, :serial ], [ 57, 61, Pdb_Integer, :serial ]   CONECT record class
MASTER = def_rec([ 11, 15, Pdb_Integer, :numRemark ], [ 16, 20, Pdb_Integer, "0" ], [ 21, 25, Pdb_Integer, :numHet ], [ 26, 30, Pdb_Integer, :numHelix ], [ 31, 35, Pdb_Integer, :numSheet ], [ 36, 40, Pdb_Integer, :numTurn ], [ 41, 45, Pdb_Integer, :numSite ], [ 46, 50, Pdb_Integer, :numXform ], [ 51, 55, Pdb_Integer, :numCoord ], [ 56, 60, Pdb_Integer, :numTer ], [ 61, 65, Pdb_Integer, :numConect ], [ 66, 70, Pdb_Integer, :numSeq ]   MASTER record class
RemarkN = def_rec([ 8, 10, Pdb_Integer, :remarkNum ], [ 12, 70, Pdb_LString, :text ]   REMARK record class for REMARK n (n>=3)
Default = def_rec([ 8, 70, Pdb_LString, :text ])   default (or unknown) record class
Definition = create_definition_hash   definitions (hash)
End = def_rec([ 2, 1, Pdb_Integer, :serial ])   END record class.

Because END is a reserved word of Ruby, it is separately added to the hash

Public Class methods

Returns true if this record has a field type which allows continuations.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 287
287:       def self.continue?
288:         @cont
289:       end

creates definition hash from current classes constants

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 438
438:       def self.create_definition_hash
439:         hash = {}
440:         constants.each do |x|
441:           x = x.intern # keep compatibility both Ruby 1.8 and 1.9
442:           hash[x] = const_get(x) if /\A[A-Z][A-Z0-9]+\z/ =~ x.to_s
443:         end
444:         if x = const_get(:Default) then
445:           hash.default = x
446:         end
447:         hash
448:       end

Creates new class by given field definition The difference from new_direct() is the class created by the method does lazy evaluation.

Internal use only.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 226
226:       def self.def_rec(*ary)
227:         symbolhash, symbolary, cont = parse_field_definitions(ary)
228: 
229:         klass = Class.new(self.new(*symbolary))
230:         klass.module_eval {
231:           @definition = ary
232:           @symbols = symbolhash
233:           @cont = cont
234:         }
235:         klass.module_eval {
236:           symbolary.each do |x|
237:             define_method(x) { do_parse; super() }
238:           end
239:         }
240:         klass
241:       end

Basically just look up the class in Definition hash do some munging for JRNL and REMARK

[Source]

      # File lib/bio/db/pdb/pdb.rb, line 1389
1389:       def self.get_record_class(str)
1390:         t = fetch_record_name(str)
1391:         t = t.intern unless t.empty?
1392:         if d = Definition[t] then
1393:           return d
1394:         end
1395:         case t
1396:         when :JRNL
1397:           ts = str[12..15].to_s.strip
1398:           ts = ts.intern unless ts.empty?
1399:           d = Jrnl::Definition[ts]
1400:         when :REMARK
1401:           case str[7..9].to_i
1402:           when 1
1403:             ts = str[12..15].to_s.strip
1404:             ts = ts.intern unless ts.empty?
1405:             d = Remark1::Definition[ts]
1406:           when 2
1407:             if str[28..37] == 'ANGSTROMS.' then
1408:               d = Remark2::ANGSTROMS
1409:             elsif str[22..37] == ' NOT APPLICABLE.' then
1410:               d = Remark2::NOT_APPLICABLE
1411:             else
1412:               d = Remark2::Default
1413:             end
1414:           else
1415:             d = RemarkN
1416:           end
1417:         else
1418:           # unknown field
1419:           d = Default
1420:         end
1421:         return d
1422:       end

Creates new class by given field definition.

Internal use only.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 257
257:       def self.new_direct(*ary)
258:         symbolhash, symbolary, cont = parse_field_definitions(ary)
259:         if cont
260:           raise 'continuation not allowed. please use def_rec instead'
261:         end
262: 
263:         klass = Class.new(self.new(*symbolary))
264:         klass.module_eval {
265:           @definition = ary
266:           @symbols = symbolhash
267:           @cont = cont
268:         }
269:         klass.module_eval {
270:           define_method(:initialize_from_string) { |str|
271:             r = super(str)
272:             do_parse
273:             r
274:           }
275:         }
276:         klass
277:       end

creates new class which inherits given class.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 244
244:       def self.new_inherit(klass)
245:         newklass = Class.new(klass)
246:         newklass.module_eval {
247:           @definition = klass.module_eval { @definition }
248:           @symbols    = klass.module_eval { @symbols }
249:           @cont       = klass.module_eval { @cont }
250:         }
251:         newklass
252:       end

symbols

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 280
280:       def self.symbols
281:         #p self
282:         @symbols
283:       end

Public Instance methods

Internal use only.

Adds continuation data to the record from str if str is really the continuation of current record. Returns self (= not nil) if str is the continuation. Otherwaise, returns false.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 421
421:       def add_continuation(str)
422:         #Check that this record can continue
423:         #and that str has the same type and definition
424:         return false unless self.continue?
425:         return false unless fetch_record_name(str) == @record_name
426:         return false unless self.class.get_record_class(str) == self.class
427:         return false unless fetch_cont(str) >= 2
428:         #If all this is OK then add onto @cont_data
429:         unless defined?(@cont_data)
430:           @cont_data = []
431:         end
432:         @cont_data << str
433:         # Returns self (= not nil) if succeeded.
434:         self
435:       end

Returns true if this record has a field type which allows continuations.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 293
293:       def continue?
294:         self.class.continue?
295:       end

In order to speeding up processing of PDB file format, fields have not been parsed before calling this method.

Normally, it is automatically called and you don‘t explicitly need to call it .

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 341
341:       def do_parse
342:         return self if @parsed or !@str
343:         str0 = @str
344:         each_symbol do |key, klass, ranges|
345:           #If we only have one range then pull that out
346:           #and store it in the hash
347:           if ranges.size <= 1 then
348:             self[key] = klass.new(str0[ranges.first])
349:           else
350:             #Go through each range and add the string to an array
351:             #set the hash key to point to that array
352:             ary = []
353:             ranges.each do |r|
354:               ary << klass.new(str0[r]) unless str0[r].to_s.strip.empty?
355:             end
356:             self[key] = ary
357:           end
358:         end #each_symbol
359:         #If we have continuations then for each line of extra data...
360:         if defined?(@cont_data) then
361:           @cont_data.each do |str|
362:             #Get the symbol, type and range array 
363:             each_symbol do |key, klass, ranges|
364:               #If there's one range then grab that range
365:               if ranges.size <= 1 then
366:                 r1 = ranges.first
367:                 unless str[r1].to_s.strip.empty?
368:                   #and concatenate the new data onto the old
369:                   v = klass.new(str[r1])
370:                   self[key].concat(v) if self[key] != v
371:                 end
372:               else
373:                 #If there's more than one range then add to the array
374:                 ary = self[key]
375:                 ranges.each do |r|
376:                   ary << klass.new(str[r]) unless str[r].to_s.strip.empty?
377:                 end
378:               end
379:             end
380:           end
381:         end
382:         @parsed = true
383:         self
384:       end

yields the symbol(k), type(x[0]) and array of ranges of each symbol.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 299
299:       def each_symbol
300:         self.class.symbols.each do |k, x|
301:           yield k, x[0], x[1]
302:         end
303:       end

initialize this record from the given string. str must be a line (in PDB format).

You can add continuation lines later using add_continuation method.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 323
323:       def initialize_from_string(str)
324:         @str = str
325:         @record_name = fetch_record_name(str)
326:         @parsed = false
327:         self
328:       end

same as Struct#inspect.

Note that do_parse is automatically called before inspect.

(Warning: The do_parse might sweep hidden bugs in PDB classes.)

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 456
456:       def inspect
457:         do_parse
458:         super
459:       end

Return original string (except that "\n" are truncated) for this record (usually just @str, but sometimes add on the continuation data from other lines. Returns an array of string.

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 310
310:       def original_data
311:         if defined?(@cont_data) then
312:           [ @str, *@cont_data ]
313:         else
314:           [ @str ]
315:         end
316:       end

Record name of this record, e.g. "HEADER", "ATOM".

[Source]

     # File lib/bio/db/pdb/pdb.rb, line 408
408:       def record_name
409:         @record_name or self.class.to_s.split(/\:\:/)[-1].to_s.upcase
410:       end
record_type()

Alias for record_name

[Validate]