From 974c191384b8ffe505ce57de1992c1fa2e7dd333 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 14:44:48 +0000 Subject: [PATCH 01/23] de-finalise input directory and input filenames --- src/main/java/simpaths/data/Parameters.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index be784c2ed..60b8299b6 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -288,14 +288,14 @@ else if(numberOfChildren <= 5) { public static int maleMaxAgeSick = Integer.MIN_VALUE; //For use with EUROMOD and h2 input database construction - public static final String WORKING_DIRECTORY = System.getProperty("user.dir"); - public static final String INPUT_DIRECTORY = WORKING_DIRECTORY + File.separator + "input" + File.separator; + public static String WORKING_DIRECTORY = System.getProperty("user.dir"); + public static String INPUT_DIRECTORY = WORKING_DIRECTORY + File.separator + "input" + File.separator; public static boolean trainingFlag = false; - public static final String INPUT_DIRECTORY_INITIAL_POPULATIONS = INPUT_DIRECTORY + "InitialPopulations" + File.separator; //Path to directory containing initial population for each year - public static final String EUROMOD_OUTPUT_DIRECTORY = INPUT_DIRECTORY + "EUROMODoutput" + File.separator; - public static final String EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; - public static final String EUROMODpolicyScheduleFilename = "EUROMODpolicySchedule"; - public static final String DatabaseCountryYearFilename = "DatabaseCountryYear"; + public static String INPUT_DIRECTORY_INITIAL_POPULATIONS = INPUT_DIRECTORY + "InitialPopulations" + File.separator; //Path to directory containing initial population for each year + public static String EUROMOD_OUTPUT_DIRECTORY = INPUT_DIRECTORY + "EUROMODoutput" + File.separator; + public static String EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; + public static String EUROMODpolicyScheduleFilename = "EUROMODpolicySchedule"; + public static String DatabaseCountryYearFilename = "DatabaseCountryYear"; //Headings in Excel file of EUROMOD policy scenarios public static final String EUROMODpolicyScheduleHeadingFilename = "Filename"; From 8d82eef81d85b95823387db2a3d4cdeccd69afde Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 14:50:22 +0000 Subject: [PATCH 02/23] getters and setters for amendable input dirs --- src/main/java/simpaths/data/Parameters.java | 29 ++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index 60b8299b6..efb3e39db 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -3273,4 +3273,31 @@ private static void safeDelete(String filePath) { throw e; } } -} \ No newline at end of file + public static void setWorkingDirectory(String workingDirectory) { + WORKING_DIRECTORY = workingDirectory; + INPUT_DIRECTORY = WORKING_DIRECTORY + File.separator + "input" + File.separator; + INPUT_DIRECTORY_INITIAL_POPULATIONS = INPUT_DIRECTORY + "InitialPopulations" + File.separator; //Path to directory containing initial population for each year + EUROMOD_OUTPUT_DIRECTORY = INPUT_DIRECTORY + "EUROMODoutput" + File.separator; + EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; + } + + public static void setInputDirectory(String inputDirectory) { + INPUT_DIRECTORY = inputDirectory; + INPUT_DIRECTORY_INITIAL_POPULATIONS = INPUT_DIRECTORY + "InitialPopulations" + File.separator; //Path to directory containing initial population for each year + EUROMOD_OUTPUT_DIRECTORY = INPUT_DIRECTORY + "EUROMODoutput" + File.separator; + EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; + } + public static void setInputDirectoryInitialPopulations(String inputDirectoryInitialPopulations) { + + INPUT_DIRECTORY_INITIAL_POPULATIONS = inputDirectoryInitialPopulations; + } + + public static void setEuromodOutputDirectory(String euromodOutputDirectory) { + EUROMOD_OUTPUT_DIRECTORY = euromodOutputDirectory; + EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; + } + + public static String getInputDirectory() { + return INPUT_DIRECTORY; + } +} From 0204764a3715ed87b8291c8c36da97ca258bb1e0 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 14:54:55 +0000 Subject: [PATCH 03/23] replace all mentions in Parameters.java of input with input dir getter --- src/main/java/simpaths/data/Parameters.java | 332 ++++++++++---------- 1 file changed, 166 insertions(+), 166 deletions(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index efb3e39db..f4b8ff2fa 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -830,10 +830,10 @@ public static void loadParameters(Country country, int maxAgeModel, boolean enab disposableIncomeFromLabourInnov = disposableIncomeFromLabourInnov1; // unemploymentRatesByRegion = new LinkedHashMap<>(); -// unemploymentRates = ExcelAssistant.loadCoefficientMap("input/scenario_unemploymentRates.xlsx", countryString, 1, 46); - fixedRetireAge = ExcelAssistant.loadCoefficientMap("input/scenario_retirementAgeFixed.xlsx", countryString, 1, 2); +// unemploymentRates = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "scenario_unemploymentRates.xlsx", countryString, 1, 46); + fixedRetireAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "scenario_retirementAgeFixed.xlsx", countryString, 1, 2); /* - rawProbSick = ExcelAssistant.loadCoefficientMap("input/scenario_probSick.xls", country.toString(), 2, 1); + rawProbSick = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "scenario_probSick.xls", country.toString(), 2, 1); for (Object o: rawProbSick.keySet()) { MultiKey mk = (MultiKey)o; int age = ((Number)mk.getKey(1)).intValue(); @@ -857,46 +857,46 @@ public static void loadParameters(Country country, int maxAgeModel, boolean enab */ // alignment parameters - populationProjections = ExcelAssistant.loadCoefficientMap("input/align_popProjections.xlsx", countryString, 3, 110); + populationProjections = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "align_popProjections.xlsx", countryString, 3, 110); setMapBounds(MapBounds.Population, countryString); //Alignment of education levels - projectionsHighEdu = ExcelAssistant.loadCoefficientMap("input/align_educLevel.xlsx", countryString + "_High", 1, 2); - projectionsLowEdu = ExcelAssistant.loadCoefficientMap("input/align_educLevel.xlsx", countryString + "_Low", 1, 2); + projectionsHighEdu = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "align_educLevel.xlsx", countryString + "_High", 1, 2); + projectionsLowEdu = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "align_educLevel.xlsx", countryString + "_Low", 1, 2); - studentShareProjections = ExcelAssistant.loadCoefficientMap("input/align_student_under30.xlsx", countryString, 1, 40); + studentShareProjections = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "align_student_under30.xlsx", countryString, 1, 40); //Employment alignment - employmentAlignment = ExcelAssistant.loadCoefficientMap("input/align_employment.xlsx", countryString, 2, 40); + employmentAlignment = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "align_employment.xlsx", countryString, 2, 40); //Marriage types frequencies: - marriageTypesFrequency = ExcelAssistant.loadCoefficientMap("input/marriageTypes2.xlsx", countryString, 2, 1); + marriageTypesFrequency = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "marriageTypes2.xlsx", countryString, 2, 1); marriageTypesFrequencyByGenderAndRegion = new LinkedHashMap>(); //Create a map of maps to store the frequencies //Mortality rates - mortalityProbabilityByGenderAgeYear = ExcelAssistant.loadCoefficientMap("input/projections_mortality.xlsx", countryString + "_MortalityByGenderAgeYear", 2, 120); + mortalityProbabilityByGenderAgeYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "projections_mortality.xlsx", countryString + "_MortalityByGenderAgeYear", 2, 120); setMapBounds(MapBounds.Mortality, countryString); //Fertility rates: - fertilityProjectionsByYear = ExcelAssistant.loadCoefficientMap("input/projections_fertility.xlsx", countryString + "_FertilityByYear", 1, 71); + fertilityProjectionsByYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "projections_fertility.xlsx", countryString + "_FertilityByYear", 1, 71); setMapBounds(MapBounds.Fertility, countryString); //Unemployment rates - unemploymentRatesMaleGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_RatesMaleGraduates", 1, 49); + unemploymentRatesMaleGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_RatesMaleGraduates", 1, 49); setMapBounds(MapBounds.UnemploymentMaleGraduates, countryString); - unemploymentRatesMaleNonGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_RatesMaleNonGraduates", 1, 49); + unemploymentRatesMaleNonGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_RatesMaleNonGraduates", 1, 49); setMapBounds(MapBounds.UnemploymentMaleNonGraduates, countryString); - unemploymentRatesFemaleGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_RatesFemaleGraduates", 1, 49); + unemploymentRatesFemaleGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_RatesFemaleGraduates", 1, 49); setMapBounds(MapBounds.UnemploymentFemaleGraduates, countryString); - unemploymentRatesFemaleNonGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_RatesFemaleNonGraduates", 1, 49); + unemploymentRatesFemaleNonGraduatesByAgeYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_RatesFemaleNonGraduates", 1, 49); setMapBounds(MapBounds.UnemploymentFemaleNonGraduates, countryString); //RMSE - coefficientMapRMSE = ExcelAssistant.loadCoefficientMap("input/reg_RMSE.xlsx", countryString, 1, 1); + coefficientMapRMSE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_RMSE.xlsx", countryString, 1, 1); //Employments on furlough - employmentsFurloughedFull = ExcelAssistant.loadCoefficientMap("input/scenario_employments_furloughed.xlsx", countryString + "_FullFurlough", 2, 1); - employmentsFurloughedFlex = ExcelAssistant.loadCoefficientMap("input/scenario_employments_furloughed.xlsx", countryString + "_FlexibleFurlough", 2, 1); + employmentsFurloughedFull = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "scenario_employments_furloughed.xlsx", countryString + "_FullFurlough", 2, 1); + employmentsFurloughedFlex = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "scenario_employments_furloughed.xlsx", countryString + "_FlexibleFurlough", 2, 1); //Load country specific data int columnsWagesMales = -1; @@ -1147,55 +1147,55 @@ else if(country.equals(Country.UK)) { //The Raw maps contain the estimates and covariance matrices, from which we bootstrap at the start of each simulation //Heckman model employment selection - //coeffCovarianceEmploymentSelectionMales = ExcelAssistant.loadCoefficientMap("input/reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_Males", 1, columnsEmploymentSelectionMales); - coeffCovarianceEmploymentSelectionMalesE = ExcelAssistant.loadCoefficientMap("input/reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_MaleE", 1, columnsEmploymentSelectionMalesE); - coeffCovarianceEmploymentSelectionMalesNE = ExcelAssistant.loadCoefficientMap("input/reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_MaleNE", 1, columnsEmploymentSelectionMalesNE); - //coeffCovarianceEmploymentSelectionFemales = ExcelAssistant.loadCoefficientMap("input/reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_Females", 1, columnsEmploymentSelectionFemales); - coeffCovarianceEmploymentSelectionFemalesE = ExcelAssistant.loadCoefficientMap("input/reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_FemaleE", 1, columnsEmploymentSelectionFemalesE); - coeffCovarianceEmploymentSelectionFemalesNE = ExcelAssistant.loadCoefficientMap("input/reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_FemaleNE", 1, columnsEmploymentSelectionFemalesNE); + //coeffCovarianceEmploymentSelectionMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_Males", 1, columnsEmploymentSelectionMales); + coeffCovarianceEmploymentSelectionMalesE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_MaleE", 1, columnsEmploymentSelectionMalesE); + coeffCovarianceEmploymentSelectionMalesNE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_MaleNE", 1, columnsEmploymentSelectionMalesNE); + //coeffCovarianceEmploymentSelectionFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_Females", 1, columnsEmploymentSelectionFemales); + coeffCovarianceEmploymentSelectionFemalesE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_FemaleE", 1, columnsEmploymentSelectionFemalesE); + coeffCovarianceEmploymentSelectionFemalesNE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_employmentSelection.xlsx", countryString + "_EmploymentSelection_FemaleNE", 1, columnsEmploymentSelectionFemalesNE); // Wages - //coeffCovarianceWagesMales = ExcelAssistant.loadCoefficientMap("input/reg_wages.xlsx", countryString + "_Wages_Males", 1, columnsWagesMales); - coeffCovarianceWagesMalesE = ExcelAssistant.loadCoefficientMap("input/reg_wages.xlsx", countryString + "_Wages_MalesE", 1, columnsWagesMalesE); - coeffCovarianceWagesMalesNE = ExcelAssistant.loadCoefficientMap("input/reg_wages.xlsx", countryString + "_Wages_MalesNE", 1, columnsWagesMalesNE); - //coeffCovarianceWagesFemales = ExcelAssistant.loadCoefficientMap("input/reg_wages.xlsx", countryString + "_Wages_Females", 1, columnsWagesFemales); - coeffCovarianceWagesFemalesE = ExcelAssistant.loadCoefficientMap("input/reg_wages.xlsx", countryString + "_Wages_FemalesE", 1, columnsWagesFemalesE); - coeffCovarianceWagesFemalesNE = ExcelAssistant.loadCoefficientMap("input/reg_wages.xlsx", countryString + "_Wages_FemalesNE", 1, columnsWagesFemalesNE); + //coeffCovarianceWagesMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_wages.xlsx", countryString + "_Wages_Males", 1, columnsWagesMales); + coeffCovarianceWagesMalesE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_wages.xlsx", countryString + "_Wages_MalesE", 1, columnsWagesMalesE); + coeffCovarianceWagesMalesNE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_wages.xlsx", countryString + "_Wages_MalesNE", 1, columnsWagesMalesNE); + //coeffCovarianceWagesFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_wages.xlsx", countryString + "_Wages_Females", 1, columnsWagesFemales); + coeffCovarianceWagesFemalesE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_wages.xlsx", countryString + "_Wages_FemalesE", 1, columnsWagesFemalesE); + coeffCovarianceWagesFemalesNE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_wages.xlsx", countryString + "_Wages_FemalesNE", 1, columnsWagesFemalesNE); //Labour Supply coefficients from Zhechun's estimates on the EM input data - coeffLabourSupplyUtilityMales = ExcelAssistant.loadCoefficientMap("input/reg_labourSupplyUtility.xlsx", countryString + "_Single_Males", 1, columnsLabourSupplyUtilityMales); - coeffLabourSupplyUtilityFemales = ExcelAssistant.loadCoefficientMap("input/reg_labourSupplyUtility.xlsx", countryString + "_Single_Females", 1, columnsLabourSupplyUtilityFemales); - coeffLabourSupplyUtilityMalesWithDependent = ExcelAssistant.loadCoefficientMap("input/reg_labourSupplyUtility.xlsx", countryString + "_Males_With_Dep", 1, columnsLabourSupplyUtilityMalesWithDependent); - coeffLabourSupplyUtilityFemalesWithDependent = ExcelAssistant.loadCoefficientMap("input/reg_labourSupplyUtility.xlsx", countryString + "_Females_With_Dep", 1, columnsLabourSupplyUtilityFemalesWithDependent); - coeffLabourSupplyUtilityACMales = ExcelAssistant.loadCoefficientMap("input/reg_labourSupplyUtility.xlsx", countryString + "_SingleAC_Males", 1, columnsLabourSupplyUtilityACMales); - coeffLabourSupplyUtilityACFemales = ExcelAssistant.loadCoefficientMap("input/reg_labourSupplyUtility.xlsx", countryString + "_SingleAC_Females", 1, columnsLabourSupplyUtilityACFemales); - coeffLabourSupplyUtilityCouples = ExcelAssistant.loadCoefficientMap("input/reg_labourSupplyUtility.xlsx", countryString + "_Couples", 1, columnsLabourSupplyUtilityCouples); + coeffLabourSupplyUtilityMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourSupplyUtility.xlsx", countryString + "_Single_Males", 1, columnsLabourSupplyUtilityMales); + coeffLabourSupplyUtilityFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourSupplyUtility.xlsx", countryString + "_Single_Females", 1, columnsLabourSupplyUtilityFemales); + coeffLabourSupplyUtilityMalesWithDependent = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourSupplyUtility.xlsx", countryString + "_Males_With_Dep", 1, columnsLabourSupplyUtilityMalesWithDependent); + coeffLabourSupplyUtilityFemalesWithDependent = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourSupplyUtility.xlsx", countryString + "_Females_With_Dep", 1, columnsLabourSupplyUtilityFemalesWithDependent); + coeffLabourSupplyUtilityACMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourSupplyUtility.xlsx", countryString + "_SingleAC_Males", 1, columnsLabourSupplyUtilityACMales); + coeffLabourSupplyUtilityACFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourSupplyUtility.xlsx", countryString + "_SingleAC_Females", 1, columnsLabourSupplyUtilityACFemales); + coeffLabourSupplyUtilityCouples = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourSupplyUtility.xlsx", countryString + "_Couples", 1, columnsLabourSupplyUtilityCouples); // Load coefficients for Covid-19 labour supply models // Coefficients for process assigning simulated people to self-employment - coeffCovarianceC19LS_SE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_SE", 1, columnsLabourCovid19_SE); + coeffCovarianceC19LS_SE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_SE", 1, columnsLabourCovid19_SE); // Transitions from lagged state: employed - coeffC19LS_E1_NE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_E1_NE", 1, 1); - coeffC19LS_E1_SE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_E1_SE", 1, 1); - coeffC19LS_E1_FF = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_E1_FF", 1, 1); - coeffC19LS_E1_FX = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_E1_FX", 1, 1); - coeffC19LS_E1_SC = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_E1_SC", 1, 1); + coeffC19LS_E1_NE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_E1_NE", 1, 1); + coeffC19LS_E1_SE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_E1_SE", 1, 1); + coeffC19LS_E1_FF = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_E1_FF", 1, 1); + coeffC19LS_E1_FX = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_E1_FX", 1, 1); + coeffC19LS_E1_SC = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_E1_SC", 1, 1); // Transitions from lagged state: furloughed full - coeffC19LS_FF1_E = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_E", 1, 1); - coeffC19LS_FF1_FX = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_FX", 1, 1); - coeffC19LS_FF1_NE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_NE", 1, 1); - coeffC19LS_FF1_SE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_SE", 1, 1); + coeffC19LS_FF1_E = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_E", 1, 1); + coeffC19LS_FF1_FX = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_FX", 1, 1); + coeffC19LS_FF1_NE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_NE", 1, 1); + coeffC19LS_FF1_SE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FF1_SE", 1, 1); // Transitions from lagged state: furloughed flex - coeffC19LS_FX1_E = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_E", 1, 1); - coeffC19LS_FX1_FF = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_FF", 1, 1); - coeffC19LS_FX1_NE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_NE", 1, 1); - coeffC19LS_FX1_SE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_SE", 1, 1); + coeffC19LS_FX1_E = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_E", 1, 1); + coeffC19LS_FX1_FF = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_FF", 1, 1); + coeffC19LS_FX1_NE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_NE", 1, 1); + coeffC19LS_FX1_SE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_FX1_SE", 1, 1); // Transitions from lagged state: self-employed - coeffC19LS_S1_E = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_S1_E", 1, 1); - coeffC19LS_S1_NE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_S1_NE", 1, 1); + coeffC19LS_S1_E = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_S1_E", 1, 1); + coeffC19LS_S1_NE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_S1_NE", 1, 1); // Transitions from lagged state: not-employed - coeffC19LS_U1_E = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_U1_E", 1, 1); - coeffC19LS_U1_SE = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_U1_SE", 1, 1); + coeffC19LS_U1_E = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_U1_E", 1, 1); + coeffC19LS_U1_SE = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_U1_SE", 1, 1); // For multi logit regressions, put coefficients loaded below into maps coeffC19LS_E1Map = new LinkedHashMap<>(); //Add only categories from Les_transitions_E1 enum which are possible destinations for transitions from employment @@ -1226,106 +1226,106 @@ else if(country.equals(Country.UK)) { coeffC19LS_U1Map.put(Les_transitions_U1.SelfEmployed, coeffC19LS_U1_SE); // Coefficients for new working hours - coeffC19LS_E2a = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_E2a", 1, columnsLabourCovid19_2a_processes); - coeffC19LS_E2b = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_E2b", 1, columnsLabourCovid19_2a_processes); - coeffC19LS_F2a = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_F2a", 1, columnsLabourCovid19_2a_processes); - coeffC19LS_F2b = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_F2b", 1, columnsLabourCovid19_2a_processes); - coeffC19LS_F2c = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_F2c", 1, columnsLabourCovid19_2a_processes); - coeffC19LS_S2a = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_S2a", 1, columnsLabourCovid19_2a_processes); - coeffC19LS_U2a = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_U2a", 1, columnsLabourCovid19_2a_processes); + coeffC19LS_E2a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_E2a", 1, columnsLabourCovid19_2a_processes); + coeffC19LS_E2b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_E2b", 1, columnsLabourCovid19_2a_processes); + coeffC19LS_F2a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_F2a", 1, columnsLabourCovid19_2a_processes); + coeffC19LS_F2b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_F2b", 1, columnsLabourCovid19_2a_processes); + coeffC19LS_F2c = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_F2c", 1, columnsLabourCovid19_2a_processes); + coeffC19LS_S2a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_S2a", 1, columnsLabourCovid19_2a_processes); + coeffC19LS_U2a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_U2a", 1, columnsLabourCovid19_2a_processes); // Coefficients for probability of SEISS - coeffC19LS_S3 = ExcelAssistant.loadCoefficientMap("input/reg_labourCovid19.xlsx", countryString + "_C19LS_S3", 1, 1); + coeffC19LS_S3 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_labourCovid19.xlsx", countryString + "_C19LS_S3", 1, 1); //Health - coeffCovarianceHealthH1a = ExcelAssistant.loadCoefficientMap("input/reg_health.xlsx", countryString + "_H1a", 1, columnsHealthH1a); - coeffCovarianceHealthH1b = ExcelAssistant.loadCoefficientMap("input/reg_health.xlsx", countryString + "_H1b", 1, columnsHealthH1b); - coeffCovarianceHealthH2b = ExcelAssistant.loadCoefficientMap("input/reg_health.xlsx", countryString + "_H2b", 1, columnsHealthH2b); + coeffCovarianceHealthH1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health.xlsx", countryString + "_H1a", 1, columnsHealthH1a); + coeffCovarianceHealthH1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health.xlsx", countryString + "_H1b", 1, columnsHealthH1b); + coeffCovarianceHealthH2b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health.xlsx", countryString + "_H2b", 1, columnsHealthH2b); //Social care - coeffCovarianceSocialCareS1a = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S1a", 1, columnsSocialCareS1a); - coeffCovarianceSocialCareS1b = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S1b", 1, columnsSocialCareS1b); - coeffCovarianceSocialCareS2a = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2a", 1, columnsSocialCareS2a); - coeffCovarianceSocialCareS2b = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2b", 1, columnsSocialCareS2b); - coeffCovarianceSocialCareS2c = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2c", 1, columnsSocialCareS2c); - coeffCovarianceSocialCareS2d = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2d", 1, columnsSocialCareS2d); - coeffCovarianceSocialCareS2e = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2e", 1, columnsSocialCareS2e); - coeffCovarianceSocialCareS2f = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2f", 1, columnsSocialCareS2f); - coeffCovarianceSocialCareS2g = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2g", 1, columnsSocialCareS2g); - coeffCovarianceSocialCareS2h = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2h", 1, columnsSocialCareS2h); - coeffCovarianceSocialCareS2i = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2i", 1, columnsSocialCareS2i); - coeffCovarianceSocialCareS2j = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2j", 1, columnsSocialCareS2j); - coeffCovarianceSocialCareS2k = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S2k", 1, columnsSocialCareS2k); - coeffCovarianceSocialCareS3a = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S3a", 1, columnsSocialCareS3a); - coeffCovarianceSocialCareS3b = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S3b", 1, columnsSocialCareS3b); - coeffCovarianceSocialCareS3c = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S3c", 1, columnsSocialCareS3c); - coeffCovarianceSocialCareS3d = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S3d", 1, columnsSocialCareS3d); - coeffCovarianceSocialCareS3e = ExcelAssistant.loadCoefficientMap("input/reg_socialcare.xlsx", countryString + "_S3e", 1, columnsSocialCareS3e); + coeffCovarianceSocialCareS1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S1a", 1, columnsSocialCareS1a); + coeffCovarianceSocialCareS1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S1b", 1, columnsSocialCareS1b); + coeffCovarianceSocialCareS2a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2a", 1, columnsSocialCareS2a); + coeffCovarianceSocialCareS2b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2b", 1, columnsSocialCareS2b); + coeffCovarianceSocialCareS2c = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2c", 1, columnsSocialCareS2c); + coeffCovarianceSocialCareS2d = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2d", 1, columnsSocialCareS2d); + coeffCovarianceSocialCareS2e = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2e", 1, columnsSocialCareS2e); + coeffCovarianceSocialCareS2f = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2f", 1, columnsSocialCareS2f); + coeffCovarianceSocialCareS2g = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2g", 1, columnsSocialCareS2g); + coeffCovarianceSocialCareS2h = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2h", 1, columnsSocialCareS2h); + coeffCovarianceSocialCareS2i = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2i", 1, columnsSocialCareS2i); + coeffCovarianceSocialCareS2j = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2j", 1, columnsSocialCareS2j); + coeffCovarianceSocialCareS2k = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S2k", 1, columnsSocialCareS2k); + coeffCovarianceSocialCareS3a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S3a", 1, columnsSocialCareS3a); + coeffCovarianceSocialCareS3b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S3b", 1, columnsSocialCareS3b); + coeffCovarianceSocialCareS3c = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S3c", 1, columnsSocialCareS3c); + coeffCovarianceSocialCareS3d = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S3d", 1, columnsSocialCareS3d); + coeffCovarianceSocialCareS3e = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_socialcare.xlsx", countryString + "_S3e", 1, columnsSocialCareS3e); //Unemployment - coeffCovarianceUnemploymentU1a = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_U1a", 1, columnsUnemploymentU1a); - coeffCovarianceUnemploymentU1b = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_U1b", 1, columnsUnemploymentU1b); - coeffCovarianceUnemploymentU1c = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_U1c", 1, columnsUnemploymentU1c); - coeffCovarianceUnemploymentU1d = ExcelAssistant.loadCoefficientMap("input/reg_unemployment.xlsx", countryString + "_U1d", 1, columnsUnemploymentU1d); + coeffCovarianceUnemploymentU1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_U1a", 1, columnsUnemploymentU1a); + coeffCovarianceUnemploymentU1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_U1b", 1, columnsUnemploymentU1b); + coeffCovarianceUnemploymentU1c = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_U1c", 1, columnsUnemploymentU1c); + coeffCovarianceUnemploymentU1d = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_U1d", 1, columnsUnemploymentU1d); //Health mental: level and case-based - coeffCovarianceHM1Level = ExcelAssistant.loadCoefficientMap("input/reg_health_mental.xlsx", countryString + "_HM1_L", 1, columnsHealthHM1); - coeffCovarianceHM2LevelMales = ExcelAssistant.loadCoefficientMap("input/reg_health_mental.xlsx", countryString + "_HM2_Males_L", 1, columnsHealthHM2Males); - coeffCovarianceHM2LevelFemales = ExcelAssistant.loadCoefficientMap("input/reg_health_mental.xlsx", countryString + "_HM2_Females_L", 1, columnsHealthHM2Females); - coeffCovarianceHM1Case = ExcelAssistant.loadCoefficientMap("input/reg_health_mental.xlsx", countryString + "_HM1_C", 1, columnsHealthHM1); - coeffCovarianceHM2CaseMales = ExcelAssistant.loadCoefficientMap("input/reg_health_mental.xlsx", countryString + "_HM2_Males_C", 1, columnsHealthHM2Males); - coeffCovarianceHM2CaseFemales = ExcelAssistant.loadCoefficientMap("input/reg_health_mental.xlsx", countryString + "_HM2_Females_C", 1, columnsHealthHM2Females); + coeffCovarianceHM1Level = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_mental.xlsx", countryString + "_HM1_L", 1, columnsHealthHM1); + coeffCovarianceHM2LevelMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_mental.xlsx", countryString + "_HM2_Males_L", 1, columnsHealthHM2Males); + coeffCovarianceHM2LevelFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_mental.xlsx", countryString + "_HM2_Females_L", 1, columnsHealthHM2Females); + coeffCovarianceHM1Case = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_mental.xlsx", countryString + "_HM1_C", 1, columnsHealthHM1); + coeffCovarianceHM2CaseMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_mental.xlsx", countryString + "_HM2_Males_C", 1, columnsHealthHM2Males); + coeffCovarianceHM2CaseFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_mental.xlsx", countryString + "_HM2_Females_C", 1, columnsHealthHM2Females); //Education - coeffCovarianceEducationE1a = ExcelAssistant.loadCoefficientMap("input/reg_education.xlsx", countryString + "_E1a", 1, columnsEducationE1a); - coeffCovarianceEducationE1b = ExcelAssistant.loadCoefficientMap("input/reg_education.xlsx", countryString + "_E1b", 1, columnsEducationE1b); - coeffCovarianceEducationE2a = ExcelAssistant.loadCoefficientMap("input/reg_education.xlsx", countryString + "_E2a", 1, columnsEducationE2a); + coeffCovarianceEducationE1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_education.xlsx", countryString + "_E1a", 1, columnsEducationE1a); + coeffCovarianceEducationE1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_education.xlsx", countryString + "_E1b", 1, columnsEducationE1b); + coeffCovarianceEducationE2a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_education.xlsx", countryString + "_E2a", 1, columnsEducationE2a); //Partnership if (country.equals(Country.UK)) { - coeffCovariancePartnershipU1a = ExcelAssistant.loadCoefficientMap("input/reg_partnership.xlsx", countryString + "_U1a", 1, columnsPartnershipU1a); - coeffCovariancePartnershipU1b = ExcelAssistant.loadCoefficientMap("input/reg_partnership.xlsx", countryString + "_U1b", 1, columnsPartnershipU1b); - coeffCovariancePartnershipU2b = ExcelAssistant.loadCoefficientMap("input/reg_partnership.xlsx", countryString + "_U2b", 1, columnsPartnershipU2b); + coeffCovariancePartnershipU1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_partnership.xlsx", countryString + "_U1a", 1, columnsPartnershipU1a); + coeffCovariancePartnershipU1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_partnership.xlsx", countryString + "_U1b", 1, columnsPartnershipU1b); + coeffCovariancePartnershipU2b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_partnership.xlsx", countryString + "_U2b", 1, columnsPartnershipU2b); } else if (country.equals(Country.IT)) { - coeffCovariancePartnershipITU1 = ExcelAssistant.loadCoefficientMap("input/reg_partnership.xlsx", countryString + "_U1", 1, columnsPartnershipU1); - coeffCovariancePartnershipITU2 = ExcelAssistant.loadCoefficientMap("input/reg_partnership.xlsx", countryString + "_U2", 1, columnsPartnershipU2); + coeffCovariancePartnershipITU1 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_partnership.xlsx", countryString + "_U1", 1, columnsPartnershipU1); + coeffCovariancePartnershipITU2 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_partnership.xlsx", countryString + "_U2", 1, columnsPartnershipU2); } //Partnership - parameters for matching based on wage and age differential - meanCovarianceParametricMatching = ExcelAssistant.loadCoefficientMap("input/scenario_parametricMatching.xlsx", countryString, 1, 1); + meanCovarianceParametricMatching = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "scenario_parametricMatching.xlsx", countryString, 1, 1); //Fertility if (country.equals(Country.UK)) { - coeffCovarianceFertilityF1a = ExcelAssistant.loadCoefficientMap("input/reg_fertility.xlsx", countryString + "_F1a", 1, columnsFertilityF1a); - coeffCovarianceFertilityF1b = ExcelAssistant.loadCoefficientMap("input/reg_fertility.xlsx", countryString + "_F1b", 1, columnsFertilityF1b); + coeffCovarianceFertilityF1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_fertility.xlsx", countryString + "_F1a", 1, columnsFertilityF1a); + coeffCovarianceFertilityF1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_fertility.xlsx", countryString + "_F1b", 1, columnsFertilityF1b); } else if (country.equals(Country.IT)) { - coeffCovarianceFertilityF1 = ExcelAssistant.loadCoefficientMap("input/reg_fertility.xlsx", countryString + "_F1", 1, columnsFertilityF1); + coeffCovarianceFertilityF1 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_fertility.xlsx", countryString + "_F1", 1, columnsFertilityF1); } //Income - coeffCovarianceIncomeI3a = ExcelAssistant.loadCoefficientMap("input/reg_income.xlsx", countryString + "_I3a", 1, columnsIncomeI3a); - coeffCovarianceIncomeI3b = ExcelAssistant.loadCoefficientMap("input/reg_income.xlsx", countryString + "_I3b", 1, columnsIncomeI3b); - coeffCovarianceIncomeI4b = ExcelAssistant.loadCoefficientMap("input/reg_income.xlsx", countryString + "_I4b", 1, columnsIncomeI4b); - coeffCovarianceIncomeI5a_selection = ExcelAssistant.loadCoefficientMap("input/reg_income.xlsx", countryString + "_I5a", 1, columnsIncomeI5a); - coeffCovarianceIncomeI5b_amount = ExcelAssistant.loadCoefficientMap("input/reg_income.xlsx", countryString + "_I5b", 1, columnsIncomeI5b); - coeffCovarianceIncomeI3a_selection = ExcelAssistant.loadCoefficientMap("input/reg_income.xlsx", countryString + "_I3a_selection", 1, columnsIncomeI3a_selection); - coeffCovarianceIncomeI3b_selection = ExcelAssistant.loadCoefficientMap("input/reg_income.xlsx", countryString + "_I3b_selection", 1, columnsIncomeI3b_selection); + coeffCovarianceIncomeI3a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_income.xlsx", countryString + "_I3a", 1, columnsIncomeI3a); + coeffCovarianceIncomeI3b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_income.xlsx", countryString + "_I3b", 1, columnsIncomeI3b); + coeffCovarianceIncomeI4b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_income.xlsx", countryString + "_I4b", 1, columnsIncomeI4b); + coeffCovarianceIncomeI5a_selection = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_income.xlsx", countryString + "_I5a", 1, columnsIncomeI5a); + coeffCovarianceIncomeI5b_amount = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_income.xlsx", countryString + "_I5b", 1, columnsIncomeI5b); + coeffCovarianceIncomeI3a_selection = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_income.xlsx", countryString + "_I3a_selection", 1, columnsIncomeI3a_selection); + coeffCovarianceIncomeI3b_selection = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_income.xlsx", countryString + "_I3b_selection", 1, columnsIncomeI3b_selection); //Leaving parental home - coeffCovarianceLeaveHomeP1a = ExcelAssistant.loadCoefficientMap("input/reg_leaveParentalHome.xlsx", countryString + "_P1a", 1, columnsLeaveHomeP1a); + coeffCovarianceLeaveHomeP1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_leaveParentalHome.xlsx", countryString + "_P1a", 1, columnsLeaveHomeP1a); //Homeownership - coeffCovarianceHomeownership = ExcelAssistant.loadCoefficientMap("input/reg_home_ownership.xlsx", countryString + "_HO1a", 1, columnsHomeownership); + coeffCovarianceHomeownership = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_home_ownership.xlsx", countryString + "_HO1a", 1, columnsHomeownership); //Retirement - coeffCovarianceRetirementR1a = ExcelAssistant.loadCoefficientMap("input/reg_retirement.xlsx", countryString + "_R1a", 1, columnsRetirementR1a); - coeffCovarianceRetirementR1b = ExcelAssistant.loadCoefficientMap("input/reg_retirement.xlsx", countryString + "_R1b", 1, columnsRetirementR1b); + coeffCovarianceRetirementR1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_retirement.xlsx", countryString + "_R1a", 1, columnsRetirementR1a); + coeffCovarianceRetirementR1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_retirement.xlsx", countryString + "_R1b", 1, columnsRetirementR1b); //Childcare - coeffCovarianceChildcareC1a = ExcelAssistant.loadCoefficientMap("input/reg_childcarecost.xlsx", countryString + "_C1a", 1, columnsChildcareC1a); - coeffCovarianceChildcareC1b = ExcelAssistant.loadCoefficientMap("input/reg_childcarecost.xlsx", countryString + "_C1b", 1, columnsChildcareC1b); + coeffCovarianceChildcareC1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_childcarecost.xlsx", countryString + "_C1a", 1, columnsChildcareC1a); + coeffCovarianceChildcareC1b = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_childcarecost.xlsx", countryString + "_C1b", 1, columnsChildcareC1b); //Bootstrap the coefficients if(bootstrapAll) { @@ -1590,69 +1590,69 @@ else if (country.equals(Country.IT)) { /////////////////////////////////////////////////POPULATE STATISTICS FOR VALIDATION///////////////////////////// //Students by Age - validationStudentsByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_studentsByAge", 1, columnsValidationStudentsByAge); + validationStudentsByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_studentsByAge", 1, columnsValidationStudentsByAge); //Students by Region - validationStudentsByRegion = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_studentsByRegion", 1, columnsValidationStudentsByRegion); + validationStudentsByRegion = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_studentsByRegion", 1, columnsValidationStudentsByRegion); //Education level of over 17 year olds - validationEducationLevel = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_educationLevel", 1, columnsValidationEducationLevel); + validationEducationLevel = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_educationLevel", 1, columnsValidationEducationLevel); //Education level by age group - validationEducationLevelByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_educationLevelByAge", 1, columnsValidationEducationLevelByAge); + validationEducationLevelByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_educationLevelByAge", 1, columnsValidationEducationLevelByAge); //Education level by region - validationEducationLevelByRegion = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_educationLevelByRegion", 1, columnsValidationEducationLevelByRegion); + validationEducationLevelByRegion = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_educationLevelByRegion", 1, columnsValidationEducationLevelByRegion); //Partnered BU share by region - validationPartneredShareByRegion = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_partneredBUShareByRegion", 1, columnsValidationPartneredBUShareByRegion); + validationPartneredShareByRegion = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_partneredBUShareByRegion", 1, columnsValidationPartneredBUShareByRegion); //Disabled by age - validationDisabledByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_disabledByAgeGroup", 1, columnsValidationDisabledByAgeGroup); + validationDisabledByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_disabledByAgeGroup", 1, columnsValidationDisabledByAgeGroup); - validationDisabledByGender = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_disabledByGender", 1, columnsValidationDisabledByGender); + validationDisabledByGender = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_disabledByGender", 1, columnsValidationDisabledByGender); //Health by age - validationHealthByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_healthByAgeGroup", 1, columnsValidationHealthByAgeGroup); + validationHealthByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_healthByAgeGroup", 1, columnsValidationHealthByAgeGroup); //Mental health by age and gender - validationMentalHealthByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_mentalHealthByAgeGroup", 1, columnsValidationMentalHealthByAgeGroup); + validationMentalHealthByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_mentalHealthByAgeGroup", 1, columnsValidationMentalHealthByAgeGroup); //Psychological distress by age and gender - validationPsychDistressByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_psychDistressByAgeGroup", 1, columnsValidationMentalHealthByAgeGroup); - validationPsychDistressByAgeLow = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_psychDistressByAgeGroupLowED", 1, columnsValidationMentalHealthByAgeGroup); - validationPsychDistressByAgeMed = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_psychDistressByAgeGroupMedED", 1, columnsValidationMentalHealthByAgeGroup); - validationPsychDistressByAgeHigh = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_psychDistressByAgeGroupHiEd", 1, columnsValidationMentalHealthByAgeGroup); + validationPsychDistressByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_psychDistressByAgeGroup", 1, columnsValidationMentalHealthByAgeGroup); + validationPsychDistressByAgeLow = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_psychDistressByAgeGroupLowED", 1, columnsValidationMentalHealthByAgeGroup); + validationPsychDistressByAgeMed = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_psychDistressByAgeGroupMedED", 1, columnsValidationMentalHealthByAgeGroup); + validationPsychDistressByAgeHigh = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_psychDistressByAgeGroupHiEd", 1, columnsValidationMentalHealthByAgeGroup); //Employment by gender - validationEmploymentByGender = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_employmentByGender", 1, columnsValidationEmploymentByGender); + validationEmploymentByGender = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_employmentByGender", 1, columnsValidationEmploymentByGender); //Employment by age and gender - validationEmploymentByAgeAndGender = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_employmentByGenderAndAge", 1, columnsValidationEmploymentByGenderAndAge); + validationEmploymentByAgeAndGender = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_employmentByGenderAndAge", 1, columnsValidationEmploymentByGenderAndAge); //Employment by maternity - validationEmploymentByMaternity = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_employmentByMaternity", 1, columnsValidationEmploymentByMaternity); + validationEmploymentByMaternity = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_employmentByMaternity", 1, columnsValidationEmploymentByMaternity); //Employment by gender and region - validationEmploymentByGenderAndRegion = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_employmentByGenderAndRegion", 1, columnsValidationEmploymentByGenderAndRegion); + validationEmploymentByGenderAndRegion = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_employmentByGenderAndRegion", 1, columnsValidationEmploymentByGenderAndRegion); //Labour supply by education - validationLabourSupplyByEducation = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_labourSupplyByEducation", 1, columnsValidationLabourSupplyByEducation); + validationLabourSupplyByEducation = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_labourSupplyByEducation", 1, columnsValidationLabourSupplyByEducation); //Activity status - validationActivityStatus = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_activityStatus", 1, columnsValidationActivityStatus); + validationActivityStatus = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_activityStatus", 1, columnsValidationActivityStatus); //Homeownership status - validationHomeownershipBenefitUnits = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_homeownership", 1, columnsValidationHomeownership); + validationHomeownershipBenefitUnits = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_homeownership", 1, columnsValidationHomeownership); //Gross earnings yearly by education and gender (for employed persons) - validationGrossEarningsByGenderAndEducation = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_grossEarningsByGenderAndEdu", 1, columnsValidationByGenderAndEducation); + validationGrossEarningsByGenderAndEducation = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_grossEarningsByGenderAndEdu", 1, columnsValidationByGenderAndEducation); //Hourly wages by education and gender (for employed persons) - validationLhwByGenderAndEducation = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_lhwByGenderAndEdu", 1, 8); + validationLhwByGenderAndEducation = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_lhwByGenderAndEdu", 1, 8); //Hours worked weekly by education and gender (for employed persons) - hourlyWageByGenderAndEducation = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_hourlywageByGenderAndEdu", 1, columnsValidationByGenderAndEducation); + hourlyWageByGenderAndEducation = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_hourlywageByGenderAndEdu", 1, columnsValidationByGenderAndEducation); } /** @@ -1803,7 +1803,7 @@ private static void calculatePopulationGrowthRatiosFromProjections() { public static TreeMap calculateEUROMODpolicySchedule(Country country) { //Load current values for policy description and initiation year - MultiKeyCoefficientMap currentEUROMODpolicySchedule = ExcelAssistant.loadCoefficientMap("input" + File.separator + EUROMODpolicyScheduleFilename + ".xlsx", country.toString(), 1, 3); + MultiKeyCoefficientMap currentEUROMODpolicySchedule = ExcelAssistant.loadCoefficientMap(getInputDirectory() + EUROMODpolicyScheduleFilename + ".xlsx", country.toString(), 1, 3); TreeMap newEUROMODpolicySchedule = new TreeMap<>(); for(Object o: currentEUROMODpolicySchedule.keySet()) { @@ -1887,7 +1887,7 @@ public static void setCountryRegions(Country country) { public static void setCountryBenefitUnitName() { //Benefit unit variable has different name in each country. This method loads the correct name of the benefit unit variable from Excel file system_bu_names.xlsx in the input folder. - benefitUnitVariableNames = ExcelAssistant.loadCoefficientMap("input/system_bu_names.xlsx", "Names", 1, 1); + benefitUnitVariableNames = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "system_bu_names.xlsx", "Names", 1, 1); } //----------------------------------------------------------------------------------------------------- @@ -2458,23 +2458,23 @@ public static LinearRegression getRegEmploymentSelectionFemaleNE() { public static void loadTimeSeriesFactorMaps(Country country) { // load time varying rates - priceMapRealSavingReturns = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_saving_returns", 1, 1); - priceMapRealDebtCostLow = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_debt_cost_low", 1, 1); - priceMapRealDebtCostHigh = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_debt_cost_hi", 1, 1); + priceMapRealSavingReturns = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_saving_returns", 1, 1); + priceMapRealDebtCostLow = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_debt_cost_low", 1, 1); + priceMapRealDebtCostHigh = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_debt_cost_hi", 1, 1); // load time varying wage rates - wageRateFormalSocialCare = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_carer_hourly_wage", 1, 1); + wageRateFormalSocialCare = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_carer_hourly_wage", 1, 1); // load time varying indices - upratingIndexMapRealGDP = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_gdp", 1, 1); - upratingIndexMapInflation = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_inflation", 1, 1); - upratingIndexMapRealWageGrowth = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_wage_growth", 1, 1); - socialCareProvisionTimeAdjustment = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_care_adjustment", 1, 1); - partnershipTimeAdjustment = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_cohabitation_adjustment", 1, 1); - fertilityTimeAdjustment = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_fertility_adjustment", 1, 1); - utilityTimeAdjustmentSingleMales = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_utility_adj_smales", 1, 1); - utilityTimeAdjustmentSingleFemales = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_utility_adj_sfemales", 1, 1); - utilityTimeAdjustmentCouples = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_utility_adj_couples", 1, 1); + upratingIndexMapRealGDP = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_gdp", 1, 1); + upratingIndexMapInflation = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_inflation", 1, 1); + upratingIndexMapRealWageGrowth = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_wage_growth", 1, 1); + socialCareProvisionTimeAdjustment = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_care_adjustment", 1, 1); + partnershipTimeAdjustment = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_cohabitation_adjustment", 1, 1); + fertilityTimeAdjustment = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_fertility_adjustment", 1, 1); + utilityTimeAdjustmentSingleMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_utility_adj_smales", 1, 1); + utilityTimeAdjustmentSingleFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_utility_adj_sfemales", 1, 1); + utilityTimeAdjustmentCouples = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_utility_adj_couples", 1, 1); // rebase indices to base year defined by BASE_PRICE_YEAR rebaseIndexMap(TimeSeriesVariable.GDP); @@ -2482,11 +2482,11 @@ public static void loadTimeSeriesFactorMaps(Country country) { rebaseIndexMap(TimeSeriesVariable.WageGrowth); // load year-specific fiscal policy parameters - socialCarePolicy = ExcelAssistant.loadCoefficientMap("input/policy parameters.xlsx", "social care", 1, 8); - partneredShare = ExcelAssistant.loadCoefficientMap("input/policy parameters.xlsx", "partnership", 1, 1); - employedShareSingleMales = ExcelAssistant.loadCoefficientMap("input/policy parameters.xlsx", "employment_smales", 1, 1); - employedShareSingleFemales = ExcelAssistant.loadCoefficientMap("input/policy parameters.xlsx", "employment_sfemales", 1, 1); - employedShareCouples = ExcelAssistant.loadCoefficientMap("input/policy parameters.xlsx", "employment_couples", 1, 1); + socialCarePolicy = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "policy parameters.xlsx", "social care", 1, 8); + partneredShare = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "policy parameters.xlsx", "partnership", 1, 1); + employedShareSingleMales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "policy parameters.xlsx", "employment_smales", 1, 1); + employedShareSingleFemales = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "policy parameters.xlsx", "employment_sfemales", 1, 1); + employedShareCouples = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "policy parameters.xlsx", "employment_couples", 1, 1); } @@ -2504,15 +2504,15 @@ public static void loadTimeSeriesFactorForTaxDonor(Country country) { TimeSeriesVariable index = getTimeSeriesVariable(UpratingCase.TaxDonor); switch (index) { case GDP -> { - upratingIndexMapRealGDP = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_gdp", 1, 1); + upratingIndexMapRealGDP = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_gdp", 1, 1); rebaseIndexMap(TimeSeriesVariable.GDP); } case WageGrowth -> { - upratingIndexMapRealWageGrowth = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_wage_growth", 1, 1); + upratingIndexMapRealWageGrowth = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_wage_growth", 1, 1); rebaseIndexMap(TimeSeriesVariable.WageGrowth); } case Inflation -> { - upratingIndexMapInflation = ExcelAssistant.loadCoefficientMap("input/time_series_factor.xlsx", country.toString() + "_inflation", 1, 1); + upratingIndexMapInflation = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "time_series_factor.xlsx", country.toString() + "_inflation", 1, 1); rebaseIndexMap(TimeSeriesVariable.Inflation); } } From bfeae9c6c828793556a3105363224214aedb3c88 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 15:22:41 +0000 Subject: [PATCH 04/23] de-finalise some potential changing parameters --- src/main/java/simpaths/data/Parameters.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index f4b8ff2fa..7389e6cd8 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -256,8 +256,8 @@ else if(numberOfChildren <= 5) { //public static int MAX_AGE_IN_EDUCATION;// = MAX_AGE;//30; // Max age a person can stay in education //Cannot set here, as MAX_AGE is not known yet. Now set to MAX_AGE in buildObjects in Model class. //public static int MAX_AGE_MARRIAGE;// = MAX_AGE;//75; // Max age a person can marry //Cannot set here, as MAX_AGE is not known yet. Now set to MAX_AGE in buildObjects in Model class. - private static final int MIN_START_YEAR = 2011; //Minimum allowed starting point. Should correspond to the oldest initial population. - private static final int MAX_START_YEAR = 2021; //Maximum allowed starting point. Should correspond to the most recent initial population. + private static int MIN_START_YEAR = 2011; //Minimum allowed starting point. Should correspond to the oldest initial population. + private static int MAX_START_YEAR = 2021; //Maximum allowed starting point. Should correspond to the most recent initial population. public static int startYear; public static int endYear; private static final int MIN_START_YEAR_TRAINING = 2019; @@ -267,7 +267,7 @@ else if(numberOfChildren <= 5) { public static final boolean FLAG_SINGLE_MOTHERS = true; public static boolean flagUnemployment = false; - public static final int BASE_PRICE_YEAR = 2015; // Base price year of model parameters + public static int BASE_PRICE_YEAR = 2015; // Base price year of model parameters public static double PROB_NEWBORN_IS_MALE = 0.5; // Must be strictly greater than 0.0 and less than 1.0 From d31cef744be42d04b53b6d2d2ff1d4774fa5a4f4 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 15:23:21 +0000 Subject: [PATCH 05/23] simpaths start calls dynamic input folder loc --- src/main/java/simpaths/experiment/SimPathsStart.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/simpaths/experiment/SimPathsStart.java b/src/main/java/simpaths/experiment/SimPathsStart.java index 62b004911..8bb523da3 100644 --- a/src/main/java/simpaths/experiment/SimPathsStart.java +++ b/src/main/java/simpaths/experiment/SimPathsStart.java @@ -82,7 +82,7 @@ public static void main(String[] args) { } //Adjust the country and year to the value read from Excel, which is updated when the database is rebuilt. Otherwise it will set the country and year to the last one used to build the database - MultiKeyCoefficientMap lastDatabaseCountryAndYear = ExcelAssistant.loadCoefficientMap("input" + File.separator + Parameters.DatabaseCountryYearFilename + ".xlsx", "Data", 1, 1); + MultiKeyCoefficientMap lastDatabaseCountryAndYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + Parameters.DatabaseCountryYearFilename + ".xlsx", "Data", 1, 1); if (lastDatabaseCountryAndYear.keySet().stream().anyMatch(key -> key.toString().equals("MultiKey[IT]"))) { country = Country.IT; } else { @@ -213,8 +213,8 @@ private static void runGUIlessSetup(int option) throws FileNotFoundException { // Create EUROMODPolicySchedule input from files if (!rewritePolicySchedule && - !new File("input" + File.separator + Parameters.EUROMODpolicyScheduleFilename + ".xlsx").exists()) { - throw new FileNotFoundException("Policy Schedule file '"+ File.separator + "input" + File.separator + + !new File(Parameters.getInputDirectory() + Parameters.EUROMODpolicyScheduleFilename + ".xlsx").exists()) { + throw new FileNotFoundException("Policy Schedule file '"+ File.separator + Parameters.getInputDirectory() + Parameters.EUROMODpolicyScheduleFilename + ".xlsx` doesn't exist. " + "Provide excel file or use `--rewrite-policy-schedule` to re-construct from available policy files."); }; @@ -346,7 +346,7 @@ private static void runGUIdialog() { // call to select policies // load previously stored values for policy description and initiation year - MultiKeyCoefficientMap previousEUROMODfileInfo = ExcelAssistant.loadCoefficientMap("input" + File.separator + Parameters.EUROMODpolicyScheduleFilename + ".xlsx", country.toString(), 1, 3); + MultiKeyCoefficientMap previousEUROMODfileInfo = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + Parameters.EUROMODpolicyScheduleFilename + ".xlsx", country.toString(), 1, 3); Collection euromodOutputTextFiles = FileUtils.listFiles(new File(Parameters.getEuromodOutputDirectory()), new String[]{"txt"}, false); Iterator fIter = euromodOutputTextFiles.iterator(); while (fIter.hasNext()) { From 641f4072522158e5ed5c5779b7e9622e2c0685b1 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 15:24:01 +0000 Subject: [PATCH 06/23] reads in parameter args --- src/main/java/simpaths/experiment/SimPathsMultiRun.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 4332884b2..72d667e00 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -47,6 +47,7 @@ public class SimPathsMultiRun extends MultiRun { private static Map modelArgs; private static Map innovationArgs; private static Map collectorArgs; + private static Map parameterArgs; public static String configFile = "default.yml"; // other working variables @@ -268,6 +269,12 @@ private static boolean parseYamlConfig(String[] args) { continue; } + // Read in parameter arguments - to be handled differently as no Parameters object + if ("parameter_args".equals(key)) { + parameterArgs = (Map) value; + continue; + } + // Use reflection to dynamically set the field based on the key updateLocalParameters(key, value); } From 55926f2d2b2fe326a3830789f5b151e8ecd4aff2 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 15:24:25 +0000 Subject: [PATCH 07/23] setting paramters including input directory in Experiment --- .../simpaths/experiment/SimPathsMultiRun.java | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 72d667e00..1a930edcf 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -12,6 +12,7 @@ import simpaths.data.Parameters; import simpaths.model.SimPathsModel; +import microsim.data.db.Experiment; import microsim.data.MultiKeyCoefficientMap; import microsim.data.excel.ExcelAssistant; import microsim.engine.MultiRun; @@ -344,6 +345,85 @@ public static void updateParameters(Object object, Map args) { } } + // Specifically for updating parameters when no object called - i.e. Parameters.java + public static void updateParameters(Map parameter_args) { + + for (Map.Entry entry : parameter_args.entrySet()) { + String key = entry.getKey(); + Object value = entry.getValue(); + + switch (key) { + case "WORKING_DIRECTORY": + Parameters.setWorkingDirectory(value.toString()); + setExperimentFolders(value.toString(), true); + break; + case "INPUT_DIRECTORY": + Parameters.setInputDirectory(value.toString()); + setExperimentFolders(value.toString()); + break; + case "INPUT_DIRECTORY_INITIAL_POPULATIONS": + Parameters.setInputDirectoryInitialPopulations(value.toString()); + break; + case "EUROMOD_OUTPUT_DIRECTORY": + Parameters.setEuromodOutputDirectory(value.toString()); + break; + default: + try { + Field field = Parameters.class.getDeclaredField(key); + field.setAccessible(true); + + // Determine the field type + Class fieldType = field.getType(); + + // Convert the YAML value to the field type + Object convertedValue = convertToType(value, fieldType); + + // Set the field value + field.set(Parameters.class, convertedValue); + + field.setAccessible(false); + } catch (NoSuchFieldException | IllegalAccessException e) { + // Handle exceptions if the field is not found or inaccessible + e.printStackTrace(); + } + + } + + } + + } + + public static void setExperimentFolders(String root_dir) { + + try { + Field inputDir = Experiment.class.getDeclaredField("inputFolder"); + inputDir.setAccessible(true); + inputDir.set(Experiment.class, root_dir + File.separator + "input"); + inputDir.setAccessible(false); + } catch (NoSuchFieldException | IllegalAccessException e) { + e.printStackTrace(); + } + + } + public static void setExperimentFolders(String root_dir, boolean working_dir) { + + try { + Field inputDir = Experiment.class.getDeclaredField("inputFolder"); + inputDir.setAccessible(true); + inputDir.set(null, root_dir + File.separator + "input"); + inputDir.setAccessible(false); + if (working_dir) { + Field outputDir = Experiment.class.getDeclaredField("outputRootFolder"); + outputDir.setAccessible(true); + outputDir.set(null, root_dir + File.separator + "output"); + outputDir.setAccessible(false); + } + } catch (NoSuchFieldException | IllegalAccessException e) { + e.printStackTrace(); + } + + } + private static Object convertToType(Object value, Class targetType) { // Convert the YAML value to the target type if (int.class.equals(targetType)) { From c42085d64a44ff934f16cda6927979b3e0e72a05 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 15:26:10 +0000 Subject: [PATCH 08/23] update parameters (when building model) --- src/main/java/simpaths/experiment/SimPathsMultiRun.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 1a930edcf..8e7106011 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -447,6 +447,9 @@ private static Object convertToType(Object value, Class targetType) { @Override public void buildExperiment(SimulationEngine engine) { + if (parameterArgs != null) + updateParameters(parameterArgs); + SimPathsModel model = new SimPathsModel(Country.getCountryFromNameString(countryString), startYear); updateLocalParameters(model); if (modelArgs != null) From 166e4b635cd07421d95f5b22a124e80d825717e8 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 16:00:25 +0000 Subject: [PATCH 09/23] experimental configs --- config/default.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/config/default.yml b/config/default.yml index 4f3afba82..db35b816e 100644 --- a/config/default.yml +++ b/config/default.yml @@ -59,4 +59,7 @@ collector_args: # persistBenefitUnits: false # persistHouseholds: false # dataDumpStartTime: 0L -# dataDumpTimePeriod: 1.0 \ No newline at end of file +# dataDumpTimePeriod: 1.0 + +parameter_args: + INPUT_DIRECTORY: input \ No newline at end of file From 7cdf68b820b46b9e6bd4f78fc2b8601da542cb61 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 16:00:31 +0000 Subject: [PATCH 10/23] add logging --- pom.xml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pom.xml b/pom.xml index 03fd5dc21..6f3ab4e11 100644 --- a/pom.xml +++ b/pom.xml @@ -127,6 +127,12 @@ opencsv 5.9 + + + org.apache.logging.log4j + log4j-core + 2.24.1 + From 66dec3073fafafe887ac239e0d3d884c9b1f951d Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 16:00:43 +0000 Subject: [PATCH 11/23] correct file finding --- src/main/java/simpaths/data/Parameters.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index 7389e6cd8..11873a18b 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -3282,7 +3282,7 @@ public static void setWorkingDirectory(String workingDirectory) { } public static void setInputDirectory(String inputDirectory) { - INPUT_DIRECTORY = inputDirectory; + INPUT_DIRECTORY = inputDirectory + File.separator; INPUT_DIRECTORY_INITIAL_POPULATIONS = INPUT_DIRECTORY + "InitialPopulations" + File.separator; //Path to directory containing initial population for each year EUROMOD_OUTPUT_DIRECTORY = INPUT_DIRECTORY + "EUROMODoutput" + File.separator; EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; From 78855aea4b308fd1f09db168866393d744d4d4d0 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Thu, 21 Nov 2024 16:01:06 +0000 Subject: [PATCH 12/23] parse input folder before looking up country --- .../simpaths/experiment/SimPathsMultiRun.java | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 8e7106011..157d2f72d 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -65,8 +65,18 @@ public class SimPathsMultiRun extends MultiRun { */ public static void main(String[] args) { + + // process Yaml config file + if (!parseYamlConfig(args)) { + // if parseYamlConfig returns false (indicating bad filename passed), exit main + return; + } + + if (parameterArgs != null) + updateParameters(parameterArgs); + // set default values for country and start year - MultiKeyCoefficientMap lastDatabaseCountryAndYear = ExcelAssistant.loadCoefficientMap("input" + File.separator + Parameters.DatabaseCountryYearFilename + ".xlsx", "Data", 1, 1); + MultiKeyCoefficientMap lastDatabaseCountryAndYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + File.separator + Parameters.DatabaseCountryYearFilename + ".xlsx", "Data", 1, 1); if (lastDatabaseCountryAndYear.keySet().stream().anyMatch(key -> key.toString().equals("MultiKey[IT]"))) { countryString = "Italy"; } else { @@ -76,11 +86,6 @@ public static void main(String[] args) { String valueYear = lastDatabaseCountryAndYear.getValue(country.toString()).toString(); startYear = Integer.parseInt(valueYear); - // process Yaml config file - if (!parseYamlConfig(args)) { - // if parseYamlConfig returns false (indicating bad filename passed), exit main - return; - } if (innovationArgs!=null) updateLocalParameters(innovationArgs); @@ -447,9 +452,6 @@ private static Object convertToType(Object value, Class targetType) { @Override public void buildExperiment(SimulationEngine engine) { - if (parameterArgs != null) - updateParameters(parameterArgs); - SimPathsModel model = new SimPathsModel(Country.getCountryFromNameString(countryString), startYear); updateLocalParameters(model); if (modelArgs != null) From bcfabdd9976eafaba034707679178d0be6f53858 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 14:26:07 +0100 Subject: [PATCH 13/23] some safe checking for last database country file if doesnt exist --- .../simpaths/experiment/SimPathsMultiRun.java | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 46d7831d0..03a550f12 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -79,14 +79,21 @@ public static void main(String[] args) { updateParameters(parameterArgs); // set default values for country and start year MultiKeyCoefficientMap lastDatabaseCountryAndYear = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + File.separator + Parameters.DatabaseCountryYearFilename + ".xlsx", "Data", 1, 1); - if (lastDatabaseCountryAndYear.keySet().stream().anyMatch(key -> key.toString().equals("MultiKey[IT]"))) { - countryString = "Italy"; - } else { + try { + if (lastDatabaseCountryAndYear.keySet().stream().anyMatch(key -> key.toString().equals("MultiKey[IT]"))) { + countryString = "Italy"; + } else { + countryString = "United Kingdom"; + } + String valueYear = lastDatabaseCountryAndYear.getValue(country.toString()).toString(); + startYear = Integer.parseInt(valueYear); + } catch (NullPointerException e) { + System.out.println("No last database country and year found."); countryString = "United Kingdom"; + startYear = 2019; } + country = Country.getCountryFromNameString(countryString); - String valueYear = lastDatabaseCountryAndYear.getValue(country.toString()).toString(); - startYear = Integer.parseInt(valueYear); if (innovationArgs!=null) updateLocalParameters(innovationArgs); From 008221abd3fe70b79347ef8685c70316ee7628b7 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 15:00:31 +0100 Subject: [PATCH 14/23] correct persist root database ref --- src/main/java/simpaths/experiment/SimPathsMultiRun.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 03a550f12..4d14b76cc 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -504,7 +504,7 @@ public void buildExperiment(SimulationEngine engine) { SimPathsModel model = new SimPathsModel(Country.getCountryFromNameString(countryString), startYear); if (persist_population) model.setPersistPopulation(true); - if (persist_root) model.setPersistDatabasePath("./input/input"); + if (persist_root) model.setPersistDatabasePath(Parameters.getInputDirectory() + "input"); updateLocalParameters(model); if (modelArgs != null) updateParameters(model, modelArgs); From c173ef82400f5651626bfd702810064fa02a4937 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 15:01:37 +0100 Subject: [PATCH 15/23] correct database parsing path --- src/main/java/simpaths/data/startingpop/DataParser.java | 2 +- .../java/simpaths/model/taxes/database/TaxDonorDataParser.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/simpaths/data/startingpop/DataParser.java b/src/main/java/simpaths/data/startingpop/DataParser.java index 150aa29d2..10a3d9afa 100644 --- a/src/main/java/simpaths/data/startingpop/DataParser.java +++ b/src/main/java/simpaths/data/startingpop/DataParser.java @@ -421,7 +421,7 @@ public static void databaseFromCSV(Country country, boolean showGui) { Connection conn = null; try { Class.forName("org.h2.Driver"); - conn = DriverManager.getConnection("jdbc:h2:file:./input" + File.separator + "input;TRACE_LEVEL_FILE=0;TRACE_LEVEL_SYSTEM_OUT=0;AUTO_SERVER=TRUE", "sa", ""); + conn = DriverManager.getConnection("jdbc:h2:file:." + Parameters.getInputDirectory() + File.separator + "input;TRACE_LEVEL_FILE=0;TRACE_LEVEL_SYSTEM_OUT=0;AUTO_SERVER=TRUE", "sa", ""); Parameters.setPopulationInitialisationInputFileName("population_initial_" + country.toString()); diff --git a/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java b/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java index f240e10d3..d12d9c317 100644 --- a/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java +++ b/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java @@ -63,7 +63,7 @@ public static void databaseFromCSV(Country country, int startYear, boolean isVis Connection conn = null; try { Class.forName("org.h2.Driver"); - conn = DriverManager.getConnection("jdbc:h2:file:./input" + File.separator + "input;TRACE_LEVEL_FILE=0;TRACE_LEVEL_SYSTEM_OUT=0;AUTO_SERVER=TRUE", "sa", ""); + conn = DriverManager.getConnection("jdbc:h2:file:" + Parameters.getInputDirectory() + "input;TRACE_LEVEL_FILE=0;TRACE_LEVEL_SYSTEM_OUT=0;AUTO_SERVER=TRUE", "sa", ""); createTaxDonorTables(conn, country, startYear); updateDefaultDonorTables(conn, country); From 6043d3e23e5d2e7557843e9df97afdf0205f0d8d Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 15:02:20 +0100 Subject: [PATCH 16/23] override all calls to static root database in parameters --- src/main/java/simpaths/data/Parameters.java | 28 ++++++++++----------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index c7c58cc07..b1bb3b31f 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -1361,7 +1361,7 @@ else if(country.equals(Country.UK)) { coeffCovarianceUnemploymentU1d = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_unemployment.xlsx", countryString + "_U1d", 1, columnsUnemploymentU1d); //Financial distress - coeffCovarianceFinancialDistress = ExcelAssistant.loadCoefficientMap("input/reg_financial_distress.xlsx", countryString, 1, columnsFinancialDistress); + coeffCovarianceFinancialDistress = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_financial_distress.xlsx", countryString, 1, columnsFinancialDistress); //Health mental: level and case-based coeffCovarianceHM1Level = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_mental.xlsx", countryString + "_HM1_L", 1, columnsHealthHM1); @@ -1373,23 +1373,23 @@ else if(country.equals(Country.UK)) { //Health - coeffCovarianceDHE_MCS1 = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DHE_MCS1", 1, columnsHealthMCS1); - coeffCovarianceDHE_MCS2Males = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DHE_MCS2_Males", 1, columnsHealthMCS2Males); - coeffCovarianceDHE_MCS2Females = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DHE_MCS2_Females", 1, columnsHealthMCS2Females); + coeffCovarianceDHE_MCS1 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DHE_MCS1", 1, columnsHealthMCS1); + coeffCovarianceDHE_MCS2Males = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DHE_MCS2_Males", 1, columnsHealthMCS2Males); + coeffCovarianceDHE_MCS2Females = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DHE_MCS2_Females", 1, columnsHealthMCS2Females); - coeffCovarianceDHE_PCS1 = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DHE_PCS1", 1, columnsHealthPCS1); - coeffCovarianceDHE_PCS2Males = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DHE_PCS2_Males", 1, columnsHealthPCS2Males); - coeffCovarianceDHE_PCS2Females = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DHE_PCS2_Females", 1, columnsHealthPCS2Females); + coeffCovarianceDHE_PCS1 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DHE_PCS1", 1, columnsHealthPCS1); + coeffCovarianceDHE_PCS2Males = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DHE_PCS2_Males", 1, columnsHealthPCS2Males); + coeffCovarianceDHE_PCS2Females = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DHE_PCS2_Females", 1, columnsHealthPCS2Females); - coeffCovarianceDLS1 = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DLS1", 1, columnsLifeSatisfaction1); - coeffCovarianceDLS2Males = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DLS2_Males", 1, columnsLifeSatisfaction2Males); - coeffCovarianceDLS2Females = ExcelAssistant.loadCoefficientMap("input/reg_health_wellbeing.xlsx", countryString + "_DLS2_Females", 1, columnsLifeSatisfaction2Females); + coeffCovarianceDLS1 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DLS1", 1, columnsLifeSatisfaction1); + coeffCovarianceDLS2Males = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DLS2_Males", 1, columnsLifeSatisfaction2Males); + coeffCovarianceDLS2Females = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_health_wellbeing.xlsx", countryString + "_DLS2_Females", 1, columnsLifeSatisfaction2Females); loadEQ5DParameters(countryString, columnsHealthEQ5D); //Life satisfaction -// coeffCovarianceDLS1 = ExcelAssistant.loadCoefficientMap("input/reg_lifesatisfaction.xlsx", countryString + "_DLS1", 1, columnsLifeSatisfaction1); +// coeffCovarianceDLS1 = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_lifesatisfaction.xlsx", countryString + "_DLS1", 1, columnsLifeSatisfaction1); //Education coeffCovarianceEducationE1a = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "reg_education.xlsx", countryString + "_E1a", 1, columnsEducationE1a); @@ -1748,9 +1748,9 @@ else if (country.equals(Country.IT)) { validationMentalHealthByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_mentalHealthByAgeGroup", 1, columnsValidationMentalHealthByAgeGroup); - validationHealthMCSByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_healthMCSByAgeGroup", 1, columnsValidationHealthMCSByAgeGroup); - validationHealthPCSByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_healthPCSByAgeGroup", 1, columnsValidationPhysicalHealthByAgeGroup); - validationLifeSatisfactionByAge = ExcelAssistant.loadCoefficientMap("input/validation_statistics.xlsx", countryString + "_lifeSatisfactionByAgeGroup", 1, columnsValidationLifeSatisfactionByAgeGroup); + validationHealthMCSByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_healthMCSByAgeGroup", 1, columnsValidationHealthMCSByAgeGroup); + validationHealthPCSByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_healthPCSByAgeGroup", 1, columnsValidationPhysicalHealthByAgeGroup); + validationLifeSatisfactionByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_lifeSatisfactionByAgeGroup", 1, columnsValidationLifeSatisfactionByAgeGroup); //Psychological distress by age and gender validationPsychDistressByAge = ExcelAssistant.loadCoefficientMap(Parameters.getInputDirectory() + "validation_statistics.xlsx", countryString + "_psychDistressByAgeGroup", 1, columnsValidationMentalHealthByAgeGroup); From cde7ba76ad0a51e007c079083ff0c87c5aa28d24 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 15:06:55 +0100 Subject: [PATCH 17/23] detect if input filder is absolute or not --- src/main/java/simpaths/data/Parameters.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index b1bb3b31f..84f1098aa 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -3407,7 +3407,12 @@ public static void setWorkingDirectory(String workingDirectory) { } public static void setInputDirectory(String inputDirectory) { - INPUT_DIRECTORY = inputDirectory + File.separator; + File inputpath = new File(inputDirectory); + if (inputpath.isAbsolute()){ + INPUT_DIRECTORY = inputDirectory + File.separator; + } else { + INPUT_DIRECTORY = WORKING_DIRECTORY + File.separator + inputDirectory + File.separator; + } INPUT_DIRECTORY_INITIAL_POPULATIONS = INPUT_DIRECTORY + "InitialPopulations" + File.separator; //Path to directory containing initial population for each year EUROMOD_OUTPUT_DIRECTORY = INPUT_DIRECTORY + "EUROMODoutput" + File.separator; EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; From 5bb70b781b4f6d7c495986737c5b90519d7dd090 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 15:08:42 +0100 Subject: [PATCH 18/23] prefer lower-case args to parameters --- src/main/java/simpaths/experiment/SimPathsMultiRun.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 4d14b76cc..81c5d19ad 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -408,18 +408,18 @@ public static void updateParameters(Map parameter_args) { Object value = entry.getValue(); switch (key) { - case "WORKING_DIRECTORY": + case "working_directory": Parameters.setWorkingDirectory(value.toString()); setExperimentFolders(value.toString(), true); break; - case "INPUT_DIRECTORY": + case "input_directory": Parameters.setInputDirectory(value.toString()); setExperimentFolders(value.toString()); break; - case "INPUT_DIRECTORY_INITIAL_POPULATIONS": + case "input_directory_initial_populations": Parameters.setInputDirectoryInitialPopulations(value.toString()); break; - case "EUROMOD_OUTPUT_DIRECTORY": + case "euromod_output_directory": Parameters.setEuromodOutputDirectory(value.toString()); break; default: From 2fc7419daf8c95730a77db32c15b81684b0837e3 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 16:51:36 +0100 Subject: [PATCH 19/23] fixes to find correct input folder (maybe?) --- src/main/java/simpaths/data/Parameters.java | 2 +- src/main/java/simpaths/data/startingpop/DataParser.java | 2 +- src/main/java/simpaths/experiment/SimPathsMultiRun.java | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index 84f1098aa..7a5e2a49a 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -3359,7 +3359,7 @@ public static double getFertilityRateByYear(int year) { public static void databaseSetup(Country country, boolean executeWithGui, int startYear) { // remove database file if it exists - String filePath = "./input" + File.separator + "input.mv.db"; + String filePath = getInputDirectory() + "input.mv.db"; safeDelete(filePath); // Detect if data available; set to testing data if not diff --git a/src/main/java/simpaths/data/startingpop/DataParser.java b/src/main/java/simpaths/data/startingpop/DataParser.java index 10a3d9afa..16a99fdf6 100644 --- a/src/main/java/simpaths/data/startingpop/DataParser.java +++ b/src/main/java/simpaths/data/startingpop/DataParser.java @@ -421,7 +421,7 @@ public static void databaseFromCSV(Country country, boolean showGui) { Connection conn = null; try { Class.forName("org.h2.Driver"); - conn = DriverManager.getConnection("jdbc:h2:file:." + Parameters.getInputDirectory() + File.separator + "input;TRACE_LEVEL_FILE=0;TRACE_LEVEL_SYSTEM_OUT=0;AUTO_SERVER=TRUE", "sa", ""); + conn = DriverManager.getConnection("jdbc:h2:file:" + Parameters.getInputDirectory() + "input;TRACE_LEVEL_FILE=0;TRACE_LEVEL_SYSTEM_OUT=0;AUTO_SERVER=TRUE", "sa", ""); Parameters.setPopulationInitialisationInputFileName("population_initial_" + country.toString()); diff --git a/src/main/java/simpaths/experiment/SimPathsMultiRun.java b/src/main/java/simpaths/experiment/SimPathsMultiRun.java index 81c5d19ad..391f33d24 100644 --- a/src/main/java/simpaths/experiment/SimPathsMultiRun.java +++ b/src/main/java/simpaths/experiment/SimPathsMultiRun.java @@ -414,7 +414,7 @@ public static void updateParameters(Map parameter_args) { break; case "input_directory": Parameters.setInputDirectory(value.toString()); - setExperimentFolders(value.toString()); + setExperimentFolders(); break; case "input_directory_initial_populations": Parameters.setInputDirectoryInitialPopulations(value.toString()); @@ -448,12 +448,12 @@ public static void updateParameters(Map parameter_args) { } - public static void setExperimentFolders(String root_dir) { + public static void setExperimentFolders() { try { Field inputDir = Experiment.class.getDeclaredField("inputFolder"); inputDir.setAccessible(true); - inputDir.set(Experiment.class, root_dir + File.separator + "input"); + inputDir.set(Experiment.class, Parameters.getInputDirectory()); inputDir.setAccessible(false); } catch (NoSuchFieldException | IllegalAccessException e) { e.printStackTrace(); From f25063cdc7de2247735b682b5549d277e34dbbb1 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 16:51:57 +0100 Subject: [PATCH 20/23] eq5d test file moved to test folder --- src/test/java/simpaths/model/PersonTest.java | 4 ++++ src/test/java/simpaths/testinput/reg_eq5d.xlsx | Bin 0 -> 10546 bytes 2 files changed, 4 insertions(+) create mode 100644 src/test/java/simpaths/testinput/reg_eq5d.xlsx diff --git a/src/test/java/simpaths/model/PersonTest.java b/src/test/java/simpaths/model/PersonTest.java index bb1be9b24..3fc41906b 100644 --- a/src/test/java/simpaths/model/PersonTest.java +++ b/src/test/java/simpaths/model/PersonTest.java @@ -27,6 +27,8 @@ class WithLawrenceParameters { @BeforeEach public void setupLawrenceCoefficients() { + Parameters.setInputDirectory("src/test/java/simpaths/testinput"); + Parameters.eq5dConversionParameters = "lawrence"; Parameters.loadEQ5DParameters("UK", 8); @@ -70,6 +72,8 @@ class WithFranksParameters { @BeforeEach public void setupFranksCoefficients() { + Parameters.setInputDirectory("src/test/java/simpaths/testinput"); + Parameters.eq5dConversionParameters = "franks"; Parameters.loadEQ5DParameters("UK", 8); diff --git a/src/test/java/simpaths/testinput/reg_eq5d.xlsx b/src/test/java/simpaths/testinput/reg_eq5d.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..744768a8337af66e7df3bf8aa5777431f9d4af5f GIT binary patch literal 10546 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 z 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 literal 0 HcmV?d00001 From f377ed7e4cde695725af30d95c522340e6febd01 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 17:24:20 +0100 Subject: [PATCH 21/23] caught one last reference to static root database --- .../simpaths/model/taxes/database/TaxDonorDataParser.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java b/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java index d12d9c317..58ae755bc 100644 --- a/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java +++ b/src/main/java/simpaths/model/taxes/database/TaxDonorDataParser.java @@ -606,8 +606,10 @@ public static void populateDonorTaxUnitTables(Country country, boolean showGui) // establish session for database link EntityTransaction txn = null; try { - - EntityManager em = Persistence.createEntityManagerFactory("tax-database").createEntityManager(); + // access database and obtain donor pool + Map propertyMap = new HashMap(); + propertyMap.put("hibernate.connection.url", "jdbc:h2:file:" + Parameters.getInputDirectory() + "input" + ";TRACE_LEVEL_FILE=0;TRACE_LEVEL_SYSTEM_OUT=0;AUTO_SERVER=TRUE"); + EntityManager em = Persistence.createEntityManagerFactory("tax-database", propertyMap).createEntityManager(); txn = em.getTransaction(); txn.begin(); From c64aa5b603a6ecab147bb94d3a6499ce53345ea3 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 17:55:02 +0100 Subject: [PATCH 22/23] change yaml file to commented out defaults --- config/default.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/config/default.yml b/config/default.yml index db35b816e..5e8daf241 100644 --- a/config/default.yml +++ b/config/default.yml @@ -62,4 +62,6 @@ collector_args: # dataDumpTimePeriod: 1.0 parameter_args: - INPUT_DIRECTORY: input \ No newline at end of file +# input_directory: input +# input_directory_initial_populations: input/InitialPopulations +# euromod_output_directory: input/EUROMODoutput From e8d9e5ddff13ddd7f847ee552581c4b871fa22c3 Mon Sep 17 00:00:00 2001 From: Andy Baxter Date: Mon, 23 Jun 2025 17:55:26 +0100 Subject: [PATCH 23/23] ensure parsing of aboslute/relative paths in pop/euromod args --- src/main/java/simpaths/data/Parameters.java | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/main/java/simpaths/data/Parameters.java b/src/main/java/simpaths/data/Parameters.java index 7a5e2a49a..2858f2f6e 100644 --- a/src/main/java/simpaths/data/Parameters.java +++ b/src/main/java/simpaths/data/Parameters.java @@ -3418,12 +3418,21 @@ public static void setInputDirectory(String inputDirectory) { EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; } public static void setInputDirectoryInitialPopulations(String inputDirectoryInitialPopulations) { - - INPUT_DIRECTORY_INITIAL_POPULATIONS = inputDirectoryInitialPopulations; + File inputpath = new File(inputDirectoryInitialPopulations); + if (inputpath.isAbsolute()){ + INPUT_DIRECTORY_INITIAL_POPULATIONS = inputDirectoryInitialPopulations + File.separator; + } else { + INPUT_DIRECTORY_INITIAL_POPULATIONS = WORKING_DIRECTORY + File.separator + inputDirectoryInitialPopulations + File.separator; + } } public static void setEuromodOutputDirectory(String euromodOutputDirectory) { - EUROMOD_OUTPUT_DIRECTORY = euromodOutputDirectory; + File inputPath = new File(euromodOutputDirectory); + if (inputPath.isAbsolute()){ + EUROMOD_OUTPUT_DIRECTORY = euromodOutputDirectory + File.separator; + } else { + EUROMOD_OUTPUT_DIRECTORY = WORKING_DIRECTORY + File.separator + euromodOutputDirectory + File.separator; + } EUROMOD_TRAINING_DIRECTORY = EUROMOD_OUTPUT_DIRECTORY + "training" + File.separator; }