Class: Bio::PDB::Record

Inherits:
Struct
  • Object
show all
Extended by:
DataType::ConstLikeMethod
Includes:
DataType
Defined in:
lib/bio/db/pdb/pdb.rb

Overview

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.

Defined Under Namespace

Classes: ANISOU, ATOM, HETATM, Jrnl, Remark1, Remark2

Constant Summary

HEADER =

HEADER record class

def_rec([ 11, 50, Pdb_String, :classification ], #Pdb_String(40)
[ 51, 59, Pdb_Date,   :depDate ],
[ 63, 66, Pdb_IDcode, :idCode ]
)
OBSLTE =

OBSLTE record class

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 ]
)
TITLE =

TITLE record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 11, 70, Pdb_String, :title ]
)
CAVEAT =

CAVEAT record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 12, 15, Pdb_IDcode, :idcode ],
[ 20, 70, Pdb_String, :comment ]
)
COMPND =

COMPND record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 11, 70, Pdb_Specification_list, :compound ]
)
SOURCE =

SOURCE record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 11, 70, Pdb_Specification_list, :srcName ]
)
KEYWDS =

KEYWDS record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 11, 70, Pdb_List, :keywds ]
)
EXPDTA =

EXPDTA record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 11, 70, Pdb_SList, :technique ]
)
AUTHOR =

AUTHOR record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 11, 70, Pdb_List, :authorList ]
)
REVDAT =

REVDAT record class

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  ]
)
SPRSDE =

SPRSDE record class

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 ]
)
JRNL =

'JRNL' is defined below

nil
REMARK =

'REMARK' is defined below

nil
DBREF =

DBREF record class

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    ]
)
SEQADV =

SEQADV record class

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 ]
)
SEQRES =

SEQRES record class

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 ]
)
MODRES =

MODRS record class

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 ]
)
HET =

HET record class

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 ]
)
HETNAM =

HETNAM record class

def_rec([ 9, 10,  Pdb_Continuation, nil ],
[ 12, 14, Pdb_LString(3),   :hetID ],
[ 16, 70, Pdb_String,       :text ]
)
HETSYN =

HETSYN record class

def_rec([  9, 10, Pdb_Continuation, nil ],
[ 12, 14, Pdb_LString(3),   :hetID ],
[ 16, 70, Pdb_SList,        :hetSynonyms ]
)
FORMUL =

FORMUL record class

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 ]
)
HELIX =

HELIX record class

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 ]
)
SHEET =

SHEET record class

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 ]
)
TURN =

TURN record class

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 ]
)
SSBOND =

SSBOND record class

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     ]
)
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 ]
)
HYDBND =

HYDBND record class

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 ]
)
SLTBRG =

SLTBRG record class

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 ]
)
CISPEP =

CISPEP record class

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 ]
)
SITE =

SITE record class

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    ]
)
CRYST1 =

CRYST1 record class

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 ]
)
ORIGX1 =

ORIGX1 record class

ORIGXn n=1, 2, or 3

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 ]
)
ORIGX2 =

ORIGX2 record class

new_inherit(ORIGX1)
ORIGX3 =

ORIGX3 record class

new_inherit(ORIGX1)
SCALE1 =

SCALE1 record class

SCALEn n=1, 2, or 3

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 ]
)
SCALE2 =

SCALE2 record class

new_inherit(SCALE1)
SCALE3 =

SCALE3 record class

new_inherit(SCALE1)
MTRIX1 =

MTRIX1 record class

MTRIXn n=1,2, or 3

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 ]
)
MTRIX2 =

MTRIX2 record class

new_inherit(MTRIX1)
MTRIX3 =

MTRIX3 record class

new_inherit(MTRIX1)
TVECT =

TVECT record class

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 ]
)
MODEL =

MODEL record class

def_rec([ 11, 14, Pdb_Integer, :serial ]
)
SIGATM =

SIGATM record class

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 ]
)
SIGUIJ =

SIGUIJ record class

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 ]
)
TER =

TER record class

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 ]
)
ENDMDL =

ENDMDL record class

def_rec([  2,  1, Pdb_Integer, :serial ] # dummy field (always 0)
)
CONECT =

CONECT record class

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 ]
)
MASTER =

MASTER record class

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 ]
)
RemarkN =

REMARK record class for REMARK n (n>=3)

