InputParameters.cs

// Author: Clément Hardy
// With many elements copied from the corresponding class
// in the "Base Fire" extension by Robert M. Scheller and James B. Domingo

using Landis.Utilities;
using System.Collections.Generic;
using System.Text;

namespace Landis.Extension.ForestRoadsSimulation
{
	/// <summary>
	/// Parameters for the plug-in.
	/// </summary>
	public interface IInputParameters
	{
		// ------------------------------------------------------------------------------
		// BASIC PARAMETERS

		/// <summary>
		/// Timestep (years)
		/// </summary>
		int Timestep
		{
			get; set;
		}

		/// <summary>
		/// The heuristic given by the user to determine the ordrer in which the roads are built with the least-cost path algorithm.
		/// </summary>
		string HeuristicForNetworkConstruction
		{
			get; set;
		}

		/// <summary>
		/// The distance (in meters) onto which wood can be skidded, rather than transported on a road.
		/// </summary>
		int SkiddingDistance
		{
			get; set;
		}

		/// <summary>
		/// Boolean describing if the looping behavior is activated
		/// </summary>
		bool LoopingBehavior
		{
			get; set;
		}

		/// <summary>
		/// The distance (in meters) under which we will not create a loop if there is a road
		/// </summary>
		int LoopingMinDistance
		{
			get; set;
		}

		/// <summary>
		/// The distance (in meters) under which we will consider creating a loop if there are at least 2 road pixels
		/// </summary>
		int LoopingMaxDistance
		{
			get; set;
		}

		/// <summary>
		/// The percentage of roads in the looping distance around a site under which a loop will be created.
		/// </summary>
		int LoopingMaxPercentageOfRoads
		{
			get; set;
		}

		/// <summary>
		/// A multiplicative value affecting the behavior of the looping algorithm.
		/// </summary>
		double LoopingMaxCost
		{
			get; set;
		}

		/// <summary>
		/// The probability to construct a loop if all other conditions are validated in the loop algorithm.
		/// </summary>
		int LoopingProbability
		{
			get; set;
		}

		/// <summary>
		/// Path to save the output maps of the forest road network
		/// </summary>
		string OutputsOfRoadNetworkMaps
		{
			get; set;
		}

		/// <summary>
		/// Path of the folder where the log must be saved
		/// </summary>
		string OutputsOfRoadLog
		{
			get; set;
		}

		// ------------------------------------------------------------------------------
		// INPUT RASTERS AND COST PARAMETERS

		/// <summary>
		/// Path of the raster file containing the zones of the landscape where roads can be built
		/// </summary>
		string ZonesForRoadCreation
		{
			get; set;
		}

		/// <summary>
		/// Path of the raster file containing the initial road network
		/// </summary>
		string InitialRoadNetworkMap
		{
			get; set;
		}

		/// <summary>
		/// The basic cost of building a forest road on the distance of a site
		/// </summary>
		double DistanceCost
		{
			get; set;
		}

		/// <summary>
		/// Path of the raster file containing the coarse elevation values
		/// </summary>
		string CoarseElevationRaster
		{
			get; set;
		}

		/// <summary>
		/// The multiplication value used to increase cost of construction with elevation differences.
		/// </summary>
		ElevationCostRanges CoarseElevationCosts
		{
			get; set;
		}

		/// <summary>
		/// Path of the raster file containing the fine elevation values
		/// </summary>
		string FineElevationRaster
		{
			get; set;
		}

		/// <summary>
		/// The multiplication value used to increase cost of construction with elevation differences.
		/// </summary>
		ElevationCostRanges FineElevationCosts
		{
			get; set;
		}

		/// <summary>
		/// Path of the raster file containing the coarse water values
		/// </summary>
		string CoarseWaterRaster
		{
			get; set;
		}

		/// <summary>
		/// The cost of constructing a bridge on a body of water the size of the site
		/// </summary>
		int CoarseWaterCost
		{
			get; set;
		}

		/// <summary>
		/// Path of the raster file containing the fine water values
		/// </summary>
		string FineWaterRaster
		{
			get; set;
		}

