main page namespaces classes files
ELL home

src/ell/protein/S_LP.cc

Go to the documentation of this file.

#include "ell/protein/S_LP.hh"
#include "biu/RandomNumberFactory.hh"
#include <cmath>    // for getFitness()


namespace ell
{

// TODO maybe better to replace pointer copy with real clone to avoid dependency to external data
// inconsistency to copy construction 
S_LP::S_LP(biu::LatticeProtein_I* _latProt, biu::LatticeMoveSet* _moveSet)
    : latProt(_latProt), moveSet(_moveSet)
    {}

S_LP::S_LP(const S_LP& state)
    : latProt(state.latProt->clone()), moveSet(state.moveSet->clone())
    {}
    
S_LP::~S_LP() {
    if (latProt!=NULL) delete latProt;
    if (moveSet!=NULL) delete moveSet;
}

double  
S_LP::getEnergy(void) const {
    assertbiu(latProt != NULL, "no lattice protein available (NULL)");
    return latProt->getEnergy();
}

std::string 
S_LP::toString() const {
    assertbiu(latProt != NULL, "no lattice protein available (NULL)");
    return latProt->getStringRepresentation();
}

/* Fills the given string with a specific std::string 
 * representation of this State.
 * @param toFill the string to overwrite
 * @return the changed toFill in parameter
 */
std::string& 
S_LP::toString( std::string & toFill ) const
{
     // can be improved
    toFill = latProt->getStringRepresentation();
    return toFill;
}


bool    
S_LP::operator== (const State& state2) const {
    if ((const State*)latProt == &state2) 
        return true;
    const S_LP* s2 = dynamic_cast<const S_LP*>(&state2);
    if (s2 != NULL)
        return  *latProt == *(s2->latProt);
    return false;
}

bool
S_LP::operator!= (const State& state2) const {
    return !(*this == state2);
}

bool 
S_LP::operator< (const State& lp2) const
{
    if (this == &lp2) {
        return false;
    }
    const S_LP* s2 = dynamic_cast<const S_LP*>(&lp2);
    assertbiu(s2!=NULL, "lp2 is no S_LP object");
    assertbiu(this->latProt->getLength() == s2->latProt->getLength()
                ,"the two S_LP objects differ in length");
    if (this->getEnergy() < s2->getEnergy())
        return true;
    if ( this->getEnergy() == s2->getEnergy() ) {
        biu::MoveSequence m1 = this->latProt->getMoveSeqAbs();
        biu::MoveSequence m2 = this->latProt->getMoveSeqAbs();
        return std::lexicographical_compare(    m1.begin(), m1.end()
                                                , m2.begin(), m2.end() );
    }
    return false;
}

State::NeighborListPtr 
S_LP::getNeighborList() const {
    return NeighborListPtr(new SuccessiveNeighborList(this));
}

State::NeighborListPtr 
S_LP::getRandomNeighborList() const {
    return NeighborListPtr(new RandomNeighborList(this));
}

State* S_LP::getRandomNeighbor(State* inPlaceNeigh) const {
    S_LP* s;
    // get state to work on
    if (inPlaceNeigh==NULL) {
        s = dynamic_cast<S_LP*>(this->clone());
        inPlaceNeigh = s;
    }
    else {
        s = dynamic_cast<S_LP*>(inPlaceNeigh);
        assertbiu(s != NULL, "given state is no S_LP");
        *(s->latProt) = *(this->latProt); // copy 
        *(s->moveSet) = *(this->moveSet); // copy 
    }
    
    // get random move index
    size_t index = biu::RNF::getRN(s->moveSet->getMoveNumber(s->latProt));
    if (s->moveSet->applyMoveInPlace(s->latProt, index) == NULL) {
        delete s;
        s = NULL;
    }
    
    return s;
}

size_t 
S_LP::getNeighborNumber(void) const {
    assertbiu(moveSet != NULL, "no moveset available");
    return moveSet->getMoveNumber(latProt);
}

State* 
S_LP::getNeighbor(const size_t index, State* neigh) const {
    assertbiu(moveSet != NULL, "no moveset available");
    assertbiu(index < moveSet->getMoveNumber(latProt), "index out of range");

    S_LP* s;
    if (neigh == NULL) {
         s = dynamic_cast<S_LP*>(this->clone());    // create copy
         neigh = s;
    } else {
        s = dynamic_cast<S_LP*>(neigh);                         // use neigh
        assertbiu( s!=NULL, "neigh is no S_LP*");
        *(s->latProt) = *(this->latProt); // copy 
        *(s->moveSet) = *(this->moveSet); // copy 
    }
    
    if (s->moveSet->applyMoveInPlace(s->latProt, index) == NULL) {
        delete s;
        s = NULL;
    }
    return s;
}

State* 
S_LP::undoNeighborChange(const size_t index, State* const neigh) const {
    
    if (neigh == NULL) {
        return neigh;
    } else {
        S_LP* s = dynamic_cast<S_LP*>(neigh);
        assertbiu( s!=NULL, "neigh is no S_LP*");
        if (*neigh != *this)
            s->moveSet->undoLastMove(s->latProt);
        return s;
    }
}

State* 
S_LP::applyNeighborChange(const size_t index, State* const copy) const {
    assertbiu(index < moveSet->getMoveNumber(latProt), "index out of range");
    assertbiu(copy != NULL, "no state to fill given");

    S_LP* c = dynamic_cast<S_LP*>(copy);
    assertbiu( c!=NULL || copy == NULL, "given copy is no S_LP*");
    if (c==NULL) {
        return c;
    } else {
        *(c->latProt) = *(this->latProt); // copy 
        *(c->moveSet) = *(this->moveSet); // copy 
    }
    if (c->moveSet->applyMoveInPlace(c->latProt, index) == NULL) {
        return NULL;
    }
    return c;
}

} // namespace ell