populationmanager.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2011, Christopher John Topping, Aarhus University
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
//---------------------------------------------------------------------------

#ifndef PopulationManagerH
  #define PopulationManagerH

// Forwards
class TAnimal;
class MyDialog;
class AlleleFreq;

// Start defines
typedef char * AnsiString;
typedef vector < TAnimal * > TListOfAnimals;
// END defines


//------------------------------------------------------------------------------
typedef enum
{
    TOP_Skylark,
    TOP_Vole,
    TOP_Spider,
    TOP_Beetle,
    TOP_Hare,
    TOP_Partridge,
    TOP_Goose,
    TOP_MarshFritillary,
    TOP_RoeDeer,
    TOP_Predators,
    TOP_Hunters,
    TOP_Rabbit,
    TOP_Newt,
#ifdef __dormouse  // LADA
    TOP_Dormouse,
#endif //__dormosue
    TOP_foobar
}TTypesOfPopulation;
//------------------------------------------------------------------------------

struct IntArray100 {
public:
  int n[ 100 ];
};

//------------------------------------------------------------------------------

struct rectangle {
public:
  unsigned m_x1;
  unsigned m_y1;
  unsigned m_x2;
  unsigned m_y2;
};
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

class TALMaSSObject {
protected:
    int m_CurrentStateNo;
    bool m_StepDone;
public:
    int GetCurrentStateNo() {
        return m_CurrentStateNo;
    }
    void SetCurrentStateNo(int a_num) {
        m_CurrentStateNo = a_num;
    }
    bool GetStepDone() {
        return m_StepDone;
    }
    void SetStepDone(bool a_bool) {
        m_StepDone = a_bool;
    }
    virtual void BeginStep(void) {}
    virtual void Step(void) {}
    virtual void EndStep(void) {}
    virtual void ReinitialiseObject() {
        m_StepDone = false;
        m_CurrentStateNo = 0;
    }
    TALMaSSObject();
    virtual ~TALMaSSObject();
    void OnArrayBoundsError();
#ifdef __CJTDebug_5
    int AmAlive;
    int IsAlive() {
        return AmAlive;
    }
    void DEADCODEError();
#endif
};

//------------------------------------------------------------------------------

class AnimalPosition
// used to communicate the position of an animal to inquiring objects
{
public:
  unsigned m_x;
  unsigned m_y;
  TTypesOfLandscapeElement m_EleType;
  TTypesOfVegetation m_VegType;
};
//------------------------------------------------------------------------------

class RoeDeerInfo : public AnimalPosition
{
public:
  int m_Size;
  int m_Age;
  unsigned m_Range_x;
  unsigned m_Range_y;
  unsigned m_OldRange_x;
  unsigned m_OldRange_y;
};
//------------------------------------------------------------------------------

