coord_frame.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2011 by the OpenStructure authors
//
// This library 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 3.0 of the License, or (at your option)
// any later version.
// This library 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 library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------
#ifndef OST_MOL_COORD_FRAME_HH
#define OST_MOL_COORD_FRAME_HH

/*
  Authors: Marco Biasini, Niklaus Johner, Ansgar Philippsen
 */
#include <boost/shared_ptr.hpp>
#include <ost/geom/geom.hh>
#include <ost/mol/module_config.hh>
#include <ost/mol/entity_view.hh>
#include "atom_handle.hh"

namespace ost { namespace mol {

/*
  TODO: 
  - move algorithmic code to separate functions in mol/alg
  - clean up mix of views and atom indices methods/functions
  - use existing UnitCell class
*/

class DLLEXPORT_OST_MOL CoordFrame : public geom::Vec3List{
private:
  geom::Vec3 ucell_size_;
  geom::Vec3 ucell_angles_;
public:
  typedef geom::Vec3List base_type;
  
  CoordFrame() : base_type() {}
  CoordFrame(size_t size, const geom::Vec3& value=geom::Vec3()) : base_type(size, value) {}
  CoordFrame(base_type::iterator b, base_type::iterator e): base_type(b, e) { }
  CoordFrame(const base_type& rhs) : base_type(rhs) { }
  CoordFrame(const std::vector<geom::Vec3>& rhs) : base_type(rhs) { }
  CoordFrame(const std::vector<geom::Vec3>& rhs,
             const geom::Vec3 box_size, 
             const geom::Vec3 box_angles) : base_type(rhs) {
    ucell_size_=box_size;
    ucell_angles_=box_angles;
  }

  void SetCellSize(const geom::Vec3& s) {
    ucell_size_=s;
  }

  geom::Vec3 GetCellSize() const {
    return this->ucell_size_;
  }

  void SetCellAngles(const geom::Vec3& a) {
    ucell_angles_=a;
  }

  geom::Vec3 GetCellAngles() const {
    return this->ucell_angles_;
  }

  geom::Vec3 GetAtomPos(const AtomHandle& atom) const;
  geom::Vec3 GetAtomPos(int atom_index) const;
  Real GetDistanceBetwAtoms(const AtomHandle& a1, const AtomHandle& a2) const;
  Real GetDistanceBetwAtoms(int atom1_index, int atom2_index) const;

  Real GetAngle(const AtomHandle& a1, const AtomHandle& a2, const AtomHandle& a3) const;

  Real GetAngle(int atom1_index, int atom2_index, int atom3_index) const;  

  Real GetDihedralAngle(const AtomHandle& a1, const AtomHandle& a2, const AtomHandle& a3, const AtomHandle& a4) const;

  Real GetDihedralAngle(int a1_index, int a2_index, int a3_index, int a4_index) const; 

  geom::Vec3 GetCenterOfMassPos(const mol::EntityView& sele) const;


  geom::Vec3 GetCenterOfMassPos(std::vector<unsigned long>& indices, 
                                std::vector<Real>& masses) const;

  Real GetDistanceBetwCenterOfMass(const mol::EntityView& sele1, const mol::EntityView& sele2) const;

  Real GetDistanceBetwCenterOfMass(std::vector<unsigned long>& indices1, std::vector<Real>& masses1, 
                                   std::vector<unsigned long>& indices2, std::vector<Real>& masses2) const;

  Real GetRMSD(const std::vector<geom::Vec3>& ref_pos, 
               const std::vector<unsigned long>& indices_sele) const;
  
  Real GetRMSD(const mol::EntityView& reference_view,
               const mol::EntityView& sele_view) const;


  Real GetMinDistance(std::vector<unsigned long>& index_list1, 
                      std::vector<unsigned long>& index_list2) const;

  Real GetMinDistance(const mol::EntityView& view1, const mol::EntityView& view2) const;

  Real GetMinDistBetwCenterOfMassAndView(std::vector<unsigned long>& indices_cm,
                                         std::vector<Real>& masses_cm,
                                         std::vector<unsigned long>& indices_atoms) const;
  Real GetMinDistBetwCenterOfMassAndView(const mol::EntityView& view_cm,
                                         const mol::EntityView& view_atoms) const;

  geom::Line3 GetODRLine(std::vector<unsigned long>& indices_ca) const;

  geom::Plane GetODRPlane(std::vector<unsigned long>& indices_ca) const;

  geom::Line3 GetODRLine(const mol::EntityView& view1) const;
  geom::Plane GetODRPlane(const mol::EntityView& view1) const;

  geom::Line3 FitCylinder(std::vector<unsigned long>& indices_ca) const;

  geom::Line3 FitCylinder(const mol::EntityView& view1) const;

  Real GetAlphaHelixContent(std::vector<unsigned long>& indices_ca, 
                            std::vector<unsigned long>& indices_c,
                            std::vector<unsigned long>& indices_o,
                            std::vector<unsigned long>& indices_n) const;

  Real GetAlphaHelixContent(const mol::EntityView& segment) const;
};

  typedef boost::shared_ptr<CoordFrame> CoordFramePtr;
  typedef std::vector<CoordFramePtr> CoordFrameList;

  // factory method
  // create a frame from a Vec3List containing the positions of the atoms, optionally with unit cell
  // TODO: why is this necessary? the ctor works fine 
  DLLEXPORT_OST_MOL CoordFrame CreateCoordFrame(const geom::Vec3List& atom_pos, 
                                                const geom::Vec3& cell_size=geom::Vec3(),
                                                const geom::Vec3& cell_angles=geom::Vec3());

  // these should really be either in the entity view interface or in mol/alg

  void GetIndices(const EntityView& sele, std::vector<unsigned long>& indices);

  void GetMasses(const EntityView& sele, std::vector<Real>& masses);

  void GetIndicesAndMasses(const EntityView& sele,
                           std::vector<unsigned long>& indices,
                           std::vector<Real>& masses);

  void GetPositions(const EntityView& sele, std::vector<geom::Vec3>& ref_pos);

  void GetCaIndices(const EntityView& segment, std::vector<unsigned long>& indices_ca);

  void GetCaCONIndices(const EntityView& segment, 
                       std::vector<unsigned long>& indices_ca, 
                       std::vector<unsigned long>& indices_c,
                       std::vector<unsigned long>& indices_o, 
                       std::vector<unsigned long>& indices_n);


}}

#endif