doc/FishPopulation_8h_source.html

#ifndef FISH_POPULATION_H

#define FISH_POPULATION_H


//#define CNetStructure_DO_PROFILE


// Includes

#include <string>

#include <math.h>


#include "SimObject.h"

#include "CEnvironment.h"

#include "IBasicBottom.h"

#include "ICurrentVel.h"

#include "sfh/timers/ProfilerWallclock.h"

#include "sfh/math/math.h"


#include "IndividualFish.h"

#include "particles/PelletField.h"

#include "fish/FishParameters.h"

#include "environment/ArtificialLightSource.h"

#include "fish/Z_Tree.h"

#include <CIntegratorOptions.h>

#include <CFhSimMgr.h>

#include "fish/FishCage.h"

#include <CPrintDuringExec.h>


#include <CNCField.h>       // BS_Temporary


#ifdef FH_VISUALIZATION

#include "CFhCamera.h"

#endif


//Class definition

class FishPopulation : public SimObject

{

public:

    FishPopulation(std::string simObjectName, ISimObjectCreator *creator);

    virtual ~FishPopulation();

    virtual void OdeFcn(const double T, const double *const X, double *const XDot, const bool isMajorTimeStep);

    virtual void InitialConditionSetup(const double T, const double *const currentIC, double *const updatedIC, ISimObjectCreator *const creator);

    virtual void FinalSetup(const double T, const double *const X, ISimObjectCreator *const creator);

    //const double *outBehaviouralState(const double T, const double *const X, int iFish);

    void PreOdeFcn(const double T, const double *const X, IStateUpdater* updater);


    //============================================================ Herman_dev

    bool GetRayIntersection(const Eigen::Vector3d& rayOrigin, const Eigen::Vector3d& rayVector, double& outDistance);

    //============================================================ Herman_dev


    const virtual double* DragForceNet(const double T, const double *const X); // Output function for drag force on the net

    const virtual double* DragForceSkirt(const double T, const double *const X); // Output function for drag force on the skirt

    const virtual double* DragForceDepth(const double T, const double *const X); // Output function for drag force on the net above a given depth

    const virtual double* TopOutForceNet(const double T, const double* const X, int iTop); // Output function for top connection force on the net

    const virtual double* BotOutPosition(const double T, const double* const X); // Output function for bottom positions

    const virtual double* RingOutPosition(const double T, const double* const X); // Output function for ring positions

    const virtual double* NetOutPosition(const double T, const double* const X); // Output function for net positions (single)

    const virtual double* NetOutPositionMat(const double T, const double* const X, int iIndex); // Output function for net positions (multiple)

    const virtual double* IngestionNumber(const double T, const double* const X); // Output function for number of ingestion

    const virtual double* ObstacleOutPosition(const double T, const double* const X); // Output function for obstacle positions

    const virtual double* ObstacleOutNormal(const double T, const double* const X); // Output function for obstacle normal

    const virtual double* ObstacleOutDistance(const double T, const double* const X); // Output function for obstacle distance

    const virtual double* ObstacleOutGuidance(const double T, const double* const X); // Output function for obstacle center

    const virtual double* ObstacleOutEtaReference(const double T, const double* const X); // Output function for obstacle EtaReference

    const virtual double* ObstacleOutVelocity(const double T, const double* const X); // Output function for obstacle velocities

    const virtual double* ObstacleOutVertical(const double T, const double* const X); // Output function for obstacle vertical vector

    const virtual double* TopBodyForce(const double T, const double *const X); // Output function for top body force

    const virtual double* PortOutForceNet(const double T, const double* const X, int iCon); // Output function for port connection force on the net

    const virtual double* PortOutPositionNet(const double T, const double* const X, int iCon); // Output function for port connection position on the net

    const virtual double* PortOutVelocityNet(const double T, const double* const X, int iCon); // Output function for port connection velocity on the net

    const virtual double* PortOutCageVolume(const double T, const double* const X); // Output function for cage volume

    const virtual double* PortOutCD(const double T, const double* const X, int iCon); // Output function for drag coefficient

    const virtual double* BotOutVelocity(const double T, const double* const X); // Output function for bottom velocities

    const virtual double* CageTopCentre(const double T, const double* const X); // Output function for cage top centre

    const virtual double* FishDensity(const double T, const double* const X); // Output function for fish density

    const virtual double* FishSpeed(const double T, const double* const X); // Output function for fish swimming speed

    const virtual double* FishSpeedRel(const double T, const double* const X); // Output function for fish swimming speed relative to flow

    const virtual double* RingOutForce(const double T, const double* const X, int iIndex); // Output function for connection forces to external bottom ring

    const virtual double* NetTrackOutPosition(const double T, const double* const X); // Output function for net track positions (6DOF x 2)

    const virtual double* ChainOutForce(const double T, const double* const X, int iIndex); // Output function for connection forces to external chain

    const virtual double* OutCageWakePos(const double T, const double* const X); // Output function for cage wake position


    // BS_Temporary =========================

    CNCField*       m_ncField;

    double          m_ncInput[3];

    double          m_ncOutput[3];

    const virtual double* NetCDFOutput(const double T, const double* const X);

    // BS_Temporary =========================


    //EIGEN_MAKE_ALIGNED_OPERATOR_NEW

#ifdef FH_VISUALIZATION

    virtual void RenderInit(Ogre::Root *const ogreRoot, ISimObjectCreator *const creator);

    virtual void RenderUpdate(const double T, const double *const X);

#endif


protected:

   // Fhsim logger

   CPrintDuringExec* m_logger;


    //std::mt19937& RNG(){return m_rng;}


    // States

    int m_baseStateIndex;

    int m_totalNumberOfPelletsEaten;


    FishResources   m_resources;


    std::mt19937    m_rng;


    //double                                      m_prevTextOutputTime;

    std::vector<Fish::IndividualFish>   m_individuals;

    std::vector<Fish::IndividualFish>   temp_individuals;

    //ISimObjectCreator*                       m_creator;


    //double*                       m_fishStatuses;

    bool                               m_useTemperatureAndLight;

    double                          m_fractionOfWaveVelAddedToMovementAsBias;

    //long                          m_numPelletsForTimeStep;


    long                       m_totalIngestionAttempts, m_successfulIngestionAttempts;

    std::vector<int>               m_ingestionList;


    //============================================================================ biao_dev

    double          m_DisOutTimeInt;

    std::string     m_DisOutFile;

    int             m_DisOutNum;

    double          m_DisOutStart;

    double          m_DisOutStop;


    double          m_IngestionNumber[2];


    int             m_ObstacleNum;

    double          m_ObstacleCirRate;

    double          m_ObstacleCirVel;

    double          m_ObstacleVerVel[2];

    double          m_ObstacleDisTK;

    double          m_ObstacleDepTK;

    double          m_ObstacleDepGR;

    double          m_ObstacleRefDT;

    ISignalPort*    m_ObstacleInPos;

    ISignalPort*    m_ObstacleInVel;

    double          m_ObstacleOutP[3];

    double          m_ObstacleOutN[3];

    double          m_ObstacleOutD;

    double          m_ObstacleOutG[3];

    double          m_ObstacleOutV[3];

    double          m_ObstacleOutVV[3];

    double          m_ObstacleOutGR[4];


    int             m_FishObstNum;

    Fish::vec3      m_FishObstVel;


    double          m_UpdateStepSize;

    int             m_UpdateNum;


    double          m_FishInitialPos[4];


    std::vector<int>            m_FishID;


    double          m_SchoolVar[2];

    Fish::vec3      m_SchoolVarP;

    Fish::vec3      m_SchoolVarN;


    bool            m_BoolFishInVel;

    ISignalPort*    m_FishInVelN;

    ISignalPort*    m_FishInVelE;

    ISignalPort*    m_FishInVelD;

    ISignalPort*    m_FishInVelC;


    bool            m_BoolFishInWave;

    ISignalPort*    m_FishInWaveHm;

    ISignalPort*    m_FishInWaveTm;


    double          m_OutFishDensityGrid;

    int             m_OutDataNum[4];

    double*         m_OutFishDensityData;

    double          m_OutFishDensity[4];

    double          m_OutFishSpeed[3];

    double          m_OutFishSpeedRel[3];

    double          m_MeanWeight;


    double          m_debStaTime;


    bool            m_OutCageNode;

    double*         m_OutCageNodePos;

    const virtual double* PortOutCageNodePos(const double T, const double* const X, int index);


    double          m_CageWakePos[3];

    //============================================================================ biao_dev


    //============================================================================ herman_dev

   double         m_prev_time = 0.0;

   //============================================================================ herman_dev


#ifdef FH_VISUALIZATION

    bool                    m_advancedFishAnim;

    Ogre::SceneNode*        m_childNode;

    Ogre::ManualObject*     m_fishRenderObj;

    CFhCamera*              m_FhCamera;

   double            m_FishColor[3];


    //============================================================================ biao_dev

    double                      m_ParticleGridOrigin[3];

    double                      m_ParticleGridDim[3];

    double                      m_ParticleGridSize[3];

    int                         m_ParticleGridNum[3];

    int                         m_ParticleNum;


    Ogre::ParticleSystem*   m_ParticleSystem;

    Ogre::SceneNode*            m_ParticleNode;

    Ogre::ParticleEmitter*  m_ParticleEmitter;

    double                      m_ParticleSize[2];

    double                      m_ParticleMultiplier;

    double                      m_ParticleSpeedMultiplier;

    double                      m_ParticleFadeRate;

    int                         m_ParticleQuota;

    double                      m_ParticleAngleSpread;

    double                      m_ParticleColor[3];

    double                      m_ParticleTimeToLive;

    int                         m_ParticleSetTime;

    double                      m_ParticleFlowReduction;


   // ==================== Wake effect (BiaoSu)

   bool          m_wakeEffect;

   int           m_wakeObjNum;

   ISignalPort** m_wakeObjPort;

   ISignalPort*  m_wakeDirPort;

   ISignalPort*  m_wakeRatioPort;

   ISignalPort*  m_wakeValuePort;

   double        m_wakeObjRadius[3];

   double        m_wakeObjDepth[3];

   double        m_wakeMaxVisValue;

   bool          m_wakeVisReduction;

   double        m_wakeObjPower;

   double        GetWakeRatio(const double T, const double* const X, const double adPos[3]);

   // ==================== Wake effect (BiaoSu)

    //============================================================================ biao_dev

#endif

};


#endif

CNCField
Definition: CNCField.h:8

FishPopulation
Definition: FishPopulation.h:76

FishPopulation::FishPopulation
FishPopulation(std::string simObjectName, ISimObjectCreator *creator)
The constructor sets the pointer to the output object and the parser object.

FishPopulation::~FishPopulation
virtual ~FishPopulation()
The destructor deletes dynamically allocated memory.

FishResources
Definition: IndividualFish.h:30