Page Banner

United States Department of Agriculture

Agricultural Research Service

Related Topics

Issue: November/December 2004
headline bar
<TABLE id=table1 cellSpacing=0 cellPadding=0 width="100%" border=0> 
<TBODY> 
<TR> 
<TD background=file:///O:/newwebpage/sitepublisherwebsite/images/newsimages/new/plainfactstitleextension.jpg><IMG alt="Northern PlainFacts Newsletter." src="http://www.ars.usda.gov/images/docs/6758_6942/plainfactstitle.jpg"></TD></TR> 
<TR> 
<TD> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px" align=left><B><FONT face=Verdana size=2>Current Issue: November/December 2004</FONT></B></P></TD></TR> 
<TR> 
<TD vAlign=top width="77%"> 
<P><FONT face=Verdana size=-1><BR>The Northern PlainFacts from the <B><A href="/Main/docs.htm?docid=3386"><FONT color=#0000ff>USDA-ARS Northern Plains Agricultural Research Laboratory</FONT></A></B> in Sidney, Montana, offers brief updates on research, personnel and events at the lab, and includes contact names and e-mail addresses for those interested in further details. <BR>&nbsp;</FONT></P></TD></TR> 
<TR> 
<TD width="82%"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"></P><FONT face=Verdana color=#111111 size=2><FONT face=Verdana color=#111111 size=2><FONT face=Verdana color=#111111 size=2> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG>In This Month's Issue:</STRONG></FONT> <BR> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#12"><FONT color=#0000ff>ARS Scientist Awarded CSREES Grant for Sugarbeet</FONT> <FONT color=#0000ff>Research</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#11"><FONT color=#0000ff>MT Extension Agent invited to speak at ARS Brown</FONT> <FONT color=#0000ff>Bagger</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#10"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>Employees Participate in Gift Drive for Needy</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#9"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>Research Lab Hosts Winter Weather Safety Class</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#8"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>Scientists Speak to Busch Ag Representatives</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#7"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>Research Leader Addresses Fellow Lab’s Customer Focus Group</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#6"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>Scientists Participate in Integrated Agricultural Systems Workshop</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#1"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>researcher invited to speak at Swiss University</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#2"><FONT color=#0000ff>Montana</FONT> <FONT color=#0000ff>ARS researchers to participate in Entomological Society of America meeting</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#3"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>botanist to speak to rural school students</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#4"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>range scientist to speak at NPARL Brown Bagger</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><FONT face=Verdana color=#0000ff size=2><STRONG><A href="#5"><FONT color=#0000ff>ARS</FONT> <FONT color=#0000ff>representative to speak at Saltcedar Symposium</FONT></A></STRONG></FONT></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><B><FONT face=Verdana color=#0000ff size=2><A href="#20"><FONT color=#0000ff>ARS Rep Speaks to Civic Group on</FONT> <FONT color=#0000ff>ARS 50th</FONT></A></FONT></B></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><U><B><FONT face=Verdana color=#0000ff size=2><A href="#21"><FONT color=#0000ff>ARS Scientist Prepares Students for Science</FONT> <FONT color=#0000ff>Projects</FONT></A></FONT></B></U>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><B><FONT face=Verdana size=2><A name=21></A>ARS Scientist Prepares Students for Science Projects</FONT></B>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>Dr. John Gaskin, a botanist with NPARL’s Pest Management Research Unit in Sidney MT, was invited to work with local Rau Elementary School students December 9th, to help them prepare projects for their upcoming science fair in January 2005. Dr. Gaskin's presentation was entitled “Science and the scientific method,” and in it he outlined how to test hypotheses and properly use controls and repetitions in science fair projects. In addition to Dr. Gaskin’s preliminary contribution, numerous other NPARL scientists and technicians also help judge the rural Montana school’s annual science fair each year.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>(John Gaskin, 406.433.9444, jgaskin[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><B><FONT face=Verdana size=2><A name=20></A>ARS Rep Speaks to Civic Group on ARS 50th</FONT></B>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>Beth Redlin, Technical Information Specialist with NPARL, was invited to address the Sidney, MT Lions Club Dec. 13 to discuss ARS’ year-long 50th anniversary celebration. In her presentation, Redlin outlined the impact ARS achievements have had on all our daily lives over the past 50 years, using selected grocery items to illustrate her point, from diapers to tomato paste to soy milk to frozen dinners. She also touched on ARS achievements at NPARL over that same time period, including pioneering work done on grass row barriers for erosion control; saline seep remediation, and biological control of leafy spurge. Redlin also pointed out the economic value of ARS efforts, noting that federal funding of agricultural research returns $1.35 for every dollar spent.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2></FONT>&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>(Beth Redlin, 406.433.9427, bredlin[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=12></A>ARS Scientist Awarded CSREES Grant for Sugarbeet Research</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>Dr. Stefan Jaronski, Research Entomologist with NPARL’s Pest Management Research Unit in Sidney MT and Dr. Mark Boetel, Entomology Department, North Dakota State University, have been awarded two-year funding for “Integration of microbial and cultural control tools to manage the Sugarbeet Root Maggot” by the CSREES Pest Management Alternatives Program. Their goal is to manage the economic impact of the insect by integrating a cereal, nurse-cover crop with the insect pathogenic fungus, Metarhizium anisopliae, to protect the sugarbeet crop. The Metarhizium being used has already been found to be efficacious at low, but not high, insect pressure. If successful, their research would provide sugarbeet producers with an integrated and biobased system for minimizing the impact of the insect by combining a proven cultural strategy and a microbial agent. Their research will be conducted in both the Yellowstone River Valley (Montana) and Red River Valley (ND/MN) growing regions, and under several different irrigation regimes. The sugarbeet root maggot is the most important pest of sugar beets in the North Central United States.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2></FONT>&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Stefan Jaronski, 406.433.9486, sjaronski[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=11></A>MT Extension Agent invited to speak at ARS Brown Bagger</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>Richland County (MT) Richland County (MT) Extension Agent Ben Larson will be giving the third presentation in NPARL’s 2004-2005 Brown Bagger series at noon Friday, December 10th. These informal (and informational) presentations on a variety of research related topics are held periodically at the Sidney ARS lab during the winter months. All are open to the public. Larson’s presentation is entitled “Integrated Pest Management of Cercospora Leaf Spot on Sugar Beets” and discusses his research on different management strategies for Cercospora integrating host-plant resistance, registered fungicides, and a bacterial biocontrol agent, Bacillus mycoides.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=10></A>ARS Employees Participate in Gift Drive for Needy</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>NPARL employees are participating in the 2004 “Gifts from the Heart” campaign this holiday season in Richland County, Montana. The campaign provides gifts of toys, games, food and clothing to needy families in the community where the lab is located and includes participants from a variety of organizations. For its part, NPARL has put up a tree with tags listing different ages and gift items needed, which employees will then purchase for distribution to area families on Saturday, December 18th. Under the unique program, parents from participating families will gather at a central location on that date to “shop” for gifts for their children from among the items collected. Each family also receives a food basket, family game and winter clothing under the program.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=9></A>ARS Research Lab Hosts Winter Weather Safety Class</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>NPARL hosted two winter weather safety classes for employees and the general public at the Sidney, Montana ARS research lab on Dec. 2. Leading the training were meteorologists Jeff and Jennifer Zeltwanger, a husband and wife team with the National Weather Service in Glasgow, MT. Altogether 27 employees and more than a dozen members of the general public participated in the training sessions, which featured tips on safe winter travel and definitions for common winter weather advisory terms. The training was organized by NPARL Safety Officer Jackie Couture.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2></FONT>&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Jackie Couture, 406.433.9422, jcouture[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=8></A>ARS Scientists Speak to Busch Ag Representatives</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>NPARL Agricultural Engineer and Irrigation specialist Robert Evans and Soil Scientist Jed Waddell both addressed a joint meeting of Mid-West and Western operations and field staff with Busch Agricultural Resources, Inc. held at the Sidney, Montana ARS facility from Nov. 30 through Dec. 2. Dr. Evans, head of NPARL’s Agricultural Systems Research Unit (ASRU), addressed the group on the basics of malting barely irrigation under surface and center pivot irrigation, as well as discussing current and potential ASRU research incorporating malting barley. Dr. Waddell’s presentation was entitled “Malt Barley Irrigation and Nitrogen Management in the MonDak Region.” In it he discussed preliminary results from a field study conducted in cooperation with Busch Ag and area farmers demonstrating appropriate N fertilization levels, proper water application and suitable methods for measuring water content in the field.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Robert Evans, 406.433.9496, revans[at]sidney.ars.usda.gov)<BR>(Jed Waddell, 406.433.9402, jwaddell[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=7></A>ARS Research Leader Addresses Fellow Lab’s Customer Focus Group</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>ARS Rangeland Scientist Rod Heitschmidt, Research Leader with the USDA-ARS Fort Keogh Range and Livestock Research Laboratory in Miles City, MT, provided members of NPARL’s Customer Focus Group an overview of research conducted at his facility in a meeting held in Sidney, MT, November 30th. The presentation was arranged by NPARL officials after its Focus Group members expressed interest in learning more about ARS research being conducted in the region. The Miles City and Sidney labs are the only two ARS laboratories in the state of Montana. NPARL Focus Group members also heard research updates from Sidney scientists and discussed future research priorities for the Sidney lab during the group’s annual winter meeting.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=6></A>ARS Scientists Participate in Integrated Agricultural Systems Workshop</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>Five NPARL scientists with the Sidney lab’s Agricultural Systems Research Unit (ASRU) were among two dozen ARS researchers participating in a recent USDA-ARS Integrated Agricultural Systems Workshop held Nov. 16-17 in Mandan, ND. The group’s mission was to organize common principles, criteria and indicators that exist across physiographic regions to provide insight into the management of integrated agricultural systems. Held at the USDA-ARS Northern Great Plains Research Laboratory, the workshop was led by Drs. Jon Hanson and John Hendrickson of Mandan, Dr. Mike Jawson, National Program Staff and Dr. Gerry Anderson, of NPARL, and was designed to foster creativity and collaboration among USDA-ARS natural resources research facilities. Participants hope to ultimately develop products to help producers develop integrated agricultural systems. In addition to Ecologist Gerry Anderson, other participants from NPARL included Soil Scientists Jed Waddell and Upendra Sainju, Weed Ecologist Andy Lenssen and Agricultural Engineer and ASRU Research Leader Robert Evans.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Gerry Anderson, 406.433.9416, ganderson[at]sidney.ars.usda.gov)<BR>(Robert Evans, 406.433.9496, revans[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Andy Lenssen, 406.433.9471, alenssen[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Upendra Sainju, 406.433.9408, usainju[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Jed Waddell, 406.433.9402, jwaddell[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"></FONT><FONT face=Verdana color=#111111 size=2><STRONG></STRONG></FONT> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=1></A>ARS researcher invited to speak at Swiss University</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>NPARL’s Dr. Anthony Caesar, a plant pathologist with the Sidney, MT ARS lab’s Pest Management Research Unit, has been asked to give a seminar at the University of Geneva (Geneva, Switzerland), Department of Vegetative Biology on November 11. Dr. Caesar’s presentation is entitled “Biological Control of Invasive Plants and the Application of Ecological Data, a Case Study.” Dr. Caesar was invited to speak by Dr. Francisco Barja, and, following his formal presentation, will meet with Dr. Barja and department students and staff to answer questions and discuss possible joint projects.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Anthony Caesar, 406.433.9412, caesara[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><STRONG><A name=2></A>Montana ARS researchers to participate in Entomological Society of America meeting</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>Several scientists from NPARL’s Pest Management Research Unit (PMRU) will be participating in the 2004 annual meeting of the Entomological Society of America to be held in Salt Lake City, UT, Nov. 13-18. This year’s theme is “Entomology and ESA: Our Heritage, Our Future”. NPARL researchers and their presentation / poster topics include:</FONT>  
<BLOCKQUOTE> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>Ecologist and remote sensing specialist Gerry Anderson is coauthor on a poster being presented by Dr. Raymond I. Carruthers (USDA-ARS, Exotic and Invasive Weed Research Unit, St., Albany, CA). entitled “Use of remote sensing in the evaluation of herbivory and population dispersal by Diorhabda elongata.” </FONT> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><BR>Entomologist Stefan Jaronski will speak on “Maggoty synthesis: What can we learn from each other?” as part of a symposium on “(Root) Maggot Mania: Insights into Biology and Management of Root Maggot Pests” that he helped organize along with Amy Dreves of Oregon State University, Corvallis, OR. Dr. Jaronski is also co-author on another paper being presented by Mark Boetel of North Dakota State University entitled “Sugarbeet root maggot management: Conventional tools and the pursuit of integrated strategies,” and has a poster on display entitled, “Laboratory infectivity and virulence of the Australian Metarhizium anisopliae var. acridum strain FI985 and Beauveria bassiana Strain GHA for North American acridids and Anabrus simplex.”</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><BR>Entomologist David Kazmer will discuss “Molecular markers for distinguishing populations of Diorhabda elongata and monitoring hybridization in the field.” The presentation is part of a symposium on “The Biological Control of Saltcedar (Tamarix spp.): Multidisciplinary Approaches Enhance Success” organized by Dr. Kazmer and Dr. Daniel W. Bean, with the University of California, Davis. Co-author on Dr. Kazmer’s paper presentation is Dr. John Gaskin, a botanist with PMRU.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2><BR>Entomologist Tom Shanower is doing a poster presentation entitled “Impact of natural enemies on wheat stem sawfly (Cephuscinctus Norton [Hymenoptera: Cephidae]) populations in eastern Montana.”<BR>Ecologist Gregory Sword is co-organizing an Orthopterists’ Society Symposium on the “Future of Orthopteran Science” with Hojun Song, of Ohio State University, Columbus. As part of that symposium he is presenting a paper entitled, “Linking locust gregarization to local resource distribution patterns across a large spatial scale.” Co-author on that effort is Mohammed Abdallahi Ould Babah of the Centre de Lutte Antiacridienne, Nouakchott, Mauritania. Dr. Sword is also presenting a second paper at the meeting entitled “The life, legend, and lessons of the Mormon cricket,” as part of a symposium on “Legendary Orthoptera of North America: The Mormon Cricket and the Rocky Mountain Locust.”</FONT></P></BLOCKQUOTE> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>Founded in 1889, the Entomological Society of America is a non-profit organization committed to serving the scientific and professional needs of nearly 6,000 entomologists and individuals in related disciplines. ESA's membership includes representatives from educational institutions, government, health agencies, and private industry.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana color=#111111 size=2>(Gerry Anderson, 406.433.9416, ganderson[at]sidney.ars.usda.gov)<BR>(Stefan Jaronski, 406.433.9486, sjaronki[at]sidney.ars.usda.gov)<BR>(David Kazmer, 406.433.9440, dkazmer[at]sidney.ars.usda.gov)<BR>(Tom Shanower, 406.433.9405, tshanower[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2><STRONG></STRONG></FONT> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2><STRONG><A name=3></A>ARS botanist to speak to rural school students</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>NPARL Botanist John Gaskin was invited to speak to the third and fifth grade students at Rau Elementary School, a rural school in Richland County, Montana on Tuesday, November 9th. Gaskin discussed “Plants and Plant Science” during his 45-minute presentation to the students. Gaskin is a researcher with NPARL’s Pest Management Research Unit. His current work focuses on the biological control of invasive weeds including saltcedar and whitetop.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>(John Gaskin, 406.433.9444, jgaskin[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2><STRONG></STRONG></FONT> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2><STRONG><A name=4></A>ARS range scientist to speak at NPARL Brown Bagger</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>ARS Range Ecologist Lance T. Vermeire will be giving the second presentation in the USDA-ARS Northern Plains Agricultural Research Laboratory‘s 2004-2005 Brown Bagger series at noon Friday, November 12th. Vermeire’s presentation is entitled “Fire and Post-Fire Grazing in the Great Plains” and reflects his recent research at the USDA-ARS Fort Keogh Livestock and Range Research Laboratory in Miles City, MT, where he is examining the ecological ramifications of natural disturbances. At Fort Keogh, Vermeire has been studying plant community responses to summer fire, post-fire grazing management and long-term livestock exclusion, as well as studying fire effects on grasshopper communities. The latter research is being conducted in collaboration with Sidney ARS Research Entomologist David Branson. The NPARL Brown Bagger series features informal presentations on a variety of research related topics held periodically during the winter months. All are open to the public.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2><STRONG></STRONG></FONT> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2><STRONG><A name=5></A>ARS representative to speak at Saltcedar Symposium</STRONG></FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>NPARL Biological Science Technician Mary Mayer has been invited to speak Nov. 22-23 at the Saltcedar and Noxious Weed Symposium sponsored by the Midmusselshell Watershed Group in Roundup and Lavina, MT. Mayer’s presentation is entitled “Biological Control of Saltcedar” and describes the work underway on saltcedar at the USDA-ARS Northern Plains Agricultural Research Laboratory in Sidney, MT. Mayer works with Entomologist Dave Kazmer in the lab’s Pest Management Research Unit in its Biological Control of Weeds research. In addition to ARS, other agencies represented at the symposium include: Yellowstone County (MT) Weed District; DowAgroSciences; Bureau of Land Management and the Extension Service of Musselshell and Golden Valley Counties.</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2></FONT>&nbsp; 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>(Dave Kazmer, 406.433.9440, dkazmer[at]sidney.ars.usda.gov)</FONT>  
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px"><FONT face=Verdana size=2>(Mary Mayer, 406.433.9426, mmayer[at]sidney.ars.usda.gov)</FONT></P> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp;</P> 
<P style="MARGIN-TOP: 0px; MARGIN-BOTTOM: 0px">&nbsp;</P></FONT></FONT></TD></TR></TBODY></TABLE>

Last Modified: 8/13/2016
Footer Content Back to Top of Page