buildable_monomer_family_pattern.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) 2004, Christopher Saunders <ctsa@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.
//

// singleton static data class -
// abstract base to singleton data classes defining 
//  family patterns for peptide and nucleotide types
//

#ifndef BTK_BUILDABLE_MONOMER_FAMILY_PATTERN_H
#define BTK_BUILDABLE_MONOMER_FAMILY_PATTERN_H


#include "atom_group_concept.h"
#include "atom_index_tetrad.h"
#include "atom_index_pair.h"
#include "atom_types.h"
#include "group_types.h"
#include "group_variant_types.h"
#include "torsion_types.h"

#include <boost/optional.hpp>
#include <boost/tuple/tuple.hpp>

#include <cassert>

#include <map>
#include <set>
#include <utility>
#include <vector>

namespace BTK{


  class BuildableMonomerFamilyPattern {
    typedef BuildableMonomerFamilyPattern self_type;
  public:
    typedef self_type types;
    typedef std::pair<int,ATOM::index_t> monomer_atom_idx_t;

    typedef AtomIndexPair bond_t;

    typedef AtomIndexTetrad tetrad_t;

    typedef std::set<ATOM::index_t> atom_container_t;
    typedef std::set<bond_t> bond_container_t;
    typedef std::set<tetrad_t> tetrad_container_t;
 
    typedef boost::tuple<monomer_atom_idx_t,monomer_atom_idx_t,
                         monomer_atom_idx_t,monomer_atom_idx_t> torsion_atom_t;

  protected:
    typedef std::map<monomer_atom_idx_t,tetrad_container_t> tetrad_map_t;
    
    typedef std::map<TORSION::index_t,torsion_atom_t> torsion_atom_map_t;

    struct member_pattern_t {
      atom_container_t _atoms;
      bond_container_t _bonds;
      tetrad_map_t _tetrads;
    };

    struct member_modifier_t {
      member_pattern_t _add;
      member_pattern_t _delete;
    };

    typedef std::map<GROUP_VARIANT::index_t,member_modifier_t> member_modifier_map_t;

    struct modifiable_member_pattern_t {
      member_pattern_t _default;
      member_modifier_map_t _modifiers;

      // torsion atoms are not eligible for modification (implementable -- but what would the
      // appication be??)
      torsion_atom_map_t _torsion_atoms;
    };

    
    typedef std::map<GROUP::index_t,modifiable_member_pattern_t> member_map_t;

//    typedef std::map<GROUP::index_t,member_pattern_t> member_map_t;

    struct family_pattern_t { 
      member_map_t _member_map;
    };

  public:    
    // changing the family_pattern class over to functional access --
    // temporarily making the whole scheme much less efficient while
    // the variant scheme is being worked out, (now we pass out copies
    // of the data instead of const refs... yuk!!)
    //
    
    atom_container_t 
    atoms(GROUP::index_t g,
          AtomGroupConcept::group_variant_container_t v) const 
    {
      return get_modified_data<atom_container_t>(g,v,get_atoms());
    }
    
    bond_container_t 
    bonds(GROUP::index_t g,
    AtomGroupConcept::group_variant_container_t v) const
    {
      return get_modified_data<bond_container_t>(g,v,get_bonds());
    }

    tetrad_container_t
    tetrads(GROUP::index_t g,
      AtomGroupConcept::group_variant_container_t v,
            monomer_atom_idx_t ma) const
    {
      return get_modified_data<tetrad_container_t>(g,v,get_tetrads(ma));
    }

    // torsion atoms are not subject to the group variant scheme...
    torsion_atom_t
    torsion_atoms(GROUP::index_t g,
                  TORSION::index_t t) const
    {
      torsion_atom_map_t::const_iterator ci = member(g)._torsion_atoms.find(t);
      if(ci == member(g)._torsion_atoms.end()) { assert(0); }
      return ci->second;
    }

  protected:
    virtual family_pattern_t& family_pattern() = 0;
    virtual const family_pattern_t& family_pattern() const = 0;

    //
    // This method is being used instead of writing the tetrad info
    // directly in the family pattern constructor to get around a gcc
    // optimization behaviour that causes *very* high compile time and
    // memory usage when the tetrad code pattern below is specified
    // directly in the code for each tetrad.
    //
    // This is defined separately from the class definition to
    // prevent inlining. If this function is inlined the usual gcc
    // optimization problems occur.
    //
    void
    tetrad_helper(GROUP::index_t g,
                  int i1,
                  ATOM::index_t a1,
                  int i2,
                  ATOM::index_t a2,
                  int i3,
                  ATOM::index_t a3,
                  int i4,
                  ATOM::index_t a4,
                  double l,
                  double a,
                  double d,
                  bool r);
  private:

    struct get_atoms {
      atom_container_t
      operator()(const member_pattern_t& t)
      {
        return t._atoms;
      }
    };
   
    struct get_bonds {
      bond_container_t
      operator()(const member_pattern_t& t)
      {
        return t._bonds;
      }
    };

    struct get_tetrads {
      get_tetrads(monomer_atom_idx_t ma) : _ma(ma) {}

      tetrad_container_t
      operator()(const member_pattern_t& t)
      {
        const tetrad_map_t& tm = t._tetrads;
        tetrad_map_t::const_iterator tmi = tm.find(_ma);

        // we expect calls to tetrad for atomtypes with no tetrads, this
        // should not be treated as an error
        //
        if( tmi == tm.end() ) 
          return tetrad_container_t();
        else 
          return tmi->second;
      }

    private:
      monomer_atom_idx_t _ma;
    };
   

    // accepts one of the get_ function objects above, together with
    // the modifier set, to produce the appropriate modified container
    // 
    template <typename SetContainer,typename UnaryFunction>
    SetContainer
    get_modified_data(GROUP::index_t g,
                      AtomGroupConcept::group_variant_container_t v,
                      UnaryFunction get_func) const 
    {
      SetContainer c = get_func(member(g)._default);

      typedef AtomGroupConcept::group_variant_container_t::const_iterator vci;
      vci i=v.begin(),i_end=v.end();

      // add variant additions and delete variant subtractions
      //
      for(;i!=i_end;++i){
        member_modifier_map_t::const_iterator mm = member(g)._modifiers.find(*i);
        if( mm == member(g)._modifiers.end() ) continue;

        const SetContainer& tmp_add = get_func(mm->second._add);
        c.insert(tmp_add.begin(),tmp_add.end());
        
        const SetContainer& tmp_delete = get_func(mm->second._delete);
        typename SetContainer::const_iterator si=tmp_delete.begin(),si_end=tmp_delete.end();
        for(;si!=si_end;++si){
          c.erase(*si);
        }
      }
      return c;
    }


    const modifiable_member_pattern_t& 
    member(GROUP::index_t g) const 
    {
      member_map_t::const_iterator ci = family_pattern()._member_map.find(g);
      if( ci == family_pattern()._member_map.end() ) { assert(0); }
      return ci->second;
    }

  };
} // namespace BTK



#endif

---