		/// <summary>
		/// The mean cost of constructing a culvert on one stream
		/// </summary>
		int FineWaterCost
		{
			get; set;
		}

		/// <summary>
		/// Path of the raster file containing the soil regions
		/// </summary>
		string SoilsRaster
		{
			get; set;
		}

		// ------------------------------------------------------------------------------
		// ROAD TYPE THRESHOLDS AND MULTIPLICATION VALUES

		/// <summary>
		/// Parameter indicating if the scenecence of roads must be modeled in the simulation
		/// </summary>
		bool SimulationOfRoadAging
		{
			get; set;
		}

		/// <summary>
		/// Parameter indicating if the flux of woods must be modeled in the simulation
		/// </summary>
		bool SimulationOfWoodFlux
		{
			get; set;
		}

		/// <summary>
		/// Table of parameters for the roads that are not exit points, meaning the forest roads that can be created by the module
		/// </summary>
		RoadCatalogue RoadCatalogueNonExit
		{
			get; set;
		}

		/// <summary>
		/// Table of parameters for the roads that are exit points
		/// </summary>
		RoadCatalogue RoadCatalogueExit
		{
			get; set;
		}
	}

	/// <summary>
	/// Parameters for the plug-in.
	/// </summary>
	public class InputParameters
		: IInputParameters
	{
		private int timestep;
		private string heuristicForNetworkConstruction;
		private int skiddingDistance;
		private bool loopingBehavior;
		private int loopingMinDistance;
		private int loopingMaxDistance;
		private int loopingMaxPercentageOfRoads;
		private double loopingMaxCost;
		private int loopingProbability;
		private string outputsOfRoadNetworkMaps;
		private string outputsOfRoadLog;

		private string zonesForRoadCreation;
		private string initialRoadNetworkMap;
		private double distanceCost;
		private string coarseElevationRaster;
		private ElevationCostRanges coarseElevationCosts;
		private string fineElevationRaster;
		private ElevationCostRanges fineElevationCosts;
		private string coarseWaterRaster;
		private int coarseWaterCost;
		private string fineWaterRaster;
		private int fineWaterCost;
		private string soilsRaster;

		private bool simulationOfRoadAging;
		private bool simulationOfWoodFlux;
		private RoadCatalogue roadCatalogueNonExit;
		private RoadCatalogue roadCatalogueExit;

		// ------------------------------------------------------------------------------
		// BASIC PARAMETERS

		/// <summary>
		/// Timestep (years)
		/// </summary>
		public int Timestep
		{
			get
			{
				return timestep;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				timestep = value;
			}
		}

		/// <summary>
		/// The heuristic given by the user to determine the ordrer in which the roads are built with the least-cost path algorithm.
		/// </summary>
		public string HeuristicForNetworkConstruction
		{
			get
			{
				return heuristicForNetworkConstruction;
			}
			set
			{
				if (value != "Random" && value != "Closestfirst" && value != "Farthestfirst")
				{
					throw new InputValueException(value.ToString(), "Value must be \"Random\", \"Closestfirst\" or \"Farthestfirst\".");
				}
				else heuristicForNetworkConstruction = value;
			}
		}

		/// <summary>
		/// The distance (in meters) onto which wood can be skidded, rather than transported on a road.
		/// </summary>
		public int SkiddingDistance
		{
			get
			{
				return skiddingDistance;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				skiddingDistance = value;
			}
		}

		/// <summary>
		/// Indicates if looping behavior is activated.
		/// </summary>
		public bool LoopingBehavior
		{
			get
			{
				return loopingBehavior;
			}
			set
			{
				loopingBehavior = value;
			}
		}

		/// <summary>
		/// The distance (in meters) under which we will not create a loop if there is a road
		/// </summary>
		public int LoopingMinDistance
		{
			get
			{
				return loopingMinDistance;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				loopingMinDistance = value;
			}
		}

		/// <summary>
		/// The distance (in meters) under which we will consider creating a loop if there are at least 2 road pixels
		/// </summary>
		public int LoopingMaxDistance
		{
			get
			{
				return loopingMaxDistance;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				loopingMaxDistance = value;
			}
		}

		/// <summary>
		/// The percentage of roads in the looping distance around a site under which a loop will be created.
		/// </summary>
		public int LoopingMaxPercentageOfRoads
		{
			get
			{
				return loopingMaxPercentageOfRoads;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				loopingMaxPercentageOfRoads = value;
			}
		}

		/// <summary>
		///  A multiplicative value affecting the behavior of the looping algorithm.
		/// </summary>
		public double LoopingMaxCost
		{
			get
			{
				return loopingMaxCost;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				loopingMaxCost = value;
			}
		}

		/// <summary>
		/// The probability to construct a loop if all other conditions are validated in the loop algorithm.
		/// </summary>
		public int LoopingProbability
		{
			get
			{
				return loopingProbability;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				loopingProbability = value;
			}
		}

		/// <summary>
		/// Path to save the output maps of the forest road network
		/// </summary>
		public string OutputsOfRoadNetworkMaps
		{
			get
			{
				return outputsOfRoadNetworkMaps;
			}
			set
			{
				if (value != null)
				{
					// FIXME: check for null or empty path (value.Actual);
					outputsOfRoadNetworkMaps = value;
				}
				else throw new InputValueException(value.ToString(), "A correct path to a file must be given");
			}
		}

		/// <summary>
		/// Path of the folder where the log must be saved
		/// </summary>
		public string OutputsOfRoadLog
		{
			get
			{
				return outputsOfRoadLog;
			}
			set
			{
				if (value != null)
				{
					// FIXME: check for null or empty path (value.Actual);
					outputsOfRoadLog = value;
				}
				else throw new InputValueException(value.ToString(), "A correct path to a folder must be given");
			}
		}

		// ------------------------------------------------------------------------------
		// INPUT RASTERS AND COST PARAMETERS

		/// <summary>
		/// Path of the raster file containing the zones where the roads can be built.
		/// </summary>
		public string ZonesForRoadCreation
		{
			get
			{
				return zonesForRoadCreation;
			}
			set
			{
				if (value != null)
				{
					zonesForRoadCreation = value;
				}
				else throw new InputValueException(value.ToString(), "A correct path to a file must be given");
			}
		}

		/// <summary>
		/// Path of the raster file containing the initial road network
		/// </summary>
		public string InitialRoadNetworkMap
		{
			get
			{
				return initialRoadNetworkMap;
			}
			set
			{
				if (value != null)
				{
					initialRoadNetworkMap = value;
				}
				else throw new InputValueException(value.ToString(), "A correct path to a file must be given");
			}
		}

		/// <summary>
		/// The basic cost of building a forest road on the distance of a site
		/// </summary>
		public double DistanceCost
		{
			get
			{
				return distanceCost;
			}
			set
			{
				if (value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				distanceCost = value;
			}
		}

		/// <summary>
		/// Path of the raster file containing the coarse elevation values
		/// </summary>
		public string CoarseElevationRaster
		{
			get
			{
				return coarseElevationRaster;
			}
			set
			{
				if (value != null)
				{
					coarseElevationRaster = value;
				}
				else if (value == "None" || value == "none" || value == "" || value == null) coarseElevationRaster = "none";
			}
		}

		/// <summary>
		/// The multiplication value used to increase cost of construction with elevation differences.
		/// </summary>
		public ElevationCostRanges CoarseElevationCosts
		{
			get
			{
				return coarseElevationCosts;
			}
			set
			{
				if (this.CoarseElevationRaster == "none") coarseElevationCosts = null;
				else if (this.CoarseElevationRaster != "none" && value == null)
					throw new InputValueException(value.ToString(), "Problem with the coarse elevation costs. Please check your parameter file.");
				else coarseElevationCosts = value;
			}
		}

		/// <summary>
		/// Path of the raster file containing the fine elevation values
		/// </summary>
		public string FineElevationRaster
		{
			get
			{
				return fineElevationRaster;
			}
			set
			{
				if (value != null)
				{
					fineElevationRaster = value;
				}
				else if (value == "None" || value == "none" || value == "" || value == null) fineElevationRaster = "none";
			}
		}

		/// <summary>
		/// The multiplication value used to increase cost of construction with elevation differences.
		/// </summary>
		public ElevationCostRanges FineElevationCosts
		{
			get
			{
				return fineElevationCosts;
			}
			set
			{
				if (this.FineElevationRaster == "none") fineElevationCosts = null;
				else if (this.FineElevationRaster != "none" && value == null)
					throw new InputValueException(value.ToString(), "Problem with the fine elevation costs. Please check your parameter file.");
				else fineElevationCosts = value;
			}
		}

		/// <summary>
		/// Path of the raster file containing the coarse water values
		/// </summary>
		public string CoarseWaterRaster
		{
			get
			{
				return coarseWaterRaster;
			}
			set
			{
				if (value != null)
				{
					coarseWaterRaster = value;
				}
				else if (value == "None" || value == "none" || value == "" || value == null) coarseWaterRaster = "none";
			}
		}

		/// <summary>
		/// The cost of constructing a bridge on a body of water the size of the site
		/// </summary>
		public int CoarseWaterCost
		{
			get
			{
				return coarseWaterCost;
			}
			set
			{
				if (this.CoarseWaterRaster == "none") coarseWaterCost = 0;
				else if (this.CoarseWaterRaster != "none" && value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				else coarseWaterCost = value;
			}
		}

		/// <summary>
		/// Path of the raster file containing the fine water values
		/// </summary>
		public string FineWaterRaster
		{
			get
			{
				return fineWaterRaster;
			}
			set
			{
				if (value != null)
				{
					fineWaterRaster = value;
				}
				else if (value == "None" || value == "none" || value == "" || value == null) fineWaterRaster = "none";
			}
		}

		/// <summary>
		/// The mean cost of constructing a culvert on one stream
		/// </summary>
		public int FineWaterCost
		{
			get
			{
				return fineWaterCost;
			}
			set
			{
				if (this.FineWaterRaster == "none") fineWaterCost = 0;
				else if (this.FineWaterRaster != "none" && value < 0)
					throw new InputValueException(value.ToString(), "Value must be = or > 0.");
				else fineWaterCost = value;
			}
		}

		/// <summary>
		/// Path of the raster file containing the soil regions
		/// </summary>
		public string SoilsRaster
		{
			get
			{
				return soilsRaster;
			}
			set
			{
				if (value != null)
				{
					soilsRaster = value;
				}
				else if (value == "None" || value == "none" || value == "" || value == null) soilsRaster = "none";
			}
		}

		// ------------------------------------------------------------------------------
		// ROAD TYPE THRESHOLDS AND MULTIPLICATION VALUES

		/// <summary>
		/// Indicate if road aging will be simulated
		/// </summary>
		public bool SimulationOfRoadAging
		{
			get
			{
				return simulationOfRoadAging;
			}
			set
			{
				simulationOfRoadAging = value;
			}
		}

		/// <summary>
		/// Indicate if road aging will be simulated
		/// </summary>
		public bool SimulationOfWoodFlux
		{
			get
			{
				return simulationOfWoodFlux;
			}
			set
			{
				simulationOfWoodFlux = value;
			}
		}

		/// <summary>
		/// The object containing all of the informations on the road types.
		/// </summary>
		public RoadCatalogue RoadCatalogueNonExit
		{
			get
			{
				return roadCatalogueNonExit;
			}
			set
			{
				if (value == null)
					throw new InputValueException(value.ToString(), "Value must not be null.");
				else roadCatalogueNonExit = value;
			}
		}

		/// <summary>
		/// The object containing all of the informations on the road type where the wood can exit.
		/// </summary>
		public RoadCatalogue RoadCatalogueExit
		{
			get
			{
				return roadCatalogueExit;
			}
			set
			{
				if (value == null)
					throw new InputValueException(value.ToString(), "Value must not be null.");
				else roadCatalogueExit = value;
			}
		}

		public InputParameters()
		{
		}
	}
}