Arc: copy /res2/maidment/nonpoint/anprecip anprecip
Arc: grid
Grid: mape anprecip
Grid: gridpaint anprecip
Grid: describe anprecip

The painted version of this grid is not too informative, just a set of colored squares. We'll make a better version in Arcview later. The size of these squares is approximately 5 km. From this description of the grid, you can identify the range of precipitation values (min to max) over the basin. Note that the units of these values are in millimeters/year. Also verify cell-size and projection of the grid to check its compatibility with the DEM.

To Be Turned In: What is the range of the precipitation across the basin in mm/yr? What is the basin mean precipitation (mm/yr). What are the corresponding values in in/yr? What grid cell size and map projection are used?

Now create a polygon coverage of this grid. You'll need this to establish precipitation intervals for mapping in ArcView. In typing Grid commands, the target grid to be created is on the left hand side of the = sign, then to the right of the = sign comes the Grid function, and then the grids and parameters that are inputs to this operation. It seems to help the system interpret the command sequence if you leave spaces around each element of the command, as shown below:

Grid: raincov = gridpoly ( anprecip )

At any time in Grid or Arc, you can check what coverages you have with the commands lc (Listcoverages), and lg (Listgrids). For example at this point in the exercise, you have:

Grid: lc

 Available Coverages
 -------------------
  ARABASIN          COPBASIN          MISBASIN          RAINCOV
  SANBAYS           SANBORD           STREAMS

Grid: lg

 Available GRIDs
 -------------------
  ANPRECIP

Quit out of Grid and Arc/Info and fire up ArcView.

Grid: quit
Arc: quit
When you run an application in Unix, you can type & after the function and has the effect of allowing this function to be put in background later so that you can run a second process from the same window. Lets start up Arcview in this way:

$: arcview &

Open a new View and add the themes raincov (polygon) and sanbord (arc) from your /ex5 directory, using the button. When the themes show up in the legend of the view, double click on the raincov symbol (rectangle) to bring up the Legend Editor window. In the Legend Editor, click on the arrow to the right of the Field line to select a different field through which to view the raincov theme. Scroll down and select grid-code; this is the field that contains the annual precip value from the grid that you just converted. You should see 5 ranges of precipitation values in shades from white to black:

Click on the box. Now click on the first range of values to the right of the white symbol. The range will become "black lit". You may now change the effective range for the white symbol. Follow this procedure to change all of the ranges so that they run from the minimum to the maximum precip values from the grid. For example:

Click on the box and change the ranges of labels to correspond to the Value changes that you just made. Now use the Legend Editor to change the color scheme of raincov to get a ramped effect by clicking in the top box and selecting a light blue color, the bottom box to select a dark blue color, and then hitting the Ramp button. You'll see the intermediate boxes change their colors to grade between the colors of the top and bottom boxes. When you are finished, select in the Legend Editor window and then close both the Legend Editor and Fill Palette. Finally, select the raincov and sanbord themes in the View Legend. You should be able to easily see the distribution of annual precipitation in the San Antonio-Nueces Basin.

$: arc
Arc: grid
Grid: runoff = 1.0527 * anprecip - 799.37

Make sure that you leave spaces BEFORE AND AFTER each of the operators (i.e. =, *, -) in this equation.

Grid: display 9999
Grid: mape runoff
Grid: gridpaint runoff

Now use the cellvalue command to investigate values of runoff throughout the basin:

Grid: cellvalue runoff *

A cursor with crosshairs will appear on the Grid. With the cursor, click on a number of different locations in the basin to identify values of average annual runoff at those points. What happens when you click on a location in the very northwestern edge of the basin?? Based on the above linear relationship, negative values of runoff occur for any precipitation value less than or equal to 759 mm/yr. Since the concept of negative runoff is meaningless, you need to correct the runoff grid for these cases. But first, type 9 with the cursor positioned over the Grid to get back to the Grid prompt.

