main page namespaces classes files
ELL home

src/ell/LT_Funnels.cc

Go to the documentation of this file.

#include "LT_Funnels.hh"

namespace ell
{

    LT_Funnels::LT_Funnels()
    {
    }
    
    LT_Funnels::~LT_Funnels()
    {
    }

    
    
    // Sets the saddle if (a) no saddle exists or (b) the old saddle is higher
    // than the new one.
    // NOTE: only a DIRECTED edge is checked from the higher to the lower 
    // minimum according to the State::less operator.
    // @param i index of the first minimum to connect
    // @param j index of the second minimum to connect
    // @param s the State representating the saddle point
    // @return whether or not the data structure has been changed
    virtual 
    bool 
    LT_Funnels::
	addSaddle(const size_t i, const size_t j, const State* const s);
    
    // Sets the saddle if (a) no saddle exists or (b) the old saddle is higher
    // than the new one.
    // NOTE: only a DIRECTED edge is checked from the higher to the lower 
    // minimum according to the State::less operator.
    // @param m_i the first minimum to connect
    // @param m_j the second minimum to connect
    // @param s the State representating the saddle point
    // @return whether or not the data structure has been changed
    virtual 
    bool 
    LT_Funnels::
	addSaddle(const State* const m_i, const State* const m_j, const State* const s);
    
    // Adds an UNKNOWN minimum to the topology.
    // NOTE : this operation should NOT change the indices of already existing
    //        minima in the topology !
    // FURTHER : the minimum is not checked if it is already known
    // @param m the minimum to add
    // @return the index of the minimum in the landscape
    virtual 
    const size_t 
    LT_Funnels::
	addMin(const State* const m);
    
    // Access to the minimum index.
    // @param m the minimum of that the index should be accessed
    // @return  the index of the minimum, or INVALID_INDEX if 'm' is no known 
    //          minimum
    virtual 
    const size_t 
    LT_Funnels::
	getMinIndex(const State* const m) const;
    
    // Access to the number of stored minima.
    // @return the number of minima
    virtual 
    const size_t 
    LT_Funnels::
	getMinCount() const;
    
    // Access to a minimum.
    // @param i index of the minimum to access
    // @return the State with the specified minimum index
    virtual 
    const State* const 
    LT_Funnels::
	getMin(size_t i) const;
    
    // Access to the global minimum of the landscape with minimal energy.
    // @return the minimum with smallest energy (and smallest string 
    //         representation for tiebreaking)
    virtual 
    const State* const 
    LT_Funnels::
	getMFEState() const;

    // Calculates the relative 'distance' between landscape topologies.
    // On the LandscapeTopology level it is done on the minima only. For each
    // minimum m present in only one of the two LTs a value of 
    // MISSING_MINIMUM_PENALTY*(e^(-energy(m)/BOLTZMANN_KT)) is summed. The 
    // resulting sum is normalized by the number of (unique) minima in both
    // topologies.
    // @param lt the landscape topology to calculate the distance to
    // @return the distance
    virtual 
    double 
    LT_Funnels::
	getDistance(const LandscapeTopology* const lt) const;
    
    // Sorts the minima ascending by their energy (mfe minimum gets index 0). 
    // If energy is equal they are sorted by their string representation.
    virtual 
    void 
    LT_Funnels::
	sort();

    // Check if the minima of the landscape are sorted ascendingly by their 
    // energy (mfe minimum gets index 0). 
    // If energy is equal they are sorted by their string representation.
    virtual 
    bool 
    LT_Funnels::
	isSorted() const;

    // Clears the data structure and removes all stored information to be 
    // filled again afterwards. 
    virtual 
    void 
    LT_Funnels::
	clear();

    // Writes the current landscape topology to stream.
    // @param out the output stream to write to.
    // @param writeGraph whether or not the output should contain a graph
    //        representation of the topology in graphviz DOT format
    virtual 
    void
    LT_Funnels::
	write( std::ostream & out, 
            const bool writeGraph = false ) const;

    // Fills the landscape topology from stream.
    // @param in the input stream to read from.
    // @param templateState the State template to create new State objects via
    //        its 'fromString' function
    // @return an error encoding and an error string :
    //          0 = no error occured, read was successfull
    //         -1 = landscape topology type not supported
    //         -2 = state description differs from the given one
    //         -3 = other read errors
    virtual 
    std::pair<int,std::string>
    LT_Funnels::
	read(  std::istream & in, 
            const State * const templateState );
    
    
} // namespace ell