GamsLandUseOptimiser.java

package ac.ed.lurg.country.gams;

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Vector;

import ac.ed.lurg.ModelConfig;
import ac.ed.lurg.landuse.CropAreas;
import ac.ed.lurg.landuse.Intensities;
import ac.ed.lurg.landuse.Intensity;
import ac.ed.lurg.types.CropType;
import ac.ed.lurg.utils.LogWriter;
import ac.ed.lurg.yield.YieldResponses;

import com.gams.api.GAMSDatabase;
import com.gams.api.GAMSGlobals;
import com.gams.api.GAMSJob;
import com.gams.api.GAMSOptions;
import com.gams.api.GAMSParameter;
import com.gams.api.GAMSVariable;
import com.gams.api.GAMSVariableRecord;
import com.gams.api.GAMSWorkspace;
import com.gams.api.GAMSWorkspaceInfo;

public class GamsLandUseOptimiser {

	private GamsInput inputData;

	public GamsLandUseOptimiser(GamsInput inputData) {
		this.inputData = inputData;
	}

	public GamsOutput run() {

		File workingDirectory = new File(ModelConfig.TEMP_DIR, "GamsTest");
		workingDirectory.mkdir();

		GAMSWorkspaceInfo  wsInfo  = new GAMSWorkspaceInfo();
		wsInfo.setWorkingDirectory(workingDirectory.getAbsolutePath());
		//	wsInfo.setDebugLevel(DebugLevel.VERBOSE);

		GAMSWorkspace ws = new GAMSWorkspace(wsInfo);
		GAMSDatabase inDB = ws.addDatabase();

		setupInDB(inDB);

		GAMSJob gamsJob = ws.addJobFromFile(ModelConfig.GAMS_MODEL);
		GAMSOptions opt = ws.addOptions();
		opt.defines("gdxincname", inDB.getName());

		long startTime = System.currentTimeMillis();
		gamsJob.run(opt, inDB);
		LogWriter.println("Took " + (System.currentTimeMillis() - startTime) + " ms to run");

		return handleResults(gamsJob.OutDB());
	}

	private void setupInDB(GAMSDatabase inDB) {
		LogWriter.println("\nPrevious areas");
		GAMSParameter param = inDB.addParameter("previous_area", 2, "the previous area for each land use");
		addLocationMapParm(param, inputData.getPreviousCropArea());

		LogWriter.println("\nDemand");
		param = inDB.addParameter("demand", 1, "demand for crop");
		addItemMapParm(param, inputData.getCountryInput().getProjectedDemand());

		LogWriter.println("\nYieldNone");
		GAMSParameter yNoneP = inDB.addParameter("yieldNone", 2);
		GAMSParameter y_fert = inDB.addParameter("yieldFertOnly", 2);
		GAMSParameter y_irrig = inDB.addParameter("yieldIrrigOnly", 2);
		GAMSParameter y_both = inDB.addParameter("yieldBoth", 2);
		GAMSParameter fert_p = inDB.addParameter("fertParam", 2);
		GAMSParameter irrig_p = inDB.addParameter("irrigParam", 2);

		for (Entry<Integer, ? extends YieldResponses> cropsForALocation : inputData.getYields().entrySet()) {
			Integer locationId = cropsForALocation.getKey();
			YieldResponses yresp = cropsForALocation.getValue();

			for (CropType crop : CropType.values()) {
				LogWriter.println(String.format("     %15s,\t %.1f", crop.getGamsName(), yresp.getYieldNone(crop)));
				
				Vector<String> v = new Vector<String>();
				v.add(crop.getGamsName());
				v.add(Integer.toString(locationId));

				yNoneP.addRecord(v).setValue(yresp.getYieldNone(crop));
				y_fert.addRecord(v).setValue(yresp.getYieldFertOnly(crop));
				y_irrig.addRecord(v).setValue(yresp.getYieldIrrigOnly(crop));
				y_both.addRecord(v).setValue(yresp.getYieldMax(crop));
				fert_p.addRecord(v).setValue(yresp.getFertParam(crop));
				irrig_p.addRecord(v).setValue(yresp.getIrrigParam(crop));
			}
		}

		LogWriter.println("\nWorld input energy");
		param = inDB.addParameter("world_input_energy", 1, "average input energy from world exports used to determine if we should import or export energy per t");
		addItemMapParm(param, inputData.getCountryInput().getWorldInputEnergy());

		LogWriter.println("\nMax Net Import");
		param = inDB.addParameter("maxNetImport", 1, "max net imports for each crop based on world market");
		addItemMapParm(param, inputData.getCountryInput().getMaxNetImport());

		LogWriter.println("\nMin Net Import");
		param = inDB.addParameter("minNetImport", 1, "min net imports for each crop based on world market");
		addItemMapParm(param, inputData.getCountryInput().getMinNetImport());

		addScalar(inDB.addParameter("meatEfficency", 0, "efficency of converting feed and pasture into animal products"), inputData.getCountryInput().getMeatEfficiency());
		addScalar(inDB.addParameter("maxLandUseChange", 0, "max rate of land use change"), inputData.getCountryInput().getMaxLandUseChange());
		addScalar(inDB.addParameter("tradeBarrier", 0, "trade barrier which adjust energy cost of imports"), inputData.getCountryInput().getTradeBarrier());
		addScalar(inDB.addParameter("landChangeEnergy", 0, "energy required to add ha of agricultural land"), inputData.getCountryInput().getLandChangeEnergy());
		addScalar(inDB.addParameter("minFeedRate", 0, "minimum rate of feed for producing animal products"), inputData.getCountryInput().getMinFeedRate());
	}

