polymer.hpp

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.

#include "pdb_atom.h"

#include <boost/concept_check.hpp>

#include <iostream>
#include <iterator>

template <typename MonomerType>
BTK::Polymer<MonomerType>::
Polymer(size_type s,
        build_strategy_t build_strategy) 
  : base_type(s), 
    _molecule(),
    _build_strategy(build_strategy)
{
  sync_molecule_to_monomers();
  if( _build_strategy) _build_strategy(atom_begin(),atom_end());
}

template <typename MonomerType>
template <typename AtomIterator>
BTK::Polymer<MonomerType>::
Polymer(AtomIterator first,
        AtomIterator last,
        build_strategy_t build_strategy) 
  : base_type(), 
    _molecule(),
    _build_strategy(build_strategy)
{
  create_monomers(first,last);
  sync_molecule_to_monomers();
  if(_build_strategy) _build_strategy(atom_begin(),atom_end());
}

// for now the build-strategy doesn't copy until I figure out how
// to make the cross atom case work
//
template <typename MonomerType>
BTK::Polymer<MonomerType>::
Polymer(const self_type& source) 
  : base_type(source), 
    _molecule(),
    _build_strategy(0)
  // _build_strategy(source.build_strategy()) 
{
  _molecule.set_chain_id(source.chain_id());
  _molecule.set_name(source.name());
  sync_molecule_to_monomers();
}

template <typename MonomerType>
template <typename T2>
BTK::Polymer<MonomerType>::
Polymer(const Polymer<T2>& source) 
  : base_type(source), 
    _molecule(),
    _build_strategy(0)
    // _build_strategy(source.build_strategy())
{
  _molecule.set_chain_id(source.chain_id());
  _molecule.set_name(source.name());
  sync_molecule_to_monomers();
}


template <typename MonomerType>
typename BTK::Polymer<MonomerType>::self_type&
BTK::Polymer<MonomerType>::
operator=(const self_type& rhs)
{
  if (&rhs == this) return *this;
  base_type::operator=(rhs);
  set_chain_id(rhs.chain_id());
  set_name(rhs.name());
  _build_strategy=0;
  //_build_strategy=rhs.build_strategy();
  sync_molecule_to_monomers();  
  return *this;
}

template <typename MonomerType>
template <typename T2>
typename BTK::Polymer<MonomerType>::self_type&
BTK::Polymer<MonomerType>::
operator=(const Polymer<T2>& rhs)
{
  base_type::operator=(rhs);
  set_chain_id(rhs.chain_id());
  set_name(rhs.name());
  _build_strategy=0;
  //  _build_strategy=rhs.build_strategy();
  sync_molecule_to_monomers();  
  return *this;
}

template <typename MonomerType>
void
BTK::Polymer<MonomerType>::
sync_molecule_to_monomers()
{
  _molecule.clear();
  const_iterator m=this->monomer_begin(),m_end=this->monomer_end();
  for(;m!=m_end;++m){
    _molecule.shallow_insert(atom_end(),m->atom_begin(),m->atom_end());
  }
}


template <typename MonomerType>
template <typename AtomIterator>
void
BTK::Polymer<MonomerType>::
add_monomer(AtomIterator first,
            AtomIterator last,
            const AtomGroupConcept::group_variant_container_t& modifiers)
{
  // iterator requirements: InputIterator
  monomer_type* m_ptr = 0;
  if(this->monomer_end()!= this->monomer_begin()) {
    m_ptr = &(back());
  }
  shallow_push_back(new monomer_type(first,last,m_ptr,0,modifiers));
}

template <typename MonomerType>
template <typename AtomIterator>
void
BTK::Polymer<MonomerType>::
create_monomers(AtomIterator first,
                AtomIterator last)
{
  // iterator requirements: InputIterator
  typedef typename std::iterator_traits<AtomIterator>::value_type InputT;
  boost::function_requires<boost::ConvertibleConcept<InputT,PDBAtom> >();

  // until a more complete modifier system is in place, start with
  // empty sets here and shove the NTERM and CTERM in
  //

  AtomIterator group_begin = first;
  int current_group_num = first->group_num();
  AtomGroupConcept::group_variant_container_t current_group_modifier;
  current_group_modifier.insert(GROUP_VARIANT::NTER);
  
  // group atoms into monomers by group number
  //
  for (;first!=last;++first) {
    if (first->group_num() != current_group_num) {
      add_monomer(group_begin,first,current_group_modifier);
      current_group_modifier.clear();
      group_begin = first;
      current_group_num = first->group_num();
    }
  }

  // add the last monomer
  if (group_begin != first) { 
    current_group_modifier.insert(GROUP_VARIANT::CTER);
    add_monomer(group_begin,first,current_group_modifier);
  }
}

template <typename MonomerType>
std::ostream& operator<<(std::ostream& os,
                         const BTK::Polymer<MonomerType>& p)
{
  unsigned atom = 1;
  typedef typename BTK::Polymer<MonomerType>::const_atom_iterator citer;
  citer i=p.atom_begin(),i_end=p.atom_end();
  for (;i!=i_end;++i) {
    i->print_pdb_line(atom++,p.chain_id(),os);
  }  
  os << "TER\n";
  
  return os;
}

---