DNAMutator.h

Go to the documentation of this file.

/*
 * File: BALL/STRUCTURE/DNAMutator.h
 * Created: 23.10.2008
 *
 * Author: Daniel Stoeckel
 */

#ifndef DNAMUTATOR_H
#define DNAMUTATOR_H

#include <BALL/COMMON/exception.h>
#include <BALL/MATHS/vector3.h>

namespace BALL
{
  class FragmentDB;
  class EnergyMinimizer;
  class ForceField;
  class Fragment;
  class AtomContainer;
  class Atom;

  class BALL_EXPORT DNAMutator
  {
    public:
      enum Base { ADENINE = 0, THYMINE = 1, GUANINE = 2, CYTOSINE = 3, URACILE = 4 };

      DNAMutator(EnergyMinimizer* mini = NULL, ForceField* ff = NULL, FragmentDB* frag = NULL);

      ~DNAMutator();

      void setup();

      void mutate(Fragment* res, Base base) throw(Exception::InvalidOption);

      /*
       * Set the current minimizer to mini. Passing NULL will disable
       * minimization.
       */
      void setMinimizer(EnergyMinimizer* mini);

      /*
       * Set a new FragmentDB instance that shall be used to obtain
       * the new bases. If NULL is passed, a default instance will be automatically
       * created when calling DNAMutator::mutate().
       */
      void setFragmentDB(FragmentDB* frag);

      /*
       * Set a new ForceField instance that is used in conjunction with the minimizer to
       * refine the structure. Even if no minimizer has been passed this force field will
       * be used to calculate the most favourable rotation of the base using a simple heuristic.
       * If you do not want this behaviour pass NULL.
       */
      void setForceField(ForceField* ff);

      /*
       * Controlls maximum number of steps to be used when
       * refining the generated structure via a minimizer.
       */
      void setMaxOptimizationSteps(Size steps);

      /*
       * The DNAMutator internally uses the unnamed property mechanism of the Atoms.
       * This defaults to property Atom::NUMBER_OF_PROPERTIES. If you already use this
       * property in your code you can set another property by passing it to this function.
       */
      void setUsedProperty(Property p);

    private:
      bool keep_db_;
      bool keep_ff_;

      FragmentDB* db_;
      ForceField* ff_;
      EnergyMinimizer* minimizer_;

      Size num_steps_;
      Property prop_;

      void freeDB_();
      void freeFF_();

      void mark_(AtomContainer* atoms);
      void unmark_(AtomContainer* atoms);

      void tryFlip_(Fragment* res, const Vector3& connect_atom, const Vector3& axis) const;

      bool optimize_(Fragment* frag);

      Atom* getAttachmentAtom(AtomContainer* res);

      Atom* markBaseAtoms(AtomContainer* res);

      void rotateBases(AtomContainer* from, const Atom* from_at, const Atom* to_at,
                       const Vector3& from_connection, const Vector3& to_connection);
      void rotateSameBases(AtomContainer* from, AtomContainer* to);

      const Atom* getSecondNitro(const std::vector<const Atom*>& ring_atoms, const Atom* base);

      Vector3 getNormalVector(const Atom* at);
      Atom* getConnectionAtom(Atom* at);
      Vector3 getOrthogonalVector(const Vector3& n, const Atom* base, const Atom* at);

      bool isPurine(const Atom& baseNitrogen) const;
      bool isPyrimidine(const Atom& baseNitrogen) const;

      static const char* bases_[];
      static const Size default_num_steps_;
  };
}

#endif