def_rec([  8, 10, Pdb_Integer, :remarkNum ],
[ 12, 70, Pdb_LString, :text ]
)
Default =

default (or unknown) record class

def_rec([ 8, 70, Pdb_LString, :text ])
Definition =

definitions (hash)

create_definition_hash
End =

END record class.

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

def_rec([  2,  1, Pdb_Integer, :serial ])

Constants included from DataType

DataType::Pdb_AChar, DataType::Pdb_Atom, DataType::Pdb_Character, DataType::Pdb_Continuation, DataType::Pdb_Date, DataType::Pdb_IDcode, DataType::Pdb_Residue_name, DataType::Pdb_SymOP

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods included from DataType::ConstLikeMethod

Pdb_LString, Pdb_Real, Pdb_String

Class Method Details

+ (Boolean) continue?

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

Returns:

  • (Boolean) 


286
287
288
 
# File 'lib/bio/db/pdb/pdb.rb', line 286

def self.continue?
  @cont
end

+ (Object) create_definition_hash

creates definition hash from current classes constants



437
438
439
440
441
442
443
444
445
446
447
 
# File 'lib/bio/db/pdb/pdb.rb', line 437

def self.create_definition_hash
  hash = {}
  constants.each do |x|
    x = x.intern # keep compatibility both Ruby 1.8 and 1.9
    hash[x] = const_get(x) if /\A[A-Z][A-Z0-9]+\z/ =~ x.to_s
  end
  if x = const_get(:Default) then
    hash.default = x
  end
  hash
end

+ (Object) 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.



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/bio/db/pdb/pdb.rb', line 225

def self.def_rec(*ary)
  symbolhash, symbolary, cont = parse_field_definitions(ary)

  klass = Class.new(self.new(*symbolary))
  klass.module_eval {
    @definition = ary
    @symbols = symbolhash
    @cont = cont
  }
  klass.module_eval {
    symbolary.each do |x|
      define_method(x) { do_parse; super() }
    end
  }
  klass
end

+ (Object) fetch_record_name(str)

fetches record name



392
393
394
 
# File 'lib/bio/db/pdb/pdb.rb', line 392

def self.fetch_record_name(str)
  str[0..5].strip
end

+ (Object) get_record_class(str)

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



1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
 
# File 'lib/bio/db/pdb/pdb.rb', line 1388

def self.get_record_class(str)
  t = fetch_record_name(str)
  t = t.intern unless t.empty?
  if d = Definition[t] then
    return d
  end
  case t
  when :JRNL
    ts = str[12..15].to_s.strip
    ts = ts.intern unless ts.empty?
    d = Jrnl::Definition[ts]
  when :REMARK
    case str[7..9].to_i
    when 1
      ts = str[12..15].to_s.strip
      ts = ts.intern unless ts.empty?
      d = Remark1::Definition[ts]
    when 2
      if str[28..37] == 'ANGSTROMS.' then
        d = Remark2::ANGSTROMS
      elsif str[22..37] == ' NOT APPLICABLE.' then
        d = Remark2::NOT_APPLICABLE
      else
        d = Remark2::Default
      end
    else
      d = RemarkN
    end
  else
    # unknown field
    d = Default
  end
  return d
end

+ (Object) new_direct(*ary)

Creates new class by given field definition.

Internal use only.



256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
# File 'lib/bio/db/pdb/pdb.rb', line 256

def self.new_direct(*ary)
  symbolhash, symbolary, cont = parse_field_definitions(ary)
  if cont
    raise 'continuation not allowed. please use def_rec instead'
  end

  klass = Class.new(self.new(*symbolary))
  klass.module_eval {
    @definition = ary
    @symbols = symbolhash
    @cont = cont
  }
  klass.module_eval {
    define_method(:initialize_from_string) { |str|
      r = super(str)
      do_parse
      r
    }
  }
  klass
end

+ (Object) new_inherit(klass)

creates new class which inherits given class.



243
244
245
246
247
248
249
250
251
 
# File 'lib/bio/db/pdb/pdb.rb', line 243

def self.new_inherit(klass)
  newklass = Class.new(klass)
  newklass.module_eval {
    @definition = klass.module_eval { @definition }
    @symbols    = klass.module_eval { @symbols }
    @cont       = klass.module_eval { @cont }
  }
  newklass
end

+ (Object) parse_field_definitions(ary)

Internal use only.

parse filed definitions.



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/bio/db/pdb/pdb.rb', line 185

