Land change simulation

agents.map#

An attribute of the agents painted on their parcels: each cell takes the value of the agent whose id is the cell's parcel (missing where none).

agents.parcels#

An agent per parcel of a map of parcel ids (its cells sharing an id): the columns id and cells (its size), and for every other map input (any name) the mean of the map over the parcel (name). Parcels in increasing order of id.

Takes any other inputs by name (map).

agents.summary#

The number of agents and the sum and mean of each attribute (a row), to collect along a loop.

agents.table#

Agents from a table written in the model (macro agents: countries, markets): agents is a list of objects of numbers, one per agent, or the input table.

agents.update#

The agents' behaviour at a step: rules, lines attribute = expression applied in order (each line sees the lines before), over the agents' attributes and the node's number inputs (any name: the step, a price...): map algebra's expressions, if then else, functions; an attribute may be new.

Takes any other inputs by name (any).

cars.step#

One step of PLUS's CARS: iterations from the current map until every class has the cells of the step's demand, each free cell giving each class the probability of growth x neighbourhood x an adaptive coefficient (random seeds where no neighbour has the class), a roulette wheel picking the class and a decaying threshold deciding the change.

clumondo.ages#

The years each cell has had its land system at the start: the given map (missing cells counted 1), or rand() % max_age + 1 per cell from the runtime generator seeded with the seed (CLUMondo's random ages), else 1.

clumondo.step#

One year of CLUMondo: the suitability of each land system (logistic regressions in floats, or given maps) with its neighbourhood functions and location preferences, then the allocation that meets the demand for goods and services (conversion resistances, the conversion matrix with its codes, ages). stop is true when the year has no solution (CLUMondo stops there: use it as the loop's until).

crafty.allocate#

One step of CRAFTY's competition for land between agent functional types (AFTs): production of services from the cells' capitals, the value of unmet demand, giving up and taking over. The land map holds the AFT of each cell (1, 2... in the order of afts; 0 unmanaged).

demand.from_maps#

The cells of each class at each step, interpolated and extrapolated linearly from observed maps (lulcc's approxExtrapDemand): negative areas set to 0, every step rounded to whole cells that add up to the cells of the first map.

demand.regional#

A demand per region (municipalities, biomes, basins...): each region's cells meet its own demand, cells of no region keep their class. The demand of a region is a table of cells per class and step (CLUE-S, ordered allocation, CARS) or a Markov chain (Expander and Patcher, CARS).

demand.table#

A demand given as a table: classes and one row of cells per step (the first the start).

dinamica.continuous_patcher#

Dinamica EGO's Patcher of a continuous state (PatcherContinuousState), landschaft's ContinuousPatcher: new patches (logging, clearing, harvest) that take the stock of their cells (biomass, carbon, timber) until a quota is met. Seeds drawn among the cells with stock and probability ranked from the highest (prune_factor x quota of stock), in proportion to the probability; lognormal patch sizes grown as the Patcher's.

dinamica.cost_map#

The cost of reaching every cell from the nearest source over a friction surface, Dinamica EGO's CalcCostMap (landschaft's friction_cost): a step into a cell costs its friction (x sqrt 2 on a diagonal), 8 neighbours, Dijkstra's sums; and the direction of each cell's predecessor (1 NW, 2 N, 3 NE, 4 E, 5 SE, 6 S, 7 SW, 8 W; 0 at the sources, 255 unreached).

dinamica.destinations#

Cells drawn by attraction in quadrants of a map, Dinamica EGO's CalcDestinationMap (landschaft's destinations): in each of the horizontal x vertical parts, up to per_quadrant cells in proportion to their attraction, a draw closer than min_distance to an earlier one drawn again.

dinamica.pathways#

Paths from source cells to a network, Dinamica EGO's CalcPathwayMap (landschaft's pathways): from each source (row order) to the cheapest of its 8 neighbours until a cell of cost <= 0 (the network), or along the directions of a cost map until the network.

dinamica.roads#

A step of endogenous road building, Dinamica EGO's road constructor (landschaft's RoadBuilder.step): the attraction kept where the distance to the roads is within distance (and the mask allows), destinations drawn in quadrants, each joined to the network down the cost of reaching it over the friction; the network with the new roads, and the distance to them (a dynamic variable).

dinamica.step#

One step of Dinamica's Expander and Patcher: the changes of each transition (its rate per step times the cells of its origin class) split between the Expander, which grows existing patches, and the Patcher, which seeds new ones, with lognormal patch sizes shaped by the isometry.

dynamic.distance_to#

The distance from each cell to the nearest cell of some classes (exact Euclidean distance between cell centres), in map units or cells: a driver that moves with the simulated map.

dynamic.share_of#