	private GamsOutput handleResults(GAMSDatabase outDB) {
		int modelStatus = (int) outDB.getParameter("ms").findRecord().getValue();
		System.out.println(
				"\nModelstatus: " + GAMSGlobals.ModelStat.lookup( modelStatus ) +
				", Solvestatus: " + GAMSGlobals.SolveStat.lookup((int) outDB.getParameter("ss").findRecord().getValue()) );

		GAMSVariable varAreas = outDB.getVariable("area");
		GAMSVariable varFertIntensities = outDB.getVariable("fertI");
		GAMSVariable varIrrigIntensities = outDB.getVariable("irrigI");
		GAMSVariable varOtherIntensities = outDB.getVariable("otherIntensity");
		GAMSVariable varFeedAmount = outDB.getVariable("feedAmount");
		GAMSVariable varNetImports = outDB.getVariable("netImportAmount");

		double totalArea = 0;
		double area, fertIntensity, irrigIntensity, otherIntensity, feedAmount, netImport;

		Map<Integer, Intensities> intensities = new HashMap<Integer, Intensities>();
		Map<Integer, CropAreas> cropAreas = new HashMap<Integer, CropAreas>();
		Map<CropType, Double> feedAmounts = new HashMap<CropType, Double>();
		Map<CropType, Double> netImports = new HashMap<CropType, Double>();

		for (GAMSVariableRecord rec : varAreas) {
			String itemName = rec.getKeys()[0];
			String locationName = rec.getKeys()[1];
			area = rec.getLevel();
			fertIntensity = varFertIntensities.findRecord(itemName, locationName).getLevel();
			irrigIntensity = varIrrigIntensities.findRecord(itemName, locationName).getLevel();
			otherIntensity = varOtherIntensities.findRecord(itemName, locationName).getLevel();
			int locId = Integer.parseInt(locationName);
			CropType cropType = CropType.getForGamsName(itemName);
			
			if (locId == 1) {
				feedAmount = varFeedAmount.findRecord(itemName).getLevel();
				netImport = varNetImports.findRecord(itemName).getLevel();
				feedAmounts.put(cropType, feedAmount);
				netImports.put(cropType, netImport);
				LogWriter.println(String.format("\n%s:\tfeedAmount= %.1f,\tnetImports= %.3f", itemName, feedAmount, netImport)); 
			}

			if (area > 0) {
				LogWriter.println(String.format("\t location %s:\tarea= %.1f,\tfert= %.3f,\tirrg= %.3f,\tintensity= %.3f", 
						locationName, area, fertIntensity, irrigIntensity, otherIntensity)); 

				Intensities intensityItem = intensities.get(locId);
				if (intensityItem == null) {
					intensityItem = new Intensities();
					intensities.put(locId, intensityItem);
				}
				intensityItem.setIntensity(cropType, new Intensity(fertIntensity, irrigIntensity, otherIntensity));

				CropAreas areaItem = cropAreas.get(locId);
				if (areaItem == null) {
					areaItem = new CropAreas();
					cropAreas.put(locId, areaItem);
				}
				areaItem.setCropArea(cropType, area);
				
				totalArea += area;
			}
			
		}
		LogWriter.println(String.format("\nTotal area= %.1f", totalArea));
		//cleanup(ws.workingDirectory());
		
		GamsOutput results = new GamsOutput(modelStatus, intensities, cropAreas, feedAmounts, netImports);
		return results ;
	}

	private void addScalar(GAMSParameter param, double val) {
		param.addRecord().setValue(val);
	}

	private void addItemMapParm(GAMSParameter parm, Map<CropType, Double> itemMap) {
		for (Map.Entry<CropType, Double> entry : itemMap.entrySet()) {
			LogWriter.println(String.format("     %15s,\t %.1f", entry.getKey().getGamsName(), entry.getValue()));
			parm.addRecord(entry.getKey().getGamsName()).setValue(entry.getValue());
		}
	}

	private void addLocationMapParm(GAMSParameter parm, Map<Integer, ? extends CropAreas> locationItemMap) {
		for (Map.Entry<Integer, ? extends CropAreas> cropsForALocation : locationItemMap.entrySet()) {
			Integer locationId = cropsForALocation.getKey();
			CropAreas itemMap = cropsForALocation.getValue();

			for (CropType cropType : CropType.values()) {
				double d = itemMap.getCropArea(cropType);
				LogWriter.println(String.format("     %15s,\t %.1f", cropType.getGamsName(), d));
				Vector<String> v = new Vector<String>();
				v.add(cropType.getGamsName());
				v.add(Integer.toString(locationId));
				parm.addRecord(v).setValue(d);
			}
		}
	}

	@SuppressWarnings("unused")
	private void cleanup(String directory)  {
		File directoryToDelete = new File(directory);
		String files[] = directoryToDelete.list();
		for (String file : files) {
			File fileToDelete = new File(directoryToDelete, file);
			try {
				fileToDelete.delete();
			} catch(Exception e){
				e.printStackTrace();
			}
		}
		try {
			directoryToDelete.delete();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}