Neuron.h

Go to the documentation of this file.

/*
 * This file is a part of the Biology project by eons LLC.
 * Biology (aka Develop Biology) is a framework for approaching software
 * development from a natural sciences perspective.
 *
 * Copyright (C) 2022 Séon O'Shannon & eons LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "Synapse.h"
#include "bio/neural/Impulse.h"
#include "bio/common/wrapper/Pointer.h"
 
namespace bio {
namespace neural {
 
class Neuron :
    public neural::Class< Neuron >,
    public StemCell,
    public Covalent< chemical::LinearMotif< Impulse > >,
    public Covalent< chemical::LinearMotif< Dendrite > >, //Neurite
    public Covalent< chemical::LinearMotif< Axon > > //Neurite
{
public:
 
    BIO_DISAMBIGUATE_REQUIRED_CLASS_METHODS(neural, Neuron)
    BIO_DISAMBIGUATE_OPTIONAL_CLASS_METHODS(genetic, Neuron)
 
    BIO_DEFAULT_IDENTIFIABLE_CONSTRUCTORS_WITH_COMMON_CONSTRUCTOR(
        neural,
        Neuron,
        filter::Neural()
    )
 
    virtual ~Neuron();
 
    //START: Recommended overrides
 
    /*
     * These are the most important methods for every Neuron.
     * However, they may not all be required for your Neuron.
     */
 
    virtual Code CacheProteins();
 
    virtual Code CreateDefaultProteins();
 
    virtual bool ExciteTrigger() const
    {
 
        // YOUR CODE GOES HERE
 
        return false;
    }
    
    // The above can also be accessed through the Impulse methods, below.
 
    virtual void PreCrest();
 
    //END: Recommended overrides
 
    virtual void Learn();
 
    //START: Impulses
 
    /*
     * ______Impulse() methods are called by DetermineAndCallImpulseTriggers(). <br />
     * It is up to children of *this to determine what these methods do. <br />
     * NOTE: Impulses should not set the FiringCondition, which is returned by GetReasonForFiring. Only DetermineImpulseTriggers() will do that. <br />
     * If you would like to make your own Impulses, use the CreateImpulse() method and populate a molecular::Protein of the given Name. <br />
     */
 
    /*
     * The default Impulses are: "RisingEdge" Called if newly activated. <br />
     * "Continuing" Called if active and previously active. <br />
     * "FallingEdge" Called when *this stops being active. <br />
     */
 
    bool DetermineAndCallImpulseTriggers();
 
    void StartAtRisingEdge();
 
    /*
     * What "active" means is up to each Neuron to determine for itself. For example, a sensor may be active when a significant amount of stimulus is received, whereas a behavior may be active whenever it makes a call to an actuator. <br />
     * When a Neuron is not sending continuing impulses, it will be considered active until proven otherwise (e.g. falling edge is sent). In such a case, GetTimeLastActive() will return the current timestamp. <br />
     * NOTE: if a Neuron is not sending continuing impulses, ActiveUntil will not trigger a falling edge at the indicated time. The methods below are for reporting only and do not affect operation. <br />
     * For how to keep a Neuron active for a time after an initial stimulus, see PersistFor or PersistUntil (below). <br />
     * NOTE: activity may also by checked & modified through States. For example, this->Has< State >(::bio::state::Active()). <br />
     */
 
    void ActiveNow();
 
    void ActiveUntil(Timestamp time);
 
    Timestamp GetTimeLastActive() const;
 
    bool IsActive() const;
 
    void UpdateImpulseCallers();
 
    void CreateImpulse(
        const FiringCondition& trigger,
        const Name& impulseName,
        bool shouldBeActive = true
    );
 
    FiringCondition GetReasonForFiring() const;
 
    bool IsPersisting(const Timestamp now) const;
 
    bool IsPersisting() const
    {
        return IsPersisting(physical::GetCurrentTimestamp());
    }
 
    //END: Impulses
 
    //START: Configuration/Settings
    /*
     * Neurons may stay active (persist) for a given amount of time after their excite trigger. <br />
     * Calling Persist___() will result in *this remaining active for the indicated time. <br />
     * Once *this is no longer persisting, FallingEdge will be called. <br />
     * NOTE: Persistence requires the continuing impulses only set Active___() if and only if ExciteTrigger() is true (as should always be the case). <br />
 
     * FIXME: PersistUntil needs to only be applied once.
     * FIXME: Is this even a useful feature?
     */
 
    void PersistFor(const Milliseconds ms);
 
    void PersistUntil(const Timestamp time);
 
    //END: Configuration/Settings
 
 
    //START: Synapses
 
    Pointer< Synapse > ConnectTo(
        Pointer< Neuron > target,
        Pointer< const Synapse > synapseType
    );
 
    void RequestProcessingOf(Pointer< Dendrite > dendrite);
 
    virtual void PreSend();
 
    virtual Code Transmit(Pointer< ::bio::Affinity > selection = NULL);
 
    virtual void PostSend();
 
    virtual Code DepotentiateSentData(Pointer< ::bio::Affinity > selection = NULL);
 
    Index DetachOutgoingSynapsesTopologyNoDelete();
 
    Index DetachIncomingSynapsesTopologyNoDelete();
 
    Index DetachAllSynapsesTopologyNoDelete();
 
    Index PruneAllSynapses();
 
    //END: Synapses
 
    //START: These are not for you.
 
    virtual bool CheckIn();
 
    virtual Code Crest();
 
    virtual Code Apoptose();
 
    //END: These are not for you.
 
protected:
 
    virtual void CommonConstructor();
 
    Pointer< molecular::Protein > mcRisingEdge;
    Pointer< molecular::Protein > mcContinuing;
    Pointer< molecular::Protein > mcFallingEdge;
    Pointer< molecular::Protein > mcPreCrest;
    Pointer< molecular::Protein > mcPreSend;
    Pointer< molecular::Protein > mcPostSend;
    Pointer< molecular::Protein > mcLearn;
 
    virtual bool DetermineImpulseTriggers(bool trigger);
 
     virtual void PotentiateDendrite(Pointer< Dendrite > dendrite);
 
    virtual void DepotentiateDendrite(Pointer< Dendrite > dendrite);
 
    virtual void ProcessDendrites(Pointer< ::bio::Affinity > selection = NULL);
 
    virtual Code ProcessDendrite(Pointer< Dendrite > dendrite);
 
private:
    Timestamp mLastActive;
 
    FiringCondition mFiringReason;
 
    bool mContinuingImpulse;
 
    Milliseconds mPersistFor;
};
 
} //neural namespace
} //bio namespace