main page namespaces classes files
ELL home

src/ell/BarrierSampling.cc

Go to the documentation of this file.

#include "ell/BarrierSampling.hh"

namespace ell
{

    BarrierSampling::~BarrierSampling()
    {
    }

}  // namespace ell

#include "ell/StateCollector.hh"

namespace ell
{

    BS_DirectWalk::
	BS_DirectWalk( const DirectWalk* const dw_)
     :  dw(dw_)
    {
        assertbiu(dw!=NULL, "no direct walk given (==NULL)");
    }
    
    BS_DirectWalk::
	~BS_DirectWalk()
    {
    }
    
    size_t
    BS_DirectWalk::
	findBarriers(  LandscapeTopology* const lt
                    , MinimumSelector* const ms
                    , SamplingAbortionCriterion * const sac
                    )
    {
        assertbiu(lt!=NULL, "no landscape topology given (==NULL)");
        assertbiu(ms!=NULL, "no minimum selector given (==NULL)");
        assertbiu(sac!=NULL, "no sampling abortion criterion given (==NULL)");
        
        if (lt->getMinCount() < 2) {
            return 0;
        }
        
          // number of performed iterations
        size_t iterations = 0;
          // whether or not the lt was changed
        bool wasChanged = true;
        
          // indices of the minima to perform the walk between
        size_t m1 = ms->select(lt, false);
          // check if there are minima selectable by the minimum selector
        if (m1 == LandscapeTopology::INVALID_INDEX) {
            return 0;
        }
        size_t m2 = m1;
        
          // check if another iteration is to do
        while( !sac->abortSampling( lt, wasChanged ) ) {
            iterations++;
              // get two different minima via selector
            m1 = ms->select(lt, false);
            assertbiu(m1!=LandscapeTopology::INVALID_INDEX,
                    "no minimum m1 was selected");
            do {
                m2 = ms->select(lt, false);
            } while (m1 == m2);
            assertbiu(m2!=LandscapeTopology::INVALID_INDEX,
                    "no minimum m2 was selected");
              // perform direct walk using Morgan Higgs heuristic and store
              // the state with maximal energy along the walk
            SC_Maximum scMax;
            dw->walk(lt->getMin(m1), lt->getMin(m2), &scMax);
              // update lt and check if lt was changed
            wasChanged = lt->addSaddle(m1,m2,scMax.getMaximumState());
        }
        
        return iterations;
    }
    

}  // namespace ell

#include "ell/StateCollector.hh"

namespace ell
{

    BS_UpDown::
	BS_UpDown( const Walk* const up
                , const Walk* const down
                , const bool addNewMin )
     :  upWalk(up)
        , downWalk(down)
        , addNewMinima(addNewMin)
    {
        assertbiu(upWalk!=NULL, "no up walk given (==NULL)");
        assertbiu(downWalk!=NULL, "no down walk given (==NULL)");
    }
    
    BS_UpDown::
	~BS_UpDown()
    {
    }
    
    size_t
    BS_UpDown::
	findBarriers(  LandscapeTopology* const lt
                    , MinimumSelector* const ms
                    , SamplingAbortionCriterion * const sac
                    )
    {
        assertbiu(lt!=NULL, "no landscape topology given (==NULL)");
        assertbiu(ms!=NULL, "no minimum selector given (==NULL)");
        assertbiu(sac!=NULL, "no sampling abortion criterion given (==NULL)");
        
        if (lt->getMinCount() < 1 ) {
            return 0;
        }
        if (!addNewMinima && lt->getMinCount() < 2 ) {
            return 0;
        }
        
          // number of performed iterations
        size_t iterations = 0;
          // whether or not the lt was changed
        bool wasChanged = true;
          // whether or not the lt was changed
        bool minimaChanged = addNewMinima;
        
          // indices of the minima to perform the walk between
        size_t m1 = ms->select(lt, false);
          // check if there are minima selectable by the minimum selector
        if (m1 == LandscapeTopology::INVALID_INDEX) {
            return 0;
        }
        size_t m2 = m1;
        
        State * upWalkEnd = NULL;
        
          // check if another iteration is to do
        while( !sac->abortSampling( lt, wasChanged ) ) {
            iterations++;
              // get two different minima via selector
            m1 = ms->select(lt, minimaChanged);
            assertbiu(m1!=LandscapeTopology::INVALID_INDEX,
                    "no minimum m1 was selected");
              // perform up- and down-walk and store
              // the state with maximal energy along the walk
            SC_Maximum scMax;
            upWalk->walk( lt->getMin(m1), &scMax, NULL );
            assertbiu(scMax.getLastAdded() != NULL, "nothing was added to scMax");
            upWalkEnd = scMax.getLastAdded()->clone(upWalkEnd);
            downWalk->walk( upWalkEnd, &scMax, NULL );
              // check if final minimum unknown
            m2 = lt->getMinIndex(scMax.getLastAdded());
            if ( m2 == LandscapeTopology::INVALID_INDEX )
            {
                if (addNewMinima) {
                      // add new minimum
                    minimaChanged = true;
                    m2 = lt->addMin(scMax.getLastAdded());
                } else {
                      // go to next iteration
                    continue;
                }
            }
              // check if start and end minimum are different
            if (m1 != m2) {
                  // update lt and check if lt was changed
                wasChanged = lt->addSaddle(m1,m2,scMax.getMaximumState());
            } else {
                wasChanged = false;
            }
        }
        if (upWalkEnd != NULL) delete upWalkEnd;
        
        return iterations;
    }
    

}  // namespace ell