src/de/pik/lagom/generic/initvalues/SectorInitValues.java

00001 
00002 // Copyright 2010 by Carlo Jaeger, Antoine Mandel, Steffen Fuerst and European Climate Forum
00003 // Licensed under the Open Software License version 3.0
00004 // See the file "License-OSL-3.0.txt" in the distribution for more information
00005 // The License text can be also found under http://www.opensource.org/licenses/osl-3.0.php
00007 
00008 package de.pik.lagom.generic.initvalues;
00009 
00010 import java.io.Serializable;
00011 import java.util.List;
00012 
00013 import de.pik.lagom.annotations.Description;
00014 import de.pik.lagom.annotations.InitValue;
00015 import de.pik.lagom.annotations.MatrixDescription;
00016 import de.pik.lagom.annotations.NameInUI;
00017 import de.pik.lagom.annotations.Variability;
00018 import static de.pik.lagom.annotations.Variability.*;
00019 import de.pik.lagom.exceptions.ValueValidationException;
00020 import de.pik.lagom.toolbox.ArrayTools;
00021 import de.pik.lagom.toolbox.io.initvalues.InitValuesManager;
00022 import de.pik.lagom.toolbox.math.FloatMath;
00023 
00025 @Variability(SIMULATION)
00026 public class SectorInitValues extends InitValuesWithSectors implements Serializable {
00028   private final FirmInitValues firmInitValues;
00030   private final ImportExportInitValues importExportInitValues;
00031 
00033   @InitValue(inspector = "Data", posInInspector = 100, exclude ="defaultInputOutputCirculating")
00034   @MatrixDescription(rowNames = "getSectorNames", columnNames = "getSectorNames")
00035   @NameInUI("Circulating Capital Input Output Table")
00036   @Description("The input output table for circulating capital " +
00037       "(the flow is from rows to columns)")
00038   private double[][] inputOutputCirculatingMatrix;
00041   @InitValue(readOnly = true, exclude = "inputOutputCirculatingMatrix")
00042   private double defaultInputOutputCirculating = 1d;
00043 
00045   @InitValue(inspector = "Data", posInInspector = 200, exclude = "defaultInputOutputFixed")
00046   @MatrixDescription(rowNames = "getSectorNames", columnNames = "getSectorNames")
00047   @NameInUI("Fixed Capital Input Output Table")
00048   @Description("The input output table for fixed capital (the flow is from rows to columns)")
00049   private double[][] inputOutputFixedMatrix;
00052   @InitValue(readOnly = true, exclude = "inputOutputFixedMatrix")
00053   private double defaultInputOutputFixed = 0.2d;
00054 
00056   @InitValue(inspector = "Data", posInInspector = 101)
00057   @NameInUI("Production Elasticity of Substitution")
00058   @Description("The Elasticity of Substitution for Production")
00059   private double productionElasticity = 2;
00060 
00061 /*  *//*
00062   @InitValue(inspector = "Data", posInInspector = 101)
00063   @NameInUI("Capital Reserve Rate")
00064   @Description("The margin above current needs when investing in fixed capital.")
00065   private double capitalReserveRate = 0.25;
00066   */
00068   @InitValue(inspector = "Data")
00069   @NameInUI("Capacity utilization Rate")
00070   @Description("The rate of fixed capital utilization.")
00071   private double capacityUtilizationRate = 0.8d;
00072   
00073   
00076   @InitValue(inspector = "Data", posInInspector = 500, exclude = "defaultGrowthRate")
00077   @MatrixDescription(rowNames = "getSectorNames")
00078   @NameInUI("Growth Rate")
00079   @Description("The initial (\"real world\") growth rates. One can either initialize the " +
00080       "growth rates or the depreciation rates.")
00081   private double[] growthRateArray;
00084   @InitValue(readOnly = true, exclude = "growthRateArray")
00085   private double defaultGrowthRate = 0.04d;
00086 
00088   @InitValue(inspector = "Data", posInInspector = 300, exclude = "defaultCapitalStock")
00089   @MatrixDescription(rowNames = "getSectorNames", columnNames = "getSectorNames")
00090   @NameInUI("Capital Stock Table")
00091   @Description("The capital stock (as a sum over all firms capital stock)")
00092   private double[][] capitalStockMatrix;
00095   @InitValue(readOnly = true, exclude = "capitalStockMatrix")
00096   private double defaultCapitalStock = 5d;
00097 
00099   @InitValue(inspector = "Data", posInInspector = 401, 
00100              exclude = "defaultInventoryDepreciationRate")
00101   @MatrixDescription(rowNames = "getSectorNames")
00102   @NameInUI("Inventory Deprication Rate")
00103   @Description("The inventory depreciation rate, separated for each sector")
00104   private double[] inventoryDepreciationRateArray;
00107   @InitValue(readOnly = true, exclude = "inventoryDepreciationRateArray")
00108   private double defaultInventoryDepreciationRate = 0.05d;
00109 
00112   @InitValue(inspector = "Data", posInInspector = 500, exclude = "defaultProduction")
00113   @MatrixDescription(rowNames = "getSectorNames")
00114   @NameInUI("Production")
00115   @Description("The initial production (as a sum over all firms in the sector)")
00116   private double[] productionArray;
00119   @InitValue(readOnly = true, exclude = "productionArray")
00120   private double defaultProduction = 20d;
00121 
00123   @InitValue(inspector = "Data", posInInspector = 600,
00124              exclude = "defaultConsumption")
00125   @MatrixDescription(rowNames = "getSectorNames")
00126   @NameInUI("Final Consumption Households")
00127   @Description("The initial consumption (as a sum over all households)")
00128   private double[] consumptionArray;
00131   @InitValue(readOnly = true, exclude = "consumptionArray")
00132   private double defaultConsumption = 8d;
00133 
00135   @InitValue(inspector = "Data", posInInspector = 700, exclude = "defaultLaborProductivity")
00136   @MatrixDescription(rowNames = "getSectorNames")
00137   @NameInUI("Labor Productivity")
00138   @Description("The initial labor productivity")
00139   private double[] laborProductivityArray;
00142   @InitValue(readOnly = true, exclude = "laborProductivityArray")
00143   private double defaultLaborProductivity = 1d;
00144 
00154   @InitValue(inspector = "Emissions", posInInspector = 100, exclude = "defaultUnitInPetaJoule")
00155   @MatrixDescription(rowNames = "getSectorNames")
00156   @NameInUI("Petajoule Equivalent")
00157   @Description("The value describe how many 'real world' Petajoule equals 1 unit of 'model' " +
00158       "energy (Should be zero for all non-energy sectors)")
00159   private double[] unitInPetaJouleArray;
00162   @InitValue(readOnly = true, exclude = "unitInPetaJouleArray")
00163   private double defaultUnitInPetaJoule = 0d;
00164 
00169   @InitValue(inspector = "Emissions", posInInspector = 200, exclude = "defaultCiCoefMin")
00170   @MatrixDescription(rowNames = "getSectorNames")
00171   @NameInUI("Carbon Intensity Lower Limit")
00172   @Description("The carbon intensity coefficient is calculated as a logistic function: " +
00173       "Upper - ((Upper - Lower) / (1 + exp(-Slope(x - TurningYear))))")
00174   private double[] ciCoefMinArray;
00177   @InitValue(readOnly = true, exclude = "ciCoefMinArray")
00178   private double defaultCiCoefMin = 0.0589d;
00179 
00181   @InitValue(inspector = "Emissions", posInInspector = 201, exclude = "defaultCiCoefMax")
00182   @MatrixDescription(rowNames = "getSectorNames")
00183   @NameInUI("Carbon Intensity Upper Limit")
00184   @Description("The carbon intensity coefficient is calculated as a logistic function: " +
00185       "Upper - ((Upper - Lower) / (1 + exp(-Slope(x - TurningYear))))")
00186   private double[] ciCoefMaxArray;
00189   @InitValue(readOnly = true, exclude = "ciCoefMaxArray")
00190   private double defaultCiCoefMax = 0.0756d;
00191 
00193   @InitValue(inspector = "Emissions", posInInspector = 202, exclude = "defaultCiCoefTurningYear")
00194   @MatrixDescription(rowNames = "getSectorNames")
00195   @NameInUI("Carbon Intensity Turning Year")
00196   @Description("The carbon intensity coefficient is calculated as a logistic function: " +
00197       "Upper - ((Upper - Lower) / (1 + exp(-Slope(x - TurningYear))))")
00198   private double[] ciCoefTurningYearArray;
00201   @InitValue(readOnly = true, exclude = "ciCoefTurningYearArray")
00202   private double defaultCiCoefTurningYear= 1982.d;
00203 
00205   @InitValue(inspector = "Emissions", posInInspector = 203, exclude = "defaultCiCoefSlope")
00206   @MatrixDescription(rowNames = "getSectorNames")
00207   @NameInUI("Carbon Intensity Slope")
00208   @Description("The carbon intensity coefficient is calculated as a logistic function: " +
00209       "Upper - ((Upper - Lower) / (1 + exp(-Slope(x - TurningYear))))")
00210   private double[] ciCoefSlopeArray;
00213   @InitValue(readOnly = true, exclude = "ciCoefSlopeArray")
00214   private double defaultCiCoefSlope = 0.2d;
00215 
00217   @InitValue(inspector = "Data", posInInspector = 800, exclude = "defaultCalibrationsNumWorker")
00218   @MatrixDescription(rowNames = "getSectorNames")
00219   @NameInUI("Number of Employees")
00220   @Description("The 'real world' number of workers per sector")
00221   private double[] calibrationNumWorkersArray;
00224   @InitValue(readOnly = true, exclude = "calibrationNumWorkersArray")
00225   private double defaultCalibrationsNumWorker = 1d;
00226 
00228   @InitValue(inspector = "Data", posInInspector = 901)
00229   @MatrixDescription(rowNames = "getSectorNames")
00230   @NameInUI("Total Wages Paid")
00231   @Description("The sum off wages paid (only used, when Sector Specific Wages are enabled)")
00232   private double[] wagesArray;
00233 
00235   @InitValue(priority = 50, inspector = "Data", posInInspector = 0)
00236   @MatrixDescription(rowNames = "getSectorNames")
00237   @NameInUI("Sector Names")
00238   @Description("The sector names, only used for the UI")
00239   private String[] nameArray;
00240 
00243   @InitValue(inspector = "Sector", posInInspector = 500)
00244   @NameInUI("Imitation Rate")
00245   @Description("The fraction of firms that will imitate the behaviour from others firms")
00246   private double firmReplacementRate = 0.25d;
00247   
00249   @InitValue(inspector = "Sector", posInInspector = 400)
00250   @NameInUI("Peers Sampling Rate")
00251   @Description("The fraction of firms that will be observed for imitation")
00252   private double firmSamplingRate = 0.25d;
00253   
00255   @InitValue(inspector = "Sector", posInInspector = 0)
00256   @NameInUI("Firms Entry Rate")
00257   @Description("When the average profit rate is higher then the Startup Profit Rate, then " +
00258       "the number of firms in the sector will be increased by (Startup Factor * 100) percent")
00259   private double firmCreationRate = 0.05d;
00260 
00262   @InitValue(inspector = "Sector", posInInspector = 100)
00263   @NameInUI("Firms Exit Rate")
00264   @Description("When the average profit rate is higher then the Bankrupt Profit Rate, then " +
00265       "the number of firms in the sector will be decreased by (Bankrupt Factor * 100) percent")
00266   private double firmDestructionRate = 0.05d;
00267 
00270   @InitValue(inspector = "Firm", posInInspector = 10010)
00271   @NameInUI("Minimal Number of Firms per Sector")
00272   @Description("Firms can't go bankrupt if the number of firms in the sector equals already " +
00273       "the Minimal Number of Firms per Sector")
00274   private int numFirmMin = 1;
00275 
00276   @InitValue(inspector = "Firm", posInInspector = 9)
00277   @NameInUI("Variation of Labor Input Coefficient")
00278   @Description("The labor input coefficients are variated maximal by this factor")
00279   private double initialLaborCoeffMutation = 0.05d;
00280 
00281   @InitValue(inspector = "Firm", posInInspector = 8)
00282   @NameInUI("Variation of Circulating Input Coeff.")
00283   @Description("The circulating capital input coefficients are variated maximal by this factor")
00284   private double initialCirculatingInputCoeffMutation = 0.05d;
00285 
00286   @InitValue(inspector = "Firm", posInInspector = 7)
00287   @NameInUI("Variation of Fixed Input Coefficients")
00288   @Description("The fixed capital input coefficients are variated maximal by this factor")
00289   private double initialFixedInputCoeffMutation = 0.05d;
00290 
00293   @InitValue(inspector = "Sector", posInInspector = 200, exclude = "defaultRiskPremium")
00294   @MatrixDescription(rowNames = "getSectorNames")
00295   @NameInUI("Risk Premium")
00296   @Description("The risk premium an investor requests to invest in the sector. That is a firm can be created in" +
00297       "the sector only if the profit rate is greater than the interest rate + the risk premium")
00298   private double[]riskPremiumArray;
00301   @InitValue(readOnly = true, exclude = "growthRateArray")
00302   private double defaultRiskPremium = 0.0d;
00303   
00305   @SuppressWarnings("hiding")
00306   @InitValue(inspector = "Foundation", posInInspector = 1, required = true, priority = 100)
00307   @NameInUI("Number of Sectors")
00308   @Description("The number of sectors")
00309   private int numSectors = InitValuesWithSectors.numSectors;
00310 
00311   SectorInitValues(InitValuesManager pIVM) {
00312     super(pIVM);
00313     firmInitValues = new FirmInitValues(pIVM);
00314     importExportInitValues = new ImportExportInitValues(pIVM);
00315   }
00316 
00317   @Override
00318   public void setArrayValues() {
00319     setDefaultInputOutputCirculating(defaultInputOutputCirculating);
00320     setDefaultInputOutputFixed(defaultInputOutputFixed);
00321     setDefaultCapitalStock(defaultCapitalStock);
00322 
00323     setDefaultInventoryDepreciationRate(defaultInventoryDepreciationRate);
00324 
00325     setDefaultProduction(defaultProduction);
00326     setDefaultConsumption(defaultConsumption);
00327     setDefaultGrowthRate(defaultGrowthRate);
00328 
00329     setDefaultLaborProductivity(defaultLaborProductivity);
00330     setDefaultRiskPremium(defaultRiskPremium);
00331 
00332     setDefaultCalibrationsNumWorker(defaultCalibrationsNumWorker);
00333 
00334     setDefaultUnitInPetaJoule(defaultUnitInPetaJoule);
00335 
00336     setDefaultCiCoefMin(defaultCiCoefMin);
00337     setDefaultCiCoefMax(defaultCiCoefMax);
00338     setDefaultCiCoefTurningYear(defaultCiCoefTurningYear);
00339     setDefaultCiCoefSlope(defaultCiCoefSlope);
00340 
00341     nameArray = new String[numSectors];
00342     wagesArray = new double[numSectors];
00343     for (int iSector = 0; iSector < numSectors; iSector++) {
00344       nameArray[iSector] = new String("" + (iSector + 1));
00345       wagesArray[iSector] = 1.d;
00346     }
00347 
00348   }
00349 
00350   @Override
00351   public void validate(List<String> pWarnings) throws ValueValidationException {
00352     for (int iSector = 0; iSector < numSectors; iSector++) {
00353       if (!(FloatMath.lowerOrApproxEqual(
00354           consumptionArray[iSector]
00355                            + ArrayTools.sumDouble(inputOutputFixedMatrix[iSector])
00356                            + ArrayTools.sumDouble(inputOutputCirculatingMatrix[iSector]),
00357                            productionArray[iSector]))) {
00358         pWarnings.add("Production in Sector " + nameArray[iSector] + " is too low.");
00359       }
00360     }
00361 
00362     for (int iRow = 0; iRow < numSectors; iRow++) {
00363       for (int iColumn = 0; iColumn < numSectors; iColumn++) {
00364         if (inputOutputFixedMatrix[iRow][iColumn] > capitalStockMatrix[iRow][iColumn]) {
00365           pWarnings.add("inputOutputFixed[" + iRow + "][" + iColumn + "]" +
00366             " is higher then capitalStock[" + iRow + "][" + iColumn + "], " +
00367             "which can be only the case when the depreciation rate is higher then 100%.");
00368         }
00369       }
00370     }
00371 
00372 
00373     if (wagesArray.length != numSectors) {
00374       throw new ValueValidationException("wagesArray size doesn't match number of sectors.");
00375     }
00376   }
00377 
00378   public FirmInitValues firmInitValues() {
00379     return firmInitValues;
00380   }
00381 
00382   public ImportExportInitValues importExportInitValues() {
00383     return importExportInitValues;
00384   }
00385 
00386   public int getNumSectors() {
00387     return numSectors;
00388   }
00389 
00390   public void setNumSectors(int pNumSectors) {
00391     if (numSectors != pNumSectors) {
00392       numSectors = pNumSectors;
00393       ((InitValuesManagerWithSectors) initValuesManager).numSectorsChanged(pNumSectors);
00394     }
00395 
00396     wagesArray = new double[numSectors];
00397   }
00398 
00399   public double getDefaultInventoryDepreciationRate() {
00400     return ArrayTools.allElementsHaveSameValue(inventoryDepreciationRateArray);
00401   }
00402 
00403   public void setDefaultInventoryDepreciationRate(double pNewValue) {
00404     defaultInventoryDepreciationRate = pNewValue;
00405     inventoryDepreciationRateArray = createArray(pNewValue);
00406   }
00407 
00408   public double[] getInventoryDepreciationRateArray() {
00409     return inventoryDepreciationRateArray;
00410   }
00411 
00412   public void setInventoryDepreciationRateArray(double[] pInventoryDepreciationRateArray) {
00413     inventoryDepreciationRateArray = pInventoryDepreciationRateArray;
00414     defaultInventoryDepreciationRate =
00415       checkForDefault(defaultInventoryDepreciationRate, pInventoryDepreciationRateArray);
00416   }
00417 
00418   public double getDefaultProduction() {
00419     return ArrayTools.allElementsHaveSameValue(productionArray);
00420   }
00421 
00422   public void setDefaultProduction(double pNewValue) {
00423     defaultProduction = pNewValue;
00424     productionArray = createArray(pNewValue);
00425   }
00426 
00427   public double[] getProductionArray() {
00428     return productionArray;
00429   }
00430 
00431   public void setProductionArray(double[] pProductionArray) {
00432     productionArray = pProductionArray;
00433     defaultProduction = checkForDefault(defaultProduction, pProductionArray);
00434   }
00435 
00436   public double getDefaultConsumption() {
00437     return ArrayTools.allElementsHaveSameValue(consumptionArray);
00438   }
00439 
00440   public void setDefaultConsumption(double pNewValue) {
00441     defaultConsumption = pNewValue;
00442     consumptionArray = createArray(pNewValue);
00443   }
00444 
00445   public double[] getConsumptionArray() {
00446     return consumptionArray;
00447   }
00448 
00449   public void setConsumptionArray(double[] pConsumptionArray) {
00450     consumptionArray = pConsumptionArray;
00451     defaultConsumption = checkForDefault(defaultConsumption, pConsumptionArray);
00452   }
00453 
00454   public double getDefaultLaborProductivity() {
00455     return ArrayTools.allElementsHaveSameValue(laborProductivityArray);
00456   }
00457 
00458   public void setDefaultLaborProductivity(double pNewValue) {
00459     defaultLaborProductivity = pNewValue;
00460     laborProductivityArray = createArray(pNewValue);
00461   }
00462 
00463   public double[] getLaborProductivityArray() {
00464     return laborProductivityArray;
00465   }
00466 
00467   public void setLaborProductivityArray(double[] pLaborProductivityArray) {
00468     laborProductivityArray = pLaborProductivityArray;
00469     defaultLaborProductivity = checkForDefault(defaultLaborProductivity, 
00470                                                pLaborProductivityArray);
00471   }
00472 
00473   public double getDefaultCalibrationsNumWorker() {
00474     return ArrayTools.allElementsHaveSameValue(calibrationNumWorkersArray);
00475   }
00476 
00477   public void setDefaultCalibrationsNumWorker(double pDefaultCalibrationsNumWorker) {
00478     defaultCalibrationsNumWorker = pDefaultCalibrationsNumWorker;
00479     calibrationNumWorkersArray = createArray(pDefaultCalibrationsNumWorker);
00480   }
00481 
00482   public double[] getCalibrationNumWorkersArray() {
00483     return calibrationNumWorkersArray;
00484   }
00485 
00486   public void setCalibrationNumWorkersArray(double[] pCalibrationNumWorkersArray) {
00487     calibrationNumWorkersArray = pCalibrationNumWorkersArray;
00488     defaultCalibrationsNumWorker =
00489       checkForDefault(defaultCalibrationsNumWorker, pCalibrationNumWorkersArray);
00490   }
00491 
00492   public double getFirmReplacementRate() {
00493     return firmReplacementRate;
00494   }
00495 
00496   public void setFirmReplacementRate(double pFirmReplacementRate) {
00497     firmReplacementRate = pFirmReplacementRate;
00498   }
00499 
00500   public int getNumFirmMin() {
00501     return numFirmMin;
00502   }
00503 
00504   public void setNumFirmMin(int pNumFirmMin) {
00505     numFirmMin = pNumFirmMin;
00506   }
00507 
00508   public double getDefaultCapitalStock() {
00509     return ArrayTools.allElementsHaveSameValue(capitalStockMatrix);
00510   }
00511 
00512   public void setDefaultCapitalStock(double pNewValue) {
00513     defaultCapitalStock = pNewValue;
00514     capitalStockMatrix = createMatrix(pNewValue);
00515   }
00516 
00517   public double[][] getCapitalStockMatrix() {
00518     return capitalStockMatrix;
00519   }
00520 
00521   public void setCapitalStockMatrix(double[][] pCapitalStockMatrix) {
00522     capitalStockMatrix = pCapitalStockMatrix;
00523     defaultCapitalStock = checkForDefault(defaultCapitalStock, pCapitalStockMatrix);
00524   }
00525 
00526   public double getDefaultInputOutputCirculating() {
00527     return ArrayTools.allElementsHaveSameValue(inputOutputCirculatingMatrix);
00528   }
00529 
00530   public void setDefaultInputOutputCirculating(double pNewValue) {
00531     defaultInputOutputCirculating = pNewValue;
00532     inputOutputCirculatingMatrix = createMatrix(pNewValue);
00533   }
00534 
00535   public double[][] getInputOutputCirculatingMatrix() {
00536     return inputOutputCirculatingMatrix;
00537   }
00538 
00539   public void setInputOutputCirculatingMatrix(double[][] pInputOutputCirculatingMatrix) {
00540     inputOutputCirculatingMatrix = pInputOutputCirculatingMatrix;
00541     defaultInputOutputCirculating =
00542       checkForDefault(defaultInputOutputCirculating, pInputOutputCirculatingMatrix);
00543   }
00544 
00545   public double getDefaultInputOutputFixed() {
00546     return ArrayTools.allElementsHaveSameValue(inputOutputFixedMatrix);
00547   }
00548 
00549   public void setDefaultInputOutputFixed(double pNewValue) {
00550     defaultInputOutputFixed = pNewValue;
00551     inputOutputFixedMatrix = createMatrix(pNewValue);
00552   }
00553 
00554   public double[][] getInputOutputFixedMatrix() {
00555     return inputOutputFixedMatrix;
00556   }
00557 
00558   public void setInputOutputFixedMatrix(double[][] pInputOutputFixedMatrix) {
00559     inputOutputFixedMatrix = pInputOutputFixedMatrix;
00560     defaultInputOutputFixed = checkForDefault(defaultInputOutputFixed, pInputOutputFixedMatrix);
00561   }
00562 
00563   public double getDefaultUnitInPetaJoule() {
00564     return ArrayTools.allElementsHaveSameValue(unitInPetaJouleArray);
00565   }
00566 
00567   public void setDefaultUnitInPetaJoule(double pUnitInPetaJoule) {
00568     defaultUnitInPetaJoule =  pUnitInPetaJoule;
00569     unitInPetaJouleArray = createArray(pUnitInPetaJoule);
00570   }
00571 
00572   public double[] getUnitInPetaJouleArray() {
00573     return unitInPetaJouleArray;
00574   }
00575 
00576   public void setUnitInPetaJouleArray(double[] pUnitInPetaJouleArray) {
00577     unitInPetaJouleArray = pUnitInPetaJouleArray;
00578     defaultUnitInPetaJoule = checkForDefault(defaultUnitInPetaJoule, pUnitInPetaJouleArray);
00579   }
00580 
00581   public double getDefaultCiCoefMin() {
00582     return ArrayTools.allElementsHaveSameValue(ciCoefMinArray);
00583   }
00584 
00585   public void setDefaultCiCoefMin(double pDefault) {
00586     defaultCiCoefMin = pDefault;
00587     ciCoefMinArray = createArray(defaultCiCoefMin);
00588   }
00589 
00590   public double[] getCiCoefMinArray() {
00591     return ciCoefMinArray;
00592   }
00593 
00594   public void setCiCoefMinArray(double[] pCiCoefMinArray) {
00595     ciCoefMinArray = pCiCoefMinArray;
00596     defaultCiCoefMin = checkForDefault(defaultCiCoefMin, pCiCoefMinArray);
00597   }
00598 
00599   public double getDefaultCiCoefMax() {
00600     return ArrayTools.allElementsHaveSameValue(ciCoefMaxArray);
00601   }
00602 
00603   public void setDefaultCiCoefMax(double pDefault) {
00604     defaultCiCoefMax = pDefault;
00605     ciCoefMaxArray = createArray(defaultCiCoefMax);
00606   }
00607 
00608   public double[] getCiCoefMaxArray() {
00609     return ciCoefMaxArray;
00610   }
00611 
00612   public void setCiCoefMaxArray(double[] pCiCoefMaxArray) {
00613     ciCoefMaxArray = pCiCoefMaxArray;
00614     defaultCiCoefMax = checkForDefault(defaultCiCoefMax, pCiCoefMaxArray);
00615   }
00616 
00617   public double getDefaultCiCoefTurningYear() {
00618     return ArrayTools.allElementsHaveSameValue(ciCoefTurningYearArray);
00619   }
00620 
00621   public void setDefaultCiCoefTurningYear(double pDefault) {
00622     defaultCiCoefTurningYear = pDefault;
00623     ciCoefTurningYearArray = createArray(defaultCiCoefTurningYear);
00624   }
00625 
00626   public double[] getCiCoefTurningYearArray() {
00627     return ciCoefTurningYearArray;
00628   }
00629 
00630   public void setCiCoefTurningYearArray(double[] pCiCoefTurningYearArray) {
00631     ciCoefTurningYearArray = pCiCoefTurningYearArray;
00632     defaultCiCoefTurningYear = checkForDefault(defaultCiCoefTurningYear, 
00633                                                pCiCoefTurningYearArray);
00634   }
00635 
00636   public double getDefaultCiCoefSlope() {
00637     return ArrayTools.allElementsHaveSameValue(ciCoefSlopeArray);
00638   }
00639 
00640   public void setDefaultCiCoefSlope(double pDefault) {
00641     defaultCiCoefSlope = pDefault;
00642     ciCoefSlopeArray = createArray(defaultCiCoefSlope);
00643   }
00644 
00645   public double[] getCiCoefSlopeArray() {
00646     return ciCoefSlopeArray;
00647   }
00648 
00649   public void setCiCoefSlopeArray(double[] pCiCoefSlopeArray) {
00650     ciCoefSlopeArray = pCiCoefSlopeArray;
00651     defaultCiCoefSlope = checkForDefault(defaultCiCoefSlope, pCiCoefSlopeArray);
00652   }
00653 
00654   public void setNameArray(String[] pNameArray) {
00655     nameArray = pNameArray;
00656   }
00657 
00658   public String[] getNameArray() {
00659     return nameArray;
00660   }
00661 
00662   public double getFirmCreationRate() {
00663     return firmCreationRate;
00664   }
00665 
00666   public double getFirmDestructionRate() {
00667     return firmDestructionRate;
00668   }
00669 
00670   public void setFirmCreationRate(double pFirmCreationRate) {
00671     firmCreationRate = pFirmCreationRate;
00672   }
00673 
00674   public void setFirmDestructionRate(double pFirmDestructionRate) {
00675     firmDestructionRate = pFirmDestructionRate;
00676   }
00677 
00678   public double[] getWagesArray() {
00679     return wagesArray;
00680   }
00681 
00682   public void setWagesArray(double[] pWagesArray) {
00683     wagesArray = pWagesArray;
00684   }
00685 
00686   public double getDefaultGrowthRate() {
00687     return ArrayTools.allElementsHaveSameValue(growthRateArray);
00688   }
00689 
00690   public void setDefaultGrowthRate(double pNewValue) {
00691     defaultGrowthRate = pNewValue;
00692     growthRateArray = createArray(pNewValue);
00693   }
00694 
00695   public double[] getGrowthRateArray() {
00696     return growthRateArray;
00697   }
00698 
00699   public void setGrowthRateArray(double[] pGrowthRateArray) {
00700     growthRateArray = pGrowthRateArray;
00701     defaultProduction = checkForDefault(defaultGrowthRate, pGrowthRateArray);
00702   }
00703 
00704   public double getInitialCirculatingInputCoeffMutation() {
00705     return initialCirculatingInputCoeffMutation;
00706   }
00707 
00708   public double getInitialFixedInputCoeffMutation() {
00709     return initialFixedInputCoeffMutation;
00710   }
00711 
00712   public void setInitialCirculatingInputCoeffMutation(
00713                                                  double pInitialCirculatingInputCoeffMutation) {
00714     initialCirculatingInputCoeffMutation = pInitialCirculatingInputCoeffMutation;
00715   }
00716 
00717   public void setInitialFixedInputCoeffMutation(double pInitialFixedInputCoeffMutation) {
00718     initialFixedInputCoeffMutation = pInitialFixedInputCoeffMutation;
00719   }
00720 
00721   @Override
00722   public String[] getSectorNames() {
00723     return nameArray;
00724   }
00725 
00726   public double getInitialLaborCoeffMutation() {
00727     return initialLaborCoeffMutation;
00728   }
00729 
00730   public void setInitialLaborCoeffMutation(double pInitialLaborCoeffMutation) {
00731     initialLaborCoeffMutation = pInitialLaborCoeffMutation;
00732   }
00733 
00734   public double getProductionElasticity() {
00735     return productionElasticity;
00736   }
00737 
00738   public void setProductionElasticity(double pFirmsElasticity) {
00739     productionElasticity = pFirmsElasticity;
00740   }
00741   
00742   public double getFirmSamplingRate() {
00743     return firmSamplingRate;
00744   }
00745 
00746   public void setFirmSamplingRate(double pFirmSamplingRate) {
00747     firmSamplingRate = pFirmSamplingRate;
00748   }
00749 
00750   public double getCapacityUtilizationRate() {
00751     return capacityUtilizationRate;
00752   }
00753 
00754   public void setCapacityUtilizationRate(double pCapacityUtilizationRate) {
00755     capacityUtilizationRate = pCapacityUtilizationRate;
00756   }
00757 
00758   public void setDefaultRiskPremium(double pNewValue) {
00759     defaultRiskPremium = pNewValue;
00760     riskPremiumArray = createArray(pNewValue);
00761   }
00762 
00763   public double[] getRiskPremiumArray() {
00764     return riskPremiumArray;
00765   }
00766 
00767   public void setRiskPremiumArray(double[] pLaborProductivityArray) {
00768     riskPremiumArray = pLaborProductivityArray;
00769     defaultRiskPremium = checkForDefault(defaultRiskPremium, 
00770                                                pLaborProductivityArray);
00771   }
00772 
00773   public double getDefaultRiskPremium() {
00774     return defaultRiskPremium;
00775   }
00776 
00777 }
00778 
00780 // EOF

Generated on Tue Sep 14 11:11:48 2010 for lagom_generiC by  doxygen 1.5.4