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

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

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

continue?() click to toggle source

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
create_definition_hash() click to toggle source

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
def_rec(*ary) click to toggle source

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.

Calls superclass method
# 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) click to toggle source

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
new_direct(*ary) click to toggle source

Creates new class by given field definition.

Internal use only.

Calls superclass method
# 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) click to toggle source

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() click to toggle source

symbols

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

Public Instance Methods

add_continuation(str) click to toggle source

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
continue?() click to toggle source

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
do_parse() click to toggle source

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
each_symbol() { |k, x, x| ... } click to toggle source

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_from_string(str) click to toggle source

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
inspect() click to toggle source

same as Struct#inspect.

Note that do_parse is automatically called before inspect.

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

Calls superclass method
# File lib/bio/db/pdb/pdb.rb, line 456
def inspect
  do_parse
  super
end
original_data() click to toggle source

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() click to toggle source

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
Also aliased as: record_type
record_type()

keeping compatibility with old version

Alias for: record_name