class Bio::PDB::Record
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.
Constants
- ANISOU
ANISOU record class
- ATOM
ATOM record class
- AUTHOR
AUTHOR record class
- CAVEAT
CAVEAT record class
- CISPEP
CISPEP record class
- COMPND
COMPND record class
- CONECT
CONECT record class
- CRYST1
CRYST1 record class
- DBREF
DBREF record class
- Default
default (or unknown) record class
- Definition
definitions (hash)
- ENDMDL
ENDMDL record class
- EXPDTA
EXPDTA record class
- End
END record class.
Because END is a reserved word of Ruby, it is separately added to the hash
- FORMUL
FORMUL record class
- HEADER
HEADER record class
- HELIX
HELIX record class
- HET
HET record class
- HETATM
HETATM record class
- HETNAM
HETNAM record class
- HETSYN
HETSYN record class
- HYDBND
HYDBND record class
- JRNL
'JRNL' is defined below
- KEYWDS
KEYWDS record class
- LINK
LINK record class
- MASTER
MASTER record class
- MODEL
MODEL record class
- MODRES
MODRS record class
- MTRIX1
MTRIX1 record class
MTRIXn n=1,2, or 3
- MTRIX2
MTRIX2 record class
- MTRIX3
MTRIX3 record class
- OBSLTE
OBSLTE record class
- ORIGX1
ORIGX1 record class
ORIGXn n=1, 2, or 3
- ORIGX2
ORIGX2 record class
- ORIGX3
ORIGX3 record class
- REMARK
'REMARK' is defined below
- REVDAT
REVDAT record class
- RemarkN
- SCALE1
SCALE1 record class
SCALEn n=1, 2, or 3
- SCALE2
SCALE2 record class
- SCALE3
SCALE3 record class
- SEQADV
SEQADV record class
- SEQRES
SEQRES record class
- SHEET
SHEET record class
- SIGATM
SIGATM record class
- SIGUIJ
SIGUIJ record class
- SITE
SITE record class
- SLTBRG
SLTBRG record class
- SOURCE
SOURCE record class
- SPRSDE
SPRSDE record class
- SSBOND
SSBOND record class
- TER
TER record class
- TITLE
TITLE record class
- TURN
TURN record class
- TVECT
TVECT record class
Public Class Methods
Returns true if this record has a field type which allows continuations.
# File lib/bio/db/pdb/pdb.rb, line 287 def self.continue? @cont end
creates definition hash from current classes constants
# 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
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.
# 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
Basically just look up the class in Definition hash do some munging for JRNL and REMARK
# 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
Creates new class by given field definition.
Internal use only.
# 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
creates new class which inherits given class.
# 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
# File lib/bio/db/pdb/pdb.rb, line 280 def self.symbols #p self @symbols end
Private Class Methods
fetches record name
# File lib/bio/db/pdb/pdb.rb, line 393 def self.fetch_record_name(str) str[0..5].strip end
Internal use only.
parse filed definitions.
# File lib/bio/db/pdb/pdb.rb, line 186 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
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.
# 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
Returns true if this record has a field type which allows continuations.
# File lib/bio/db/pdb/pdb.rb, line 293 def continue? self.class.continue? 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 .
# 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
yields the symbol(k), type(x) and array of ranges of each symbol.
# 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 this record from the given string. str must be a line (in PDB format).
You can add continuation lines later using add_continuation
method.
# 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
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.
# 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 of this record, e.g. “HEADER”, “ATOM”.
# 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
Private Instance Methods
If given str can be the continuation of the current record, then return the order number of the continuation associated with the Pdb_Continuation field definition. Otherwise, returns -1.
# File lib/bio/db/pdb/pdb.rb, line 402 def fetch_cont(str) (c = continue?) ? str[c].to_i : -1 end
fetches record name
# File lib/bio/db/pdb/pdb.rb, line 387 def fetch_record_name(str) str[0..5].strip end