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.

Direct Known Subclasses

ChemicalComponent::Record, Jrnl, Remark1, Remark2

Defined Under Namespace

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

Constant Summary collapse

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

.continue? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

def self.continue?
  @cont
end

.create_definition_hash ⇒ Object

creates definition hash from current classes constants



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

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

.def_rec(*ary) ⇒ Object

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.



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

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

.get_record_class(str) ⇒ Object

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



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
1422
 
# File 'lib/bio/db/pdb/pdb.rb', line 1389

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

.new_direct(*ary) ⇒ Object

Creates new class by given field definition.

Internal use only.



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

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

.new_inherit(klass) ⇒ Object

creates new class which inherits given class.



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

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

.symbols ⇒ Object

symbols



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

def self.symbols
  #p self
  @symbols
end

Instance Method Details

#add_continuation(str) ⇒ Object

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.



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

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

#continue? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

def continue?
  self.class.continue?
end

#do_parse ⇒ Object

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 .



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
384
 
# File 'lib/bio/db/pdb/pdb.rb', line 341

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

#each_symbol ⇒ Object

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



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

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

#initialize_from_string(str) ⇒ Object

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.



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

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

#inspect ⇒ Object

same as Struct#inspect.

Note that do_parse is automatically called before inspect.

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



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

def inspect
  do_parse
  super
end

#original_data ⇒ Object

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.



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

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

#record_name ⇒ Object Also known as: record_type

Record name of this record, e.g. “HEADER”, “ATOM”.



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

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