atom_algorithms.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) 2001, 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_ALGORITHMS_H
#define BTK_ATOM_ALGORITHMS_H


#include "atom.h"
#include "atom_predicates.h"
#include "linear_algebra.h"

#include <boost/concept_check.hpp>


namespace BTK {
  

template <bool SelectValue, typename AtomIterator>
void
set_atom_selection(AtomIterator first,
                   AtomIterator last)
{
  set_atom_selection<SelectValue>(first,last,is_any());
}

template <bool SelectValue, typename AtomIterator, typename UnaryPredicate>
void
set_atom_selection(AtomIterator first,
                   AtomIterator last,
       UnaryPredicate test)
{
  for(; first!= last; ++first){
    if( test( *first ) ) first->set_is_selected(SelectValue);
  }
}


template <typename AtomIterator>
void 
translate(AtomIterator first,
          AtomIterator last,
          const BTKVector& T);





template <typename AtomIterator>
void 
rotate(AtomIterator first,
       AtomIterator last,
       double phi,
       double theta,
       double psi,
       const BTKVector& fixed_point);


template <typename AtomIterator>
inline 
void 
rotate(AtomIterator first,
       AtomIterator last,
       double phi,
       double theta,
       double psi) 
{
  rotate(first,last,phi,theta,psi,
         center_of_mass(first,last));
}



template <typename AtomIterator>
void 
rotate(AtomIterator first,
       AtomIterator last,
       const BTKVector& axis,
       double theta,
       const BTKVector& fixed_point);



template <typename AtomIterator>
inline 
void 
rotate(AtomIterator first,
       AtomIterator last,
       const BTKVector& axis,
       double theta) 
{
  rotate(first,last,axis,theta,
         center_of_mass(first,last));
}


template <typename AtomIterator>
void 
rotate(AtomIterator first,
       AtomIterator last,
       const BTKMatrix& R);

template <typename AtomIterator>
void
transform(AtomIterator first,
          AtomIterator last,
          const BTKMatrix& R,
          const BTKVector& T);




template <typename AtomIterator>
BTKVector 
center_of_mass(AtomIterator first,
               AtomIterator last);

template <typename AtomIterator>
void 
center(AtomIterator first,
       AtomIterator last);

template <typename AtomIterator1,typename AtomIterator2>
void 
align_centers(AtomIterator1 fixed_first,
              AtomIterator1 fixed_last,
              AtomIterator2 align_first,
              AtomIterator2 align_last);

template <typename AtomIterator>
void 
principal_axes(AtomIterator first,
               AtomIterator last,
               std::vector<EigenState>& axes,
               BTKVector& COM);


template <typename AtomIterator1, typename AtomIterator2>
double 
get_trivial_rmsd(AtomIterator1 a1_first,
                 AtomIterator1 a1_last,
                 AtomIterator2 a2_first,
                 AtomIterator2 a2_last);




template <typename AtomIterator1, typename AtomIterator2>
double 
get_rmsd(AtomIterator1 a1_first,
         AtomIterator1 a1_last,
         AtomIterator2 a2_first,
         AtomIterator2 a2_last);


template <typename AtomIterator1, typename AtomIterator2>
void 
leastsquares_superposition(AtomIterator1 fixed_first,
                           AtomIterator1 fixed_last,
                           AtomIterator2 superimpose_first,
                           AtomIterator2 superimpose_last,
                           BTKMatrix& R,
                           BTKVector& T,
                           double& rmsd);

template <typename AtomIterator1, typename AtomIterator2, typename AtomIterator3>
void
leastsquares_superposition(AtomIterator1 fixed_first,
                           AtomIterator1 fixed_last, 
                           AtomIterator2 superimpose_first,
                           AtomIterator2 superimpose_last,
                           AtomIterator3 transform_first,
                           AtomIterator3 transform_last,
                           double& rmsd);




template <typename AtomType>
struct atom_rotator : public std::unary_function<AtomType&,void> {
  
  BOOST_CLASS_REQUIRE2(AtomType, Atom, boost, ConvertibleConcept);

  atom_rotator(BTKMatrix& R,
               BTKVector& T) 
    : _R(R), _T(T) {}

  void 
  operator()(AtomType& x)
  { 
    x.set_position(prec_prod(_R,x.position())+_T); 
  }

private:
  BTKMatrix _R;
  BTKVector _T;
};


} // namespace BTK

#include "atom_algorithms.hpp"

#endif

---