GamsLocationOptimiser.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.AreasItem;
import ac.ed.lurg.landuse.CropUsageData;
import ac.ed.lurg.landuse.IntensitiesItem;
import ac.ed.lurg.landuse.Intensity;
import ac.ed.lurg.landuse.IrrigationCostItem;
import ac.ed.lurg.types.CommodityType;
import ac.ed.lurg.types.CropType;
import ac.ed.lurg.utils.LogWriter;
import ac.ed.lurg.yield.YieldResponsesItem;

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

public class GamsLocationOptimiser {

	// DM kg / kg
	// cereals 0.86
	// oilcrops 0.90
	// soy 0.89
	// potatoes 0.21
	
	private static final boolean DEBUG = true;
	
	private GamsLocationInput inputData;

	public GamsLocationOptimiser(GamsLocationInput inputData) {
		this.inputData = inputData;
	}

	public GamsLocationOutput 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.setAllModelTypes("conopt");
		
		opt.defines("gdxincname", inDB.getName());

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

		return handleResults(gamsJob.OutDB());
	}

	private void setupInDB(GAMSDatabase inDB) {
		if (DEBUG) LogWriter.println("\nLocation set");
		GAMSSet locationSet = inDB.addSet("location", 1);
		for (Integer locId : inputData.getPreviousAreas().keySet()) {
			if (DEBUG) LogWriter.println("     " + locId);
			locationSet.addRecord(locId.toString());
		}

		if (DEBUG) LogWriter.println("\nPrevious crop and land areas");	
		GAMSParameter prevCropP = inDB.addParameter("previousArea", 2);
		GAMSParameter landP = inDB.addParameter("suitableLandArea", 1);

		double totalAgriLand = 0;
		
		for (Map.Entry<Integer, ? extends AreasItem> entry : inputData.getPreviousAreas().entrySet()) {
			Integer locationId = entry.getKey();
			String locString = Integer.toString(locationId);
			AreasItem areasItem = entry.getValue();

			for (CropType cropType : CropType.values()) {
				double d = areasItem.getCropArea(cropType);
				if (DEBUG) if (d != 0) LogWriter.println(String.format("  %d   %15s,\t %.1f", locationId, cropType.getGamsName(), d));
				Vector<String> v = new Vector<String>();
				v.add(cropType.getGamsName());
				v.add(locString);
				prevCropP.addRecord(v).setValue(d);
				totalAgriLand += d;
			}

			double suitableLand = areasItem.getSuitableLand();
			if (DEBUG) LogWriter.println(String.format("  %d   %15s,\t %.1f", locationId, "suitableLand", suitableLand));
			landP.addRecord(locString).setValue(suitableLand);
		}
		if (DEBUG) LogWriter.println(String.format("  Total agricultural\t %.1f", totalAgriLand));

		if (DEBUG) LogWriter.println("\nIrrigation cost");
		GAMSParameter irrigCostP = inDB.addParameter("irrigCost", 1);
		for (Entry<Integer, ? extends IrrigationCostItem> entry : inputData.getIrrigationCosts().entrySet()) {
			Integer locationId = entry.getKey();
			IrrigationCostItem irrigCostItem = entry.getValue();
			double irrigCost = irrigCostItem.getIrrigCost();
			if (DEBUG) LogWriter.println(String.format("  %d   %15s,\t %.1f", locationId, "irrigCost", irrigCost));
			irrigCostP.addRecord(Integer.toString(locationId)).setValue(irrigCost);
		}

		if (DEBUG) LogWriter.println("\nDemand");
		GamsCountryInput countryInput = inputData.getCountryInput();
		addCommodityMapParm(inDB.addParameter("demand", 1), countryInput.getProjectedDemand());

		if (DEBUG) LogWriter.println("\nYield (fert/irrig) None/None, Max/None, None/Max, Max/Max,\t [fert p],\t [irrig p]");
		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 YieldResponsesItem> entry : inputData.getYields().entrySet()) {
			Integer locationId = entry.getKey();
			String locString = Integer.toString(locationId);
			YieldResponsesItem yresp = entry.getValue();

			for (CropType crop : CropType.getNonMeatTypes()) {
				if (DEBUG) LogWriter.println(String.format("%d     %15s,\t %.1f,\t %.1f, \t %.1f,\t %.1f,\t\t [%.2f],\t [%.2f]", 
						locationId, crop.getGamsName(), yresp.getYieldNone(crop), yresp.getYieldFertOnly(crop), yresp.getYieldIrrigOnly(crop), yresp.getYieldMax(crop), yresp.getFertParam(crop), yresp.getIrrigParam(crop)));

				Vector<String> v = new Vector<String>();
				v.add(crop.getGamsName());
				v.add(locString);

				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));
			}
		}

		if (DEBUG) LogWriter.println("\nWorld input energy");
		addItemMapParm(inDB.addParameter("worldInputEnergy", 1), countryInput.getWorldInputEnergy());

		if (DEBUG) LogWriter.println("\nMax Net Import");
		addItemMapParm(inDB.addParameter("maxNetImport", 1), countryInput.getMaxNetImport());

		if (DEBUG) LogWriter.println("\nMin Net Import");
		addItemMapParm(inDB.addParameter("minNetImport", 1), countryInput.getMinNetImport());

		addScalar(inDB.addParameter("meatEfficency", 0), countryInput.getMeatEfficiency());
		if (DEBUG) LogWriter.println("\nMeatEfficiency: " + countryInput.getMeatEfficiency());
		
		addScalar(inDB.addParameter("maxLandUseChange", 0), countryInput.getMaxLandUseChange());
		if (DEBUG) LogWriter.println("\nMaxLandUseChange: " + countryInput.getMaxLandUseChange());
		
		addScalar(inDB.addParameter("landChangeEnergy", 0), countryInput.getLandChangeEnergy());
		if (DEBUG) LogWriter.println("\nLandChangeEnergy: " + countryInput.getLandChangeEnergy());
		
		addScalar(inDB.addParameter("minFeedRate", 0), countryInput.getMinFeedRate());
		if (DEBUG) LogWriter.println("\nMinFeedRate: " + countryInput.getMinFeedRate());
		
		double fitToPreviousAreas = countryInput.isCalibrateToObserved() ? 1 : 0;
		if (DEBUG) LogWriter.println("\nfitToPreviousAreas: " + fitToPreviousAreas);
		addScalar(inDB.addParameter("fitToPreviousAreas", 0), fitToPreviousAreas);

		if (DEBUG) LogWriter.println("\ncropAdj");
		addItemMapParm(inDB.addParameter("cropAdj", 1), countryInput.getCropAdjustments());
	}

	private GamsLocationOutput 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");
		GAMSVariable varYields = outDB.getVariable("yield");
		GAMSVariable varUnitEnergies = outDB.getVariable("unitEnergy");
		GAMSParameter parmCropAdj = outDB.getParameter("cropAdj");
		GAMSParameter parmProd = outDB.getParameter("totalProd");
		GAMSParameter parmProdCost = outDB.getParameter("totalProdCost");
		
		double totalArea = 0;
		double area, fertIntensity, irrigIntensity, otherIntensity = Double.NaN, feedAmount, netImport, yield, unitEnergy, cropAdj, prod, prodCost;

		Map<Integer, IntensitiesItem> intensities = new HashMap<Integer, IntensitiesItem>();
		Map<Integer, AreasItem> cropAreas = new HashMap<Integer, AreasItem>();
		Map<CropType, CropUsageData> cropUsageData = new HashMap<CropType, CropUsageData>();
		Map<CropType, Double> cropAdjs = new HashMap<CropType, Double>();
		CropType prevCropType = null;

		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();
			yield = varYields.findRecord(itemName, locationName).getLevel();
			unitEnergy = varUnitEnergies.findRecord(itemName, locationName).getLevel();

			int locId = Integer.parseInt(locationName);
			CropType cropType = CropType.getForGamsName(itemName);

			if (!cropType.equals(prevCropType)) {
				feedAmount = varFeedAmount.findRecord(itemName).getLevel();
				netImport = cropType.isImportedCrop() ? varNetImports.findRecord(itemName).getLevel() : 0;
				cropAdj = getParmValue(parmCropAdj, itemName);
				prod =  getParmValue(parmProd, itemName);
				prodCost = getParmValue(parmProdCost, itemName);
				
				cropUsageData.put(cropType, new CropUsageData(feedAmount, netImport, prod, prodCost));
				cropAdjs.put(cropType, cropAdj);
				if (DEBUG) LogWriter.println(String.format("\n%s:\tfeedAmount= %.1f,\tnetImports= %.3f,\tprod= %.3f,\tprodCost= %.3f,\tcropAdj= %.3f", itemName, feedAmount, netImport, prod, prodCost, cropAdj)); 
			}

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

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

				AreasItem areaItem = cropAreas.get(locId);
				if (areaItem == null) {
					areaItem = new AreasItem();
					cropAreas.put(locId, areaItem);
				}
				areaItem.setCropArea(cropType, area);
				totalArea += area;
			}
			prevCropType = cropType;
		}
		
		netImport = varNetImports.findRecord(CropType.MEAT.getGamsName()).getLevel();
		prod = parmProd.findRecord(CropType.MEAT.getGamsName()).getValue();
		prodCost = parmProdCost.findRecord(CropType.MEAT.getGamsName()).getValue();
		cropUsageData.put(CropType.MEAT, new CropUsageData(0.0, netImport, prod, prodCost));
		if (DEBUG) {
			LogWriter.println(String.format("\n%s:\t\t\t\t\tnetImports= %.3f,\tprod= %.3f,\tprodCost= %.3f", CropType.MEAT.getGamsName(), netImport, prod, prodCost)); 
			LogWriter.println(String.format("\nTotal area= %.1f", totalArea));
		}
		
		GamsLocationOutput results = new GamsLocationOutput(modelStatus, intensities, cropAreas, cropUsageData, cropAdjs);
		return results;
	}
	
	private double getParmValue(GAMSParameter aParm, String itemName) {
		try {
			double d = aParm.findRecord(itemName).getValue();
			return d;
		}
		catch (GAMSException gamsEx) {
			//LogWriter.println("GAMSException thrown for " + itemName);
			return 0;
		}
	}

	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()) {
			double d = entry.getValue();
			if (DEBUG) LogWriter.println(String.format("     %15s,\t %.3f", entry.getKey().getGamsName(), d));
			if (!Double.isNaN(d))
				parm.addRecord(entry.getKey().getGamsName()).setValue(d);
		}
	}
	
	private void addCommodityMapParm(GAMSParameter parm, Map<CommodityType, Double> itemMap) {
		for (Map.Entry<CommodityType, Double> entry : itemMap.entrySet()) {
			double d = entry.getValue();
			if (DEBUG) LogWriter.println(String.format("     %15s,\t %.1f", entry.getKey().getGamsName(), d));
			if (!Double.isNaN(d))
				parm.addRecord(entry.getKey().getGamsName()).setValue(d);
		}
	}


	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();
		}
	}
}