main page namespaces classes files
ELL home

src/ell/LandscapeTopology.hh

Go to the documentation of this file.

#ifndef LANDSCAPETOPOLOGY_HH_
#define LANDSCAPETOPOLOGY_HH_

#include "ell/State.hh"

#include <string>

 // check which map to use
#include "biu/HashMap.hh"


//##############################################################################
//##############################################################################

namespace ell {

class LandscapeTopology {

public:
    
#ifdef HAVE_GNU_HASH_MAP
    typedef __gnu_cxx::hash_map< int, size_t > Int2SizeT_MAP;
#else
    typedef std::map< int, size_t > Int2SizeT_MAP;
#endif
    
public:  
    
    static const size_t INVALID_INDEX;
    
    static const double AVOGADRO_CONSTANT_NA;
    static const double GAS_CONSTANT_R;
    static const double BOLTZMANN_CONSTANT_KB;
    
public:  
    
    static double BOLTZMANN_KT;
    
    static double MISSING_MINIMUM_PENALTY;
    
public:
    
    virtual 
    ~LandscapeTopology();
    
    virtual 
    bool 
    addSaddle(const size_t i, const size_t j, const State* const s) = 0;
    
    virtual 
    bool 
    addSaddle(const State* const m_i, const State* const m_j, const State* const s) = 0;
    
    virtual 
    const size_t 
    addMin(const State* const m) = 0;
    
    virtual 
    const size_t 
    getMinIndex(const State* const m) const = 0;
    
    virtual 
    const size_t 
    getMinCount() const = 0;
    
    virtual 
    const State* const 
    getMin(size_t i) const = 0;
    
    virtual 
    const State* const 
    getMFEState() const = 0;

    virtual 
    double 
    getDistance(const LandscapeTopology* const lt) const;
    
    virtual 
    void 
    sort() = 0;

    virtual 
    bool 
    isSorted() const = 0;

    virtual 
    void 
    clear() = 0;

    virtual 
    void
    write(  std::ostream & out, 
            const bool writeGraph = false ) const = 0;

    virtual 
    std::pair<int,std::string>
    read(   std::istream & in, 
            const State * const templateState ) = 0;

    
    
    
    
    
    static
    void
    writeHeader(    std::ostream & out, 
                    const std::string& LT_ID,
                    const size_t minNumber,
                    const std::string & StateDescription );
    
    static
    void
    writeMinimum(   std::ostream & out, 
                    const State* const minimum,
                    const size_t index );

    static
    void
    writeMinimum(   std::ostream & out, 
                    const std::vector<const State*> & minima,
                    const size_t index );

    static
    void
    writeBarrier(   std::ostream & out, 
                    const State* const barrier,
                    const size_t index,
                    const std::vector<size_t> & minConnected );
    
    
    static
    void
    writeSaddle(    std::ostream & out, 
                    const State* const saddle,
                    const size_t index,
                    const std::vector<size_t> & minConnected );
    
    static
    std::pair<int,std::string>
    parseHeader(    const std::string & line, 
                    std::string& LT_ID,
                    size_t& minNumber,
                    std::string & StateDescription );

    static
    std::pair<int,std::string>
    parseMinimum(   LandscapeTopology & toFill,
                    const std::string & line, 
                    const State * const templateState,
                    Int2SizeT_MAP & idx2min );
    
    
    static
    std::pair<int,std::string>
    parseBarrier(   LandscapeTopology & toFill,
                    const std::string & line, 
                    const State * const templateState,
                    const Int2SizeT_MAP & idx2min );

    
    static
    std::pair<int,std::string>
    parseSaddle(    LandscapeTopology & toFill,
                    const std::string & line, 
                    const State * const templateState,
                    const Int2SizeT_MAP & idx2min );

protected:  
    
    static
    double 
    getSortedMinimaDistance(    const std::vector<const State*> & m1,
                                const std::vector<const State*> & m2 );
    
    
    static const std::string OUTPUT_KEY_ELL_HEAD;
    static const std::string OUTPUT_KEY_MINIMUM;
    static const std::string OUTPUT_KEY_BARRIER;
    static const std::string OUTPUT_KEY_SADDLE;
    
    static
    void
    writeConnection(    std::ostream & out, 
                        const State* const connectionState,
                        const size_t index,
                        const std::vector<size_t> & minConnected,
                        const std::string& connectionKey  );
    
    static
    std::pair< State*, std::string>
    parseConnection(    const std::string & line, 
                        const State * const templateState,
                        const Int2SizeT_MAP & idx2min,
                        const std::string& connectionKey,
                        std::vector<size_t> & connectedMinima );
    
};

//##############################################################################
//##############################################################################



}// ell


#endif /*LANDSCAPETOPOLOGY_HH_*/