atom.h

Go to the documentation of this file.

// -*- mode: c++; -*-
//
//The Biomolecule Toolkit (BTK) is a C++ library for use in the
//modeling, analysis, and design of biological macromolecules.
//Copyright (C) 2003, Tim Robertson (kid50@users.sourceforge.net)
//
//This program is free software; you can redistribute it and/or modify
//it under the terms of the GNU Lesser General Public License as published
//by the Free Software Foundation; either version 2.1 of the License, or (at
//your option) any later version.
//
//This program is distributed in the hope that it will be useful,  but
//WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//Lesser General Public License for more details. 
//
//You should have received a copy of the GNU Lesser General Public License 
//along with this program; if not, write to the Free Software Foundation, 
//Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


#ifndef BTK_ATOM_H
#define BTK_ATOM_H

#include "atom_group_concept.h"
#include "atom_types.h"
#include "element_types.h"
#include "group_types.h"
#include "linear_algebra.h"  

#include <iosfwd>
#include <string>


namespace BTK {

  class Atom {
    typedef Atom self_type;
    typedef AtomGroupConcept group_type;
  public:
    Atom(ATOM::index_t index = ATOM::UNKNOWN, 
         ELEMENT::index_t element = ELEMENT::UNKNOWN,
         group_type * group = 0) :
      _atom_index(index), _element(element), 
      _group(group), _pos(new_vector()),
      _is_selected(false) {}

    Atom(BTKVector const & pos,
         ATOM::index_t index = ATOM::UNKNOWN, 
         ELEMENT::index_t element = ELEMENT::UNKNOWN,
         group_type * group = 0) :
      _atom_index(index), _element(element), 
      _group(group), _pos(pos),
      _is_selected(false) {}

    Atom(double X, double Y, double Z,
         ATOM::index_t index = ATOM::UNKNOWN, 
         ELEMENT::index_t element = ELEMENT::UNKNOWN,
         group_type * group = 0) :
      _atom_index(index), _element(element), 
      _group(group), _pos(new_vector(X,Y,Z)),
      _is_selected(false) {}
         
    virtual ~Atom() {};

    ATOM::index_t atom_index() const { return _atom_index; }

    void set_atom_index(ATOM::index_t x) { 
      _atom_index = x; 
      set_element(ATOM::atom_index_to_element_index(_atom_index));
    }

    virtual const std::string& atom_name() const {
      return ATOM::atom_index_to_pdbname(atom_index());
    }

    ELEMENT::index_t element() const {return _element;}

    void set_element(ELEMENT::index_t element) { 
      _element = element;
    }

    std::string element_name() const { return ELEMENT::name(element()); };

    virtual int group_num() const {
      if(_group){
        return _group->group_num();
      } else {
        return 0;
      }
    }

    virtual const std::string& group_name3() const {
      static std::string s("XXX");
      if(_group){
        return _group->group_name3();
      } else {
        return s;
      }
    }

    GROUP::index_t group_index() const { 
      if(_group) {
        return _group->group_index();
      } else {
        return GROUP::UNKNOWN;
      } 
    }

    void set_group(group_type& a) { _group = &a; }

    const BTKVector& position() const {return _pos;}
    void set_position(const BTKVector& position) {_pos = position;}

    void print_pdb_line(int atom_num,
                        char chain_id, 
                        std::ostream& os) const;

    bool is_selected() const { return _is_selected; }
    void set_is_selected(const bool is_selected) { _is_selected = is_selected; }

  private:
    ATOM::index_t _atom_index;
    ELEMENT::index_t _element;
    group_type* _group; 
    BTKVector _pos;

    bool _is_selected;
  };
  
  // This eliminates hiding of class with a function 
  typedef class Atom Atom;


  void print_pdb_atom_line(int atom_num,
                           const std::string& atom_name,
                           const std::string& res_name,
                           char chain_id,
                           int res_num,
                           const BTKVector& pos,
                           std::ostream& os); 

  
  inline void Atom::print_pdb_line(int atom_num,
                                   char chain_id, 
                                   std::ostream& os) const {
    print_pdb_atom_line(atom_num,atom_name(),group_name3(),chain_id,group_num(),position(),os);
  }

  std::ostream& operator<<(std::ostream& os, 
                           const BTK::Atom& a);

} // namespace BTK


#endif

---