anneal.h

Go to the documentation of this file.

 
#ifndef SI_GRAPH_ANNEALING_H
#define SI_GRAPH_ANNEALING_H
 
#include <string>
#include <vector>
#include <si/graph/clique.h>
 
class Vertex;
 
namespace sigraph
{
  class CGraph;
  class MGraph;
  class AnnealExtension;
  class SGProvider;

  struct EnergyField
  {
    EnergyField();
    EnergyField( const EnergyField & ef );

    std::vector<Vertex*>        vertices;
    std::vector<std::string>    labels;
    std::map<Clique*, double>   involvedCliques;
    double                      energy;
    double                      expEnergy;
    double                      probability;
    double                      probabilitySum;
  };
 
  //    inline
 
 
  inline EnergyField::EnergyField()
  {
  }
 
  inline EnergyField::EnergyField( const EnergyField & ef )
  {
    vertices = ef.vertices;
    labels = ef.labels;
    involvedCliques = ef.involvedCliques;
    energy = ef.energy;
    expEnergy = ef.expEnergy;
    probability = ef.probability;
    probabilitySum = ef.probabilitySum;
  }
 

  class Anneal
  {
  public:
    enum Mode
      {
        METROPOLIS, 
        GIBBS,
        ICM,
        MPM,
        SPECIAL,
      };
 
    enum IterType
      {
        VERTEX, 
        CLIQUE, 
        CUSTOM
      };
 
    enum VoidMode
      {
        VOIDMODE_NONE, 
        VOIDMODE_REGULAR, 
        VOIDMODE_STOCHASTIC
      };
 
    enum InitLabelsType
      {
        INITLABELS_NONE, 
        INITLABELS_VOID, 
        INITLABELS_RANDOM
      };
 
    Anneal( CGraph & cg, MGraph & rg );
    virtual ~Anneal();

    void init( Mode mode, double temp, double tmult, double tICM, 
               double stopProp, unsigned gibbsMaxTrans, bool verbose = true, 
               IterType itType = VERTEX, 
               InitLabelsType voidInitialLabels = INITLABELS_RANDOM, 
               const std::string & voidLabel = "", 
               std::ostream *plotStream = 0, 
               unsigned niterBelowStopProp = 1 );
    void setVoidMode( VoidMode mode, unsigned occurency = 0 );
    void deleteExtensions();
    void addExtension( AnnealExtension* ae, unsigned occurency = 20 );
    void clear();
    void reset();
    void checkStop();
    void fitStep();
    void fit();
    void stepMetropolis();
    void stepGibbs();
    void stepICM();
    void stepVoid();
    void processPotentials( const std::set<Vertex *> & vertices, 
                            std::vector<EnergyField> & en );
    double processAllPotentials();


    const CGraph & cGraph() const { return( _cgraph ); }
    CGraph & cGraph() { return( _cgraph ); }
    const MGraph & rGraph() const { return( _mgraph ); }
    MGraph & rGraph() { return( _mgraph ); }
    Mode modeI() const { return( _modeI ); }
    Mode mode() const { return( _mode ); }
    double tempI() const { return( _tempI ); }
    double temp() const { return( _temp ); }
    bool isFinished() const { return( _finished ); }
    double tMult() const { return( _tmult ); }
    double tICM() const { return( _tICM ); }
    double stopProp() const { return( _stopProp ); }
    unsigned nTrans() const { return( _ntrans ); }
    unsigned maxTrans() const { return( _maxtrans ); }
    unsigned gibbsMaxTrans() const { return( _gibbsMaxTrans ); }
    double deltaE() const { return( _deltaE ); }
    double stepDeltaE() const { return( _stepDeltaE ); }
    double initialEnergy() const { return( _initEnergy ); }
    double energy() const { return( _initEnergy + _deltaE ); }
    bool verbosity() const { return( _verbose ); }
    IterType iterType() const { return( _iterType ); }
    unsigned nIter() const { return( _niter ); }
    bool doubleDrawingLots() const { return( _doubleDrawingLots ); }
    void setDoubleDrawingLots( bool t ) { _doubleDrawingLots = t; }
    const std::string & voidLabel() const { return( _voidLabel ); }
    void setAllowThreads( bool );
    bool threadsAllowed() const;
    void setMaxIterations( unsigned n );
    unsigned maxIterations() const;
    unsigned MPMUnrecordedIterations() const;
    void setMPMUnrecordedIterations( unsigned n );
 
  protected:
    CGraph                                &_cgraph;
    MGraph                                &_mgraph;
    Mode                            _modeI;
    Mode                            _mode;
    double                              _tempI;
    double                              _temp;
    bool                                _finished;
    double                              _tmult;
    double                              _tICM;
    double                              _stopProp;
    unsigned                            _ntrans;
    unsigned                            _maxtrans;
    unsigned                            _gibbsMaxTrans;
    double                              _stepDeltaE;
    double                              _deltaE;
    double                              _initEnergy;
    bool                                _verbose;
    IterType                            _iterType;
    SGProvider                                *_sgProvider;
    unsigned                            _niter;
    std::ostream                        *_plotStream;
    InitLabelsType                        _initialLabelsType;
    std::string                         _voidLabel;
    VoidMode                            _voidmode;
    unsigned                            _voidoccurency;
    std::vector<AnnealExtension *>      _annealExtensions;
    unsigned                            _extensionPassOccurency;
    bool                                _doubleDrawingLots;
    unsigned                            _niterBelowStopProp;
    unsigned                            _currentNiterBelowStopProp;
 
  private:
    struct Private;
    Private     *d;

    void processNodes( const std::set<Vertex *> & ver, std::vector<EnergyField> & ef, 
                       bool* npos, unsigned first, unsigned nn, 
                       std::string* orLab );
    void processConfig( const std::set<Vertex *> & ver, 
                        std::vector<EnergyField> & ef, 
                        bool* npos, std::string* orLab );
  };
 
}
 
#endif