CropActualPrecipitation.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
//
//  Thomas Berger (main author), Pepijn Schreinemachers, and Thorsten Arnold
//
//
//  Hohenheim University (490d)
//  Professorship for Land Use Economics in the Tropics and Subtropics
//
//  May not be distributed without permission by main author
//
//  File:       CropActualPrecipitation.h
//
//  Contents:   Auxiliary class for actual precipiation
//              
//
//
//------------------------------------------------------------------------------


#ifndef _CropActualPrecipitation_h
#define _CropActualPrecipitation_h

#include "BasicData.h"
#include "MatrixDouble.h"

enum enumPrecipType {
   precipTypeActual, precipTypeAverage
};

enum typeInputDataActualPrecipitation
{       inputTypeByYear, inputTypeRandom
};

class CropPrecipitation{
public:

   virtual double getActualPrecipitationByYear(int year_, int month_, int catchment_, int sector_);
   virtual double getActualPrecipitationByIndex(int year_, int month_, int catchment_, int sector_);
   virtual int getIndexForAbsoluteYear(int year);
   virtual void printValue(int year_, int month_, int catchment_, int sector_);
   virtual void printValueByIndex(int yearIndex, int month_, int catchment_, int sector_);
        virtual double getAveragePrecipitationInMonth(int month_, int catchment_, int sector_);


        virtual void printToScreen();
        virtual void writeToFile(string fn, int catchID);//with <ifstream>
        virtual void writeToFile(char* filename, int catchID);//with <fscanf>
        //virtual void readFromFile(string fn, int catchID);//with <ifstream>
   virtual void readHeader(FILE* strm);
   virtual void readPrecipitationDataIntoMatrix(FILE* strm, MatrixDouble& matrixPassedByRef, int numYR_, int secID, enumPrecipType precipType);
        virtual void readFromFile(char* filename, int catchID);//with <fscanf>


        CropPrecipitation()
        {       allocate();
        }
                
        CropPrecipitation(int numCatchments_, int numSectors_, int numberOfYears_, int numTimeSteps_)
        {       allocate(numCatchments_, numSectors_, numberOfYears_, numTimeSteps_);
        }
                
        CropPrecipitation(CropPrecipitation& orig)
   {    allocate(orig);
        }
                
        virtual CropPrecipitation& operator=(CropPrecipitation&);
        virtual ~CropPrecipitation();
        

protected:

   int numberOfYears;
   int numTimeSteps;
   int numCatchments;
   int numSectors;
   typeInputDataActualPrecipitation inputType;

   virtual int getNumberOfYears()  
        {       return numberOfYears;
        }
   
        virtual int getNumTimeStepsPerYear()
        {       return numTimeSteps;
        }
   
        virtual int getNumCatchments()
        {       return numCatchments;
        }

   virtual int getNumSectors()
        {       return numSectors;
        }

   virtual int getRealYear(int yInd)
   {  return (int)translationMatrix_YearToIndex.getValue(yInd);
   }

   virtual typeInputDataActualPrecipitation getInputType()      
        {       return inputType;
        }

   virtual bool  getIsDataPerSector()      
        {       return isDataPerSector;
        }

   bool isDataPerSector;
   MatrixDouble translationMatrix_YearToIndex;
        
        MatrixDouble** actualPrecipitation;
   // Dimension of matrix: (years X timeSteps ):
   // Length of array: (catchments X sectors)

        MatrixDouble** averagePrecipitation;
   // Dimension of matrix: (1 X timeSteps ):
   // Length of array: (catchments X sectors)


   // Functions:
   virtual void allocate();
   virtual void allocate(int numCatchments_, int numSectors_, int numberOfYears_, int numTimeSteps_);
   virtual void allocate(CropPrecipitation& orig);
   virtual void deallocate();
   virtual void copy(CropPrecipitation& orig);
};


#endif

---