PelletField.h

 
 
#ifndef PelletField_H
#define PelletField_H
 
#include <iostream>
#include <Eigen/Eigen>
#include <string>
#include <sstream>
 
#include "SpreaderModel.h"
#include "SimpleFish.h"
 
#include <CEnvironment.h>
 
#include "IBasicBottom.h"
#include "ICurrentVel.h"
#include <SimObject.h>
 
#include "sfh/util/diagnostic.h"
#include "sfh/text.h"
#include "sfh/constants.h"
#include "sfh/math.h"
 
#include <math.h>
#include <vector>
 
using std::vector;
 
#ifdef FH_VISUALIZATION
#include <OgreBoxEmitter.h>
#endif
 
class PelletField : public SimObject
{
public:
 
    static const int USE_SIMPLE_FISH_MODEL = 0;
 
    PelletField(std::string sSimObjectName, ISimObjectCreator* pCreator );
    ~PelletField();
    void FinalSetup(const double T, const double *const X, ISimObjectCreator* const creator);
 
    void InitialConditionSetup(const double T, const double *const currentIC, double* const updatedIC, ISimObjectCreator* const  creator);
 
    void OdeFcn(const double dT, const double* const adX, double* const adXDot, const bool bIsMajorTimeStep);
 
    int getIndex(int x, int y, int z);
 
    void calcAdvectAndDiff(double T, const double* const adX,double* const adXDot);
 
    void calcAdvectAndDiffWorker(double T, double dt,  const double* const adX, double* const adXDot, int kstart, int kend);
 
    int* getIndexFromPos(Eigen::Vector3d position);
 
    double getConcentration(Eigen::Vector3d position, const double* const X);
 
    double getConcentrationAndGradient(Eigen::Vector3d position, const double* const X, double* gradient);
 
    double removePellet(Eigen::Vector3d position, const double* const X, IStateUpdater* updater);
 
    double getPelletWeight();
 
    double getTotalFeed(const double *const X);
 
    double superbeeAdv(double dt, double dx, double c_ll, double c_l, double c_c, double c_r, double c_rr, double v_l, double v_r);
 
    bool checkSign(double value, bool signToTest);
 
    double minmod(double v1, double v2);
 
    double maxmod(double v1, double v2);
 
    void PreOdeFcn(const double T, const double *const X, IStateUpdater* updater);
 
    const virtual double* ConcAtRefPos(const double T, const double *const X, int iPos); // Output function for concentration at reference position
    const virtual double *concOutputAtStaticPos(const double dT, const double *const adX, int iExtNode);
 
    // BS
    const virtual double* OutputIngestion(const double T, const double* const X); // Output function for ingestion
 
#ifdef FH_VISUALIZATION
    virtual void            RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
 
    virtual void            RenderUpdate(const double T, const double* const X);
 
    void CloudRenderInit(Ogre::SceneManager* sceneMgr);
    void RenderCloud(const double T, const double* const X);
#endif
 
 
protected:
 
    std::vector<std::string>    SplitString(std::string sData,std::string separator);
    virtual const double* Position(const double dT, const double* const adX);
 
    double getAtPos(int i, int j, int k, const double* const X);
 
    ISimObjectCreator* m_pCreator;
 
    // Pointer to state vector:
    const double* local_adX;
    double* local_adXdot;
 
    // Input
    int m_nRefPosOutputs;
    ISignalPort **m_refPos;
    double *m_concAtRefPos;
 
    // State vector:
    int m_state_feed;
    int m_numThreads; // Number of parallel threads to use
    int m_bstates; // Number of bookkeeping states
    int m_iwaste; // Index of state value for total accumulated waste
    int m_iingestion; // Index of state value for total accumulated ingestion
    int m_nfishstates, m_isimplefish; // Number of states, and index of first state value for simple fish model
 
    double m_time_last = -1;
    double m_dx, m_sinkingSpeed, m_diffKappaXY, m_diffKappaZ;
    int m_imax, m_jmax, m_kmax; // Grid dimensions
    double m_cageRad, m_cageCylDepth, m_cageTotDepth; // Cage dimensions
    int m_feederCenterX, m_feederCenterY, m_feederType, m_feederTilt;
    double m_feederAirSpeed, m_feederAngle;
 
    double m_simpleFishN, m_simpleFishW, m_simpleFishStd; // Settings for simple fish population
    int m_feedingLevel; // Vertical level of feeding input
    double m_feedingRateMult; // Total feeding rate
    double m_pelletWeight; // Pellet weight (g)
    double m_totalFeed; // Total feed in grid (g)
    double m_temperature;
 
    vector<double> m_advect, m_diffus, m_feeding;
    vector<vector<double>> m_feedingRate;
 
    //bool ***m_mask;
    bool *m_mask;
 
    vector<vector<vector<vector<double>>>> m_currentField;
 
    vector<vector<int>> m_cellOffsets;
 
    int m_readCurrentField, m_outputcounter;
 
    SpreaderModel* m_spreaderModel;
    SimpleFish* m_simpleFish; // Simple fish ingestion model
    int m_nStaticSensorPoints;
    ISignalPort **m_staticPosInputs;
    double* m_staticPosOutputs;
    //ISignalPort *m_InEngineControl;
 
    IBasicBottom**                  m_bottom;
    ICurrentVel**                   m_currentVel;
    CEnvironment*                   m_environment;
 
    // Keeping track of cage centre possition
    bool                               m_boolCagePos;                   
    bool                               m_boolMoveGrid;                  
    ISignalPort*                    m_cageCentreNED;                
    float*                          m_gridCentre;                   
    float*                          m_gridCentreInit;               
    int                             m_di_grid;
    int                             m_dj_grid;
    int                             m_di_gLast;
    int                             m_dj_gLast;
    int*                               m_dij_tot;                   
    double*                         m_cageCentre;                   
    void setVarValFromInputPort(ISignalPort* inputPort, double* varVal, int nVal ,const double T, const double* const X); 
 
    // NEW: feeding regime
    int                                m_nFeedingPeriods;               
    double**                              m_feedingRegime;              
    bool                                  m_boolVarFeedRate;                
    double                             m_dynFeedRate;                   
    ISignalPort*                       m_feedRateIn;                    
   std::string                   m_startDateString;            
    double m_prevTextOutputTime;
 
    int                             m_pelletsEaten;
 
 
    // BS
    double                          m_IngestionRate[3];
    double                          m_CurrentReduction;
    double                          m_UpdateStepSize;
    int                             m_UpdateNum;
    int                             m_SINum;
 
   // PC_dev ============================================
   bool     m_useTankFeeding; 
   bool     m_useFeedAsExperimentalO2Proxy; 
 
#ifdef FH_VISUALIZATION
 
    double m_visParticleSize;
    double m_visParticleMultiplier;
    double m_visSinkingSpeedMultiplier;
    double m_visParticleTimeToLive;
    double m_visParticleFadeRate;
    int m_visParticleQuota;
    double m_visAngleSpread;
    std::string m_visParticleColor;
 
    std::string             m_sMaterial;    
    std::string             m_sMeshName;    
    double                  m_dScale;       
    Ogre::Entity*           m_pRenderEntity;    
    Ogre::SceneNode*        m_pRenderNode;  
    Ogre::SceneManager*     m_pSceneMgr;    
 
   Ogre::ParticleSystem*  m_particleSystem;
   Ogre::SceneNode*       m_particleNode;
   Ogre::ParticleEmitter* m_particleEmitter;
#endif
};
 
 
#endif