00001
00002
00003
00004
00005
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
00063
00064
00065
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