Grid: kill runoff all
Grid: runoff = con(anprecip > 759, 1.0527 * anprecip - 799.37, 0)

Essentially this con-ditional statement says "For every cell in the anprecip grid that has a value > 759, apply the rainfall/runoff function to create the new runoff grid. Store values of 0 in the rest of the runoff grid cells."

Now, repaint the runoff grid and use the cellvalue command again to verify that only non-negative values occur in the new runoff grid.

If at any time, you want to clear the screen and repaint some coverages, you can use Grid: clear to clear the screen and then repaint it.

Grid: gridpaint runoff
Grid: arcs sanbord
Grid: cellvalue runoff * (return to Grid prompt by typing 9)

The int statement returns the integer values of each of the runoff cell values. You'll need to do this before creating an equivalent coverage.

Grid: irunoff = int(runoff)
Grid: describe irunoff

To Be Turned In: What is the mean runoff from the basin (mm/yr)? What is the range in the runoff (mm/yr)?

Create the equivalent coverage of the irunoff grid, using the gridpoly command, as before:

Grid: runoffcv = gridpoly(irunoff)
Grid: kill anprecip all
Grid: kill irunoff all

Now double-click on the ArcView icon on your Alpha workspace to restore the Arcview Project that you previously created. If you have closed Arcview, restart it and load the project that you saved previously.

In a new View, add runoffcv (polygon) and sanbord (arc) as themes. As before, select grid-code in the Legend Editor as the field through which to display the theme, and change the Value and Label ranges to reflect approximately equal intervals between the minimum and maximum runoff grid values. Change the color scheme of the theme and all of your changes. Close the Fill Palette and Legend Editor and select the runoffcv and sanbord themes to view the runoff distribution in the basin.

$ cp /res2/maidment/nonpoint/lanuses.e00 lanuses.e00
$ cp /res2/maidment/nonpoint/emc.txt emc.txt
$ cp /res2/maidment/nonpoint/emca.dat emca.dat

Use the Unix command ls to check that you have got all the files:

alpha62:ce397m:/class/ce397m/ex5$ ls
arabasin/      info/          nonpoint.htm   runoffcv/
copbasin/      lanuses.e00*   precip.apr     sanbays/
emc.txt*       log*           raincov/       sanbord/
emca.dat*      misbasin/      runoff/        streams/

Import the land use coverage from the .e00 file.
Arc: import cover lanuses lanuses
Importing lanuses from interchange file lanuses.e00...

Delete the interchange file to save space. This rm command is executed from within Arc but it drops back to the basic Unix system to be executed because Arc has no rm function:

Arc: rm lanuses.e00
Submitting command to Operating System ...

Then call up Arcplot to view the coverage:
Arc: arcplot
Arcplot: display 9999
Arcplot mape lanuses
Arcplot: arcs lanuses

Wow! A pretty detailed coverage. Notice that the parallels and meridians intersect some of the landuse polygons. These lines arise from the fact that a number of maps were joined to form the coverage that you see here. You can get rid of the parallels and meridians by using the Arc/Info dissolve command. This command removes all arcs separating polygons with equal values for a particular attribute:

Arcplot: quit
Arc: dissolve lanuses luse lanuses-id poly

Don't worry if you see some error statements here. They don't seem to be fatal.
Make note of the 4 arguments in the dissolve command. What this command says is:
(1) dissolve the coverage lanuses to create a new coverage called luse.
(2) Use the coverage attribute lanuses-id as the item to decide which arcs to remove. Arcs are removed between any two polygons which have the same lanuses-id.
(3) Define the new coverage as a polygon coverage.

Now view the dissolved coverage in Arcplot:

Arc: arcplot
Arcplot: mape luse
Arcplot: arcs luse

You'll see that nearly all the straight map borders have been dissolved. Overlay the San Antonio-Nueces Basin border:

Arcplot: linecolor 2
Arcplot: arcs sanbord

