diff --git a/Untitled/MyLibrary.bib b/Untitled/MyLibrary.bib
new file mode 100644
index 0000000..cfbb472
--- /dev/null
+++ b/Untitled/MyLibrary.bib
@@ -0,0 +1,3308 @@
+
+@article{noauthor_permafrost_2018,
+	title = {Permafrost Terrain Dynamics and Infrastructure Impacts Revealed by {UAV} Photogrammetry and Thermal Imaging},
+	abstract = {Unmanned Aerial Vehicle ({UAV}) systems, sensors, and photogrammetric processing techniques have enabled timely and highly detailed three-dimensional surface reconstructions at a scale that bridges the gap between conventional remote-sensing and ﬁeld-scale observations. In this work 29 rotary and ﬁxed-wing {UAV} surveys were conducted during multiple ﬁeld campaigns, totaling 47 ﬂights and over 14.3 km2, to document permafrost thaw subsidence impacts on or close to road infrastructure in the Northwest Territories, Canada. This paper provides four case studies: (1) terrain models and orthomosaic time series revealed the morphology and daily to annual dynamics of thaw-driven mass wasting phenomenon (retrogressive thaw slumps; {RTS}). Scar zone cut volume estimates ranged between 3.2 × 103 and 5.9 × 106 m3. The annual net erosion of {RTS} surveyed ranged between 0.35 × 103 and 0.39 × 106 m3. The largest {RTS} produced a long debris tongue with an estimated volume of 1.9 × 106 m3. Downslope transport of scar zone and embankment ﬁll materials was visualized using ﬂow vectors, while thermal imaging revealed areas of exposed ground ice and mobile lobes of saturated, thawed materials. (2) Stratigraphic models were developed for {RTS} headwalls, delineating ground-ice bodies and stratigraphic unconformities. (3) In poorly drained areas along road embankments, {UAV} surveys detected seasonal terrain uplift and settlement of up to 0.5 m ({\textgreater}1700 m2 in extent) as a result of injection ice development. (4) Time series of terrain models highlighted the thaw-driven evolution of a borrow pit (6.4 × 105 m3 cut volume) constructed in permafrost terrain, whereby ﬂuvial and thaw-driven sediment transfer (1.1 and 3.9 × 103 m3 a−1 respectively) was observed and whereby annual slope proﬁle reconﬁguration was monitored to gain management insights concerning site stabilization. Elevation model vertical accuracies were also assessed as part of the case studies and ranged between 0.02 and 0.13 m Root Mean Square Error, whereby photogrammetric models processed with Post-processed Kinematic image solutions achieved similar accuracies without ground control points over much larger and complex areas than previously reported. The high resolution of {UAV} surveys, and the capacity to derive quantitative time series provides novel insights into permafrost processes that are otherwise challenging to study. The timely emergence of these tools bridges ﬁeld-based research and applied studies with broad-scale remote-sensing approaches during a period when climate change is transforming permafrost environments.},
+	pages = {30},
+	date = {2018},
+	langid = {english},
+	file = {2018 - Permafrost Terrain Dynamics and Infrastructure Imp.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\FUDSGAUE\\2018 - Permafrost Terrain Dynamics and Infrastructure Imp.pdf:application/pdf}
+}
+
+@thesis{tank_sources_2009,
+	location = {Canada},
+	title = {Sources and cycling of dissolved organic carbon across a landscape of arctic delta lakes},
+	abstract = {Dissolved organic carbon ({DOC}) is a key regulator of aquatic ecosystems, and the primary substrate for aquatic bacteria. However, variations in function between different {DOC} sources are rarely studied. Arctic Mackenzie Delta lakes exhibit striking differences in {DOC} composition, with {DOC} sources ranging from C produced as a byproduct of aquatic plant (macrophyte) photosynthesis, to C derived from permafrost melting (thermokarst), and C delivered to lakes via river-water. This study assessed how variations in {DOC} source regulate the composition of the within-lake pool, drive bacterial metabolism and the contribution of bacterial biomass to higher trophic levels, and affect {CO}2 flux from Delta lakes. {DOC}-specific tracers showed macrophyte-derived {DOC} to comprise less than 15\% of the {DOC} pool in macrophyte-rich lakes, despite macrophyte C levels 7-12-fold greater than total {DOC}. However, bacterial δ13C indicated that bacteria preferentially incorporate {DOC} generated by macrophytes, while surveys and incubation experiments showed that bacterial metabolism is rapid on macrophytic {DOC}, with high rates of bacterial biomass production relative to respiratory loss as {CO}2. Accordingly, δ13C, δ15N, and fatty acid biomarkers demonstrated that zooplankton from macrophyte-rich lakes receive a greater proportion of their biomass from bacterial organic matter than zooplankton from other lake types. At the same time, however, experiments indicated that the high {pH} resulting from rapid photosynthesis in macrophyte-rich lakes can decrease the rate of bacterial metabolism over the short-term, and increase {CO}2 respiration at the expense of bacterial biomass production. In contrast, {DOC}-specific tracers indicated that thermokarst-derived {DOC} accumulates in lakes. Incubation experiments and in situ surveys revealed thermokarst {DOC} to be a relatively poor bacterial substrate, which resulted in proportionately more {CO}2 respiration, relative to bacterial biomass production, than observed for other Delta {DOC} sources. Moreover, multi-year surveys demonstrated that thermokarst lakes exhibit high levels of {CO}2 emission, despite clear undersaturation in other lakes, presumably because permafrost-derived {DOC} was largely respired by bacteria. Understanding the divergent roles played by the contrasting sources of {DOC} to Delta lakes both adds insight to the functioning of other lake regions, globally, and helps clarify the effect of climate-induced changes in {DOC} on northern lakes.},
+	pagetotal = {238},
+	institution = {Simon Fraser University},
+	type = {phdthesis},
+	author = {Tank, S. E.},
+	date = {2009},
+	file = {Tank - 2009 - Sources and cycling of dissolved organic carbon ac.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\UI6YIRWV\\Tank - 2009 - Sources and cycling of dissolved organic carbon ac.pdf:application/pdf}
+}
+
+@article{sobek_patterns_2007,
+	title = {Patterns and regulation of dissolved organic carbon: An analysis of 7,500 widely distributed lakes},
+	volume = {52},
+	issn = {1939-5590},
+	url = {https://aslopubs.onlinelibrary.wiley.com/doi/abs/10.4319/lo.2007.52.3.1208},
+	doi = {10.4319/lo.2007.52.3.1208},
+	shorttitle = {Patterns and regulation of dissolved organic carbon},
+	abstract = {Dissolved organic carbon ({DOC}) is a key parameter in lakes that can affect numerous features, including microbial metabolism, light climate, acidity, and primary production. In an attempt to understand the factors that regulate {DOC} in lakes, we assembled a large database (7,514 lakes from 6 continents) of {DOC} concentrations and other parameters that characterize the conditions in the lakes, the catchment, the soil, and the climate. {DOC} concentrations were in the range 0.1–332 mg L−1, and the median was 5.71 mg L−1. A partial least squares regression explained 48\% of the variability in lake {DOC} and showed that altitude, mean annual runoff, and precipitation were negatively correlated with lake {DOC}, while conductivity, soil carbon density, and soil C:N ratio were positively related with lake {DOC}. A multiple linear regression using altitude, mean annual runoff, and soil carbon density as predictors explained 40\% of the variability in lake {DOC}. While lake area and drainage ratio (catchment : lake area) were not correlated to lake {DOC} in the global data set, these two factors explained significant variation of the residuals of the multiple linear regression model in several regional subsets of data. These results suggest a hierarchical regulation of {DOC} in lakes, where climatic and topographic characteristics set the possible range of {DOC} concentrations of a certain region, and catchment and lake properties then regulate the {DOC} concentration in each individual lake.},
+	pages = {1208--1219},
+	number = {3},
+	journaltitle = {Limnology and Oceanography},
+	author = {Sobek, Sebastian and Tranvik, Lars J. and Prairie, Yves T. and Kortelainen, Pirkko and Cole, Jonathan J.},
+	urldate = {2018-10-24},
+	date = {2007-05-01},
+	langid = {english},
+	file = {Sobek et al. - 2007 - Patterns and regulation of dissolved organic carbo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\5WVT5HTP\\Sobek et al. - 2007 - Patterns and regulation of dissolved organic carbo.pdf:application/pdf}
+}
+
+@article{macander_regional_2017,
+	title = {Regional Quantitative Cover Mapping of Tundra Plant Functional Types in Arctic Alaska},
+	volume = {9},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/9/10/1024},
+	doi = {10.3390/rs9101024},
+	abstract = {Ecosystem maps are foundational tools that support multi-disciplinary study design and applications including wildlife habitat assessment, monitoring and Earth-system modeling. Here, we present continuous-ﬁeld cover maps for tundra plant functional types ({PFTs}) across {\textasciitilde}125,000 km2 of Alaska’s North Slope at 30-m resolution. To develop maps, we collected a ﬁeld-based training dataset using a point-intercept sampling method at 225 plots spanning bioclimatic and geomorphic gradients. We stratiﬁed vegetation by nine {PFTs} (e.g., low deciduous shrub, dwarf evergreen shrub, sedge, lichen) and summarized measurements of the {PFTs}, open water, bare ground and litter using the cover metrics total cover (areal cover including the understory) and top cover (uppermost canopy or ground cover). We then developed 73 spectral predictors derived from Landsat satellite observations (surface reﬂectance composites for {\textasciitilde}15-day periods from May–August) and ﬁve gridded environmental predictors (e.g., summer temperature, climatological snow-free date) to model cover of {PFTs} using the random forest data-mining algorithm. Model performance tended to be best for canopy-forming {PFTs}, particularly deciduous shrubs. Our assessment of predictor importance indicated that models for low-statured {PFTs} were improved through the use of seasonal composites from early and late in the growing season, particularly when similar {PFTs} were aggregated together (e.g., total deciduous shrub, herbaceous). Continuous-ﬁeld maps have many advantages over traditional thematic maps, and the methods described here are well-suited to support periodic map updates in tandem with future ﬁeld and Landsat observations.},
+	pages = {1024},
+	number = {10},
+	journaltitle = {Remote Sensing},
+	author = {Macander, Matthew and Frost, Gerald and Nelson, Peter and Swingley, Christopher},
+	urldate = {2018-10-11},
+	date = {2017-10-04},
+	langid = {english},
+	file = {Macander et al. - 2017 - Regional Quantitative Cover Mapping of Tundra Plan.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\NLKZSHKX\\Macander et al. - 2017 - Regional Quantitative Cover Mapping of Tundra Plan.pdf:application/pdf}
+}
+
+@book{zazula_ice_2013,
+	location = {Whitehorse},
+	title = {Ice age Old Crow: Yukon's ancient history from north of the Arctic Circle},
+	isbn = {978-1-55362-634-3},
+	shorttitle = {Ice age Old Crow},
+	abstract = {"Introduction: The remote village of Old Crow is Yukon's only community north of the Arctic Circle. The fascinating ice age history in this region has captured the imaginations of scientists, the Vuntut Gwitchin and the world for generations. Bluffs and banks along the Old Crow River are the richest source of ice age fossils in Canada. The Old Crow region also provides important clues about when the first people arrived in North America. In addition, layers of sediment and soil laid down over millions of years provide a crucial framework for the study of climate change in the Arctic. Scientific evidence from the Old Crow region provides many answers - and even more questions - about the long-vanished ice age world. ... An integral part of the story of ice age research in the Old Crow region is the continued involvement of the Vuntut Gwitchin. Since ancient times they have encountered the fossils of strange ancient beasts as they traversed the land and travelled the river. The importance of these ancient fossils is reflected in stories told by elders about how life as they know it came to be. Since the first arrival of scientists more than a century ago, the local people of Old Crow have provided valuable assistance and taken the time to share their stories and culture. With the signing of land claims and self-government agreements in 1993 the Vuntut Gwitchin gained greater responsibility for the management of ancient artifacts and fossils on their land. As a result, the Vuntut Gwitchin Government ({VGG}) owns and manages all fossils and artifacts found since 1995 on Vuntut Gwitchin Settlement Land. The creation of Vuntut National Park in 1995 further highlighted the importance of ice age research in the Old Crow region to the people of Canada."--{ASTIS} [online] database.},
+	publisher = {Yukon Tourism and Culture},
+	author = {Zazula, Grant and Froese, Duane Gerald and Halladay, Patricia and {Yukon} and {Department of Tourism and Culture}},
+	date = {2013},
+	langid = {english},
+	note = {{OCLC}: 864275210},
+	file = {Zazula et al. - 2013 - Ice age Old Crow Yukon's ancient history from nor.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\8PR3KYD4\\Zazula et al. - 2013 - Ice age Old Crow Yukon's ancient history from nor.pdf:application/pdf}
+}
+
+@article{holden_identifying_2012,
+	title = {Identifying structural complexity in aeromagnetic data: An image analysis approach to greenfields gold exploration},
+	volume = {46},
+	issn = {01691368},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0169136811001454},
+	doi = {10.1016/j.oregeorev.2011.11.002},
+	shorttitle = {Identifying structural complexity in aeromagnetic data},
+	abstract = {Aeromagnetic data is important for the exploration of gold and other hydrothermal deposits because geologically favourable environments are associated with changes in rock magnetism. For example, Archean orogenic gold mineralisation is known to be present in areas of structural complexity near major shear-zones that form conduits for mineralising ﬂuids. Potential ﬂuid pathways such as shear zones and faults are often associated with magnetite destructive alteration resulting in linear negative anomalies in magnetic data. Here, we present a new image analysis method that identiﬁes geological structural complexity using lineaments automatically mapped within magnetic data. This quantitative analysis is efﬁcient and self consistent in dealing with large volumes of data, and is suitable as a ﬁrst-pass ground selection tool for orogenic gold exploration in greenﬁeld terrains.},
+	pages = {47--59},
+	journaltitle = {Ore Geology Reviews},
+	author = {Holden, Eun-Jung and Wong, Jason C. and Kovesi, Peter and Wedge, Daniel and Dentith, Mike and Bagas, Leon},
+	urldate = {2018-10-03},
+	date = {2012-08},
+	langid = {english},
+	file = {Holden et al. - 2012 - Identifying structural complexity in aeromagnetic .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\VUVAL6C8\\Holden et al. - 2012 - Identifying structural complexity in aeromagnetic .pdf:application/pdf}
+}
+
+@thesis{noauthor_aspler_nodate,
+	title = {Aspler - Geology of Nonacho Basin - {PhD} Thesis - 1985.pdf},
+	type = {phdthesis},
+	file = {Aspler - Geology of Nonacho Basin - PhD Thesis - 1985.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\H3EF6FNV\\Aspler - Geology of Nonacho Basin - PhD Thesis - 1985.pdf:application/pdf}
+}
+
+@article{tyren_lineament_nodate,
+	title = {Lineament interpretation Short review and methodology},
+	pages = {42},
+	author = {Tyrén, Sven},
+	langid = {english},
+	file = {Tyrén - Lineament interpretation Short review and methodol.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\IX2X2DS9\\Tyrén - Lineament interpretation Short review and methodol.pdf:application/pdf}
+}
+
+@article{middleton_geological_nodate,
+	title = {{GEOLOGICAL} {LINEAMENT} {INTERPRETATION} {USING} {THE} {OBJECT}-{BASED} {IMAGE} {ANALYSIS} {APPROACH}: {RESULTS} {OF} {SEMI}-{AUTOMATED} {ANALYSES} {VERSUS} {VISUAL} {INTERPRETATION}},
+	pages = {20},
+	author = {Middleton, Maarit and Schnur, Tilo and Sorjonen-Ward, Peter},
+	langid = {english},
+	file = {Middleton et al. - GEOLOGICAL LINEAMENT INTERPRETATION USING THE OBJE.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\CDZR88LQ\\Middleton et al. - GEOLOGICAL LINEAMENT INTERPRETATION USING THE OBJE.pdf:application/pdf}
+}
+
+@article{loranty_reviews_2018,
+	title = {Reviews and syntheses: Changing ecosystem influences on soil thermal regimes in northern high-latitude permafrost regions},
+	issn = {1810-6285},
+	url = {https://www.biogeosciences-discuss.net/bg-2018-201/},
+	doi = {10.5194/bg-2018-201},
+	shorttitle = {Reviews and syntheses},
+	pages = {1--56},
+	journaltitle = {Biogeosciences Discussions},
+	author = {Loranty, Michael M. and Abbott, Benjamin W. and Blok, Daan and Douglas, Thomas A. and Epstein, Howard E. and Forbes, Bruce C. and Jones, Benjamin M. and Kholodov, Alexander L. and Kropp, Heather and Malhotra, Avni and Mamet, Steven D. and Myers-Smith, Isla H. and Natali, Susan M. and O{\textbackslash}\&amp;apos;Donnell, Jonathan A. and Phoenix, Gareth K. and Rocha, Adrian V. and Sonnentag, Oliver and Tape, Ken D. and Walker, Donald A.},
+	urldate = {2018-09-17},
+	date = {2018-05-07},
+	langid = {english},
+	file = {Loranty et al. - 2018 - Reviews and syntheses Changing ecosystem influenc.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\QM3WZTNY\\Loranty et al. - 2018 - Reviews and syntheses Changing ecosystem influenc.pdf:application/pdf}
+}
+
+@article{weymer_statistical_2018,
+	title = {Statistical modeling of the long-range-dependent structure of barrier island framework geology and surface geomorphology},
+	volume = {6},
+	issn = {2196-632X},
+	url = {https://www.earth-surf-dynam.net/6/431/2018/},
+	doi = {10.5194/esurf-6-431-2018},
+	abstract = {Shorelines exhibit long-range dependence ({LRD}) and have been shown in some environments to be described in the wave number domain by a power-law characteristic of scale independence. Recent evidence suggests that the geomorphology of barrier islands can, however, exhibit scale dependence as a result of systematic variations in the underlying framework geology. The {LRD} of framework geology, which inﬂuences island geomorphology and its response to storms and sea level rise, has not been previously examined. Electromagnetic induction ({EMI}) surveys conducted along Padre Island National Seashore ({PAIS}), Texas, United States, reveal that the {EMI} apparent conductivity (σa) signal and, by inference, the framework geology exhibits {LRD} at scales of up to 101 to 102 km. Our study demonstrates the utility of describing {EMI} σa and lidar spatial series by a fractional autoregressive integrated moving average ({ARIMA}) process that speciﬁcally models {LRD}. This method offers a robust and compact way of quantifying the geological variations along a barrier island shoreline using three statistical parameters (p, d, q). We discuss how {ARIMA} models that use a single parameter d provide a quantitative measure for determining free and forced barrier island evolutionary behavior across different scales. Statistical analyses at regional, intermediate, and local scales suggest that the geologic framework within an area of paleo-channels exhibits a ﬁrst-order control on dune height. The exchange of sediment amongst nearshore, beach, and dune in areas outside this region are scale independent, implying that barrier islands like {PAIS} exhibit a combination of free and forced behaviors that affect the response of the island to sea level rise.},
+	pages = {431--450},
+	number = {2},
+	journaltitle = {Earth Surface Dynamics},
+	author = {Weymer, Bradley A. and Wernette, Phillipe and Everett, Mark E. and Houser, Chris},
+	urldate = {2018-09-12},
+	date = {2018-06-01},
+	langid = {english},
+	file = {Weymer et al. - 2018 - Statistical modeling of the long-range-dependent s.PDF:C\:\\Users\\Brent Thorne\\Zotero\\storage\\BXBDDUKW\\Weymer et al. - 2018 - Statistical modeling of the long-range-dependent s.PDF:application/pdf}
+}
+
+@article{park_influence_2012,
+	title = {The influence of climate and hydrological variables on opposite anomaly in active layer thickness between Eurasian and North American watersheds},
+	volume = {6},
+	issn = {1994-0440},
+	url = {http://www.the-cryosphere-discuss.net/6/2537/2012/},
+	doi = {10.5194/tcd-6-2537-2012},
+	pages = {2537--2574},
+	number = {4},
+	journaltitle = {The Cryosphere Discussions},
+	author = {Park, H. and Walsh, J. and Fedorov, A. N. and Sherstiukov, A. B. and Iijima, Y. and Ohata, T.},
+	urldate = {2018-09-10},
+	date = {2012-07-17},
+	langid = {english},
+	file = {Park et al. - 2012 - The influence of climate and hydrological variable.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\RVMGM4HC\\Park et al. - 2012 - The influence of climate and hydrological variable.pdf:application/pdf}
+}
+
+@article{morison_hydrology_nodate,
+	title = {Hydrology and Nutrient Biogeochemistry of Shallow Pond-Peatland Complexes, Hudson Bay Lowlands},
+	pages = {186},
+	author = {Morison, Matthew},
+	langid = {english},
+	file = {Morison - Hydrology and Nutrient Biogeochemistry of Shallow .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\9F8RG8VX\\Morison - Hydrology and Nutrient Biogeochemistry of Shallow .pdf:application/pdf}
+}
+
+@article{bolduc_multiyear_2018,
+	title = {Multiyear variations in High Arctic river temperatures in response to climate variability},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2017-0053},
+	doi = {10.1139/as-2017-0053},
+	abstract = {Water temperature measurements (2004–2016) from two small rivers in the High Arctic were analyzed to determine the effects of climate variability on thermal regime and the sensitivity to climate change. The East and West rivers (unofficial names) drain similar watersheds (11.6 and 8.0 km2, respectively) and are located at the Cape Bounty Arctic Watershed Observatory ({CBAWO}), Melville Island, Canada (74°55′N, 109°35′W). Differences in seasonal timing of river temperatures were evident when comparing the coldest and warmest years of the study period, and across different discharge conditions. Snowmelt runoff is characterized by uniformly cold water (∼0–1 °C) over a wide range of discharge conditions, followed by warming water temperatures during flow recession. The rivers showed varying sensitivity to mid-summer air temperature conditions in a given year, with warmer years indicating high correlation (r2 = 0.794–0.929), whereas colder years showed reduced correlation (r2 = 0.368–0.778). River temperatures reached levels which are reported to negatively affect fish and other cold-water aquatic species ({\textgreater}18 °C) with greater frequency and duration during the warmest years. These results provide a basis to further enhance prediction of river thermal conditions to assess ecosystem health in a river system and to refine insights into the effects of climate change on High Arctic aquatic ecosystems.},
+	pages = {1--19},
+	journaltitle = {Arctic Science},
+	author = {Bolduc, Christopher and Lamoureux, Scott F.},
+	urldate = {2018-09-02},
+	date = {2018-04-17},
+	langid = {english},
+	file = {Bolduc and Lamoureux - 2018 - Multiyear variations in High Arctic river temperat.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\BR5SN5GZ\\Bolduc and Lamoureux - 2018 - Multiyear variations in High Arctic river temperat.pdf:application/pdf}
+}
+
+@article{matveev_methane_2018,
+	title = {Methane and carbon dioxide emissions from thermokarst lakes on mineral soils},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2017-0047},
+	doi = {10.1139/as-2017-0047},
+	abstract = {Thermokarst lakes are known to emit methane ({CH}4) and carbon dioxide ({CO}2), but little attention has been given to those formed from the thawing and collapse of lithalsas, ice-rich mineral soil mounds that occur in permafrost landscapes. The present study was undertaken to assess greenhouse gas stocks and fluxes in eight lithalsa lakes across a 200 km gradient of permafrost degradation in subarctic Québec. The northernmost lakes varied in their surface-water {CO}2 content from below to above saturation, but the southern lakes in this gradient had much higher surface concentrations that were well above airequilibrium. Surface-water {CH}4 concentrations were at least an order of magnitude above air-equilibrium values at all sites, and the diffusive fluxes of both gases increased from north to south. Methane oxidation in the surface waters from a northern lake was only 10\% of the emission rate, but at the southern end it was around 60\% of the efflux to the atmosphere, indicating that methanotrophy can play a substantive role in reducing net emissions. Overall, our observations show that lithalsa lakes can begin emitting {CH}4 and {CO}2 soon after they form, with effluxes of both gases that persist and increase as the permafrost continues to warm and erode.},
+	pages = {1--21},
+	journaltitle = {Arctic Science},
+	author = {Matveev, Alex and Laurion, Isabelle and Vincent, Warwick F.},
+	urldate = {2018-08-26},
+	date = {2018-05-17},
+	langid = {english},
+	file = {Matveev et al. - 2018 - Methane and carbon dioxide emissions from thermoka.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\5KIDBYHG\\Matveev et al. - 2018 - Methane and carbon dioxide emissions from thermoka.pdf:application/pdf}
+}
+
+@book{davis_permafrost:_2001,
+	location = {Fairbanks, Alaska},
+	title = {Permafrost: a guide to frozen ground in transition},
+	isbn = {978-1-889963-19-8},
+	shorttitle = {Permafrost},
+	pagetotal = {351},
+	publisher = {University of Alaska Press},
+	author = {Davis, T. Neil},
+	date = {2001},
+	keywords = {Permafrost}
+}
+
+@article{hindshaw_origin_2016,
+	title = {Origin and temporal variability of unusually low \textit{δ} $^{\textrm{13}}$ C-{DOC} values in two High Arctic catchments: {UNUSUALLY} {LOW} {\textless}i{\textgreater}δ{\textless}/i{\textgreater} $^{\textrm{13}}$ C-{DOC} {VALUES}},
+	volume = {121},
+	issn = {21698953},
+	url = {http://doi.wiley.com/10.1002/2015JG003303},
+	doi = {10.1002/2015JG003303},
+	shorttitle = {Origin and temporal variability of unusually low \textit{δ} $^{\textrm{13}}$ C-{DOC} values in two High Arctic catchments},
+	abstract = {The stable carbon isotopic composition of dissolved organic matter (������13C-{DOC}) reveals information about its source and extent of biological processing. Here we report the lowest ������13C-{DOC} values (−43.8‰) measured to date in surface waters. The streams were located in the High Arctic, a region currently experiencing rapid changes in climate and carbon cycling. Based on the widespread occurrence of methane cycling in permafrost regions and the detection of the {pmoA} gene, a proxy for aerobic methanotrophs, we conclude that the low ������13C-{DOC} values are due to organic matter partially derived from methanotrophs consuming biologically produced, 13C-depleted methane. These ﬁndings demonstrate the signiﬁcant impact that biological activity has on the stream water chemistry exported from permafrost and glaciated environments in the Arctic. Given that the catchments studied here are representative of larger areas of the Arctic, occurrences of low ������13C-{DOC} values may be more widespread than previously recognized, with implications for understanding C cycling in these environments.},
+	pages = {1073--1085},
+	number = {4},
+	journaltitle = {Journal of Geophysical Research: Biogeosciences},
+	author = {Hindshaw, R. S. and Lang, S. Q. and Bernasconi, S. M. and Heaton, T. H. E. and Lindsay, M. R. and Boyd, E. S.},
+	urldate = {2018-07-19},
+	date = {2016-04},
+	langid = {english},
+	file = {Hindshaw et al. - 2016 - Origin and temporal variability of unusually low .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\LWN5SYIG\\Hindshaw et al. - 2016 - Origin and temporal variability of unusually low .pdf:application/pdf}
+}
+
+@article{frey_impacts_2009,
+	title = {Impacts of permafrost degradation on arctic river biogeochemistry},
+	volume = {23},
+	issn = {08856087, 10991085},
+	url = {http://doi.wiley.com/10.1002/hyp.7196},
+	doi = {10.1002/hyp.7196},
+	abstract = {Over the next century, near-surface permafrost across the circumpolar Arctic is expected to degrade signiﬁcantly, particularly for land areas south of 70°N. This is likely to cause widespread impacts on arctic hydrology, ecology, and trace gas emissions. Here, we present a review of recent studies investigating linkages between permafrost dynamics and river biogeochemistry in the Arctic, including consideration of likely impacts that warming-induced changes in permafrost may be having (or will have in the future) on the delivery of organic matter, inorganic nutrients, and major ions to the Arctic Ocean. These interacting processes can be highly complex and undoubtedly exhibit spatial and temporal variabilities associated with current permafrost conditions, sensitivity to permafrost thaw, mode of permafrost degradation (overall permafrost thaw, active layer deepening, and/or thermokarst processes), and environmental characteristics of watersheds (e.g. land cover, soil type, and topography). One of the most profound consequences of permafrost thaw projected for the future is that the arctic terrestrial freshwater system is likely to experience a transition from a surface water-dominated system to a groundwater-dominated system. Along with many other cascading impacts from this transition, mineral-rich groundwater may become an important contributor to streamﬂow, in addition to the currently dominant contribution from mineral-poor surface water. Most studies observe or predict an increase in major ion, phosphate, and silicate export with this shift towards greater groundwater contributions. However, we see conﬂicting accounts of whether the delivery of inorganic nitrogen and organic matter will increase or decrease with warming and permafrost thaw. It is important to note that uncertainties in the predictions of the total ﬂux of biogeochemical constituents are tightly linked to future uncertainties in discharge of rivers. Nonetheless, it is clear that over the next century there will be important shifts in the river transport of organic matter, inorganic nutrients, and major ions, which may in turn have critical implications for primary production and carbon cycling on arctic shelves and in the Arctic Ocean basin interior. Copyright  2008 John Wiley \& Sons, Ltd.},
+	pages = {169--182},
+	number = {1},
+	journaltitle = {Hydrological Processes},
+	author = {Frey, Karen E. and {McClelland}, James W.},
+	urldate = {2018-07-17},
+	date = {2009-01-01},
+	langid = {english},
+	file = {Frey and McClelland - 2009 - Impacts of permafrost degradation on arctic river .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\VGHCAHGV\\Frey and McClelland - 2009 - Impacts of permafrost degradation on arctic river .pdf:application/pdf}
+}
+
+@article{vonk_reviews_2015,
+	title = {Reviews and syntheses: Effects of permafrost thaw on Arctic aquatic ecosystems},
+	volume = {12},
+	issn = {1726-4189},
+	url = {https://www.biogeosciences.net/12/7129/2015/},
+	doi = {10.5194/bg-12-7129-2015},
+	shorttitle = {Reviews and syntheses},
+	pages = {7129--7167},
+	number = {23},
+	journaltitle = {Biogeosciences},
+	author = {Vonk, J. E. and Tank, S. E. and Bowden, W. B. and Laurion, I. and Vincent, W. F. and Alekseychik, P. and Amyot, M. and Billet, M. F. and Canário, J. and Cory, R. M. and Deshpande, B. N. and Helbig, M. and Jammet, M. and Karlsson, J. and Larouche, J. and {MacMillan}, G. and Rautio, M. and Walter Anthony, K. M. and Wickland, K. P.},
+	urldate = {2018-07-17},
+	date = {2015-12-08},
+	langid = {english},
+	file = {Vonk et al. - 2015 - Reviews and syntheses Effects of permafrost thaw .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\FP89SUHS\\Vonk et al. - 2015 - Reviews and syntheses Effects of permafrost thaw .pdf:application/pdf}
+}
+
+@article{waldrop_molecular_2010,
+	title = {Molecular investigations into a globally important carbon pool: permafrost-protected carbon in Alaskan soils},
+	volume = {16},
+	issn = {1365-2486},
+	url = {https://onlinelibrary.wiley.com/doi/abs/10.1111/j.1365-2486.2009.02141.x},
+	doi = {10.1111/j.1365-2486.2009.02141.x},
+	shorttitle = {Molecular investigations into a globally important carbon pool},
+	abstract = {The fate of carbon (C) contained within permafrost in boreal forest environments is an important consideration for the current and future carbon cycle as soils warm in northern latitudes. Currently, little is known about the microbiology or chemistry of permafrost soils that may affect its decomposition once soils thaw. We tested the hypothesis that low microbial abundances and activities in permafrost soils limit decomposition rates compared with active layer soils. We examined active layer and permafrost soils near Fairbanks, {AK}, the Yukon River, and the Arctic Circle. Soils were incubated in the lab under aerobic and anaerobic conditions. Gas fluxes at −5 and 5 °C were measured to calculate temperature response quotients (Q10). The Q10 was lower in permafrost soils (average 2.7) compared with active layer soils (average 7.5). Soil nutrients, leachable dissolved organic C ({DOC}) quality and quantity, and nuclear magnetic resonance spectroscopy of the soils revealed that the organic matter within permafrost soils is as labile, or even more so, than surface soils. Microbial abundances (fungi, bacteria, and subgroups: methanogens and Basidiomycetes) and exoenzyme activities involved in decomposition were lower in permafrost soils compared with active layer soils, which, together with the chemical data, supports the reduced Q10 values. {CH}4 fluxes were correlated with methanogen abundance and the highest {CH}4 production came from active layer soils. These results suggest that permafrost soils have high inherent decomposability, but low microbial abundances and activities reduce the temperature sensitivity of C fluxes. Despite these inherent limitations, however, respiration per unit soil C was higher in permafrost soils compared with active layer soils, suggesting that decomposition and heterotrophic respiration may contribute to a positive feedback to warming of this eco region.},
+	pages = {2543--2554},
+	number = {9},
+	journaltitle = {Global Change Biology},
+	author = {Waldrop, M. P. and Wickland, K. P. and Iii, R. White and Berhe, A. A. and Harden, J. W. and Romanovsky, V. E.},
+	urldate = {2018-07-17},
+	date = {2010},
+	langid = {english},
+	keywords = {carbon cycling, enzymes, methanogenesis, microbial communities, permafrost, respiration},
+	file = {Waldrop et al. - Molecular investigations into a globally important.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\FMFNECBB\\Waldrop et al. - Molecular investigations into a globally important.pdf:application/pdf}
+}
+
+@article{drake_ancient_2015,
+	title = {Ancient low–molecular-weight organic acids in permafrost fuel rapid carbon dioxide production upon thaw},
+	volume = {112},
+	issn = {0027-8424, 1091-6490},
+	url = {http://www.pnas.org/lookup/doi/10.1073/pnas.1511705112},
+	doi = {10.1073/pnas.1511705112},
+	pages = {13946--13951},
+	number = {45},
+	journaltitle = {Proceedings of the National Academy of Sciences},
+	author = {Drake, Travis W. and Wickland, Kimberly P. and Spencer, Robert G. M. and {McKnight}, Diane M. and Striegl, Robert G.},
+	urldate = {2018-07-17},
+	date = {2015-11-10},
+	langid = {english},
+	file = {Drake et al. - 2015 - Ancient low–molecular-weight organic acids in perm.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\QH32PI44\\Drake et al. - 2015 - Ancient low–molecular-weight organic acids in perm.pdf:application/pdf}
+}
+
+@article{wickland_dissolved_2007,
+	title = {Dissolved Organic Carbon in Alaskan Boreal Forest: Sources, Chemical Characteristics, and Biodegradability},
+	volume = {10},
+	issn = {1432-9840, 1435-0629},
+	url = {http://link.springer.com/10.1007/s10021-007-9101-4},
+	doi = {10.1007/s10021-007-9101-4},
+	shorttitle = {Dissolved Organic Carbon in Alaskan Boreal Forest},
+	pages = {1323--1340},
+	number = {8},
+	journaltitle = {Ecosystems},
+	author = {Wickland, Kimberly P. and Neff, Jason C. and Aiken, George R.},
+	urldate = {2018-07-17},
+	date = {2007-12},
+	langid = {english},
+	file = {Wickland et al. - 2007 - Dissolved Organic Carbon in Alaskan Boreal Forest.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\EEKLIR9K\\Wickland et al. - 2007 - Dissolved Organic Carbon in Alaskan Boreal Forest.pdf:application/pdf}
+}
+
+@article{schuur_expert_2013,
+	title = {Expert assessment of vulnerability of permafrost carbon to climate change},
+	volume = {119},
+	issn = {0165-0009, 1573-1480},
+	url = {http://link.springer.com/10.1007/s10584-013-0730-7},
+	doi = {10.1007/s10584-013-0730-7},
+	pages = {359--374},
+	number = {2},
+	journaltitle = {Climatic Change},
+	author = {Schuur, E. A. G. and Abbott, B. W. and Bowden, W. B. and Brovkin, V. and Camill, P. and Canadell, J. G. and Chanton, J. P. and Chapin, F. S. and Christensen, T. R. and Ciais, P. and Crosby, B. T. and Czimczik, C. I. and Grosse, G. and Harden, J. and Hayes, D. J. and Hugelius, G. and Jastrow, J. D. and Jones, J. B. and Kleinen, T. and Koven, C. D. and Krinner, G. and Kuhry, P. and Lawrence, D. M. and {McGuire}, A. D. and Natali, S. M. and O’Donnell, J. A. and Ping, C. L. and Riley, W. J. and Rinke, A. and Romanovsky, V. E. and Sannel, A. B. K. and Schädel, C. and Schaefer, K. and Sky, J. and Subin, Z. M. and Tarnocai, C. and Turetsky, M. R. and Waldrop, M. P. and Walter Anthony, K. M. and Wickland, K. P. and Wilson, C. J. and Zimov, S. A.},
+	urldate = {2018-07-17},
+	date = {2013-07},
+	langid = {english},
+	file = {Schuur et al. - 2013 - Expert assessment of vulnerability of permafrost c.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\T3XQGA86\\Schuur et al. - 2013 - Expert assessment of vulnerability of permafrost c.pdf:application/pdf}
+}
+
+@article{grosse_vulnerability_nodate,
+	title = {Vulnerability of high-latitude soil organic carbon in North America to disturbance},
+	volume = {116},
+	issn = {2156-2202},
+	url = {https://agupubs.onlinelibrary.wiley.com/doi/abs/10.1029/2010JG001507},
+	doi = {10.1029/2010JG001507},
+	abstract = {This synthesis addresses the vulnerability of the North American high-latitude soil organic carbon ({SOC}) pool to climate change. Disturbances caused by climate warming in arctic, subarctic, and boreal environments can result in significant redistribution of C among major reservoirs with potential global impacts. We divide the current northern high-latitude {SOC} pools into (1) near-surface soils where {SOC} is affected by seasonal freeze-thaw processes and changes in moisture status, and (2) deeper permafrost and peatland strata down to several tens of meters depth where {SOC} is usually not affected by short-term changes. We address key factors (permafrost, vegetation, hydrology, paleoenvironmental history) and processes (C input, storage, decomposition, and output) responsible for the formation of the large high-latitude {SOC} pool in North America and highlight how climate-related disturbances could alter this pool's character and size. Press disturbances of relatively slow but persistent nature such as top-down thawing of permafrost, and changes in hydrology, microbiological communities, pedological processes, and vegetation types, as well as pulse disturbances of relatively rapid and local nature such as wildfires and thermokarst, could substantially impact {SOC} stocks. Ongoing climate warming in the North American high-latitude region could result in crossing environmental thresholds, thereby accelerating press disturbances and increasingly triggering pulse disturbances and eventually affecting the C source/sink net character of northern high-latitude soils. Finally, we assess postdisturbance feedbacks, models, and predictions for the northern high-latitude {SOC} pool, and discuss data and research gaps to be addressed by future research.},
+	issue = {G4},
+	journaltitle = {Journal of Geophysical Research: Biogeosciences},
+	author = {Grosse, Guido and Harden, Jennifer and Turetsky, Merritt and {McGuire}, A. David and Camill, Philip and Tarnocai, Charles and Frolking, Steve and Schuur, Edward A. G. and Jorgenson, Torre and Marchenko, Sergei and Romanovsky, Vladimir and Wickland, Kimberly P. and French, Nancy and Waldrop, Mark and Bourgeau‐Chavez, Laura and Striegl, Robert G.},
+	urldate = {2018-07-17},
+	langid = {english},
+	keywords = {permafrost, disturbance, high latitudes, North America, peatlands, soil carbon},
+	file = {Grosse et al. - Vulnerability of high-latitude soil organic carbon.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\PSCLLGST\\Grosse et al. - Vulnerability of high-latitude soil organic carbon.pdf:application/pdf}
+}
+
+@article{striegl_carbon_2007,
+	title = {Carbon export and cycling by the Yukon, Tanana, and Porcupine rivers, Alaska, 2001-2005: {YUKON} {BASIN} {CARBON} {EXPORT}},
+	volume = {43},
+	issn = {00431397},
+	url = {http://doi.wiley.com/10.1029/2006WR005201},
+	doi = {10.1029/2006WR005201},
+	shorttitle = {Carbon export and cycling by the Yukon, Tanana, and Porcupine rivers, Alaska, 2001-2005},
+	number = {2},
+	journaltitle = {Water Resources Research},
+	author = {Striegl, Robert G. and Dornblaser, Mark M. and Aiken, George R. and Wickland, Kimberly P. and Raymond, Peter A.},
+	urldate = {2018-07-17},
+	date = {2007-02},
+	langid = {english},
+	file = {Striegl et al. - 2007 - Carbon export and cycling by the Yukon, Tanana, an.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4WV5PGZB\\Striegl et al. - 2007 - Carbon export and cycling by the Yukon, Tanana, an.pdf:application/pdf}
+}
+
+@article{striegl_carbon_2001,
+	title = {Carbon dioxide partial pressure and 13C content of north temperate and boreal lakes at spring ice melt},
+	volume = {46},
+	issn = {00243590},
+	url = {http://doi.wiley.com/10.4319/lo.2001.46.4.0941},
+	doi = {10.4319/lo.2001.46.4.0941},
+	pages = {941--945},
+	number = {4},
+	journaltitle = {Limnology and Oceanography},
+	author = {Striegl, Robert G. and Kortelainen, Pirkko and Chanton, Jeffrey P. and Wickland, Kimberly P. and Bugna, Glynnis C. and Rantakari, Miitta},
+	urldate = {2018-07-17},
+	date = {2001-06},
+	langid = {english},
+	file = {Striegl et al. - 2001 - Carbon dioxide partial pressure and 13C content of.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ZACPZD3B\\Striegl et al. - 2001 - Carbon dioxide partial pressure and 13C content of.pdf:application/pdf}
+}
+
+@article{matveev_methane_2018-1,
+	title = {Methane and carbon dioxide emissions from thermokarst lakes on mineral soils},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2017-0047},
+	doi = {10.1139/as-2017-0047},
+	abstract = {Thermokarst lakes are known to emit methane ({CH}4) and carbon dioxide ({CO}2), but little attention has been given to those formed from the thawing and collapse of lithalsas, ice-rich mineral soil mounds that occur in permafrost landscapes. The present study was undertaken to assess greenhouse gas stocks and fluxes in eight lithalsa lakes across a 200 km gradient of permafrost degradation in subarctic Québec. The northernmost lakes varied in their surface-water {CO}2 content from below to above saturation, but the southern lakes in this gradient had much higher surface concentrations that were well above airequilibrium. Surface-water {CH}4 concentrations were at least an order of magnitude above air-equilibrium values at all sites, and the diffusive fluxes of both gases increased from north to south. Methane oxidation in the surface waters from a northern lake was only 10\% of the emission rate, but at the southern end it was around 60\% of the efflux to the atmosphere, indicating that methanotrophy can play a substantive role in reducing net emissions. Overall, our observations show that lithalsa lakes can begin emitting {CH}4 and {CO}2 soon after they form, with effluxes of both gases that persist and increase as the permafrost continues to warm and erode.},
+	pages = {1--21},
+	journaltitle = {Arctic Science},
+	author = {Matveev, Alex and Laurion, Isabelle and Vincent, Warwick F.},
+	urldate = {2018-07-13},
+	date = {2018-05-17},
+	langid = {english},
+	file = {Matveev et al. - 2018 - Methane and carbon dioxide emissions from thermoka.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\R7AE2NU6\\Matveev et al. - 2018 - Methane and carbon dioxide emissions from thermoka.pdf:application/pdf}
+}
+
+@article{brown_thermal_2010,
+	title = {The Thermal State of Permafrost: the {IPY}- {IPA} snapshot (2007-2009)},
+	abstract = {During the International Polar Year ({IPY}) the International Permafrost Association ({IPA}) coordinated the acquisition of standardized permafrost temperatures data (snapshot) under the Thermal State of Permafrost ({TSP}) Project. The current network consists of more than 860 boreholes in both hemispheres with more than 25 participating countries. The vast majority of sites are equipped for long-term permafrost temperature observations. A borehole inventory including mean annual ground temperatures for 600 boreholes (snapshot) is available online.},
+	pages = {7},
+	author = {Brown, Jerry and Kholodov, Alexander and Romanovsky, Vladimir and Yoshikawa, Kenji and Smith, Sharon L and Christiansen, Hanne H and Vieira, Goncalo and Noetzli, Jeannette},
+	date = {2010},
+	langid = {english},
+	file = {Brown et al. - The Thermal State of Permafrost the IPY- IPA snap.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\87EWNZZY\\Brown et al. - The Thermal State of Permafrost the IPY- IPA snap.pdf:application/pdf}
+}
+
+@article{romanovsky_permafrost_2010,
+	title = {Permafrost thermal state in the polar Northern Hemisphere during the international polar year 2007-2009: a synthesis},
+	volume = {21},
+	issn = {10456740, 10991530},
+	url = {http://doi.wiley.com/10.1002/ppp.689},
+	doi = {10.1002/ppp.689},
+	shorttitle = {Permafrost thermal state in the polar Northern Hemisphere during the international polar year 2007-2009},
+	abstract = {The permafrost monitoring network in the polar regions of the Northern Hemisphere was enhanced during the International Polar Year ({IPY}), and new information on permafrost thermal state was collected for regions where there was little available. This augmented monitoring network is an important legacy of the {IPY}, as is the updated baseline of current permafrost conditions against which future changes may be measured. Within the Northern Hemisphere polar region, ground temperatures are currently being measured in about 575 boreholes in North America, the Nordic region and Russia. These show that in the discontinuous permafrost zone, permafrost temperatures fall within a narrow range, with the mean annual ground temperature ({MAGT}) at most sites being higher than À28C. A greater range in {MAGT} is present within the continuous permafrost zone, from above À18C at some locations to as low as À158C. The latest results indicate that the permafrost warming which started two to three decades ago has generally continued into the {IPY} period. Warming rates are much smaller for permafrost already at temperatures close to 08C compared with colder permafrost, especially for ice-rich permafrost where latent heat effects dominate the ground thermal regime. Colder permafrost sites are warming more rapidly. This improved knowledge about the permafrost thermal state and its dynamics is important for multidisciplinary polar research, but also for many of the 4 million people living in the Arctic. In particular, this knowledge is required for designing effective adaptation strategies for the local communities under warmer climatic conditions. Copyright \# 2010 John Wiley \& Sons, Ltd.},
+	pages = {106--116},
+	number = {2},
+	journaltitle = {Permafrost and Periglacial Processes},
+	author = {Romanovsky, Vladimir E. and Smith, Sharon L. and Christiansen, Hanne H.},
+	urldate = {2018-07-12},
+	date = {2010-06-08},
+	langid = {english},
+	file = {Romanovsky et al. - 2010 - Permafrost thermal state in the polar Northern Hem.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\VIRP59D7\\Romanovsky et al. - 2010 - Permafrost thermal state in the polar Northern Hem.pdf:application/pdf}
+}
+
+@article{zimov_permafrost_2006,
+	title = {Permafrost and the Global Carbon Budget},
+	volume = {312},
+	issn = {0036-8075, 1095-9203},
+	url = {http://www.sciencemag.org/cgi/doi/10.1126/science.1128908},
+	doi = {10.1126/science.1128908},
+	shorttitle = {{CLIMATE} {CHANGE}},
+	pages = {1612--1613},
+	number = {5780},
+	journaltitle = {Science},
+	author = {Zimov, S. A.},
+	urldate = {2018-07-12},
+	date = {2006-06-16},
+	langid = {english},
+	file = {Zimov - 2006 - CLIMATE CHANGE Permafrost and the Global Carbon B.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\F7N376ZX\\Zimov - 2006 - CLIMATE CHANGE Permafrost and the Global Carbon B.pdf:application/pdf}
+}
+
+@article{zimov_permafrost_2006-1,
+	title = {Permafrost carbon: Stock and decomposability of a globally significant carbon pool},
+	volume = {33},
+	issn = {0094-8276},
+	url = {http://doi.wiley.com/10.1029/2006GL027484},
+	doi = {10.1029/2006GL027484},
+	shorttitle = {Permafrost carbon},
+	number = {20},
+	journaltitle = {Geophysical Research Letters},
+	author = {Zimov, S. A. and Davydov, S. P. and Zimova, G. M. and Davydova, A. I. and Schuur, E. A. G. and Dutta, K. and Chapin, F. S.},
+	urldate = {2018-07-12},
+	date = {2006-10-27},
+	langid = {english},
+	file = {Zimov et al. - 2006 - Permafrost carbon Stock and decomposability of a .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\V28TVFWE\\Zimov et al. - 2006 - Permafrost carbon Stock and decomposability of a .pdf:application/pdf}
+}
+
+@article{schuur_effect_2009,
+	title = {The effect of permafrost thaw on old carbon release and net carbon exchange from tundra},
+	volume = {459},
+	issn = {0028-0836, 1476-4687},
+	url = {http://www.nature.com/articles/nature08031},
+	doi = {10.1038/nature08031},
+	pages = {556--559},
+	number = {7246},
+	journaltitle = {Nature},
+	author = {Schuur, Edward A. G. and Vogel, Jason G. and Crummer, Kathryn G. and Lee, Hanna and Sickman, James O. and Osterkamp, T. E.},
+	urldate = {2018-07-12},
+	date = {2009-05},
+	langid = {english},
+	file = {Schuur et al. - 2009 - The effect of permafrost thaw on old carbon releas.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\YRBJYIWH\\Schuur et al. - 2009 - The effect of permafrost thaw on old carbon releas.pdf:application/pdf}
+}
+
+@article{tarnocai_soil_2009,
+	title = {Soil organic carbon pools in the northern circumpolar permafrost region: {SOIL} {ORGANIC} {CARBON} {POOLS}},
+	volume = {23},
+	issn = {08866236},
+	url = {http://doi.wiley.com/10.1029/2008GB003327},
+	doi = {10.1029/2008GB003327},
+	shorttitle = {Soil organic carbon pools in the northern circumpolar permafrost region},
+	pages = {n/a--n/a},
+	number = {2},
+	journaltitle = {Global Biogeochemical Cycles},
+	author = {Tarnocai, C. and Canadell, J. G. and Schuur, E. A. G. and Kuhry, P. and Mazhitova, G. and Zimov, S.},
+	urldate = {2018-07-12},
+	date = {2009-06},
+	langid = {english},
+	file = {Tarnocai et al. - 2009 - Soil organic carbon pools in the northern circumpo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\2FYYA39I\\Tarnocai et al. - 2009 - Soil organic carbon pools in the northern circumpo.pdf:application/pdf}
+}
+
+@article{schaefer_impact_2014,
+	title = {The impact of the permafrost carbon feedback on global climate},
+	volume = {9},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/9/i=8/a=085003?key=crossref.30cf8c5adeaa54d6e76392833f9bc72e},
+	doi = {10.1088/1748-9326/9/8/085003},
+	abstract = {Degrading permafrost can alter ecosystems, damage infrastructure, and release enough carbon dioxide ({CO}2) and methane ({CH}4) to inﬂuence global climate. The permafrost carbon feedback ({PCF}) is the ampliﬁcation of surface warming due to {CO}2 and {CH}4 emissions from thawing permafrost. An analysis of available estimates {PCF} strength and timing indicate 120 ± 85 Gt of carbon emissions from thawing permafrost by 2100. This is equivalent to 5.7 ± 4.0\% of total anthropogenic emissions for the Intergovernmental Panel on Climate Change ({IPCC}) representative concentration pathway ({RCP}) 8.5 scenario and would increase global temperatures by 0.29 ± 0.21 °C or 7.8 ± 5.7\%. For {RCP}4.5, the scenario closest to the 2 °C warming target for the climate change treaty, the range of cumulative emissions in 2100 from thawing permafrost decreases to between 27 and 100 Gt C with temperature increases between 0.05 and 0.15 °C, but the relative fraction of permafrost to total emissions increases to between 3\% and 11\%. Any substantial warming results in a committed, long-term carbon release from thawing permafrost with 60\% of emissions occurring after 2100, indicating that not accounting for permafrost emissions risks overshooting the 2 °C warming target. Climate projections in the {IPCC} Fifth Assessment Report ({AR}5), and any emissions targets based on those projections, do not adequately account for emissions from thawing permafrost and the effects of the {PCF} on global climate. We recommend the {IPCC} commission a special assessment focusing on the {PCF} and its impact on global climate to supplement the {AR}5 in support of treaty negotiation.},
+	pages = {085003},
+	number = {8},
+	journaltitle = {Environmental Research Letters},
+	author = {Schaefer, Kevin and Lantuit, Hugues and Romanovsky, Vladimir E and Schuur, Edward A G and Witt, Ronald},
+	urldate = {2018-07-12},
+	date = {2014-08-01},
+	langid = {english},
+	file = {Schaefer et al. - 2014 - The impact of the permafrost carbon feedback on gl.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\QZWSMAJF\\Schaefer et al. - 2014 - The impact of the permafrost carbon feedback on gl.pdf:application/pdf}
+}
+
+@article{raymond_global_2013,
+	title = {Global carbon dioxide emissions from inland waters},
+	volume = {503},
+	issn = {0028-0836, 1476-4687},
+	url = {http://www.nature.com/articles/nature12760},
+	doi = {10.1038/nature12760},
+	pages = {355--359},
+	number = {7476},
+	journaltitle = {Nature},
+	author = {Raymond, Peter A. and Hartmann, Jens and Lauerwald, Ronny and Sobek, Sebastian and {McDonald}, Cory and Hoover, Mark and Butman, David and Striegl, Robert and Mayorga, Emilio and Humborg, Christoph and Kortelainen, Pirkko and Dürr, Hans and Meybeck, Michel and Ciais, Philippe and Guth, Peter},
+	urldate = {2018-07-11},
+	date = {2013-11},
+	langid = {english},
+	file = {Raymond et al. - 2013 - Global carbon dioxide emissions from inland waters.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\XA6S3BWZ\\Raymond et al. - 2013 - Global carbon dioxide emissions from inland waters.pdf:application/pdf}
+}
+
+@article{tank_landscape-level_2012,
+	title = {Landscape-level controls on dissolved carbon flux from diverse catchments of the circumboreal: {DISSOLVED} {CARBON} {FLUX} {FROM} {BOREAL} {RIVERS}},
+	volume = {26},
+	issn = {08866236},
+	url = {http://doi.wiley.com/10.1029/2012GB004299},
+	doi = {10.1029/2012GB004299},
+	shorttitle = {Landscape-level controls on dissolved carbon flux from diverse catchments of the circumboreal},
+	pages = {n/a--n/a},
+	number = {4},
+	journaltitle = {Global Biogeochemical Cycles},
+	author = {Tank, Suzanne E. and Frey, Karen E. and Striegl, Robert G. and Raymond, Peter A. and Holmes, Robert M. and {McClelland}, James W. and Peterson, Bruce J.},
+	urldate = {2018-07-10},
+	date = {2012-12},
+	langid = {english},
+	file = {Tank et al. - 2012 - Landscape-level controls on dissolved carbon flux .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\22AQP5MM\\Tank et al. - 2012 - Landscape-level controls on dissolved carbon flux .pdf:application/pdf}
+}
+
+@article{tank_land--ocean_2012,
+	title = {A land-to-ocean perspective on the magnitude, source and implication of {DIC} flux from major Arctic rivers to the Arctic Ocean: {ARCTIC} {RIVER} {DIC}},
+	volume = {26},
+	issn = {08866236},
+	url = {http://doi.wiley.com/10.1029/2011GB004192},
+	doi = {10.1029/2011GB004192},
+	shorttitle = {A land-to-ocean perspective on the magnitude, source and implication of {DIC} flux from major Arctic rivers to the Arctic Ocean},
+	pages = {n/a--n/a},
+	number = {4},
+	journaltitle = {Global Biogeochemical Cycles},
+	author = {Tank, Suzanne E. and Raymond, Peter A. and Striegl, Robert G. and {McClelland}, James W. and Holmes, Robert M. and Fiske, Greg J. and Peterson, Bruce J.},
+	urldate = {2018-07-10},
+	date = {2012-12},
+	langid = {english},
+	file = {Tank et al. - 2012 - A land-to-ocean perspective on the magnitude, sour.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\JZ6UWCEK\\Tank et al. - 2012 - A land-to-ocean perspective on the magnitude, sour.pdf:application/pdf}
+}
+
+@article{olefeldt_permafrost_2014,
+	title = {Permafrost conditions in peatlands regulate magnitude, timing, and chemical composition of catchment dissolved organic carbon export},
+	volume = {20},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/gcb.12607},
+	doi = {10.1111/gcb.12607},
+	abstract = {Permafrost thaw in peatlands has the potential to alter catchment export of dissolved organic carbon ({DOC}) and thus inﬂuence downstream aquatic C cycling. Subarctic peatlands are often mosaics of different peatland types, where permafrost conditions regulate the hydrological setting of each type. We show that hydrological setting is key to observed differences in magnitude, timing, and chemical composition of {DOC} export between permafrost and nonpermafrost peatland types, and that these differences inﬂuence the export of {DOC} of larger catchments even when peatlands are minor catchment components. In many aspects, {DOC} export from a studied peatland permafrost plateau was similar to that of a forested upland catchment. Similarities included low annual export (2–3 g C {mÀ}2) dominated by the snow melt period ({\textasciitilde}70\%), and how substantial {DOC} export following storms required wet antecedent conditions. Conversely, nonpermafrost fens had higher {DOC} export (7 g C {mÀ}2), resulting from sustained hydrological connectivity during summer. Chemical composition of catchment {DOC} export arose from the mixing of highly aromatic {DOC} from organic soils from permafrost plateau soil water and upland forest surface horizons with nonaromatic {DOC} from mineral soil groundwater, but was further modulated by fens. Increasing aromaticity from fen inﬂow to outlet was substantial and depended on both water residence time and water temperature. The role of fens as catchment biogeochemical hotspots was further emphasized by their capacity for sulfate retention. As a result of fen characteristics, a 4\% fen cover in a mixed catchment was responsible for 34\% higher {DOC} export, 50\% higher {DOC} concentrations and {\textasciitilde}10\% higher {DOC} aromaticity at the catchment outlet during summer compared to a nonpeatland upland catchment. Expansion of fens due to thaw thus has potential to inﬂuence landscape C cycling by increasing fen capacity to act as biogeochemical hotspots, amplifying aquatic C cycling, and increasing catchment {DOC} export.},
+	pages = {3122--3136},
+	number = {10},
+	journaltitle = {Global Change Biology},
+	author = {Olefeldt, David and Roulet, Nigel T.},
+	urldate = {2018-07-10},
+	date = {2014-10},
+	langid = {english},
+	file = {Olefeldt and Roulet - 2014 - Permafrost conditions in peatlands regulate magnit.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\AG4JVWK5\\Olefeldt and Roulet - 2014 - Permafrost conditions in peatlands regulate magnit.pdf:application/pdf}
+}
+
+@article{helbig_direct_2017,
+	title = {Direct and indirect climate change effects on carbon dioxide fluxes in a thawing boreal forest-wetland landscape},
+	volume = {23},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/gcb.13638},
+	doi = {10.1111/gcb.13638},
+	abstract = {In the sporadic permafrost zone of northwestern Canada, boreal forest carbon dioxide ({CO}2) ﬂuxes will be altered directly by climate change through changing meteorological forcing and indirectly through changes in landscape functioning associated with thaw-induced collapse-scar bog (‘wetland’) expansion. However, their combined effect on landscape-scale net ecosystem {CO}2 exchange ({NEELAND}), resulting from changing gross primary productivity ({GPP}) and ecosystem respiration ({ER}), remains unknown. Here, we quantify indirect land cover change impacts on {NEELAND} and direct climate change impacts on modeled temperature- and light-limited {NEELAND} of a boreal forest–wetland landscape. Using nested eddy covariance ﬂux towers, we ﬁnd both {GPP} and {ER} to be larger at the landscape compared to the wetland level. However, annual {NEELAND} (À20 g C {mÀ}2) and wetland {NEE} (À24 g C {mÀ}2) were similar, suggesting negligible wetland expansion effects on {NEELAND}. In contrast, we ﬁnd non-negligible direct climate change impacts when modeling {NEELAND} using projected air temperature and incoming shortwave radiation. At the end of the 21st century, modeled {GPP} mainly increases in spring and fall due to reduced temperature limitation, but becomes more frequently light-limited in fall. In a warmer climate, {ER} increases year-round in the absence of moisture stress resulting in net {CO}2 uptake increases in the shoulder seasons and decreases during the summer. Annually, landscape net {CO}2 uptake is projected to decline by 25 Æ 14 g C {mÀ}2 for a moderate and 103 Æ 38 g C {mÀ}2 for a high warming scenario, potentially reversing recently observed positive net {CO}2 uptake trends across the boreal biome. Thus, even without moisture stress, net {CO}2 uptake of boreal forest–wetland landscapes may decline, and ultimately, these landscapes may turn into net {CO}2 sources under continued anthropogenic {CO}2 emissions. We conclude that {NEELAND} changes are more likely to be driven by direct climate change rather than by indirect land cover change impacts.},
+	pages = {3231--3248},
+	number = {8},
+	journaltitle = {Global Change Biology},
+	author = {Helbig, Manuel and Chasmer, Laura E. and Desai, Ankur R. and Kljun, Natascha and Quinton, William L. and Sonnentag, Oliver},
+	urldate = {2018-07-10},
+	date = {2017-08},
+	langid = {english},
+	file = {Helbig et al. - 2017 - Direct and indirect climate change effects on carb.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\8E5C5R6X\\Helbig et al. - 2017 - Direct and indirect climate change effects on carb.pdf:application/pdf}
+}
+
+@article{jantze_subsurface_2013,
+	title = {Subsurface release and transport of dissolved carbon in a discontinuous permafrost region},
+	volume = {17},
+	issn = {1607-7938},
+	url = {https://www.hydrol-earth-syst-sci.net/17/3827/2013/},
+	doi = {10.5194/hess-17-3827-2013},
+	abstract = {Subsurface hydrological ﬂow pathways and advection rates through the landscape affect the quantity and timing of hydrological transport of dissolved carbon. This study investigates hydrological carbon transport through the subsurface to streams and how it is affected by the distribution of subsurface hydrological pathways and travel times through the landscape. We develop a consistent mechanistic, pathway- and travel time-based modeling approach for release and transport of dissolved organic carbon ({DOC}) and dissolved inorganic carbon ({DIC}). The model implications are tested against observations in the subarctic Abiskojokken catchment in northernmost Sweden (68◦21 N, 18◦49 E) as a ﬁeld case example of a discontinuous permafrost region. The results show: (a) For {DOC}, both concentration and load are essentially ﬂow-independent because their dynamics are instead dominated by the annual renewal and depletion. Specifically, the ﬂow independence is the result of the small characteristic {DOC} respiration-dissolution time scale, in the range of 1 yr, relative to the average travel time of water through the subsurface to the stream. (b) For {DIC}, the load is highly ﬂow-dependent due to the large characteristic weatheringdissolution time, much larger than 1 yr, relative to the average subsurface water travel time to the stream. This rate relation keeps the {DIC} concentration essentially ﬂow-independent, and thereby less ﬂuctuating in time than the {DIC} load.},
+	pages = {3827--3839},
+	number = {10},
+	journaltitle = {Hydrology and Earth System Sciences},
+	author = {Jantze, E. J. and Lyon, S. W. and Destouni, G.},
+	urldate = {2018-07-10},
+	date = {2013-10-08},
+	langid = {english},
+	file = {Jantze et al. - 2013 - Subsurface release and transport of dissolved carb.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\M7BJ9KTX\\Jantze et al. - 2013 - Subsurface release and transport of dissolved carb.pdf:application/pdf}
+}
+
+@article{jones_rapid_2017,
+	title = {Rapid carbon loss and slow recovery following permafrost thaw in boreal peatlands},
+	volume = {23},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/gcb.13403},
+	doi = {10.1111/gcb.13403},
+	abstract = {Permafrost peatlands store one-third of the total carbon (C) in the atmosphere and are increasingly vulnerable to thaw as high-latitude temperatures warm. Large uncertainties remain about C dynamics following permafrost thaw in boreal peatlands. We used a chronosequence approach to measure C stocks in forested permafrost plateaus (forest) and thawed permafrost bogs, ranging in thaw age from young ({\textless}10 years) to old ({\textgreater}100 years) from two interior Alaska chronosequences. Permafrost originally aggraded simultaneously with peat accumulation (syngenetic permafrost) at both sites. We found that upon thaw, C loss of the forest peat C is equivalent to {\textasciitilde}30\% of the initial forest C stock and is directly proportional to the prethaw C stocks. Our model results indicate that permafrost thaw turned these peatlands into net C sources to the atmosphere for a decade following thaw, after which post-thaw bog peat accumulation returned sites to net C sinks. It can take multiple centuries to millennia for a site to recover its prethaw C stocks; the amount of time needed for them to regain their prethaw C stocks is governed by the amount of C that accumulated prior to thaw. Consequently, these ﬁndings show that older peatlands will take longer to recover prethaw C stocks, whereas younger peatlands will exceed prethaw stocks in a matter of centuries. We conclude that the loss of sporadic and discontinuous permafrost by 2100 could result in a loss of up to 24 Pg of deep C from permafrost peatlands.},
+	pages = {1109--1127},
+	number = {3},
+	journaltitle = {Global Change Biology},
+	author = {Jones, Miriam C. and Harden, Jennifer and O'Donnell, Jonathan and Manies, Kristen and Jorgenson, Torre and Treat, Claire and Ewing, Stephanie},
+	urldate = {2018-07-10},
+	date = {2017-03},
+	langid = {english},
+	file = {Jones et al. - 2017 - Rapid carbon loss and slow recovery following perm.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\G5LIA6V4\\Jones et al. - 2017 - Rapid carbon loss and slow recovery following perm.pdf:application/pdf}
+}
+
+@article{lessels_coupled_2015,
+	title = {A coupled hydrology-biogeochemistry model to simulate dissolved organic carbon exports from a permafrost-influenced catchment: A {COUPLED} {HYDROLOGY}-{BIOGEOCHEMISTRY} {MODEL}},
+	volume = {29},
+	issn = {08856087},
+	url = {http://doi.wiley.com/10.1002/hyp.10566},
+	doi = {10.1002/hyp.10566},
+	shorttitle = {A coupled hydrology-biogeochemistry model to simulate dissolved organic carbon exports from a permafrost-influenced catchment},
+	abstract = {We outline the development of a simple, coupled hydrology–biogeochemistry model for simulating stream discharge and dissolved organic carbon ({DOC}) dynamics in data sparse, permafrost-inﬂuenced catchments with large stores of soil organic carbon. The model incorporates the inﬂuence of active layer dynamics and slope aspect on hydrological ﬂowpaths and resulting {DOC} mobilization. Calibration and evaluation of the model was undertaken using observations from Granger Basin within the Wolf Creek research basin, Yukon, northern Canada. Results show that the model was able to capture the dominant hydrological response and {DOC} dynamics of the catchment reasonably well. Simulated {DOC} was highly correlated with observed {DOC} (r2 = 0.65) for the study period. During the snowmelt period, the model adequately captured the observed dynamics, with simulations generally reﬂecting the timing and magnitude of the observed {DOC} and stream discharge. The model was less successful over the later summer period although this partly reﬂected a lack of {DOC} observations for calibration. The developed model offers a valuable framework for investigating the interactions between hydrological and {DOC} processes in these highly dynamic systems, where data acquisition is often very difﬁcult. © 2015 The Authors Hydrological Processes Published by John Wiley \& Sons, Ltd.},
+	pages = {5383--5396},
+	number = {26},
+	journaltitle = {Hydrological Processes},
+	author = {Lessels, Jason S. and Tetzlaff, Doerthe and Carey, Sean K and Smith, Pete and Soulsby, Chris},
+	urldate = {2018-07-10},
+	date = {2015-12-30},
+	langid = {english},
+	file = {Lessels et al. - 2015 - A coupled hydrology-biogeochemistry model to simul.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\SFAG89YM\\Lessels et al. - 2015 - A coupled hydrology-biogeochemistry model to simul.pdf:application/pdf}
+}
+
+@article{tank_multiple_2011,
+	title = {Multiple tracers demonstrate distinct sources of dissolved organic matter to lakes of the Mackenzie Delta, western Canadian Arctic},
+	volume = {56},
+	issn = {00243590},
+	url = {http://doi.wiley.com/10.4319/lo.2011.56.4.1297},
+	doi = {10.4319/lo.2011.56.4.1297},
+	abstract = {Lakes of the Mackenzie Delta occur across a gradient that contains three clear end members: those that remain connected to river-water channels throughout the summer; those that receive only brief inputs of river water during an annual spring flood but contain dense macrophyte stands; and those that experience significant permafrost thaw along their margins. We measured dissolved organic carbon ({DOC}) concentration, dissolved organic matter ({DOM}) absorption and fluorescence, and stable isotopes of {DOM}, {DOM} precursor materials, and bacteria to elucidate the importance of river water, macrophytes, and thermokarst as {DOM} sources to Mackenzie Delta lakes. Despite standing stocks of macrophyte C that are sevenfold to 12-fold greater than those of total {DOC}, stable isotopes indicated that autochthonous sources contributed less than 15\% to overall {DOM} in macrophyte-rich lakes. Instead, fluorescence and absorption indicated that the moderate summertime increase in {DOC} concentration in macrophyte-rich lakes was the result of infrequent flushing, while bacterial d13C indicated rapid bacterial removal of autochthonous {DOC} from the water column. In thermokarst lakes, summertime increases in {DOC} concentration were substantial, and stable isotopes indicated that much of this increase came from C released as a result of thermokarst-related processes. Our results indicate that these distinct sources of {DOM} to neighboring arctic Delta lakes may drive between-lake differences in C cycling and energy flow. Rapidly assimilated macrophyte {DOM} should be an important contributor to microbial food webs in our study lakes. In contrast, the accumulation of thermokarst-origin {DOM} allows for a significant role in physico-chemistry but indicates a lesser contribution of this {DOM} to higher trophic levels.},
+	pages = {1297--1309},
+	number = {4},
+	journaltitle = {Limnology and Oceanography},
+	author = {Tank, Suzanne E. and Lesack, Lance F. W. and Gareis, Jolie A. L. and Osburn, Christopher L. and Hesslein, Ray H.},
+	urldate = {2018-07-10},
+	date = {2011-07},
+	langid = {english},
+	file = {Tank et al. - 2011 - Multiple tracers demonstrate distinct sources of d.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\JBYRCSYS\\Tank et al. - 2011 - Multiple tracers demonstrate distinct sources of d.pdf:application/pdf}
+}
+
+@article{voigt_warming_2017,
+	title = {Warming of subarctic tundra increases emissions of all three important greenhouse gases - carbon dioxide, methane, and nitrous oxide},
+	volume = {23},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/gcb.13563},
+	doi = {10.1111/gcb.13563},
+	abstract = {Rapidly rising temperatures in the Arctic might cause a greater release of greenhouse gases ({GHGs}) to the atmosphere. To study the effect of warming on {GHG} dynamics, we deployed open-top chambers in a subarctic tundra site in Northeast European Russia. We determined carbon dioxide ({CO}2), methane ({CH}4), and nitrous oxide (N2O) ﬂuxes as well as the concentration of those gases, inorganic nitrogen (N) and dissolved organic carbon ({DOC}) along the soil proﬁle. Studied tundra surfaces ranged from mineral to organic soils and from vegetated to unvegetated areas. As a result of air warming, the seasonal {GHG} budget of the vegetated tundra surfaces shifted from a {GHG} sink of À300 to À198 g {CO}2–eq {mÀ}2 to a source of 105 to 144 g {CO}2–eq {mÀ}2. At bare peat surfaces, we observed increased release of all three {GHGs}. While the positive warming response was dominated by {CO}2, we provide here the ﬁrst in situ evidence of increasing N2O emissions from tundra soils with warming. Warming promoted N2O release not only from bare peat, previously identiﬁed as a strong N2O source, but also from the abundant, vegetated peat surfaces that do not emit N2O under present climate. At these surfaces, elevated temperatures had an adverse effect on plant growth, resulting in lower plant N uptake and, consequently, better N availability for soil microbes. Although the warming was limited to the soil surface and did not alter thaw depth, it increased concentrations of {DOC}, {CO}2, and {CH}4 in the soil down to the permafrost table. This can be attributed to downward {DOC} leaching, fueling microbial activity at depth. Taken together, our results emphasize the tight linkages between plant and soil processes, and different soil layers, which need to be taken into account when predicting the climate change feedback of the Arctic.},
+	pages = {3121--3138},
+	number = {8},
+	journaltitle = {Global Change Biology},
+	author = {Voigt, Carolina and Lamprecht, Richard E. and Marushchak, Maija E. and Lind, Saara E. and Novakovskiy, Alexander and Aurela, Mika and Martikainen, Pertti J. and Biasi, Christina},
+	urldate = {2018-07-10},
+	date = {2017-08},
+	langid = {english},
+	file = {Voigt et al. - 2017 - Warming of subarctic tundra increases emissions of.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\HP5JPI38\\Voigt et al. - 2017 - Warming of subarctic tundra increases emissions of.pdf:application/pdf}
+}
+
+@article{yuan_microbial_2018,
+	title = {Microbial functional diversity covaries with permafrost thaw-induced environmental heterogeneity in tundra soil},
+	volume = {24},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/gcb.13820},
+	doi = {10.1111/gcb.13820},
+	pages = {297--307},
+	number = {1},
+	journaltitle = {Global Change Biology},
+	author = {Yuan, Mengting M. and Zhang, Jin and Xue, Kai and Wu, Liyou and Deng, Ye and Deng, Jie and Hale, Lauren and Zhou, Xishu and He, Zhili and Yang, Yunfeng and Van Nostrand, Joy D. and Schuur, Edward A. G. and Konstantinidis, Konstantinos T. and Penton, Christopher R. and Cole, James R. and Tiedje, James M. and Luo, Yiqi and Zhou, Jizhong},
+	urldate = {2018-07-10},
+	date = {2018-01},
+	langid = {english},
+	file = {Yuan et al. - 2018 - Microbial functional diversity covaries with perma.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\SNW3HGEE\\Yuan et al. - 2018 - Microbial functional diversity covaries with perma.pdf:application/pdf}
+}
+
+@article{grewer_redistribution_2016,
+	title = {Redistribution of soil organic matter by permafrost disturbance in the Canadian High Arctic},
+	volume = {128},
+	issn = {0168-2563, 1573-515X},
+	url = {http://link.springer.com/10.1007/s10533-016-0215-7},
+	doi = {10.1007/s10533-016-0215-7},
+	pages = {397--415},
+	number = {3},
+	journaltitle = {Biogeochemistry},
+	author = {Grewer, David M. and Lafrenière, Melissa J. and Lamoureux, Scott F. and Simpson, Myrna J.},
+	urldate = {2018-07-10},
+	date = {2016-07},
+	langid = {english},
+	file = {Grewer et al. - 2016 - Redistribution of soil organic matter by permafros.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\9AVWLWEN\\Grewer et al. - 2016 - Redistribution of soil organic matter by permafros.pdf:application/pdf}
+}
+
+@article{birkel_integrating_2014,
+	title = {Integrating parsimonious models of hydrological connectivity and soil biogeochemistry to simulate stream {DOC} dynamics: {PARSIMONIOUS} {COUPLED} {DOC} {MODEL}},
+	volume = {119},
+	issn = {21698953},
+	url = {http://doi.wiley.com/10.1002/2013JG002551},
+	doi = {10.1002/2013JG002551},
+	shorttitle = {Integrating parsimonious models of hydrological connectivity and soil biogeochemistry to simulate stream {DOC} dynamics},
+	abstract = {To improve understanding and prediction of dissolved organic carbon ({DOC}) sources and ﬂuxes in northern peat-dominated catchments, we present the development and application of a parsimonious tracer-aided rainfall-runoff model coupled with a biogeochemistry subroutine able to concurrently simulate streamﬂow and {DOC} dynamics. The modeling approach which included quantitative assessment of associated uncertainties was conditioned by geochemical tracers which discriminate dominant water sources. Integration of {DOC} was predicated on statistical time series models which identiﬁed air temperature and streamﬂow as the key proxies that capture {DOC} supply and transport processes in two upland catchments in Scotland, {UK}. Conceptualizing the nonlinear partitioning of quick near-surface and slower groundwater runoff sources in combination with a {DOC} mass balance resulted in a coupled, low-parameter mechanistic model. Model tests showed mostly sensitive parameters and reasonable simulation results with seasonally controlled {DOC} supply and event-based {DOC} transport. Transport is facilitated even for smaller events by overland ﬂow from saturated histosols connected to the stream network. However, during prolonged dry periods, near-surface runoff “switches off” and stream {DOC} is dominated by low concentration groundwaters. Furthermore, the model was able to explain subtle differences in {DOC} dynamics between the two catchments mainly reﬂecting the distribution of saturated soils and available storage. We conclude that tracers and statistical time series models can successfully guide the development of parsimonious yet structurally consistent water quality models. Parsimonious models provide tools for estimating {DOC} dynamics and loads with reduced uncertainty and potentially greater transferability.},
+	pages = {1030--1047},
+	number = {5},
+	journaltitle = {Journal of Geophysical Research: Biogeosciences},
+	author = {Birkel, Christian and Soulsby, Chris and Tetzlaff, Doerthe},
+	urldate = {2018-07-10},
+	date = {2014-05},
+	langid = {english},
+	file = {Birkel et al. - 2014 - Integrating parsimonious models of hydrological co.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\IHILJUWI\\Birkel et al. - 2014 - Integrating parsimonious models of hydrological co.pdf:application/pdf}
+}
+
+@article{grosse_changing_2016,
+	title = {Changing permafrost in a warming world and feedbacks to the Earth system},
+	volume = {11},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/11/i=4/a=040201?key=crossref.721a63a7398b84c27da7f27834004831},
+	doi = {10.1088/1748-9326/11/4/040201},
+	pages = {040201},
+	number = {4},
+	journaltitle = {Environmental Research Letters},
+	author = {Grosse, Guido and Goetz, Scott and {McGuire}, A Dave and Romanovsky, Vladimir E and Schuur, Edward A G},
+	urldate = {2018-07-10},
+	date = {2016-04-01},
+	langid = {english},
+	file = {Grosse et al. - 2016 - Changing permafrost in a warming world and feedbac.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\DR29MC8H\\Grosse et al. - 2016 - Changing permafrost in a warming world and feedbac.pdf:application/pdf}
+}
+
+@article{meng_focus_2016,
+	title = {Focus on the impact of climate change on wetland ecosystems and carbon dynamics},
+	volume = {11},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/11/i=10/a=100201?key=crossref.ada7f1df1dfcbdace4ca4278816eceb2},
+	doi = {10.1088/1748-9326/11/10/100201},
+	abstract = {The renewed growth in atmospheric methane ({CH}4) since 2007 after a decade of stabilization has drawn much attention to its causes and future trends. Wetlands are the single largest source of atmospheric {CH}4. Understanding wetland ecosystems and carbon dynamics is critical to the estimation of global {CH}4 and carbon budgets. After approximately 7 years of {CH}4 related research following the renewed growth in atmospheric {CH}4, Environmental Research Letters launched a special issue of research letters on wetland ecosystems and carbon dynamics in 2014. This special issue highlights recent developments in terrestrial ecosystem models and ﬁeld measurements of carbon ﬂuxes across different types of wetland ecosystems. The 14 research letters emphasize the importance of wetland ecosystems in the global {CO}2 and {CH}4 budget.},
+	pages = {100201},
+	number = {10},
+	journaltitle = {Environmental Research Letters},
+	author = {Meng, Lei and Roulet, Nigel and Zhuang, Qianlai and Christensen, Torben R and Frolking, Steve},
+	urldate = {2018-07-10},
+	date = {2016-10-01},
+	langid = {english},
+	file = {Meng et al. - 2016 - Focus on the impact of climate change on wetland e.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\MZ9EJSBG\\Meng et al. - 2016 - Focus on the impact of climate change on wetland e.pdf:application/pdf}
+}
+
+@article{mann_pan-arctic_2016,
+	title = {Pan-Arctic Trends in Terrestrial Dissolved Organic Matter from Optical Measurements},
+	volume = {4},
+	issn = {2296-6463},
+	url = {http://journal.frontiersin.org/Article/10.3389/feart.2016.00025/abstract},
+	doi = {10.3389/feart.2016.00025},
+	abstract = {Climate change is causing extensive warming across Arctic regions resulting in permafrost degradation, alterations to regional hydrology and shifting amounts and composition of dissolved organic matter ({DOM}) transported by streams and rivers. Here, we characterize the {DOM} composition and optical properties of the six largest Arctic rivers draining into the Arctic Ocean to examine the ability of optical measurements to provide meaningful insights into terrigenous carbon export patterns and biogeochemical cycling. The chemical composition of aquatic {DOM} varied with season, spring months were typiﬁed by highest lignin phenol and dissolved organic carbon ({DOC}) concentrations with greater hydrophobic acid content, and lower proportions of hydrophilic compounds, relative to summer and winter months. Chromophoric {DOM} ({CDOM}) spectral slope (S275–295) tracked seasonal shifts in {DOM} composition across river basins. Fluorescence and parallel factor analysis identiﬁed seven components across the six Arctic rivers. The ratios of “terrestrial humic-like” vs. “marine humic-like” ﬂuorescent components co-varied with lignin monomer ratios over summer and winter months, suggesting ﬂuorescence may provide information on the age and degradation state of riverine {DOM}. {CDOM} absorbance (a350) proved a sensitive proxy for lignin phenol concentrations across all six river basins and over the hydrograph, enabling for the ﬁrst time the development of a single pan-arctic relationship between a350 and terrigenous {DOC} (R2 = 0.93). Combining this lignin proxy with high-resolution monitoring of a350, pan-arctic estimates of annual lignin ﬂux were calculated to range from 156 to 185 Gg, resulting in shorter and more constrained estimates of terrigenous {DOM} residence times in the Arctic Ocean (spanning 7 months to 2½ years). Furthermore, multiple linear regression models incorporating both absorbance and ﬂuorescence variables proved capable of explaining much of the variability in lignin composition across rivers and seasons. Our ﬁndings suggest that synoptic, high-resolution optical measurements can provide improved understanding of northern high-latitude organic matter cycling and ﬂux, and prove an important technique for capturing future climate-driven changes.},
+	journaltitle = {Frontiers in Earth Science},
+	author = {Mann, Paul J. and Spencer, Robert G. M. and Hernes, Peter J. and Six, Johan and Aiken, George R. and Tank, Suzanne E. and {McClelland}, James W. and Butler, Kenna D. and Dyda, Rachael Y. and Holmes, Robert M.},
+	urldate = {2018-07-10},
+	date = {2016-03-17},
+	langid = {english},
+	file = {Mann et al. - 2016 - Pan-Arctic Trends in Terrestrial Dissolved Organic.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\EDA6WJEQ\\Mann et al. - 2016 - Pan-Arctic Trends in Terrestrial Dissolved Organic.pdf:application/pdf}
+}
+
+@article{striegl_carbon_2012,
+	title = {Carbon dioxide and methane emissions from the Yukon River system: {YUKON} {RIVER} C {GAS} {EMISSIONS}},
+	volume = {26},
+	issn = {08866236},
+	url = {http://doi.wiley.com/10.1029/2012GB004306},
+	doi = {10.1029/2012GB004306},
+	shorttitle = {Carbon dioxide and methane emissions from the Yukon River system},
+	pages = {n/a--n/a},
+	number = {4},
+	journaltitle = {Global Biogeochemical Cycles},
+	author = {Striegl, Robert G. and Dornblaser, M. M. and {McDonald}, C. P. and Rover, J. R. and Stets, E. G.},
+	urldate = {2018-07-10},
+	date = {2012-12},
+	langid = {english},
+	file = {Striegl et al. - 2012 - Carbon dioxide and methane emissions from the Yuko.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4VJK44C5\\Striegl et al. - 2012 - Carbon dioxide and methane emissions from the Yuko.pdf:application/pdf}
+}
+
+@article{abbott_biomass_2016,
+	title = {Biomass offsets little or none of permafrost carbon release from soils, streams, and wildfire: an expert assessment},
+	volume = {11},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/11/i=3/a=034014?key=crossref.66df61179f78005f9999c2637a68bf9e},
+	doi = {10.1088/1748-9326/11/3/034014},
+	shorttitle = {Biomass offsets little or none of permafrost carbon release from soils, streams, and wildfire},
+	abstract = {As the permafrost region warms, its large organic carbon pool will be increasingly vulnerable to decomposition, combustion, and hydrologic export. Models predict that some portion of this release will be offset by increased production of Arctic and boreal biomass; however, the lack of robust estimates of net carbon balance increases the risk of further overshooting international emissions targets. Precise empirical or model-based assessments of the critical factors driving carbon balance are unlikely in the near future, so to address this gap, we present estimates from 98 permafrost-region experts of the response of biomass, wildﬁre, and hydrologic carbon ﬂux to climate change. Results suggest that contrary to model projections, total permafrost-region biomass could decrease due to water stress and disturbance, factors that are not adequately incorporated in current models. Assessments indicate that end-of-the-century organic carbon release from Arctic rivers and collapsing coastlines could increase by 75\% while carbon loss via burning could increase four-fold. Experts identiﬁed water balance, shifts in vegetation community, and permafrost degradation as the key sources of uncertainty in predicting future system response. In combination with previous ﬁndings, results suggest the permafrost region will become a carbon source to the atmosphere by 2100 regardless of warming scenario but that 65\%–85\% of permafrost carbon release can still be avoided if human emissions are actively reduced.},
+	pages = {034014},
+	number = {3},
+	journaltitle = {Environmental Research Letters},
+	author = {Abbott, Benjamin W and Jones, Jeremy B and Schuur, Edward A G and Chapin III, F Stuart and Bowden, William B and Bret-Harte, M Syndonia and Epstein, Howard E and Flannigan, Michael D and Harms, Tamara K and Hollingsworth, Teresa N and Mack, Michelle C and McGuire, A David and Natali, Susan M and Rocha, Adrian V and Tank, Suzanne E and Turetsky, Merritt R and Vonk, Jorien E and Wickland, Kimberly P and Aiken, George R and Alexander, Heather D and Amon, Rainer M W and Benscoter, Brian W and Bergeron, Yves and Bishop, Kevin and Blarquez, Olivier and {Ben Bond-Lamberty} and Breen, Amy L and Buffam, Ishi and Cai, Yihua and Carcaillet, Christopher and Carey, Sean K and Chen, Jing M and Chen, Han Y H and Christensen, Torben R and Cooper, Lee W and Cornelissen, J Hans C and de Groot, William J and DeLuca, Thomas H and Dorrepaal, Ellen and Fetcher, Ned and Finlay, Jacques C and Forbes, Bruce C and French, Nancy H F and Gauthier, Sylvie and Girardin, Martin P and Goetz, Scott J and Goldammer, Johann G and Gough, Laura and Grogan, Paul and Guo, Laodong and Higuera, Philip E and Hinzman, Larry and Hu, Feng Sheng and Hugelius, Gustaf and Jafarov, Elchin E and Jandt, Randi and Johnstone, Jill F and {Jan Karlsson} and Kasischke, Eric S and Kattner, Gerhard and Kelly, Ryan and Keuper, Frida and Kling, George W and Kortelainen, Pirkko and Kouki, Jari and Kuhry, Peter and Laudon, Hjalmar and Laurion, Isabelle and Macdonald, Robie W and Mann, Paul J and Martikainen, Pertti J and McClelland, James W and Molau, Ulf and Oberbauer, Steven F and Olefeldt, David and Paré, David and Parisien, Marc-André and Payette, Serge and Peng, Changhui and Pokrovsky, Oleg S and Rastetter, Edward B and Raymond, Peter A and Raynolds, Martha K and Rein, Guillermo and Reynolds, James F and Robards, Martin and Rogers, Brendan M and Schädel, Christina and Schaefer, Kevin and Schmidt, Inger K and Shvidenko, Anatoly and Sky, Jasper and Spencer, Robert G M and Starr, Gregory and Striegl, Robert G and Teisserenc, Roman and Tranvik, Lars J and Virtanen, Tarmo and Welker, Jeffrey M and Zimov, Sergei},
+	urldate = {2018-07-10},
+	date = {2016-03-01},
+	langid = {english},
+	file = {Abbott et al. - 2016 - Biomass offsets little or none of permafrost carbo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ZIVXAECM\\Abbott et al. - 2016 - Biomass offsets little or none of permafrost carbo.pdf:application/pdf;Abbott_SI.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\BXSPRXVM\\Abbott_SI.pdf:application/pdf}
+}
+
+@article{tank_multi-decadal_2016,
+	title = {Multi-decadal increases in dissolved organic carbon and alkalinity flux from the Mackenzie drainage basin to the Arctic Ocean},
+	volume = {11},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/11/i=5/a=054015?key=crossref.7d1c7cfed6e5144abdb52d2f625a9970},
+	doi = {10.1088/1748-9326/11/5/054015},
+	pages = {054015},
+	number = {5},
+	journaltitle = {Environmental Research Letters},
+	author = {Tank, Suzanne E and Striegl, Robert G and {McClelland}, James W and Kokelj, Steven V},
+	urldate = {2018-07-10},
+	date = {2016-05-01},
+	langid = {english},
+	file = {Tank et al. - 2016 - Multi-decadal increases in dissolved organic carbo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\J5V6VHLI\\Tank et al. - 2016 - Multi-decadal increases in dissolved organic carbo.pdf:application/pdf}
+}
+
+@article{baofeng_digital_2016,
+	title = {Digital surface model applied to unmanned aerial vehicle based photogrammetry to assess potential biotic or abiotic effects on grapevine canopies},
+	volume = {9},
+	abstract = {Accurate data acquisition and analysis to obtain crop canopy information are critical steps to understand plant growth dynamics and to assess the potential impacts of biotic or abiotic stresses on plant development. A versatile and easy to use monitoring system will allow researchers and growers to improve the follow-up management strategies within farms once potential problems have been detected. This study reviewed existing remote sensing platforms and relevant information applied to crops and specifically grapevines to equip a simple Unmanned Aerial Vehicle ({UAV}) using a visible high definition {RGB} camera. The objective of the proposed Unmanned Aerial System ({UAS}) was to implement a Digital Surface Model ({DSM}) in order to obtain accurate information about the affected or missing grapevines that can be attributed to potential biotic or abiotic stress effects. The analysis process started with a three-dimensional (3D) reconstruction from the {RGB} images collected from grapevines using the {UAS} and the Structure from Motion ({SfM}) technique to obtain the {DSM} applied on a per-plant basis. Then, the {DSM} was expressed as greyscale images according to the halftone technique to finally extract the information of affected and missing grapevines using computer vision algorithms based on canopy cover measurement and classification. To validate the automated method proposed, each grapevine row was visually inspected within the study area. The inspection was then compared to the digital assessment using the proposed {UAS} in order to validate calculations of affected and missing grapevines for the whole studied vineyard. Results showed that the percentage of affected and missing grapevines was 9.5\% and 7.3\%, respectively from the area studied. Therefore, for this specific study, the abiotic stress that affected the experimental vineyard (frost) impacted a total of 16.8 \% of plants. This study provided a new method for automatically surveying affected or missing grapevines in the field and an evaluation tool for plant growth conditions, which can be implemented for other uses such as canopy management, irrigation scheduling and other precision agricultural applications.},
+	pages = {13},
+	journaltitle = {Biol Eng},
+	author = {Baofeng, Su and Jinru, Xue and Chunyu, Xie and Yulin, Fang and Yuyang, Song and Fuentes, Sigfredo},
+	date = {2016-11-16},
+	langid = {english},
+	file = {Baofeng et al. - Digital surface model applied to unmanned aerial v.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\25SC6CWE\\Baofeng et al. - Digital surface model applied to unmanned aerial v.pdf:application/pdf}
+}
+
+@article{gennaro_unmanned_2016,
+	title = {Unmanned Aerial Vehicle ({UAV})-based remote sensing to monitor grapevine leaf stripe disease within a vineyard affected by esca complex},
+	issn = {00319465},
+	url = {http://www.fupress.net/index.php/pm/article/view/18312},
+	doi = {10.14601/Phytopathol_Mediterr-18312},
+	abstract = {Foliar symptoms of grapevine leaf stripe disease ({GLSD}, a disease within the esca complex) are linked to drastic alteration of photosynthetic function and activation of defense responses in affected grapevines several days before the appearance of the first visible symptoms on leaves. The present study suggests a methodology to investigate the relationships between high-resolution multispectral images (0.05 m/pixel) acquired using an Unmanned Aerial Vehicle ({UAV}), and {GLSD} foliar symptoms monitored by ground surveys. This approach showed high correlation between Normalized Differential Vegetation Index ({NDVI}) acquired by the {UAV} and {GLSD} symptoms, and discrimination between symptomatic from asymptomatic plants. High-resolution multispectral images were acquired during June and July of 2012 and 2013, in an experimental vineyard heavily affected by {GLSD}, located in Tuscany (Italy), where vines had been surveyed and mapped since 2003. Each vine was located with a global positioning system, and classified for appearance of foliar symptoms and disease severity at weekly intervals from the beginning of each season. Remote sensing and ground observation data were analyzed to promptly identify the early stages of disease, even before visual detection. This work suggests an innovative methodology for quantitative and qualitative analysis of spatial distribution of symptomatic plants. The system may also be used for exploring the physiological bases of {GLSD}, and predicting the onset of this disease.},
+	number = {2},
+	journaltitle = {Phytopathologia Mediterranea},
+	author = {{GENNARO}, Salvatore F. {DI} and {BATTISTON}, Enrico and {MARCO}, Stefano {DI} and {FACINI}, Osvaldo and {MATESE}, Alessandro and {NOCENTINI}, Marco and {PALLIOTTI}, Alberto and {MUGNAI}, Laura},
+	urldate = {2018-07-04},
+	date = {2016-07-29},
+	langid = {english},
+	file = {GENNARO et al. - 2016 - Unmanned Aerial Vehicle (UAV)-based remote sensing.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\Q38A2UPX\\GENNARO et al. - 2016 - Unmanned Aerial Vehicle (UAV)-based remote sensing.pdf:application/pdf}
+}
+
+@article{arno_review._2009,
+	title = {Review. Precision viticulture. Research topics, challenges and opportunities in site-specific vineyard management},
+	volume = {7},
+	issn = {2171-9292, 1695-971X},
+	url = {http://revistas.inia.es/index.php/sjar/article/view/1092},
+	doi = {10.5424/sjar/2009074-1092},
+	abstract = {Precision Viticulture ({PV}) is a concept that is beginning to have an impact on the wine-growing sector. Its practical implementation is dependant on various technological developments: crop sensors and yield monitors, local and remote sensors, Global Positioning Systems ({GPS}), {VRA} (Variable-Rate Application) equipment and machinery, Geographic Information Systems ({GIS}) and systems for data analysis and interpretation. This paper reviews a number of research lines related to {PV}. These areas of research have focused on four very specific fields: 1) quantification and evaluation of within-field variability, 2) delineation of zones of differential treatment at parcel level, based on the analysis and interpretation of this variability, 3) development of Variable-Rate Technologies ({VRT}) and, finally, 4) evaluation of the opportunities for site-specific vineyard management. Research in these fields should allow winegrowers and enologists to know and understand why yield variability exists within the same parcel, what the causes of this variability are, how the yield and its quality are interrelated and, if spatial variability exists, whether site-specific vineyard management is justifiable on a technical and economic basis.},
+	pages = {779},
+	number = {4},
+	journaltitle = {Spanish Journal of Agricultural Research},
+	author = {Arnó, J. and Martínez Casasnovas, J.A. and Ribes Dasi, M. and Rosell, J.R.},
+	urldate = {2018-07-04},
+	date = {2009-12-01},
+	langid = {english},
+	file = {Arnó et al. - 2009 - Review. Precision viticulture. Research topics, ch.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\MYKWTYKV\\Arnó et al. - 2009 - Review. Precision viticulture. Research topics, ch.pdf:application/pdf}
+}
+
+@article{bramley_understanding_2005,
+	title = {Understanding variability in winegrape production systems 2. Within vineyard variation in quality over several vintages},
+	volume = {11},
+	issn = {1322-7130, 1755-0238},
+	url = {http://doi.wiley.com/10.1111/j.1755-0238.2005.tb00277.x},
+	doi = {10.1111/j.1755-0238.2005.tb00277.x},
+	abstract = {Spatial variability in various indices of winegrape quality was studied over several vintages in blocks planted to Cabernet Sauvignon and Ruby Cabernet in the Coonawarra (1999–2002) and Sunraysia (2000–2002) regions of Australia. At both sites, inter-annual variation was marked whilst intra-annual variation was much greater for some indices (e.g. concentration of total phenolics) than others (e.g. Baumé). The magnitude of intra-annual variation was readily identiﬁed in terms of the ‘spread’, deﬁned as the difference between the maximum and minimum values, expressed as a \% of the median value. Typical values of the spread were 20\% for Baumé, but could be as high as 117\% for phenolics, and better indicated the extent of variation facing the winemaker than the coefﬁcient of variation ({CV}; typically 3\% for Baumé and 14\% for phenolics). For all attributes, variation in any given year showed marked spatial structure, with the patterns of variation being broadly consistent for each attribute in each year of the study, and with many attributes following similar patterns. The results therefore strongly support the idea of zonal vineyard management. However, fruit quality zone identification is dependent on a large sampling effort. Therefore, given the current availability of yield monitors, the ﬁnding that between-zone differences in quality indices were generally signiﬁcant (P {\textless} 0.05) for zones identiﬁed on the basis of yield alone, and, in the absence of an on-the-go sensing capability, it is suggested that zonal management should proceed on the basis of zones of characteristic yield productivity. Based on the present work, it is suggested that development of an on-the-go fruit quality sensing technology would enable the wine industry to maximise its opportunity to gain benefit from differential vineyard management such as selective harvesting. Indeed, the results of this work suggest that in the absence of zonal management, preferably supported by on-the-go quality sensing, winemaker demands for delivery of uniform parcels of fruit are unlikely to be satisﬁed.},
+	pages = {33--42},
+	number = {1},
+	journaltitle = {Australian Journal of Grape and Wine Research},
+	author = {Bramley, R.G.V.},
+	urldate = {2018-07-04},
+	date = {2005-04},
+	langid = {english},
+	file = {Bramley - 2005 - Understanding variability in winegrape production .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\SMNS5YAL\\Bramley - 2005 - Understanding variability in winegrape production .pdf:application/pdf}
+}
+
+@article{de_castro_3-d_2018,
+	title = {3-D Characterization of Vineyards Using a Novel {UAV} Imagery-Based {OBIA} Procedure for Precision Viticulture Applications},
+	volume = {10},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/10/4/584},
+	doi = {10.3390/rs10040584},
+	abstract = {Precision viticulture has arisen in recent years as a new approach in grape production. It is based on assessing ﬁeld spatial variability and implementing site-speciﬁc management strategies, which can require georeferenced information of the three dimensional (3D) grapevine canopy structure as one of the input data. The 3D structure of vineyard ﬁelds can be generated applying photogrammetric techniques to aerial images collected with Unmanned Aerial Vehicles ({UAVs}), although processing the large amount of crop data embedded in 3D models is currently a bottleneck of this technology. To solve this limitation, a novel and robust object-based image analysis ({OBIA}) procedure based on Digital Surface Model ({DSM}) was developed for 3D grapevine characterization. The signiﬁcance of this work relies on the developed {OBIA} algorithm which is fully automatic and self-adaptive to different crop-ﬁeld conditions, classifying grapevines, and row gap (missing vine plants), and computing vine dimensions without any user intervention. The results obtained in three testing ﬁelds on two different dates showed high accuracy in the classiﬁcation of grapevine area and row gaps, as well as minor errors in the estimates of grapevine height. In addition, this algorithm computed the position, projected area, and volume of every grapevine in the ﬁeld, which increases the potential of this {UAV}- and {OBIA}-based technology as a tool for site-speciﬁc crop management applications.},
+	pages = {584},
+	number = {4},
+	journaltitle = {Remote Sensing},
+	author = {de Castro, Ana and Jiménez-Brenes, Francisco and Torres-Sánchez, Jorge and Peña, José and Borra-Serrano, Irene and López-Granados, Francisca},
+	urldate = {2018-07-04},
+	date = {2018-04-10},
+	langid = {english},
+	file = {de Castro et al. - 2018 - 3-D Characterization of Vineyards Using a Novel UA.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\V7C4QQ8G\\de Castro et al. - 2018 - 3-D Characterization of Vineyards Using a Novel UA.pdf:application/pdf}
+}
+
+@article{feng_uav_2015,
+	title = {{UAV} Remote Sensing for Urban Vegetation Mapping Using Random Forest and Texture Analysis},
+	volume = {7},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/7/1/1074},
+	doi = {10.3390/rs70101074},
+	pages = {1074--1094},
+	number = {1},
+	journaltitle = {Remote Sensing},
+	author = {Feng, Quanlong and Liu, Jiantao and Gong, Jianhua},
+	urldate = {2018-07-04},
+	date = {2015-01-19},
+	langid = {english},
+	file = {Feng et al. - 2015 - UAV Remote Sensing for Urban Vegetation Mapping Us.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\AEGI5689\\Feng et al. - 2015 - UAV Remote Sensing for Urban Vegetation Mapping Us.pdf:application/pdf}
+}
+
+@article{mcguire_dependence_2018,
+	title = {Dependence of the evolution of carbon dynamics in the northern permafrost region on the trajectory of climate change},
+	volume = {115},
+	issn = {0027-8424, 1091-6490},
+	url = {http://www.pnas.org/lookup/doi/10.1073/pnas.1719903115},
+	doi = {10.1073/pnas.1719903115},
+	pages = {3882--3887},
+	number = {15},
+	journaltitle = {Proceedings of the National Academy of Sciences},
+	author = {{McGuire}, A. David and Lawrence, David M. and Koven, Charles and Clein, Joy S. and Burke, Eleanor and Chen, Guangsheng and Jafarov, Elchin and {MacDougall}, Andrew H. and Marchenko, Sergey and Nicolsky, Dmitry and Peng, Shushi and Rinke, Annette and Ciais, Philippe and Gouttevin, Isabelle and Hayes, Daniel J. and Ji, Duoying and Krinner, Gerhard and Moore, John C. and Romanovsky, Vladimir and Schädel, Christina and Schaefer, Kevin and Schuur, Edward A. G. and Zhuang, Qianlai},
+	urldate = {2018-07-02},
+	date = {2018-04-10},
+	langid = {english},
+	file = {McGuire et al. - 2018 - Dependence of the evolution of carbon dynamics in .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\V4CP9RI9\\McGuire et al. - 2018 - Dependence of the evolution of carbon dynamics in .pdf:application/pdf}
+}
+
+@article{noauthor_3882.full.pdf_nodate,
+	title = {3882.full.pdf},
+	doi = {https://doi.org/10.1073/pnas.1719903115}
+}
+
+@article{turner_controls_2014,
+	title = {Controls on water balance of shallow thermokarst lakes and their relations with catchment characteristics: a multi-year, landscape-scale assessment based on water isotope tracers and remote sensing in Old Crow Flats, Yukon (Canada)},
+	volume = {20},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/gcb.12465},
+	doi = {10.1111/gcb.12465},
+	shorttitle = {Controls on water balance of shallow thermokarst lakes and their relations with catchment characteristics},
+	abstract = {Many northern lake-rich regions are undergoing pronounced hydrological change, yet inadequate knowledge of the drivers of these landscape-scale responses hampers our ability to predict future conditions. We address this challenge in the thermokarst landscape of Old Crow Flats ({OCF}) using a combination of remote sensing imagery and monitoring of stable isotope compositions of lake waters over three thaw seasons (2007–2009). Quantitative analysis conﬁrmed that the hydrological behavior of lakes is strongly inﬂuenced by catchment vegetation and physiography. Catchments of snowmelt-dominated lakes, typically located in southern peripheral areas of {OCF}, encompass high proportions of woodland/forest and tall shrub vegetation (mean percent land cover = ca. 60\%). These land cover types effectively capture snow and generate abundant snowmelt runoff that offsets lake water evaporation. Rainfalldominated lakes that are not strongly inﬂuenced by evaporation are typically located in eastern and northern {OCF} where their catchments have higher proportions of dwarf shrub/herbaceous and sparse vegetation (ca. 45\%), as well as surface water (ca. 20\%). Evaporation-dominated lakes, are located in the {OCF} interior where their catchments are distinguished by substantially higher lake area to catchment area ratios ({LA}/{CA} = ca. 29\%) compared to low evaporation-inﬂuenced rainfall-dominated (ca. 10\%) and snowmelt-dominated (ca. 4\%) lakes. Lakes whose catchments contain {\textgreater}75\% combined dwarf shrub/herbaceous vegetation and surface water are most susceptible to evaporative lake-level drawdown, especially following periods of low precipitation. Findings indicate that multiple hydrological trajectories are probable in response to climate-driven changes in precipitation amount and seasonality, vegetation composition, and thermokarst processes. These will likely include a shift to greater snowmelt inﬂuence in catchments experiencing expansion of tall shrubs, greater inﬂuence from evaporation in catchments having higher proportions of surface water, and an increase in the rate of thermokarst lake expansion and probability of drainage. Local observations suggest that some of these changes are already underway.},
+	pages = {1585--1603},
+	number = {5},
+	journaltitle = {Global Change Biology},
+	author = {Turner, Kevin W. and Wolfe, Brent B. and Edwards, Thomas W. D. and Lantz, Trevor C. and Hall, Roland I. and Larocque, Guillaume},
+	urldate = {2018-06-29},
+	date = {2014-05},
+	langid = {english},
+	file = {Turner et al. - 2014 - Controls on water balance of shallow thermokarst l.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ENFATHMR\\Turner et al. - 2014 - Controls on water balance of shallow thermokarst l.pdf:application/pdf}
+}
+
+@article{carrillo_use_2016,
+	title = {Use of multi-spectral airborne imagery to improve yield sampling in viticulture},
+	volume = {17},
+	issn = {1385-2256, 1573-1618},
+	url = {http://link.springer.com/10.1007/s11119-015-9407-8},
+	doi = {10.1007/s11119-015-9407-8},
+	pages = {74--92},
+	number = {1},
+	journaltitle = {Precision Agriculture},
+	author = {Carrillo, E. and Matese, A. and Rousseau, J. and Tisseyre, B.},
+	urldate = {2018-06-27},
+	date = {2016-02},
+	langid = {english},
+	file = {Carrillo et al. - 2016 - Use of multi-spectral airborne imagery to improve .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\NP4AZI7X\\Carrillo et al. - 2016 - Use of multi-spectral airborne imagery to improve .pdf:application/pdf}
+}
+
+@misc{gordon_arctic_2005,
+	title = {Arctic Borderlands Ecological Knowledge Co-op},
+	author = {Gordon, Annie B and Andre, May and Kaglik, Butch and Cockney, Steve and Allen, Mildred and Snowshoe, Audrey and Tetlichi, Randall},
+	date = {2005},
+	langid = {english},
+	file = {Gordon et al. - 2005 - Arctic Borderlands Ecological Knowledge Co-op.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\DXMNW9PT\\Gordon et al. - 2005 - Arctic Borderlands Ecological Knowledge Co-op.pdf:application/pdf}
+}
+
+@article{hogrefe_normalized_2017,
+	title = {Normalized Difference Vegetation Index as an Estimator for Abundance and Quality of Avian Herbivore Forage in Arctic Alaska},
+	volume = {9},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/9/12/1234},
+	doi = {10.3390/rs9121234},
+	abstract = {Tools that can monitor biomass and nutritional quality of forage plants are needed to understand how arctic herbivores may respond to the rapidly changing environment at high latitudes. The Normalized Difference Vegetation Index ({NDVI}) has been widely used to assess changes in abundance and distribution of terrestrial vegetative communities. However, the efﬁcacy of {NDVI} to measure seasonal changes in biomass and nutritional quality of forage plants in the Arctic remains largely un-evaluated at landscape and ﬁne-scale levels. We modeled the relationships between {NDVI} and seasonal changes in aboveground biomass and nitrogen concentration in halophytic graminoids, a key food source for arctic-nesting geese. The model was calibrated based on data collected at one site and validated using data from another site. Effects of spatial scale on model accuracy were determined by comparing model predictions between {NDVI} derived from moderate resolution (250 × 250 m pixels) satellite data and high resolution (20 cm diameter area) handheld spectrometer data. {NDVI} derived from the handheld spectrometer was a superior estimator (R2 ≥ 0.67) of seasonal changes in aboveground biomass compared to satellite-derived {NDVI} (R2 ≤ 0.40). The addition of temperature and precipitation variables to the model for biomass improved ﬁt, but provided minor gains in predictive power beyond that of the {NDVI}-only model. This model, however, was only a moderately accurate estimator of biomass in an ecologically-similar halophytic graminoid wetland located 100 km away, indicating the necessity for site-speciﬁc validation. In contrast to assessments of biomass, satellite-derived {NDVI} was a better estimator for the timing of peak percent of nitrogen than {NDVI} derived from the handheld spectrometer. We conﬁrmed that the date when {NDVI} reached 50\% of its seasonal maximum was a reasonable approximation of the period of peak spring vegetative green-up and peak percent nitrogen. This study demonstrates the importance of matching the scale of {NDVI} measurements to the vegetation properties of biomass and nitrogen phenology.},
+	pages = {1234},
+	number = {12},
+	journaltitle = {Remote Sensing},
+	author = {Hogrefe, Kyle and Patil, Vijay and Ruthrauff, Daniel and Meixell, Brandt and Budde, Michael and Hupp, Jerry and Ward, David},
+	urldate = {2018-06-19},
+	date = {2017-11-29},
+	langid = {english},
+	file = {Hogrefe et al. - 2017 - Normalized Difference Vegetation Index as an Estim.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\QJLPS23F\\Hogrefe et al. - 2017 - Normalized Difference Vegetation Index as an Estim.pdf:application/pdf}
+}
+
+@article{ahmed_assessment_2018,
+	title = {Assessment of land cover change using remote sensing, aerial photographs and dendrochronological approaches in Old Crow Flats, Yukon},
+	abstract = {Changing climate conditions have been amplified across Arctic and subarctic regions, which have influenced landscape characteristics. Notably, shrub vegetation size and spatial distributions have increased in many locations, which have been found to influence other landscape components including hydrological and ecological conditions. The 14,500 km2 Old Crow Flats ({OCF}) basin in northern Yukon is one such landscape where past research has identified relations among land cover and hydroecological conditions, however, more refined insight of land cover changes is required to identify how this important and vast wetland will respond to future changing climate. Here, we evaluated spatial and temporal patterns of vegetation change in {OCF} since 1985 using Landsat imagery and ground control observations from plot sampling, oblique aerial images, and an unmanned aerial vehicle ({UAV}). Trends in greening vegetation spatial distribution were identified using remote-sensing indicators, the normalized difference vegetation index ({NDVI}) and tasseled cap transformation ({TCg}). Findings showed a significant increase in vegetation greening during the last 30 years, which was compared with a Landsat-derived land cover classification layer. Quantitative analysis showed that greening occurred mostly in 8,335 km2 shrub-vegetation classified areas (outside of drained lake basins) from 1985 to 2014. Shrub vegetation coverage was estimated to increase approximately 13.25 km2 per year in {OCF}. The greatest increases in vegetation was found across the northern and eastern ecotone areas of the {OCF} basin. The highest percentage of greening ({\textasciitilde}7.58\%) was observed in the northern {OCF} basin and northern parts of the Black Fox Creek subcatchment, and the highest coverage of greening ({\textasciitilde}2,108 km2) was found in the Johnson Creek subcatchment. Additional validation of remote sensing analysis was generated from 550 oblique photographs, as well as integration of shrub age analysis and acquisition of multispectral images in two 90-m plots. Oblique photographs showed the majority (72\%) of sampled pixels with significant greening were shrub vegetation. {UAV} and analysis of tree rings in the two plots within greening pixels showed that shrub was the dominant vegetation (70-73\% coverage) and that 70\% of shrubs sampled were dated at ≤ 30 years old. The Landsat-derived vegetation greening products will be essential for refining our knowledge of how changing land cover is impacting lake and river hydroecological conditions. Insight generated here about key wildlife habitat will be useful for stakeholders including the Vuntut Gwitchin First Nation and Vuntut National Park as they form monitoring and land management plans as climate continues to change.},
+	journaltitle = {Remote Sensing},
+	shortjournal = {Remote Sensing},
+	author = {Ahmed, M. Razu and Turner, Kevin W. and Thorne, W. Brent and Wang, Jon A. and Lantz, Trevor C.},
+	date = {2018-06},
+	file = {Ahmed et al. - 2018 - Assessment of land cover change using remote sensi.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\UKJEP9PC\\Ahmed et al. - 2018 - Assessment of land cover change using remote sensi.pdf:application/pdf}
+}
+
+@article{olthof_recent_2009,
+	title = {Recent (1986-2006) Vegetation-Specific {NDVI} Trends in Northern Canada from Satellite Data},
+	volume = {61},
+	issn = {1923-1245, 0004-0843},
+	url = {http://arctic.journalhosting.ucalgary.ca/arctic/index.php/arctic/article/view/46},
+	doi = {10.14430/arctic46},
+	abstract = {Recent northern vegetation changes caused by climate warming have been well documented, using experimental plot warming to examine vegetation-specific changes and satellite image data to examine overall trends. Previous remote sensing efforts have employed the Normalized Difference Vegetation Index ({NDVI}) from {AVHRR}, whose 1 km to 8 km pixel size is too large for examination of broad scale vegetation-specific responses because of mixing within the pixel footprint. In this paper, we reconcile differences between field- and remote sensing-based approaches by using both medium-resolution (30 m) and coarseresolution (1 km) data to study 20 years of vegetation-specific responses to northern climate warming (1986 to 2006). Trends are compared among vegetation communities from two separate Landsat classifications in Canada’s eastern and western forest-tundra transition zone, as well as a 1 km {AVHRR} database recently developed over Canada. A comparison of absolute trends among mapped vegetation communities revealed lichen-dominated communities consistently exhibiting lower trends than those dominated by vascular plants, with both exhibiting increasing {NDVI}. Our results and those obtained from experimental warming suggest that the magnitude difference in {NDVI} increase between lichen and vascular vegetation is related to increasing vigor and biomass of vascular vegetation, in contrast to physiological impairment of lichen due to the short-term secondary effect of temperature on moisture. In the longer term, succession from lichen to vascular is likely responsible for the small observed {NDVI} increase over lichen-dominated regions. The fact that both Landsat and {AVHRR} exhibited similar relative vegetation-specific trends in {NDVI} suggests that this phenomenon may be widespread in the North.},
+	number = {4},
+	journaltitle = {{ARCTIC}},
+	author = {Olthof, Ian and Pouliot, Darren},
+	urldate = {2018-05-09},
+	date = {2009-08-28},
+	langid = {english},
+	file = {Olthof and Pouliot - 2009 - Recent (1986-2006) Vegetation-Specific NDVI Trends.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\B2P2MZGI\\Olthof and Pouliot - 2009 - Recent (1986-2006) Vegetation-Specific NDVI Trends.pdf:application/pdf}
+}
+
+@article{van_der_maaten_dendrometer:_2016,
+	title = {{dendrometeR}: Analyzing the pulse of trees in R},
+	volume = {40},
+	issn = {11257865},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S1125786516300662},
+	doi = {10.1016/j.dendro.2016.06.001},
+	shorttitle = {{dendrometeR}},
+	abstract = {Dendrometers are measurement devices proven to be useful to analyze tree water relations and growth responses in relation to environmental variability. To analyze dendrometer data, two analytical methods prevail: (1) daily approaches that calculate or extract single values per day, and (2) stem-cycle approaches that separate high-resolution dendrometer records into distinct phases of contraction, expansion and stem-radius increment. Especially the stem-cycle approach requires complex algorithms to disentangle cyclic phases. Here, we present an R package, named {dendrometeR}, that facilitates the analysis of dendrometer data using both analytical methods. By making the package freely available, we make a ﬁrst step towards comparable and reproducible methods to analyze dendrometer data. The package contains customizable functions to prepare, verify, process and plot dendrometer series, as well as functions that facilitate the analysis of dendrometer data (i.e. daily statistics or extracted phases) in relation to environmental data. The functionality of {dendrometeR} is illustrated in this note.},
+	pages = {12--16},
+	journaltitle = {Dendrochronologia},
+	author = {van der Maaten, Ernst and van der Maaten-Theunissen, Marieke and Smiljanić, Marko and Rossi, Sergio and Simard, Sonia and Wilmking, Martin and Deslauriers, Annie and Fonti, Patrick and von Arx, Georg and Bouriaud, Olivier},
+	urldate = {2018-04-13},
+	date = {2016-12},
+	langid = {english},
+	file = {van der Maaten et al. - 2016 - dendrometeR Analyzing the pulse of trees in R.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\LUEFGPTC\\van der Maaten et al. - 2016 - dendrometeR Analyzing the pulse of trees in R.pdf:application/pdf}
+}
+
+@article{suzuki_hydrological_2018,
+	title = {Hydrological Variability and Changes in the Arctic Circumpolar Tundra and the Three Largest Pan-Arctic River Basins from 2002 to 2016},
+	volume = {10},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/10/3/402},
+	doi = {10.3390/rs10030402},
+	abstract = {The Arctic freshwater budget is critical for understanding the climate in the northern regions. However, the hydrology of the Arctic circumpolar tundra region ({ACTR}) and the largest pan-Arctic rivers are still not well understood. In this paper, we analyze the spatiotemporal variations in the terrestrial water storage ({TWS}) of the {ACTR} and three of the largest pan-Arctic river basins (Lena, Mackenzie, Yukon). To do this, we utilize monthly Gravity Recovery and Climate Experiment ({GRACE}) data from 2002 to 2016. Together with global land reanalysis, and river runoff data, we identify declining {TWS} trends throughout the {ACTR} that we attribute largely to increasing evapotranspiration driven by increasing summer air temperatures. In terms of regional changes, large and signiﬁcant negative trends in {TWS} are observed mainly over the North American continent. At basin scale, we show that, in the Lena River basin, the autumnal {TWS} signal persists until the spring of the following year, while in the Mackenzie River basin, the {TWS} level in the autumn and winter has no signiﬁcant impact on the following year. As expected global warming is expected to be particularly signiﬁcant in the northern regions, our results are important for understanding future {TWS} trends, with possible further decline.},
+	pages = {402},
+	number = {3},
+	journaltitle = {Remote Sensing},
+	author = {Suzuki, Kazuyoshi and Matsuo, Koji and Yamazaki, Dai and Ichii, Kazuhito and Iijima, Yoshihiro and Papa, Fabrice and Yanagi, Yuji and Hiyama, Tetsuya},
+	urldate = {2018-04-06},
+	date = {2018-03-06},
+	langid = {english},
+	file = {Suzuki et al. - 2018 - Hydrological Variability and Changes in the Arctic.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\HNQ334P9\\Suzuki et al. - 2018 - Hydrological Variability and Changes in the Arctic.pdf:application/pdf}
+}
+
+@inproceedings{liu_combining_2010,
+	title = {Combining Tasseled Cap Transformation with Support Vector Machine to classify Landsat {TM} imagery data},
+	isbn = {978-1-4244-5958-2},
+	url = {http://ieeexplore.ieee.org/document/5582727/},
+	doi = {10.1109/ICNC.2010.5582727},
+	abstract = {Landsat represents the world's longest continuously acquired collection of space-based moderate-resolution land remote sensing data. Compared with the other earlier Landsat satellites, Landsat 8 has several new characteristics in spectral bands, spectral range and radiometric resolution. Therefore, there is a strong requirement to analyze the characteristics of the Landsat 8 for land cover classification, global change research. In this paper, Landsat 8 {OLI} image was used with Support Vector Machine ({SVM}) and Tasseled Cap Transformation ({TCT}) for land cover classification. Firstly, the Top of Atmospheric ({TOA}) reflectance based {TCT} was developed based on Landsat 8 {OLI} images. Then comparison of {ISODATA}, K-Means and {SVM} of all original 8 Landsat 8 {OLI} bands and both of {TCT} Greenness and Wetness in land cover classification was done. The present results showed that compared with using the original 8 Landsat 8 {OLI} bands, the classification results from {ISODATA} and K-Means based on both of {TCT} Greenness and Wetness had better robustness and accuracy, and the classification using {SVM} with {TCT} had better efficiency and accuracy.},
+	pages = {3570--3572},
+	publisher = {{IEEE}},
+	author = {Liu, Qingsheng and Liu, Gaohuan},
+	urldate = {2018-03-28},
+	date = {2010-08},
+	langid = {english},
+	file = {Liu and Liu - 2010 - Combining Tasseled Cap Transformation with Support.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\E8JGU7PD\\Liu and Liu - 2010 - Combining Tasseled Cap Transformation with Support.pdf:application/pdf}
+}
+
+@article{davidson_mapping_2016,
+	title = {Mapping Arctic Tundra Vegetation Communities Using Field Spectroscopy and Multispectral Satellite Data in North Alaska, {USA}},
+	volume = {8},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/8/12/978},
+	doi = {10.3390/rs8120978},
+	pages = {978},
+	number = {12},
+	journaltitle = {Remote Sensing},
+	author = {Davidson, Scott and Santos, Maria and Sloan, Victoria and Watts, Jennifer and Phoenix, Gareth and Oechel, Walter and Zona, Donatella},
+	urldate = {2018-03-28},
+	date = {2016-11-26},
+	langid = {english},
+	file = {Davidson et al. - 2016 - Mapping Arctic Tundra Vegetation Communities Using.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\U6E5F6HB\\Davidson et al. - 2016 - Mapping Arctic Tundra Vegetation Communities Using.pdf:application/pdf}
+}
+
+@article{thompson_atmospheric_2015,
+	title = {Atmospheric correction for global mapping spectroscopy: {ATREM} advances for the {HyspIRI} preparatory campaign},
+	volume = {167},
+	issn = {00344257},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0034425715000607},
+	doi = {10.1016/j.rse.2015.02.010},
+	shorttitle = {Atmospheric correction for global mapping spectroscopy},
+	abstract = {Orbital imaging spectrometers, such as the proposed Hyperspectral Infrared Imager ({HyspIRI}) mission, will provide global, multi-year Visible Shortwave Infrared ({VSWIR}) reﬂectance maps. Monitoring the Earth's surface at high spectral resolution will advance our understanding of changing ecosystems and land use. These applications depend on reliable correction of atmospheric scattering and absorption. The {HyspIRI} Preparatory Campaign is an airborne precursor mission comprised of multiple ﬂights by the “classic” Airborne Visible Infrared Imaging Spectrometer ({AVIRIS}-C) over a wide geographic area. This article describes the atmospheric correction that we have implemented for the campaign. We ﬁrst present the theoretical basis of our approach, which is grounded in the {ATmospheric} {REMoval} ({ATREM}) algorithm. We then describe new enhancements including retrieval of pressure altitude, which improves accuracy over widely varying topography, and joint retrieval of optical absorption for three phases of water (vapor, liquid, and ice), which improves accuracy over vegetated areas. Reﬂectance is validated using ground spectra acquired across a wide range of targets and elevations. Finally, we use the algorithm to map vapor, liquid, and ice phases of water over 6 months across a 14,000 km2 region of California. © 2015 Elsevier Inc. All rights reserved.},
+	pages = {64--77},
+	journaltitle = {Remote Sensing of Environment},
+	author = {Thompson, David R. and Gao, Bo-Cai and Green, Robert O. and Roberts, Dar A. and Dennison, Philip E. and Lundeen, Sarah R.},
+	urldate = {2018-03-28},
+	date = {2015-09},
+	langid = {english},
+	file = {Thompson et al. - 2015 - Atmospheric correction for global mapping spectros.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\SZUB9598\\Thompson et al. - 2015 - Atmospheric correction for global mapping spectros.pdf:application/pdf}
+}
+
+@article{robert_airborne_nodate,
+	title = {Airborne Visible/Infrared Imaging Spectrometer Next Generation ({AVIRIS}-{NG}) Data User’s Guide - India Campaign 2015},
+	pages = {13},
+	author = {Robert, Robert O Green and Lundeen, Sarah and {McCubbin}, Ian and Thompson, David R and Bue, Brian D},
+	langid = {english},
+	file = {Robert et al. - Airborne VisibleInfrared Imaging Spectrometer Nex.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\U3LZ3QMN\\Robert et al. - Airborne VisibleInfrared Imaging Spectrometer Nex.pdf:application/pdf}
+}
+
+@article{lantuit_temporal_2005,
+	title = {Temporal stereophotogrammetric analysis of retrogressive thaw slumps on Herschel Island, Yukon Territory},
+	volume = {5},
+	issn = {1684-9981},
+	url = {http://www.nat-hazards-earth-syst-sci.net/5/413/2005/},
+	doi = {10.5194/nhess-5-413-2005},
+	pages = {413--423},
+	number = {3},
+	journaltitle = {Natural Hazards and Earth System Science},
+	author = {Lantuit, H. and Pollard, W. H.},
+	urldate = {2018-03-23},
+	date = {2005-05-30},
+	langid = {english},
+	file = {Lantuit and Pollard - 2005 - Temporal stereophotogrammetric analysis of retrogr.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\U6QNUN9M\\Lantuit and Pollard - 2005 - Temporal stereophotogrammetric analysis of retrogr.pdf:application/pdf}
+}
+
+@article{weismuller_modeling_2011,
+	title = {Modeling the thermal dynamics of the active layer at two contrasting permafrost sites on Svalbard and on the Tibetan Plateau},
+	volume = {5},
+	issn = {1994-0424},
+	url = {http://www.the-cryosphere.net/5/741/2011/},
+	doi = {10.5194/tc-5-741-2011},
+	abstract = {Employing a one-dimensional, coupled thermal and hydraulic numerical model, we quantitatively analyze high-resolution, multi-year data from the active layers at two contrasting permafrost sites. The model implements heat conduction with the de Vries parameterization, heat convection with water and vapor ﬂow, freeze-thaw transition parameterized with a heuristic soil-freezing characteristic, and liquid water ﬂow with the Mualem-van Genuchten parameterization. The model is driven by measured temperatures and water contents at the upper and lower boundary with all required material properties deduced from the measured data. The aims are (i) to ascertain the applicability of such a rather simple model, (ii) to quantify the dominating processes, and (iii) to discuss possible causes of remaining deviations.},
+	pages = {741--757},
+	number = {3},
+	journaltitle = {The Cryosphere},
+	author = {Weismüller, J. and Wollschläger, U. and Boike, J. and Pan, X. and Yu, Q. and Roth, K.},
+	urldate = {2018-03-23},
+	date = {2011-09-19},
+	langid = {english},
+	file = {Weismüller et al. - 2011 - Modeling the thermal dynamics of the active layer .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\RERPBMUI\\Weismüller et al. - 2011 - Modeling the thermal dynamics of the active layer .pdf:application/pdf}
+}
+
+@collection{giosan_river_2005,
+	location = {Tulsa, Okla},
+	title = {River deltas: concepts, models, and examples},
+	isbn = {978-1-56576-113-1 978-1-56576-219-0},
+	series = {{SEPM} special publication},
+	shorttitle = {River deltas},
+	abstract = {Coastal-prism sediments record rising local water levels, forced by sea-level rise. Sea-level rise is the primary driving factor, but the anatomy of the coastal prism is a result of a complex interplay of sea level, subsidence, and upstream controls (essentially sediment load). The sedimentary architecture of a coastal prism is linked to paleo–groundwater rise. Groundwater rise is quantified for the entire Rhine–Meuse delta (extending 120 km inland, 60 km wide) between an 11.0 kyr {BP} groundwater lowstand and the present highstand, dating series of organic markers (peats) of paleo–groundwater levels at compaction-free locations. The accumulated dataset of paleo–groundwater-level markers ({\textgreater} 300 index points) has a dense spatial and temporal coverage and a predictive quality that enables geostatistical analysis. The combination of this dataset and a carefully designed interpolation method (a form of 3D kriging) reveals the interplay between upstream (climate, discharge) and downstream (sea level, tides) controls on gradients of groundwater level and patterns of groundwater rise. Regional effects due to local controls (differential subsidence, groundwater flow) are also identified.},
+	pagetotal = {502},
+	number = {83},
+	publisher = {Society for Sedimentary Geology},
+	editor = {Giosan, Liviu},
+	date = {2005},
+	langid = {english},
+	note = {{OCLC}: 255162802},
+	file = {Giosan - 2005 - River deltas concepts, models, and examples.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\SQL7BJL4\\Giosan - 2005 - River deltas concepts, models, and examples.pdf:application/pdf}
+}
+
+@article{chen_three-dimensional_2015,
+	title = {Three-Dimensional Mapping of Soil Organic Carbon by Combining Kriging Method with Profile Depth Function},
+	volume = {10},
+	issn = {1932-6203},
+	url = {https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4457849/},
+	doi = {10.1371/journal.pone.0129038},
+	abstract = {Understanding spatial variation of soil organic carbon ({SOC}) in three-dimensional direction is helpful for land use management. Due to the effect of profile depths and soil texture on vertical distribution of {SOC}, the stationary assumption for {SOC} cannot be met in the vertical direction. Therefore the three-dimensional (3D) ordinary kriging technique cannot be directly used to map the distribution of {SOC} at a regional scale. The objectives of this study were to map the 3D distribution of {SOC} at a regional scale by combining kriging method with the profile depth function of {SOC} ({KPDF}), and to explore the effects of soil texture and land use type on vertical distribution of {SOC} in a fluvial plain. A total of 605 samples were collected from 121 soil profiles (0.0 to 1.0 m, 0.20 m increment) in Quzhou County, China and {SOC} contents were determined for each soil sample. The {KPDF} method was used to obtain the 3D map of {SOC} at the county scale. The results showed that the exponential equation well described the vertical distribution of mean values of the {SOC} contents. The coefficients of determination, root mean squared error and mean prediction error between the measured and the predicted {SOC} contents were 0.52, 1.82 and -0.24 g kg-1 respectively, suggesting that the {KPDF} method could be used to produce a 3D map of {SOC} content. The surface {SOC} contents were high in the mid-west and south regions, and low values lay in the southeast corner. The {SOC} contents showed significant positive correlations between the five different depths and the correlations of {SOC} contents were larger in adjacent layers than in non-adjacent layers. Soil texture and land use type had significant effects on the spatial distribution of {SOC}. The influence of land use type was more important than that of soil texture in the surface soil, and soil texture played a more important role in influencing the {SOC} levels for 0.2-0.4 m layer.},
+	number = {6},
+	journaltitle = {{PLoS} {ONE}},
+	shortjournal = {{PLoS} One},
+	author = {Chen, Chong and Hu, Kelin and Li, Hong and Yun, Anping and Li, Baoguo},
+	urldate = {2018-03-23},
+	date = {2015-06-05},
+	pmid = {26047012},
+	pmcid = {PMC4457849},
+	file = {Chen et al. - 2015 - Three-Dimensional Mapping of Soil Organic Carbon b.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\52K9DNCY\\Chen et al. - 2015 - Three-Dimensional Mapping of Soil Organic Carbon b.pdf:application/pdf}
+}
+
+@article{gibson_estimating_1993,
+	title = {Estimating Evaporation Using Stable Isotopes: Quantitative Results and Sensitivity Analysis for Two Catchments in Northern Canada},
+	volume = {24},
+	url = {http://hr.iwaponline.com/content/24/2-3/79.abstract},
+	abstract = {The stable isotope-mass balance method can provide useful water balance information in ungauged catchments. The method has been used to evaluate evaporation and water balance at two contrasting sites in northern Canada. Areally weighted evaporative discharge from an 850 km2 tundra catchment in south-central District of Keewatin is estimated to be about 7 \% of total water discharge (≈ 16 mm/yr), compared to about 19 \% (≈ 65 mm/yr) from a 300 km2 forested watershed in the Upper Mackenzie Valley. Lakes in both watersheds exhibit broad ranges of evaporation/inflow ratios related to local water balance. The potential errors in the estimates are evaluated through consideration of possible variations in basin storage, humidity, and the isotopic composition of atmospheric vapour.},
+	pages = {79},
+	number = {2},
+	journaltitle = {Hydrology Research},
+	shortjournal = {Hydrol Res},
+	author = {Gibson, J.J. and Edwards, T.W.D. and Bursey, G.G. and Prowse, T.D.},
+	date = {1993-04-01},
+	file = {Gibson et al. - 1993 - Estimating Evaporation Using Stable Isotopes Quan.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\KALY3NJ8\\Gibson et al. - 1993 - Estimating Evaporation Using Stable Isotopes Quan.pdf:application/pdf}
+}
+
+@article{welker_arctic_2005,
+	title = {Arctic and North Atlantic Oscillation phase changes are recorded in the isotopes (delta18O and delta13C) of Cassiope tetragona plants},
+	volume = {11},
+	issn = {1354-1013, 1365-2486},
+	url = {http://doi.wiley.com/10.1111/j.1365-2486.2005.00961.x},
+	doi = {10.1111/j.1365-2486.2005.00961.x},
+	abstract = {The Arctic and North Atlantic Oscillations ({AO}/{NAO}) are large-scale annual modes of atmospheric circulation that have shifted in the last 30 years. Recent changes in arctic climate, including increasing surface air temperature, declining sea ice extent, and shifts in the amounts seasonality of precipitation are linked to the strong positive phase of the {AO}/{NAO}. Here, we show that phase changes in the {AO}/{NAO} are recorded in the isotopic (d18O and D-carbon isotope discrimination) characteristics of the long-lived circum-arctic plant, Cassiope tetragona, as summer rain has become a more important water source than snowmelt water which in turn has lead to decreases in D and reductions in plant stem growth. These isotopic records in C. tetragona may facilitate reconstructions of climate, plant–soil water relations, plant gas exchange attributes and a mechanistic understanding of growth responses to shifts in atmospheric circulation. If plant specimens were available for populations across the arctic as part of the International Polar Year, these archives could provide a circum-arctic record of historical climate change and associated shifts in physiological plant performance and growth.},
+	pages = {997--1002},
+	number = {7},
+	journaltitle = {Global Change Biology},
+	author = {Welker, Jeffrey M. and Rayback, Shelly and Henry, Greg H. R.},
+	urldate = {2018-03-23},
+	date = {2005-07},
+	langid = {english},
+	file = {Welker et al. - 2005 - Arctic and North Atlantic Oscillation phase change.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\LKCW7B34\\Welker et al. - 2005 - Arctic and North Atlantic Oscillation phase change.pdf:application/pdf}
+}
+
+@article{andreu-hayles_long_2011,
+	title = {Long tree-ring chronologies reveal 20th century increases in water-use efficiency but no enhancement of tree growth at five Iberian pine forests: {IBERIAN} {PINE} {PHYSIOLOGICAL} {AND} {GROWTH} {CHANGES}},
+	volume = {17},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/j.1365-2486.2010.02373.x},
+	doi = {10.1111/j.1365-2486.2010.02373.x},
+	shorttitle = {Long tree-ring chronologies reveal 20th century increases in water-use efficiency but no enhancement of tree growth at five Iberian pine forests},
+	abstract = {We investigated the tree growth and physiological response of ﬁve pine forest stands in relation to changes in atmospheric {CO}2 concentration (ca) and climate in the Iberian Peninsula using annually resolved width and d13C treering chronologies since {AD} 1600. 13C discrimination (D \% ci/ca), leaf intercellular {CO}2 concentration (ci) and intrinsic water-use efﬁciency ({iWUE}) were inferred from d13C values. The most pronounced changes were observed during the second half of the 20th century, and differed between stands. Three sites kept a constant ci/ca ratio, leading to signiﬁcant ci and {iWUE} increases (active response to ca); whereas a signiﬁcant increase in ci/ca resulted in the lowest {iWUE} increase of all stands at a relict Pinus uncinata forest site (passive response to ca). A signiﬁcant decrease in ci/ca led to the greatest {iWUE} improvement at the northwestern site. We tested the climatic signal strength registered in the d13C series after removing the low-frequency trends due to the physiological responses to increasing ca. We found stronger correlations with temperature during the growing season, demonstrating that the physiological response to ca changes modulated d13C and masked the climate signal. Since 1970 higher d13C values revealed {iWUE} improvements at all the sites exceeding values expected by an active response to the ca increase alone. These patterns were related to upward trends in temperatures, indicating that other factors are reinforcing stomatal closure in these forests. Narrower rings during the second half of the 20th century than in previous centuries were observed at four sites and after 1970 at all sites, providing no evidence for a possible {CO}2 ‘fertilization’ effect on growth. The {iWUE} improvements found for all the forests, reﬂecting both a ca rise and warmer conditions, seem to be insufﬁcient to compensate for the negative effects of the increasing water limitation on growth.},
+	pages = {2095--2112},
+	number = {6},
+	journaltitle = {Global Change Biology},
+	author = {Andreu-Hayles, Laia and Planells, Octavi and {GutiéRrez}, Emilia and Muntan, Elena and Helle, Gerhard and Anchukaitis, Kevin J. and Schleser, Gerhard H.},
+	urldate = {2018-03-23},
+	date = {2011-06},
+	langid = {english},
+	file = {Andreu-Hayles et al. - 2011 - Long tree-ring chronologies reveal 20th century in.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\H4GW7466\\Andreu-Hayles et al. - 2011 - Long tree-ring chronologies reveal 20th century in.pdf:application/pdf}
+}
+
+@article{santruckova_carbon_2007,
+	title = {Carbon Isotopes in Tree Rings of Norway Spruce Exposed to Atmospheric Pollution},
+	volume = {41},
+	issn = {0013-936X, 1520-5851},
+	url = {http://pubs.acs.org/doi/abs/10.1021/es070011t},
+	doi = {10.1021/es070011t},
+	pages = {5778--5782},
+	number = {16},
+	journaltitle = {Environmental Science \& Technology},
+	author = {Šantr˚učková, Hana and Šantr˚uček, Jiří and Šetlík, Jiří and Svoboda, Miroslav and Kopáček, Jiří},
+	urldate = {2018-03-23},
+	date = {2007-08},
+	langid = {english},
+	file = {Šantr˚učková et al. - 2007 - Carbon Isotopes in Tree Rings of Norway Spruce Exp.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\XV22547M\\Šantr˚učková et al. - 2007 - Carbon Isotopes in Tree Rings of Norway Spruce Exp.pdf:application/pdf}
+}
+
+@article{roy-leveillee_permafrost_nodate,
+	title = {Permafrost conditions near shorelines of oriented lakes in Old Crow Flats, Yukon Territory},
+	abstract = {Old Crow Flats is a 4300 km2 plain in the continuous permafrost of Northern Yukon. It contains over 2500 thermokarst lakes, many of which have rectilinear shorelines and tend to be oriented either {NE}-{SW} or {NW}-{SE}. Previous explanations of the shape and orientation of the lakes focussed on the underlying geological structure and the propagation of faults through the sediments to cause the alignment of the lakeshores. Permafrost conditions and shore erosion mechanisms observed at forested and tundra sites suggest that wind and patterns of ice-wedge development may be contributing to the occurrence of rectilinear shorelines in the open tundra of Old Crow Flats.},
+	pages = {8},
+	author = {Roy-Léveillée, P and Burn, C R},
+	file = {Roy-Léveillée and Burn - Permafrost conditions near shorelines of oriented .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\F47TUKRZ\\Roy-Léveillée and Burn - Permafrost conditions near shorelines of oriented .pdf:application/pdf}
+}
+
+@book{roots_ecoregions_2006,
+	location = {Summerland, B.C.},
+	title = {Ecoregions of the Yukon Territory: biophysical properties of Yukon landscapes},
+	isbn = {978-0-660-18828-7},
+	shorttitle = {Ecoregions of the Yukon Territory},
+	publisher = {Agriculture and Agri-Food Canada, Research Branch},
+	author = {Roots, Charles Frederick and Smith, C. A. Scott and Meikle, J. C and {Canada} and {Agriculture and Agri-Food Canada}},
+	date = {2006},
+	note = {{OCLC}: 1015906693},
+	file = {Roots et al. - 2006 - Ecoregions of the Yukon Territory biophysical pro.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\NL2CMXQC\\Roots et al. - 2006 - Ecoregions of the Yukon Territory biophysical pro.pdf:application/pdf}
+}
+
+@article{brock_spatial_2008,
+	title = {Spatial and temporal perspectives on spring break-up flooding in the Slave River Delta, {NWT}},
+	volume = {22},
+	issn = {08856087, 10991085},
+	url = {http://doi.wiley.com/10.1002/hyp.7008},
+	doi = {10.1002/hyp.7008},
+	abstract = {Spatial and temporal patterns of spring break-up ﬂooding in the Slave River Delta ({SRD}), Northwest Territories, are characterized during three years (2003–2005) using water isotope tracers and total inorganic suspended sediment ({TSS}) concentrations measured from lakewater samples collected shortly after the spring melt. Strongly contrasting spring melt periods led to a moderate ﬂood in 2003, no ﬂooding in 2004 and widespread ﬂooding in 2005. Flooded lakes have isotopically-depleted υ18O (υ2H) signatures, ranging between 19Ð2‰ ( 145‰) and 17Ð1‰ ( 146‰) and most have high {TSS} concentrations ({\textgreater}10 mg L 1), while non-ﬂooded lakes have more isotopically-enriched υ18O (υ2H) signatures, ranging between 18Ð2‰ ( 149‰) and 10Ð6‰ ( 118‰) and low {TSS} concentrations ({\textless}10 mg L 1). These results, in conjunction with the isotopic signatures of Slave River water and snowmelt, are used to estimate the proportion of river- or snowmelt-induced dilution in delta lakes during the spring of each study year. Calculations indicate river ﬂooding caused dilution of ¾70–100\% in delta lakes, while snowmelt dilution in the absence of river ﬂooding ranged from ¾0–56\%. A positive relationship exists between the spatial extent of spring ﬂooding in the {SRD} and level and discharge on the Slave River and upstream tributaries, suggesting that upstream ﬂow generation plays a key role in determining the magnitude of spring ﬂooding in the {SRD}. Parallel variations in the 46-year instrumental Slave River discharge record and ﬂood stratigraphy in the active delta indicate that there is potential for extending the ﬂood history of the {SRD}, a development that will contribute to a more robust understanding of the drivers of historic, contemporary and future ﬂood frequency in the delta. Copyright  2008 John Wiley \& Sons, Ltd.},
+	pages = {4058--4072},
+	number = {20},
+	journaltitle = {Hydrological Processes},
+	author = {Brock, B. E. and Wolfe, B. B. and Edwards, T. W. D.},
+	urldate = {2018-03-16},
+	date = {2008-09-30},
+	langid = {english},
+	file = {Brock et al. - 2008 - Spatial and temporal perspectives on spring break-.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\TXAM7JBF\\Brock et al. - 2008 - Spatial and temporal perspectives on spring break-.pdf:application/pdf}
+}
+
+@article{tondu_using_2013,
+	title = {Using Water Isotope Tracers to Develop the Hydrological Component of a Long-Term Aquatic Ecosystem Monitoring Program for a Northern Lake-Rich Landscape},
+	volume = {45},
+	issn = {1523-0430, 1938-4246},
+	url = {http://www.bioone.org/doi/abs/10.1657/1938-4246-45.4.594},
+	doi = {10.1657/1938-4246-45.4.594},
+	abstract = {Arctic lake-rich landscapes are vulnerable to climate change, but their remote locations present a challenge to develop effective approaches for monitoring hydroecological status and trends. Here, we structure the hydrological component of an aquatic ecosystem monitoring program that addresses concerns of Parks Canada (Vuntut National Park) and the Vuntut Gwitchin First Nation about changing water levels of Old Crow Flats ({OCF}), Yukon, Canada, a 5600-km2 thermokarst landscape recognized nationally and internationally for its ecological, historical, and cultural significance. The foundation of the monitoring program is 5 years (2007–2011) of water isotope data from 14 lakes situated in catchments that are representative of the land-cover and hydrological diversity of {OCF}. Isotopic compositions of input water (␦I) and evaporation-to-inflow (E/I) ratios, calculated using the coupled-isotope tracer method, provide key hydrological metrics for each lake over the 5-year sampling interval. From these time series, we identify monitoring lakes that are sensitive to changes in snowmelt, rainfall, and evaporation, and demonstrate the use of the Mann-Kendall test for determining statistically significant trends in the roles of these hydrological processes on lake-water balances. These approaches will serve to identify lake hydrological responses to climate change and variability from ongoing water isotope monitoring by Parks Canada, in partnership with the Vuntut Gwitchin Government, Wilfrid Laurier University, and the University of Waterloo.},
+	pages = {594--614},
+	number = {4},
+	journaltitle = {Arctic, Antarctic, and Alpine Research},
+	author = {Tondu, J. M. E. and Turner, K. W. and Wolfe, B. B. and Hall, R. I. and Edwards, T. W. D. and {McDonald}, I.},
+	urldate = {2018-03-14},
+	date = {2013-11},
+	langid = {english},
+	file = {Tondu et al. - 2013 - Using Water Isotope Tracers to Develop the Hydrolo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\C3JYWJGC\\Tondu et al. - 2013 - Using Water Isotope Tracers to Develop the Hydrolo.pdf:application/pdf}
+}
+
+@thesis{hughes_detecting_2018,
+	location = {St. Catharines},
+	title = {Detecting spatial variation in hydrology and carbon export across a lake-rich permafrost landscape, Old Crow Flats, Yukon, Canada},
+	rights = {2018 Daniel Hughes},
+	abstract = {Lake-rich permafrost landscapes are widespread across northern regions and provide refuge for abundant wildlife and resources for local communities. Evidence suggests that these landscapes are highly sensitive to changes in climate. The traditional territory of the Vuntut Gwitchin First Nation, Old Crow Flats ({OCF}), {YK}, is a vast 5600-km2 lake-rich landscape that is internationally recognized for its ecological and cultural integrity. Pronounced changes in lake and river water levels and land cover compositions have been observed during recent decades by local community members and in scientific studies. Research presented here focuses on enhancing our understanding of spatial patterns in hydrology and carbon export across {OCF}, using a suite of water chemistry parameters, carbon concentrations and water and carbon isotope tracers. The spatial patterns detected are providing an important reference for ongoing investigations of how
+changing climate and lake-rich landscapes are influencing water and carbon balances.},
+	pagetotal = {116},
+	institution = {Brock University},
+	type = {phdthesis},
+	author = {Hughes, Daniel D.},
+	editora = {Turner, Kevin W.},
+	editoratype = {collaborator},
+	date = {2018-03},
+	file = {Hughes - 2018 - Detecting spatial variation in hydrology and carbo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\C6IGSVPE\\Hughes - 2018 - Detecting spatial variation in hydrology and carbo.pdf:application/pdf}
+}
+
+@article{turner_characterising_2014,
+	title = {Characterising Runoff Generation Processes in a Lake-Rich Thermokarst Landscape (Old Crow Flats, Yukon, Canada) using δ $^{\textrm{18}}$ O, δ $^{\textrm{2}}$ H and d-excess Measurements: Characterising Runoff with Water Isotope Tracers in Old Crow Flats, Yukon},
+	volume = {25},
+	issn = {10456740},
+	url = {http://doi.wiley.com/10.1002/ppp.1802},
+	doi = {10.1002/ppp.1802},
+	shorttitle = {Characterising Runoff Generation Processes in a Lake-Rich Thermokarst Landscape (Old Crow Flats, Yukon, Canada) using δ $^{\textrm{18}}$ O, δ $^{\textrm{2}}$ H and d-excess Measurements},
+	pages = {53--59},
+	number = {1},
+	journaltitle = {Permafrost and Periglacial Processes},
+	author = {Turner, Kevin W. and Edwards, Thomas W. D. and Wolfe, Brent B.},
+	urldate = {2018-03-07},
+	date = {2014-01},
+	langid = {english},
+	file = {Turner et al. - 2014 - Characterising Runoff Generation Processes in a La.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\277B3VGI\\Turner et al. - 2014 - Characterising Runoff Generation Processes in a La.pdf:application/pdf}
+}
+
+@article{bouchard_paleolimnology_2017,
+	title = {Paleolimnology of thermokarst lakes: a window into permafrost landscape evolution},
+	volume = {3},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2016-0022},
+	doi = {10.1139/as-2016-0022},
+	shorttitle = {Paleolimnology of thermokarst lakes},
+	pages = {91--117},
+	number = {2},
+	journaltitle = {Arctic Science},
+	author = {Bouchard, Frédéric and {MacDonald}, Lauren A. and Turner, Kevin W. and Thienpont, Joshua R. and Medeiros, Andrew S. and Biskaborn, Boris K. and Korosi, Jennifer and Hall, Roland I. and Pienitz, Reinhard and Wolfe, Brent B.},
+	urldate = {2018-03-07},
+	date = {2017-06},
+	langid = {english},
+	file = {Bouchard et al. - 2017 - Paleolimnology of thermokarst lakes a window into.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\RNIVRCN4\\Bouchard et al. - 2017 - Paleolimnology of thermokarst lakes a window into.pdf:application/pdf}
+}
+
+@article{tondu_limnological_2017,
+	title = {Limnological evolution of Zelma Lake, a recently drained thermokarst lake in Old Crow Flats (Yukon, Canada)},
+	volume = {3},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2016-0012},
+	doi = {10.1139/as-2016-0012},
+	pages = {220--236},
+	number = {2},
+	journaltitle = {Arctic Science},
+	author = {Tondu, Jana M.E. and Turner, Kevin W. and Wiklund, Johan A. and Wolfe, Brent B. and Hall, Roland I. and {McDonald}, Ian},
+	urldate = {2018-03-07},
+	date = {2017-06},
+	langid = {english},
+	file = {Tondu et al. - 2017 - Limnological evolution of Zelma Lake, a recently d.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\9WQHG3HI\\Tondu et al. - 2017 - Limnological evolution of Zelma Lake, a recently d.pdf:application/pdf}
+}
+
+@article{fabre_using_2017,
+	title = {Using Modeling Tools to Better Understand Permafrost Hydrology},
+	volume = {9},
+	issn = {2073-4441},
+	url = {http://www.mdpi.com/2073-4441/9/6/418},
+	doi = {10.3390/w9060418},
+	pages = {418},
+	number = {12},
+	journaltitle = {Water},
+	author = {Fabre, Clément and Sauvage, Sabine and Tananaev, Nikita and Srinivasan, Raghavan and Teisserenc, Roman and Sánchez Pérez, José},
+	urldate = {2018-02-22},
+	date = {2017-06-10},
+	langid = {english},
+	file = {Fabre et al. - 2017 - Using Modeling Tools to Better Understand Permafro.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\HMRLJQCM\\Fabre et al. - 2017 - Using Modeling Tools to Better Understand Permafro.pdf:application/pdf}
+}
+
+@article{watts_unmanned_2012,
+	title = {Unmanned Aircraft Systems in Remote Sensing and Scientific Research: Classification and Considerations of Use},
+	volume = {4},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/4/6/1671},
+	doi = {10.3390/rs4061671},
+	shorttitle = {Unmanned Aircraft Systems in Remote Sensing and Scientific Research},
+	pages = {1671--1692},
+	number = {12},
+	journaltitle = {Remote Sensing},
+	author = {Watts, Adam C. and Ambrosia, Vincent G. and Hinkley, Everett A.},
+	urldate = {2018-02-01},
+	date = {2012-06-08},
+	langid = {english},
+	file = {Watts et al. - 2012 - Unmanned Aircraft Systems in Remote Sensing and Sc.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\XPPNT6PV\\Watts et al. - 2012 - Unmanned Aircraft Systems in Remote Sensing and Sc.pdf:application/pdf}
+}
+
+@article{schuur_vulnerability_2008,
+	title = {Vulnerability of permafrost carbon to climate change: Implications for the global carbon cycle},
+	volume = {58},
+	doi = {https://doi.org/10.1641/B580807},
+	shorttitle = {Vulnerability of permafrost carbon to climate change},
+	pages = {701--714},
+	number = {8},
+	journaltitle = {{AIBS} Bulletin},
+	author = {Schuur, Edward {AG} and Bockheim, James and Canadell, Josep G. and Euskirchen, Eugenie and Field, Christopher B. and Goryachkin, Sergey V. and Hagemann, Stefan and Kuhry, Peter and Lafleur, Peter M. and Lee, Hanna},
+	date = {2008},
+	file = {Schuur et al. - 2008 - Vulnerability of permafrost carbon to climate chan.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\RE2HU2NG\\Schuur et al. - 2008 - Vulnerability of permafrost carbon to climate chan.pdf:application/pdf}
+}
+
+@article{chenot_substrate_2017,
+	title = {Substrate Composition and Depth Affect Soil Moisture Behavior and Plant-Soil Relationship on Mediterranean Extensive Green Roofs},
+	volume = {9},
+	issn = {2073-4441},
+	url = {http://www.mdpi.com/2073-4441/9/11/817},
+	doi = {10.3390/w9110817},
+	pages = {817},
+	number = {11},
+	journaltitle = {Water},
+	author = {Chenot, Julie and Gaget, Elie and Moinardeau, Cannelle and Jaunatre, Renaud and Buisson, Elise and Dutoit, Thierry},
+	urldate = {2018-01-29},
+	date = {2017-10-25},
+	langid = {english},
+	file = {Chenot et al. - 2017 - Substrate Composition and Depth Affect Soil Moistu.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\82CYQTEA\\Chenot et al. - 2017 - Substrate Composition and Depth Affect Soil Moistu.pdf:application/pdf}
+}
+
+@article{gevaert_classification_2016,
+	title = {Classification of informal settlements through the integration of 2D and 3D features extracted from {UAV} data},
+	volume = {{III}-3},
+	issn = {2194-9050},
+	url = {http://www.isprs-ann-photogramm-remote-sens-spatial-inf-sci.net/III-3/317/2016/},
+	doi = {10.5194/isprs-annals-III-3-317-2016},
+	pages = {317--324},
+	journaltitle = {{ISPRS} Annals of Photogrammetry, Remote Sensing and Spatial Information Sciences},
+	author = {Gevaert, C. M. and Persello, C. and Sliuzas, R. and Vosselman, G.},
+	urldate = {2018-01-25},
+	date = {2016-06-06},
+	langid = {english},
+	file = {Gevaert et al. - 2016 - Classification of informal settlements through the.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\EUBADFJI\\Gevaert et al. - 2016 - Classification of informal settlements through the.pdf:application/pdf}
+}
+
+@article{strecha_developing_2012,
+	title = {Developing species specific vegetation maps using multi-spectral hyperspatial imagery from unmanned aerial vehicles},
+	volume = {3},
+	pages = {311--316},
+	journaltitle = {{ISPRS} Annals of the Photogrammetry, Remote Sensing and Spatial Information Sciences},
+	author = {Strecha, Christoph and Fletcher, Andrew and Lechner, Alex and Erskine, Peter and Fua, Pascal},
+	date = {2012},
+	file = {Strecha et al. - 2012 - Developing species specific vegetation maps using .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\73HGX3PY\\Strecha et al. - 2012 - Developing species specific vegetation maps using .pdf:application/pdf}
+}
+
+@article{schuh_soil_2017,
+	title = {Soil moisture redistribution and its effect on inter-annual active layer temperature and thickness variations in a dry loess terrace in Adventdalen, Svalbard},
+	volume = {11},
+	issn = {1994-0424},
+	url = {https://www.the-cryosphere.net/11/635/2017/},
+	doi = {10.5194/tc-11-635-2017},
+	pages = {635--651},
+	number = {1},
+	journaltitle = {The Cryosphere},
+	author = {Schuh, Carina and Frampton, Andrew and Christiansen, Hanne Hvidtfeldt},
+	urldate = {2018-01-25},
+	date = {2017-02-28},
+	langid = {english},
+	file = {Schuh et al. - 2017 - Soil moisture redistribution and its effect on int.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\DVIHARFQ\\Schuh et al. - 2017 - Soil moisture redistribution and its effect on int.pdf:application/pdf}
+}
+
+@article{minsley_sensitivity_2015,
+	title = {Sensitivity of airborne geophysical data to sublacustrine and near-surface permafrost thaw},
+	volume = {9},
+	issn = {1994-0424},
+	url = {http://www.the-cryosphere.net/9/781/2015/},
+	doi = {10.5194/tc-9-781-2015},
+	pages = {781--794},
+	number = {2},
+	journaltitle = {The Cryosphere},
+	author = {Minsley, B. J. and Wellman, T. P. and Walvoord, M. A. and Revil, A.},
+	urldate = {2018-01-24},
+	date = {2015-04-27},
+	langid = {english},
+	file = {Minsley et al. - 2015 - Sensitivity of airborne geophysical data to sublac.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\NRKLDFHM\\Minsley et al. - 2015 - Sensitivity of airborne geophysical data to sublac.pdf:application/pdf}
+}
+
+@article{kass_situ_2017,
+	title = {In situ nuclear magnetic resonance response of permafrost and active layer soil in boreal and tundra ecosystems},
+	volume = {11},
+	issn = {1994-0424},
+	url = {https://www.the-cryosphere.net/11/2943/2017/},
+	doi = {10.5194/tc-11-2943-2017},
+	pages = {2943--2955},
+	number = {6},
+	journaltitle = {The Cryosphere},
+	author = {Kass, M. Andy and Irons, Trevor P. and Minsley, Burke J. and Pastick, Neal J. and Brown, Dana R. N. and Wylie, Bruce K.},
+	urldate = {2018-01-24},
+	date = {2017-12-14},
+	langid = {english},
+	file = {Kass et al. - 2017 - In situ nuclear magnetic resonance response of per.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\73SJ7YKA\\Kass et al. - 2017 - In situ nuclear magnetic resonance response of per.pdf:application/pdf}
+}
+
+@article{walvoord_influence_2012,
+	title = {Influence of permafrost distribution on groundwater flow in the context of climate-driven permafrost thaw: Example from Yukon Flats Basin, Alaska, United States: {PERMAFROST} {DISTRIBUTION} {AND} {GROUNDWATER} {FLOW}},
+	volume = {48},
+	issn = {00431397},
+	url = {http://doi.wiley.com/10.1029/2011WR011595},
+	doi = {10.1029/2011WR011595},
+	shorttitle = {Influence of permafrost distribution on groundwater flow in the context of climate-driven permafrost thaw},
+	number = {7},
+	journaltitle = {Water Resources Research},
+	author = {Walvoord, Michelle A. and Voss, Clifford I. and Wellman, Tristan P.},
+	urldate = {2018-01-24},
+	date = {2012-07},
+	langid = {english},
+	file = {Walvoord et al. - 2012 - Influence of permafrost distribution on groundwate.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\528PXEWI\\Walvoord et al. - 2012 - Influence of permafrost distribution on groundwate.pdf:application/pdf}
+}
+
+@article{vonk_high_2013,
+	title = {High biolability of ancient permafrost carbon upon thaw: {BIOLABILITY} {OF} {ANCIENT} {PERMAFROST} {CARBON}},
+	volume = {40},
+	issn = {00948276},
+	url = {http://doi.wiley.com/10.1002/grl.50348},
+	doi = {10.1002/grl.50348},
+	shorttitle = {High biolability of ancient permafrost carbon upon thaw},
+	pages = {2689--2693},
+	number = {11},
+	journaltitle = {Geophysical Research Letters},
+	author = {Vonk, Jorien E. and Mann, Paul J. and Davydov, Sergey and Davydova, Anna and Spencer, Robert G. M. and Schade, John and Sobczak, William V. and Zimov, Nikita and Zimov, Sergei and Bulygina, Ekaterina and Eglinton, Timothy I. and Holmes, Robert M.},
+	urldate = {2018-01-24},
+	date = {2013-06-16},
+	langid = {english},
+	file = {Vonk et al. - 2013 - High biolability of ancient permafrost carbon upon.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\WVV4DVTG\\Vonk et al. - 2013 - High biolability of ancient permafrost carbon upon.pdf:application/pdf}
+}
+
+@article{striegl_decrease_2005,
+	title = {A decrease in discharge-normalized {DOC} export by the Yukon River during summer through autumn},
+	volume = {32},
+	issn = {0094-8276},
+	url = {http://doi.wiley.com/10.1029/2005GL024413},
+	doi = {10.1029/2005GL024413},
+	number = {21},
+	journaltitle = {Geophysical Research Letters},
+	author = {Striegl, Robert G. and Aiken, George R. and Dornblaser, Mark M. and Raymond, Peter A. and Wickland, Kimberly P.},
+	urldate = {2018-01-24},
+	date = {2005},
+	langid = {english},
+	file = {Striegl et al. - 2005 - A decrease in discharge-normalized DOC export by t.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\Y9FY79WV\\Striegl et al. - 2005 - A decrease in discharge-normalized DOC export by t.pdf:application/pdf}
+}
+
+@article{khedri_estimating_2017,
+	title = {Estimating soil moisture using {POLSAR} data: a machine learning approach},
+	volume = {{XLII}-4/W4},
+	issn = {2194-9034},
+	url = {https://www.int-arch-photogramm-remote-sens-spatial-inf-sci.net/XLII-4-W4/133/2017/},
+	doi = {10.5194/isprs-archives-XLII-4-W4-133-2017},
+	shorttitle = {{ESTIMATING} {SOIL} {MOISTURE} {USING} {POLSAR} {DATA}},
+	pages = {133--137},
+	journaltitle = {{ISPRS} - International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences},
+	author = {Khedri, E. and Hasanlou, M. and Tabatabaeenejad, A.},
+	urldate = {2018-01-23},
+	date = {2017-09-26},
+	langid = {english},
+	file = {Khedri et al. - 2017 - Estimating soil moisture using POLSAR data a mach.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\LGWFBNJS\\Khedri et al. - 2017 - Estimating soil moisture using POLSAR data a mach.pdf:application/pdf}
+}
+
+@article{olefeldt_circumpolar_2016,
+	title = {Circumpolar distribution and carbon storage of thermokarst landscapes},
+	volume = {7},
+	issn = {2041-1723},
+	url = {http://www.nature.com/doifinder/10.1038/ncomms13043},
+	doi = {10.1038/ncomms13043},
+	pages = {13043},
+	journaltitle = {Nature Communications},
+	author = {Olefeldt, D. and Goswami, S. and Grosse, G. and Hayes, D. and Hugelius, G. and Kuhry, P. and {McGuire}, A. D. and Romanovsky, V. E. and Sannel, A.B.K. and Schuur, E.A.G. and Turetsky, M. R.},
+	urldate = {2018-01-23},
+	date = {2016-10-11},
+	file = {Olefeldt et al. - 2016 - Circumpolar distribution and carbon storage of the.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\SWZ2MFY7\\Olefeldt et al. - 2016 - Circumpolar distribution and carbon storage of the.pdf:application/pdf}
+}
+
+@article{bourgeau-chavez_development_2010,
+	title = {Development of calibration algorithms for selected water content reflectometry probes for burned and non-burned organic soils of Alaska},
+	volume = {19},
+	issn = {1049-8001},
+	url = {http://www.publish.csiro.au/?paper=WF07175},
+	doi = {10.1071/WF07175},
+	pages = {961},
+	number = {7},
+	journaltitle = {International Journal of Wildland Fire},
+	author = {Bourgeau-Chavez, Laura L. and Garwood, Gordon C. and Riordan, Kevin and Koziol, Benjamin W. and Slawski, James},
+	urldate = {2018-01-10},
+	date = {2010},
+	langid = {english},
+	file = {Bourgeau-Chavez et al. - 2010 - Development of calibration algorithms for selected.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\QTKBP7QQ\\Bourgeau-Chavez et al. - 2010 - Development of calibration algorithms for selected.pdf:application/pdf}
+}
+
+@inproceedings{whitcomb_method_2016,
+	title = {Method for upscaling in-situ soil moisture measurements for calibration and validation of smap soil moisture products},
+	isbn = {978-1-5090-3332-4},
+	url = {http://ieeexplore.ieee.org/document/7729419/},
+	doi = {10.1109/IGARSS.2016.7729419},
+	pages = {1641--1644},
+	publisher = {{IEEE}},
+	author = {Whitcomb, J. and Clewley, D. and Akbar, R. and Silva, A. and Berg, A. and Adams, J. and Moghaddam, M.},
+	editor = {{Uknown}},
+	urldate = {2018-01-05},
+	date = {2016-07}
+}
+
+@article{clewley_method_2017,
+	title = {A Method for Upscaling In Situ Soil Moisture Measurements to Satellite Footprint Scale Using Random Forests},
+	volume = {10},
+	issn = {1939-1404, 2151-1535},
+	url = {http://ieeexplore.ieee.org/document/7907192/},
+	doi = {10.1109/JSTARS.2017.2690220},
+	pages = {2663--2673},
+	number = {6},
+	journaltitle = {{IEEE} Journal of Selected Topics in Applied Earth Observations and Remote Sensing},
+	author = {Clewley, Daniel and Whitcomb, Jane B. and Akbar, Ruzbeh and Silva, Agnelo R. and Berg, Aaron and Adams, Justin R. and Caldwell, Todd and Entekhabi, Dara and Moghaddam, Mahta},
+	urldate = {2018-01-05},
+	date = {2017-06}
+}
+
+@article{street_what_2007,
+	title = {What is the relationship between changes in canopy leaf area and changes in photosynthetic {CO}2 flux in arctic ecosystems?},
+	volume = {95},
+	issn = {1365-2745},
+	url = {http://onlinelibrary.wiley.com/doi/10.1111/j.1365-2745.2006.01187.x/abstract},
+	doi = {10.1111/j.1365-2745.2006.01187.x},
+	abstract = {* 1The arctic environment is highly heterogeneous in terms of plant distribution and productivity. If we are to make regional scale predictions of carbon exchange it is necessary to find robust relationships that can simplify this variability. One such potential relationship is that of leaf area to photosynthetic {CO}2 flux at the canopy scale.
+* 2In this paper we assess the effectiveness of canopy leaf area in explaining variation in gross primary productivity ({GPP}): (i) across different vegetation types; (ii) at various stages of leaf development; and (iii) under enhanced nutrient availability. To do this we measure net {CO}2 flux light response curves with a 1 × 1 m chamber, and calculate {GPP} at a photosynthetic photon flux density ({PPFD}) of 600 µmol m−2 s−1.
+* 3At a subarctic site in Sweden, we report 10-fold variation in {GPP} among natural vegetation types with leaf area index ({LAI}) values of 0.05–2.31 m2 m−2. At a site of similar latitude in Alaska we document substantially elevated rates of {GPP} in fertilized vegetation.
+* 4We can explain 80\% of the observed variation in {GPP} in natural vegetation (including vegetation measured before deciduous leaf bud burst) by leaf area alone, when leaf area is predicted from measurements of normalized difference vegetation index ({NDVI}).
+* 5In fertilized vegetation the relative increase in leaf area between control and fertilized treatments exceeds the relative increase in {GPP}. This suggests that higher leaf area causes increased self-shading, or that lower leaf nitrogen per unit leaf area causes a reduction in the rate of photosynthesis.
+* 6The results of this study indicate that canopy leaf area is an excellent predictor of {GPP} in diverse low arctic tundra, across a wide range of plant functional types.},
+	pages = {139--150},
+	number = {1},
+	journaltitle = {Journal of Ecology},
+	author = {Street, L. E. and Shaver, G. R. and Williams, M. and Van Wijk, M. T.},
+	urldate = {2018-01-04},
+	date = {2007-01-01},
+	langid = {english},
+	keywords = {Alaska, Arctic tundra, carbon balance, {CO}2 flux, gross primary productivity, landscape heterogeneity, leaf area index, light response, normalized difference vegetation index, Sweden},
+	file = {Street et al. - 2007 - What is the relationship between changes in canopy.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4TA5BNA3\\Street et al. - 2007 - What is the relationship between changes in canopy.pdf:application/pdf}
+}
+
+@article{von_fischer_vegetation_2010,
+	title = {Vegetation height and other controls of spatial variability in methane emissions from the Arctic coastal tundra at Barrow, Alaska},
+	volume = {115},
+	issn = {2156-2202},
+	url = {http://onlinelibrary.wiley.com/doi/10.1029/2009JG001283/abstract},
+	doi = {10.1029/2009JG001283},
+	abstract = {We conducted measurements of methane ({CH}4) emission and ecosystem respiration on {\textgreater}200 points across the Arctic coastal tundra near Barrow, Alaska, United States, in July 2007 and August 2008. This site contains broad diversity in tundra microtopography, including polygonal tundra, thaw lakes, and drained lake basins. In 2007, we surveyed {CH}4 emissions across this landscape, and found that soil water content was the strongest control of methane emission rate, such that emission rates rose exponentially with water content. However, there was considerable residual variation in {CH}4 emission in the wettest soils ({\textgreater}80\% volumetric water content) where {CH}4 emissions were highest. A statistical analysis of possible soil and plant controls on {CH}4 emission rates from these wet soils revealed that vegetation height (especially of Carex aquatilis) was the best predictor, with ecosystem respiration and permafrost depth as significant copredictors. To evaluate whether plant height served as a proxy for aboveground plant biomass, or gross primary production, we conducted a survey of {CH}4 emission rates from wet, Carex-dominated sites in 2008, coincidently measuring these candidate predictors. Surprisingly, vegetation height remained the best predictor of {CH}4 emission rates, with {CH}4 emissions rising exponentially with vegetation height. We hypothesize that taller plants have more extensive root systems that both stimulate more methanogenesis and conduct more pore water {CH}4 to the atmosphere. We anticipate that the magnitude of the climate change–{CH}4 feedback in the Arctic Coastal Plain will strongly depend on how permafrost thaw alters the ecology of Carex aquatilis.},
+	pages = {G00I03},
+	issue = {G4},
+	journaltitle = {Journal of Geophysical Research: Biogeosciences},
+	shortjournal = {J. Geophys. Res.},
+	author = {von Fischer, Joseph C. and Rhew, Robert C. and Ames, Gregory M. and Fosdick, Bailey K. and von Fischer, Paul E.},
+	urldate = {2018-01-04},
+	date = {2010-12-01},
+	langid = {english},
+	keywords = {0404 Anoxic and hypoxic environments, 0428 Carbon cycling, 0476 Plant ecology, 0490 Trace gases, 0497 Wetlands, Carex aquatilis, methane, tundra},
+	file = {Snapshot:C\:\\Users\\Brent Thorne\\Zotero\\storage\\L22276TK\\abstract.html:text/html;von Fischer et al. - 2010 - Vegetation height and other controls of spatial va.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\2J374FDT\\von Fischer et al. - 2010 - Vegetation height and other controls of spatial va.pdf:application/pdf}
+}
+
+@article{delworth_influence_1988,
+	title = {The Influence of Potential Evaporation on the Variabilities of Simulated Soil Wetness and Climate},
+	volume = {1},
+	url = {http://journals.ametsoc.org/doi/abs/10.1175/1520-0442%281988%29001%3C0523%3ATIOPEO%3E2.0.CO%3B2},
+	doi = {10.1175/1520-0442(1988)001<0523:TIOPEO>2.0.CO;2},
+	abstract = {Abstract An atmospheric general circulation model with prescribed sea surface temperature and cloudiness was integrated for 50 years in order to study atmosphere-land surface interactions. The temporal variability of model soil moisture and precipitation have been studied in an effort to understand the interactions of these variables with other components of the climate system. Temporal variability analysis has shown that the spectra of monthly mean precipitation over land are close to white at all latitudes, with total variance decreasing poleward. In contrasts, the spectra of soil moisture are red, and become more red with increasing latitude. As a measure of this redness, half of the total variance of a composite tropical soil moisture spectrum occurs at periods longer than nine months, while at high latitudes, half of the total variance of a composite soil moisture spectrum occurs at periods longer than 22 months. The spectra of soil moisture also exhibit marked longitudinal variations. These spectral results may be viewed in the light of stochastic theory. The formulation of the {GFDL} soil moisture parameterization is mathematically similar to a stochastic process. According to this model, forcing of a system by an input white noise variable (precipitation) will yield an output variable (soil moisture) with a red spectrum, the redness of which is controlled by a damping term (potential evaporation). Thus, the increasingly red nature of the soil moisture spectra at higher latitudes is a result of declining potential evaporation values at higher latitudes. Physically, soil moisture excesses are dissipated more slowly at high latitudes where the energy available for evaporation is small. Some of the longitudinal variations in soil moisture spectra result from longitudinal variations in potential evaporation, while others are explicable in terms of the value of the ratio of potential evaporation to precipitation. Regions where this value is less than one are characterized by frequent runoff and short time scales of soil moisture variability. By preventing excessive positive anomalies of soil moisture, the runoff process hastens the return of soil moisture values to their mean state, thereby shortening soil moisture time scales. Through the use of a second {GCM} integration with prescribed soil moisture, it was shown that interactive sod moisture may substantially increase summer surface air temperature variability. Soil moisture interacts with the atmosphere primarily through the surface energy balance. The degree of soil saturation strongly influences the atmosphere of outgoing energy from the surface between the latent and sensible heat fluxes. Interactive soil moisture allows larger variations of these fluxes, thereby increasing the variance of surface air temperature. Because the flux of latent heat is directly proportional to potential evaporation under conditions of sufficient moisture, the influence of soil moisture on the atmosphere is greatest when the potential evaporation value is large. This occurs most frequently in the tropics and summer hemisphere extratropics.},
+	pages = {523--547},
+	number = {5},
+	journaltitle = {Journal of Climate},
+	author = {Delworth, Thomas L. and Manabe, Syukuro},
+	date = {1988},
+	note = {bibtex[eprint=http://journals.ametsoc.org/doi/pdf/10.1175/1520-0442\%281988\%29001\%3C0523\%3ATIOPEO\%3E2.0.{CO}\%3B2]},
+	file = {Delworth and Manabe - 1988 - The Influence of Potential Evaporation on the Vari.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4IRHH9AM\\Delworth and Manabe - 1988 - The Influence of Potential Evaporation on the Vari.pdf:application/pdf}
+}
+
+@article{chen_temporal_2014,
+	title = {Temporal and spatial pattern of thermokarst lake area changes at Yukon Flats, Alaska},
+	volume = {28},
+	issn = {08856087},
+	url = {http://doi.wiley.com/10.1002/hyp.9642},
+	doi = {10.1002/hyp.9642},
+	shorttitle = {Temporal and spatial pattern of thermokarst lake area changes at Yukon Flats, Alaska},
+	pages = {837--852},
+	number = {3},
+	journaltitle = {Hydrological Processes},
+	author = {Chen, Min and Rowland, Joel C. and Wilson, Cathy J. and Altmann, Garrett L. and Brumby, Steven P.},
+	urldate = {2018-01-03},
+	date = {2014-01-30},
+	langid = {english},
+	file = {Chen et al. - 2014 - Temporal and spatial pattern of thermokarst lake a.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\L3765CJI\\Chen et al. - 2014 - Temporal and spatial pattern of thermokarst lake a.pdf:application/pdf}
+}
+
+@article{arp_depth_2015,
+	title = {Depth, ice thickness, and ice-out timing cause divergent hydrologic responses among Arctic lakes: {ICE} {CAUSES} {DIVERGENT} {HYDROLOGIC} {RESPONSES} {AMONG} {ARCTIC} {LAKES}},
+	volume = {51},
+	issn = {00431397},
+	url = {http://doi.wiley.com/10.1002/2015WR017362},
+	doi = {10.1002/2015WR017362},
+	shorttitle = {Depth, ice thickness, and ice-out timing cause divergent hydrologic responses among Arctic lakes},
+	pages = {9379--9401},
+	number = {12},
+	journaltitle = {Water Resources Research},
+	author = {Arp, Christopher D. and Jones, Benjamin M. and Liljedahl, Anna K. and Hinkel, Kenneth M. and Welker, Jeffery A.},
+	urldate = {2018-01-03},
+	date = {2015-12},
+	langid = {english},
+	file = {Arp et al. - 2015 - Depth, ice thickness, and ice-out timing cause div.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\VB4TAZA6\\Arp et al. - 2015 - Depth, ice thickness, and ice-out timing cause div.pdf:application/pdf}
+}
+
+@article{minsley_airborne_2012,
+	title = {Airborne electromagnetic imaging of discontinuous permafrost: {AEM} {IMAGING} {OF} {PERMAFROST}},
+	volume = {39},
+	issn = {00948276},
+	url = {http://doi.wiley.com/10.1029/2011GL050079},
+	doi = {10.1029/2011GL050079},
+	shorttitle = {Airborne electromagnetic imaging of discontinuous permafrost},
+	pages = {n/a--n/a},
+	number = {2},
+	journaltitle = {Geophysical Research Letters},
+	author = {Minsley, Burke J. and Abraham, Jared D. and Smith, Bruce D. and Cannia, James C. and Voss, Clifford I. and Jorgenson, M. Torre and Walvoord, Michelle A. and Wylie, Bruce K. and Anderson, Lesleigh and Ball, Lyndsay B. and Deszcz-Pan, Maryla and Wellman, Tristan P. and Ager, Thomas A.},
+	urldate = {2018-01-03},
+	date = {2012-01},
+	langid = {english},
+	file = {Minsley et al. - 2012 - Airborne electromagnetic imaging of discontinuous .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\8J2PUMRQ\\Minsley et al. - 2012 - Airborne electromagnetic imaging of discontinuous .pdf:application/pdf}
+}
+
+@article{liu_estimating_2012,
+	title = {Estimating 1992-2000 average active layer thickness on the Alaskan North Slope from remotely sensed surface subsidence: {REMOTELY} {SENSING} {ACTIVE} {LAYER} {THICKNESS}},
+	volume = {117},
+	issn = {01480227},
+	url = {http://doi.wiley.com/10.1029/2011JF002041},
+	doi = {10.1029/2011JF002041},
+	shorttitle = {Estimating 1992-2000 average active layer thickness on the Alaskan North Slope from remotely sensed surface subsidence},
+	pages = {n/a--n/a},
+	issue = {F1},
+	journaltitle = {Journal of Geophysical Research: Earth Surface},
+	author = {Liu, Lin and Schaefer, Kevin and Zhang, Tingjun and Wahr, John},
+	urldate = {2018-01-03},
+	date = {2012-03},
+	langid = {english},
+	file = {Liu et al. - 2012 - Estimating 1992-2000 average active layer thicknes.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\YZH67QQQ\\Liu et al. - 2012 - Estimating 1992-2000 average active layer thicknes.pdf:application/pdf}
+}
+
+@thesis{thorne_using_2017,
+	location = {St. Catharines},
+	title = {Using unmanned aviation vehicle ({UAV}) multi-spectral remote sensing to detect shrub vegetation characteristics in Old Crow Flats, Yukon},
+	rights = {Copyright (c) William Brent Thorne 2017},
+	abstract = {Climate change is having major impacts on northern regions. Shrub vegetation proliferation is an example of how land cover is being modified, which can influence ground biophysical conditions and the hydrology of lake-rich landscapes. These impacts are being investigated in Old Crow Flats, Yukon, traditional territory of the Vuntut Gwitchin First Nation who rely on the resources of this landscape to support their traditional lifestyle. Vegetation conditions of two 90-m x 90-m plots were investigated using dendrochronology and high-resolution multi-spectral images captured using an unmanned aviation vehicle ({UAV}). Dendrochronology results showed that the average age for shrub vegetation was 28 years old (standard deviation = 13.65). The dominant species in the two plots included green alder (Alnus viridis,), dwarf birch (Betula nan), and willow (Salix sp.). Red and near-infrared bands of the multi-spectral images were used to calculate normalized difference vegetation index values ({NDVI}) for the two plots, which is an indicator of plant chlorophyll and phytomass. Vegetation characteristics measured on the ground were compared to {NDVI} values to identify whether {NDVI} may be used to differentiate species and plant age. Results of this research show that coupling {UAV} technology with ground measurements may be highly useful for identifying shrub species and age in lake-rich Arctic landscapes such as Old Crow Flats, Yukon. Integrated approaches being developed here are enhancing hydroecological monitoring protocols, which are providing the basis to identify how
+this landscape is responding to a changing climate.},
+	pagetotal = {49},
+	institution = {Brock University},
+	type = {Undergraduate Thesis},
+	author = {Thorne, W. Brent},
+	editora = {Turner, Kevin W.},
+	editoratype = {collaborator},
+	date = {2017},
+	keywords = {hydrology, {NDVI}, remote sensing, shrub, Thorne, {UAV}, unmanned aviation vehicle, vegetation},
+	file = {Thorne - 2017 - Using unmanned aviation vehicle (UAV) multi-spectr.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\U7ZUJ56M\\Thorne - 2017 - Using unmanned aviation vehicle (UAV) multi-spectr.pdf:application/pdf}
+}
+
+@incollection{roy-leveillee_old_2017,
+	title = {Old Crow Flats: Thermokarst Lakes in the Forest–Tundra Transition},
+	url = {http://link.springer.com/chapter/10.1007/978-3-319-44595-3_19},
+	shorttitle = {Old Crow Flats},
+	pages = {267--276},
+	booktitle = {Landscapes and Landforms of Western Canada},
+	publisher = {Springer},
+	author = {Roy-Leveillee, Pascale and Burn, Christopher R.},
+	editor = {Slaymaker, Olav},
+	urldate = {2017-07-31},
+	date = {2017},
+	file = {Roy-Léveillée and Burn - 2017 - Old Crow Flats Thermokarst Lakes in the Forest–Tu.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\TZQISKEQ\\Roy-Léveillée and Burn - 2017 - Old Crow Flats Thermokarst Lakes in the Forest–Tu.pdf:application/pdf}
+}
+
+@article{engram_characterization_2013,
+	title = {Characterization of L-band synthetic aperture radar ({SAR}) backscatter from floating and grounded thermokarst lake ice in Arctic Alaska},
+	volume = {7},
+	issn = {1994-0424},
+	url = {http://www.the-cryosphere.net/7/1741/2013/},
+	doi = {10.5194/tc-7-1741-2013},
+	pages = {1741--1752},
+	number = {6},
+	journaltitle = {The Cryosphere},
+	author = {Engram, M. and Anthony, K. W. and Meyer, F. J. and Grosse, G.},
+	urldate = {2018-01-02},
+	date = {2013-11-14},
+	langid = {english},
+	file = {Engram et al. - 2013 - Characterization of L-band synthetic aperture rada.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4WZ9FCKA\\Engram et al. - 2013 - Characterization of L-band synthetic aperture rada.pdf:application/pdf}
+}
+
+@article{minsley_evidence_2016,
+	title = {Evidence for nonuniform permafrost degradation after fire in boreal landscapes: {MAPPING} {POSTFIRE} {PERMAFROST} {DEGRADATION}},
+	volume = {121},
+	issn = {21699003},
+	url = {http://doi.wiley.com/10.1002/2015JF003781},
+	doi = {10.1002/2015JF003781},
+	shorttitle = {Evidence for nonuniform permafrost degradation after fire in boreal landscapes},
+	pages = {320--335},
+	number = {2},
+	journaltitle = {Journal of Geophysical Research: Earth Surface},
+	author = {Minsley, Burke J. and Pastick, Neal J. and Wylie, Bruce K. and Brown, Dana R. N. and Andy Kass, M.},
+	urldate = {2018-01-02},
+	date = {2016-02},
+	langid = {english},
+	file = {Minsley et al. - 2016 - Evidence for nonuniform permafrost degradation aft.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\BPUM7RZI\\Minsley et al. - 2016 - Evidence for nonuniform permafrost degradation aft.pdf:application/pdf}
+}
+
+@article{tabatabaeenejad_p-band_2015,
+	title = {P-Band Radar Retrieval of Subsurface Soil Moisture Profile as a Second-Order Polynomial: First {AirMOSS} Results},
+	volume = {53},
+	issn = {0196-2892, 1558-0644},
+	url = {http://ieeexplore.ieee.org/document/6839044/},
+	doi = {10.1109/TGRS.2014.2326839},
+	shorttitle = {P-Band Radar Retrieval of Subsurface Soil Moisture Profile as a Second-Order Polynomial},
+	pages = {645--658},
+	number = {2},
+	journaltitle = {{IEEE} Transactions on Geoscience and Remote Sensing},
+	author = {Tabatabaeenejad, Alireza and Burgin, Mariko and {Xueyang Duan} and Moghaddam, Mahta},
+	urldate = {2018-01-02},
+	date = {2015-02},
+	file = {Tabatabaeenejad et al. - 2015 - P-Band Radar Retrieval of Subsurface Soil Moisture.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\CGW3899H\\Tabatabaeenejad et al. - 2015 - P-Band Radar Retrieval of Subsurface Soil Moisture.pdf:application/pdf}
+}
+
+@article{sadeghi_advancing_2016,
+	title = {Advancing {NASA}’s {AirMOSS} P-Band Radar Root Zone Soil Moisture Retrieval Algorithm via Incorporation of Richards’ Equation},
+	volume = {9},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/9/1/17},
+	doi = {10.3390/rs9010017},
+	pages = {17},
+	number = {1},
+	journaltitle = {Remote Sensing},
+	author = {Sadeghi, Morteza and Tabatabaeenejad, Alireza and Tuller, Markus and Moghaddam, Mahta and Jones, Scott},
+	urldate = {2018-01-02},
+	date = {2016-12-28},
+	langid = {english},
+	file = {Sadeghi et al. - 2016 - Advancing NASA’s AirMOSS P-Band Radar Root Zone So.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\QBJQWC47\\Sadeghi et al. - 2016 - Advancing NASA’s AirMOSS P-Band Radar Root Zone So.pdf:application/pdf}
+}
+
+@article{riley_characterizing_2014,
+	title = {Characterizing coarse-resolution watershed soil moisture heterogeneity using fine-scale simulations},
+	volume = {18},
+	issn = {1607-7938},
+	url = {http://www.hydrol-earth-syst-sci.net/18/2463/2014/},
+	doi = {10.5194/hess-18-2463-2014},
+	pages = {2463--2483},
+	number = {7},
+	journaltitle = {Hydrology and Earth System Sciences},
+	author = {Riley, W. J. and Shen, C.},
+	urldate = {2018-01-02},
+	date = {2014-07-03},
+	langid = {english},
+	file = {Riley and Shen - 2014 - Characterizing coarse-resolution watershed soil mo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\RBQPC368\\Riley and Shen - 2014 - Characterizing coarse-resolution watershed soil mo.pdf:application/pdf}
+}
+
+@article{lawrence_permafrost_2015,
+	title = {Permafrost thaw and resulting soil moisture changes regulate projected high-latitude {CO} $_{\textrm{2}}$ and {CH} $_{\textrm{4}}$ emissions},
+	volume = {10},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/10/i=9/a=094011?key=crossref.0ec3ff97879a814d0c3dfaacde810d23},
+	doi = {10.1088/1748-9326/10/9/094011},
+	pages = {094011},
+	number = {9},
+	journaltitle = {Environmental Research Letters},
+	author = {Lawrence, D M and Koven, C D and Swenson, S C and Riley, W J and Slater, A G},
+	urldate = {2018-01-02},
+	date = {2015-09-01},
+	file = {Lawrence et al. - 2015 - Permafrost thaw and resulting soil moisture change.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\BIWWD7UN\\Lawrence et al. - 2015 - Permafrost thaw and resulting soil moisture change.pdf:application/pdf}
+}
+
+@article{myers-smith_shrub_2013,
+	title = {Shrub canopies influence soil temperatures but not nutrient dynamics: An experimental test of tundra snow-shrub interactions},
+	volume = {3},
+	issn = {20457758},
+	url = {http://doi.wiley.com/10.1002/ece3.710},
+	doi = {10.1002/ece3.710},
+	shorttitle = {Shrub canopies influence soil temperatures but not nutrient dynamics},
+	pages = {3683--3700},
+	number = {11},
+	journaltitle = {Ecology and Evolution},
+	author = {Myers-Smith, Isla H. and Hik, David S.},
+	urldate = {2018-01-01},
+	date = {2013-10},
+	langid = {english},
+	file = {Myers-Smith_et_al-2013-Ecology_and_Evolution.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\BXJH6H4S\\Myers-Smith_et_al-2013-Ecology_and_Evolution.pdf:application/pdf}
+}
+
+@article{jorgenson_remote_2016,
+	title = {Remote Sensing of Landscape Change in Permafrost Regions: Remote Sensing of Landscape Change in Permafrost Regions},
+	volume = {27},
+	issn = {10456740},
+	url = {http://doi.wiley.com/10.1002/ppp.1914},
+	doi = {10.1002/ppp.1914},
+	shorttitle = {Remote Sensing of Landscape Change in Permafrost Regions},
+	pages = {324--338},
+	number = {4},
+	journaltitle = {Permafrost and Periglacial Processes},
+	author = {Jorgenson, Mark Torre and Grosse, Guido},
+	urldate = {2017-12-23},
+	date = {2016-10},
+	langid = {english},
+	file = {Jorgenson_et_al-2016-Permafrost_and_Periglacial_Processes.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\A2EE3KVX\\Jorgenson_et_al-2016-Permafrost_and_Periglacial_Processes.pdf:application/pdf}
+}
+
+@article{gilabert_generalized_2002,
+	title = {A generalized soil-adjusted vegetation index},
+	volume = {82},
+	pages = {303--310},
+	number = {2},
+	journaltitle = {Remote Sensing of environment},
+	author = {Gilabert, M. A. and González-Piqueras, J. and Garcıa-Haro, F. J. and Meliá, J.},
+	date = {2002},
+	file = {Gilabert et al. - 2002 - A generalized soil-adjusted vegetation index.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ET3DR4XH\\Gilabert et al. - 2002 - A generalized soil-adjusted vegetation index.pdf:application/pdf}
+}
+
+@article{huete_soil-adjusted_1988,
+	title = {A soil-adjusted vegetation index ({SAVI})},
+	volume = {25},
+	pages = {295--309},
+	number = {3},
+	journaltitle = {Remote sensing of environment},
+	author = {Huete, Alfredo R.},
+	date = {1988},
+	file = {Huete - 1988 - A soil-adjusted vegetation index (SAVI).pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\V6TUS789\\Huete - 1988 - A soil-adjusted vegetation index (SAVI).pdf:application/pdf}
+}
+
+@article{candiago_evaluating_2015,
+	title = {Evaluating Multispectral Images and Vegetation Indices for Precision Farming Applications from {UAV} Images},
+	volume = {7},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/7/4/4026/},
+	doi = {10.3390/rs70404026},
+	pages = {4026--4047},
+	number = {4},
+	journaltitle = {Remote Sensing},
+	author = {Candiago, Sebastian and Remondino, Fabio and De Giglio, Michaela and Dubbini, Marco and Gattelli, Mario},
+	urldate = {2017-12-20},
+	date = {2015-04-02},
+	langid = {english},
+	file = {Candiago et al. - 2015 - Evaluating Multispectral Images and Vegetation Ind.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\KQXU52BU\\Candiago et al. - 2015 - Evaluating Multispectral Images and Vegetation Ind.pdf:application/pdf}
+}
+
+@article{albetis_detection_2017,
+	title = {Detection of Flavescence dorée Grapevine Disease Using Unmanned Aerial Vehicle ({UAV}) Multispectral Imagery},
+	volume = {9},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/9/4/308},
+	doi = {10.3390/rs9040308},
+	pages = {308},
+	number = {4},
+	journaltitle = {Remote Sensing},
+	author = {Albetis, Johanna and Duthoit, Sylvie and Guttler, Fabio and Jacquin, Anne and Goulard, Michel and Poilvé, Hervé and Féret, Jean-Baptiste and Dedieu, Gérard},
+	urldate = {2017-12-20},
+	date = {2017-03-24},
+	langid = {english},
+	file = {Albetis et al. - 2017 - Detection of Flavescence dorée Grapevine Disease U.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\TG2QSUD4\\Albetis et al. - 2017 - Detection of Flavescence dorée Grapevine Disease U.pdf:application/pdf}
+}
+
+@article{lopez-lopez_early_2016,
+	title = {Early Detection and Quantification of Almond Red Leaf Blotch Using High-Resolution Hyperspectral and Thermal Imagery},
+	volume = {8},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/8/4/276},
+	doi = {10.3390/rs8040276},
+	pages = {276},
+	number = {4},
+	journaltitle = {Remote Sensing},
+	author = {López-López, Manuel and Calderón, Rocío and González-Dugo, Victoria and Zarco-Tejada, Pablo and Fereres, Elías},
+	urldate = {2017-12-20},
+	date = {2016-03-25},
+	langid = {english},
+	file = {López-López et al. - 2016 - Early Detection and Quantification of Almond Red L.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\6KFIEIW3\\López-López et al. - 2016 - Early Detection and Quantification of Almond Red L.pdf:application/pdf}
+}
+
+@article{balasubramaniam_biotic_2017,
+	title = {Biotic responses to multiple aquatic and terrestrial gradients in shallow subarctic lakes (Old Crow Flats, Yukon, Canada)},
+	volume = {3},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2016-0021},
+	doi = {10.1139/as-2016-0021},
+	pages = {277--300},
+	number = {2},
+	journaltitle = {Arctic Science},
+	author = {Balasubramaniam, A.M. and Medeiros, A.S. and Turner, K.W. and Hall, R.I. and Wolfe, B.B.},
+	urldate = {2017-12-18},
+	date = {2017-06},
+	langid = {english},
+	file = {Balasubramaniam et al. - 2017 - Biotic responses to multiple aquatic and terrestri.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\Q5WUQE2F\\Balasubramaniam et al. - 2017 - Biotic responses to multiple aquatic and terrestri.pdf:application/pdf}
+}
+
+@article{walvoord_hydrologic_2016,
+	title = {Hydrologic Impacts of Thawing Permafrost—A Review},
+	volume = {15},
+	issn = {1539-1663},
+	url = {https://dl.sciencesocieties.org/publications/vzj/abstracts/15/6/vzj2016.01.0010},
+	doi = {10.2136/vzj2016.01.0010},
+	pages = {0},
+	number = {6},
+	journaltitle = {Vadose Zone Journal},
+	author = {Walvoord, Michelle A. and Kurylyk, Barret L.},
+	urldate = {2017-12-18},
+	date = {2016},
+	langid = {english}
+}
+
+@article{wang_analysis_2017,
+	title = {Analysis of Differences in Phenology Extracted from the Enhanced Vegetation Index and the Leaf Area Index},
+	volume = {17},
+	issn = {1424-8220},
+	url = {http://www.mdpi.com/1424-8220/17/9/1982},
+	doi = {10.3390/s17091982},
+	pages = {1982},
+	number = {9},
+	journaltitle = {Sensors},
+	author = {Wang, Cong and Li, Jing and Liu, Qinhuo and Zhong, Bo and Wu, Shanlong and Xia, Chuanfu},
+	urldate = {2017-12-07},
+	date = {2017-08-30},
+	langid = {english},
+	file = {Wang et al. - 2017 - Analysis of Differences in Phenology Extracted fro.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\6QVN5DJJ\\Wang et al. - 2017 - Analysis of Differences in Phenology Extracted fro.pdf:application/pdf}
+}
+
+@article{filippini_alba_geotechnologies_2017,
+	title = {Geotechnologies and Soil Mapping for Delimitation of Management Zones as an Approach to Precision Viticulture},
+	volume = {2017},
+	issn = {1687-7667, 1687-7675},
+	url = {https://www.hindawi.com/journals/aess/2017/4180965/},
+	doi = {10.1155/2017/4180965},
+	pages = {1--10},
+	journaltitle = {Applied and Environmental Soil Science},
+	author = {Filippini Alba, José Maria and Flores, Carlos Alberto and Miele, Alberto},
+	urldate = {2017-12-07},
+	date = {2017},
+	langid = {english},
+	file = {Filippini Alba et al. - 2017 - Geotechnologies and Soil Mapping for Delimitation .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\C7AA8MZH\\Filippini Alba et al. - 2017 - Geotechnologies and Soil Mapping for Delimitation .pdf:application/pdf}
+}
+
+@article{puletti_unsupervised_2014,
+	title = {Unsupervised classification of very high remotely sensed images for grapevine rows detection},
+	volume = {47},
+	issn = {2279-7254},
+	url = {https://www.tandfonline.com/doi/full/10.5721/EuJRS20144704},
+	doi = {10.5721/EuJRS20144704},
+	pages = {45--54},
+	number = {1},
+	journaltitle = {European Journal of Remote Sensing},
+	author = {Puletti, Nicola and Perria, Rita and Storchi, Paolo},
+	urldate = {2017-12-07},
+	date = {2014-01},
+	langid = {english},
+	file = {Puletti et al. - 2014 - Unsupervised classification of very high remotely .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\8NI2EUMR\\Puletti et al. - 2014 - Unsupervised classification of very high remotely .pdf:application/pdf}
+}
+
+@book{harris_s.a._glossary_1988,
+	location = {Ottawa,Ontario,Canada},
+	title = {Glossary of permafrost and related ground-ice terms},
+	isbn = {978-0-660-12540-4},
+	series = {Technical Memorandum / National Research Council, Canada},
+	pagetotal = {156},
+	number = {142},
+	author = {{Harris S.A.} and {French H.M.} and {Heginbottom J.A.}},
+	date = {1988},
+	note = {{OCLC}: 20504505},
+	file = {Harris S.A. et al. - 1988 - Glossary of permafrost and related ground-ice term.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4GF3MEPG\\Harris S.A. et al. - 1988 - Glossary of permafrost and related ground-ice term.pdf:application/pdf}
+}
+
+@article{poblete-echeverria_detection_2017,
+	title = {Detection and Segmentation of Vine Canopy in Ultra-High Spatial Resolution {RGB} Imagery Obtained from Unmanned Aerial Vehicle ({UAV}): A Case Study in a Commercial Vineyard},
+	volume = {9},
+	issn = {20724292},
+	url = {https://proxy.library.brocku.ca/login?url=http://search.ebscohost.com/login.aspx?direct=true&db=a9h&AN=122027077&site=eds-live&scope=site},
+	doi = {10.3390/rs9030268},
+	shorttitle = {Detection and Segmentation of Vine Canopy in Ultra-High Spatial Resolution {RGB} Imagery Obtained from Unmanned Aerial Vehicle ({UAV})},
+	abstract = {The use of Unmanned Aerial Vehicles ({UAVs}) in viticulture permits the capture of aerial Red-Green-Blue ({RGB}) images with an ultra-high spatial resolution. Recent studies have demonstrated that {RGB} images can be used to monitor spatial variability of vine biophysical parameters. However, for estimating these parameters, accurate and automated segmentation methods are required to extract relevant information from {RGB} images. Manual segmentation of aerial images is a laborious and time-consuming process. Traditional classification methods have shown satisfactory results in the segmentation of {RGB} images for diverse applications and surfaces, however, in the case of commercial vineyards, it is necessary to consider some particularities inherent to canopy size in the vertical trellis systems ({VSP}) such as shadow effect and different soil conditions in inter-rows (mixed information of soil and weeds). Therefore, the objective of this study was to compare the performance of four classification methods (K-means, Artificial Neural Networks ({ANN}), Random Forest ({RForest}) and Spectral Indices ({SI})) to detect canopy in a vineyard trained on {VSP}. Six flights were carried out from post-flowering to harvest in a commercial vineyard cv. Carménère using a low-cost {UAV} equipped with a conventional {RGB} camera. The results show that the {ANN} and the simple {SI} method complemented with the Otsu method for thresholding presented the best performance for the detection of the vine canopy with high overall accuracy values for all study days. Spectral indices presented the best performance in the detection of Plant class (Vine canopy) with an overall accuracy of around 0.99. However, considering the performance pixel by pixel, the Spectral indices are not able to discriminate between Soil and Shadow class. The best performance in the classification of three classes (Plant, Soil, and Shadow) of vineyard {RGB} images, was obtained when the {SI} values were used as input data in trained methods ({ANN} and {RForest}), reaching overall accuracy values around 0.98 with high sensitivity values for the three classes.},
+	pages = {1--14},
+	number = {3},
+	journaltitle = {Remote Sensing},
+	shortjournal = {Remote Sensing},
+	author = {Poblete-Echeverría, Carlos and Federico Olmedo, Guillermo and Ingram, Ben and Bardeen, Matthew},
+	date = {2017-03},
+	keywords = {remote sensing, {DRONE} aircraft, image analysis, {PARAMETER} estimation, {PLANT} canopies, precision viticulture, random forest, {SEGMENTATION} (Image processing), spatial variability, {VINEYARDS}},
+	file = {EBSCO Full Text:C\:\\Users\\Brent Thorne\\Zotero\\storage\\AQ3Q7WQ5\\Poblete-Echeverría et al. - 2017 - Detection and Segmentation of Vine Canopy in Ultra.pdf:application/pdf}
+}
+
+@article{sladojevic_deep_2016,
+	title = {Deep Neural Networks Based Recognition of Plant Diseases by Leaf Image Classification},
+	volume = {2016},
+	issn = {1687-5265},
+	url = {https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4934169/},
+	doi = {10.1155/2016/3289801},
+	abstract = {The latest generation of convolutional neural networks ({CNNs}) has achieved impressive results in the field of image classification. This paper is concerned with a new approach to the development of plant disease recognition model, based on leaf image classification, by the use of deep convolutional networks. Novel way of training and the methodology used facilitate a quick and easy system implementation in practice. The developed model is able to recognize 13 different types of plant diseases out of healthy leaves, with the ability to distinguish plant leaves from their surroundings. According to our knowledge, this method for plant disease recognition has been proposed for the first time. All essential steps required for implementing this disease recognition model are fully described throughout the paper, starting from gathering images in order to create a database, assessed by agricultural experts. Caffe, a deep learning framework developed by Berkley Vision and Learning Centre, was used to perform the deep {CNN} training. The experimental results on the developed model achieved precision between 91\% and 98\%, for separate class tests, on average 96.3\%.},
+	journaltitle = {Computational Intelligence and Neuroscience},
+	shortjournal = {Comput Intell Neurosci},
+	author = {Sladojevic, Srdjan and Arsenovic, Marko and Anderla, Andras and Culibrk, Dubravko and Stefanovic, Darko},
+	date = {2016},
+	pmid = {27418923},
+	pmcid = {PMC4934169},
+	file = {Sladojevic et al. - 2016 - Deep Neural Networks Based Recognition of Plant Di.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ZWU7NT3Z\\Sladojevic et al. - 2016 - Deep Neural Networks Based Recognition of Plant Di.pdf:application/pdf}
+}
+
+@article{terron_evaluation_2015,
+	title = {Evaluation of vineyard growth under four irrigation regimes using vegetation and soil on-the-go sensors},
+	volume = {1},
+	issn = {2199-398X},
+	url = {http://www.soil-journal.net/1/459/2015/},
+	doi = {10.5194/soil-1-459-2015},
+	pages = {459--473},
+	number = {1},
+	journaltitle = {{SOIL}},
+	author = {Terrón, J. M. and Blanco, J. and Moral, F. J. and Mancha, L. A. and Uriarte, D. and Marques da Silva, J. R.},
+	urldate = {2017-11-28},
+	date = {2015-06-17},
+	langid = {english},
+	file = {Terrón et al. - 2015 - Evaluation of vineyard growth under four irrigatio.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\AIKE8PI9\\Terrón et al. - 2015 - Evaluation of vineyard growth under four irrigatio.pdf:application/pdf}
+}
+
+@collection{dion_microbiology_2008,
+	location = {Berlin},
+	title = {Microbiology of extreme soils},
+	isbn = {978-3-540-74230-2},
+	series = {Soil biology},
+	pagetotal = {369},
+	number = {v. 13},
+	publisher = {Springer},
+	editor = {Dion, Patrice and Nautiyal, Chandra Shekhar},
+	date = {2008},
+	note = {{OCLC}: ocn181328027},
+	keywords = {Effect of human beings on, Microbiology, Research, Soil microbiology, Soils},
+	file = {Dion and Nautiyal - 2008 - Microbiology of extreme soils.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\P42SF3BP\\Dion and Nautiyal - 2008 - Microbiology of extreme soils.pdf:application/pdf}
+}
+
+@article{lamoureux_more_2017,
+	title = {More than just snowmelt: integrated watershed science for changing climate and permafrost at the Cape Bounty Arctic Watershed Observatory: Integrated watershed science for changing climate and permafrost at {CBAWO}},
+	issn = {20491948},
+	url = {http://doi.wiley.com/10.1002/wat2.1255},
+	doi = {10.1002/wat2.1255},
+	shorttitle = {More than just snowmelt},
+	pages = {e1255},
+	journaltitle = {Wiley Interdisciplinary Reviews: Water},
+	author = {Lamoureux, Scott F. and Lafrenière, Melissa J.},
+	urldate = {2017-11-01},
+	date = {2017-10-24},
+	langid = {english},
+	file = {Lamoureux_et_al-2017-Wiley_Interdisciplinary_Reviews-_Water.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\H2489T2P\\Lamoureux_et_al-2017-Wiley_Interdisciplinary_Reviews-_Water.pdf:application/pdf}
+}
+
+@thesis{macdougall_evaluating_2017,
+	title = {Evaluating the affect of seasonal soil moisture and vegetation change on C-Band {SAR} backscatter over corn fields in {SW} Ontario},
+	type = {phdthesis},
+	author = {{MacDougall}, Joshua},
+	date = {2017},
+	file = {MacDougall - 2017 - Evaluating the affect of seasonal soil moisture an.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\QWSBV5I8\\MacDougall - 2017 - Evaluating the affect of seasonal soil moisture an.pdf:application/pdf}
+}
+
+@article{ouellette_time-series_2017,
+	title = {A Time-Series Approach to Estimating Soil Moisture From Vegetated Surfaces Using L-Band Radar Backscatter},
+	volume = {55},
+	issn = {0196-2892, 1558-0644},
+	url = {http://ieeexplore.ieee.org/document/7864350/},
+	doi = {10.1109/TGRS.2017.2663768},
+	pages = {3186--3193},
+	number = {6},
+	journaltitle = {{IEEE} Transactions on Geoscience and Remote Sensing},
+	author = {Ouellette, Jeffrey D. and Johnson, Joel T. and Balenzano, Anna and Mattia, Francesco and Satalino, Giuseppe and Kim, Seung-Bum and Dunbar, R. Scott and Colliander, Andreas and Cosh, Michael H. and Caldwell, Todd G. and Walker, Jeffrey P. and Berg, Aaron A.},
+	urldate = {2017-10-20},
+	date = {2017-06},
+	file = {Ouellette et al. - 2017 - A Time-Series Approach to Estimating Soil Moisture.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\CRSW45MW\\Ouellette et al. - 2017 - A Time-Series Approach to Estimating Soil Moisture.pdf:application/pdf}
+}
+
+@article{hosseini_using_2017,
+	title = {Using multi-polarization C- and L-band synthetic aperture radar to estimate biomass and soil moisture of wheat fields},
+	volume = {58},
+	issn = {03032434},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0303243417300065},
+	doi = {10.1016/j.jag.2017.01.006},
+	pages = {50--64},
+	journaltitle = {International Journal of Applied Earth Observation and Geoinformation},
+	author = {Hosseini, Mehdi and {McNairn}, Heather},
+	urldate = {2017-10-20},
+	date = {2017-06},
+	langid = {english},
+	file = {Hosseini and McNairn - 2017 - Using multi-polarization C- and L-band synthetic a.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\XMSAT6Q4\\Hosseini and McNairn - 2017 - Using multi-polarization C- and L-band synthetic a.pdf:application/pdf}
+}
+
+@article{ackerman_arctic_2017,
+	title = {Arctic shrub growth trajectories differ across soil moisture levels},
+	volume = {23},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/gcb.13677},
+	doi = {10.1111/gcb.13677},
+	pages = {4294--4302},
+	number = {10},
+	journaltitle = {Global Change Biology},
+	author = {Ackerman, Daniel and Griffin, Daniel and Hobbie, Sarah E. and Finlay, Jacques C.},
+	urldate = {2017-09-14},
+	date = {2017-10},
+	langid = {english},
+	file = {Ackerman et al. - 2017 - Arctic shrub growth trajectories differ across soi.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\7ZRCVS73\\Ackerman et al. - 2017 - Arctic shrub growth trajectories differ across soi.pdf:application/pdf}
+}
+
+@thesis{turner_investigating_2014,
+	location = {Waterloo, Ontario},
+	title = {Investigating the Hydrology of a Thermokarst Landscape (Old Crow Flats, Yukon, Canada) Using Water Isotope Tracers.},
+	rights = {Kevin W. Turner},
+	pagetotal = {219},
+	institution = {Wilfrid Laurier University},
+	type = {phdthesis},
+	author = {Turner, Kevin William},
+	date = {2014},
+	note = {{OCLC}: 921571251},
+	file = {Turner - 2014 - Investigating the Hydrology of a Thermokarst Lands.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\DNST7PF3\\Turner - 2014 - Investigating the Hydrology of a Thermokarst Lands.pdf:application/pdf}
+}
+
+@article{vincent_arctic_2017,
+	title = {Arctic permafrost landscapes in transition: towards an integrated Earth system approach},
+	volume = {3},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2016-0027},
+	doi = {10.1139/as-2016-0027},
+	shorttitle = {Arctic permafrost landscapes in transition},
+	pages = {39--64},
+	number = {2},
+	journaltitle = {Arctic Science},
+	author = {Vincent, Warwick F. and Lemay, Mickaël and Allard, Michel},
+	urldate = {2017-08-30},
+	date = {2017-06},
+	langid = {english},
+	file = {Vincent et al. - 2017 - Arctic permafrost landscapes in transition toward.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\UXR8GEI2\\Vincent et al. - 2017 - Arctic permafrost landscapes in transition toward.pdf:application/pdf}
+}
+
+@article{schadel_circumpolar_2014,
+	title = {Circumpolar assessment of permafrost C quality and its vulnerability over time using long-term incubation data},
+	volume = {20},
+	issn = {1365-2486},
+	url = {http://onlinelibrary.wiley.com.proxy.library.brocku.ca/doi/10.1111/gcb.12417/abstract},
+	doi = {10.1111/gcb.12417},
+	abstract = {High-latitude ecosystems store approximately 1700 Pg of soil carbon (C), which is twice as much C as is currently contained in the atmosphere. Permafrost thaw and subsequent microbial decomposition of permafrost organic matter could add large amounts of C to the atmosphere, thereby influencing the global C cycle. The rates at which C is being released from the permafrost zone at different soil depths and across different physiographic regions are poorly understood but crucial in understanding future changes in permafrost C storage with climate change. We assessed the inherent decomposability of C from the permafrost zone by assembling a database of long-term ({\textgreater}1 year) aerobic soil incubations from 121 individual samples from 23 high-latitude ecosystems located across the northern circumpolar permafrost zone. Using a three-pool (i.e., fast, slow and passive) decomposition model, we estimated pool sizes for C fractions with different turnover times and their inherent decomposition rates using a reference temperature of 5 °C. Fast cycling C accounted for less than 5\% of all C in both organic and mineral soils whereas the pool size of slow cycling C increased with C : N. Turnover time at 5 °C of fast cycling C typically was below 1 year, between 5 and 15 years for slow turning over C, and more than 500 years for passive C. We project that between 20 and 90\% of the organic C could potentially be mineralized to {CO}2 within 50 incubation years at a constant temperature of 5 °C, with vulnerability to loss increasing in soils with higher C : N. These results demonstrate the variation in the vulnerability of C stored in permafrost soils based on inherent differences in organic matter decomposability, and point toward C : N as an index of decomposability that has the potential to be used to scale permafrost C loss across landscapes.},
+	pages = {641--652},
+	number = {2},
+	journaltitle = {Global Change Biology},
+	shortjournal = {Glob Change Biol},
+	author = {Schädel, Christina and Schuur, Edward A. G. and Bracho, Rosvel and Elberling, Bo and Knoblauch, Christian and Lee, Hanna and Luo, Yiqi and Shaver, Gaius R. and Turetsky, Merritt R.},
+	date = {2014-02-01},
+	langid = {english},
+	keywords = {Alaska, tundra, boreal forest, C decomposition, climate change, Siberia, soil organic carbon},
+	file = {Schädel et al. - 2014 - Circumpolar assessment of permafrost C quality and.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\N6A9G9M5\\Schädel et al. - 2014 - Circumpolar assessment of permafrost C quality and.pdf:application/pdf;Snapshot:C\:\\Users\\Brent Thorne\\Zotero\\storage\\8RCSUATK\\abstract.html:text/html}
+}
+
+@article{smith_thermal_2010,
+	title = {Thermal state of permafrost in North America: a contribution to the international polar year},
+	volume = {21},
+	url = {http://onlinelibrary.wiley.com/doi/10.1002/ppp.690/full},
+	shorttitle = {Thermal state of permafrost in North America},
+	pages = {117--135},
+	number = {2},
+	journaltitle = {Permafrost and Periglacial Processes},
+	author = {Smith, S. L. and Romanovsky, V. E. and Lewkowicz, A. G. and Burn, C. R. and Allard, M. and Clow, G. D. and Yoshikawa, K. and Throop, J.},
+	urldate = {2017-08-30},
+	date = {2010},
+	file = {Smith et al. - 2010 - Thermal state of permafrost in North America a co.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\B2EASXDZ\\Smith et al. - 2010 - Thermal state of permafrost in North America a co.pdf:application/pdf}
+}
+
+@article{park_widespread_2016,
+	title = {Widespread permafrost vulnerability and soil active layer increases over the high northern latitudes inferred from satellite remote sensing and process model assessments},
+	volume = {175},
+	issn = {00344257},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0034425715302686},
+	doi = {10.1016/j.rse.2015.12.046},
+	pages = {349--358},
+	journaltitle = {Remote Sensing of Environment},
+	author = {Park, Hotaek and Kim, Youngwook and Kimball, John S.},
+	urldate = {2017-08-30},
+	date = {2016-03},
+	langid = {english},
+	file = {Park et al. - 2016 - Widespread permafrost vulnerability and soil activ.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\XUCW9HPK\\Park et al. - 2016 - Widespread permafrost vulnerability and soil activ.pdf:application/pdf}
+}
+
+@article{newman_microtopographic_2015,
+	title = {Microtopographic and depth controls on active layer chemistry in Arctic polygonal ground: Polygonal Ground Chemistry},
+	volume = {42},
+	issn = {00948276},
+	url = {http://doi.wiley.com/10.1002/2014GL062804},
+	doi = {10.1002/2014GL062804},
+	shorttitle = {Microtopographic and depth controls on active layer chemistry in Arctic polygonal ground},
+	pages = {1808--1817},
+	number = {6},
+	journaltitle = {Geophysical Research Letters},
+	author = {Newman, B. D. and Throckmorton, H. M. and Graham, D. E. and Gu, B. and Hubbard, S. S. and Liang, L. and Wu, Y. and Heikoop, J. M. and Herndon, E. M. and Phelps, T. J. and Wilson, C. J. and Wullschleger, S. D.},
+	urldate = {2017-08-30},
+	date = {2015-03-28},
+	langid = {english},
+	file = {Newman et al. - 2015 - Microtopographic and depth controls on active laye.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\R6KTPTXE\\Newman et al. - 2015 - Microtopographic and depth controls on active laye.pdf:application/pdf}
+}
+
+@article{muskett_active-layer_2015,
+	title = {Active-Layer Soil Moisture Content Regional Variations in Alaska and Russia by Ground-Based and Satellite-Based Methods, 2002 through 2014},
+	volume = {06},
+	issn = {2156-8359, 2156-8367},
+	url = {http://www.scirp.org/journal/doi.aspx?DOI=10.4236/ijg.2015.61002},
+	doi = {10.4236/ijg.2015.61002},
+	pages = {12--41},
+	number = {1},
+	journaltitle = {International Journal of Geosciences},
+	author = {Muskett, Reginald R. and Romanovsky, Vladimir E. and Cable, William L. and Kholodov, Alexander L.},
+	urldate = {2017-08-30},
+	date = {2015},
+	file = {Muskett et al. - 2015 - Active-Layer Soil Moisture Content Regional Variat.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\IAIE7EPM\\Muskett et al. - 2015 - Active-Layer Soil Moisture Content Regional Variat.pdf:application/pdf}
+}
+
+@article{gusmeroli_active_2015,
+	title = {Active Layer Stratigraphy and Organic Layer Thickness at a Thermokarst Site in Arctic Alaska Identified Using Ground Penetrating Radar},
+	volume = {47},
+	issn = {1523-0430, 1938-4246},
+	url = {http://www.bioone.org/doi/10.1657/AAAR00C-13-301},
+	doi = {10.1657/AAAR00C-13-301},
+	pages = {195--202},
+	number = {2},
+	journaltitle = {Arctic, Antarctic, and Alpine Research},
+	author = {Gusmeroli, Alessio and Liu, Lin and Schaefer, Kevin and Zhang, Tingjun and Schaefer, Timothy and Grosse, Guido},
+	urldate = {2017-08-30},
+	date = {2015-05},
+	langid = {english},
+	file = {Gusmeroli et al. - 2015 - Active Layer Stratigraphy and Organic Layer Thickn.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\BXQWQX86\\Gusmeroli et al. - 2015 - Active Layer Stratigraphy and Organic Layer Thickn.pdf:application/pdf}
+}
+
+@article{brown_circumpolar_2000,
+	title = {The circumpolar active layer monitoring (calm) program: Research designs and initial results $^{\textrm{1}}$},
+	volume = {24},
+	issn = {1088-937X, 1939-0513},
+	url = {http://www.tandfonline.com/doi/abs/10.1080/10889370009377698},
+	doi = {10.1080/10889370009377698},
+	shorttitle = {The circumpolar active layer monitoring (calm) program},
+	pages = {166--258},
+	number = {3},
+	journaltitle = {Polar Geography},
+	author = {Brown, J. and Hinkel, K. M. and Nelson, F. E.},
+	urldate = {2017-08-30},
+	date = {2000-07},
+	langid = {english},
+	file = {Brown et al. - 2000 - The circumpolar active layer monitoring (calm) pro.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\NRFEFXQE\\Brown et al. - 2000 - The circumpolar active layer monitoring (calm) pro.pdf:application/pdf}
+}
+
+@article{gangodagamage_extrapolating_2014,
+	title = {Extrapolating active layer thickness measurements across Arctic polygonal terrain using {LiDAR} and {NDVI} data sets},
+	volume = {50},
+	issn = {1944-7973},
+	url = {http://onlinelibrary.wiley.com/doi/10.1002/2013WR014283/abstract},
+	doi = {10.1002/2013WR014283},
+	abstract = {Landscape attributes that vary with microtopography, such as active layer thickness ({ALT}), are labor intensive and difficult to document effectively through in situ methods at kilometer spatial extents, thus rendering remotely sensed methods desirable. Spatially explicit estimates of {ALT} can provide critically needed data for parameterization, initialization, and evaluation of Arctic terrestrial models. In this work, we demonstrate a new approach using high-resolution remotely sensed data for estimating centimeter-scale {ALT} in a 5 km2 area of ice-wedge polygon terrain in Barrow, Alaska. We use a simple regression-based, machine learning data-fusion algorithm that uses topographic and spectral metrics derived from multisensor data ({LiDAR} and {WorldView}-2) to estimate {ALT} (2 m spatial resolution) across the study area. Comparison of the {ALT} estimates with ground-based measurements, indicates the accuracy (r2 = 0.76, {RMSE} ±4.4 cm) of the approach. While it is generally accepted that broad climatic variability associated with increasing air temperature will govern the regional averages of {ALT}, consistent with prior studies, our findings using high-resolution {LiDAR} and {WorldView}-2 data, show that smaller-scale variability in {ALT} is controlled by local eco-hydro-geomorphic factors. This work demonstrates a path forward for mapping {ALT} at high spatial resolution and across sufficiently large regions for improved understanding and predictions of coupled dynamics among permafrost, hydrology, and land-surface processes from readily available remote sensing data.},
+	pages = {6339--6357},
+	number = {8},
+	journaltitle = {Water Resources Research},
+	shortjournal = {Water Resour. Res.},
+	author = {Gangodagamage, Chandana and Rowland, Joel C. and Hubbard, Susan S. and Brumby, Steven P. and Liljedahl, Anna K. and Wainwright, Haruko and Wilson, Cathy J. and Altmann, Garrett L. and Dafflon, Baptiste and Peterson, John and Ulrich, Craig and Tweedie, Craig E. and Wullschleger, Stan D.},
+	date = {2014-08-01},
+	langid = {english},
+	keywords = {Alaska, 0704 Seasonally frozen ground, 0706 Active layer, 0748 Ponds, 1823 Frozen ground, active layer thickness, barrow, eco-hydro-geo-thermal regimes, frozen ground, ice wedge polygons, thaw depth},
+	file = {Gangodagamage et al. - 2014 - Extrapolating active layer thickness measurements .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\AKTMBIC6\\Gangodagamage et al. - 2014 - Extrapolating active layer thickness measurements .pdf:application/pdf;Snapshot:C\:\\Users\\Brent Thorne\\Zotero\\storage\\J4BANJIG\\abstract.html:text/html}
+}
+
+@article{kokelj_impacts_2009,
+	title = {The impacts of thawing permafrost on the chemistry of lakes across the subarctic boreal-tundra transition, Mackenzie Delta region, Canada},
+	volume = {20},
+	issn = {10456740, 10991530},
+	url = {http://doi.wiley.com/10.1002/ppp.641},
+	doi = {10.1002/ppp.641},
+	pages = {185--199},
+	number = {2},
+	journaltitle = {Permafrost and Periglacial Processes},
+	author = {Kokelj, S. V. and Zajdlik, B. and Thompson, M. S.},
+	urldate = {2017-08-28},
+	date = {2009-04},
+	langid = {english},
+	file = {Kokelj et al. - 2009 - The impacts of thawing permafrost on the chemistry.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\WZ9RZ2GV\\Kokelj et al. - 2009 - The impacts of thawing permafrost on the chemistry.pdf:application/pdf}
+}
+
+@article{lapp_hydrology_2017,
+	title = {Hydrology of the North Klondike River: carbon export, water balance and inter-annual climate influences within a sub-alpine permafrost catchment},
+	volume = {53},
+	issn = {1025-6016},
+	url = {http://journals.scholarsportal.info/detailsundefined},
+	doi = {10.1080/10256016.2017.1355795},
+	shorttitle = {Hydrology of the North Klondike River},
+	abstract = {{ABSTRACT} Arctic and sub-arctic watersheds are undergoing significant changes due to recent climate warming and degrading permafrost, engendering enhanced monitoring of arctic rivers. Smaller catchments provide understanding of discharge, solute flux and groundwater recharge at the process level that contributes to an understanding of how larger arctic watersheds are responding to climate change. The North Klondike River, located in west central Yukon, is a sub-alpine permafrost catchment, which maintains an active hydrological monitoring station with a record of {\textgreater}40 years. In addition to being able to monitor intra-annual variability, this data set allows for more complex analysis of streamflow records. Streamflow data, geochemistry and stable isotope data for 2014 show a groundwater-dominated system, predominantly recharged during periods of snowmelt. Radiocarbon is shown to be a valuable tracer of soil zone recharge processes and carbon sources. Winter groundwater baseflow contributes 20 \% of total annual discharge, and accounts for up to 50 \% of total river discharge during the spring and summer months. Although total stream discharge remains unchanged, mean annual groundwater baseflow has increased over the 40-year monitoring period. Wavelet analysis reveals a catchment that responds to El Niño and longer solar cycles, as well as climatic shifts such as the Pacific Decadal Oscillation. Dedicated to Professor Peter Fritz on the occasion of his 80th birthday},
+	pages = {500--517},
+	number = {5},
+	journaltitle = {Isotopes in Environmental and Health Studies},
+	shortjournal = {Isotopes in Environmental and Health Studies},
+	author = {Lapp, Anthony and Clark, Ian and Macumber, Andrew and Patterson, Tim},
+	date = {2017},
+	keywords = {Carbon-13, carbon-14, catchment, groundwater, hydrogen-2, hydrogen-3, isotope hydrology, North Klondike River, oxygen-18, sub-alpine permafrost, water balance}
+}
+
+@article{serreze_observational_2000,
+	title = {Observational Evidence of Recent Change in the Northern High-Latitude Environment},
+	volume = {46},
+	issn = {0165-0009},
+	url = {http://journals.scholarsportal.info/detailsundefined},
+	abstract = {Studies from a variety of disciplines document recent change in the northern high-latitude environment. Prompted by predictions of an amplified response of the Arctic to enhanced greenhouse forcing, we present a synthesis of these observations. Pronounced winter and spring warming over northern continents since about 1970 is partly compensated by cooling over the northern North Atlantic. Warming is also evident over the central Arctic Ocean. There is a downward tendency in sea ice extent, attended by warming and increased areal extent of the Arctic Ocean's Atlantic layer. Negative snow cover anomalies have dominated over both continents since the late 1980s and terrestrial precipitation has increased since 1900. Small Arctic glaciers have exhibited generally negative mass balances. While permafrost has warmed in Alaska and Russia, it has cooled in eastern Canada. There is evidence of increased plant growth, attended by greater shrub abundance and northward migration of the tree line. Evidence also suggests that the tundra has changed from a net sink to a net source of atmospheric carbon dioxide. Taken together, these results paint a reasonably coherent picture of change, but their interpretation as signals of enhanced greenhouse warming is open to debate. Many of the environmental records are either short, are of uncertain quality, or provide limited spatial coverage. The recent high-latitude warming is also no larger than the interdecadal temperature range during this century. Nevertheless, the general patterns of change broadly agree with model predictions. Roughly half of the pronounced recent rise in Northern Hemisphere winter temperatures reflects shifts in atmospheric circulation. However, such changes are not inconsistent with anthropogenic forcing and include generally positive phases of the North Atlantic and Arctic Oscillations and extratropical responses to the El-Niño Southern Oscillation. An anthropogenic effect is also suggested from interpretation of the paleoclimate record, which indicates that the 20th century Arctic is the warmest of the past 400 years.},
+	pages = {159--207},
+	number = {1},
+	journaltitle = {Climatic Change},
+	shortjournal = {Climatic Change},
+	author = {Serreze, M. C. and Walsh, J. E. and Chapin {III}, F. S. and Osterkamp, T. and Dyurgerov, M. and Romanovsky, V. and Oechel, W. C. and Morison, J. and Zhang, T. and Barry, R. G.},
+	date = {2000},
+	file = {Serreze et al. - 2000 - Observational Evidence of Recent Change in the Nor.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\A8SBW8KF\\Serreze et al. - 2000 - Observational Evidence of Recent Change in the Nor.pdf:application/pdf}
+}
+
+@article{zhang_spatial_2005,
+	title = {Spatial and temporal variability in active layer thickness over the Russian Arctic drainage basin},
+	volume = {110},
+	issn = {2156-2202},
+	url = {http://onlinelibrary.wiley.com/doi/10.1029/2004JD005642/abstract},
+	doi = {10.1029/2004JD005642},
+	abstract = {Changes in active layer thickness ({ALT}) over northern high-latitude permafrost regions have important impacts on the surface energy balance, hydrologic cycle, carbon exchange between the atmosphere and the land surface, plant growth, and ecosystems as a whole. This study examines the 20th century variations of {ALT} for the Ob, Yenisey, and Lena River basins. {ALT} is estimated from historical soil temperature measurements from 17 stations (1956–1990, Lena basin only), an annual thawing index based on both surface air temperature data (1901–2002) and numerical modeling (1980–2002). The latter two provide spatial fields. Based on the thawing index, the long-term average (1961–1990) {ALT} is about 1.87 m in the Ob, 1.67 in the Yenisey, and 1.69 m in the Lena basin. Over the past several decades, {ALT} over the three basins shows positive trends, but with different magnitudes. Based on the 17 stations, {ALT} increased about 0.32 m between 1956 and 1990 in the Lena. To the extent that results based on the soil temperatures represent ground “truth,” {ALT} obtained from both the thawing index and numerical modeling is underestimated. It is widely believed that {ALT} will increase with global warming. However, this hypothesis needs further refinement since {ALT} responds primarily to summer air temperature while observed warming has occurred mainly in winter and spring. It is also shown that {ALT} exhibits complex and inconsistent responses to variations in snow cover.},
+	pages = {D16101},
+	issue = {D16},
+	journaltitle = {Journal of Geophysical Research: Atmospheres},
+	shortjournal = {J. Geophys. Res.},
+	author = {Zhang, Tingjun and Frauenfeld, Oliver W. and Serreze, Mark C. and Etringer, Andrew and Oelke, Christoph and {McCreight}, James and Barry, Roger G. and Gilichinsky, David and Yang, Daqing and Ye, Hengchun and Ling, Feng and Chudinova, Svetlana},
+	date = {2005-08-27},
+	langid = {english},
+	keywords = {permafrost, 1823 Frozen ground, 1824 Geomorphology: general, 1834 Human impacts, 1863 Snow and ice, active layer, Russian Arctic},
+	file = {Snapshot:C\:\\Users\\Brent Thorne\\Zotero\\storage\\JFQAGW5E\\abstract.html:text/html;Zhang et al. - 2005 - Spatial and temporal variability in active layer t.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\5FU38XED\\Zhang et al. - 2005 - Spatial and temporal variability in active layer t.pdf:application/pdf}
+}
+
+@article{christiansen_thermal_2010,
+	title = {The thermal state of permafrost in the nordic area during the international polar year 2007-2009: Thermal state of permafrost in the Nordic area},
+	volume = {21},
+	issn = {10456740},
+	url = {http://doi.wiley.com/10.1002/ppp.687},
+	doi = {10.1002/ppp.687},
+	shorttitle = {The thermal state of permafrost in the nordic area during the international polar year 2007-2009},
+	pages = {156--181},
+	number = {2},
+	journaltitle = {Permafrost and Periglacial Processes},
+	author = {Christiansen, H. H. and Etzelmüller, B. and Isaksen, K. and Juliussen, H. and Farbrot, H. and Humlum, O. and Johansson, M. and Ingeman-Nielsen, T. and Kristensen, L. and Hjort, J. and Holmlund, P. and Sannel, A. B. K. and Sigsgaard, C. and Åkerman, H. J. and Foged, N. and Blikra, L. H. and Pernosky, M. A. and Ødegård, R. S.},
+	urldate = {2017-08-20},
+	date = {2010-04},
+	langid = {english},
+	file = {Christiansen et al. - 2010 - The thermal state of permafrost in the nordic area.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\LVTFFSK2\\Christiansen et al. - 2010 - The thermal state of permafrost in the nordic area.pdf:application/pdf}
+}
+
+@article{schaefer_remotely_2015,
+	title = {Remotely Sensed Active Layer Thickness ({ReSALT}) at Barrow, Alaska Using Interferometric Synthetic Aperture Radar},
+	volume = {7},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/7/4/3735/},
+	doi = {10.3390/rs70403735},
+	pages = {3735--3759},
+	number = {4},
+	journaltitle = {Remote Sensing},
+	author = {Schaefer, Kevin and Liu, Lin and Parsekian, Andrew and Jafarov, Elchin and Chen, Albert and Zhang, Tingjun and Gusmeroli, Alessio and Panda, Santosh and Zebker, Howard and Schaefer, Tim},
+	urldate = {2017-08-20},
+	date = {2015-03-27},
+	langid = {english},
+	file = {Schaefer et al. - 2015 - Remotely Sensed Active Layer Thickness (ReSALT) at.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\UJDM5XAJ\\Schaefer et al. - 2015 - Remotely Sensed Active Layer Thickness (ReSALT) at.pdf:application/pdf}
+}
+
+@thesis{riglin_perpetual_1977,
+	title = {The Perpetual Landslide, Summerland, British Columbia},
+	institution = {University of British Columbia},
+	type = {Master's Thesis},
+	author = {Riglin, Linda},
+	date = {1977-04},
+	file = {Riglin - 1977 - The Perpetual Landslide, Summerland, British Colum.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\M8EGSI9A\\Riglin - 1977 - The Perpetual Landslide, Summerland, British Colum.pdf:application/pdf}
+}
+
+@article{stone_even_2014,
+	title = {Even for Slide-Prone Region, Landslide Was Off the Chart},
+	volume = {344},
+	url = {http://science.sciencemag.org/content/344/6179/16.short},
+	pages = {16--17},
+	number = {6179},
+	journaltitle = {Science},
+	author = {Stone, Richard and {others}},
+	urldate = {2017-08-09},
+	date = {2014},
+	file = {Stone and others - 2014 - Even for Slide-Prone Region, Landslide Was Off the.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\75HGFCE7\\Stone and others - 2014 - Even for Slide-Prone Region, Landslide Was Off the.pdf:application/pdf}
+}
+
+@article{murphy_use_2016,
+	title = {Use of a Small Unmanned Aerial System for the {SR}-530 Mudslide Incident near Oso, Washington: Use of Small Unmanned Aerial System for {SR}-530 Mudslide Incident near Oso, Washington},
+	volume = {33},
+	issn = {15564959},
+	url = {http://doi.wiley.com/10.1002/rob.21586},
+	doi = {10.1002/rob.21586},
+	shorttitle = {Use of a Small Unmanned Aerial System for the {SR}-530 Mudslide Incident near Oso, Washington},
+	pages = {476--488},
+	number = {4},
+	journaltitle = {Journal of Field Robotics},
+	author = {Murphy, Robin R. and Duncan, Brittany A. and Collins, Tyler and Kendrick, Justin and Lohman, Patrick and Palmer, Tamara and Sanborn, Frank},
+	urldate = {2017-08-09},
+	date = {2016-06},
+	langid = {english},
+	file = {Murphy et al. - 2016 - Use of a Small Unmanned Aerial System for the SR-5.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\U2XXHRV9\\Murphy et al. - 2016 - Use of a Small Unmanned Aerial System for the SR-5.pdf:application/pdf}
+}
+
+@misc{dragovich_geologic_2003,
+	title = {Geologic Map of the Mount Higgins 7.5-minute Quadrangle, Skagit and Snohomish Counties, Washington},
+	url = {http://file.dnr.wa.gov/publications/ger_ofr2003-12_geol_map_mounthiggins_24k.pdf},
+	publisher = {Washington Department of Natural Resources},
+	type = {Topographic},
+	editora = {Dragovich,, Joe and Stanton,, Benjamin and Lingley,, William and Griesel,, Gerry},
+	editoratype = {collaborator},
+	urldate = {2017-08-09},
+	date = {2003},
+	file = {Dragovich, et al. - 2003 - Geologic Map of the Mount Higgins 7.5-minute Quadr.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\F4FK2QTW\\Dragovich, et al. - 2003 - Geologic Map of the Mount Higgins 7.5-minute Quadr.pdf:application/pdf}
+}
+
+@report{haugerud_preliminary_2014,
+	title = {Preliminary Interpretation of Pre-2014 Landslide Deposits in the Vicinity of Oso, Washington},
+	institution = {U.S. Geological Survey},
+	type = {U.S. Geological Survey Open-File Report},
+	author = {Haugerud, Ralph A.},
+	date = {2014},
+	langid = {english},
+	file = {Haugerud - 2014 - Preliminary Interpretation of Pre-2014 Landslide D.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\3R4N67B8\\Haugerud - 2014 - Preliminary Interpretation of Pre-2014 Landslide D.pdf:application/pdf}
+}
+
+@article{wartman_22_2016,
+	title = {The 22 March 2014 Oso landslide, Washington, {USA}},
+	volume = {253},
+	issn = {0169555X},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0169555X15301860},
+	doi = {10.1016/j.geomorph.2015.10.022},
+	pages = {275--288},
+	journaltitle = {Geomorphology},
+	author = {Wartman, Joseph and Montgomery, David R. and Anderson, Scott A. and Keaton, Jeffrey R. and Benoît, Jean and dela Chapelle, John and Gilbert, Robert},
+	urldate = {2017-08-09},
+	date = {2016-01},
+	langid = {english},
+	file = {Wartman et al. - 2016 - The 22 March 2014 Oso landslide, Washington, USA.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ZB3AI2DV\\Wartman et al. - 2016 - The 22 March 2014 Oso landslide, Washington, USA.pdf:application/pdf}
+}
+
+@article{goncalves_concentration_2001,
+	title = {Concentration of photosynthetic pigments and chlorophyll fluorescence of mahogany and tonka bean under two light environments},
+	volume = {13},
+	url = {http://www.scielo.br/scielo.php?pid=S0103-31312001000200004&script=sci_arttext&tlng=es},
+	pages = {149--157},
+	number = {2},
+	journaltitle = {Revista Brasileira de Fisiologia Vegetal},
+	author = {{GONÇALVES}, {JOSÉ} {FRANCISCO} {DE} {CARVALHO} and {MARENCO}, {RICARDO} {ANTONIO} and Vieira, Gil},
+	urldate = {2017-07-31},
+	date = {2001},
+	file = {GONÇALVES et al. - 2001 - Concentration of photosynthetic pigments and chlor.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\3AAZTFZP\\GONÇALVES et al. - 2001 - Concentration of photosynthetic pigments and chlor.pdf:application/pdf}
+}
+
+@article{lamhonwah_multi-year_2016,
+	title = {Multi-year impacts of permafrost disturbance and thermal perturbation on High Arctic stream chemistry},
+	volume = {3},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/full/10.1139/as-2016-0024},
+	doi = {10.1139/as-2016-0024},
+	abstract = {Permafrost disturbances (such as active layer detachment ({ALD}) slides) and thermal perturbation (deep ground thaw from high soil temperatures) alter Arctic surface water chemistry. However, the potential multi-year impacts on water chemistry and the ultimate recovery time are not well understood. This study evaluates the impacts on surface waters and recovery following disturbance of a High Arctic catchment in 2007 from {ALDs}. We measured ion concentrations and stable isotopes in surface waters collected between 2006 and 2014 from paired catchments — one disturbed and the other not. The years 2007 and 2012 were exceptionally warm and represent unusual thermal perturbation for both catchments. Results indicate that the exposure and mobilization of soluble ions in near surface soil is a key control over dissolved ion concentrations and composition following {ALDs}. Runoff in the disturbed catchment shows increased total dissolved solute ({TDS}) concentrations and seasonal {TDS} fluxes and changes to the relative c..., Les perturbations du pergélisol (telles que les glissements causés par le détachement de la couche active ({DCA})) et la perturbation thermique (le dégel du sol en profondeur causé par des températures élevées) changent l’hydrochimie des eaux de surface dans l’Arctique. Cependant, on ne comprend pas bien les impacts potentiels de plusieurs années sur l’hydrochimie ni le temps de rétablissement final. Cette étude évalue les impacts sur les eaux de surface après la perturbation d’un bassin hydrologique du Haut-Arctique en 2007 en raison d’un {DCA} ainsi que le rétablissement. Nous avons mesuré les concentrations d’ions et les isotopes stables dans les eaux de surface recueillies entre 2006 et 2014 provenant de deux bassins hydrologiques appariés — un perturbé et l’autre non. Les années 2007 et 2012 étaient exceptionnellement chaudes et représentent une perturbation thermique inhabituelle des deux bassins hydrologiques. Les résultats indiquent que l’exposition et la mobilisation d’ions solubles dans le sol près ...},
+	pages = {254--276},
+	number = {2},
+	journaltitle = {Arctic Science},
+	shortjournal = {Arctic Science},
+	author = {Lamhonwah, Daniel and Lafrenière, M. J. and Lamoureux, S. F. and Wolfe, B. B.},
+	urldate = {2017-07-20},
+	date = {2016-12-05},
+	file = {Lamhonwah et al. - 2016 - Multi-year impacts of permafrost disturbance and t.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\PTR5CW5H\\Lamhonwah et al. - 2016 - Multi-year impacts of permafrost disturbance and t.pdf:application/pdf;NRC Research Press Snapshot:C\:\\Users\\Brent Thorne\\Zotero\\storage\\NCNBQGUJ\\Lamhonwah et al. - 2016 - Multi-year impacts of permafrost disturbance and t.html:text/html}
+}
+
+@article{lantz_vegetation_2017,
+	title = {Vegetation Succession and Environmental Conditions following Catastrophic Lake Drainage in Old Crow Flats, Yukon},
+	volume = {70},
+	issn = {1923-1245, 0004-0843},
+	url = {http://arctic.journalhosting.ucalgary.ca/arctic/index.php/arctic/article/view/4646},
+	doi = {10.14430/arctic4646},
+	pages = {177},
+	number = {2},
+	journaltitle = {{ARCTIC}},
+	author = {Lantz, Trevor C.},
+	urldate = {2017-07-17},
+	date = {2017-05-31},
+	file = {Lantz - 2017 - Vegetation Succession and Environmental Conditions.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\6HNB3ZPP\\Lantz - 2017 - Vegetation Succession and Environmental Conditions.pdf:application/pdf}
+}
+
+@article{dyke_climate_2000,
+	title = {Climate of the Mackenzie River valley},
+	volume = {547},
+	url = {https://www.researchgate.net/profile/Larry_Dyke2/publication/273380005_Climate_of_the_Mackenzie_River_valley/links/54ff4de80cf2741b69f657d0.pdf},
+	pages = {21--30},
+	journaltitle = {The Physical Environment of the Mackenzie Valley, Northwest Territories: a Baseline for the Assessment of Environmental Change. Ottawa, Ontario: Geological Survey of Canada Bulletin},
+	author = {Dyke, L. D.},
+	urldate = {2017-07-17},
+	date = {2000},
+	file = {Dyke - 2000 - Climate of the Mackenzie River valley.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\T27INN4F\\Dyke - 2000 - Climate of the Mackenzie River valley.pdf:application/pdf}
+}
+
+@misc{heginbottom_canada_1995,
+	title = {Canada Permafrost},
+	url = {http://ftp.geogratis.gc.ca/pub/nrcan_rncan/raster/atlas_5_ed/eng/environment/land/mcr4177.pdf},
+	publisher = {Natural Resources Canada},
+	editora = {Heginbottom, J.A.},
+	editoratype = {collaborator},
+	urldate = {2017-07-17},
+	date = {1995},
+	file = {Heginbottom - 1995 - Canada Permafrost.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\N83438FX\\Heginbottom - 1995 - Canada Permafrost.pdf:application/pdf}
+}
+
+@article{lantz_changes_2015,
+	title = {Changes in lake area in response to thermokarst processes and climate in Old Crow Flats, Yukon},
+	volume = {120},
+	issn = {2169-8961},
+	url = {http://onlinelibrary.wiley.com/doi/10.1002/2014JG002744/abstract},
+	doi = {10.1002/2014JG002744},
+	abstract = {Growing evidence indicates that lake-dominated ecosystems at high latitudes are undergoing significant hydrological changes. Research examining these changes is complicated because both thermokarst and climatic processes likely influence lake dynamics. To examine the relative impacts of these processes in permafrost landscapes, we investigated the dynamics of lake area and number in Old Crow Flats ({OCF}), Yukon using historical air photos and satellite imagery. Between 1951 and 2007, {OCF} experienced a decline of {\textasciitilde}6000 ha in total lake area but gained 232 lakes. Close to half (49\%) of the difference in lake area was driven by the rapid and persistent drainage of 38 large lakes. These catastrophic drainages were associated with new or enlarged outlet channels, resulted in the formation of numerous residual ponds, and were likely driven by thermokarst processes. Our analysis shows that catastrophic lake drainages have become more than 5 times more frequent in recent decades. These changes are likely related to the impacts of increased temperature and precipitation on thermokarst processes. Fifty-nine of the 170 intensively studied lakes showed either large bidirectional fluctuations or gradual cumulative declines. These changes affected a much smaller portion of {OCF} and were likely driven by interactions between increased precipitation and temperature and individual catchment characteristics. To anticipate landscape-scale changes in these systems, and assess their impact on hydrology, wildlife habitat, and carbon storage, field research is required to better characterize the mechanisms responsible for changes.},
+	pages = {2014JG002744},
+	number = {3},
+	journaltitle = {Journal of Geophysical Research: Biogeosciences},
+	shortjournal = {J. Geophys. Res. Biogeosci.},
+	author = {Lantz, T. C. and Turner, K. W.},
+	date = {2015-03-01},
+	langid = {english},
+	keywords = {permafrost, 0497 Wetlands, 0475 Permafrost, cryosphere, and high-latitude processes, 0480 Remote sensing, 1807 Climate impacts, air photos, global change, thermokarst},
+	file = {Lantz and Turner - 2015 - Changes in lake area in response to thermokarst pr.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\N8IK6QTM\\Lantz and Turner - 2015 - Changes in lake area in response to thermokarst pr.pdf:application/pdf}
+}
+
+@unpublished{bouchard_isotopic_2013,
+	location = {Ottawa, {ON}},
+	title = {Isotopic evidence for recent hydrological shifts in source waters of shallow lakes in northern freshwater landscapes.},
+	abstract = {In northern Canada, shallow-lake-rich freshwater landscapes provide key habitat for many wildlife species and play a vital role in the traditional use of the land by local indigenous communities. Changes in precipitation have the potential to substantially alter the hydrological conditions of these shallow lakes. Here we compare multiple years of measurements of lake water oxygen isotope composition (δ18Omes) with surface sediment cellulose-inferred lake water oxygen isotope composition (δ18Oinf) for {\textasciitilde}80 lakes in two of Canada’s largest lake-rich thermokarst landscapes – Old Crow Flats ({OCF}), Yukon, and western Hudson Bay Lowlands ({HBL}), Manitoba. Results reveal a strikingly coherent pattern of recent hydrological change in these two landscapes. In {OCF}, δ18Oinf values from snowmelt-dominated lakes align reasonably well with the 2007-2008 δ18Omes values from the early ice-free season, as expected. In contrast, δ18Oinf from rainfall-dominated lakes are systematically lower (i.e., more 18O-depleted) relative to δ18Omes. Climate data indicate that the winter of 2007-08 had markedly lower snowfall compared to the long-term mean, whereas winters immediately prior to our water sample collections were characterized by snowfall equal to or greater than the long-term mean. Thus, we speculate that the isotopic offset between δ18Oinf and δ18Omes for some of the lakes is due to a shift to more rainfall-dominated precipitation. Similar results have been obtained from lakes in {HBL}. Here too, about 40\% of the sampled lakes contain δ18Oinf values that are lower than δ18Omes values from 2010-2012, which may also reflect a recent shift to more rainfall-dominated precipitation. These findings suggest that some lakes in our study areas received less snowmelt during the water sampling years in comparison to the time interval captured in the surface-sediments. Notably, a few lakes in {HBL} lost all of their water to evaporation during mid-summer 2010, fuelling concerns that reduction in snowmelt and an increase in the length of the ice-free season in these landscapes may lead to an increase in the occurrence of lake desiccation.},
+	type = {Conference},
+	howpublished = {Conference},
+	note = {{PALS} 2013},
+	author = {Bouchard, Frederic},
+	editora = {Deakin, C. and Turner, Kevin W. and White, H.E. and Macdonald, Lauren and Medeiros, Andrew and Wolfe, Brent B. and Hall, Roland I. and Pienitz, Reinhard},
+	editoratype = {collaborator},
+	date = {2013},
+	file = {Bouchard - 2013 - Isotopic evidence for recent hydrological shifts i.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ISPJ397I\\Bouchard - 2013 - Isotopic evidence for recent hydrological shifts i.pdf:application/pdf}
+}
+
+@book{reeuwijk_procedures_2002,
+	location = {Wageningen},
+	edition = {6. ed},
+	title = {Procedures for soil analysis},
+	isbn = {978-90-6672-044-2},
+	series = {Technical paper / International Soil Reference an Information Centre},
+	number = {9},
+	publisher = {International Soil Reference and Information Centre},
+	author = {Reeuwijk, L. P. van},
+	date = {2002},
+	note = {{OCLC}: 248862095},
+	file = {Reeuwijk - 2002 - Procedures for soil analysis.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\TRHHI2KR\\Reeuwijk - 2002 - Procedures for soil analysis.pdf:application/pdf}
+}
+
+@article{consortium_global_2017,
+	title = {A global multiproxy database for temperature reconstructions of the Common Era},
+	volume = {4},
+	rights = {2017 Nature Publishing Group},
+	issn = {2052-4463},
+	url = {https://www.nature.com/articles/sdata201788},
+	doi = {10.1038/sdata.2017.88},
+	abstract = {Data Descriptor},
+	pages = {sdata201788},
+	journaltitle = {Scientific Data},
+	author = {Consortium, {PAGES}2k and Emile-Geay, Julien and {McKay}, Nicholas P. and Kaufman, Darrell S. and Gunten, Lucien von and Wang, Jianghao and Anchukaitis, Kevin J. and Abram, Nerilie J. and Addison, Jason A. and Curran, Mark A. J. and Evans, Michael N. and Henley, Benjamin J. and Hao, Zhixin and Martrat, Belen and {McGregor}, Helen V. and Neukom, Raphael and Pederson, Gregory T. and Stenni, Barbara and Thirumalai, Kaustubh and Werner, Johannes P. and Xu, Chenxi and Divine, Dmitry V. and Dixon, Bronwyn C. and Gergis, Joelle and Mundo, Ignacio A. and Nakatsuka, Takeshi and Phipps, Steven J. and Routson, Cody C. and Steig, Eric J. and Tierney, Jessica E. and Tyler, Jonathan J. and Allen, Kathryn J. and Bertler, Nancy A. N. and Björklund, Jesper and Chase, Brian M. and Chen, Min-Te and Cook, Ed and Jong, Rixt de and {DeLong}, Kristine L. and Dixon, Daniel A. and Ekaykin, Alexey A. and Ersek, Vasile and Filipsson, Helena L. and Francus, Pierre and Freund, Mandy B. and Frezzotti, Massimo and Gaire, Narayan P. and Gajewski, Konrad and Ge, Quansheng and Goosse, Hugues and Gornostaeva, Anastasia and Grosjean, Martin and Horiuchi, Kazuho and Hormes, Anne and Husum, Katrine and Isaksson, Elisabeth and Kandasamy, Selvaraj and Kawamura, Kenji and Kilbourne, K. Halimeda and Koç, Nalan and Leduc, Guillaume and Linderholm, Hans W. and Lorrey, Andrew M. and Mikhalenko, Vladimir and Mortyn, P. Graham and Motoyama, Hideaki and Moy, Andrew D. and Mulvaney, Robert and Munz, Philipp M. and Nash, David J. and Oerter, Hans and Opel, Thomas and Orsi, Anais J. and Ovchinnikov, Dmitriy V. and Porter, Trevor J. and Roop, Heidi A. and Saenger, Casey and Sano, Masaki and Sauchyn, David and Saunders, Krystyna M. and Seidenkrantz, Marit-Solveig and Severi, Mirko and Shao, Xuemei and Sicre, Marie-Alexandrine and Sigl, Michael and Sinclair, Kate and George, Scott St and Jacques, Jeannine-Marie St and Thamban, Meloth and Thapa, Udya Kuwar and Thomas, Elizabeth R. and Turney, Chris and Uemura, Ryu and Viau, Andre E. and Vladimirova, Diana O. and Wahl, Eugene R. and White, James W. C. and Yu, Zicheng and Zinke, Jens},
+	urldate = {2017-07-12},
+	date = {2017-07-11},
+	langid = {english},
+	file = {Consortium et al. - 2017 - A global multiproxy database for temperature recon.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\V9X5BRUF\\Consortium et al. - 2017 - A global multiproxy database for temperature recon.pdf:application/pdf;Snapshot:C\:\\Users\\Brent Thorne\\Zotero\\storage\\GCREN8I7\\Consortium et al. - 2017 - A global multiproxy database for temperature recon.html:text/html}
+}
+
+@article{walvoord_increased_2007,
+	title = {Increased groundwater to stream discharge from permafrost thawing in the Yukon River basin: Potential impacts on lateral export of carbon and nitrogen},
+	volume = {34},
+	issn = {0094-8276},
+	url = {http://doi.wiley.com/10.1029/2007GL030216},
+	doi = {10.1029/2007GL030216},
+	shorttitle = {Increased groundwater to stream discharge from permafrost thawing in the Yukon River basin},
+	number = {12},
+	journaltitle = {Geophysical Research Letters},
+	author = {Walvoord, Michelle A. and Striegl, Robert G.},
+	urldate = {2017-07-12},
+	date = {2007-06-28},
+	langid = {english},
+	file = {Walvoord and Striegl - 2007 - Increased groundwater to stream discharge from per.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\K9HFZCT5\\Walvoord and Striegl - 2007 - Increased groundwater to stream discharge from per.pdf:application/pdf}
+}
+
+@article{tunaley_scaling_2017,
+	title = {Scaling effects of riparian peatlands on stable isotopes in runoff and {DOC} mobilisation},
+	volume = {549},
+	issn = {00221694},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0022169417301956},
+	doi = {10.1016/j.jhydrol.2017.03.056},
+	pages = {220--235},
+	journaltitle = {Journal of Hydrology},
+	author = {Tunaley, C. and Tetzlaff, D. and Soulsby, C.},
+	urldate = {2017-07-12},
+	date = {2017-06},
+	langid = {english},
+	file = {Tunaley et al. - 2017 - Scaling effects of riparian peatlands on stable is.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\473I62RG\\Tunaley et al. - 2017 - Scaling effects of riparian peatlands on stable is.pdf:application/pdf}
+}
+
+@article{wissel_new_2008,
+	title = {A new approach for the isolation of cellulose from aquatic plant tissue and freshwater sediments for stable isotope analysis},
+	volume = {39},
+	issn = {01466380},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0146638008002398},
+	doi = {10.1016/j.orggeochem.2008.07.014},
+	pages = {1545--1561},
+	number = {11},
+	journaltitle = {Organic Geochemistry},
+	author = {Wissel, Holger and Mayr, Christoph and Lücke, Andreas},
+	urldate = {2017-07-12},
+	date = {2008-11},
+	langid = {english},
+	file = {Wissel et al. - 2008 - A new approach for the isolation of cellulose from.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\C88UXPZF\\Wissel et al. - 2008 - A new approach for the isolation of cellulose from.pdf:application/pdf}
+}
+
+@book{speer_fundamentals_2010,
+	location = {Tucson},
+	title = {Fundamentals of tree-ring research},
+	isbn = {978-0-8165-2684-0},
+	pagetotal = {333},
+	publisher = {University of Arizona Press},
+	author = {Speer, James H.},
+	date = {2010},
+	note = {{OCLC}: ocn460061751},
+	keywords = {Dendrochronology, Growth, Tree-rings, Trees, Wood},
+	file = {Speer - 2010 - Fundamentals of tree-ring research.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ZUQ5JRRD\\Speer - 2010 - Fundamentals of tree-ring research.pdf:application/pdf}
+}
+
+@article{arnon_copper_1949,
+	title = {Copper enzymes in isolated chloroplasts. Polyphenoloxidase in Beta vulgaris},
+	volume = {24},
+	url = {https://www.ncbi.nlm.nih.gov/pmc/articles/pmc437905/},
+	pages = {1},
+	number = {1},
+	journaltitle = {Plant physiology},
+	author = {Arnon, Daniel I.},
+	urldate = {2017-07-12},
+	date = {1949},
+	file = {Plant Physiology (Arnon, 1948).pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\B28EETIK\\Plant Physiology (Arnon, 1948).pdf:application/pdf}
+}
+
+@inproceedings{shibghatallah_measuring_2013,
+	title = {Measuring leaf chlorophyll concentration from its color: A way in monitoring environment change to plantations},
+	volume = {1554},
+	url = {http://aip.scitation.org/doi/abs/10.1063/1.4820322},
+	shorttitle = {Measuring leaf chlorophyll concentration from its color},
+	pages = {210--213},
+	booktitle = {{AIP} Conference Proceedings},
+	publisher = {{AIP}},
+	author = {Shibghatallah, Muhammad Abdul Hakim and Khotimah, Siti Nurul and Suhandono, Sony and Viridi, Sparisoma and Kesuma, Teja},
+	urldate = {2017-07-12},
+	date = {2013},
+	file = {Measuring Leaf Chlorophyll Concentration from Its Color.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ZV5ZSSFP\\Measuring Leaf Chlorophyll Concentration from Its Color.pdf:application/pdf}
+}
+
+@article{balasubramaniam_source_2015,
+	title = {Source water inputs and catchment characteristics regulate limnological conditions of shallow subarctic lakes (Old Crow Flats, Yukon, Canada)},
+	volume = {72},
+	issn = {0706-652X, 1205-7533},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/cjfas-2014-0340},
+	doi = {10.1139/cjfas-2014-0340},
+	pages = {1058--1072},
+	number = {7},
+	journaltitle = {Canadian Journal of Fisheries and Aquatic Sciences},
+	author = {Balasubramaniam, Ann M. and Hall, Roland I. and Wolfe, Brent B. and Sweetman, Jon N. and Wang, Xiaowa and Smith, Ralph},
+	urldate = {2017-07-11},
+	date = {2015-07},
+	langid = {english},
+	file = {Balasubramaniam et al. - 2015 - Source water inputs and catchment characteristics .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\6AHUH3SG\\Balasubramaniam et al. - 2015 - Source water inputs and catchment characteristics .pdf:application/pdf}
+}
+
+@article{ahmed_hierarchical_2017,
+	title = {Hierarchical land cover and vegetation classification using multispectral data acquired from an unmanned aerial vehicle},
+	volume = {38},
+	pages = {2037--2052},
+	number = {8},
+	journaltitle = {International Journal of Remote Sensing},
+	author = {Ahmed, Oumer S. and Shemrock, Adam and Chabot, Dominique and Dillon, Chris and Williams, Griffin and Wasson, Rachel and Franklin, Steven E.},
+	date = {2017},
+	file = {Ahmed et al. - 2017 - Hierarchical land cover and vegetation classificat.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\IVAKQGUK\\Ahmed et al. - 2017 - Hierarchical land cover and vegetation classificat.pdf:application/pdf}
+}
+
+@thesis{myers-smith_shrub_2011,
+	title = {Shrub encroachment in arctic and alpine tundra: Patterns of expansion and ecosystem impacts.},
+	url = {https://era.library.ualberta.ca/files/df65v836z},
+	shorttitle = {Shrub encroachment in arctic and alpine tundra},
+	type = {phdthesis},
+	author = {Myers-Smith, Isla H.},
+	urldate = {2017-07-11},
+	date = {2011},
+	file = {Myers-Smith - 2011 - Shrub encroachment in arctic and alpine tundra Pa.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\3T9BCR66\\Myers-Smith - 2011 - Shrub encroachment in arctic and alpine tundra Pa.pdf:application/pdf}
+}
+
+@thesis{blok_shrubs_nodate,
+	title = {Shrubs in the cold: interactions between vegetation, permafrost and climate in Siberian tundra},
+	shorttitle = {Shrubs in the cold},
+	pagetotal = {152},
+	type = {phdthesis},
+	author = {Blok, Daan},
+	note = {{OCLC}: 930839610},
+	file = {Blok - Shrubs in the cold interactions between vegetatio.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\5XSARGGZ\\Blok - Shrubs in the cold interactions between vegetatio.pdf:application/pdf}
+}
+
+@article{schwartz_dating_2005,
+	title = {Dating the Growth of Oceanic Crust at a Slow-Spreading Ridge},
+	volume = {310},
+	issn = {0036-8075, 1095-9203},
+	url = {http://www.sciencemag.org/cgi/doi/10.1126/science.1116349},
+	doi = {10.1126/science.1116349},
+	pages = {654--657},
+	number = {5748},
+	journaltitle = {Science},
+	author = {Schwartz, J. J.},
+	urldate = {2017-07-11},
+	date = {2005-10-28},
+	langid = {english},
+	file = {Schwartz - 2005 - Dating the Growth of Oceanic Crust at a Slow-Sprea.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\GUADV58E\\Schwartz - 2005 - Dating the Growth of Oceanic Crust at a Slow-Sprea.pdf:application/pdf}
+}
+
+@article{castilla_we_2016,
+	title = {We Must all Pay More Attention to Rigor in Accuracy Assessment: Additional Comment to “The Improvement of Land Cover Classification by Thermal Remote Sensing”. Remote Sens. 2015, 7, 8368–8390},
+	volume = {8},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/8/4/288},
+	doi = {10.3390/rs8040288},
+	shorttitle = {We Must all Pay More Attention to Rigor in Accuracy Assessment},
+	pages = {288},
+	number = {4},
+	journaltitle = {Remote Sensing},
+	author = {Castilla, Guillermo},
+	urldate = {2017-07-11},
+	date = {2016-03-26},
+	langid = {english},
+	file = {Castilla - 2016 - We Must all Pay More Attention to Rigor in Accurac.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\V9PG28IA\\Castilla - 2016 - We Must all Pay More Attention to Rigor in Accurac.pdf:application/pdf}
+}
+
+@article{wolfe_environmental_2011,
+	title = {Environmental change and traditional use of the Old Crow Flats in northern Canada: an {IPY} opportunity to meet the challenges of the new northern research paradigm},
+	volume = {64},
+	url = {http://search.proquest.com/openview/09405a4d127d9f97d6eb37ae2598ef8b/1?pq-origsite=gscholar&cbl=40958},
+	shorttitle = {Environmental change and traditional use of the Old Crow Flats in northern Canada},
+	pages = {127},
+	number = {1},
+	journaltitle = {Arctic},
+	author = {Wolfe, Brent B. and Humphries, Murray M. and Pisaric, Michael FJ and Balasubramaniam, Ann M. and Burn, Chris R. and Chan, Laurie and Cooley, Dorothy and Froese, Duane G. and Graupe, Shel and Hall, Roland I. and {others}},
+	urldate = {2017-07-11},
+	date = {2011},
+	file = {Wolfe et al. - 2011 - Environmental change and traditional use of the Ol.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ZPA2CX36\\Wolfe et al. - 2011 - Environmental change and traditional use of the Ol.pdf:application/pdf}
+}
+
+@article{turner_characterizing_2010,
+	title = {Characterizing the role of hydrological processes on lake water balances in the Old Crow Flats, Yukon Territory, Canada, using water isotope tracers},
+	volume = {386},
+	issn = {00221694},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0022169410001381},
+	doi = {10.1016/j.jhydrol.2010.03.012},
+	pages = {103--117},
+	number = {1},
+	journaltitle = {Journal of Hydrology},
+	author = {Turner, Kevin W. and Wolfe, Brent B. and Edwards, Thomas W.D.},
+	urldate = {2017-07-11},
+	date = {2010-05},
+	langid = {english},
+	file = {Turner 2010 Characterising the role of hydrological process - OCF.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\CBN6I3K8\\Turner 2010 Characterising the role of hydrological process - OCF.pdf:application/pdf}
+}
+
+@article{sturm_changing_2005,
+	title = {Changing snow and shrub conditions affect albedo with global implications},
+	volume = {110},
+	issn = {0148-0227},
+	url = {http://doi.wiley.com/10.1029/2005JG000013},
+	doi = {10.1029/2005JG000013},
+	issue = {G1},
+	journaltitle = {Journal of Geophysical Research},
+	author = {Sturm, Matthew},
+	urldate = {2017-07-11},
+	date = {2005},
+	langid = {english},
+	file = {Sturm - 2005 - Changing snow and shrub conditions affect albedo w.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4MWJX3K3\\Sturm - 2005 - Changing snow and shrub conditions affect albedo w.pdf:application/pdf}
+}
+
+@article{sturm_snowshrub_2001,
+	title = {Snow–shrub interactions in Arctic tundra: a hypothesis with climatic implications},
+	volume = {14},
+	url = {http://journals.ametsoc.org/doi/abs/10.1175/1520-0442(2001)014%3C0336:SSIIAT%3E2.0.CO%3B2},
+	shorttitle = {Snow–shrub interactions in Arctic tundra},
+	pages = {336--344},
+	number = {3},
+	journaltitle = {Journal of Climate},
+	author = {Sturm, Matthew and Holmgren, Jon and {McFadden}, Joseph P. and Liston, Glen E. and Chapin {III}, F. Stuart and Racine, Charles H.},
+	urldate = {2017-07-11},
+	date = {2001},
+	file = {Sturm et al. - 2001 - Snow–shrub interactions in Arctic tundra a hypoth.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\UKAKDNPV\\Sturm et al. - 2001 - Snow–shrub interactions in Arctic tundra a hypoth.pdf:application/pdf}
+}
+
+@article{blok_shrub_2010,
+	title = {Shrub expansion may reduce summer permafrost thaw in Siberian tundra},
+	volume = {16},
+	issn = {13541013, 13652486},
+	url = {http://doi.wiley.com/10.1111/j.1365-2486.2009.02110.x},
+	doi = {10.1111/j.1365-2486.2009.02110.x},
+	pages = {1296--1305},
+	number = {4},
+	journaltitle = {Global Change Biology},
+	author = {Blok, D. and Heijmans, M. M. P. D. and Schaepman-Strub, G. and Kononov, A. V. and Maximov, T. C. and Berendse, F.},
+	urldate = {2017-07-11},
+	date = {2010-04},
+	langid = {english},
+	file = {Blok et al. - 2010 - Shrub expansion may reduce summer permafrost thaw .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\35FI3H4X\\Blok et al. - 2010 - Shrub expansion may reduce summer permafrost thaw .pdf:application/pdf}
+}
+
+@article{beck_corrigendum:_2012,
+	title = {Corrigendum: Satellite observations of high northern latitude vegetation productivity changes between 1982 and 2008: ecological variability and regional differences},
+	volume = {7},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/7/i=2/a=029501?key=crossref.71b082981f4be8dfd192909a1eabddbf},
+	doi = {10.1088/1748-9326/7/2/029501},
+	shorttitle = {Corrigendum},
+	pages = {029501},
+	number = {2},
+	journaltitle = {Environmental Research Letters},
+	author = {Beck, Pieter S A and Goetz, Scott J},
+	urldate = {2017-07-11},
+	date = {2012-06-01},
+	file = {Beck and Goetz - 2012 - Corrigendum Satellite observations of high northe.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\4RRV3R4Z\\Beck and Goetz - 2012 - Corrigendum Satellite observations of high northe.pdf:application/pdf}
+}
+
+@article{paradis_greater_2016,
+	title = {Greater effect of increasing shrub height on winter versus summer soil temperature},
+	volume = {11},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/11/i=8/a=085005?key=crossref.7b7752b09481fb6d33045327abdd3395},
+	doi = {10.1088/1748-9326/11/8/085005},
+	pages = {085005},
+	number = {8},
+	journaltitle = {Environmental Research Letters},
+	author = {Paradis, Mélissa and Lévesque, Esther and Boudreau, Stéphane},
+	urldate = {2017-07-11},
+	date = {2016-08-01},
+	file = {Paradis et al. - 2016 - Greater effect of increasing shrub height on winte.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\HCJANEGX\\Paradis et al. - 2016 - Greater effect of increasing shrub height on winte.pdf:application/pdf}
+}
+
+@article{naito_patterns_2011,
+	title = {Patterns and processes of global shrub expansion},
+	volume = {35},
+	issn = {0309-1333, 1477-0296},
+	url = {http://journals.sagepub.com/doi/10.1177/0309133311403538},
+	doi = {10.1177/0309133311403538},
+	pages = {423--442},
+	number = {4},
+	journaltitle = {Progress in Physical Geography},
+	author = {Naito, Adam T. and Cairns, David M.},
+	urldate = {2017-07-11},
+	date = {2011-08},
+	langid = {english},
+	file = {Naito and Cairns - 2011 - Patterns and processes of global shrub expansion.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\5G8NZ9QP\\Naito and Cairns - 2011 - Patterns and processes of global shrub expansion.pdf:application/pdf}
+}
+
+@article{myers-smith_shrub_2011-1,
+	title = {Shrub expansion in tundra ecosystems: dynamics, impacts and research priorities},
+	volume = {6},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/6/i=4/a=045509?key=crossref.3e2b3e3172ca6f9fc39a607c137b880f},
+	doi = {10.1088/1748-9326/6/4/045509},
+	shorttitle = {Shrub expansion in tundra ecosystems},
+	pages = {045509},
+	number = {4},
+	journaltitle = {Environmental Research Letters},
+	author = {Myers-Smith, Isla H and Forbes, Bruce C and Wilmking, Martin and Hallinger, Martin and Lantz, Trevor and Blok, Daan and Tape, Ken D and Macias-Fauria, Marc and Sass-Klaassen, Ute and Lévesque, Esther and Boudreau, Stéphane and Ropars, Pascale and Hermanutz, Luise and Trant, Andrew and Collier, Laura Siegwart and Weijers, Stef and Rozema, Jelte and Rayback, Shelly A and Schmidt, Niels Martin and Schaepman-Strub, Gabriela and Wipf, Sonja and Rixen, Christian and Ménard, Cécile B and Venn, Susanna and Goetz, Scott and Andreu-Hayles, Laia and Elmendorf, Sarah and Ravolainen, Virve and Welker, Jeffrey and Grogan, Paul and Epstein, Howard E and Hik, David S},
+	urldate = {2017-07-11},
+	date = {2011-12-01},
+	file = {Myers-Smith et al. - 2011 - Shrub expansion in tundra ecosystems dynamics, im.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\GRPDSF39\\Myers-Smith et al. - 2011 - Shrub expansion in tundra ecosystems dynamics, im.pdf:application/pdf}
+}
+
+@article{loranty_tundra_2011,
+	title = {Tundra vegetation effects on pan-Arctic albedo},
+	volume = {6},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/6/i=2/a=029601?key=crossref.2e8808c62dac2c1672cede1d420f86fa},
+	doi = {10.1088/1748-9326/6/2/029601},
+	pages = {029601},
+	number = {2},
+	journaltitle = {Environmental Research Letters},
+	author = {Loranty, Michael M and Goetz, Scott J and Beck, Pieter S A},
+	urldate = {2017-07-11},
+	date = {2011-06-01},
+	file = {Loranty et al. - 2011 - Tundra vegetation effects on pan-Arctic albedo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\CG2CSWIX\\Loranty et al. - 2011 - Tundra vegetation effects on pan-Arctic albedo.pdf:application/pdf}
+}
+
+@article{liston_modelled_2002,
+	title = {Modelled changes in arctic tundra snow, energy and moisture fluxes due to increased shrubs},
+	volume = {8},
+	url = {http://onlinelibrary.wiley.com/doi/10.1046/j.1354-1013.2001.00416.x/full},
+	pages = {17--32},
+	number = {1},
+	journaltitle = {Global Change Biology},
+	author = {Liston, Glen E. and Mcfadden, Joseph P. and Sturm, Matthew and Pielke, Roger A.},
+	urldate = {2017-07-11},
+	date = {2002},
+	file = {Liston et al. - 2002 - Modelled changes in arctic tundra snow, energy and.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\2H8GSEDM\\Liston et al. - 2002 - Modelled changes in arctic tundra snow, energy and.pdf:application/pdf}
+}
+
+@article{lantz_response_2010,
+	title = {Response of green alder (Alnus viridis subsp. fruticosa) patch dynamics and plant community composition to fire and regional temperature in north-western Canada: Response of vegetation to fire and regional climate},
+	issn = {03050270, 13652699},
+	url = {http://doi.wiley.com/10.1111/j.1365-2699.2010.02317.x},
+	doi = {10.1111/j.1365-2699.2010.02317.x},
+	shorttitle = {Response of green alder (Alnus viridis subsp. fruticosa) patch dynamics and plant community composition to fire and regional temperature in north-western Canada},
+	pages = {no--no},
+	journaltitle = {Journal of Biogeography},
+	author = {Lantz, Trevor C. and Gergel, Sarah E. and Henry, Greg H. R.},
+	urldate = {2017-07-11},
+	date = {2010-05},
+	langid = {english},
+	file = {Lantz et al. - 2010 - Response of green alder (Alnus viridis subsp. frut.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\U473UEV5\\Lantz et al. - 2010 - Response of green alder (Alnus viridis subsp. frut.pdf:application/pdf}
+}
+
+@article{lantz_relative_2009,
+	title = {Relative impacts of disturbance and temperature: persistent changes in microenvironment and vegetation in retrogressive thaw slumps},
+	volume = {15},
+	issn = {13541013, 13652486},
+	url = {http://doi.wiley.com/10.1111/j.1365-2486.2009.01917.x},
+	doi = {10.1111/j.1365-2486.2009.01917.x},
+	shorttitle = {Relative impacts of disturbance and temperature},
+	pages = {1664--1675},
+	number = {7},
+	journaltitle = {Global Change Biology},
+	author = {Lantz, Trevor C. and Kokelj, Steven V. and Gergel, Sarah E. and Henry, Greg H. R.},
+	urldate = {2017-07-11},
+	date = {2009-07},
+	langid = {english},
+	file = {Lantz et al. - 2009 - Relative impacts of disturbance and temperature p.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\7KFTF2Z5\\Lantz et al. - 2009 - Relative impacts of disturbance and temperature p.pdf:application/pdf}
+}
+
+@article{korosi_broad-scale_2017,
+	title = {Broad-scale lake expansion and flooding inundates essential wood bison habitat},
+	volume = {8},
+	issn = {2041-1723},
+	url = {http://www.nature.com/doifinder/10.1038/ncomms14510},
+	doi = {10.1038/ncomms14510},
+	pages = {14510},
+	journaltitle = {Nature Communications},
+	author = {Korosi, Jennifer B. and Thienpont, Joshua R. and Pisaric, Michael F. J. and {deMontigny}, Peter and Perreault, Joelle T. and {McDonald}, Jamylynn and Simpson, Myrna J. and Armstrong, Terry and Kokelj, Steven V. and Smol, John P. and Blais, Jules M.},
+	urldate = {2017-07-11},
+	date = {2017-02-23},
+	file = {Korosi et al. - 2017 - Broad-scale lake expansion and flooding inundates .pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\8J5JH3BH\\Korosi et al. - 2017 - Broad-scale lake expansion and flooding inundates .pdf:application/pdf}
+}
+
+@article{hallinger_establishing_2010,
+	title = {Establishing a missing link: warm summers and winter snow cover promote shrub expansion into alpine tundra in Scandinavia},
+	volume = {186},
+	issn = {0028646X},
+	url = {http://doi.wiley.com/10.1111/j.1469-8137.2010.03223.x},
+	doi = {10.1111/j.1469-8137.2010.03223.x},
+	shorttitle = {Establishing a missing link},
+	pages = {890--899},
+	number = {4},
+	journaltitle = {New Phytologist},
+	author = {Hallinger, Martin and Manthey, Michael and Wilmking, Martin},
+	urldate = {2017-07-11},
+	date = {2010-06},
+	langid = {english},
+	file = {Hallinger et al. - 2010 - Establishing a missing link warm summers and wint.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\T2IXWH6W\\Hallinger et al. - 2010 - Establishing a missing link warm summers and wint.pdf:application/pdf}
+}
+
+@article{johnstone_environmental_2008,
+	title = {Environmental conditions and vegetation recovery at abandoned drilling mud sumps in the Mackenzie Delta region, Northwest Territories, Canada},
+	url = {http://www.jstor.org/stable/40513206},
+	pages = {199--211},
+	journaltitle = {Arctic},
+	author = {Johnstone, Jill F. and Kokelj, Steven V.},
+	urldate = {2017-07-11},
+	date = {2008},
+	file = {Johnstone and Kokelj - 2008 - Environmental conditions and vegetation recovery a.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\PUAK44TF\\Johnstone and Kokelj - 2008 - Environmental conditions and vegetation recovery a.pdf:application/pdf}
+}
+
+@article{kemper_directional_2009,
+	title = {Directional change in upland tundra plant communities 20-30 years after seismic exploration in the Canadian low-arctic},
+	volume = {20},
+	url = {http://onlinelibrary.wiley.com/doi/10.1111/j.1654-1103.2009.01069.x/full},
+	pages = {557--567},
+	number = {3},
+	journaltitle = {Journal of Vegetation Science},
+	author = {Kemper, J. Todd and Macdonald, S. Ellen},
+	urldate = {2017-07-11},
+	date = {2009},
+	file = {Kemper and Macdonald - 2009 - Directional change in upland tundra plant communit.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\SEJPMQPM\\Kemper and Macdonald - 2009 - Directional change in upland tundra plant communit.pdf:application/pdf}
+}
+
+@article{dial_changes_2007,
+	title = {Changes in the alpine forest-tundra ecotone commensurate with recent warming in southcentral Alaska: Evidence from orthophotos and field plots: {TREE} {LINE} {CHANGES} {IN} {SOUTHCENTRAL} {ALASKA}},
+	volume = {112},
+	issn = {01480227},
+	url = {http://doi.wiley.com/10.1029/2007JG000453},
+	doi = {10.1029/2007JG000453},
+	shorttitle = {Changes in the alpine forest-tundra ecotone commensurate with recent warming in southcentral Alaska},
+	pages = {n/a--n/a},
+	issue = {G4},
+	journaltitle = {Journal of Geophysical Research: Biogeosciences},
+	author = {Dial, Roman J. and Berg, Edward E. and Timm, Katriina and {McMahon}, Alissa and Geck, Jason},
+	urldate = {2017-07-11},
+	date = {2007-12},
+	langid = {english},
+	file = {Dial et al. - 2007 - Changes in the alpine forest-tundra ecotone commen.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\NV4FKNGN\\Dial et al. - 2007 - Changes in the alpine forest-tundra ecotone commen.pdf:application/pdf}
+}
+
+@article{dahlgren_age_2016,
+	title = {Age distributions of Greenlandic dwarf shrubs support concept of negligible actuarial senescence},
+	volume = {7},
+	issn = {21508925},
+	url = {http://doi.wiley.com/10.1002/ecs2.1521},
+	doi = {10.1002/ecs2.1521},
+	pages = {e01521},
+	number = {10},
+	journaltitle = {Ecosphere},
+	author = {Dahlgren, Johan P. and Rizzi, Silvia and Schweingruber, Fritz H. and Hellmann, Lena and Büntgen, Ulf},
+	urldate = {2017-07-11},
+	date = {2016-10},
+	langid = {english},
+	file = {Dahlgren_et_al-2016-Ecosphere.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\7G34882A\\Dahlgren_et_al-2016-Ecosphere.pdf:application/pdf}
+}
+
+@article{fraser_uav_2016,
+	title = {{UAV} photogrammetry for mapping vegetation in the low-Arctic},
+	volume = {2},
+	issn = {2368-7460},
+	url = {http://www.nrcresearchpress.com/doi/10.1139/as-2016-0008},
+	doi = {10.1139/as-2016-0008},
+	pages = {79--102},
+	number = {3},
+	journaltitle = {Arctic Science},
+	author = {Fraser, Robert H. and Olthof, Ian and Lantz, Trevor C. and Schmitt, Carla},
+	urldate = {2017-07-11},
+	date = {2016-09},
+	langid = {english},
+	file = {Fraser et al. - 2016 - UAV photogrammetry for mapping vegetation in the l.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\RBZXGWB9\\Fraser et al. - 2016 - UAV photogrammetry for mapping vegetation in the l.pdf:application/pdf}
+}
+
+@article{anisimov_arctic_2017,
+	title = {Arctic Ecosystems and their Services Under Changing Climate: Predictive-Modeling Assessment},
+	volume = {107},
+	url = {http://onlinelibrary.wiley.com/doi/10.1111/j.1931-0846.2016.12199.x/full},
+	shorttitle = {Arctic Ecosystems and their Services Under Changing Climate},
+	pages = {108--124},
+	number = {1},
+	journaltitle = {Geographical Review},
+	author = {Anisimov, Oleg and Kokorev, Vasily and Zhiltcova, Yelena},
+	urldate = {2017-07-11},
+	date = {2017},
+	file = {Arctic Ecosystems and Their Services Under Changing Climate.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\FQBTGIAK\\Arctic Ecosystems and Their Services Under Changing Climate.pdf:application/pdf}
+}
+
+@article{militino_stochastic_2017,
+	title = {Stochastic Spatio-Temporal Models for Analysing {NDVI} Distribution of {GIMMS} {NDVI}3g Images},
+	volume = {9},
+	issn = {2072-4292},
+	url = {http://www.mdpi.com/2072-4292/9/1/76},
+	doi = {10.3390/rs9010076},
+	pages = {76},
+	number = {1},
+	journaltitle = {Remote Sensing},
+	author = {Militino, Ana and Ugarte, Maria and Pérez-Goya, Unai},
+	urldate = {2017-07-11},
+	date = {2017-01-15},
+	langid = {english},
+	file = {Militino et al. - 2017 - Stochastic Spatio-Temporal Models for Analysing ND.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\TPPXSR5G\\Militino et al. - 2017 - Stochastic Spatio-Temporal Models for Analysing ND.pdf:application/pdf}
+}
+
+@article{moffat_recent_2016,
+	title = {Recent Vegetation Change (1980–2013) in the Tundra Ecosystems of the Tuktoyaktuk Coastlands, {NWT}, Canada},
+	volume = {48},
+	issn = {1523-0430, 1938-4246},
+	url = {http://www.bioone.org/doi/10.1657/AAAR0015-063},
+	doi = {10.1657/AAAR0015-063},
+	pages = {581--597},
+	number = {3},
+	journaltitle = {Arctic, Antarctic, and Alpine Research},
+	author = {Moffat, Nina D. and Lantz, Trevor C. and Fraser, Robert H. and Olthof, Ian},
+	urldate = {2017-07-11},
+	date = {2016-08},
+	langid = {english},
+	file = {Moffat et al. - 2016 - Recent Vegetation Change (1980–2013) in the Tundra.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\IJJ8UXS6\\Moffat et al. - 2016 - Recent Vegetation Change (1980–2013) in the Tundra.pdf:application/pdf}
+}
+
+@article{pattison_trends_2015,
+	title = {Trends in {NDVI} and Tundra Community Composition in the Arctic of {NE} Alaska Between 1984 and 2009},
+	volume = {18},
+	issn = {1432-9840, 1435-0629},
+	url = {http://link.springer.com/10.1007/s10021-015-9858-9},
+	doi = {10.1007/s10021-015-9858-9},
+	pages = {707--719},
+	number = {4},
+	journaltitle = {Ecosystems},
+	author = {Pattison, Robert R. and Jorgenson, Janet C. and Raynolds, Martha K. and Welker, Jeffery M.},
+	urldate = {2017-07-11},
+	date = {2015-06},
+	langid = {english},
+	file = {Pattison et al. - 2015 - Trends in NDVI and Tundra Community Composition in.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\M4GT9EHE\\Pattison et al. - 2015 - Trends in NDVI and Tundra Community Composition in.pdf:application/pdf}
+}
+
+@article{greaves_estimating_2015,
+	title = {Estimating aboveground biomass and leaf area of low-stature Arctic shrubs with terrestrial {LiDAR}},
+	volume = {164},
+	issn = {00344257},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0034425715000826},
+	doi = {10.1016/j.rse.2015.02.023},
+	pages = {26--35},
+	journaltitle = {Remote Sensing of Environment},
+	author = {Greaves, Heather E. and Vierling, Lee A. and Eitel, Jan U.H. and Boelman, Natalie T. and Magney, Troy S. and Prager, Case M. and Griffin, Kevin L.},
+	urldate = {2017-07-11},
+	date = {2015-07},
+	langid = {english},
+	file = {Greaves et al. - 2015 - Estimating aboveground biomass and leaf area of lo.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\6IN4XJHA\\Greaves et al. - 2015 - Estimating aboveground biomass and leaf area of lo.pdf:application/pdf}
+}
+
+@article{olofsson_good_2014,
+	title = {Good practices for estimating area and assessing accuracy of land change},
+	volume = {148},
+	issn = {00344257},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0034425714000704},
+	doi = {10.1016/j.rse.2014.02.015},
+	pages = {42--57},
+	journaltitle = {Remote Sensing of Environment},
+	author = {Olofsson, Pontus and Foody, Giles M. and Herold, Martin and Stehman, Stephen V. and Woodcock, Curtis E. and Wulder, Michael A.},
+	urldate = {2017-07-11},
+	date = {2014-05},
+	langid = {english},
+	file = {Olofsson et al. - 2014 - Good practices for estimating area and assessing a.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\MA5FKWXJ\\Olofsson et al. - 2014 - Good practices for estimating area and assessing a.pdf:application/pdf}
+}
+
+@article{wulder_lidar_2012,
+	title = {Lidar sampling for large-area forest characterization: A review},
+	volume = {121},
+	issn = {00344257},
+	url = {http://linkinghub.elsevier.com/retrieve/pii/S0034425712000855},
+	doi = {10.1016/j.rse.2012.02.001},
+	shorttitle = {Lidar sampling for large-area forest characterization},
+	pages = {196--209},
+	journaltitle = {Remote Sensing of Environment},
+	author = {Wulder, Michael A. and White, Joanne C. and Nelson, Ross F. and Næsset, Erik and Ørka, Hans Ole and Coops, Nicholas C. and Hilker, Thomas and Bater, Christopher W. and Gobakken, Terje},
+	urldate = {2017-07-11},
+	date = {2012-06},
+	langid = {english},
+	file = {Wulder et al. - 2012 - Lidar sampling for large-area forest characterizat.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\ARMF4NBB\\Wulder et al. - 2012 - Lidar sampling for large-area forest characterizat.pdf:application/pdf}
+}
+
+@article{porter_temperature-growth_2011,
+	title = {Temperature-growth divergence in white spruce forests of Old Crow Flats, Yukon Territory, and adjacent regions of northwestern North America},
+	volume = {17},
+	issn = {13541013},
+	url = {http://doi.wiley.com/10.1111/j.1365-2486.2011.02507.x},
+	doi = {10.1111/j.1365-2486.2011.02507.x},
+	pages = {3418--3430},
+	number = {11},
+	journaltitle = {Global Change Biology},
+	author = {Porter, Trevor J. and Pisaric, Michael F. J.},
+	urldate = {2017-07-11},
+	date = {2011-11},
+	langid = {english},
+	file = {Porter and Pisaric - 2011 - Temperature-growth divergence in white spruce fore.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\23CCN7BK\\Porter and Pisaric - 2011 - Temperature-growth divergence in white spruce fore.pdf:application/pdf}
+}
+
+@article{white_food_2007,
+	title = {Food and water security in a changing arctic climate},
+	volume = {2},
+	issn = {1748-9326},
+	url = {http://stacks.iop.org/1748-9326/2/i=4/a=045018?key=crossref.d4de7703f8707536a0c7fa3cf28caf94},
+	doi = {10.1088/1748-9326/2/4/045018},
+	pages = {045018},
+	number = {4},
+	journaltitle = {Environmental Research Letters},
+	author = {White, Daniel M and Craig Gerlach, S and Loring, Philip and Tidwell, Amy C and Chambers, Molly C},
+	urldate = {2017-07-11},
+	date = {2007-10},
+	file = {White et al. - 2007 - Food and water security in a changing arctic clima.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\UGI5NDKN\\White et al. - 2007 - Food and water security in a changing arctic clima.pdf:application/pdf}
+}
+
+@incollection{simpson_human_2012,
+	location = {Dordrecht},
+	title = {Human Impacts: Applications of Numerical Methods to Evaluate Surface-Water Acidification and Eutrophication},
+	volume = {5},
+	isbn = {978-94-007-2744-1 978-94-007-2745-8},
+	url = {http://link.springer.com/10.1007/978-94-007-2745-8},
+	series = {Developments in Paleoenvironmental Research},
+	pages = {579--614},
+	booktitle = {Tracking Environmental Change Using Lake Sediments},
+	publisher = {Springer Netherlands},
+	author = {Simpson, George L. and Hall, Roland I.},
+	editor = {Birks, H. John B. and Juggins, Steve and Smol, John P.},
+	urldate = {2017-07-11},
+	date = {2012},
+	doi = {10.1007/978-94-007-2745-8},
+	file = {Simpson and Hall - 2012 - Human Impacts Applications of Numerical Methods t.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\Z9CEMCUB\\Simpson and Hall - 2012 - Human Impacts Applications of Numerical Methods t.pdf:application/pdf}
+}
+
+@collection{birks_tracking_2012,
+	location = {Dordrecht},
+	title = {Tracking Environmental Change Using Lake Sediments},
+	volume = {5},
+	isbn = {978-94-007-2744-1 978-94-007-2745-8},
+	url = {http://link.springer.com/10.1007/978-94-007-2745-8},
+	series = {Developments in Paleoenvironmental Research},
+	publisher = {Springer Netherlands},
+	editor = {Birks, H. John B. and Lotter, André F. and Juggins, Steve and Smol, John P.},
+	urldate = {2017-07-11},
+	date = {2012},
+	doi = {10.1007/978-94-007-2745-8},
+	file = {Birks et al. - 2012 - Tracking Environmental Change Using Lake Sediments.pdf:C\:\\Users\\Brent Thorne\\Zotero\\storage\\J7KIKFJ7\\Birks et al. - 2012 - Tracking Environmental Change Using Lake Sediments.pdf:application/pdf}
+}
\ No newline at end of file
