homeostasis.h

Go to the documentation of this file.

#ifndef HOMEOSTASIS_H
#define HOMEOSTASIS_H

#include <string>
#include <iostream>
#include <iomanip>
#include <math.h>
#include <limits>
#include <time.h>

class Drive
{
public:
    std::string name; 
    std::string key; 
    double period;
    double value, homeostasisMin, homeostasisMax, decay, valueMin, valueMax, default_value, decay_multiplier;
    bool gradient;
    time_t start_sleep; 
    bool is_sleeping; 
    double time_to_sleep; 

    Drive(std::string d_name, double d_period, std::string d_key="default", double d_value=0.5, double d_homeo_min=0.25, double d_homeo_max=0.75, double d_decay = 0.05, double d_value_min=std::numeric_limits<double>::min(), double d_value_max=std::numeric_limits<double>::max(), bool d_gradient = false) :
        name(d_name),
        key(d_key),
        period(d_period),
        value(d_value),
        homeostasisMin(d_homeo_min),
        homeostasisMax(d_homeo_max),
        decay(d_decay),
        valueMin(d_value_min),
        valueMax(d_value_max),
        default_value((d_homeo_max + d_homeo_min)/2.),
        decay_multiplier(1),
        gradient(d_gradient),
        start_sleep(time(NULL)),
        is_sleeping(true),
        time_to_sleep(1e10)
    {
        //todo : check the min/max
        if (d_value_min == std::numeric_limits<double>::min() && d_value_max == std::numeric_limits<double>::max()){
            double homeoRange =  homeostasisMax - homeostasisMin;
            valueMin = homeostasisMin - 0.5 * homeoRange;
            valueMax = homeostasisMax + 0.5 * homeoRange;
        }
    }

    Drive() = delete; 

    void setKey(std::string d_key)
    {
        this->key=d_key;
    }
    void setValue(double d_value)
    {
        this->value=d_value;
    }
    void deltaValue(double d_value)
    {
        this->value += d_value;
    }

    void setHomeostasisMin(double d_homeo_min)
    {
        this->homeostasisMin = d_homeo_min;
    }
    void deltaHomeostasisMin(double d_homeo_min)
    {
        this->homeostasisMin += d_homeo_min;
    }

    void setHomeostasisMax(double d_homeo_max)
    {
        this->homeostasisMax = d_homeo_max;
    }
    void deltaHomeostasisMax(double d_homeo_max)
    {
        this->homeostasisMax += d_homeo_max;
    }
   
    void setDecay(double d_decay)
    {
        this->decay = d_decay;
    }
    void deltaDecay(double d_decay)
    {
        this->decay += d_decay;
    }

    void setDecayMultiplier(double mult)
    {
        this->decay_multiplier = mult;
    }

    void sleep(double t) {
        start_sleep = time(NULL);
        is_sleeping = true;
        time_to_sleep = t;
    }

    void freeze() {
        start_sleep = time(NULL);
        is_sleeping = true;
        time_to_sleep = 1e10;
    }

    void reset(){
        value = default_value;
    }

    void unfreeze() {
        is_sleeping = false;
    }

    void update()
    {
        if (is_sleeping) {
            if (difftime(time(NULL), start_sleep) > time_to_sleep) {
                is_sleeping = false;
            }
        }
        else if (! ((this->value > valueMax && this->decay<0) || (this->value < valueMin && this->decay>0))) {
            this->value -= (this->decay * this->decay_multiplier * period);          
        }
    }

    double getValue()
    {
        return(value);
    }

    void setName(std::string n)
    {
        this->name = n;
    }

    void setGradient(bool b)
    {
        this->gradient = b;
    }

};

#endif