class TAnimal : public TALMaSSObject {
public:
  unsigned SupplyFarmOwnerRef();
  AnimalPosition SupplyPosition();
  APoint SupplyPoint() { APoint p( m_Location_x, m_Location_y); return p; }
  int SupplyPolygonRef() {
    return m_OurLandscape->SupplyPolyRef( m_Location_x, m_Location_y );
  }
  int Supply_m_Location_x() {
    return m_Location_x;
  }
  int Supply_m_Location_y() {
    return m_Location_y;
  }
  virtual void KillThis()
  {
    m_CurrentStateNo = -1;
    m_StepDone = true;
  };
  virtual void CopyMyself() {
  };
protected:
  int m_Location_x;
  int m_Location_y;
  Landscape * m_OurLandscape;
  void CorrectWrapRound() {
    m_Location_x = (m_Location_x + m_OurLandscape->SupplySimAreaWidth()) % m_OurLandscape->SupplySimAreaWidth();
    m_Location_y = (m_Location_y + m_OurLandscape->SupplySimAreaHeight()) % m_OurLandscape->SupplySimAreaHeight();
  }
public:
  void SetX( int a_x ) {
    m_Location_x = a_x;
  }
  void SetY( int a_y ) {

    m_Location_y = a_y;

  }
  TAnimal( int x, int y, Landscape * L );
  // Note that below must be replaced in a descendent class e.g. Skylark_Base
  virtual void BeginStep( void ) {
  }
  virtual void Step( void ) {
  }
  virtual void EndStep( void ) {
  }
  virtual void ReinitialiseObject(int x, int y, Landscape * L) {
      m_OurLandscape = L;
      m_Location_x = x;
      m_Location_y = y;
      TALMaSSObject::ReinitialiseObject();
  }
  virtual int WhatState() {
    return 0;
  }
  virtual void Dying() {
    KillThis();
  }
  void CheckManagement( void );
  void CheckManagementXY( int x, int y );
  virtual bool OnFarmEvent( FarmToDo /* event */ ) {
    return false;
  }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

class probe_data
{
protected:
  ofstream * m_MyFile;
  int m_Time;
  char m_MyFileName[ 255 ];
public:
  bool m_FileRecord;
  unsigned m_ReportInterval; // from 1-10
  unsigned m_NoAreas; // from 1-10
  rectangle m_Rect[ 10 ]; // can have up to ten areas
  unsigned m_NoEleTypes;
  unsigned m_NoVegTypes;
  unsigned m_NoFarms;
  TTypesOfVegetation m_RefVeg[ 25 ]; // up to 25 reference types
  TTypesOfLandscapeElement m_RefEle[ 25 ]; // up to 25 reference types
  unsigned m_RefFarms[ 25 ]; // up to 25 reference types
  // Species Specific Code below:
  bool m_TargetTypes[ 10 ]; // eggs,nestlings,fledgelings,males,females etc.
  void FileOutput( int No, int time, int ProbeNo );
  void FileAppendOutput( int No, int time );
  probe_data();
  void SetFile( ofstream * F );
  ofstream * OpenFile( char * Nme );

