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

add_continuation continue? continue? create_definition_hash def_rec do_parse each_symbol get_record_class initialize_from_string inspect new_direct new_inherit original_data record_name record_type symbols

### 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

continue?()

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

create_definition_hash()

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

def_rec(*ary)

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

get_record_class(str)

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

new_direct(*ary)

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

new_inherit(klass)

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()

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

add_continuation(str)

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

continue?()

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

do_parse()

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

each_symbol() {|k, x[0], x[1]| ...}

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_from_string(str)

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

inspect()

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

original_data()

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()

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]