IndividualFish.h

#ifndef INDIVIDUAL_FISH_H
#define INDIVIDUAL_FISH_H
 
#include "sfh/math/math.h"
#include "sfh/math/array.h"
#include "sfh/text.h"
#include "sfh/linalg.h"
#include "sfh/constants.h"
#include "sfh/util/diagnostic.h"
#include "sfh/sim.h"
#include "sfh/sim/Quaternion.h"
#include <CPrintDuringExec.h>
 
#include "compact_data_representations.h"
 
#include <random>
 
#include <CPrintDuringExec.h>
#include <EnvironmentProvider.h>
#include "DebModel.h"
#include "FishParameters.h"
#include "eigen_matrix_defs.h"
#include "../particles/PelletField.h"
#include "../environment/VerticalAbioticEnvironment.h"
#include "FishCage.h"
#include "Z_Tree.h"
 
 
struct FishResources {
    Fish::DebModel              m_debModel;
    Fish::FishParameters        m_par; 
    PelletField                 *m_pellets;
    environment::EnvironmentProvider    *m_env;
    VerticalAbioticEnvironment  *m_abioticEnvironment;
    Grid::FastNeighbourLookup   m_spatial_map;
    Fish::FishCage              m_cage;
    std::vector<Fish::IndividualFish>* m_individuals;
    int                         m_base_state_index;
    bool                        m_surfRespActive;
    bool                        m_wallRespActive;
    bool                        m_feedRespActive;
    bool                        m_tempRespActive;
    bool                        m_lightRespActive;
    bool                        m_nbRespActive;
    bool                        m_stochRespActive;
    bool                        m_wvelRespActive;
 
    //============================================================================ biao_dev
    int                         m_ObstacleNum;
    double                      m_ObstaclePrefDis;
    Fish::vec3                  m_ObstaclePos;
    Fish::vec3                  m_ObstacleVel;
    //============================================================================ biao_dev
};
 
 
namespace Fish{ 
    static const int g_NumStatesPerFish = 10;
 
    class IndividualFish
    {
    public:
 
        void Init(FishResources *fishResources, std::mt19937& rng, const double* states);
 
        void calculateDerivative(
            int index,
            const double T,
            const double* const X,
            double * const  XDot,
            std::mt19937& rng,
            std::vector<int>& ingestionList,
            bool& obstacle
         //============================================================================ herman_dev
         //, const double delta_T
         //============================================================================ herman_dev
        );
        
        vec3    Position(){return m_Position;}
        vec3    Velocity(){return m_Velocity;}
        double  BodyLength(){return m_Length;}
        double  CharacteristicVelocity(){return m_characteristicVelocityFactor;}
 
 
        char BehaviouralState(){return m_behaviouralState;}
        void UpdateStates(const double* states);
        void WriteStates(double* states);
    
        int entropy();
 
        inline static double forward_scanning_distance(const vec3& P0, const vec3& V0,const vec3& P1,const vec3& V1) {
            vec3 dP = P1 - P0;
            vec3 dV = V1 - V0;
            double d = dP.norm();
            double x = dP.dot(dV);
            return d + x/(x*x+1.0);
        }
 
        //============================================================================ biao_dev
        //void  mass_gain(const double& fMass){m_Mass = fMass/1000.0;}
        
        vec3    VelocityRel() {return m_VelocityRel;}
        double  GetDEBG0() {return m_debG0;}
        double  GetDEBE0() {return m_debE0;}
        double  GetDEBV0() {return m_debV0;}
        //============================================================================ biao_dev
 
 
#ifdef FH_VISUALIZATION
        Eigen::Vector3f Color();
        Eigen::Vector3f m_rgb;
#endif
 
    protected:
        struct behaviour_vote{
            behaviour_vote(){direction.setZero();vote_gain=0.0;}
            behaviour_vote(const vec3& d, double g){direction = d; vote_gain = g;}
            vec3 direction;
            double vote_gain;
        };
 
        behaviour_vote containment_behaviour(Fish::FishCage& cage, Fish::FishParameters& parameters, vec3& current, double surface_elevation, double& wallcur, double& walldis); // keep inside net and below surface. if this vote is 100%, all other behavioural patterns are neglected.
        behaviour_vote temperature_behaviour();
        behaviour_vote light_behaviour();
        //behaviour_vote temperature_and_light_behaviour(); // seek equilibrium. 
        behaviour_vote schooling_behaviour(Fish::FishParameters& parameters, int index); // avoid overcrowding. converge towards dominating swimming direction.
        behaviour_vote feed_behaviour(const double T, const double* const X, std::mt19937& rng); // approach feed if hungry and food is present
      //============================================================================ herman_dev
        behaviour_vote wandering_behaviour(Fish::FishParameters& parameters, std::mt19937& rng, const double T
      //, const double delta_T
      ); // slightly random, keep momentum, converge towards ideal swimming speed.
      //============================================================================ herman_dev
 
 
 
        //inline Fish::FishCage& CAGE(){return m_ptr->m_cage;}
        //inline Fish::FishParameters& PARAMS(){return m_ptr->m_par;}
        //inline PelletField* PELLETS(){return m_ptr->m_pellets;}
        //inline environment::EnvironmentProvider* ENV(){return m_ptr->m_env;}
        //inline VerticalAbioticEnvironment* ABIOTICENV(){return m_ptr->m_abioticEnvironment;}
 
        // Functions
        //void surfaceBehaviour     (vec3& posDot,double surfaceElevation,vec2& quotas);
        //void netWallBehaviour     (vec3& posDot,vec2& quotas);
        //void feedBehaviour            (vec3& posDot,double T, const double* const feedData,vec2& quotas);
        //void temperatureBehaviour (vec3& posDot, vec2& quotas);
        //void lightLevelBehaviour  (vec3& posDot, vec2& quotas);
        //void neighborBehaviour        (vec3& posDot,vec2& quotas, int current_global_index);
        //void stochasticBehaviour  (vec3& posDot,vec2& quotas,std::mt19937& rng);
        //void waterVelocityBehaviour   (vec3& posDot, vec3& waterVel,vec2& quotas);
 
        //void getNewBehaviouralState   (double T,const double* const feedData, std::mt19937& rng);
        //double getAppetite();
 
        // Variables
        FishResources* m_ptr; 
 
        // Auxiliary variables
        float   m_lastEvaluationOfSatiation;    
        float   m_startTimeManipulation;        
 
        // dynamic state variables
        vec3   m_Position;
        vec3   m_Velocity;
        double m_debG;
        double m_debE;
        double m_debV;
        double m_Length;
 
        char    m_behaviouralState; // 0 = normal, 1 = satiated, 2 = approach feed, 3 = capture feed, 4 = manipulate feed
        CompactData::Duration       m_manipulateTime;
        CompactData::Temperature    m_prefTemperatureLow;
        CompactData::Temperature    m_prefTemperatureHigh;
        CompactData::Speed          m_characteristicVelocityFactor;
        CompactData::Speed          m_maxSustainableVelocityFactor; 
 
        bool outside_net;
 
        //============================================================================ biao_dev     
        /*double m_Mass;
        double m_DargA;*/
 
        behaviour_vote obstacle_behaviour(bool& obstacle);
        bool m_obsInt;
 
        behaviour_vote schooling_behaviour_h(Fish::FishParameters& parameters, int index, const double T);
        behaviour_vote schooling_behaviour_v(Fish::FishParameters& parameters, int index);
 
        vec3 m_VelocityRel;
        double m_debG0;
        double m_debE0;
        double m_debV0;
        //============================================================================ biao_dev
    };
}
#endif