def self.parse_field_definitions(ary)
  symbolhash = {}
  symbolary = []
  cont = false

  # For each field definition (range(start, end), type,symbol)
  ary.each do |x|
    range = (x[0] - 1)..(x[1] - 1)
    # If type is nil (Pdb_Continuation) then set 'cont' to the range
    # (other wise it is false to indicate no continuation
    unless x[2] then
      cont = range
    else
      klass = x[2]
      sym = x[3]
      # If the symbol is a proper symbol then...
      if sym.is_a?(Symbol) then
        # ..if we have the symbol already in the symbol hash
        # then add the range onto the range array
        if symbolhash.has_key?(sym) then
          symbolhash[sym][1] << range
        else
          # Other wise put a new symbol in with its type and range
          # range is given its own array. You can have
          # anumber of ranges.
          symbolhash[sym] = [ klass, [ range ] ]
          symbolary << sym
        end
      end
    end
  end #each
  [ symbolhash, symbolary, cont ]
end

+ (Object) symbols

symbols



279
280
281
282
 
# File 'lib/bio/db/pdb/pdb.rb', line 279

def self.symbols
  #p self
  @symbols
end

Instance Method Details

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



420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
 
# File 'lib/bio/db/pdb/pdb.rb', line 420

def add_continuation(str)
  #Check that this record can continue
  #and that str has the same type and definition
  return false unless self.continue?
  return false unless fetch_record_name(str) == @record_name
  return false unless self.class.get_record_class(str) == self.class
  return false unless fetch_cont(str) >= 2
  #If all this is OK then add onto @cont_data
  unless defined?(@cont_data)
    @cont_data = []
  end
  @cont_data << str
  # Returns self (= not nil) if succeeded.
  self
end

- (Boolean) continue?

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

Returns:

  • (Boolean) 


292
293
294
 
# File 'lib/bio/db/pdb/pdb.rb', line 292

def continue?
  self.class.continue?
end

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



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
 
# File 'lib/bio/db/pdb/pdb.rb', line 340

def do_parse
  return self if @parsed or !@str
  str0 = @str
  each_symbol do |key, klass, ranges|
    #If we only have one range then pull that out
    #and store it in the hash
    if ranges.size <= 1 then
      self[key] = klass.new(str0[ranges.first])
    else
      #Go through each range and add the string to an array
      #set the hash key to point to that array
      ary = []
      ranges.each do |r|
        ary << klass.new(str0[r]) unless str0[r].to_s.strip.empty?
      end
      self[key] = ary
    end
  end #each_symbol
  #If we have continuations then for each line of extra data...
  if defined?(@cont_data) then
    @cont_data.each do |str|
      #Get the symbol, type and range array 
      each_symbol do |key, klass, ranges|
        #If there's one range then grab that range
        if ranges.size <= 1 then
          r1 = ranges.first
          unless str[r1].to_s.strip.empty?
            #and concatenate the new data onto the old
            v = klass.new(str[r1])
            self[key].concat(v) if self[key] != v
          end
        else
          #If there's more than one range then add to the array
          ary = self[key]
          ranges.each do |r|
            ary << klass.new(str[r]) unless str[r].to_s.strip.empty?
          end
        end
      end
    end
  end
  @parsed = true
  self
end

- (Object) each_symbol

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



298
299
300
301
302
 
# File 'lib/bio/db/pdb/pdb.rb', line 298

def each_symbol
  self.class.symbols.each do |k, x|
    yield k, x[0], x[1]
  end
end

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



322
323
324
325
326
327
 
# File 'lib/bio/db/pdb/pdb.rb', line 322

def initialize_from_string(str)
  @str = str
  @record_name = fetch_record_name(str)
  @parsed = false
  self
end

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



455
456
457
458
 
# File 'lib/bio/db/pdb/pdb.rb', line 455

def inspect
  do_parse
  super
end

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



309
310
311
312
313
314
315
 
# File 'lib/bio/db/pdb/pdb.rb', line 309

def original_data
  if defined?(@cont_data) then
    [ @str, *@cont_data ]
  else
    [ @str ]
  end
end

- (Object) record_name Also known as: record_type

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



407
408
409
 
# File 'lib/bio/db/pdb/pdb.rb', line 407

def record_name
  @record_name or self.class.to_s.split(/\:\:/)[-1].to_s.upcase
end