How do you override the required Create Fishnet parameters in ArcMap 10.1?

How do you override the required Create Fishnet parameters in ArcMap 10.1?

I'm writing a python script that creates a fishnet in a specified area (parcel shapefile) that accepts user input to create a polygon shapefile that represents a building, and polyline shapefile that represent parking area in the parcel. In ArcMap, you're able to choose the optional parameter of "Template Extent" that automatically populates the Y-Axis, and Origin Coordinates that the tool requires. I keep getting this error when running my script:

ExecuteError: Failed to execute. Parameters are not valid. ERROR 000735: Fishnet Origin Coordinate : Value is required ERROR 000735: Y-Axis Coordinate : Value is required Failed to execute (CreateFishnet).

In my CreateFIshnet syntax, using "#" in the origin_coord and y_axis coord results in an error instead of passing the request to the optional {template}.

Is there a way around this? I'd like the optional {template} parameter to take priority, but I'm wondering if I have to create points within the specified area and pass those coordinates to the fishnet parameters?

Its always hard to advise on ArcPy code when a snippet is not included in a question.

However, I suspect that one of your variables is not set to what you think it is before using it within the CreateFishnet line of code.

For testing I recommend adding someprintand/orarcpy.AddMessagelines to see their values.

Coming at it from another direction, I also recommend using Copy As Python Snippet from theGeoprocessing | Resultswindow to grab the correct syntax it writes on a successful run of the Create Fishnet tool from its tool dialog. Having a working syntax to compare against can do wonders.

With respect to the optional {template} parameter that works so well on the Create Fishnet tool, this is because that system tool runs some tool validation code to calculate the relevant values. It is that code which I suspect you are trying, or need, to reproduce in your script.

ModelBuilder.Configurations.Add and modelBuilder.Entity on OnModelCreating

I have just started working on entity framework code first approach, I have written two approaches below and both are working fine.

Please let me know what are the core concepts behind both these approaches and what should follow?

Approach 1 : Using EntityTypeConfiguration

Approach 2 :

Please provide me concept/blogs on entity,since i have just started.

Environment settings

Environment settings can be thought of as additional parameters that affect a tool's results. They differ from normal tool parameters in that they don't appear on a tool's dialog box (with certain exceptions). Rather, they are values you set once using a separate dialog box and are interrogated and used by tools when they are run.

Changing the environment settings is often a prerequisite to performing geoprocessing tasks, for example, the Current and Scratch workspace environment settings, which allow you to set workspaces for inputs and outputs. Another example is the Extent environment setting, which allows your analysis to be limited to a small geographic area, or the Output Coordinate System environment setting, which defines the coordinate system (map projection) for new data.

There are four levels of environment settings.

  1. Application level settings are the default settings that will be applied to any tool when it is executed.
  2. Tool level settings are applied to a single run of a tool and override the application level settings.
  3. Model level settings are specified and saved with a model and override tool level and application level settings.
  4. Model process level settings are specified at the model process level, are saved with the model, and override model level settings.

Named dependencies and factories are not the right way to handle this.

