MarketTradablesHandler.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:       MarketTradablesHandler.h (formerly markt9.h)
//
//  Contents:   Market class for tradables, containing time series for input
//              and output prices plus imputed prices (for in-kind consumption)
//
//
//------------------------------------------------------------------------------


#ifndef _MarketTradablesHandler_h
#define _MarketTradablesHandler_h



#include "MatrixDouble.h"


class markt
{       
public:


        virtual int getNumberOfSimulationPeriods();
        virtual int getNumberOfTradables();
        virtual int getNumberOfFuturePrices();
        virtual int getNumberOfProductionCosts();
        virtual double getPriceForTradable(int period, int prd);

        virtual void readInputFromFile(const char* filename);
        virtual void writeInputIntoFile(char* filename);

        virtual double getExtCons();
        virtual double getMinCons();
        virtual double getForCons();
        virtual double calcConsumption(double income, int hhSize);

        virtual int checkTypeOfEarning(int lpCol);
        virtual int getIncR(void);
        virtual void calcSvgsPart(double hhEgy, MatrixDouble& scolV);
        virtual double compZeroSvgs(double hhEgy);
        virtual int getsColU(void);
        virtual int getsRowB(void);
        virtual int getsColB(void);
        virtual int getsRowS(void);
        virtual int getsColS(void);
        virtual int getsNumS(void);

        virtual double calcFNoFPart(double hhEgy, MatrixDouble& fcolV);
        virtual int getfNumS(void);
        virtual int getfRowS(void);
        virtual int getfColS(void);
        virtual int getfRowH(void);
        virtual int getfColH(void);

        virtual void calcItemPart(int period, double hhEgy,
                MatrixDouble& irowH, MatrixDouble& irowP, MatrixDouble& imatS);
        virtual int getiNumF(void);
        virtual int getiNumS(void);
        virtual int getiRowS(void);
        virtual int getiColS(void);
        virtual int getiRowP(void);
        virtual int getiColP(void);
        virtual int getiRowH(void);
        virtual int getiColH(void);
        virtual int getNumNtr(void);

        virtual void insPriceIndicesNR(double**& ap, int period);
        virtual void insActPrInObjFunc(double*& objF, int period);
        virtual void insFutPrInObjFunc(double**& ap, int period);

        virtual void makeBackUpOfCostsFromLpMatrix(int averageCashRow, double**& ap);
        virtual int getInternalIndexForLpActivity(int lpActivity);

        virtual void retrieveAbsoluteCosts(MatrixDouble& lpIndicesAndAbsoluteCosts, int period);
        virtual double getAbsoluteProductionCost(int lpActivity, int period);
        virtual double getAbsolutePreHarvestCost(int lpActivity, int period);

        virtual void retrieveRelativeProductionCosts(MatrixDouble& lpIndicesAndRelativeCosts, int period);
        virtual double getRelativeProductionCost(int lpActivity, int period);

        virtual void computeMarketEquilibriumPrices(int period);


        markt();
        virtual ~markt()
        {       delete [] reservationPrice;
                delete [] priceFlexibility;
                delete [] priceOverallTrend;
                pricePaths.deallokieren();

                delete [] activityIndexInLp;
                delete [] productionCostInBaseYear;
                delete [] preHarvestCostInBaseYear;
                relativeChangeInCosts.deallocate();
                
                delete [] typeEarning;
                delete [] coLP;
                futP.deallokieren();

                sVecS.deallokieren();
                fBeta.deallokieren();
                iAlfa.deallokieren();
                iBeta.deallokieren();
                iGamm.deallokieren();
                iDelt.deallokieren();
                pMatP.deallokieren();

                delete [] pRows;
                delete [] pCols;
        }


protected:
        FILE* strm;

        int numRounds;
        int numCommod;

        double* reservationPrice;
        double* priceFlexibility;
        double* priceOverallTrend;

        MatrixDouble pricePaths;//renamed from <preispfade>

        int numberProductionCosts;
        int* activityIndexInLp;
        double* productionCostInBaseYear;//= pre-harvest plus harvest costs
        double* preHarvestCostInBaseYear;
        MatrixDouble relativeChangeInCosts;//for all periods, in relation to base year
        
        double extCons;//renamed from KONSUMFAKTOR
        double minCons;//renamed from MINENTNAHMEN
        double forCons;//renamed from VERZICHT

        int* typeEarning;//flags indicating type of earning
        int nApp;//number of future prices for permanent crops ("appreciation")
        int* coLP;//column indices in MILP
        MatrixDouble futP;//expected future prices
        int incR;//income transfer row

        int sColU;//col in LP of upper bound on segment0 (=zero-savings)
        int sRowB;//row in LP of binary constraint for segment0 (=zero-savings)
        int sColB;//col in LP of binary constraint for segment0 (=zero-savings)
        int sRowS;//row in LP of savings segments
        int sColS;//col in LP of segment1

        int sNumS;//number of other segments in savings model (excl. segment0)
        MatrixDouble sVecS;//vector of segment sizes (size: 1 * sNumS)

        double sAlfa;//income coefficient
        double sBeta;//squared income coefficient
        double sGamm;//household size coefficient
        double sDelt;//constant term

        int fNumS;//number of expenditure segments
        int fRowS;//row in LP of expenditure segments
        int fColS;//col in LP of expenditure segment1
        int fRowH;//row in LP of household size coefficient
        int fColH;//col in LP of household size coefficient

        double fAlfa;//expenditure coefficient
        MatrixDouble fBeta;//vector of income coefficients (size: 1 * fNumS)
        double fGamm;//household size coefficient

        int iNumF;//number of food items
        int iNumS;//number of expenditure segments
        int iRowH;//row in LP of household size coefficient1
        int iColH;//col in LP of household size coefficients
        int iRowP;//row in LP of price coefficient1
        int iColP;//col in LP of price coefficients
        int iRowS;//row in LP of expenditure segment1
        int iColS;//col in LP of expenditure segment1

        MatrixDouble iAlfa;//vector of expenditure coefficients (size: 1* iNumF)
        MatrixDouble iBeta;//MatrixDouble of period-specific expenditures (numRounds * iNumS)
        MatrixDouble iGamm;//MatrixDouble of price coefficients (size: numRounds * iNumF)
        MatrixDouble iDelt;//vector of household size coefficients (size: 1 * iNumF)

        int  pNumG;//number of goods
        int* pRows;//row indices of prices of consumption goods in LP
        int* pCols;//column indices of prices of consumption goods in LP
        MatrixDouble pMatP;//MatrixDouble of price coefficients (size: numRounds * pNumG)

        int numNtr;
};


#endif

---