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
{

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();
}

int 
S_LP::getFitness() const 
{
    assertbiu(latProt != NULL, "no lattice protein available (NULL)");
    // rounds energy and casts it an int-value, then negate it
    double energy = latProt->getEnergy();
    if (energy >= 0)
        return - static_cast<int>(floor(energy + 0.5));
        else
            return - static_cast<int>(ceil(energy - 0.5));
};

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

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);
}

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