The share of the cells around each cell that hold some classes (the mean of the window's weights x presence over the cells with a value): a driver that moves with the simulated map.

futures.calibrate#

The calibration of FUTURES' patches (r.futures.calib through landschaft's calibrate_patches): the patches developed between the start and the end give the patch library and the histograms of patch area and compactness (perimeter / (2 sqrt(pi area))); every combination of the compactness means, ranges and discount factors is simulated repeat times from the start (futures.simulation's settings, seeds (seed + k) 10000 + i) and its patches compared with the observed ones by the histograms' chi-square distance. The combinations from the best, as landschaft's.

futures.devpressure#

The development pressure of each cell (r.futures.devpressure through landschaft): the sum over the developed cells within a radius (a circular window, the cell itself left out) of 1 (occurrence), scaling / d^gamma (gravity) or scaling exp(-2 d / gamma) (kernel), as GRASS's r.mfilter computes it; the pressure futures.simulation starts from.

futures.patch_library#

The sizes of the patches developed between two maps (r.futures.calib's patch library through landschaft): the 4-connected groups of cells developed in the end and not at the start (inside a subregion), in cells, sorted; one library per subregion (each patch cut to its part in it), or one for all. The patch_sizes futures.simulation draws from.

futures.simulation#

FUTURES' patch growing (r.futures.simulation): at every step each subregion develops its demand in patches grown from seeds drawn on the development probability (the potential's coefficients, the development pressure updated around every new cell, zoning, incentives), with the flood submodel (damage, retreat, adaptation, migration) when given.

glm.coefficients#

Logistic regressions given in the model: per class, its drivers and coefficients (the intercept first), as glm.fit gives them.

glm.fit#

Logistic regression of the presence of each class on the drivers (lulcc's glmModels, R's glm.fit operation for operation), on the cells with a value in the map and in the class's drivers.

glm.predict#

The probability of each class in every cell from fitted logistic regressions (NaN where a driver, or the landscape when given, is missing).

lulcc.history#

The steps each cell has had its class at the start (lulcc's hist): the given map, missing cells counted 1, else 1 everywhere.

lulcc.step#

One step of a CLUE-S or ordered allocation (lulcc's allocate): the elasticity of each cell's class (CLUE), the neighbourhood rules, the conversion matrix with its time and demand codes, the automatic conversions of cells whose class is no longer allowed, then the allocation of the step's demand.

markov.fit#

A Markov chain of land change from two maps: the transition probabilities of the period (cells of each class at the start that hold each class at the end) and, over steps time steps, those of one step (the principal root of the period's matrix, as Dinamica EGO's DetermineTransitionMatrix).

markov.matrix#

A Markov chain given in the model: the transition probabilities of a period over steps steps (rows the class at the start); those per step are its principal root, unless given.

molusce.step#

One iteration of MOLUSCE's Simulator: every cell is predicted the transition of largest total weight (or the class of largest potential) with a confidence (100 x the gap to the second, truncated); then for each pair of classes of the map, the cells predicted to take it with the highest confidence + U(0, 1) / 1000 change, as many as the observed cross table says.

molusce.total#

MOLUSCE's total weight of each transition: per transition, the sum over the drivers of the weight of each cell's category (drivers cut by their bins, or integer categories); NaN where a driver has no value.

patches.observe#

The Expander and Patcher settings of each transition with a rate, measured on the observed change: the share of the changed cells in expansions of existing patches (8 neighbours), and the mean and variance of the sizes of the expansion and new patches; the isometry is given.

patches.settings#

The Expander and Patcher settings given in the model: per transition the Expander's share and the mean, variance and isometry of the patches of each function.

plus.demand#

The cells of each class at each step for CARS: a Markov chain projected from the starting map (PLUS's default, rounded to whole cells), or an area demand.

validate.agreement#

How a simulated map matches the observed one, both from the same start: the share of cells of the same class, the figure of merit (hits / (hits + misses + false alarms + wrong hits)) and its terms.

validate.error_budget#

MOLUSCE's error budget (Pontius 2002, through landschaft): the agreement of the maps when the simulation has no, medium or perfect information of quantity and location, at the maps' resolution and coarser ones, merging scale x scale cells each time (the edges left over dropped).

validate.futures#

FUTURES' validation (r.futures.validation through landschaft): the quantity and allocation disagreement per class and in total (Pontius & Millones 2011) and kappa; with the original map, kappa simulation (van Vliet et al. 2011) and, for 0/1 maps, misses, hits, false alarms, null successes, the figure of merit, producer's and user's accuracy (Pontius et al. 2008).

validate.futures_grid#

FUTURES' validation per tile or per region (r.futures.gridvalidation through landschaft): a row per tile of size x size cells from the top-left (its row, column and centre) or per region, the metrics of validate.futures and the cells compared.

validate.kappa#

MOLUSCE's comparison of two maps of classes (DependenceCoef through landschaft): kappa, kappa location and kappa histogram and the % of cells of the same class over the classes of both maps; Cramer's V and the joint information uncertainty; the correlation of the class values.

validate.similarity#

Dinamica EGO's validation: the fuzzy similarity of the simulated and the observed change (the cells that changed from the start, in their new class) in windows of growing size; the minimum of the two directions is Dinamica's result.

validate.three_map#

The three-map comparison of a simulation (Pontius, Peethambaram & Castella 2011; lulcc's ThreeMapComparison through landschaft): the reference at the start and at the end and the simulated end compared at blocks of several sizes, the budget of agreement and disagreement (misses, hits, wrong hits, false alarms, correct rejections; overall, per class, per transition) and the figure of merit. The cells without a value in any map are left out of all three.

woe.fit#

Weights of evidence of each transition, calibrated on two maps as Dinamica EGO does: the ranges of a continuous variable from nested buffers of increment cut by line generalisation (a new range when the direction deviates by more than tolerance degrees or the range passes max_delta cells, none below min_delta), a range per category of a categorical one; W+ per range.

woe.probability#

The probability of each calibrated transition at every cell of its initial class, from the weights of evidence (Dinamica EGO's CalcWOfEProbabilityMap).

woe.weights#

Weights of evidence given in the model (as woe.fit gives them): transitions, ranges and weights.