  bool OpenForAppendToFile() {
      m_MyFile = new ofstream(m_MyFileName, ios::app);
      if (!(*m_MyFile).is_open())
      {
          g_msg->Warn( WARN_FILE, "PopulationManager::AppendToFile() Unable to open file for append: ", m_MyFileName );
          exit(1);
      }
      return true;
  }
  void CloseFile();
  ~probe_data();
};
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

class SimpleStatistics
{
protected:
    double m_K;
    double m_n;
    double m_Sum;
    double m_SumX;
    double m_SumX2;
public:
    SimpleStatistics()
    {
        ClearData();
    }
    void add_variable(double x){
        // This uses the computed shifted data equation. 
        if (m_n == 0) m_K = x;
        m_n++;
        m_Sum += x;
        m_SumX += x - m_K;
        m_SumX2 += (x - m_K) * (x - m_K);
    }
    void remove_variable(double x){
        m_n--;
        m_Sum -= x;
        m_SumX -= (x - m_K);
        m_SumX2 -= (x - m_K) * (x - m_K);
    }
    double get_N(){
        return m_n;
    }
    double get_Total(){
        return m_Sum;
    }
    double get_meanvalue(){
        return m_K + m_SumX / m_n;
    }
    double get_varianceP(){
        if (m_n < 2)
        {
            return -1; // Ilegal n value, but don't want to exit
        }
        return (m_SumX2 - (m_SumX*m_SumX) / m_n) / (m_n);
    }
    double get_varianceS(){
        if (m_n < 2)
        {
            return -1; // Ilegal n value, but don't want to exit
        }
        return (m_SumX2 - (m_SumX*m_SumX) / m_n) / (m_n - 1);
    }
    void ClearData()
    {
        m_K = 0;
        m_n = 0;
        m_Sum = 0;
        m_SumX = 0;
        m_SumX2 = 0;
    }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class Population_Manager {
public:
    // Methods
  Population_Manager( Landscape * L );
  virtual ~Population_Manager( void );
    void SetNoProbes(int a_pn) { m_NoProbes=a_pn; }
    unsigned GetLiveArraySize(int a_listindex) {
        return m_LiveArraySize[a_listindex];
    }
    void IncLiveArraySize(int a_listindex) {
        m_LiveArraySize[a_listindex]++;
    }
    virtual void Catastrophe(int /* a_mort */) {
    }
    unsigned int FarmAnimalCensus(unsigned int a_farm, unsigned int a_typeofanimal);
    char* SpeciesSpecificReporting(int a_species, int a_time);
    char* ProbeReport(int a_time);
    char* ProbeReportTimed(int a_time);
    void ImpactProbeReport( int a_Time );
    bool BeginningOfMonth();
    void LOG( const char* fname);
  int SupplyStepSize() {
    return m_StepSize;
  }
  int SupplySimW() {
    return SimW;
  }
  int SupplySimH() {
    return SimH;
  }
  virtual void Run( int NoTSteps );
  virtual float Probe( int ListIndex, probe_data * p_TheProbe );
  virtual void ImpactedProbe(  );
  int SupplyListNameLength() {
    return m_ListNameLength;
  }
  unsigned SupplyListIndexSize() {
    return (unsigned)TheArray.size();
  }
  unsigned SupplyListSize( unsigned listindex ) {
    return (unsigned) TheArray[ listindex ].size();
  }
  bool CheckXY(int l, int i);

//---------------------------------------------------------------------------
  const char* SupplyListName( int i ) {
    return m_ListNames[ i ];
  }
  bool IsLast( unsigned listindex ) {
    if ( TheArray[ listindex ].size() > 1 ) return false; else
      return true;
  }
  int SupplyState( unsigned listindex, unsigned j ) {
    return TheArray[ listindex ] [ j ]->WhatState();
  }
  virtual void SupplyLocXY( unsigned listindex, unsigned j, int & x, int & y ) {
    x = TheArray[ listindex ] [ j ]->Supply_m_Location_x();
    y = TheArray[ listindex ] [ j ]->Supply_m_Location_y();
  }
  const char* SupplyStateNames( int i ) {
    return StateNames[ i ];
  }
  unsigned SupplyStateNamesLength() {
    return StateNamesLength;
  }
  virtual void DisplayLocations();
  int ProbeFileInput( char * p_Filename, int p_ProbeNo );
  // Attributes
#ifdef __ALMASS_VISUAL
  MyDialog * m_MainForm; // Need to use this when drawing to main form
#endif
  int IndexArrayX[ 5 ] [ 10000 ];
  probe_data * TheProbe[ 100 ];
  int SimH, SimW;
  unsigned SimHH, SimWH;
  char m_SimulationName[ 255 ];
  bool ProbesSet; // used to show when probes are needed to be set
  Landscape * m_TheLandscape;
  TAnimal * FindClosest( int x, int y, unsigned Type );
  // Output arrays
  #ifndef __UNIX__
  // unsigned Counts[ 10 ] [ 100 ];
  #endif
protected:
  // Attributes
    // Holds the number of live animals repsented in each element of vector of vectors TheArray
    vector<unsigned> m_LiveArraySize;
  int m_NoProbes;
  FILE* m_GeneticsFile;
  FILE* m_AlleleFreqsFile;
  FILE* m_EasyPopRes;
  //FILE* m_FledgelingFile;
  const char* StateNames[ 100 ];
  int m_catastrophestartyear;
  int m_StepSize;
  vector < TListOfAnimals > TheArray; // Creates an empty array of arrays
  unsigned StateNamesLength;
  /* IntArray100 StateList; */
  const char* m_ListNames[ 10 ];
  unsigned m_ListNameLength;
  FILE * TestFile;
  FILE * TestFile2;
  unsigned BeforeStepActions[ 10 ];
  int m_SeasonNumber;
  // Methods
  virtual bool StepFinished();
  virtual void DoFirst();
  virtual void DoBefore();
  virtual void DoAfter();
  virtual void DoAlmostLast();
  virtual void DoLast();
  void EmptyTheArray();
  void SortX( unsigned Type );
  void SortXIndex( unsigned Type );
  void SortY( unsigned Type );
  void SortState( unsigned Type );
  void SortStateR(unsigned Type);
  unsigned PartitionLiveDead(unsigned Type);
  void Shuffle_or_Sort(unsigned Type);
  void Shuffle( unsigned Type );
  virtual void Catastrophe();
  void NWordOutput();
// Grid related functions
public:
       bool OpenTheRipleysOutputProbe();
       bool OpenTheMonthlyRipleysOutputProbe();
       bool OpenTheReallyBigProbe();
       virtual void TheRipleysOutputProbe(FILE* a_prb);
       virtual void TheReallyBigOutputProbe();
       virtual void TheNWordOutputProbe() {};
       void CloseTheMonthlyRipleysOutputProbe();
       void CloseTheRipleysOutputProbe();
       void CloseTheReallyBigOutputProbe();
       bool OpenTheCIPEGridOutputProbe();
       virtual void TheCIPEGridOutputProbe();
       void CloseTheCIPEGridOutputProbe();
       TTypesOfPopulation GetPopulationType() { return m_population_type; }
       int GetSeasonNumber() {return m_SeasonNumber;}
protected:
       TTypesOfPopulation m_population_type;
       FILE * RipleysOutputPrb;
       FILE * RipleysOutputPrb1;
       FILE * RipleysOutputPrb2;
       FILE * RipleysOutputPrb3;
       FILE * RipleysOutputPrb4;
       FILE * RipleysOutputPrb5;
       FILE * RipleysOutputPrb6;
       FILE * RipleysOutputPrb7;
       FILE * RipleysOutputPrb8;
       FILE * RipleysOutputPrb9;
       FILE * RipleysOutputPrb10;
       FILE * RipleysOutputPrb11;
       FILE * RipleysOutputPrb12;
       FILE * CIPEGridOutputPrb;
       FILE * CIPEGridOutputPrbB;
       FILE * ReallyBigOutputPrb;
       FILE * NWordOutputPrb;
       int* m_cgridcount;
       int* m_gridcount[4];
       int m_cgridcountwidth;
       int m_gridcountwidth[4];
       int m_cipegridsize;
       int m_gridcountsize[4];

       long int lamdagrid[2][257][257]; // THIS ONLY WORKS UP TO 10x10 KM !!!!
public:
       void LamdaDeath(int x, int y) {
               // inlined for speed
               lamdagrid[1][x / __lgridsize][y / __lgridsize ]++;
       }
       void LamdaBirth(int x, int y) {
               lamdagrid[0][x / __lgridsize][y / __lgridsize ]++;
       }
       void LamdaBirth(int x, int y, int z) {
               lamdagrid[0][x / __lgridsize][y / __lgridsize ]+=z;
       }
       void LamdaClear() {
               for (int i=0; i<257; i++ ) {
                       for (int j=0; j<257; j++) {
                               lamdagrid[0][i][j]=0;
                               lamdagrid[1][i][j]=0;
                       }
               }
       }
       void LamdaDumpOutput();
       // end grid stuff
public: // Special ones for compatability to descended managers
  virtual int SupplyPegPosx( int ) {
    return 0;
  }
  virtual int SupplyPegPosy( int ) {
    return 0;
  }
  virtual int SupplyCovPosx( int ) {
    return 0;
  }
  virtual int SupplyCovPosy( int ) {
    return 0;
  }
  virtual bool OpenTheFledgelingProbe() {
    return false;
  }
  virtual bool OpenTheBreedingPairsProbe() {
    return false;
  }
  virtual bool OpenTheBreedingSuccessProbe() {
    return false;
  }
  virtual void BreedingPairsOutput( int  ) {
  }
  virtual int TheBreedingFemalesProbe( int ) {
    return 0;
  }
  virtual int TheFledgelingProbe() {
    return 0;
  }
  virtual void BreedingSuccessProbeOutput( double, int, int, int, int, int, int , int ) {
  }
  virtual int TheBreedingSuccessProbe( int & , int & , int & , int & , int &, int &  ) {
         return 0;
  }
  virtual void FledgelingProbeOutput( int, int ) {
  }
  virtual void TheGeneticProbe( unsigned , int , unsigned &  ) {
  }
  virtual void GeneticsResultsOutput( FILE * , unsigned  ) {
  }
  // Attributes
//  AlleleFreq * AlFreq;
};
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

class PopulationManagerList
{
public:
  PopulationManagerList() { for (int i=0; i< TOP_foobar; i++) m_populationlist[i] = NULL; }
  void SetPopulation(Population_Manager* p_pm, TTypesOfPopulation a_pt) { m_populationlist[a_pt] = p_pm; }
  Population_Manager* GetPopulation(TTypesOfPopulation a_pt) { return m_populationlist[a_pt]; }
protected:
  Population_Manager* m_populationlist[TOP_foobar];
};
//------------------------------------------------------------------------------


#endif