Arc: copy /res2/maidment/nonpoint/sanfdr sanfdr
Arc: grid

In order to perform this analysis, you'll first need to convert your EMC maps to equivalent grids. Just as you used the gridpoly command to create equivalent polygon coverages from grids, you can create grid representations of coverages using polygrid:

Grid: phosgrid = polygrid(sanlu,tp,#,#,100)

With this command, you are specifying to use the tp item to define the values of the grid cells. You are also specifying to create a grid of cell-sizes = 100 m. Now determine the annual Phosphorus loading contribution from each cell in the grid by multiplying your runoff grid by your EMC grid:

Grid: phosld = phosgrid * runoff
Grid: kill phosgrid all

Accumulate these cell-based values for annual Phosphorus load to determine downstream values of average annual loads:

Grid: phosfac = flowaccumulation(sanfdr,phosld)

This command is what is known as a WEIGHTED flow accumulation. This is an extension of the regular flowaccumulation command which uses the flow direction grid to count the number of cells upstream of each particular cell in the grid. It then stores that particular count as the value for that cell. For the WEIGHTED flowaccumulation command, a weight grid (in this case, phosld) is used and t he SUM of the values in the cells upstream of a particular cell is what is stored as the value of that cell.

Grid: kill phosld all
Grid: phloadkg = phosfac / 100

This step is necessary to get the resultant load grid in units of kilograms. The conversion constant of 100 comes about because the input units are mm/yr for runoff and mg/l for concentration, the output units are kg/yr for loading, there are 1,000,000 mg / kg, and each cell has 10,000 m2 area. In effect, for each cell, the load is computed as

Load = Runoff * Concentration * Cell Area (1)

where the cell area is 10,000 m2.

To Be Turned In: A units analysis of the above formula to show why dividing the product of the load and concentration grids by 100 leads to the correct units for the loading (kg/yr).

Grid: kill phosfac all
Grid: describe phloadkg

Use this describe command to identify the maximum value for average annual phosphorus loading on the grid. Also, note that the values in the grid are real number values. Later, you'll need to convert parts of this grid to coverages, which will require the grid to be an integer grid. Go ahead, now and convert the real # grid to an integer grid:

Grid: display 9999
Grid: mape phosload
Grid: gridpaint phosload value linear nowrap gray
Grid: linecolor 2
Grid: arcs arabasin
Grid: arcs misbasin
Grid: arcs copbasin

Notice that, for the Aransas sub-basin, there are actually 3 streams that drain into Copano Bay in close proximity to each other. The northernmost of these streams is the Aransas River and, proceeding south, the other streams are Chiltipin Creek and Taft Creek. This subwatershed boundary was constructed by delineating the watersheds for each of the 3 streams and then merging the resultant grids.

Now comes the fun part! We are going to identify the phosophorus loads coming into Copano Bay from the different rivers.

Use the Pan/Zoom feature of the GRID display window to create a zoomed view of the Aransas basin outlet. From the main GRID window, click on Pan/Zoom and select Create. A cursor with crosshairs will show up on the window. Click once just a little to the northwest of where the subwatershed outlet is. Then, as you move the cursor to the southeast, a small box will form. When the cursor is just a little to the southeast of the watershed outlet, click again. Make the expanded View window as large as you can in your workspace and then repaint the load grid.

Grid: gridpaint phosload value linear nowrap gray

Wow! Pretty cool! Now you can see the individual cells in the river as they enter the bay. Lets check the load from the outlet:

Grid: cellvalue phosload *

With the cursor, click on the outlet cells and read off the value that is given there. You should get a number between 9,000 and 70,000 kg / yr depending on which outlet you choose. Click on a few places in the stream going upstream and see how the load accumulation increases going downstream, and how it jumps when you go past a tributary. Type 9 on the key board to exit when necessary.

Repeat this exercise for each of the five principal stream outlets to the bay (3 in the Aransas basin, 1 each in the Mission and Copano Basins).

Which stream contributes the most? What does this say about which land uses contribute the most to phosphorus loading through rainfall runoff?

To Be Turned In: A listing showing the 5 streams and their respective phosophorus loadings.

Close each of the expanded View Grid windows and repeat this analysis for Nitrogen. To do this, you are going to write a small Arc Macro Language Program (AML). This is a list of the commands that you would type one by one at the keyboard which is stored in a text file so that they can all be executed in a sequence without having to be individually entered. For this procedure, open a text editor window and enter the following text:

nitgrid = polygrid (sanlu,tn,#,#,100)
nitld = nitgrid * runoff
kill nitgrid all
nitfac = flowaccumulation(sanfdr, nitld)
kill nitld all
niloadkg = nitfac / 100
kill nitfac all
nitload = int(niloadkg)
buildvat nitload
kill niloadkg all
display 9999
mape nitload
gridpaint nitload value linear nowrap gray
linecolor 2
arcs arabasin
arcs misbasin
arcs copbasin
&return

Remember to hit <return> after typing &return. Save the file in your local working directory as load.aml. Now you can invoke this AML from the grid prompt as:

Grid: &run load.aml (this will take some time to complete)

Use Pan/Zoom to create expanded Views of the subwatershed outlets:

Grid: gridpaint nitload value linear nowrap gray
Grid: cellvalue nitload *
Record the average annual nitrogen loadings values at each of the 5 main outlets and determine the annual loadings from each subwatershed. Type 9 to get back to the Grid prompt.

To Be Turned In: Nitrogen loadings from each subwatershed.

Now lets liberate some file space!

Grid: kill runoff all
Grid: kill sanfdr all

Close each of the expanded View Grid windows when you are done.

From the above Grid analyses with phosload and nitload, it is evident that the largest accumulated nutrient loadings occur within the stream networks. One method for visualization of the loadings distribution in the basin is to convert grid cells whose values exceed certain threshold values to equivalent arc coverages. For example, the largest load value in the phosload grid is approximately 60,000 kg/yr. By setting a threshold value of, say, 50,000, the stream reaches where the greatest loadings occur can be identified:

Grid: maxload = con(phosload > 50000,1)

This command stores a 1 in maxload cells that correspond to phosload cells with values > 50,000. The rest of the maxload cells get a value of NODATA. This string of cells can be converted to an arc coverage by using the gridline command:

Grid: phld50k = gridline(maxload)

Further, these 2 commands can be combined by substituting the equation for maxload into the equation for phld50k .... i.e. phld50k = gridline(con(phosload > 50000,1))

Now, create arc coverages for other loading threshold values. Lets do this with an aml called line.aml:

Type in a text editor window:

phld10k = gridline(con(phosload > 10000,1))
phld5k = gridline(con(phosload > 5000,1))
phld1k = gridline(con(phosload > 1000,1))
&return

Grid: &run line.aml

Check to see if you have got the new coverages:

Grid: lc

Available Coverages
 -------------------
  ARABASIN          COPBASIN          MISBASIN          PHLD10K
  PHLD1K            PHLD50K           PHLD5K            RAINCOV
  RUNOFFCV          SANBAYS           SANBORD           SANLU
  STREAMS

You can use ArcView to represent the loadings distribution in the basin, using these newly created arc coverages. Click on the ArcView icon in the Alpha workspace and, in a new View, add the following themes: phld50k, phld10k, phld5k, phld1k, sanbord (arc), and sanbays (polygon). In the legend of the new View, drag sanbord and sanbays to the bottom of the theme list. Then, rearrange the phosphorus load themes in decreasing order, from phld50k at the top down to phld1k. Using the Fill Palette, select light colors for the smaller threshold themes and darker colors for the larger loading themes:

Select all of these themes in the View to get an overview of average annual phosphorus loadings in the basin.