Yes, you are abusing your IOC container. The principle of DI is to ask for what you need. You need an IEnumerable<IValidationType> (an IList is inappropriate here because you should not be modifying it and don't need random access). But instead of just asking for an IEnumerable<IValidationType> , you're asking for two different implementations. As you identified, this violates open/closed because your factory will change every time you come up with a new implementation.

I also don't understand the point of your factory. It seems to have 0 responsibilities. Instead of the factory, write the composite.

Then get your IOC container to register this composite with the right component implementations as the canonical IValidationType. Reflection can be your friend here.

I am vehemently against ever using named dependencies it breaks the sensible rule that renaming a method parameter should always be a safe refactor.

Optimized Hotspot Analysis

Remove all layers from map the except the two original layers with the burglary data and the neighborhoods. From the Toolbox navigate to Spatial Statistics Tools > Mapping Clusters and open the Optimized Hotspot Analysis tool. This tool allows for quick hotspot analysis using minimal input parameters and sets/calculates default parameters for those you have no control over. For more control over the statistical elements you can use the Hotspot Analysis (Getis-Ord GI*) tool. For now we will use the optimized approach.

Set the burglary points as the Input Features, name your Output Features (here I have named them ohsa_burg_plygns), select COUNT_INCIDENTS_WITHIN_AGGREGATION_POLYGONS for the Incident Data Aggregation Method and choose the neighborhoods features for the Polygons For Aggregating Incidents Into Counts.

What if I add a class Kelvin without modifying the other classes? When I convert Celsius to Kelvin then, your code says that 20 °C = 20 K, which is simply wrong.

Your whole approach is doomed to fail. What you should do instead is to define one reference temperature scale. I would take Kelvin for that. Then, for every other temperature scale, have methods fromKelvin and toKelvin . That's all. This approach is well-known from constructing compilers, which has the same problem of several similar source languages and several different target machines.

For converting between arbitrary temperature scales you can have a helper method in the Temperature class like this:

You can see that there are two completely different classes involved:

  1. A temperature scale, like Kelvin or Fahrenheit
  2. A specific temperature, consisting of a temperature scale and a value, like 293 Kelvin

Regarding the exception class: There is no good reason to give it a String parameter. The name of the class is already expressive enough. Therefore you should remove that parameter and just throw new AbsoluteZeroException() . You should probably rename it to BelowAbsoluteZeroException . Or you should just take the predefined IllegalArgumentException and be fine. In many cases you don't need to invent your own exception classes.

Using 2 classes here doesn't make sense.

Every time you add another class, you'll have to modify every classes conversion method.

There is a tight coupling between Celsius & Fahrenheit. You are using an instance of Fahrenheit to determine the type you want to convert to. This isn't necessary.

Note: In programming you want low coupling, high cohesion. Lots of information is available online

Temperatures would work better as an ENUM. Then you can do something like:

You might follow the example of java.util.Date . The internal representation of a Date is always in UTC, and it's converted to other time zones and date formats as needed. Similarly, you could define a Temperature class that is always in Kelvin, and a TemperatureScale interface with as many implementations as you like to perform conversions and formatting.

This is a hard question to answer because this problem is so simple it simply does not need an object-oriented solution. You'd be much better just writing two methods named convertCToF and convertFToC which will throw an Exception at absolute zero (if you desire).

  • You should make your Constructor(. ) methods public , as per convention
  • There is no need for empty constructors.
  • If you are going the object-oriented route in Java, it's best practice to use encapsulation and declare member fields to be private and write get and set methods for said fields.
  • You could instead declare an interface with a method called convert and attach them to your classes, that way it will be mandatory to implement a convert method rather than having to use @Override

But overall you really need to reconsider if you actually need to use OOP for this. See this video covering the overuse of class in Python.

All this criticism of the object model is well founded, but don't forget that this is a college exercise. College exercises sometimes ask you to do something problematic so you can understand why it's problematic. A classic example of this is bubble sort. So I wouldn't focus on that too much unless you're in a relatively advanced programming course.

The first thing that leaps out at me is that you have classes Fahrenheit and Celsius, but your convert method doesn't return instances of those classes it returns a double. The pattern of passing a valueless instance of Fahrenheit or Celsius to the conversion method to indicate the desired units of the function's double output function is profoundly unidiomatic for OOP. I suspect that your professor is after a conversion method that converts an instance of Fahrenheit to an instance of Celsius that represents the same temperature.

This isn't great object oriented design, but it might just be what your professor is looking for. If your class is more advanced, it's possible that the exercise is designed to teach a more advanced technique to support methods that convert from one class to another.

As suggested elsewhere, another approach might be to have a single temperature class that stores its magnitude in Kelvin and has factory methods like Temperature fromCelsius(double celsius) for constructing instances from a given system of units, and instance methods like double toCelsius() that return a value in a given system of units.

9 Answers 9

There is a specification (draft) for Trash on It is apparently what is usually implemented by desktop environments.

A commandline implementation would be trash-cli. Without having had a closer look, it seems to provide the funtionality you want. If not, tell us in how far this is only a partial solution.

As far as using any program as replacement/alias for rm is concerned, there are good reasons not to do that. Most important for me are:

  • The program would need to understand/handle all of rm 's options and act accordingly
  • It has the risk of getting used to the semantics of your "new rm" and performing commands with fatal consequences when working on other people's systems

The previous answers mention commands trash-cli and rmtrash . Neither of those are found by default on Ubuntu 18.04, but the command gio is. Commanding gio help trash outputs:

I tested using gio trash FILENAME on the command line, and it works just like I'd selected the file in the file browser and clicked the DEL button: the file is moved to the desktop's Trash folder. (The command doesn't prompt for confirmation even though I did not use the -f option.)

Deleting files this way is reversible, while being more convenient than redefining rm to be rm -i for safety and having to confirm each deletion, which still leaves you out of luck if you accidentally confirm a deletion you shouldn't have.

I added alias tt='gio trash' to my alias definitions file tt is a mnemonic for To Trash.

Added on edit on 2018-06-27: On server machines, there is no equivalent of a trash directory. I've written the following Bash script that does the job on desktop machines, it uses gio trash , and on other machines, moves the file(s) given as parameter(s) to a trash directory it creates. The script is tested to work I use it all the time myself. Script updated on 2021-04-27.


The input point feature class to be aggregated into space-time bins.

The output netCDF data cube that will be created to contain counts and summaries of the input feature point data.

The field containing the date and time (timestamp) for each point. This field must be of type Date.

A reference space-time cube used to define the output_cube extent of analysis, bin dimensions, and bin alignment. The time_step_interval , distance_interval , and reference_time values are also obtained from the template cube. This template cube must be a netCDF ( .nc ) file that has been created using this tool.

The number of seconds, minutes, hours, days, weeks, or years that will represent a single time step. All points within the same Time Step Interval and Distance Interval will be aggregated. (When a Template Cube is provided, this parameter is ignored, and the Time Step Interval value is obtained from the template cube). Examples of valid entries for this parameter are 1 Weeks , 13 Days , or 1 Years .

Defines how aggregation will occur based on a given time_step_interval . If a template_cube is provided, the time_step_alignment associated with the template_cube overrides this parameter setting and the time_step_alignment of the template_cube is used.

  • END_TIME —Time steps align to the last time event and aggregate back in time.
  • START_TIME —Time steps align to the first time event and aggregate forward in time.
  • REFERENCE_TIME —Time steps align to a particular date/time that you specify. If all points in the input features have a timestamp larger than the reference time you provide (or it falls exactly on the start time of the input features), the time-step interval will begin with that reference time and aggregate forward in time (as occurs with a START_TIME alignment). If all points in the input features have a timestamp smaller than the reference time you provide (or it falls exactly on the end time of the input features), the time-step interval will end with that reference time and aggregate backward in time (as occurs with an END_TIME alignment). If the reference time you provide is in the middle of the time extent of your data, a time-step interval will be created ending with the reference time provided (as occurs with an END_TIME alignment) additional intervals will be created both before and after the reference time until the full time extent of your data is covered.

The date/time to use to align the time-step intervals. If you want to bin your data weekly from Monday to Sunday, for example, you could set a reference time of Sunday at midnight to ensure bins break between Sunday and Monday at midnight. (When a template_cube is provided, this parameter is ignored and the reference_time is based on the template_cube .)

The size of the bins used to aggregate the in_features . All points that fall within the same distance_interval and time_step_interval will be aggregated. When aggregating into a hexagon grid, this distance is used as the height to construct the hexagon polygons. (When a template_cube is provided, this parameter is ignored and the distance interval value will be based on the template_cube .)

The numeric field containing attribute values used to calculate the specified statistic when aggregating into a space-time cube. Multiple statistic and field combinations may be specified. Null values are excluded from all statistical calculations.

  • SUM—Adds the total value for the specified field within each bin.
  • MEAN—Calculates the average for the specified field wintin each bin.
  • MIN—Finds the smallest value for all records of the specified field within each bin.
  • MAX—Finds the largest value for all records of the specified field withtin each bin.
  • STD—Finds the standard deviation on values in the specified field within each bin.
  • MEDIAN-Finds the sorted middle value of all records of the specified field within each bin.
  • ZEROS—Fills empty bins with zeros.
  • SPATIAL_NEIGHBORS—Fills empty bins with the average value of spatial neighbors
  • SPACE_TIME_NEIGHBORS—Fills empty bins with the average value of space time neighbors.
  • TEMPORAL_TREND—Fills empty bins using an interpolated univariate spline algorithm.

Note: Null values present in any of the summary fields will result in those features being excluded from analysis. If having the count of points in each bin is part of your analysis strategy, you may want to consider creating separate cubes, one for the count (without summary fields) and one for summary fields. If the set of null values is different for each summary field, you may also consider creating a separate cube for each summary field.

The shape of the polygon mesh the input feature point data will be aggregated into.

  • FISHNET_GRID —The input features will be aggregated into a grid of square (fishnet) cells.
  • HEXAGON_GRID —The input features will be aggregated into a grid of hexagonal cells.

ArcGIS help - creating 100m line transects within a polygon

For my thesis, I need to create three randomly generated 100meter line transects within each field I work in. I’m doing bird survey work in TN and have a lot of fields to choose from. Ideally, I want to be able to place these line transects within my available fields to see which are the best matches for my work. Every line transect must be exactly 100 meters long and each transect should be at least 100-200 meters apart to prevent potential overlap.

I’ve been trying to use the create random points tool, but it doesn’t necessarily place every point 100m apart (some are longer, like 120 or even 200m apart). I don’t have ArcGIS Pro so I can’t use the Generate Transect tool unfortunately, and while I could just adjust every point, I have quite a large amount of fields to work in, so it would be easier if I could just plug in some info and have it done for me.

Is there a simple way to do this? I’m pretty okay with ArcGIS basics but don’t know how to code. Any and all help is greatly appreciated!

Probably not the elegant solution for which you're searching, but I do the same thing for our biologists. I create random points, then connect 1 to 2, 3 to 4, and so on. Then in my transect feature class I go back and create snapped lines to the exact transect length required (alternatively, you can trim the initial snapped lines). For 100m transects requiring no overlaps, Iɽ specify minimum distance between random points to be at least 100m. Quick and dirty solution that works well as I do this infrequently.

You can create a fishnet with those exact dimensions then turn those polygons into polylines

Hi, take what I am about to say with a grain of salt if you wish, but too many people think "computer" when the word "random" pops up.

I do, and have done a lot of field work sampling various Veg/animal/growth plots and transects. The importance of "random" is to simply remove "field bias"

Here are three quick and common ways to create random transects.

Fastest and arguably the most random at the office, look at your map, choose three areas you feel would give yourself good sampling coverage and meet your required transect parameters. Then simply draw three 100m lines by hand or digitize. Grab your three location points and azimuth to follow and head out to the field.

Overlay Grid. Choose a 100mx100m or 50mx50m grid and overlay this grid over your sampling area. Choose a 100m length transects from your grid that meet your parameters, snap digitize and head out to the field.

Do as you did, let the computer choose random points for you. Think of the points as points of commencement, line them up with another point as your azimuth and simply follow for 100m. Just because the points are further or closer than 100m does not matter, just get your initial starting point and snap out 100m along an azimuth.

You may find that one of your transacts will have to be shifted in the field due to a physical barrier like an unmapped pool or cliff or sink or some other unforeseen barrier. No problem, just quickly choose a different azimuth or bump the point of start to avoid. (make sure you make clear notes as to why you did this, to follow up back at office)

The most important aspect is the sampling, collecting good accurate data with the amount of precision and statistical confidence you set for your thesis work.

2 Answers 2

Let's start with the most basic, the Card class.

Except during development, it's custom to explicitly import only the classes you need instead of using wildcards.

It's is most certainly a valid choice to store rank and suit as short s, since it's most likely the fastest and most efficient way, but if you want to learn the specifics of Java you may want to look into enumerations.

IMHO cards are a prime example for immutable objects. There is no reason to need to change the rank or the suit of a card, so I would drop the setters.

It's very unusual to use underlines in variable names in Java, especially two as a prefix. I would simple name the parameters rank and suit especially since these are class (static) methods and not instance methods, so there is no confusion with the fields.

It may be worth thinking about, if these actually need to be class methods and shouldn't be instance methods. If you have other classes which need to convert short into the corresponding names independently from the Card class, then it would be ok. But in your case I would say it's not the case, and one should try and hide the fact that suits and ranks are implemented as short s as much as possible.

The Java community is split over the question, if the toString() method should be overridden purely for debugging reasons, or if it should be used in the "business logic". In this "simple" application I don't think you need to distinguish between the two uses, so I would drop printCard() and only use toString() .

BTW, it's custom to have annotations before the method modifiers.

Instead of implementing your own method it's probably a good idea to override equals() (or at least make this an instance method). If you make Card immutable as I suggested before, it simplifies the implementation to comparing the references, to see if they are the same, because you should only have one instance of each possible card.

(Although it may be safer to compare rank and suit as a fall back.)

First a quick digression about Enumerations. The Enums have an ordinal number and a compareTo method, allowing you to sort them. You also can assign them properties and create your own order based on those.

The offical language guide has examples for suit and rank enumations and for extending enumerations with your own properties using planets as an example:

When/if I get to the hand ranking (I haven't looked at it yet) I may be able to give some suggestions have to implement it with enums.

Next are the Comparator s. I don't have much experience with them, so I can only give some general suggestions:

  • Classes should always start with a capital letter in Java.
  • You should extend them from Comparator<Card> instead of Comparator<Object> , since you only need to compare cards with each other and not with any other objects.
  • While it is good extra practice, you may want to skip the suit comparator, because it's not really needed in Poker in general (and Texas Hold'em specifically). Suits never have an order in hand ranking usually only needed in some "meta" contexts (such as randomly determinating the position of the button), that currently don't apply to your program. However if you do keep it, then you should correct the order of the suits, because the official ranking is (from lowest to highest) "Clubs", "Diamonds", "Hearts" and "Spades".

Next up, is the Board. First off, I'd like to say, that I'm nor sure if I'd use a Board class like this in a real world Poker application. However off the top of my head I can't think of a different way to do it and for practice this is perfectly fine.

The only thing I would change is instead of explicitly setting each card by index with setBoardCard(Card card, int cardNum) , I would let the Board class track the index internally itself and just use addBoardCard(Card card) , because you shouldn't be able to "go back" and change the board cards (ditto for the burn cards).

Regarding sorting suits: Ok, that makes sense. I haven't looked at hand evaluation yet. However that is more a case of grouping that sorting, so maybe there is a different (better?) way to do that. I'll have to think about it.

Tracking indexes: You certainly could use a Collection (or more specifically a List ) to do this (and it would be more "Java-like", but in your case where you have a fixed maximum number of cards on the board the arrays are fine. I'd something like:

First I'd suggest to create just one Random object statically instead of creating one for each call of shuffle and cutDeck .

Really problematic is the creation of a new temporary Deck object for cutting the deck. This can go wrong very fast, because it contains an unnecessary second set of cards and if there is a bug you'll easily get duplicate cards. Instead just use a new array. Also you can use System.arraycopy to simplify copying from one array to another.

Creating a new Deck doesn't only create a new array, it creates a a filled array with new cards, which you don't need. Just an array is enough:

There is not much to say about Player except, I'd remove setCard and just use the constructor to assign the cards to the player in order to make the object immutable. Or at least implement an addCard method just like in Board .

In getNumberOfPlayers your error handling it some what inconsistent. On the one hand you write to System.out ( System.err would probably be better) and on the other hand you throw an exception.

For the IOException I wouldn't catch it here, but outside of getNumberOfPlayers . In bigger projects it may make sense to "wrap" it in your own Exception class for this:

Both the caught NumberFormatException and invalid range should throw the same (or related) custom exceptions. Don't just throw a simple Exception , because it's meaningless to others that need to catch it. Example:

Notice that in the causing IOException and NumberFormatException , are passed as an argument to the new exception in case they are needed further down the line.

Both the HoldemIOException and HoldemUserException could be extended from a basic HoldemException which in turn extends Exception . A simple "empty" extention such as

for all three cases would be enough.

Also you never should let an exception (especially a self thrown one) just drop out at the end completely unhandled. Catch all exceptions you know of at a reasonable place, in your case at the getNumberOfPlayers :

I only added the do while loop, to show how to handle the two types of exception differently. It would be wise to add a proper way for the user to get out of the loop.

Here we have another counter ( cardCounter ) to track to "position" of the deck. Again it would be better to have the Deck class track the dealt cards. You should consider implementing the Deck as an actual "stack" or a "queue" - it doesn't matter which, since you aren't adding any items. Java provides a Queue interface you could use.

Thinking about it, you could also use the same interface for Player and Board (although you'd need to separate the burn cards into its own object in that case). That would simplify dealing to player.add(deck.remove()) , board.add(deck.remove()) and burnCards.add(deck.remove()) .

Ok, most likely the final edit.

I've started looking at the hand evaluation and I don't think I can write much about that. You've implemented it in a very procedural way based on your current Card objects and if your goal is to do this in a more Java way you'd probably need to re-write the Card object and create a proper "Hand" object first (most likely based on a Set ) and then re-write the evaluation based on that.

Poker hand evaluation is a very complex topic, especially when considering 5 cards out of 7. How this should be implemented will depend on if you want to focus on "good Java practice" or "speed". If you really interested in expanding this, then you probably should first read up on the topic - there are several questions on Stack Overflow about this, and probably countless articles on the web - and then repost a new question focusing on hand evaluation. I'll be happy to have a look at that some day - if I have the time.

Just one specific thing: What are the constants ONE, TWO, THREE and FOUR for? Even for a procedural approach these seem to be completely out of place and should most likely be replaced by an appropriate loop where they are used.

Watershed Management for Potable Water Supply: Assessing the New York City Strategy (2000)

Regulations governing the use of private land within a specified distance of a watercourse, lake, wetland, or tidal shoreline have been in effect in many states and localities since the early 1960s. Such ''setbacks" or "buffer strips" serve diverse purposes, for example, protection of surface waters from pollution, protection of structures from flooding or erosion, and preservation of riparian habitat and shoreline amenities. One of the most prevalent features of the Memorandum of Agreement (MOA) Watershed Rules and Regulations is the use of setback distances for separating waterbodies from potentially polluting activities. Depending on the activity, 25&ndash1,000 ft of land must separate the activity from nearby waterbodies. Greater distances are required for setbacks around reservoirs, reservoir stems, and controlled lakes than for those around wetlands and watercourses, which encompasses all perennial streams and in some cases intermittent streams.

Although the use of setbacks is quite common in watershed regulations across the country, little research has been done regarding the effectiveness of setbacks per se in preventing contamination of waterbodies from nonpoint source pollution. Rather, research has focused on the use of buffer zones for nonpoint source pollutant removal. Buffer zones are natural or managed areas used to protect an ecosystem or critical area from adjacent land uses or sources of pollution. They are an increasingly used best management practice (BMP) for many activities. Effective buffers along rivers, reservoirs, and lakes (riparian buffers) either retain or transform nonpoint source pollutants or produce a more favorable environment for aquatic ecosystem processes.

Setbacks, in contrast to buffer zones, are simply prescribed distances between pollutant sources and a resource or aquatic ecosystem that needs protection. Only

if a setback is subject to management or natural preservation can it be considered a "buffer" that reliably insulates ecosystems and resources from nonpoint source pollution. Because of the lack of information regarding unmanaged setbacks, this review focuses on management of buffer zones for achieving pollutant removal. In the absence of management, it is virtually impossible to predict what effect the setback distances in the MOA will have on the water quality of the New York City watershed. However, if the management practices reviewed and recommended in the following sections are used, then the setbacks may approach the pollutant-removal capabilities predicted for buffer zones.

The next section enumerates and explains key functions and characteristics of riparian buffer zones. It should be noted that waterbodies have a substantial effect on the characteristics of the surrounding buffer zones. That is, depending on whether they border wetlands, reservoirs, or streams, buffer zones will function differently. These differences are discussed when appropriate. Another important consideration is that buffer zones may not be permanent pollutant sinks, but rather may act as temporary storage areas that can be both sources and sinks of pollution. This is especially true for sediment and phosphorus, for which no degradation processes exist in the buffer (nitrogen can be removed via denitrification). Factors that enhance the long-term storage potential of riparian buffer zones, such as harvesting of vegetation, are important in evaluating their long-term effectiveness.


Riparian buffer zones refer to lands directly adjacent to waterbodies such as lakes, reservoirs, rivers, streams, and wetlands. These land areas have a significant impact on controlling nonpoint source pollution and on the associated water quality in nearby waterbodies. As a result, they are widely used in water resource protection programs and are the topic of intense investigation, especially in agriculture and forestry. Unfortunately, as noted in a recent symposium on buffer zones, policy-driven initiatives that have accelerated the debate on buffer zones have, at the same time, stretched scientifically based management to the limits of knowledge on this issue (Haycock et al., 1997). This is the case in the New York City watersheds and most other regions of the country.


Evaluating the effectiveness of riparian buffers to remove diffuse pollution from runoff requires a basic understanding of their hydrologic structure and function. Because of their proximity to waterbodies, riparian buffers are sometimes flooded by stream overflow. Riparian buffer zones are also strongly influenced by water from upslope areas, which is generally divided into three

categories: (1) overland or surface flow, (2) shallow subsurface flow, and (3) groundwater flow (Figure 10-1).

Overland flow across buffer zones can occur via two pathways. Infiltration-excess overland flow is generated when rainfall intensity or snowmelt rate exceeds the rate at which water moves through the soil surface (the infiltration process). Infiltration-excess overland flow typically occurs when the soil surface is frozen, is compacted, or is otherwise unable to transmit water to the root zone. Extreme rainfall events may deliver water rapidly enough to generate infiltration-excess across a wide range of soil types and watershed locations. As in most predominantly forested areas, this mechanism of overland flow is rare in the Catskill/Delaware region.

Saturation-excess overland flow occurs when soil water storage capacity is exceeded by precipitation volume combined with lateral inflow from upslope areas. When total inflow exceeds total outflow, saturation from below is the obligate result. Once the zone of saturation reaches the soil surface, any new input (rain or snowmelt) is immediately converted to overland flow. As shown in Figure 10-1, saturation-excess overland flow typically occurs at the transitions from the uplands to the riparian zone. Saturation-excess overland flow is usually less damaging to water quality than is infiltration-excess overland flow and, though still uncommon, it is more likely in the Catskill/Delaware region.

Both infiltration-excess and saturation-excess overland flow occur during rain or snowmelt events and constitute the bulk of stormflow. Because this water

FIGURE 10-1 Hydrologic pathways surrounding riparian buffer zones. Source: Burt (1997).

travels overland, it can accumulate high levels of particulate matter such as sediment, bacteria, and particulate-phase phosphorus. Depending on its velocity and on the soil water status of the riparian zone, overland flow can either infiltrate into buffer zones (generally desirable) or flow across buffer zones and discharge directly into neighboring waterbodies.

Shallow subsurface flow travels laterally through the root zone below the land surface (see Figure 10-1). It may be caused by an abrupt decrease in soil permeability or simply because a shallow soil is underlain by slowly permeable or impermeable bedrock. The latter is the most common case in the Catskill/Delaware region. The response of subsurface flow to storm events is more attenuated than that of overland flow, although increases in subsurface flow do generally occur during and for a period of time following precipitation or snowmelt. Filtering and biogeochemical transformations in the soil limit shallow subsurface transport of suspended particulate matter. By contrast, the concentration of dissolved solids may increase in proportion to residence (travel) time (Burt, 1997).

Groundwater flow occurs when vertical flow extends beyond the root zone into lower strata. This may occur in deeper unconsolidated material (e.g., glacial or lacustrine sands and gravels) and/or through bedrock fractures. Travel time increases in proportion to the length of the flow path and in relation to hydraulic limitations imposed by the media. Hence, groundwater can have high dissolved solids but transports little, if any, suspended solids. Shallow subsurface flow and groundwater flow combine to generate baseflow, the water entering streams, wetlands, lakes, and reservoirs during dry periods. Shallow subsurface flow is much more likely to interact with riparian buffer zones than groundwater flow because it passes laterally through the root zone. In some instances, shallow subsurface flow in upstream areas can become saturation-excess overland flow by the time a buffer zone is reached (exfiltration or seepage).

Pollutant Removal and Other Functions

The structure and function of riparian buffer zones are determined by (1) the soil, vegetation, and hydrologic characteristics of the buffer and (2) the interactions with upslope and downslope water. For management purposes and for conceptualization of the various functions, the U.S. Department of Agriculture (USDA) guidelines suggest riparian buffers can be divided into three zones, each of which has certain physical characteristics and pollutant-removing abilities (Figure 10-2) (NRCS, 1995 Welsch, 1991). Zone 1 is the area immediately adjacent to the waterbody Zone 2 is an intermediate zone upslope from Zone 1 where most active woody BMPs are used and Zone 3 is the vegetated areas upslope from Zone 2. Although this conceptualization has not been universally adopted, it is particularly useful in this report for describing how riparian buffer zone functioning varies with distance from nearby waters.

FIGURE 10-2 USDA's three-zone schematic of a riparian buffer zone. Source: EPA (1995).

Zone 3

The pollutant-removal abilities of riparian buffers are maximized when overland flow infiltrates into buffer zones rather than discharging directly into adjacent waterbodies. For this reason, the most important function of Zone 3 is to alter the hydraulic properties of rainfall runoff such that the overland flow interacting with Zones 2 and 1 is sheet flow rather than channelized flow. Depending on the characteristics of nearby land, overland flow reaching Zone 3 may be predominantly channelized flow. By design, when channelized flow reaches Zone 3, it is usually converted to sheet flow and subsurface flow by the hydraulically rough surface and the enhanced infiltration of the buffer zone.

Coarse sediment removal from stormwater is also predominantly accomplished in Zone 3, although it can also occur in Zones 2 and 1. When the hydraulic of stormwater change from channelized flow to sheet flow, infiltration of the water is enhanced. Sediment and other materials entrained in overland flow (such as particulate phosphorus) are deposited on the surface as water infiltrates into the soil. If Zone 3 land is properly managed, sediment removal can reach 80 percent (Sheridan et al., 1999).

Zone 2

Zone 2 is designed to remove, sequester, and transform nonpoint sources of pollution in stormwater (Lowrance et al., 1997 Welsch, 1991). Nutrients such as nitrogen and phosphorus, microbes, and sediment can all be altered during passage through a Zone 2 riparian buffer. Zone 2 can also reduce pesticide transport (Lowrance et al., 1997) and may trap other pollutants, including metals and hydrocarbons. In general, the ability of a Zone 2 riparian buffer to remove pollutants depends on (1) whether sheet flow has been established in Zone 3, (2) the type of vegetation present, and (3) the length of the buffer zone. The first criterion is determined by the condition of the Zone 3 riparian buffer upslope from Zone 2. The other two criteria are characteristics of Zone 2, some of which can be altered or managed to maximize pollutant removal. A literature review found later in this chapter discusses the extent of pollutant removal that can be achieved when rainfall runoff travels through riparian buffers. This review focuses on the pollutants of greatest concern in the New York City watersheds, including phosphorus, microbial pathogens, and sediment.

Zone 1

Zone 1 is the area of the riparian buffer closest to the waterbody. In forest ecosystems, it is characterized by a canopy of trees and shrubs that provide shade to near-shore areas of lakes, larger streams, and rivers during a portion of each day. The cumulative effects of the canopy on the energy balance can have a substantial (10&ndash15°C) effect on water temperature. Because dissolved oxygen concentration is inversely proportional to water temperature, increases in temperature caused by the removal of riparian vegetation can impose chronic or acute stress on invertebrate and fish populations. Riparian vegetation has the greatest influence along headwater streams where vegetation can cover the entire width of the stream. The microclimate effect decreases downstream as the width of the stream, river, or lake increases relative to the height of the riparian vegetation.

Leaves, needles, and wood supply energy&mdashas carbon&mdashto headwater streams. Like microclimate effects, the relative importance of carbon inputs from riparian vegetation decreases as the receiving water becomes larger. However, the inflow of dissolved and particulate carbon from headwater areas remains an important supplement to in situ primary production by algae and other aquatic plants in rivers and lakes. The contribution of vegetated riparian zones to the total dissolved carbon load at the point of water withdrawal is an important issue in watershed management. Because of the concern over the role of dissolved organic carbon in producing disinfection byproducts, there are possible drawbacks to increasing the dissolved organic carbon levels in streams.

In addition to being a persistent source of carbon, woody debris ranging from

small twigs to branches, boles, and entire trees is a critical structural feature for stream ecosystems. As woody debris lodges and jams along streambanks, it forms a matrix that captures leaves and other small organic matter as they drift downstream. The interlocking roots of riparian vegetation anchor streambank, floodplain, and lakeshore soils and substantially increase their resistance to erosion and slumping.

Finally, the zone nearest the waterbody can be responsible for unique aquatic habitats. Woody debris and leaf packs at the land/water interface increase the variation of flow velocity in headwater streams. Quiet water and eddies behind leaf packs and larger debris jams lead to the formation of alternating pool and riffle sections in headwater streams. Diverse hydraulic conditions provide a continuum of spawning, rearing, feeding, hiding, and overwinter habitat for fish, amphibians, and invertebrates.

All Zones

In all zones of a riparian buffer, vegetation helps to reduce soil erosion. All zones are also capable of increasing the thickness of the unsaturated zone through evapotranspiration of water from the soil profile. As a consequence, available storage for rain, snowmelt, and upland inflow is maximized.

Riparian buffer zones exhibit soil physical and hydraulic properties that further enhance the ability of the land to attenuate stormwater. Decomposition of vegetation in the riparian zone leads to reduced bulk density, thereby increasing porosity (storage capacity), infiltration capacity (rate of water movement into the soil), and permeability (rate of water movement through the soil). Water retention characteristics also are enhanced by the addition of organic matter. The growth, senescence, and death of roots, along with the actions of invertebrates and small mammals, produce a complex system of macropores that augment the permeability of the soil matrix. Collectively, these soil properties maximize the likelihood that rain, snowmelt, or overland flow from adjacent uplands will pass beneath the soil surface and travel as subsurface flow through the riparian zone. In addition, small-scale variations in slope, woody debris, herbaceous plants, and leaf litter on the forest floor present additional barriers to overland flow.


The most important management practice for influencing functioning of buffer zones is to stabilize the hydraulic properties of stormwater so that channelized flow does not reach nearby streams. Channelized flow can form very quickly during rainfall. In urban areas, stormwater concentrates into channelized flow within as few as 75 ft of its source (Schueler, 1996 Whipple, 1993). Given the typical land uses found on the East Coast, only about 10 percent to 15 percent of a watershed area produces sheet flow during precipitation

(Schueler, 1995). The remaining runoff is usually delivered to streams in open channels or storm drains, the flow from which can be extremely difficult, if not impossible, to dechannelize.

Hence, converting channelized flow to sheet flow or to multiple smaller channels is a critical aspect of buffer zone management. Most regulations involving setbacks and buffer zones have been written and enacted with no consideration of this important issue. Converting channelized flow to sheet flow may require the installation of a structural BMP in Zone 3. For example, at sites with significant overland flow parallel to the buffer, water bars should be constructed perpendicular to the buffer at 45-to 90-ft intervals to intercept runoff and force it to flow through the buffer before it can concentrate further. Low berms or vertical barriers, known as level-lip spreaders, have been used successfully to spread concentrated flow before entering a forest buffer (Franklin et al., 1992). Buffers should not be used for field roadways because vehicles and farm equipment will damage the buffers and may cause concentrated flows (Dillaha and Inamdar, 1997). Specific suggestions for dechannelizing urban stormwater are given later.

Buffers may accumulate significant amounts of sediment and nutrients over time. To promote vegetative growth and sediment trapping, herbaceous vegetated buffers should be mowed and the residue should be harvested two or three times a year (Dillaha et al., 1989a,b). Mowing and harvesting will increase vegetation density at ground level, reduce sediment transport, and remove nutrients from the system. Herbaceous vegetated buffers that have accumulated excessive sediment should be plowed out, disked and graded if necessary, and reseeded in order to reestablish shallow sheet flow conditions. Although natural herbaceous buffer zones are rare in the Catskills, those created during active management of setbacks should be harvested. The primary management for Zone 1 is to reestablish and maintain native woody vegetation.

Although it is known that vegetation type can greatly influence buffer zone functioning, field data are not available for most types of buffers. There are numerous aspects of vegetation management for which more information is needed. For instance, the rooting depth will influence nutrient uptake from shallow or deeper groundwater, and more must be known about the differences among root systems of various types of vegetation. Different types of vegetation also have different management requirements, with woody vegetation providing a natural longer-term sink for nutrients than does herbaceous vegetation. Some general conclusions can be drawn. First, riparian forest buffers require native woody vegetation near the waterbody. States make determinations as to the appropriateness of different species, with native hardwoods required in most states of the eastern United States. Second, in areas experiencing runoff high in sediment, herbaceous vegetation is recommended between a forest buffer and the runoff source because a well-managed grass buffer can be more effective at trapping sediment and associated contaminants. Combinations of vegetation may

prove most effective at removing a range of pollutants. For example, an outer grassed strip followed by an inner forested strip has been suggested for complete sediment, phosphorus, and nitrogen removal (Correll, 1991 Osborne and Kovavic, 1993). In all cases, the hardiness of riparian vegetation will determine how well it accomplishes pollutant removal and other functions. The New York City Department of Environmental Protection (NYC DEP) has recently noted that high densities of white-tailed deer may be preventing regrowth of forests around Kensico Reservoir (NYC DEP, 1997), which should be considered when determining vegetation requirements for buffer zones.

The preceding discussion applies only to those nonpoint source pollutants found in stormwater. Active management of buffer zones will have no effect on atmospheric deposition of pollutants directly over the surface of waterbodies, nor can it control in-stream increases in dissolved organic carbon derived from terrestrial vegetation. Additional suggestions for the active management of buffer zones are given below in relation to specific activities that produce nonpoint source pollution.


In general, agricultural land uses tend to increase surface runoff and decrease infiltration and groundwater recharge in comparison to perennial vegetation such as forest or grassland. Grazing animals can cause compaction of soils, especially under wet soil conditions. Tillage may increase subsurface compaction and lead to crust formation at the soil surface. The severity of these effects depends on soil properties and climate. In some watersheds, increased surface runoff, often combined with ditches and drainage enhancements, can change a groundwater-flow-dominated system to a surface-runoff-dominated system (Schultz et al., 1994). Increases in surface runoff cause increases in the stormflow/baseflow ratio and in the amount of sediment and chemical transport.

Many of the effects of agriculture on hydrologic and transport processes can be mitigated through the use of properly managed buffer zones. The USDA launched a National Conservation Buffer Initiative in 1997 to increase the adoption of conservation buffers and the integration of conservation buffers into farm plans. Conservation buffers include many practices designed to impede and retain surface flows and pollutants such as vegetated filter strips, contour filter strips, and riparian forest buffers. The general guidance given above on establishing and maintaining buffer zones is largely derived from studies in agricultural areas and is of primary importance. Hydrologic enhancement (conversion of channelized flow to sheet flow) can be accomplished through grading of soils, removal of berms or channels, and creation of shallow overland flow paths. Vegetation establishment may involve fertilizer and lime application, seeding, or other planting. Active management may also involve harvesting of vegetation to remove nutrients.

Other important aspects of buffer zone management on agricultural lands include restrictions on grazing and pesticide application. Grazing of riparian buffer systems including riparian forest buffers and filter strips, is generally not allowed under programs such as the USDA Conservation Reserve Program. Riparian buffers should be combined with practices such as fencing and alternative water supplies to exclude domestic animals from the entire buffer zone. Certain pesticides have setback restrictions from watercourses for storage, mixing, and application that are part of the label restrictions issued for the chemical by the Environmental Protection Agency (EPA). For example, metolachlor, a common herbicide used in corn production, cannot be mixed or stored within 50 ft of lakes, streams, and intermittent streams. The herbicide atrazine may not be mixed or loaded within 50 ft of an intermittent or perennial stream, it may not be applied within 66 ft of where field runoff exits a field and enters a stream, and it may not be applied within 200 ft of natural or impounded lakes or reservoirs. Caution should be used when applying herbicides to adjacent fields to avoid damage to buffer zone vegetation.

Finally, it should be noted that artificial subsurface drainage (tile drains) may short-circuit the functioning of riparian buffers in agricultural settings. Although drain lines are not supposed to enter streams directly, they sometimes do, providing a direct conduit for pollutant movement to streams. Allowing tile drain water to flow through a spreading device before entering a riparian buffer is desirable.


As noted in earlier chapters, the majority of nonpoint source pollution (primarily sediment) from timber-harvesting operations emanates from the road and skid trail network needed to remove sawtimber, pulpwood, or fuelwood from the forest. Overland flow is generated when the litter layer is scrapped away and the soil is compacted. This disturbance is usually limited to about ten percent of the harvest unit. The remainder of the site retains high infiltration capacity, with shallow subsurface flow as the predominant mechanism of streamflow generation. Therefore, it is usually unnecessary (and impractical) to construct stormwater control devices (e.g., level-lip spreaders) at the transition between the harvest unit and the riparian forest buffer. By contrast, a large proportion of agricultural fields or urban areas can generate overland flow and associated nonpoint source pollution because of changes in soil surface conditions.

Riparian forest buffers are subject to special operating restrictions, often specified by state forest practice acts, to minimize undesirable changes in site conditions. The most important restriction is the prohibition of direct access by heavy equipment. Selective harvesting of trees within Zones 2 and 3 can and should occur. However, logs can only be winched on a steel cable to a machine (skidder, specially equipped farm tractor, or small 4WD tractor) located outside of the buffer or removed by a mechanical harvester with a hydraulic boom. The

Watch the video: Create fishnet grid polygon with required dimension in ArcGIS