Page Banner

United States Department of Agriculture

Agricultural Research Service

Related Topics

Past Key Mission Area News
headline bar
<P><IMG alt="News Image" src="http://ars.usda.gov/sp2userfiles/Place/54000000/images/Category-NewsEvents.jpg"><A name=top></A></P> 
<P>Past Northern Plains Area Weekly Activity Reports:</P> 
<P><SPAN>March 4, 2009</SPAN></P> 
<P><SPAN><STRONG>ARS Researcher Participates In Regional ACE Fish Wildlife Workshop</STRONG>: On March 3-5, NPARL Research Botanist and Pest Management Research Unit Leader John Gaskin was invited to speak at the Northwestern Division of Army Corps of Engineers Fish and Wildlife Workshop held in Coeur D’Alene, ID. Dr. Gaskin’s presentation, entitled “The use of molecular genetics in controlling invasions,” was among several offered at the session on ongoing research surrounding invasive plant and animals. The three-day event included presentations by representatives from several state and federal agencies, organizations and private businesses and tribal governments and regarding fish and wildlife habitat and management programs and issues in the region.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>February 04, 2009</SPAN></P> 
<P><SPAN><STRONG>ARS Reps Help Judge Rural Science Fair:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). Seven NPARL staff members, both scientists and technicians, helped judge the Rau Elementary School Science Fair held January 29 at the rural Sidney, MT, school. The judges reviewed numerous projects submitted by 3rd through 6th grade students at the school, which serves approximately 60 students from the surrounding countryside. The judges worked in teams, typically with an ARS representative teamed with another judge from the community. The judging criteria included use of the scientific method, display quality, adherence to project guidelines, effort, originality, as well as student understanding and oral communication, the latter garnered through personal interviews with the student. This year there were several experiments with plants and growth rates, along with fertilizer methods. Participating from NPARL were: technicians Mary Mayer, Paul Kaufmann, Nicole Davidson, and Laura Senior and scientists Dr. Robert Srygley, Bill Iversen and Dr. Dave Branson. NPARL staff members also typically help with preparations for the science fair by giving a presentation for students at the school several weeks prior to that year’s event, discussing the scientific method and how to set up a science experiment. All of this year’s volunteer judges are with NPARL’s Pest Management Research Unit, except Physical Scientist Bill Iversen, who works in the Agricultural Systems Research Unit.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>January 28, 2009</SPAN></P> 
<P><SPAN><STRONG>Young Grain Growers Tour Montana ARS Laboratory: </STRONG>(USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). Forty-two young producers toured NPARL Jan. 28, as part of the Montana Grain Growers Association’s 2009 Young Grain Growers Marketing Tour. Entitled the “Follow the Markets” tour, the group is traveling from Central Montana to Minneapolis, MN, making stops along the way at ag research and related facilities and businesses.&nbsp; At NPARL, tour participants heard two presentations, the first an overview of the Sidney ARS lab by Agricultural Systems Research Unit Leader Robert Evans, and the second an overview of the wheat stem sawfly biological control program and a “virtual” tour of NPARL’s new biological control containment facilit, by Biological Science Technician Deb Waters. The group then followed up with tours of the rest of the ARS research facility led by Evans, NPARL Research Plant Ecologist Erin Espeland, NPARL Research Agronomist Brett Allen, and NPARL Technical Information Specialist Beth Redlin.&nbsp; The group then visited researchers with Montana State University’s Eastern Agricultural Research Center, which is co-located with ARS in Sidney, before completing their stay with a stop at the local Busch Ag malting barley storage facility. Dr. Allen is a member of NPARL’s Agricultural Systems Research Unit, while Waters and Dr. Espeland are members of the lab’s Pest Management Research Unit.&nbsp;&nbsp;&nbsp; </P> 
<P><STRONG>Montana ARS Research Featured At Regional Farm Shows:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). NPARL employees will be participating in two area agricultural trade shows in February. On Feb. 3-4, NPARL employees will staff a booth at the 56th National Hard Spring Wheat Show in Williston, ND. On display will be information on the Montana ARS lab’s dryland cropping systems research, with a focus on the use of alternative management systems and diverse rotations to help manage crop weeds. That research is being conducted by Dr. Andrew Lennsen, NPARL Weed Ecologist with the lab’s Agricultural Systems Research Unit. Also featured at the Williston, ND locale will be information on NPARL’s biological control program for wheat stem sawfly and the Mormon cricket immunology research being conducted by NPARL Research Ecologist Robert Srygley. On Feb. 13-14, NPARL will have another booth at the Glendive Agri-Trade Exhibition in Glendive, MT. That booth will feature research by NPARL Agronomist Bart Stevens looking at nitrogen application rates in strip-tilled versus conventionally tilled sugar beet under sprinkler irrigation. That research has shown that conventional fertilizer rates produced comparable yields and sugar percentages in the strip-tilled test crop. Stevens and other researchers with NPARL’s Agricultural Systems Research Unit previously demonstrated significant time and energy savings for strip tilled sugar beet since as many as five or six fewer passes were needed across the field, along with reduced environmental impacts. Their findings are now prompting producers both locally and across the region to convert thousands of acres of conventionally tilled sugar beet to strip till.</P> 
<P><STRONG>ARS Molecular Biologist To Present Paper In Florida</STRONG>:&nbsp; ARS Molecular Biologist, Brenda Oppert with the Biological Research Unit, Grain Marketing and Production Research Center, Manhattan, KS, will attend the Advances in Genome Biology and Technology meeting at Marco Island, Florida, February 4-7. She will present the paper “Transcriptome profiling of Bacillus thuringiensis Cry3Aa intoxication of Tenebrio molitor larvae."</P> 
<P align=right><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>December 10, 2008</SPAN></P> 
<P><SPAN><STRONG>Agricultural Research Service (ARS) Northern Plains Area Scientists To Present At Forest Service Symposium On Climate Change:</STRONG> On December 11th, Drs. Jack Morgan (Research Leader/Plant Physiologist, Ft. Collins, CO) and Mark Liebig (Research Soil Scientist, Mandan, ND) will give presentations at the Custer National Forest division’s Symposium on Climate Change in Billings, MT.&nbsp; Dr. Morgan will speak on ‘Vegetation and Invasives under a Changing Climate’ while Dr. Liebig will present ‘Management Effects on Soil Carbon Dynamics in Rangeland Ecosystems’.&nbsp; They gave similar presentations at the Dakota Prairie Grasslands division’s Symposium on Climate Change in Bismarck, ND on December 5th to an audience of over 50 attendees.</SPAN></P> 
<P><SPAN><STRONG>ARS Scientist Recipient Of The Red River Valley Sugarbeet Grower’s Association Distinguished Service Award:</STRONG>&nbsp; Karen Fugate (formerly Klotz), Research Plant Molecular Biologist, Sugarbeet & Potato Research Unit, Fargo, ND, was the 2008 recipient of the Red River Valley Sugarbeet Grower’s Association Distinguished Service Award.&nbsp; The award was presented at the annual meeting of the sugarbeet grower’s association held on December 4.&nbsp; Dr. Fugate was recognized for her research contributions to the sugarbeet industry which have focused on the effects of environment and disease on sugar retention and recovery from sugarbeets.&nbsp; </SPAN></P> 
<P><SPAN><STRONG>ARS Researcher Invited So Speak At South Dakota State University:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Research Entomologist Stefan Jaronski was invited to speak to the South Dakota University Department of Plant Sciences and the ARS North Central Agricultural Research Laboratory (NCARL), in Brookings, SD as part of their Fall 2008 Seminar Speaking Series. Dr. Jaronski, a member of NPARL’s Pest Management Research Unit, spoke at SDSU on December 8th. His seminar, entitled “Managing Maggot Mania Mycologically with Metarhizum,” featured his research on the sugar beet root maggot and the use of new fungal agents to help manage this important sugar beet pest. That research has shown that at low to moderate insect pressure Metarhizium works as well as the most common chemical control used. Dr. Jaronski is currently studying the integration of Metarhizium with a suite of other management tools to better control higher insect pressure situations.</SPAN></P> 
<P><SPAN><STRONG>ARS Researcher Invited To Speak At Irrigation Workshop:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Research Leader and Agricultural Engineer Robert Evans has been invited to speak at the “Maximize your $$$ Irrigation Workshop” to be held at North Dakota State University’s Williston Research Extension Center in Williston, ND, on December 17. The workshop will focus on how irrigators can achieve consistency in crop yields and quality, with an emphasis on specific water management techniques and crops. Dr. Evans, Research Leader of NPARLS’s Agricultural Systems Research Unit, will discuss the innovative research being done at NPARL on strip tillage of sugar beet. That research has shown that productivity and quality are comparable between strip tillage and conventional tillage systems over a five-year period. In addition, Sidney ARS research has shown that strip tillage can save producers up to $100/acre in fuel costs and time since it requires 5 to 6 fewer trips across the field than does conventional tillage. Joining Dr. Evans to discuss additional strip tillage research and application efforts at North Dakota State University in Fargo will be NDSU Ag Machines Specialist John Nowatzki and producer Scott Flynn. Other topics at the workshop include updates on EQIP programs, research at Nesson Valley, irrigation crop budgets, irrigation water management, irrigation scheduling and an update from the ND State Water Commission.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>December 3, 2008</SPAN></P> 
<P><SPAN><STRONG>ARS Researchers Invited To Meet With Scientists At International Bio Firm:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Research Entomologist Stefan Jaronski was invited to speak to researchers at Novozymes Biologicals, Corp. in Salem, VA Dec. 3 to discuss his sugarbeet maggot research using the firm’s Metarhizium fungus (F52). Novozymes is a global company headquartered in Denmark that produces industrial enzymes, microorganisms and biopharmaceutical ingredients for industry. Dr. Jaronski’s findings may lead to the expansion of Novozymes’ fungus registration to sugar beets. Also joining Dr. Jaronski was Microbiologist Mark Jackson, from ARS’ National Center for Agricultural Utilization Research in Peoria, IL, who discussed fermentation issues. Dr. Jaronski is a member of NPARL’s Pest Management Research Unit.</SPAN></P> 
<P><SPAN><STRONG>ARS researcher To Speak At The South Dakota Ag Horizons Conference:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Research Ecologist Dr. Andrew Lenssen was invited to speak at the 2008 “Crops, Critters and Carbons” Ag Horizons Conference held in Pierre, SD on December 2-3. Dr. Lenssen’s talk entitled “Dryland Cropping Systems for Improved Crop Productivity and Weed Management” was scheduled for presentation both days. His research addresses improved weed management and crop production practices in irrigated and dryland environments. An estimated 400 participants attended this year's two-day conference, which featured 25 speakers on a wide range of topics including cover crops, carbon credits, crop rotation, variety recommendations, entomology and weed management, fertilizer costs, and insurance and taxation updates. The event is popular with producers. Dr. Lennsen is a member of NPARL’s Agricultural Systems Research Unit. </SPAN></P> 
<P><SPAN><STRONG>ARS Researcher To speak At the WA Horticultural Association Meeting:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Agricultural Engineer Dr. Robert Evans spoke at the 104th annual meeting of the Washington State Horticultural Association held in Yakima, WA, on December 1-3. The meeting “Celebrating Tree Fruit: Opportunities for the Next Generation” was attended by over 1,300 participants and 200 exhibitors. Dr. Evans gave a keynote address on the basics of reducing low temperature injury to orchard and vine crops to growers, industry and Extension people. The speaking invitation was the result of previous research on cold temperature protection of crops conducted by Dr. Evans while at Washington State University. Dr. Evans currently serves as Research Leader of NPARL’s Agricultural Systems Research Unit. The Washington State Horticultural Association was organized in 1904 and represents both shippers and growers. Their mission is to advance and enhance the tree fruit industry in the state of Washington.</SPAN></P> 
<P><SPAN><STRONG>ARS Scientist Gives Seminar On Stored Product Entomology At University Of Manitoba</STRONG>:&nbsp; On December 4, Frank Arthur, Research Entomologist, ARS Grain Marketing and Production Research Center, Manhattan, KS, will present a seminar “Stored Product Entomology: Present Status and Future Trends” to the University of Manitoba's Department of Entomology, Winnipeg, Canada.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>November 13, 2008</SPAN></P> 
<P><SPAN><STRONG>ARS Scientists To Attend National Meeting Of The Entomological Society of America</STRONG>: Drs. Frank Arthur, Jim Campbell, Brenda Oppert, and Jim Throne with the Biological Research Unit, Grain Marketing and Production Research Center, Manhattan, KS, will attend the annual meeting November 16-20.&nbsp; Presentations to be given are: Stored-product Entomology, Past, Present and Future by Frank Arthur; Influence of spillage landscape pattern on red flour beetle response to pheromone traps by Jim Campbell; and Functional analysis of Bt intoxication in coleopteran insects, Desiccation and hypoxic stress induced changes in gene expression in the red flour beetle, Tribolium castaneum (Herbst), and The Tribolium genome: Unlocking the secrets of the gut transcriptome and proteome by Brenda Oppert.</SPAN></P> 
<P><SPAN><STRONG>ARS Soil Scientist Participates In A Canadian Workshop To Develop Protocols To Reduce Nitrous Oxide Emissions From Nitrogen Application In Agricultural Systems</STRONG>:&nbsp; On October 27-29, soil scientist Ardell Halvorson, ARS Soil-Plant-Nutrient Research Unit, Fort Collins, CO, was an invited participant in a Nitrous Oxide Emissions Reduction Protocol workshop in Calgary, Alberta to establish protocols that farmers can follow to reduce nitrous oxide emissions from their land resulting from nitrogen application for which they will be compensated.&nbsp;&nbsp; Halvorson served as a scientific resource person for this process.&nbsp; The nitrous oxide reduction protocols established for Alberta will apply to other Prairie Provinces and will have applicability throughout Canada and potentially for the U.S.</SPAN></P> 
<P> 
<P><SPAN></SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P>October 29, 2008</P> 
<P><STRONG>ARS Scientists To Attend Fifteenth Annual Research Conference On Methyl Bromide Alternatives And Emissions Reduction:</STRONG>&nbsp; Drs. Frank Arthur and Jim Campbell with the Biological Research Unit, Grain Marketing and Production Research Center, Manhattan, KS, will attend the conference in Orlando, FL, November 11-14. The title of Dr. Arthur’s presentation is “Esfenvalerate plus methoprene aerosol to control the Indianmeal moth”, and title for Dr. Campbell’s talk is “Evaluating the impact of structural fumigation on pest populations.”&nbsp; </P> 
<P><STRONG>ARS Laboratory Hosts Chinese Delegation:</STRONG>&nbsp; On October 18-21, the ARS Wind Erosion Research Unit, Manhattan, KS, hosted three specialists from the Conservation Tillage Research Center and China Agricultural University,&nbsp; Beijing, China.&nbsp;&nbsp; The delegation met with WERU personnel to discuss potential collaborative research interests and visited the Wind Erosion Laboratory in preparation for expanding their wind erosion research program in China.&nbsp; WERU staff also provided tours and meetings with area farmers and the Biological and Agricultural Engineering Department at Kansas State University during their stay.</P> 
<P><STRONG>ARS Botanist Invited To Speak At International Invasive Plant Research Forum:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Research Botanist John Gaskin was invited to speak at an International Research Forum Oct. 28-29, in Richmond, British Columbia, Canada. The forum, entitled “Invasive Plant Research in British Columbia: Current Projects and Future Trends”, was hosted by the Invasive Plant Council of British Columbia. The intent of this forum was to discuss (1) research that is currently underway in the Canadian Province (and the Pacific NW that relates to the Province), (2) research that is required to inform successful invasive plant management in BC, and (3) next steps for invasive plant research in BC. Dr. Gaskin’s presentation for the event was entitled “DNA and Invasion Control.”&nbsp; He also participated in a panel discussion with other speakers also participating in the “New Approaches to Management” session of the forum. Dr. Gaskin is the Research Leader of NPARL’s Pest Management Research Unit.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><SPAN>October 7, 2008</SPAN></P> 
<P><SPAN><STRONG>ARS Researchers Participate In Joint Meeting Of Five Science Societies:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL researchers John Gaskin, W. Bart Stevens, Upendra Sainju, Jay Jabro, Andy Lenssen and Brett Allen all participated in the 2008 Joint Annual Meeting of five scientific societies Oct. 5-9 in Houston, TX. The meeting theme was “Celebrating the Year of the Plant” and brought together five Societies in an unprecedented joint technical program featuring papers from all geological disciplines and the soil, agronomic, and crop sciences. The societies represented include: The Geological Society of America, Soil Science Society of America, American Society of Agronomy, Crop Science Society of America and the Gulf Coast Association of Geological Studies. Contributions from scientists at the Sidney, MT ARS lab included the following presentations:</SPAN></P><SPAN> 
<UL> 
<LI>NPARL Botanist and Pest Management Research Unit Leader John Gaskin spoke at the Impact of Global Climate Change on Plant Genetic Resources Symposium on the “Hybridization and Plant Invasions” discussing the implications of increased plant invasion involving hybrid and how hybridization can force us to alter our methodology for controlling plant invasions.  
<LI>NPARL Agronomist W. Bart Stevens’ talk was entitled “Tillage and Irrigation Method Effects on Yield and Quality of Sugarbeet and Malting Barley” and discussed the use of reduced tillage and high-efficiency irrigation systems to reduce fuel and water inputs in those crops compared to conventional practices.</LI></UL> 
<P>Sidney, MT ARS researchers presenting posters at the joint meeting were:</P> 
<UL> 
<LI>NPARL Soil Scientist Upendra Sainju presented two posters entitled “Cropping Sequence Effect on Dryland Crop Root and Soil Properties” and “Tillage, Cropping Sequence, and Nitrogen Fertilization Effects on Dryland Soil Carbon Dioxide Emission and Carbon Content (GRACEnet Project).”  
<LI>NPARL Weed Ecologist Andrew Lenssen presented a poster entitled “Crop Diversification and Management System Influence Yield and Weeds in the Northern Great Plains.”  
<LI>NPARL Soil Physicist Jay Jabro whose poster was entitled “Tillage Depth Effects on Soil Physical Properties, Sugarbeet Yield and Quality.”  
<LI>NPARL Agronomist Brett Allen whose poster was entitled “Dryland Corn Seeding Rate and Row Configuration Impacts on Biomass, Grain Yield, and Water Use.”  
<LI>Drs. Stevens, Sainju, Lenssen, Jabro and Allen are all members of NPARL’s Agricultural Systems Research Unit.</SPAN></LI></UL> 
<P><SPAN><STRONG>Montana ARS lab hosts international Wheat Stem Sawfly Conference October 13-14.</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; The Fourth International Wheat Stem Sawfly Conference will be held Oct. 13-14 at the Agricultural Research Service's Northern Plains Agricultural Research Laboratory (NPARL) in Sidney, MT. The 1-1/2-day conference, held only every three to five years, brings together scientists from across the region, the Prairie Provinces of Canada, and from Montpellier, France, to discuss ongoing and future research into the biological, cultural and chemical control of wheat stem sawfly. Topics for the conference include discussions on the genetics of the wheat stem sawfly and new wheat varieties intended to help combat the pest, as well as biological and cultural management research and survey information. Among the scheduled presenters are wheat breeders Luther Talbert and Phil Bruckner, entomologists David Weaver and Kevin Delany, and chemical ecologist Micaela Buteler, all with Montana State University–Bozeman; cereal agronomist Brian Beres and entomologist Hector Carcamo of Agriculture and Agri-Food Canada, Lethbridge, Alberta; and entomologist Walker Jones and molecular biologist Marie-Claude Bon, both with the USDA-ARS European Biological Control Laboratory in Montpellier, France. The wheat stem sawfly is a serious pest in the Northern Great Plains and Canada, causing yield losses of more than $100 million a year, with annual losses in Montana alone exceeding $25 million.</SPAN></P> 
<P><SPAN><STRONG>ARS Scientist to chair a FAO/IAEA consultants meeting devices and systems for early and rapid detection of animal diseases:</STRONG>&nbsp; On October 13-15, William Wilson, ARS microbiologist, Arthropod-Borne Animal Diseases Research Laboratory, Laramie, WY, will participate and act as chairman in a Consultants Meeting on devices and systems for early and rapid detection of animal diseases, early response to emerging diseases.&nbsp; The meeting will discuss amplification and non-amplification systems, biosensor, nanotechnology devises and equipment, sniffer technologies, remote sensing, communication technologies, administrative and logistical set-ups, networks and partnerships.&nbsp; Wilson will give a presentation on tools for early detection from pen-side to high-throughput.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>September 10, 2008</SPAN></P> 
<P><SPAN><STRONG>ARS Scientist To Attend Conference In China:</STRONG>&nbsp; September 21-26, Paul Flinn, Research Biologist with the Biological Research Unit, Grain Marketing and Production Research Center, Manhattan, KS, will make a presentation “Effects of Outside Air Temperature on Movement of Phosphine Gas in Concrete Elevator Bins” at the Controlled Atmosphere and Fumigation Conference in Chengdu, China.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>August 27, 2008</SPAN></P> 
<P><SPAN><STRONG>ARS Laboratory Hosts Ethnobotany Walk-N-Talk</STRONG>: On August 15th, the Northern Great Plains Research Laboratory hosted Linda Different Cloud-Jones, Ethnobotanist from the Standing Rock Lakota Nation, who led a walking tour of the native pastures at the USDA-ARS lab in Mandan, North Dakota. Cloud-Jones selected native plants and shared extensive information on their nutritional and medicinal use by native peoples. Thirty-five individuals interested in natural health and native plants from as far away as Minnesota joined her. Staff at the lab provided a barbecue for their guests following the tour to facilitate continued discussions. Cloud-Jones has been an audience favorite at the lab’s annual ‘Friends & Neighbors Day’ which attracted over 1000 guests this past July. She begins her PHD program in Ethnobotany at Montana State University in Bozeman in September.</SPAN></P> 
<P><SPAN><STRONG>ARS Scientist to Present at Major Biomass Biofuels Conference:</STRONG> On October 10th, Dr. David Archer, USDA-ARS Agricultural Economist will present “Corn Stover as Feedstock for Cellulosic Ethanol – Cost, Availability, and Sustainability” at the Platts 3rd Annual Cellulosic Ethanol and Biofuels conference in Chicago, Illinois. Over twenty of the nation’s foremost biofuel authorities were invited to present new research and development information at this key industry educational symposium.</SPAN></P> 
<P><SPAN><STRONG>ARS Grain Marketing and Production Research Center to Host Meeting of the Food Protection Committee of the International Association of Operative Millers:</STRONG> On 3-4 September, the ARS Grain Marketing and Production Research Center, Manhattan, KS, will host a meeting of the Food Protection Committee of the International Association of Operative Millers.&nbsp; The committee meets three times a year, and consists of about two dozen members from most of the major U.S. grain processing companies.&nbsp; Jim Throne, Research Leader of the ARS Biological Research Unit in Manhattan, will attend the meeting to report on recent ARS stored-product insect research of interest to the committee and to discuss the grain processing industry’s research needs.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>August 13, 2008</SPAN></P> 
<P><SPAN><STRONG>ARS Entomologist To Speak About Stored-Product Insect Pests at Thailand's Postharvest Technology Innovation Center At Chiang Mai University</STRONG>:&nbsp; On August 15-25, Jim Throne, Research Leader of the Biological Research Unit at the Grain Marketing and Production Research Center in Manhattan, KS, will present two seminars on his research entitled "Computer modeling of the population dynamics of stored-product pests" and "Entomological applications of near-infrared spectroscopy" at Chiang Mai University, Thailand.&nbsp; He also will discuss postharvest pest management techniques and future collaborative research with scientists at the Postharvest Technology Innovation Center.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>August 7, 2008</SPAN></P> 
<P><SPAN><STRONG>CDC Branch Chief Presents Entomology Seminar:</STRONG>&nbsp;On August 4, CDC Entomology Branch Chief Dr. Bob Wirtz presented a seminar “An Overview of CDC Entomology Branch Activities” at the Grain Marketing and Production Research Center, Manhattan, KS.&nbsp; His presentation included CDC work targeting vector-borne diseases such as malaria and lymphaitic filariasis.&nbsp; He also discussed the joint CDC-ARS work where they are applying NIR techniques developed by the ARS Engineering Research Unit to identify and age-grade disease vectors.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>July 16, 2008</SPAN></P><SPAN> 
<P><STRONG>ARS Lab Hosts Kansas Farm Bureau Delegation:</STRONG>&nbsp; On July 10th a delegation of eight producers and staff members from the Kansas Farm Bureau visited the Grain Marketing and Production Research Center (GMPRC), in Manhattan, KS. Dr Thomas Shanower, Director, gave the group an overview of the Agricultural Research Service and GMPRC’s mission and research. The group then met with several researchers. Dr. Brad Seabourn updated them on activities in the Hard Winter Wheat Quality Laboratory; Dr Floyd Dowell demonstrated high-speed kernel sorting technology developed in the Engineering Research Unit; and Dr Richard Beeman, reviewed research in the Biological Research Unit, including work on red flour beetle genomics.&nbsp; </P> 
<P><STRONG>ARS Researchers Participate In Montana State University Research Center Field Day:</STRONG> On July 16th, NPARL Plant Pathologist Robert Lartey and Agronomist Bart Stevens both gave invited presentations at Montana State University’s Eastern Ag Research Center Field Day in Sidney, Montana. Dr. Lartey’s talk was entitled “Biological seed treatments for sugarbeet and barley,” and included discussion of his work with a new fungal biocontrol agent for Cercospora leaf spot disease in sugarbeet, that is also showing promise against net blotch in malting barley. For his part, Dr. Stevens discussed “Nitrogen fertilizer placement in strip-tilled sugarbeet.” Both scientists are members of the Sidney ARS lab’s Agricultural Systems Research Unit. </P> 
<P><STRONG>Montana ARS E-Cycling Program Featured In USDA Employee Publication:</STRONG>&nbsp; The May-June 2008 issue of “USDA News” includes an article about the rural e-cycling program begun by employees of the USDA-ARS Northern Plains Agricultural Research Laboratory in Sidney, MT. The article, entitled “ARS Helps Make 'E-Recycling' A Reality In Rural America,” describes how NPARL Safety Specialist Jackie Couture and her fellow employees helped develop a community-wide electronics recycling program in their small Montana town in 2005 that is now serving as a model for others in rural areas across the state and elsewhere. The “USDA News” is available online at the USDA website under the “USDA Employee Services” link.</P> 
<P><STRONG>ARS Scientist Keynote Speaker For Symposium At International Conference On Sustainable Ag in Japan:</STRONG>&nbsp; On July 2-6, NPARL Soil Scientist Upendra Sainju was invited to give the keynote address at the Farming Systems and Agro-ecology Symposium at the International Conference on Sustainable Agriculture and Environment in Sapporo, Japan. Dr. Sainju’s presentation was entitled “Management Practices Impact on Soil Carbon Sequestration and Greenhouse Gas Emission.” More than 200 scientists from around the globe attended the conference which focused on issues surrounding sustainable crop production and improved soil and environmental quality, with an emphasis on increasing carbon sequestration, reducing greenhouse gas emissions, and sustaining crop yields.&nbsp; In addition to his symposium presentation, Dr. Sainju was also invited to speak to the faculty, staff, and farmers of Hokkaido and Ibaraki Universities, respectively, in Sapporo and Tsukuba Science City, Japan, on July 4th and 9th.&nbsp; The invitations were extended by Dr. Hajime Araki (Hokkaido University) and Dr. Masakazu Komatsuzaki (Ibaraki University). His presentation at both venues was entitled “Bicultural Cover Crops for Sustaining Crop Yields and Improving Soil and Water Quality.” The lectures have helped to establish future research collaborations between the Sidney, MT ARS lab and the two Japanese Universities, where research on cover crops is just beginning. Dr. Sainju is a member of NPARL’s Agricultural Systems Research Unit.</P> 
<P align=right><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>July 10, 2008</SPAN></P> 
<P><SPAN><STRONG>ARS Scientists To Attend The Fourth International Tribolium Meeting In Belgium</STRONG>: On July 28-29, 2008, Dick Beeman and Marce Lorenzen from the ARS Grain Marketing and Production Research Center, Manhattan, KS, will participate in the Fourth International Tribolium Meeting in Ghent, Belgium. Dr. Beeman will make a presentation and also meet with European cooperators on their mutually NRI-funded project, Insertional Mutagenesis in Tribolium. Dr. Lorenzen was invited to present a talk about her work relating to the Tribolium genome project. </SPAN></P> 
<P><SPAN><STRONG>ARS Scientist To Attend The Fourth International Conference In Africa For Comparative Physiology And Biochemistry In Kenya</STRONG>: On July 19-25, 2008, Brenda Oppert from the ARS Grain Marketing and Production Research Center, Manhattan, KS, will participate in the Fourth International Conference in Africa for Comparative Physiology and Biochemistry in Maasai Mara, Kenya. She is co-organizer of the symposium "Insect gut physiology and nutrition: new targets for control." She is also giving an invited talk: Inhibitor strategies to control coleopteran pests: Part 2, Microarray analysis, and is junior author on two other presentations.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></SPAN></P> 
<P><SPAN>July 2, 2008</SPAN></P> 
<P><SPAN><STRONG>North Dakota Water Users Group Tours Montana ARS Laboratory:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; More than 100 members attending the North Dakota Water Resource Districts Association’s 2008 Annual Summer meeting in Williston, ND, toured the USDA-ARS Northern Plains Agricultural Research Laboratory (Sidney, MT) and the co-located Montana State University Eastern Plains Eastern Agricultural Research Center on June 30. The half-day tour was sponsored by the ND Water User’s Association and featured irrigated research conducted by ARS and MSU on high value and alternate crops and also showcased the new weed and insect pest biological control Quarantine facility nearing completion at the Sidney ARS lab. Helping lead tours were NPARL Agronomist Bart Stevens and Physical Scientist William Iversen, both with the lab’s Agricultural Systems Research Unit; and Entomologist Dave Kazmer, who’s with the lab’s Pest Management Research Unit. </SPAN></P> 
<P><SPAN><STRONG>ARS Soil Scientist Participates In 2008 ASABE Meeting:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Soil Scientist Jay Jabro participated in the 2008 Annual International Meeting of the American Society of Agricultural and Biological Engineers in Providence, RI June 29-July 2. At the Session Dr. Jabro presented a poster entitled “In-situ Soil-Water Retention and Field Water Capacity Measurements in Two Contrasting Soil Textures,” which described a study showing that two different types of sensors (Watermark and Time Domain Reflectometry) both provided accurate in-situ soil water retention data that can be used in agricultural and environmental applications including irrigation management and scheduling. The paper was co-authored by fellow NPARL researchers R.G. Evans, Y. Kim and W.M. Iversen, all, like Jabro working in the Sidney ARS lab’s Agricultural Systems Research Unit. The American Society of Agricultural and Biological Engineers is an educational and scientific organization dedicated to the advancement of engineering applicable to agricultural, food, and biological systems. Founded in 1907 and headquartered in St Joseph, Michigan, ASABE comprises 9,000 members in more than 100 countries.</SPAN></P> 
<P><SPAN><STRONG>ARS Scientist Invited To Speak At 23rd International Congress Of Entomology:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Research Entomologist Stefan Jaronski has been invited to give two talks at the 23rd International Congress of Entomology (ICE) in Durban, South Africa, July 6-12. Dr. Jaronski will be discussing “Field efficacy of Metarhizium anisopliae and Beauveria bassiana against immature Mormon crickets” and “Differences among populations in susceptibility of the grasshopper Melanoplus sanguinipes to a generalist fungal pathogen” during his invited presentations. Dr. Jaronski will also be contributing a third presentation on “The challenges of commercializing microbial pest control agents in the U.S.” In addition to his ICE talks, Dr. Jaronski has also been invited to visit BCP, Ltd., a producer of Beauveria and Metarhizium, where he will discuss mass production methods. Dr. Jaronski is a member of NPARL’s Pest Management Research Unit. The ICE is held once every four years and is the only international meeting for entomology. The theme for 2008 is “Celebrating Entomology: Contributions to Modern Science.”</SPAN></P> 
<P><SPAN><STRONG>ARS Microbiologist To Present Research On A Vesicular Stomatitis Virus Transmission Cycle:</STRONG>&nbsp; On July 12-16, microbiologist Barbara Drolet, ARS Arthropod-Borne Animal Diseases Research Laboratory, Laramie, WY, will present research that describes the transmission of VSV from contaminated pasture grassland plant species to grasshoppers at the annual meeting of the American Society for Virology in Ithaca, NY.</SPAN></P> 
<P align=right><SPAN><A href="#top">Back to top</A></P> 
<P>June 4, 2008</P> 
<P><STRONG>Montana ARS Researchers Participate In New Frontiers Conference:</STRONG>&nbsp; On June 2, (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Research Leaders Drs. John Gaskin (Pest Management Research Unit) and Robert Evans (Agricultural Systems Research Unit) participated in the “2008 New Frontiers Conference: Propelling Montana Research” held in Bozeman, Montana. The event, which showcased the globally competitive research going on in Montana through a series of presentations, workshops and networking opportunities, attracted more than 400 business people, academics, politicians and government officials, including executives from such major companies, such as 3M, Abbott, General Electric, Eli Lilly and Boeing, along with representatives from research entities such as the National Science Foundation and smaller start-up businesses. Dr. Gaskin participated in the Agriculture Panel of the Montana Research Showcase and gave a presentation entitled “Agricultural Solutions through Innovative Science,” which incorporated information on research conducted at the Sidney ARS facility, as well as providing information on how interested parties could collaborate with ARS in developing related products or technologies for commercialization. ARS Northern Plains Area Technology Transfer Coordinator Bryan Kaphammer also participated in the conference, discussing funding and partnering opportunities with ARS at the regional and national levels. This first “Research Summit” in Bozeman was sponsored by Montana U.S. Senator Max Baucus, the Montana State University System and TechRanch and brought together Montana research and business leaders to promote commercialization and development of new technology in Montana.</P> 
<P align=right><A href="#top">Back to top</A></P></SPAN> 
<P>May 21, 2008</P> 
<P><STRONG>Representatives from Jilin University, China, visit ARS Center in Kansas</STRONG>:&nbsp; On May 14, Dean Jin Tong and three scientists from the College of Biological and Agricultural Engineering, Jilin University, China, visited the ARS Grain Marketing and Production Research Center in Manhattan, Kansas.&nbsp; Dr. Tom Shanower, Center Director, gave the visitors an overview of GMPRC research and Agricultural Engineers Elizabeth Maghirang, Paul Armstrong and Daniel Brabec, Engineering Research Unit (ERU), discussed and demonstrated ongoing ERU research.</P> 
<P><STRONG>ARS Scientist Presents at National Soil Survey Planning Conference</STRONG>:&nbsp; On 6 May, John Tatarko, ARS Grain Marketing and Production Research Center in Manhattan, Kansas, made a presentation titled "Soil Wind Erodibility" to the National Soil Survey Planning Conference held at the USDA-Natural Resources Conservation Service (NRCS) Plant Materials Center in Manhattan, Kansas.&nbsp; Approximately 18 NRCS personnel attended the conference.&nbsp; On 7 May, the conference attendees toured the Wind Erosion Research Unit (WERU) wind tunnel facility where they viewed and discussed current and developing wind erosion research technology.</P> 
<P><STRONG>ARS Soil Scientists To Speak At International Soils Congress</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Research Soil Scientists Jay Jabro and Upendra Sainju have been invited to participate in the 15th International Congress of the International Soil Conservation Organization (ISCO) in Budapest Hungary May 18-23. Dr. Jabro is giving two poster presentations, the first entitled: “Long-term tillage frequency effects on dryland soil physical and hydraulic properties” by Jabro and fellow ARS researchers U.M. Sainju, W. B. Stevens, A. W. Lenssen, and R.G. Evans. His second presentation with coauthors A.D. Jabro, and R. Domalski is entitled “The complexities of discussing soil vapor extraction techniques with non-Scientists.” For his part, Dr. Sainju’s poster presentation is entitled, “Tillage, Cropping Sequence, and Nitrogen Fertilization Effects on Dryland Soil Carbon Sequestration and Carbon Dioxide Emission.” Both Drs. Jabro and Sainju are members of NPARL’s Agricultural Systems Research Unit. The purpose of ISCO is to advocate for the sustainable, productive, and efficient use of soil and water resources.&nbsp; It does so through improved understanding of natural resource management issues and enhanced communication among participants in its meetings and with others with similar concerns and commitments. The Congress provides an excellent opportunity for international collaboration between those entities.</P> 
<P><STRONG>ARS Representative Invited To Speak At French Institute for Development Research</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Research Soil Scientist Jay Jabro has been invited to speak and meet with colleagues at The Institute for Development Research (IRD) in Paris France May 24-26. Dr. Jabro, will give a presentation entitled “Innovative research at the NPARL in Sidney Montana” providing an overview of the research underway at the Sidney ARS lab and then meet with Institute Director Dr. Christian Valentin and other IRD scientists, among them Dr. Erick Braudeau, a soil physicist collaborating with Jabro and other NPARL researchers on using the pedostructure concept in diverse soil and water characterization and modeling issues in agriculture and environmental quality. In addition to touring the facilities, Dr. Jabro will also be identifying other potential research collaborations between the ARS laboratory in Sidney, MT and the IRD on soil, water and environmental issues. The IRD is the pre-eminent French research organization dedicated to development and consists of 79 research laboratories, located and operating jointly with academic partners in France, in the French overseas territories and in 35 countries in Africa, Asia, the Indian Ocean, Latin America and the Pacific area. IRD’s uniqueness relies on its exclusive dedication to development research. IRD has mobilized its resources to address six development priorities: combating poverty and exclusion, international migration, emerging infectious diseases, climate change and environmental hazards, water resources and access to water, ecosystems. </P> 
<P><STRONG>ARS Representative To Speak At Saltcedar Management Project Spring Meeting</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Biological Science Technician Kimberly Mann will give a presentation May 6 at the Missouri River Watershed Coalition (MWRC) Saltcedar Management Project spring meeting in Scottsbluff, NE.&nbsp; Ms. Mann is representing NPARL Entomologist David Kazmer at the event. Dr. Kazmer works on saltcedar biocontrol in Lovell, WY and in the Charles M. Russell National Wildlife Refuge near Ft. Peck, but was unable to attend the session. Both Mann and Kazmer are members of NPARL’s Pest Management Research Unit. The Missouri River Watershed Coalition includes federal, state, and local agencies, businesses, universities, conservation groups, and private landowners. Together, the groups have drafted a Saltcedar Management Plan to coordinate efforts to manage saltcedar and restore riparian corridors of the Missouri River watershed. The goal of MWRC is to maintain productive, biodiverse riparian ecosystems that provide quality water, habitat, recreation, and power to meet the economic and ecological needs of the Missouri River Watershed region.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P>May 7, 2008</P> 
<P><STRONG>ARS Employee Receives Award</STRONG>:&nbsp; JoAnne Gresens, Safety and Occupational Health Manager, USDA-ARS Grain Marketing and Production Research Center, Manhattan, KS, received an award from the American Society of Animal Science for leadership and scholastic achievement.&nbsp; Gresens, a full time student in addition to being a full time employee, was recognized for her academic achievement which places her in the top 10% of her class.</P> 
<P><STRONG>ARS Food Technologist Provides Visitors with Hands-On Bake Lab Training</STRONG>:&nbsp; On May 20-21, Food Technologist, Margo Caley, USDA-ARS Grain Marketing and Production Research Center, Manhattan, KS, will provide hands-on bake lab training to three visitors:&nbsp; John Stromberger (Colorado State University), Connie Shelton (Oklahoma State University) and Yee-Ling “Caryn” Ong (Oregon State University).&nbsp; These visitors will receive a two day instruction, while baking in the experimental bake lab, covering experimental pup straight dough baking and mixograph training.&nbsp; Our guests requested this visit after attending the PNW-Wheat Quality Council Meeting in Portland, OR in January.&nbsp; </P> 
<P><STRONG>ARS Scientist Reviews Wind Erosion Problems in Southeast Idaho</STRONG>:&nbsp; On April 28-30, at the request of the Natural Resources Conservation Service (NRCS), John Tatarko of the Wind Erosion Research Unit, USDA-ARS Grain Marketing and Production Research Center, Manhattan, KS, visited field sites in southeast Idaho that were experiencing wind erosion problems.&nbsp; The surfaces of eroding fields were evaluated and measured to ensure that the Wind Erosion Prediction System (WEPS) will correctly predict soil loss under the existing site conditions.&nbsp; Strategies for controlling soil loss during this wind erosion susceptible period were also discussed with local NRCS personnel.</P> 
<P><STRONG>ARS Representative To Speak At Saltcedar Management Project Spring Meeting</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Biological Science Technician Kimberly Mann will give a presentation May 6 at the Missouri River Watershed Coalition (MWRC) Saltcedar Management Project spring meeting in Scottsbluff, NE.&nbsp; Ms. Mann is representing NPARL Entomologist David Kazmer at the event. Dr. Kazmer works on saltcedar biocontrol in Lovell, WY and in the Charles M. Russell National Wildlife Refuge near Ft. Peck, but was unable to attend the session. Both Mann and Kazmer are members of NPARL’s Pest Management Research Unit. The Missouri River Watershed Coalition includes federal, state, and local agencies, businesses, universities, conservation groups, and private landowners. Together, the groups have drafted a Saltcedar Management Plan to coordinate efforts to manage saltcedar and restore riparian corridors of the Missouri River watershed. The goal of MWRC is to maintain productive, biodiverse riparian ecosystems that provide quality water, habitat, recreation, and power to meet the economic and ecological needs of the Missouri River Watershed region.</P> 
<P align=right><A href="#top">Back to Top</A></P> 
<P>April 21, 2008</P> 
<P><STRONG>ARS Research Leader To Participate In The Renewable Fuels Action Summit:</STRONG> On May 19th, Northern Great Plains Research Laboratory Research Leader Jon Hanson will present “Feed Stock for Renewables” at a regional biofuels conference sponsored by North Dakota Senator Byron Dorgan and Governor John Hoven. The program will bring together nationally renowned researchers and leaders in the renewable energy field to present and discuss emerging renewable fuels opportunities for the northern Great Plains region. Hanson's participation was requested by Senator Dorgan. The summit is an initiative of the Senator’s “Great Plains Energy Corridor” project and will be held at Bismarck State College in Bismarck, ND. </P> 
<P><STRONG>ARS Scientist Presents at Livestock and Climate Change Symposium in Tunisia:</STRONG> On May 14th, Dr. Scott Kronberg, USDA-ARS Animal Scientist at the Northern Great Plains Research Laboratory in Mandan, ND will present “ A win-win scenario with flaxseed supplementation to reduce methane output and increase weight gains of grazing cattle”&nbsp; at an international symposium in Tunisia sponsored by the British Society of Animal Science, Scottish Government, European Science Foundation, other European animal and agricultural research societies (INRA, EAAP, etc.), and ICARDA and ILRI international research organizations.&nbsp; Kronberg’s research focus is in both increasing omega-3 fatty acids in beef for consumers through the feeding of flaxseed and reducing greenhouse gases in beef production.</P> 
<P><STRONG>ARS Scientists To Attend Annual Hard Winter Wheat Breeders’ Field Day</STRONG>: On April 22, Robert Bowden, Research Leader, ARS Plant Science and Entomology Research Unit (PSERU), Manhattan, KS, and Brad Seabourn, Director of the USDA-ARS Hard Winter Wheat Quality Laboratory (HWWQL), along with seven staff members, will participate in the Annual Hard Winter Wheat Breeders’ Field Day in Castroville, TX.&nbsp; Breeders and other scientists will share agronomic and end-use quality information about prospective new wheat varieties.&nbsp; Prior to the field day, Plant Geneticists Guihua Bai and Paul St. Amand (PSERU) will convene a meeting of the Hard Winter Wheat Genotyping Lab Liaison Committee.&nbsp; Unit scientists and stakeholders will discuss ways to increase the efficiency and impact of marker-assisted selection in wheat.</P> 
<P><STRONG>ARS Scientist Interviewed For National Public Radio</STRONG>: On April 21st, Dr. Rebecca Phillips was interviewed by Earth & Sky reporter Jorge Salazar. In the Journal Global Change Biology, Phillips and collaborator Ofer Beeri of the University of North Dakota, reported that fields planted to grasses and managed under the Conservation Reserve Program (CRP) removed between 2300 and 3200 kg of atmospheric carbon per acre per growing season, based on ten years of data. Results were based on field and satellite-based data for over 1400 individual CRP fields in central North Dakota.&nbsp; The interview will be broadcast within a few weeks. Earth & Sky on National Public Radio has a daily exposure of over three million listeners.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P>April 9, 2008</P> 
<P><STRONG>USDA-ARS Scientist Presents at 62nd Annual US Flax Institute</STRONG>: (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND) Dr. Eric Scholljegerdes, NGPRL Animal Scientist, presented “Effects of supplemental flaxseed on site and extent of digestion in beef heifers grazing summer pasture in the northern Great Plains” at the United States flax industry’s 2008 research forum held at Fargo, North Dakota March 27th. Flax Institute participants include a growing number of food scientists, human nutritionists, animal scientists, and physicians throughout the United States.</P> 
<P><STRONG>USDA-ARS Scientist Trains NDSU Extension Educators</STRONG>: (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND) On March 31st, Dr. Kristine Nichols, UDA-ARS Soil Microbiologist, presented several soil quality demonstrations at the North Dakota State University Extension Educator’s Spring Training Conference in Bismarck, North Dakota. These demonstrations were conducted as part of a ‘Building a 4-H Sustainable Agriculture Activity Box’ session and included demonstrations and activities for Land Grant College Cooperative Extension personnel and 4-H leaders for use in soils education for young people.</P> 
<P><STRONG>USDA-ARS Scientist Presents at NDSU/Pfizer Scientific Forum</STRONG>: (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND) Dr. Eric Scholljegerdes, NGPRL Animal Scientist, has been invited to present “Effects of an integrated crops/livestock system used for fall forage production on cow performance” at a major scientific forum in Hettinger, North Dakota on April 8th. This multi-state Animal Science Research discussion is annually sponsored by North Dakota State University and Pfizer Animal Health Company.</P> 
<P>April 2, 2008</P> 
<P><STRONG>ARS Researcher Invited To Speak At International Animal Migration Conference:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Ecologist Robert Srygley has been invited to present a paper at the “International Conference on Animal Navigation: Royal Institute of Navigation 2008, Orientation and Navigation: Birds, Humans and other Animals,” April 2-4 at the University of Reading, United Kingdom. The conference will bring together research scientists from a wide range of research disciplines relative to animal navigation, including orientation, migration, neurobiology, ethology, ecology, entomology and sensory physiology. Dr. Srygley’s presentation is titled, “Do leaf-cutter ants orient their path-integrated, home vector with a magnetic compass?” Dr. Srygley is a member of NPARL’s Pest Management Research Unit where he is currently studying migration and management of Mormon crickets. In addition to participating in the conference, Dr. Srygley will confer with Drs. Tim Guilford, Adrian Thomas, Graham Taylor, Fritz Vollrath, and other colleagues in the Department of Zoology, University of Oxford, where Dr Srygley is a Senior Research Associate.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P>March 26, 2008</P> 
<P><STRONG>USDA-ARS Employees support American Indian Higher Education Consortium (AIHEC):</STRONG>&nbsp; On March 19th, Dr. Jon Hanson, Research Leader at the USDA-ARS Northern Great Plains Research Laboratory provided a seminar on “Career Opportunities with the USDA Agricultural Research Service” and moderated an employee panel from the Mandan, ND lab and Northern Plains Agricultural Research Laboratory in Sidney, MT at the 27th annual AIHEC Student Conference in Bismarck, North Dakota. Dr. Rebecca Phillips, ARS Plant Physiologist, Dr. Scott Kronberg, ARS Animal Scientist, Dr. Mark Liebig, ARS Soil Scientist, and Ms. Jackie Couture, ARS Safety Officer, shared their personal stories that led to work with USDA, the work experience within their organizations, and recommendations to students interested in science careers. Joining the USDA-ARS professionals on the panel were students April Blackbird, Marla Stripe-Face Collins and Gail Sage, who participated in USDA-ARS internships and employment. The students shared their positive feelings about their experiences and the USDA Agricultural Research Service. Ms. Barbara King, ARS Northern Plains Area EEO/Civil Rights Manager assisted in organizing the seminar and panel. The American Indian Higher Education Consortium represents 36 Tribal Colleges and Universities (TCU) in the United States and one Canadian institution. This year, the AIHEC conference attracted over 1000 students and faculty from nearly every TCU.</P> 
<P><STRONG>Agricultural Research Service (ARS) Animal Scientist Hosts Surgeons for Cleft Palate Study:</STRONG>&nbsp; On April 9-11, Kip Panter, Animal Scientist, ARS Poisonous Plant Research Laboratory, Logan, UT, is hosting Dr. Jeffrey Weinzweig, M.D. (Head of Department of Plastic Surgery, Lahey Medical Clinic, Boston, MA) and four residents in plastic surgery to research the development of improved treatment of cleft palate in children using a goat model characterized at the Poisonous Plant Research Laboratory.&nbsp; The goat model was developed to study the mechanism, timing of insult, and prevention of skeletal defects (particularly lupine-induced “crooked calf disease”) and cleft palate in livestock. In utero surgery to repair cleft palate leaves no scars; surgeons are continuing to develop such techniques to transfer to human cleft palate repair some day.</P> 
<P>March 19, 2008</P> 
<P><STRONG>ARS Scientists from Logan, UT to Attend International Grassland Congress/International Rangeland Congress in China:</STRONG>&nbsp; During June 29-July 5, four scientists from the ARS Forage and Range Research Lab at Logan, UT will attend the first combined meeting of the International Grassland Congress and International Rangeland Congress held in Hohhot, Inner Mongolia, China.&nbsp; Douglas Johnson (Plant Physiologist) will present an invited keynote presentation “Collection and Domestication of Rangeland Plant Species with Emphasis on Mongolia and China".&nbsp; Richard Wang (Research Geneticist) will present "Development of genomic tools for wheatgrass and wildrye improvement".&nbsp; Tom Jones (Research Geneticist) will present "Wildland collection, population development, and genetic manipulation of native rangeland grasses in the Intermountain West".&nbsp; Tom Monaco (Ecologist) will present "Does disturbance similarly facilitate weed invasion within grass, forb, and shrub plots?"&nbsp; Besides attending the Congress, they will seek collaborative research exchanges with faculty and students at Inner Mongolia Agricultural University in Hohhot. Johnson and Monaco will then visit with colleagues at China Agricultural University in Beijing to discuss mutually beneficial scientific exchanges. Wang will also visit with colleagues at Fudan University in Shanghai and the Institute of Crop Science in Beijing to discuss collaborative research projects.</P> 
<P>March 5, 2008</P> 
<P><STRONG>ARS Entomologist To Speak On Stored-Product Pests At Food Industry Pest Management Seminar:</STRONG>&nbsp; On March 12, entomologist Jim Campbell, ARS Grain Marketing and Production Research Center, Manhattan, KS, will present "Stored Product Pest Update" at the McCloud Food Plant Pest Management Seminar, Hoffmann Estates, IL.&nbsp; This is an annual seminar sponsored by McCloud Services to train people working in and around the food industry, including food plant professionals, pest management professionals, and health department employees from across the country, to better manage pests.</P> 
<P><STRONG>ARS Entomologists Train Azoran Scientists in Fungus Production:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Research Entomologist Stefan Jaronski and fellow ARS entomologist Lawrence Lacey (ARS/Wapato WA) are teaching a short course in Metarhizium fungus production at the invitation of the Azores Regional Service of Crop Protection March 7-18. Azoran scientists have been developing the insect pathogenic fungus to control Japanese Beetle, which is a severe crop pest on the islands, but need to create a production capability. Jaronski has developed a fungus production facility at his ARS location in Sidney, using simple technology, to serve his own and others’ field trial needs for Metarhizium and another related fungus, Beauveria bassiana. He has subsequently taught his methods to other ARS scientists, to plant protection scientists from the Republic of Georgia, and to Agriculture AgriFood Canada entomologists. Lacey, whose research at Wapato has centered upon microbial and nematode control of tree fruit pests and potatoes, has had a long standing research involvement in using Metarhizium against the Japanese Beetle in the Azores. Jaronski is a member of NPARL’s Pest Management Research Unit.</P> 
<P>February 13, 2008</P> 
<P><STRONG>ARS Entomologist To Meet With Food Protection Committee Of The International Association Of Operative Millers</STRONG>:&nbsp; On 26-27 February, entomologist Jim Campbell, ARS Grain Marketing and Production Research Center, Manhattan, KS, will meet with the Food Protection Committee of the International Association of Operative Millers at the ARS Center for Medical, Agricultural, and Veterinary Entomology in Gainesville, FL, to report on recent ARS stored-product research of interest to the committee and to discuss the grain processing industry’s research needs.&nbsp; The committee consists of about two dozen members from most of the major U.S. grain processing companies.</P> 
<P>January 23, 2008</P> 
<P><STRONG>NGPRL Scientist Presents at Direct Seed Winter Conference.</STRONG>&nbsp; Dr. Kristine Nichols (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND) will present a seminar titled ‘Hunting for Nutrients and Trapping Carbon’ at the 11th Annual Direct Seed Cropping Systems Conference – Efficient Use of Resources, Jan. 23-24, in Kennewick, WA.&nbsp; Dr. Nichols will also be participating in a concurrent session at the conference on Direct Seed Growing Soil Health. The Pacific Northwest Direct Seed Association provides information exchange and advocacy on conservation policy issues and research coordination to no-till, direct seed producers in the Pacific Northwest.</P> 
<P><STRONG>NGPRL Scientist Presents at No-Till on the Plains Winter Conference</STRONG>.&nbsp; Dr. Kristine Nichols (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND) will present two seminars titled ‘Microbial Engineering to Enhance your Bottom Line, Parts I and II’ at the 12th Annual No Till on The Plains Conference, Jan. 29-30, in Salina, KS.&nbsp; Dr. Nichols will also be participating in the Agriculture’s Innovative Minds (AIM) symposium following the Winter Conference on Jan. 31st.&nbsp; This premier symposium is designed to “push knowledge to the limit” by providing speakers with strong backgrounds and knowledge to interact with producers and give them a more comprehensive exploration into agricultural systems that will give them an edge. </P> 
<P><STRONG>NGPRL Scientist Presents at Northern Plains Sustainable Ag Winter Conference.</STRONG>&nbsp; Dr. Kristine Nichols (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND) will present a seminar titled ‘Using Soil Biota to Advance Soil Quality and Pest Management’ at the Northern Plains Sustainable Agriculture Society’s 2008 Winter Conference, Feb. 8-9, in Mandan, ND.&nbsp; The Northern Plains Sustainable Agriculture Society is the organic agriculture society in the Northern Great Plains.</P> 
<P><STRONG>ARS Insect Pathologist Trains Georgian Scientists at MT Lab</STRONG>. (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Entomologist and Insect Pathologist Stefan Jaronski is hosting Drs.&nbsp; Eleanora Abashidze of the Georgian Institute of Plant Protection, and Medea Abashidze, Georgian Academy of Sciences, along with one of their graduate students, January 21-28, at the Sidney, MT ARS lab. The Georgian scientists are visiting the Sidney lab for additional training in mass production of insect pathogenic fungi, conduct of grasshopper bioassays, and general mycological methods. This training program is part of an ongoing USAID-funded project to build an insect pathology infrastructure in the Republic of Georgia. Dr. Jaronski previously visited Georgia in 2006 and 2007 to provide onsite training and help establish insect pathology laboratories in the Institute of Plant Protection and at Tbilisi State University.</P> 
<P>December 5, 2007</P> 
<P><STRONG>Symposium on Agricultural Biotechnology Risk Analysis Research</STRONG>:&nbsp; On December 5-6.&nbsp; Jeff&nbsp; Pedersen, Research Geneticist, Grain, Forage, and Bioenergy Research Unit, Lincoln, NE&nbsp; will be an invited speaker at the 2nd Symposium for Agricultural Biotechnology Risk Analysis Research in College Park, MD.&nbsp; The symposium is sponsored by the Agricultural Biotechnology Risk Analysis Research Task Group, a multiple federal agency task group that includes USDA, DOE, NSF, NIH, FDA, USAID, and other departments.&nbsp; Dr. Pedersen will report on potential gene flow issues in sorghum and switchgrass.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P>November 28, 2007</P> 
<P><STRONG>Biosciences Research Laboratory Scientist Participates In Project NORMAN:</STRONG>&nbsp; On October 22, Dr. Nancy Shappell participated in the second of two workshops supporting the efforts of a method validation exercise by the EU Framework Programme Contract of Research entitled “Network of Reference Laboratories and Related Organisations for (Bio-) Monitoring of Emerging Environmental Pollutants,” or Project NORMAN.&nbsp; More information about the project can be found at <A href="http://www.emerging-pollutants.net/"><FONT color=#0000ff>www.emerging-pollutants.net</FONT></A>.&nbsp; Dr. Shappell was asked to participate as the method for sample extraction and quantification of estrogenic activity she published in the Journal of Environmental Quality was included for evaluation.&nbsp; Participants at the October 22 meeting held at the University of Bergen, Norway included scientists from the United Kingdom’s Environment Agency, Norway’s Biosense Corporation, and Holland’s IVM Vrije University, whom were responsible for project design, coordination, and sample/data analysis.&nbsp; The purpose of this workshop was to review the findings of the various participants and prepare a report.&nbsp; The EU is in the process of establishing concentrations of “No Concern, Possible Concern, and Requiring Action” for wastewater effluents.&nbsp; The assays were being evaluated as to “fit for purpose” in assessing relative estrogenic activity/contamination of wastewater effluents.</P> 
<P>October 17, 2007</P> 
<P><STRONG>ARS Scientists Travel To Cairo, Egypt To Foster Cooperative Research On Rift Valley Fever:</STRONG>&nbsp; Dr. Kristine Bennett, Molecular Biologist and Dr. James Mecham, Microbiologist with the Arthropod-Borne Animal Diseases Research Laboratory (ABADRL) traveled to Cairo, Egypt September 20 – 29, 2007 to meet with colleagues who have been involved with Rift Valley fever (RVF) outbreaks in North Africa and the Arabian Peninsula.&nbsp; They were joined by Dr. Ken Linthicum, Center Director with the Center for Medical, Agricultural, and Veterinary Entomology (CMAVE), South Atlantic Area.&nbsp; The trip was made possible by the Department of State through a program administered by the Office of International Research Programs (OIRP) with funding awarded to CMAVE and ABADRL for enriching cooperative research on Rift Valley fever in endemic/epidemic countries.&nbsp; While in Cairo, the ARS scientists visited colleagues at the Cairo offices of USDA-APHIS and USDA-FAS; the U.S. Naval Medical Research Unit #3 (NAMRU-3) the Department of Environmental Studies and Research, Ain Shams University; the Veterinary Serum and Vaccine Research Institute; and the National Authority for Remote Sensing and Space Sciences.&nbsp; Scientific presentations were given and contacts made with numerous individuals at the above institutions involved with research.&nbsp; These exchanges have laid the groundwork for future international scientific collaborations.&nbsp; </P> 
<P><STRONG>Northern Plains Area Contributes to Nobel Prize-Winning Intergovernmental Panel on Climate Change:</STRONG>&nbsp; On Friday, October 12, 2007, the Norwegian Nobel Committee announced the joint award of the 2007 Nobel Peace Prize to the Intergovernmental Panel on Climate Change (IPCC) and to Albert Gore Jr. for “their efforts to build up and disseminate greater knowledge about man-made climate change, and to lay the foundations for the measures that are needed to counteract such change”.&nbsp; Since 1988, the IPCC has issued a series of reports every five or six years presenting the latest findings concerning climate change, including implications for agriculture and its role in mitigating climate change.&nbsp; Scientists from over a hundred countries have contributed to reports issued by the IPCC since its inception two decades ago, including Dr. Jack Morgan, USDA-ARS-NPA Rangeland Resources Research Unit, Fort Collins, CO, who served as a contributing author to Chapter 5, Ecosystems and Their Goods and Services of the 2001 Working Group II Report, and also as an expert reviewer of the 4th assessment report in 2007.&nbsp; ARS scientists from other areas who have contributed to the IPCC include Dr. Bruce Kimball, Maricopa, AZ; Dr. L. Hartwell Allen, Gainsville, FL; Dr. Wayne Polley, Temple, TX; and Dr. Lewis Ziska, Beltsville, MD.</P> 
<P>October 3, 2007</P> 
<P><STRONG>ARS Scientist To Present Research At Agriculture Canada And The University Of Manitoba In Winnipeg, Canada</STRONG>:&nbsp; On 8-11 October, Research Entomologist Frank Arthur, from the ARS Grain Marketing and Production Research Center in Manhattan, KS, will visit with scientists at Agriculture Canada in Winnipeg, Manitoba, and at the University of Manitoba, Department of Entomology.&nbsp; Dr. Arthur will be discussing several ongoing collaborative projects with the Agriculture Canada scientists, and he will present an invited seminar to the University of Manitoba, Department of Entomology on 11 October entitled "Stored Product Insects as Urban and Structural Pests". </P> 
<P><STRONG>Scientists From ARS Lab In Kansas To Report Their Work At The American Association Of Cereal Chemists International:</STRONG> The week of October 7th – 10th scientists from the Grain Marketing Production Research Center (GMPRC) Grain Quality Unit and the Engineering Research Unit in Manhattan, KS, will be attending American Association of Cereal Chemists International (AACCI) annual meeting in San Antonio, TX. The theme for this years meeting is “Dynamics of Grain Utilization” and will be presenting work in the areas of:&nbsp; dough viscoelastic properties, bread quality characteristics, image analysis of cereals, the impact starch has on bread quality, waxy and non-waxy wheat kernel separation, noodle and tortilla quality. This is an opportunity to share research results and ideas concerning cereal quality at both the domestic and international level.</P> 
<P><STRONG>ARS Scientist To Present Research To National Pest Management Association:</STRONG>&nbsp; On 7-19 October, Research Entomologist Jim Campbell, from the ARS Grain Marketing and Production Research Center in Manhattan, KS, will present an invited talk entitled "Advances in Understanding Stored-Product Pests in Food Facilities" at the annual meeting of the National Pest Management Association in Kissimmee, Florida.</P> 
<P>August 29, 2007</P> 
<P><STRONG>ARS Global Change Research Draws International Attention:</STRONG>&nbsp; In an article to be published the week of August 27-31 in the online Early Edition of the Proceedings of the National Academy of Sciences (<A href="http://www.pnas.org/papbyrecent.shtml"><FONT color=#0000ff>http://www.pnas.org/papbyrecent.shtml</FONT></A>), Dr. Jack Morgan and colleagues Dan Milchunas (Colorado State University), Dan LeCain, Mark West, and Arvin Mosier (last three ARS) report that increased levels of atmospheric CO2 led to a 40-fold increase in aboveground biomass of a small sub-shrub in native Colorado shortgrass steppe.&nbsp; These findings are the first from a manipulative experiment to support the notion that rising CO2 may be involved in the encroachment of grasslands by woody plants, a phenomenon that is responsible for the degradation of many world rangelands.&nbsp; Dr. Morgan has been contacted by news organizations and newspapers from around the world, including the Los Angeles Times, which are writing feature stories on the research.</P> 
<P><STRONG>ARS Scientists To Present Research On Rice Pest Management At Conference In Portugal:</STRONG>&nbsp; On 17-19 September, Research Entomologists Frank Arthur, Jim Campbell, and Jim Throne and Research Biologist Paul Flinn will present invited talks at the International Workshop on Integrated Management of Stored Rice Pests in Alcácer do Sal, Portugal.&nbsp; Arthur will present "Combination treatments with diatomaceous earth and methoprene to control the lesser grain borer, Rhyzopertha dominica, in stored rough rice", Campbell's presentation is "Evaluating sources of stored product insect infestation", Throne's is "Detection of insects in grain", and Flinn's is "Automatic monitoring of insect pests in stored grain and rice".&nbsp; Following the meeting, they will meet with colleagues at the Tropical Research Institute of Portugal in Lisbon to discuss collaborative research.</P> 
<P>August 22, 2007</P> 
<P><STRONG>USDA-ARS Technical Information Specialist Recognized for Excellence in Tech Transfer</STRONG>: USDA-ARS Technical Information Specialist Cal Thorson has been selected as the 2007 Regional Laboratory Representative for the Federal Laboratory Consortium Mid-Continent Region. Thorson manages the public outreach efforts of the Northern Great Plains Research Laboratory in Mandan, North Dakota. The USDA-ARS natural resources laboratory focuses on research and development of innovative integrated agricultural systems and dynamic cropping systems which includes improved crop sequencing, integrating new biofuel crops, evaluating carbon sequestration, and developing new remote sensing tools for land managers. Thorson focuses on the perpetuation of new USDA-ARS research into public use. “Cal is a fine example of the caliber of people involved in the ARS as well as the FLC Mid-Continent Region. We are thrilled to be able to honor him and showcase his fine work.” Thorson will be honored at the upcoming Federal Laboratory Consortium Mid-Continent Regional meeting on September 12th in San Diego, California.</P> 
<P><STRONG>ARS Scientist Assists The Centers For Disease Control In Malaria Research:</STRONG>&nbsp; From August 26-September 7, agricultural engineer and research leader Floyd Dowell will work with scientists at the Ifakara Health Research and Development Centre in Tanzania to apply near-infrared spectroscopy techniques to determining mosquito species and age.&nbsp; This research is in cooperation with the CDC and supports international efforts to control malaria.</P> 
<P>August 15, 2007</P> 
<P><STRONG>ARS Scientist Presented Invited Talk On Using Switchgrass For Bioenergy:</STRONG>&nbsp; On August 9, research agronomist Rob Mitchell, Grain, Forage, and Bioenergy Research Unit, Lincoln, NE, gave an invited presentation at the 92nd annual meeting of the Ecological Society of America, in conjunction with the 18th annual meeting of the Society for Ecological Restoration held in San Jose, CA.&nbsp; The presentation, "Biofuel production from switchgrass", focused on the economics and the net energy balance of growing switchgrass for bioenergy using data from a large scale trial involving fields on ten farms for a five year period.</P> 
<P><STRONG>ARS Scientists To Present Bioenergy Research Findings:</STRONG>&nbsp; On August 20, geneticist Ken Vogel, Grain, Forage and Bioenergy Research Unit, Lincoln, NE and plant physiologist Wallace Wilhelm, Agroecosystem Management Research Unit, Lincoln, NE&nbsp; will present invited presentations at the USDA Global Conference on Agricultural Biofuels: Research and Economics at Minneapolis, MN.&nbsp; Vogel will present information on the economics and net energy of switchgrass production for biomass energy and Wilhelm will present information on making crop residues a sustainable feedstock for biofuel production.</P> 
<P>August 8, 2007</P> 
<P><STRONG>78th Rocky Mountain Conference of Entomologists:</STRONG>&nbsp; On August 30th, Dr. Will Reeves, research entomologist, gave a scientific presentation at the 78th Rocky Mountain Conference of Entomologists in Woodland Park, Colorado. The title of his presentation was "Molecular Studies of Fly-Borne Pathogens".&nbsp; The presentation focused on developing and testing technologies developed for pathogen detection in mosquitoes on other flies such as black flies, keds, and stable flies.</P> 
<P>August 1, 2007</P> 
<P><STRONG>Friends & Neighbors support USDA-ARS Laboratory:</STRONG> On July 19th Over 800 guests joined the staff of the USDA-ARS Northern Great Plains Research Laboratory for “Research Roundup”, their annual ‘Friends & Neighbors Day.’ Campus activities included tours of the mature trees at the 94 year old campus and the USDA-ARS Grand Forks Human Nutrition Center’s ‘Mobile Nutrition Lab’, and presentations on water gardens and farm windbreak renovation. Children were treated to a children’s craft activity center, Rendezvous Tent and horse-drawn wagon rides. The scientists exhibited many research posters throughout the campus. The staff also provided continuous showing of presentations on the history of USDA-ARS research at the facility. On the research tour, scientists focused on soils research, how to sustainably sequence corn in crop rotations, and effects of oilseed supplementation on beef cow reproduction. Scientists from North Dakota State University joined their USDA colleagues in several presentations.&nbsp; Merrill Piepkorn, host of Prairie Public Radio’s “Hear It Now” program, which is heard throughout the multi-state region, was the musical entertainment following the evening barbecue. Over 60 sponsors contributed to support this annual event which was hosted by the Area 4 Soil Conservation District Cooperative Research Farm which supports the work of the USDA-ARS scientists in Mandan, North Dakota.</P> 
<P><STRONG>ARS Scientist To Speak At The Soil And Water Conservation Society Annual Meeting To Be Held In Tampa, FL, July 21-25, 2007</STRONG>:&nbsp; James C. Ascough II, hydrologic engineer, ARS Agricultural Research Unit, Fort Collins, CO will speak on Object Modeling and Scaling of Landscape Processes and Conservation Effects in Agricultural Systems.&nbsp; His presentation describes new computer modeling tools for assessing the impacts of conservation practice implementation at field to watershed scales.&nbsp; Complex interactions between system components and spatial units, scaling approaches, and uncertainties are being quantified using spatial-temporal field measurements and dynamic modeling using an Object Modeling System (OMS) with a modular environmental modeling structure.</P> 
<P><STRONG>Farm Credit Services Reps Visit Montana ARS Lab</STRONG>: On Tuesday, July 10, NPARL hosted the Eastern Montana Regional Local Advisory Committee Meeting for Northwest Farm Credit Services. Northwest Farm Credit Services provides financing and related services to farmers, ranchers, agribusinesses, commercial fishermen, timber producers, rural homeowners, and crop insurance customers in Montana, Idaho, Oregon, Washington, and Alaska. The regional meeting included staff and advisory committee members from four eastern Montana offices, including Billings, Miles City, Glasgow and Sidney, along with representatives from Northwest’s Spokane, WA headquarters. As part of the meeting, NPARL Weed Ecologist Andy Lenssen presented an overview of the Sidney ARS lab’s dryland research work which includes unit studies looking at tillage systems, cultural practices and crop rotations and their impact on weeds, diseases and soil and water quality. The group then was given a tour of the facility by Dr. Robert Evans, Research Leader of the Agricultural Systems Unit. </P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>Japanese Scientist Visits ARS Lab</STRONG> : NPARL Soil Scientist Upendra Sainju hosted Dr. Hajime Araki from the Hokkaido University, Japan at the Sidney, MT ARS lab, Friday, July 13. Dr. Araki was visiting NPARL to discuss potential soils research collaborations in carbon and nitrogen cycling between scientists at Hokkaido University and NPARL. While at NPARL, Dr. Araki toured the ARS facility and area research plots with Dr. Sainju, a member of NPARL’s Agricultural Systems Research Unit.</P> 
<P><STRONG>ARS Soil Scientist Invited To Speak At International Symposium</STRONG>: NPARL Soil Scientist Upendra Sainju has been invited to present two papers (one oral and one poster) at the “International Symposium on Organic Matter Dynamics in Agro-Ecosystems,” July 16-19 in Poitiers, France. The symposium brings together scientists from around the world interested in improving understanding of the processes that govern C sequestration and dynamics and its relationship to global climate change and environmental quality. The symposium also looks at the impacts of land use and management techniques on the dynamics, fluxes and fate of organic matter in soils (SOM), an essential ecosystems component. For his part, Dr. Sainju will discuss his work on “Carbon and Nitrogen storage in dryland soil aggregates as influenced by long-term tillage and cropping system” Wednesday and follow up with a poster presentation on work he has done with Z.N. Senwo, E.Z. Nyakatawa, I.A. Tazisong, and K.C. Reddy, all of Alabama A & M University, Normal, Alabama entitled “Tillage, cropping system, and nitrogen fertilizer source effects on soil carbon and nitrogen sequestration.” The latter research examined the long-term (10 yr) effects of tillage, cropping system, and N fertilization from poultry litter or inorganic N fertilizer on the amount of crop residue returned to the soil and soil organic C and N sequestration and determined that such long-term application of poultry litter can increase soil C and N sequestration compared with inorganic N fertilization, regardless of tillage and cropping systems. Dr. Sainju is a member of NPARL’s Agricultural Systems Research Unit.</P> 
<P><BR><STRONG>South Africans Visit GMPRC Facility:</STRONG>&nbsp; On June 18th, a group from the South African Crop Assessment Team, along with representatives from U.S. Wheat Associates and the Kansas Wheat Commission, toured the Hard Winter Wheat Quality Laboratory (HWWQL) and the ARS Grain Marketing & Production Research Center in Manhattan, KS.&nbsp; The group was given an overview and guided tour of the HWWQL by Dr. Brad Seabourn, HWWQL Director, and a short presentation on hard winter wheat quality testing.</P> 
<P><STRONG>Agricultural Research Service (ARS) Scientist To Participate in a Department of Homeland Security National Center for Foreign Animal and Zoonotic Disease Defense’s Subject Matter Experts (SME) workshop</STRONG>:&nbsp; On April 23-24,&nbsp; Dr. William Wilson, Microbiologist, Arthropod-Borne Animal Diseases Research Laboratory will participate in the&nbsp; “Modeling the Potential Economic Impacts of an Rift Valley Fever (RVF) Outbreak in the United States on the Beef Cattle and Dairy Industries” to be held in Washington D.C.&nbsp; RVF is an exotic viral disease found in Africa and the Arabian Peninsula and is on both the HHS and USDA biological threat list.&nbsp; If introduced into the U.S., RVF would likely affect human and agricultural health resulting in significant economic losses.&nbsp; Workshop participants will discuss existing geographic information system models, validation of models and how to improve and refine the models and estimates of economic impact.</P> 
<P><STRONG>ARS Scientist Meets With the California Department of Food And Agriculture&nbsp; And the California Department of Pesticide Regulations</STRONG>: On April 19, Drs. Tom Trout, Water Management Research, Ft. Collins, CO, along with Suduan Gao and Dong Wang, Parlier, CA, will be meeting with the California Department of Food and Agriculture and the California Department of Pesticide Regulation to share recent ARS research on soil and water management practices that reduce volatile organic compound (VOC) emissions from soil fumigants.&nbsp; California is developing regulations to reduce VOC emissions from pesticides.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>Agricultural Research Service (ARS) Scientist To Participate in International Micronutrient Forum</STRONG>: On April 16 to 18, Janet Hunt, research nutritionist, Grand Forks Human Nutrition Research Center (GFHNRC), will participate in this international symposium on the “Consequences and Control of Micronutrient Deficiencies” in Istanbul, Turkey. Dr. Hunt will present research conducted with support from both HarvestPlus and the International Institute of Tropical Agriculture (IITA), involving ARS researchers in Grand Forks and Ithaca, N.Y. as well as IITA researchers in Nigeria. Her research presentation is entitled “Iron Bioavailability from Maize and Beans: A Comparison of Human and Caco-2 Cell Measurements.”</P> 
<P><STRONG>ARS Scientists Invited To Speak At National Institute of Health</STRONG>:&nbsp; On April 10-11, Drs. Purdy and Blackburn have been invited to speak at a National Institute of Health workshop entitled "Achieving High Throughput Repositories for Biomedical Germplasm Preservation". At this workshop they will discuss the infrastructure and protocols required for high throughput processing of livestock genetic resources.<STRONG>Retired ARS Scientist Honored for Pollinator Conservation Research</STRONG>:&nbsp; Dr. Vince Tepedino will receive the Pollinator Advocate Award from the North American Pollinator Protection Campaign.&nbsp; He receives this honor in recognition of the significant contributions he made toward the conservation of&nbsp; bee species, and for increasing public awareness of the importance of native bees through scientific research on pollination of rare and endangered plants. This research was conducted while he was a scientist at the ARS Pollinating Insect Biology, Management, and Systematics Research Unit in Logan, UT, for 26 years. The awards are given to worthy recipients in the U.S., Mexico and Canada.&nbsp; This year’s recipients will be recognized at the NAPPC evening reception at the United States Botanic Garden in Washington, DC, on Wednesday, October 18, 2006 from 6 to 8 PM. </P> 
<P><STRONG>ARS Research Center Named One of Best Places to Work in 2006:</STRONG>&nbsp; The U.S. Meat Animal Research Center in Clay Center, NE was recently named (Oct. 2006) one of the top 40 Best Places to work in academia by "The Scientist" magazine.&nbsp;A survey conducted by the magazine found that the institutions named to the list provided balance which included the right mix of research, teaching, and administrative responsibilities; opportunities for interaction and collaboration with colleagues; avenues for career development and advancement; and freedom to follow research interests.</P> 
<P><STRONG>ARS Entomologist Invited To Speak At Tamarisk Research Conference:</STRONG> NPARL Entomologist Dave Kazmer has been invited to speak at the 2006 Tamarisk Research Conference: Current Status and Future Directions to be held Oct.3-4 in Fort Collins, CO. Dr. Kazmer will give a presentation on “Biological control of tamarisk: Establishment, population increase, and impacts of Diorhabda spp. at experimental release sites in the western U.S.” In addition to Dr. Kazmer’s presentation, NPARL Botanist John Gaskin will have two posters on display at the event, the first co-authored with Dr. Kazmer, is entitled “Comparison of ornamental and wild saltcedar (Tamarix spp.) along eastern Montana riverways using chloroplast and nuclear DNA sequence markers” and the second, coauthored with Patrick B. Shafroth of the U.S. Geological Survey, Fort Collins Science Center, is entitled “Hybridization of Tamarix ramosissima and T. chinensis (saltcedars) with T. aphylla (athel) (family Tamaricaceae) in the southwestern&nbsp; USA determined from DNA sequence data.” Drs. Kazmer and Gaskin are members of NPARL’s Pest Management Research Unit. The purpose of the conference is to bring tamarisk researchers together to share their results with other scientists and western land managers and to promote dialogue between researchers and managers to identify future research needs for the development of effective policy and management decisions. Currently, the non-native tamarisk (Tamarix spp.), also known as saltcedar, occupies hundreds of thousands of acres in arid and semi-arid western North America. The conference is sponsored by more than a dozen public and private agencies and organizations, including ARS.</P> 
<P><STRONG>ARS Representatives To Address Women In Ag Conference</STRONG>: On September 26-27, Dr. Robert Evans, Research Leader of NPARL’s Agricultural Systems Research Unit has been invited to speak on the latest research activities at NPARL at the 6th annual Women Stepping Forward for Agriculture Symposium to be held in Sidney, Montana. Also invited to speak at the event is another ARS representative, Dr. Rod Heitschmidt, Research Leader from the Fort Keogh ARS Livestock and Rangeland Research Laboratory at Miles City, MT, along with representatives from several other state and federal Ag agencies and organizations and private industry. The symposium is sponsored by the USDA State Food and Agriculture Council, Montana Agri-Women, Montana Cattlewomen, Montana Farm Bureau Women and Women involved in Farm Economics (WIFE) and were originally instituted to provide a platform for women involved in the promotion of Montana’s agriculture.</P> 
<P><STRONG>Agricultural Research Service (ARS) Scientist Chairs Veterinary Pathology Exam:</STRONG> On September 20-22, Bryan Stegelmeier, Veterinary Medical Officer, ARS Poisonous Plant Research Laboratory, Logan, UT, will be the general chair over the 2006 American College of Veterinary Pathology (ACVP) certification exams in Ames, IA.&nbsp; The two ACVP certification exams, Veterinary Anatomic Pathology and Veterinary Clinical Pathology, each have four parts and are given annually. In addition to being general chair, Stegelmeier is also chair of the Veterinary Anatomic Pathology exam.</P> 
<P><STRONG>UDSA-ARS Laboratory Hosts Safe Cattle Handling Seminar for Ranchers:</STRONG> On September 20th, Drs. Scott Kronberg and Eric Scholljegerdes, animal scientists at the Northern Great Plains Research Laboratory (NGPRL) at Mandan, North Dakota hosted 55 major ranchers and land-grant college educators from throughout the region for a day-long session on working cattle with calming methods, keeping them safe and productive. Dr. Tom Noffsinger of Twin Forks Veterinary Clinic at Binkelman Nebraska was the seminar leader. The morning classroom portion focused heavily on videos showing proper and improper cattle handling, with emphasis of positive and negative results of each. The afternoon portion utilized NGPRL cattle handling facilities for ‘hands-on’ experience. The educational expense was supported by a Sustainable Agriculture Research and Education (SARE) Grant through the North Dakota Rural Electric Cooperatives. Lunch was funded by the Area 4 SCD Cooperative Research Farm which supports NGPRL research, and organized and prepared by the NGPRL Technical Information Specialist. John Lee Njos, a rancher and active member of the NGPRL Customer Focus Group, spearheaded the organizing of this free event.</P> 
<P><STRONG>USDA-ARS Facility Has Simulated Hostage Situation: </STRONG>On September 13th,&nbsp; the Northern Great Plains Research Laboratory at Mandan, North Dakota was the scene of a training exercise by the Bismarck-Mandan Rapid Deployment Incident Team (formerly SWAT). The simulated hostage situation was enacted in one of the soils research buildings on the 15 acre campus. Five simulated perpetrators with three weapons held simulated hostages as police deployed and eventually were talked down by local police negotiators in routine training. The planned twelve hour exercise was cut short by a real-life hostage situation 100 miles away. The negotiators-in-training at USDA-ARS participated in the successful real-life negotiating of a male with firearm holding a female in her home a few hours after completing the exercise. Mandan USDA-ARS Collateral Duty Safety Officer Larry Renner received appropriate approvals from USDA-ARS Northern Plains Area for the exercise and monitored the training, ensuring no ammunition was present. No ARS employees were involved or research impacted. </P> 
<P><STRONG>USDA-ARS Technical Information Specialist Guest Lecturers:</STRONG>&nbsp; On September 22nd, Technical Information Specialist at the Northern Great Plains Research Laboratory at Mandan, North Dakota, Cal Thorson was asked to lecture on the value of customer service to the Agricultural Sales Class at Bismarck State College. Thorson, a 20 year professional in marketing and sales and former president to the state’s agribusiness trade association prior to joining USDA-ARS, shared insights on the added-value that front-line people can bring to a product or company when interfacing with farmers and ranchers. Thorson was selected to be the first Technical Information Specialist within the USDA-ARS. He also discussed the Government Performance and Results Act of 1993 and the significant efforts of USDA-ARS and the federal government to enhance customer focus and provide value to taxpayers from their investment.</P> 
<P><STRONG>ARS Scientist Invited To Report On Range Response To Fire:</STRONG> ARS scientist, Lance Vermeire, of the Livestock and Range Research Laboratory, Miles City, Montana, has been invited to an informational meeting for producers and land owners affected by fire entitled "After the Derby Fire" which burned more than 207,000 acres in Montana earlier this month. Dr. Vermeire's talk is "Range Response to Fire" in which he will discuss the different options for land recovery after a major fire event. The meeting is being sponsored by the Montana State University Extension Service.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>ARS Scientist Invited To 2006 Biological Workshop:</STRONG> ARS scientist, Lance Vermeire, of the Livestock and Range Research Laboratory, Miles City, Montana, has been invited to the 2006 Biological Workshop in Malta, Montana, to give a talk titled "Using fire as a management tool." The workshop is training for USDA-Fish and Wildlife Service Refuge Managers and Biologists explaining the ecological responses to fire.</P> 
<P> 
<P></P> 
<P><STRONG>ARS Scientist from Fargo Participates in International Conference on Fruit Flies in Brazil:</STRONG>&nbsp; On September 9-15, 2006, Dr. Roger Leopold, Research Entomologist, Insect Genetics and Biochemistry Research Unit, Red River Valley Agricultural Research Center, Fargo, ND, attended the 7th International Symposium on Fruit Flies of Economic Importance and the 6th Meeting of the Working Group on Fruit Flies of the Western Hemisphere in Salvador, Bahia, Brazil.&nbsp; Dr. Roger Leopold’s presentation “Cryopreservation of Mexican Fruit Fly Embryos by Vitrification” was well received by scientists from around the world and particularly, those from Brazil and Germany who are maintaining large numbers of fruit fly strains.&nbsp; Important information was gained for the utility of this method and it resulted in an invitation by a Brazilian scientist for Dr. Leopold to travel to Sao Paulo and teach him and his staff cryopreservation techniques for their tephritid strains.&nbsp; Discussions with scientists from Mexico on the rearing and development of Fopius arisanus, a parasitic wasp of several tephritid species, resulted in arrangements for obtaining a strain of this insect to be reared on the Mexican fruit fly for Dr. Leopold’s research project on the cryopreservation of the host and its parasitoid.</P> 
<P><STRONG>ARS Scientists Leading National Bioenergy Research Efforts:</STRONG> ARS scientists, Kenneth Vogel and Wallace Wilhelm gave invited papers on improving switchgrass as a biomass energy crop and on the sustainability of using corn stover for bioenergy, respectively, at the Third Annual World Congress on Industrial Biotechnology and Bioprocessing which was held in Toronto, in mid-July. Additionally, Vogel and Wilhelm were two of seven USDA scientists who were among 150 invited participants in U.S. Department of Energy, Office of the Biomass Program (OBP) 30x30 Workshop that was held in Washington, D.C. in early August. Purpose of the workshop was to develop short and long range plans to reach national bioenergy goals.&nbsp; In mid-August, Dr. Vogel, by invitation, led and facilitated the Lignocellulosic Crop Development Workgroup at the North Central Feedstock Workshop, Sioux Falls, SD.&nbsp; Workshop was sponsored by the U.S. Department of Energy, SunGrant Initiative – North Central Center, Western Governors Conference, and the Council of Great Lakes Governors. Wallace Wilhelm facilitated the workgroup on crop residues. Other ARS scientist stationed at Lincoln, NE, Madison, WI, St. Paul and Morris, MN, and Mandan, ND also participated. </P> 
<P><STRONG>ARS Switchgrass Biomass Energy Research Receiving National and International Attention:</STRONG>&nbsp; The switchgrass bioenergy research project in the ARS Grain, Forage, and Bioenergy Research Unit, Lincoln, NE has provided field tours and briefings on switchgrass bioenergy research to several groups in August in addition to responding to almost daily requests for information.&nbsp; On August 9, the project briefed the President and Vice-President of Mendel Biotechology, Hayward, CA.&nbsp; On August 10, the project provided a briefing to a representative of a Nevada Indian tribe on the feasibility of producing bioenergy from switchgrass on the Pyramid Lake Reservation in Nevada.&nbsp; Lincoln ARS scientists provided a briefing and a field tour to Chinese research administrators and scientists on the switchgrass bioenergy project on August 11.&nbsp; The Chinese scientists and administrators were under the sponsorship of USDA’s Cochran Fellowship Program.&nbsp; The visit to the ARS switchgrass research at Lincoln was one of their principal requests.&nbsp; Additional planned briefings in late August and September include a site visit by the President of Edenspace, a biotechnology company, a site visit by a Vice-President of Iogen, a Canadian biorefinery company, and a scientist from the United Kingdom who is provided agronomic support for a switchgrass bioenergy project in the UK.</P> 
<P><STRONG>ARS Scientists To Report On Sunflower Research At European Symposia:</STRONG> On September 4-6, Jinguo Hu, Research Molecular Geneticist, will present a talk on the integration of DNA TRAP markers into a sunflower SSR marker linkage map at the Seventh European Conference on Sunflower Biotechnology (SUNBIO 2006) in Gengenbach, Germany.&nbsp; The research conference, held every two to three years, brings together European sunflower researchers, along with researchers from other major sunflower producing countries.&nbsp; Gerald Seiler, Research Botanist, is an invited speaker at the First Symposium on Sunflower Industrial Uses to be held in Udine, Italy, September 10-14.&nbsp; Seiler will speak to the participants on the potential of wild sunflower species for industrial uses.&nbsp; This meeting is the first of its kind in Europe to focus on the use of sunflower oil, biomass, and natural products for lubricants, biofuel, rubber, and other industrial uses.</P> 
<P><STRONG>Montana ARS Lab Hosts Senate Appropriations Subcommittee Field Hearing:</STRONG> On August 26th, NPARL hosted a field hearing of the U.S. Senate Committee on Appropriations Subcommittee on Agriculture, Rural Development, and Related Agencies U.S. Senator Conrad Burns conducted the hearing which focused on the future of renewable fuels with a special emphasis on ethanol and biodiesel. The panel of expert witnesses included: Thomas C. Dorr, Undersecretary for Rural Development, U.S. Department of Agriculture, Washington DC and Dr. John Ashworth, Team Leader, Partnership Development with the National Bioenergy Center, Golden CO. A second five-member panel representing Montana interests included Dan Downs, board member Montana Farmers Union; Jon Stoner, president of the Montana Grain Growers Association; Dr. Jerald Bergman, director of Montana State University’s Eastern Agricultural Research Center; Garth Kallevig, representing Montana Independent Bankers, and Thad Willis, representing the Montana Farm Bureau Federation. Following the formal testimony, the hearing was adjourned and visitors allowed to question Sen. Burns and panel members.</P> 
<P><STRONG>Montana U.S. Senator Visits ARS Lab:</STRONG>&nbsp; On August 9, NPARL hosted U.S. Senator Max Baucus. The Montana Senator held a public listening session at the lab to gather producer and industry opinions on the new farm bill and other Ag issues. Discussion topics ranged from sugar to research to trade agreements during the session.&nbsp; Senator Baucus is a member of the Senate’s Agriculture Committee charged with drafting a new farm bill in 2007.</P> 
<P><STRONG>USDA-ARS Annual Friends & Neighbors Day Brings Needed Rain:</STRONG>&nbsp; The bigger the outdoor activity planned, the greater the likelihood of turning a 20% chance of rain into the most significant moisture event in 12 months! On July 20th, the Northern Great Plains Research Laboratory hosted their annual Friends & Neighbors Day which routinely attracts 600-800 guests to the Mandan USDA-ARS campus. Due to rainfall, attendance this year was approximately half of previous years, but no one complained. Over a third inch of precipitation slowly soaked the many campus exhibitors and guests all afternoon. This was the largest rainfall in Mandan since the July 2005 Friends & Neighbors Day event, which was also soaked! The hardy Mandan USDA-ARS scientists shared their integrated crop, livestock, and environmental research information in the rain. The USDA-ARS Grand Forks Human Nutrition Research Center and USDA-ARS Red River Valley Agricultural Research Center exhibits were among the numerous federal, state, and local research organizations from throughout the regional exhibiting at this event. </P> 
<P><STRONG>NGPRL Scientist Presents Soil Biology Information to farmers from No Till On The Plains:</STRONG>&nbsp; On August 3rd, Dr. Kristine Nichols (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND) presented information on soil biology and soil quality to a group of about 25 farmers from Kansas and Oklahoma as part of a “Points North” bus tour for No Till On The Plains Inc., ‘a non-profit educational organizationproviding information tofarmerson adopting no-till and other sustainableproduction methods.’ Tour participants visited 5 states (KS, CO, SD, ND, and NE) in 5 days ‘to get practical and relevant no-till information from other farmers and no-till experts.’&nbsp; At Gabe Brown’s farm near Bismarck, ND, Nichols demonstrated how increasing soil organic matter and soil structure using no till and diverse cropping systems may improve water infiltration, water holding capacity, and nutrient cycling.&nbsp; These topics addressed the organization’s mission to demonstrate how ‘adopting no-till and good agronomy (good biology) has the potential to greatly improve farmers' efficiency and profitability’ and many other societal, ‘such as greatly reduced soil erosion of cropland, less sedimentation of rivers and lakes,better wildlife habitat in fields, and the sequestering of atmosphericcarbon dioxide in soil organic matter.’</P> 
<P><STRONG>Montana ARS Lab To Be Recognized As NWS StormReady Supporter</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL is being recognized August 10th as a “StormReady Supporter by the National Weather Service (NWS). In announcing the award, Tanja Fransen of the Glasgow, MT weather forecast office noted: “The USDA station in Sidney has been extremely pro-active over the last few years in being prepared, not just for hazards within the facility but also to help with preparedness activities within the community. USDA safety officer Jackie Couture is the chair of the Richland County Local Emergency Planning Committee and actively involved with the Community Emergency Response Team. This is just a natural extension of all the great work they have been doing to help with preparedness in their workplace and the community.”&nbsp; The Sidney, MT ARS lab regularly hosts severe weather training courses and winter weather safety programs for both its employees and the community at large. Fifteen NPARL employees have been certified as NWS weather spotters.&nbsp; NPARL completed a series of rigorous warning criteria necessary to earn the distinction of being the first Storm Ready Supporter in Montana and only the 17th in the nation. The Sidney, MT research facility is also the only ARS facility in the nation to be so recognized.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>State Agency Adopts Montana ARS Lab’s E-waste Program Materials</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) In a July 19th meeting with NPARL and community representatives organizing their second “e-rase your e-waste” event, the Montana Department of Environmental Quality announced that it was adopting the group’s slogan and logo for a series of statewide e-cycling pilot programs. In announcing the decision, Montana DEQ Recycling and Marketing Development Specialist; Sandra Boggs, noted that the “e-rase your e-waste” materials from ARS provided a “catchy title and graphics (that) are easily remembered and quickly become recognizable by the public. We appreciate your development of these items and especially your willingness to share them with Montana communities. We believe the consistent use of a uniform name and logo for these events are an important part of DEQ's educational campaign regarding electronic waste. Once again - thank you for all your hard work promoting electronic waste recycling!” NPARL Technical Information Specialist Bethany Redlin developed the original materials with aid from NPARL Occupational Health and Safety Officer Jackie Couture to promote a community-wide e-cycling event held at the Sidney, MT ARS lab last summer. The event collected more than 4.2 tons of e-waste and a host of calls from other communities, businesses and individuals interested in putting together similar e-cycling programs. In response, NPARL representatives developed templates of the promotional materials and posted them on the lab’s website (under “Safety Information” at <A href="http://www.ars.usda.gov/npa/nparl"><FONT color=#0000ff>www.ars.usda.gov/npa/nparl</FONT></A>,) for anyone to use, along with tips on how to organize an “e-rase your e-waste” campaign. Since then, several entities have adapted the materials for their e-cycling efforts including neighboring Williston, ND; East Contra Costa County, CA and most recently Montana DEQ.</P> 
<P><STRONG>ARS Lab To Participate In NPS’s Lewis & Clark Corps II Event</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) Two NPARL representatives will be speaking in the Tent of Many Voices as part of Sidney, MT’s&nbsp; “Last, Best Stop” showing of the National Park Service’s Corps of Discovery II mobile exhibit August 8-12. Biological Science Technicians Kimberly Mann of Fairview and Deb Waters of Sidney will discuss “The plants of Lewis & Clark and what they might find today.”&nbsp; The women, both with the lab’s Pest Management Research Unit, will discuss the plants identified as new to Western Science by Lewis and Clark as they passed through the Yellowstone and Missouri River Confluence area 200 years ago. Mann and Waters will have several live samples of those native plants available, along with some of the “new” plants the pioneering naturalists would find today:&nbsp; noxious weeds. The technicians will also draw on materials provided by the Helena National Forest in their special “Montana Native Plants and Lewis & Clark” traveling trunk. In addition to the presentations, NPARL will also have an informational booth at the local Corps II event entitled “A New Corps of Discovery: Following in the Legacy of Lewis & Clark.” T he booth will feature posters describing some of the scientific discoveries of Lewis & Clark and comparing them with contemporary research efforts underway today at the local ARS research lab.</P> 
<P><STRONG>ARS Scientists Report on Irrigation of Horticultural Crops</STRONG>:&nbsp; On August 27 – Sept 2, Tom Trout, Agricultural Engineer from the Water Management Research Unit, Ft. Collins, CO, and David Bryla and Krista Shellie, Research Horticulturalists from the Horticultural Crop Research Laboratory, Corvallis, OR will be attending the 5th International Symposium on Irrigation of Horticultural Crops in Mildura, Australia.&nbsp; They will be reporting on improved irrigation management practices for bell peppers, lettuce, and garlic (Trout), and for blueberries (Bryla) and wine grapes (Shellie).&nbsp; The Symposium is sponsored every three years by the International Society for Horticultural Science.</P> 
<P><STRONG>Biosciences Research Laboratory Scientists to Participate in the 26th International Symposium on Halogenated Environmental Organic Pollutants</STRONG>: (ARS-Red River Valley Agricultural Research Center, Animal Metabolism-Agricultural Chemicals Research Unit, Fargo, ND).&nbsp; On August 21-25, Drs. Janice Huwe and Weilin Shelver will present papers at the Dioxin 2006 conference in Oslo, Norway.&nbsp; Dr. Huwe will present a seminar entitled, “Uptake of dioxin-like compounds in growing swine: correlation between experimental and predicted data.”&nbsp; Dr. Shelver will present a seminar entitled, “Comparison of soil PBDE levels using HRGC-HRMS and magnetic particle enzyme immunoassay” and a poster presentation entitled, “Development of a magnetic particle immunoassay and its application to the measurement of triclosan in water and wastewater.”&nbsp; This conference is attended by scientists from industry, government, and academia representing most developed countries of the world.</P> 
<P><STRONG>ARS Researcher To Speak At Botanical Society Centennial Conference:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Botanist John Gaskin will be attending the Botanical Society of America annual conference July 29-Aug. 2 at Chico, CA. Dr. Gaskin will be presenting a paper Aug. 2 on “Novel hybrids produced since the introduction of saltcedar and the influence of garden plantings on nearby invasions.” Additional authors of the presentation include Dr. David Kazmer, also with USDA-ARS in Sidney, MT, and Pat Shafroth (USGS, Ft. Collins, CO). Dr. Gaskin is a member of NPARL’s Pest Management Research Unit. More than 1000 participants will present over 700 scientific contributions including papers, posters, special lectures and 15 symposia at the conference, which marks the Society’s 100th year.</P> 
<P><STRONG>ARS Scientist Helping To Organize 1st International Cercospora Symposium:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Plant Pathologist Robert Lartey is among five organizers putting together the 1st International Symposium on Cercospora Leaf Spot of Sugar Beet to be held Aug. 2 during the joint meeting of the American and Canadian Phytopathological Societies and the Mycological Society of America to be held in Quebec City, Quebec, Canada July 29-Aug. 2. Two other ARS researchers are also helping coordinate this first-ever event. They include Drs. Lee Panella (USDA-ARS, Ft. Collin, CO) and John Weiland (USDA-ARS Fargo, ND). Nearly two dozen researchers from North America and Europe are participating in the day-long symposium Aug. 2 which is the first to bring together researchers from around the world studying this very serious and destructive fungal disease in sugar beet. For his part, Dr. Lartey will present a paper entitled “Biological Relations of Cercospora beticola with Host Plants and Fungal Antagonists.” Additional authors on that paper include Soumitra Ghoshroy of New Mexico State University, Las Cruces, NM, and TheCan Caesar-TonThat, Andy Lenssen and Robert Evans, all with USDA-ARS in Sidney, MT. Dr. Lartey is a member of NPARL’s Agricultural Systems Research Unit.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>Agricultural Research Service (ARS) Research Leader To Give Lecture On Nutrient Supplements</STRONG>: On Oct. 13-20, Janet Hunt, Research Leader, ARS Grand Forks Human Nutrition Research Center, Grand Forks, ND, will give a lecture in Moscow to Russian medical specialists (including practicing physicians and researchers from government medical centers, clinics, and institutes) on the effect of calcium supplementation on iron absorption. </P> 
<P><STRONG>Agricultural Research Service (ARS) Scientist To Attend Boron Symposium</STRONG>: On Oct. 28-Nov. 6, Curtiss Hunt, Research Biologist, ARS Grand Forks Human Nutrition Research Center, Grand Forks, ND, will give a presentation, “Dietary Boron: Progress in Establishing Essential Roles in Human and Animal Physiology,” at the Third International Boron Symposium in Ankara, Turkey.</P> 
<P><STRONG>ARS Researchers To Discuss Precision Ag, Sugar Beet Research At Field Day</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Research Agronomist Bart Stevens and Physical Scientist Bill Iversen have been invited to speak at Montana State University’s Eastern Agricultural Research Center (EARC) Field Day in Sidney, MT on July 20. The researchers, both with NPARL’s Agricultural Systems Research Unit, will discuss “Precision irrigation and strip till sugar beet production” in their presentation. Other presenters at the event include university and industry representatives from MSU-Bozeman; North Dakota State University’s Williston Research and Extension Center, Williston, ND; Sidney Sugars, Inc. and Busch Agricultural Resources, Inc.. In addition, cooperative research between EARC and NPARL will also be discussed during the Montana Agricultural Research Centers’ summer conference hosted by EARC July 20-21, following the field day. The gathering brings together research staff from MSU’s seven outlying research centers to learn about research work at the host site and identify possible collaborative projects.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>ARS Ecologist, Technician To Participate In Montana Farm Tour</STRONG>:&nbsp; (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Weed Ecologist Andy Lenssen and Biological Science Technician Deb Waters are participating in the Daniels County Farm Tour in Scobey, MT, July 17. Waters, who work for NPARL Entomologist Tom Shanower (currently in China to collect parasites attacking the wheat stem sawfly), will join Research Agronomist Bill Berzonsky from North Dakota State University to discuss sawfly research efforts underway in Montana and North Dakota. Dr. Lennsen will discuss “Weed management in dryland cropping systems” during his presentation. Other university, government and industry reps will discuss topics ranging from pesticide record keeping, weed control in organic production and spring wheat and durum variety plots.4 Waters is with NPARL’s Pest Management Research Unit, while Lenssen is with the lab’s Agricultural Systems Research Unit.</P> 
<P><STRONG>ARS Weed Ecologist To Speak At 26th Annual Swank Variety Tour</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Weed Ecologist Andy Lenssen has been invited to participate in the 26th annual Swank Variety Tour at the Swank farm in eastern Montana June 20. Dr. Lenssen’s presentation will address “Weed seed bank management.” The tour is sponsored by area agricultural chemical representatives, the Culbertso n and Poplar, MT Chambers of Commerce, Montana State University and Roosevelt County. Lenssen is a member of NPARL’s Agricultural Systems Research Unit.</P> 
<P><STRONG>Kazakhstan Researcher Meets With Montana ARS Saltcedar Scientists</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) Kazakhstan zoology senior researcher Roman Jashenko visited the Sidney, Montana ARS research laboratory as the guest of NPARL saltcedar researchers, Entomologist Dave Kazmer and Botanist John Gaskin July 8-11. Jashenko works with USDA to identify insects with the potential to serve as biological control agents for saltcedar and other noxious weeds that originated in Kazakhstan. Jashenko helped identify the Chinese leaf beetle, Diorhabda elongata, that has been successful in combating saltcedar at a Wyoming research site overseen by Dr. Kazmer, but which has been subject to severe predation at another site located near Fort Peck, Montana. Jashenko and Kazmer toured the Montana site July 10 and Jashenko will now turn his attention to identifying potential predator-resistant biocontrol insects for use in that area. Drs. Kazmer and Gaskin are both members of NPARL’s Pest Management Research Unit.</P> 
<P><STRONG>USDA-ARS Laboratory Hosts High School Biology Class:</STRONG>&nbsp;&nbsp; On June 20th the scientists and staff of the Northern Great Plains Research Laboratory helped the teachers of the Bismarck High School Summer Biology classes make science come alive. Drs. Kris Nichols, (Soil Microbiologist), Rebecca Phillips (Plant Physiologist), and Eric Scholljegerdes (Animal Scientist) provided the 40 students and their instructors ‘hands on’ biology experience at the Mandan, ND research campus. As they showed the students their research, each ARS scientist emphasized the symbiotic interrelationships between humans, animals, plants, soils, and the environment we all live in. After their time with the scientists and lunch provided by the Area 4 SCD Cooperative Research Farm, the students availed themselves of the beautiful 90 year-old, 15 acre campus for tree and native grass identification, and chasing insects for their biology class collections.&nbsp; Scott Bylin, Maria Striped Face – Collins, Clay Erickson, and Cal Thorson helped with the activities.</P> 
<P><STRONG>Agricultural Research Service (ARS) Research Leader to address workshop on Dietary Reference Intakes Research Synthesis</STRONG>. On June 7-8, Janet Hunt, Research Leader, ARS Grand Forks Human Nutrition Research Center, Grand Forks, ND, will attend a workshop sponsored by the Institute of Medicine of the National Academies to discuss issues related to knowledge gaps and research needs in developing and advancing the Dietary Reference Intakes.&nbsp; She has been invited as a “fresh perspective speaker” to address research needs related to trace element nutrition. The workshop will be held at the Keck Center of the National Academies in Washington, DC.</P> 
<P><STRONG>You’re Never Too Young To Learn At ARS:</STRONG>&nbsp; On May 2, NPARL hosted 20 plus Sidney, Montana, preschool students, ages 3 to 6, at the Sidney, ARS facility. The youngsters came to learn more about insects through colorful displays and fun exercises set up in the lab’s tech transfer room. In addition to viewing displays of pinned insects, the youngsters learned about: insect body parts, what insects eat, what eats insects, how insects eat, insect sounds and how insects make sounds. The youngsters then learned about good and bad insects and how good insects can be used to help control noxious weeds through biological control, a major focus of the lab’s Pest Management Research Unit. Helping with the presentations were Technical Information Specialist Beth Redlin and PMRU Biological Science Technician Kimberly Mann. This is the second year the preschoolers have visited the Sidney, MT lab.<BR></P> 
<P><STRONG>APHIS Designated TSE Epidemiology workshop at USMARC:</STRONG>&nbsp; APHIS will be conducting a week-long workshop on "Designated TSE Epidemiology" at the Center.&nbsp; The training will begin at 8:00 AM on Monday, May 1, and end at 11:00 AM on Friday, May 5.&nbsp; They are expecting about 125 attendees (including presenters).&nbsp; The attendees are APHIS veterinarians from all over the USA (one or two per state).&nbsp; They will be using the Building 19 Auditorium, and Buildings 2 and 20, as well as GPVEC facilities.&nbsp; The week long agenda is posted on USMARC intranet.&nbsp; Scott Opbroek, Shuna Jones, Mike Wallace, and Terry Madson have spent a great deal of time with our APHIS colleagues in planning for this meeting.&nbsp; Scott, Shuna and Mike will be heavily involved during the week.&nbsp; Bruce Larsen and Butch Hassler will also help.</P> 
<P><STRONG>North Central Agricultural Research Laboratory To Hold Building Dedication</STRONG>:&nbsp; On April 20th, the North Central Agricultural Research Laboratory will hold a special ceremony to celebrate the completion of 13,000 square feet of new laboratory/office space, a new Technology Transfer Center, and the renovation of existing facilities that will enhance the agricultural research carried out at the location.&nbsp; Following the dedication ceremony, NCARL staff will be offering guided tours of the entire facility.&nbsp; They’ll also be hosting an open house in the late afternoon for community members unable to attend the morning ceremony.&nbsp; Special guests include Senator Tim Johnson, South Dakota; USDA Under Secretary for Research, Education and Economics Merle Pierson; ARS Administrator Edward B. Knipling; and South Dakota State University President Peggy Gordon Miller.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P></P> 
<P><STRONG>ARS Rep Instructs WSWS Weed Management Biocontrol Course</STRONG>.&nbsp; On April 24-27, NPARL Biological Science Technician Mary Mayer has been asked to conduct a hands-on workshop session on biological control of saltcedar and spotted and diffuse knapweeds at Chico Hot Springs in Pray, MT. Mayer’s presentation is part of the annual Noxious Weed Short Course sponsored by the Western Society of Weed Science. The short course was developed for public and private land managers that want to gain a better understanding of noxious weed management. The course supports and teaches ecologically sound management practices for invasive plants. Weed management professionals from throughout the West conduct the traini ng program designed to encourage interaction between instructors and participants. Lab and field exercises, in addition to classroom sessions, are used as teaching methods. Mayer, a member of NPARL’s Pest Management Research Unit, has participated as a short course instructor in biocontrol for the past 10 years.</P> 
<P><STRONG>Agricultural Research Service (ARS) Grand Forks Human Nutrition Research Center scientist to present outreach seminar</STRONG>: On April 11, Curtiss Hunt, research biologist, will present a seminar entitled, "The Bricks (Calcium) or the Mortar (Everything Else): Which is More Important in a Healthy Bone?" The seminar is part of the University of North Dakota Medical School for the Public lecture series on "Aging from the Outside In." The series introduces the public to the basic biology of aging of organ systems. The videoconference will be available to participants in several cities in North Dakota and is also available by webcast <A href="http://smhs.med.und.nodak.edu/UNDSMHS/webcasts/minimedicalschool.html">here</A>.<BR></P> 
<P><STRONG>ARS Participates In NPS’ “Fur Trade Life” Education Program</STRONG>.&nbsp; On April 8, NPARL Biological Science Technician Kimberly Mann participated in the National Park Service’s “Fur Trade Life” outreach program at the Fort Union Trading Post National Historic Site near Williston, North Dakota.&nbsp; Approximately 50 middle schools students from around the area participated in the hands-on activities, which included a nature trail hike with discussion of native and introduced plants; buffalo hide tanning; trade transactions; tipi setup; blacksmithing; Indian games; bead sewing and traditional food preparation. For her portion of the program, Mann discussed characteristic s of native and introduced grasses in the area, along with information on the competitive nature of introduced weeds such as leafy spurge and the use of biological control to manage them. Mann, a member of NPARL’s Pest Management Research Unit, works in the Sidney, MT lab’s weed biocontrol program.</P> 
<P><STRONG>North Dakota High School Science Teachers Inspect ARS Research:</STRONG> Members of the North Dakota Science Teachers Association will tour the Northern Great Plains Research Laboratory and listen to formal presentations by NGPRL scientists on Friday, March 31st.&nbsp; Holly Johnson, and Drs. Kris Nichols and Mark Liebig will make presentations on NGPRL research, ARS Global Change research, and ARS soil microbiology research. Their research tour will visit several research labs and the research greenhouse facilities. The group of 30 teachers will conclude their experience with a brief visit to the new Beef Research Facility and Area 4 SCD Cooperative Research Farm that supports NGPRL field-scale conservation research.</P> 
<P><STRONG>USDA-ARS Scientist Trains Cattlemen on Livestock Waste Management:</STRONG> On March 7-17, Dr. Scott Kronberg, Ruminant Nutritionist at the Northern Great Plains Research Laboratory, participated in four two-day “Livestock and Manure Nutrient Management” seminars for farmers and ranchers throughout the region. In his presentation titled, “Let Cattle Hustle Their Feed: Wintering Cows and Growing/Fattening Yearlings on the Field with Annual Forages” profiled the Mandan, ND research developing annual northern agronomy crops swath-grazed throughout the winter to increase profitability and reduce environmental impact. The four sessions at Devils Lake, Valley City, Dickinson, and Minot averaged of 50 cattlemen at each meeting. Kronberg received very positive feedback on this new innovative feeding strategy. </P> 
<P><STRONG>USDA-ARS Animal Scientist Presents at Regional Scientific Conference:</STRONG> On March 28th, Dr. Scholljegerdes made a presentation titled, “Fat Supplementation of Beef Cows on a Forage-Based Diet” at the “Pfizer/NDSU Scientific Exchange.” The Northern Great Plains Research Laboratory researcher joined scientific colleagues from private industry and other public research organization from throughout North Dakota, South Dakota and Montana at this annual research conference at Dickinson, North Dakota.</P> 
<P><STRONG>ARS Scientists Present at Research Results & Technology Conference</STRONG>: The Area 4 SCD Cooperative Research Farm held their 22nd annual public technical transfer event for farmers and ranchers on February 21st in Bismarck, North Dakota. Over 160 producers participated in the all-day research information event. Agricultural Research Service scientists from the Northern Great Plains Research Laboratory in Mandan, North Dakota provided presentations on their research to assist Ag producers become more financially effective and energy efficient in their farm and ranch production systems. Participating staff and their topics were: Dr. Steve Merrill, ARS Soil Scientist - "Crop Sequencing to Reduce Costs", Dr. Joe Krupinsky, ARS Plant Pathologist - "Reduce Disease Losses by Planning Ahead", Dr. Kris Nichols, ARS Soil Microbiologist - "Make Soil Biology Work For You", Dr. Rebecca Phillips, ARS Plant Physiologist - "Remote Products for Integrated Agricultural Landscapes", Dr. Don Tanaka, ARS Soil Scientist - "Winter Feeding Annual Crops",&nbsp; Dr. Eric Scholljegerdes, ARS Ruminant Nutritionist - "Low Input High Output Cows" and "Least Cost&nbsp; Cattle Growing and Finishing" (presentation prepared by Dr. Scott Kronberg, ARS Animal Scientist), Dr. John Hendrickson, ARS Range Scientist - "Managing Range to Reduce Costs", and Dr. John Berdahl, ARS Forage Breeder - "New Grass for Hay & Grazing". Vern Hoffman, NDSU Extension Ag Engineer presented "Put Your $$$ Where It Counts", a report on the NDSU/ARS collaborative site-specific variable application research at NGPRL. Ron Wedierholdt, NDSU Nutrient Management Specialist presented "Value of Manure as a Fertilizer." Steve Metzger of the North Dakota Farm and Ranch Business Management Education Program utilized actual on-farm record statistics to present, "Integrating Crops and Livestock to Reduce Risk." Tim Faller, new director of the Northern Great Plains AgroEcoSystems Research Center shared also their collaborative direction with the audience. The 400 acre Area 4 SCD Cooperative Research Farm was developed by the local soil conservation districts 22 years ago to support natural resources research of the Agricultural Research Service.</P> 
<P><STRONG>ARS Pathologist Invited to Give Opening Keynote Address to Pathologists in South Africa</STRONG>:&nbsp; (USDA-ARS Northern Crop Science Laboratory, Fargo, ND)&nbsp; NCSL Pathologist Tom Gulya gave the opening keynote address at the 44th Congress of the Southern African Society for Plant Pathology, held at Magalies Park, South Africa, 22 to 25 January.&nbsp;&nbsp; Dr. Gulya’s address was entitled “Recent advances and novel concepts in managing Sclerotinia diseases on sunflower and other crops” and also highlighted research sponsored by the USDA Sclerotinia Initiative.&nbsp;&nbsp; Afterwards, Dr. Gulya visited with scientists from South Africa’s Agricultural Research Council and the University of Pretoria.&nbsp;&nbsp;&nbsp; Dr. Gulya also met with Dutch scientists from Wageningen University on his return trip to discuss a newly funded Dutch project to manage downy mildew on ornamental sunflowers.&nbsp; Dr. Gulya is a member of the Sunflower Research Unit.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>Media Contacts:</STRONG></P> 
<P><STRONG>ARS Chemist Contacted by Media Organizations:</STRONG>&nbsp; (USDA-ARS Northern Crop Science Laboratory, Fargo, ND)&nbsp;&nbsp; ARS Research Chemist Brady Vick was contacted by the Forum, a regional newspaper from Fargo, ND, and the local FOX news station for comment on a news release by researchers from the University of Bonn, Germany.&nbsp; The German researchers reported on an antifungal toxin isolated from Sclerotinia-infected sunflower that showed antiviral activity against HIV in in vitro experiments.</P> 
<P><STRONG>Multiple news media contacts following the President’s State of the Union address:</STRONG>&nbsp; On February 1, Kenneth P. Vogel,&nbsp; Plant Geneticist & Research Leader, Lincoln, NE was contacted by Lincon, NE ABC affiliate about switchgrass.&nbsp; Made a brief video tape in a field nursery containing dormant switchgrass plants.&nbsp; Video was on Lincoln evening TV news and on following morning news.&nbsp; Voice mail message from ABC.com concerning switchgrass.&nbsp; Referred the caller to the Lincoln ABC affiliate. February 2,&nbsp; K.P. Vogel&nbsp; had telephone interview with Rick Montgomery, Kansas City Star.&nbsp; Provided extensive background information on switchgrass as a biomass energy crop. February 7,&nbsp; K.P. Vogel had telephone interview with David Coles of&nbsp; Newshour with Jim Leher.&nbsp; Also provided background information via electronic files of&nbsp; previously published reviews and studies.<STRONG>ARS Microbiologist to Speak at Zero Tillage Workshop:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Research Microbiologist TheCan Caesar has been invited to speak at the 2006 Manitoba-North Dakota Zero Tillage Farmers Association Workshop to be held in Bismarck, ND Feb. 9-10. Dr. Caesar’s presentation for the event is entitled “Building and Enhancing Soil Biology.” She is a member of the Sidney, MT ARS lab’s Agricultural Systems Unit. In addition to her presentation, Dr. Caesar plans to meet with other interested scientists and producers at the session to discuss possible collaborations on identifying and evaluating alternative grass crops, such as intermediate wheat grass, Timothy grass or switchgrass, that not only have value as potential cash crops, but which can also improve soil quality. Currently Dr. Caesar is studying switchgrass for its ability to improve soil aggregation in rotational systems. Switchgrass is also being studied as a biofuel. Joining Dr. Caesar at the Zero Tillage Workshop will be NPARL Soil Scientist Bart Stevens, Physical Scientists Bill Iversen and Biological Science Technician Bryan Gebhard, all members of NPARL’s Agricultural Systems Research Unit. </P> 
<P><STRONG>ARS Entomologist to Speak at Range Society Meeting:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Entomologist David H. Branson has been invited to speak at the 9th Annual Meeting of the Society for Range Management, Feb 12-17, 2006 in Vancouver, British Columbia. Dr. Branson’s presentation is entitled “Effects of summer fire and post-fire grazing on grasshopper abundance and species composition” and discusses research being conducted jointly with Dr. Lance T. Vermeire, Rangeland Ecologist with USDA-ARS’s Fort Keogh Livestock and Rangeland Research Laboratory in Miles City, MT. Dr. Branson is a member of NPARL’s Pest Management Research Unit. </P> 
<P><STRONG>ARS Plant Pathologist to Speak at WSSA Meeting:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT) NPARL Plant Pathologist Anthony Caesar has been invited to speak at the 46th annual meeting of the Weed Science Society of America to be held in New York City Feb. 13-16. Dr. Caesar will present his paper entitled “Soilborne fungi associated with root galls of Lepidium draba caused by Ceutorhynchus spp. Dr. Caesar is a member of NPARL’s Pest Management Research Unit. This meeting marks the 50th Anniversary of the charter meeting of the Weed Society of America, which originally met in New York City on January 4-5, 1956. </P> 
<P><STRONG>ARS Entomologist Conducts Insect Pest ID Workshop:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; NPARL Entomologist Tom Shanower helped lead an Insect Identification Lab Wednesday, Feb. 1, as part of the 2006 Western Crop and Pest Management School sponsored by North Dakota State University’s Extension Service. The two-day school held at Dickinson, ND is designed for individuals scouting crops for pest and production problems in 2006 and targets problems common to western North Dakota. Dr. Shanower was joined by Dr. Jan Knodel, Assistant Professor in the NDSU Entomology Department, in directing the lab. In addition, NPARL Biological Science Technician Deb Waters also helped with the hands-on component, acquainting participants with Hessian fly, wheat stem maggot, saw fly and cutworm. Other subjects addressed at the Extension school included weed identification and management, crop production issues and diseases and herbicide updates. Dr. Shanower is the research leader of NPARL’s Pest Management Research Unit. </P> 
<P><STRONG>ARS Scientists to Meet with Tribal College Ag Department Head:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT)&nbsp; Carrie Archdale, Director of the Agriculture Department at Fort Peck Community College (FPCC) in Poplar, MT, and other tribal college officials, will travel to Sidney, MT Monday, February 13, to take part in a roundtable discussion with ARS researchers at the USDA-ARS Northern Plains Agricultural Research Laboratory (NPARL). Beginning with an overview by Archdale of FPCC activities, ARS scientists at the lab will follow up with brief overviews of their own research projects. The participants will then discuss common interests and/or activities that NPARL and FPCC could work on together. The meeting is an outgrowth of an earlier meeting last November between NPARL Research Leaders Dr. Robert Evans (Agricultural Systems Research Unit) and Dr. Tom Shanower (Pest Management Research Unit) and a dozen Montana State Legislators and Tribal College representatives to discuss steps to implement Montana House Joint Resolution 11 passed during the state’s last legislative session. The resolution urges “cooperation between and among state and federal agricultural research stations and tribal agricultural research programs to facilitate ongoing research, sharing of research scientists, and educational efforts in addressing critical issues concerning deleterious insects, pesticide use, livestock disease, noxious weeds and irrigated and dryland cropping systems.” Participating tribal governments include those with the Fort Peck, Fort Belknap and Rocky Boy Reservations in Montana. In addition to exploring new areas of research cooperation, NPARL has also provided tribal officials with information on student employment opportunities at the Sidney lab (and with ARS in general) and is exploring new opportunities to train tribal faculty as well through special fellowships.</P> 
<P><STRONG>Science Students Participate in Mormon Cricket Brownbagger at Montana ARS Lab</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). Approximately two dozen 8th grade students attended a Friday brownbagger given by NPARL Ecologist Greg Sword Nov. 18 entitled “Mormon crickets and the people who chase them: A retrospective.” The students, from teacher Mark Halvorsen’s advanced science class at Sidney Middle School (Sidney, MT), were invited to participate because of their recent studies on Global Positioning System technology. Dr. Sword’s presentation provided them a real-world peek into the application of GPS technology to a specific research project. Sword, a scientist with the lab’s Pest Management Research Unit, discussed work he and his collaborators have done on Mormon cricket band formation and migration. The group’s research was featured in a Brief Communications article in the Feb. 17th edition of “Nature” and showed that flightless Mormon crickets form large mobile groups, called migratory bands, as a means of protecting themselves from their predators.&nbsp; Similar processes have already been shown in herding animals, for example, but had not been previously demonstrated in migratory band-forming insects. The study involved using small radio transmitters to track individual insects within and outside large Mormon crickets bands which have been plaguing the western US the past three summers. The researchers found that 50-60% of the insects that left a band were killed by predators within two days of departure, while all of the insects remaining in the band survived. Working with Sword on the project were Dr. Pat Lorch of the University of North Carolina, Chapel Hill and Dr. Darryl Gwynne of the University of Toronto at Mississauga. </P> 
<P><STRONG>ARS Scientists Meet with Montana Tribal College Reps and State Legislators</STRONG>:&nbsp;(USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). NPARL Research Leaders Dr. Robert Evans (Agricultural Systems Research Unit) and Dr. Tom Shanower (Pest Management Research Unit) met Nov. 15 with a dozen Montana State Legislators and Tribal College representatives to discuss steps to implement Montana House Joint Resolution 11 passed during the state’s last legislative session. The resolution urges “cooperation between and among state and federal agricultural research stations and tribal agricultural research programs to facilitate ongoing research, sharing of research scientists, and educational efforts in addressing critical issues concerning deleterious insects, pesticide use, livestock disease, noxious weeds and irrigated and dryland cropping systems.” Participating tribal governments include those with the Fort Belknap, Fort Peck and Rocky Boy Reservations in Montana. While further planning sessions are needed to bring all parties together, representatives from the Sidney, MT ARS lab did agree to provide the three participating tribal college representatives with additional information on student employment opportunities at the Sidney ARS lab (and with ARS in general) and to explore new opportunities to train tribal faculty as well through special fellowships.&nbsp; </P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>ARS Scientists Participate in Tri-Societies Annual Meeting</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). Four scientists with NPARL’s Agricultural Systems Research Unit participated in the 2005 ASA-CSSA-SSSA International Meeting in Salt Lake City, UT, Nov. 6-10. The yearly meetings of the American Society of Agronomy (ASA), the Crop Science Society of America (CSSA), and the Soil Science Society of America (SSSA) bring together 4,000+ people from 40 countries representing academia, government and private industry. NPARL scientists participating and the title of their posters were: Soil Scientist Jay Jabro, “Spatial Variability of Physical Properties in Lihen Sandy Loam Soil” (coauthors included Drs. Bart Stevens and Robert Evans also with the lab’s Ag Systems unit);&nbsp; Ecologist Andy Lenssen, “Preplant Weed Management and Planting Date Influence Barley Forage Yield and Quality;”&nbsp; Soil Scientist Jed Waddell, “Effect of Phosphorus Fertilization Rates on Field Pea Nitrogen Production” (coauthored with Dr. Lennsen), and Agronomist Upendra Sainju, “Carbon supply and storage in tilled and non-tilled soils as influenced by cover crops and nitrogen fertilization,” (coathored with B.P. Singh, W.F. Whitehead and S. Wang, all with Fort Valley State Univ., GA). </P> 
<P><STRONG>Agricultural Research Service (ARS) Range Scientist Travels to Brazil for Collaborative Research Studies</STRONG>: On Nov. 26 to Dec. 16, James Pfister, range scientist, ARS Poisonous Plant Research Laboratory, Logan, UT, will travel to Brazil and consult with faculty and graduate students at the University of Sao Paulo, Center for Veterinary Toxicology, on research studies involving two toxic plants which cause major livestock losses in Brazil. In one study, pregnant goats will be fed Ipomoea carnea to examine its effect on maternal and neonate behavior at birth.&nbsp; A similar project on intoxication of goats by Senna occidentalis will also be conducted.&nbsp; Pfister has experience in this area of research because of his own work with swainsonine-containing locoweeds in the U.S. </P> 
<P><STRONG>USDA-ARS Scientists Present Symposium At Tri-Societies Annual Meeting</STRONG>: (Northern Great Plains Research Laboratory): On November 7th, Agricultural Research Service scientists from Mandan, ND and the National Soil Erosion Research Laboratory created and presented a symposium “Dynamic Cropping Systems for Soil & Water Conservation” at the 2005 ASA-CSSA-SSSA International Meeting in Salt Lake City, UT. Dynamic cropping systems – defined as a long-term strategy of annual crop sequencing that optimizes crop and soil use options to attain production, economic, and resource conservation goals using ecologically-based management principles – possess an inherent flexibility to adapt to high-risk conditions, and are therefore more sustainable than prevalent cropping systems. The symposium highlighted research results from a dynamic cropping systems project conducted in the U.S. northern Great Plains, and included presentations on crop production, plant diseases, soil water use, soil biology/quality, and potential management applications. The presentation titles (and presenters) were: “Dynamic Cropping Systems for Sustainable Crop Production” (Dr. Donald Tanaka, Soil Scientist),“Dynamic Cropping Systems for Managing Plant Disease Risks” (Dr. Joseph Krupinsky, Plant Pathologist), Dynamic Cropping Systems for Effective Use of Soil Water (Stephen D. Merrill, Soil Scientist), “Dynamic Cropping Systems Influence on Soil Biochemistry” (Diane E. Stott, USDA-ARS National Soil Erosion Research Laboratory), and “Applying Dynamic Agricultural System Concepts to Meet Future Challenges to Soil and Water Conservation” (Dr. Jon Hanson, Supervisory Rangeland Scientist). The symposium was moderated by Dr. Mark Liebig, USDA-ARS Soil Scientist. An audience of 100-110 attended the scientific symposium. Publication of these symposium papers will be forthcoming in Agronomy Journal. Dr. Al Frank, Plant Physiologist and USDA-ARS Collaborator also presented, “Intra Seasonal Net Ecosystem Flux Dynamics of Crop and Grassland” in another session at the ASA-CSSA-SSSA International Meeting. USDA-ARS scientists from Mandan authored and/or co-authored 37 papers for this annual international scientific meeting. </P> 
<P><STRONG>USDA-ARS Scientists Focus On Carbon Above And Below Ground</STRONG>: (Northern Great Plains Research Laboratory): On November 7th, Agricultural Research Service scientists from Mandan, ND supported the educational efforts of the North Dakota Association of Soil Conservation Districts by highlighting their educational program. Dr. Rebecca Phillips (Plant Physiologist) presented: “Above ground Carbon Flow – Surface to Space Connection” and Dr. Kris Nichols (Soil Microbiologist) presented: “Below ground Carbon Flow – The Glomalin Connection” to an audience of approximately 100 conservation leaders from throughout the state. </P> 
<P><STRONG>USDA-ARS Scientist Nominated For International Recognition</STRONG>: (North Central Soil Conservation Research Laboratory): Dr. Don Reicosky, USDA-ARS Soil Scientist, has been nominated by the Manitoba-North Dakota Zero Tillage Farmer’s Association for recognition as their “2006 U.S. Non-Farmer of the Year”. This recognition is bestowed each year on one individual from the United States (and one from Canada) who has most significantly advanced the ethic and science of conservation throughout the upper Great Plains region. Dr. Reicosky’s research and extensive communication on managing to improve soil organic carbon has had significant impact in influencing family farmers to focus on managing their soils as a renewable resource which can be enhanced through proper management. The award will be presented at their annual workshop in Bismarck North Dakota on February 10, 2006. Previous USDA-ARS recipients of this honor have been Al Black, Dr. Armand Bauer, Dr. Joe Krupinsky, and Dr. Ardell Halverson. </P> 
<P><STRONG>USDA-ARS Laboratory And Research Profiled In South Dakota Farm Press</STRONG>: (Northern Great Plains Research Laboratory): The Northern Great Plains Research Laboratory and scientists were the subject of a November 8th two-page article by the Aberdeen American News Farm Forum. Photos of each scientist accompanied their bio and a synopsis of their major research. This publication reaches approximately 34,000 farmers and ranchers throughout South Dakota and North Dakota. </P> 
<P><STRONG>ARS Veterinarian Invited to Speak to Scientists in Uruguay</STRONG>:&nbsp; On November 16 – 19, Bryan Stegelmeier, Veterinary Medical Officer, ARS Poisonous Plant Research Laboratory, Logan, UT, will attend the 12th International Symposium of the Association of Veterinary Laboratory Diagnosticians, in Montevideo, Uruguay.&nbsp; Stegelmeier will discuss current techniques in identifying and monitoring toxic plant problems in livestock and wildlife. </P> 
<P><STRONG>American Livestock Breeds Conservancy meets at and tours the National Animal Germplasm Program at the Center for Genetic Resources Preservation</STRONG>: On October 7, the American Livestock Breeds Conservancy in collaboration with the American Grassfed Association held a one day meeting at the National Center for Genetic Resources Preservation as part of their annual conference and members’ meeting. The theme of the meeting was "Green Genes: Saving Breeds Created for Grass". Eighty-five members from the two organizations were updated on the status of the animal germplasm collection activities, and toured the laboratories and storage area. </P> 
<P><STRONG>ARS Campus Valuable To Animal Science Students</STRONG>: (USDA-ARS Northern Great Plains Research Laboratory, Mandan, ND). Bismarck State College Animal and Range Science students will be developing understanding of laboratory and range sciences at NGPRL as part of their college curriculum. On October 12th, the BSC Animal Science class visited the range renovation research sites and was lectured on the value of grazing lands for the production of high-value protein for the human diet by Dr. John Hendrickson, USDA-ARS Range Scientist. They will return to work with Dr. Eric Scholljegerdes, USDA-ARS Ruminant Nutritionist in the new "Animal Nutrition Laboratory" ant NGPRL on October 17th. Carmel Miller, BSC Animal Agriculture Instructor and active NGPRL Customer Focus Group member expressed her appreciation that USDA supports integrated crop/animal research in this region. </P> 
<P><STRONG>Georgian Scientist Visiting Montana ARS Lab To Study Insect Mycology</STRONG>: Dr. Eleanora Abashidze, of the Georgian Institute for Plant Protection and the Georgian State University, Tblisi, will be visiting the lab of Dr. Stefan Jaronski, NPARL, Sidney Montana for two weeks of training in insect mycology. Her visit is being funded by a U.S. Agency for International Development grant to the Volcani Institute of Israel, University of Wyoming and Dr. Jaronski, entitled "Biological Control of Locusts in Georgia: Building Self-Sufficiency." The purpose of the 2- year program is to teach Georgian scientists how to select and develop a microbial control agent to the point of commercialization and to help create the scientific infrastructure to do so in that country. Later in the year Dr. Jaronski and Dr. Alex Latchininsky (University of Wyoming) will travel to Tblisi to assist setting up the relevant laboratory facilities and initiate screening studies. </P> 
<P align=right><A href="#top">Back to top</A></P> 
<P><STRONG>ARS Scientist To Participate In Biopesticide Meeting</STRONG>: On October 11th and 12th, Dr. Stefan Jaronski, Sidney Montana, has been invited to attend the annual meeting of the Biopesticide Industry Alliance, to be held in Sacramento California to represent ARS interests in the development of insect pathogens. The topic of the BPIA meeting is "Adoption of Biopesticides in IPM Programs." BPIA's first meeting was April 19, 2000. Its members include companies that have a substantial portion of their business dedicated to research, development and/or marketing of biopesticides. The mission of the BPIA is to improve the global market perception of biopesticides (microbials and biochemicals) as effective products and to facilitate the successful registration process of biopesticides. BPIA is developing industry standards for biopesticides that encompass quality, efficacy, and regulatory criteria. By developing what is essentially an industry "seal of approval," the BPIA aims to further demonstrate that biopesticides are effective and high quality alternatives to traditional crop protection products that can be used either alone or in integrated pest management programs. In addition, BPIA will serve as a sounding board for the EPA and other agencies, and act as a resource to BPIA members in disseminating information on regulatory policies and procedures. </P> 
<P><STRONG>ARS Researchers To Speak At Extension Agent Crop Training</STRONG>: On October 5th, four NPARL scientists will speak at Montana State University’s Extension Service Eastern Region Crop Training, to be held at the Sidney, Montana ARS lab. NPARL speakers and their topics include: Research Soil Scientist Jed Wadell discussing "Phosphorus Fertility in Dryland Legumes;" Research Weed Ecologist Andy Lenssen discussing "Cropping Strategies for Improved Weed Management: Research Results;" Supervisory Research Entomologist Tom Shanower discussing "Wheat Stem Sawfly Research," and Supervisory Agricultural Engineer Bob Evans discussing "Irrigation Systems and Strip Tillage." Drs. Waddell, Lenssen and Evans are with NPARL’s Agricultural Systems Research Unit, which Dr. Evans heads, while Dr. Shanower heads up the lab’s Pest Management Unit. Other speakers for the event include MSU Soil Fertility Specialist Clain Jones, MSU Plant Pathologist Jack Riesselman, and MSU Weed Scientist Fabian Menalled. </P> 
<P><STRONG>KUSD-89.7 FM, Vermillion, South Dakota, contacted Agricultural Research Service (ARS) For Information On The Research Program At The Northern Grain Insects Research Laboratory</STRONG>: On September 23, Kenton Dashiell, Research Leader, ARS Northern Grain Insects Research Laboratory, Brookings, SD was contacted by Gary Ellenbolt, KUSD-89.7 FM, for information about the research being conducted at the ARS laboratory. KUSD-89.7 FM is part of South Dakota Public Broadcasting. </P> 
<P align=justify><STRONG>ARS Scientist Lectures At Dickinson State University</STRONG>: On October 5th, Dr. Kristine Nichols will present guest lectures entitled "Belowground Carbon Flow - The Glomalin Connection" for both the 'Introduction to Soil Science' and 'Introduction to Range Management' courses at Dickinson State University in Dickinson, ND.</P> 
<P align=right><A href="#top">Back to top</A></P> 
<P align=justify><STRONG>Agricultural Research Service (ARS) and U.S. Department of Energy (DOE) Scientists Plan Cooperative Research On Biomass Energy:</STRONG> On August 17-19, ARS scientists stationed at Lincoln, Nebraska who are conducting research to develop switchgrass into a biomass energy crop met with scientists from the Idaho National Laboratory, DOE, at Lincoln, Nebraska. The successful objective of the meeting was to develop cooperative research plans to improve harvesting, storage, and post-harvest processing of switchgrass for use in biomass energy conversion facilities. At a previous meeting held in Omaha, Nebraska on August 11 with ARS scientists from Lincoln, Nebraska, Ames, Iowa, and St. Paul, Minnesota, DOE scientists from the Idaho National Laboratory, and cooperating university staff from Iowa State University, research was planned on the sustainable use of corn stover for bioenergy. </P> 
<P align=justify><STRONG>ARS Scientist Invited To Speak At Field Day:</STRONG> On August 18, Dr. Scott Bean, of the Grain Quality & Structure Research Unit at the Grain Marketing and Production Research Center in Manhattan, KS, spoke about his research during the Kansas State University Agronomy Field Day, in Hesston, KS. Brian Ioerger and Rhett Kaufman also attended the field day.</P> 
<P><STRONG>ARS Botanist To Discuss Genetics Of Plant Invasions:</STRONG> On August 31, NPARL Botanist John Gaskin has been invited to give a talk to the Conservation Genetics Program at the University of Idaho, Moscow. His presentation is entitled "Genetic studies applied toward the control of plant invasions: from family to population level." Dr. Gaskin is a member of NPARL’s Pest Management Research Unit and works in the biological control of noxious weeds field. </P> 
<P><STRONG>ARS Soil Scientist To Speak At International Sustainable Ag Conference:</STRONG> On August 22-27, NPARL Soil Scientist Upendra Sainju will present a paper at the Third International Conference on Sustainable Agriculture for Food, Energy and Industry to be held in St. Catharine’s, Canada. The conference will focus on the issues: Security, Safety, Frugality, and Conservation. Dr. Sainju’s paper is entitled "Tillage, crop rotations, and cultural practices effects on dryland soil and crop residue carbon and nitrogen," and is coauthored with fellow NPARL Agricultural Systems Research Unit scientists Andy Lenssen, Robert Evans, TheCan Caesar and Jed Waddell. The paper, to be published in the conference proceedings, discusses research by the unit on dryland soil and crop management practices that conserve soil organic matter, improve soil quality and productivity, and sustain crop yields in the northern Great Plains. The purpose of the Sustainable Agriculture Conference is to provide an international forum for scientists and researchers to exchange information and achievements, to ascertain the challenges of the future, and to offer ideas for agricultural practices "…that meets the needs of the present without compromising the ability of future generations to meet their own needs." </P> 
<P><STRONG>ARS Insect Pathologist to Aid Biopesticide Research Effort in Senegal. Africa</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). NPARL Research Entomologist Stefan Jaronski, an expert in insect pathology, has been asked to aid in the planning and implementation of field trials of the mycoinsecticide Green Muscle (Metarhizium anisopliae) against desert locusts and grasshoppers in Senegal, Africa. The Integrated Pest Management Collaborative Research Support Program, acting on a request from the U.S. Agency for International Development and USDA Foreign Agricultural Service, is conducting the tests in part to promote environmentally friendly biopesticide alternatives to large-scale, synthetic chemical control. Dr. Jaronski will travel to Dakar, Senegal, in late July and again in August, where he will aid in training field personnel, oversee the field application of the biopesticide materials and advise on concurrent nontarget ecotoxicology studies of biopesticide impacts. Dr. Jaronski is a member of NPARL’s Pest Management Research Unit. </P> 
<P><STRONG>Montana ARS Lab Featured On Malting Barley Industry Tour:</STRONG> On July 12, Soil Scientist Jed Waddell will escort members of the American Malting Barley Association, Inc. (AMBA) in a tour of ARS malting barley research plots at the Sidney, Montana Agricultural Research Service laboratory. Dr. Waddell is studying the effects of nitrogen fertilizer on the growth, yield, and quality of irrigated, six-row malting barley. He is a member of NPARL’s Agricultural Systems Research Unit. The AMBA’s 2005 Industry Barley Tour will also visit Montana State University’s Eastern Agricultural Research Center in Sidney along with other university research facilities in Williston, Dickinson and Minot, ND. The AMBA is a non-profit trade association formed in 1982 to help ensure an adequate supply of high quality malting barley for the malting and brewing industry. Member businesses include Anheuser-Busch, Inc., Briess Malt & Ingredients Co., Cargill Malt, IMC - United States, The Gambrinus Company, GModelo Agriculture Inc., Miller Brewing Co., Rahr Malting Co., Sierra Nevada Brewing Co., and Summit Brewing Company. AMBA funded research in western states is aimed at development of improved malting two-row and six-row varieties to provide producers an alternative crop to existing feed barley acreage. The eastern Montana and western North Dakota region is attractive for malting barley development because its ample water resources and semi arid climate aid quality and its cooperative research efforts between federal and state agencies can address other stumbling blocks to good returns. </P> 
<P></STRONG><STRONG>ARS Plant Pathologist To Present Paper At International Molecular Congress</STRONG>: </STRONG>USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT. On July 17-22, Robert T. Lartey has been invitedis to give a presentation at the XII International Congress on Molecular Plant-Microbe Interactions in Cancun, Mexico. The biennial congress is sponsored being organized by the International Society for Molecular Plant-Microbe Interactions (IS-MPMI). The five-day conference will feature seven Plenary symposia as well as 18 concurrent sessions and mini-symposia on topics ranging from interactions between plants and fungi to innate immune response in plants. Dr. Lartey’s presentation is entitled "A light and scanning electron microscopic study of progression of Cercospora beticola infection in sugar beet and safflower." He is the first scientist to establish that safflower is an alternate host for Cercospora beticola, the causal agent of Cercospora leaf spot of sugar beet. Dr. Lartey is a member of NPARL’s Agricultural Systems Research Unit. </P> 
<P><STRONG>North Dakota Water Users Association To Tour ARS Research Facility Test Plots:</STRONG> (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). On July 21-22, members of the North Dakota Water Users Association will tour the Northern Plains Agricultural Research Laboratory in Sidney, Montana, as part of a seasonal tour in conjunction with the Missouri Slope Irrigation District of Bismarck, ND. Members will tour NPARL’s new lab office complex as well as visit ARS and North Dakota State University irrigation research plots at the university’s Nesson Valley research site. There, Dr. Robert Evans, an agricultural engineer and Research Leader of NPARL’s Agricultural System’s Research Unit, will discuss his unit’s irrigation research program and specific ARS research being conducted at the Nesson Valley site, including precision irrigation studies. </P> 
<P><STRONG>Australian Official To Tour Montana ARS Lab</STRONG>: (USDA-ARS Northern Plains Agricultural Research Laboratory, Sidney, MT). On July 25-26, NPARL will host Dr. Graham Harris, senior development extension officer (irrigation) for the Department of Primary Industries and Fisheries in Queensland, Australia. Dr. Harris is the recipient of the 2004 Swire Group Churchill Fellowship, which provides him the opportunity to examine current international research and commercial use of precision irrigation practices in cotton and broadacre crops aimed at improving water use efficiency and minimizing environmental impact. During his visit to the Sidney, MT ARS laboratory, he will meet with Dr. Robert Evans, head of the lab’s Agricultural Systems Research Unit, and other NPARL irrigation scientists to discuss research being conducted on the precision application of agrochemicals through irrigation systems. While at NPARL he will also meet with local irrigation project officials. In addition to his visit to Montana, Dr. Harris plans several stops at other research and commercial sites in the U.S. and Israel. </P> 
<P><STRONG>Rangeland Resources Research Unit Scientist to Receive Award:</STRONG> On June 19-23, The American Society for Mining and Reclamation will recognize Dr. Gerald Schuman from the High Plains Grasslands Research Station, Cheyenne, WY at their 22nd Annual Meeting of the Society, in Breckenridge, CO. Dr. Schuman will receive the William T. Plass Award for his outstanding contributions in the area of reclamation research, development of reclamation technologies based on his research, and inclusion of his research findings into State and Federal reclamation regulations. Dr. Schuman is recognized in this field both nationally and internationally and has been invited by government, researcher, and industry representatives from numerous countries to assist with the assessment and development of reclamation technology and science. The William T. Plass Award is the most prestigious award of the American Society of Mining and Reclamation and is not given every year. </P> 
<P><STRONG>Agricultural Research Service (ARS) Scientist Invited to Speak at Entomological Meeting</STRONG>: On March 21, David Taylor, Research Entomologist, ARS Midwest Livestock Insect Research Unit, Lincoln, NE, has been invited to present a talk at the Entomological Society of America North Central Branch Meeting in North Lafayette, IN in the BCE Symposium: Urban Entomology Research and Extension Technology in the North Central Region. The title of his presentation will be: "Stable flies as urban pests: Impact on recreation and health." Agricultural Research Service (ARS) Scientist Invited to Speak at Entomological Meeting: On February 26, Jim Campbell, entomologist, ARS Biological Research Unit, Manhattan, KS, has been invited to present a talk at the Entomological Society of America Pacific Branch Meeting in Pacific Grove, CA. The title of his presentation is "Fumigation of flour mills to manage red flour beetle: assessment of treatment efficacy". On March 4, Dr. Campbell will also give a departmental seminar at the University of California, Davis, entitled "Influence of food processing facility landscapes on the behavior, ecology and management of stored product insect pests." </P> 
<P><STRONG>Agricultural Research Service (ARS) Scientist Invited to Make Presentation at the Colorado State University Extension Service Workshop</STRONG>: On February 16, Frank Arthur, entomologist, ARS Biological Research Unit, Manhattan, KS, will give a presentation entitled "Stored Commodity Treatment", at a training session "Commercial Pesticide Applicators Workshop". Dr. Arthur will discuss the major primary and secondary insect pests of stored grains, registered insecticides and non-chemical treatments that are used for the various phases of stored grain management, and potential registrations for the near future. Data from selected research topics will be used to illustrate concepts and major discussion points. The session will be attended by commercial pesticide applicators, extension personnel, and persons from the grain industries in Colorado. </P> 
<P><STRONG>Agricultural Research Service (ARS) Scientist Invited to Speak at Entomological Meeting</STRONG>: On February 26, Jim Campbell, entomologist, ARS Biological Research Unit, Manhattan, KS, has been invited to present a talk at the Entomological Society of America Pacific Branch Meeting in Pacific Grove, CA. The title of his presentation is "Fumigation of flour mills to manage red flour beetle: assessment of treatment efficacy". On March 4, Dr. Campbell will also give a departmental seminar at the University of California, Davis, entitled "Influence of food processing facility landscapes on the behavior, ecology and management of stored product insect pests." </P> 
<P><STRONG>USDA-ARS Research leader to Speak at Energy Conference:</STRONG> On February 23-24, Dr. Jon Hanson, Research Leader at the Northern Great Plains Research Laboratory at Mandan, ND, has been invited to present and be a panelist at the "Biomass Resources and Processing" session of the "Renewable Energy in the Upper Midwest conference in Grand Forks. The conference will be sponsored by U.S . Senator Byron Dorgan. Dr. Hanson will focus on the ongoing Mandan research toward developing switchgrass as an ethanol production raw material. The Mandan USDA-ARS laboratory has been significantly involved in researching switchgrass cultivars suited for the northern Great Plains area for germination rate, growth characteristics, persistence, disease incidence, carbon sequestration potential, and production yield for future ethanol production in the region. </P> 
<P><STRONG>USDA-ARS Scientist Serves on National Grass Variety Review Board:</STRONG> On February 17-18, Dr. John Berdahl, plant geneticist at the Northern Great Plains Research Laboratory and Mandan, ND, will be serving as ARS representative at the annual meeting of the National Grass Variety Review Board at Corvallis. The National Grass Variety Review Board is one of several boards of the Association of Official Seed Certifying Agencies (AOSCA). The National Grass Variety Review Board determines if the identity of forage and turf grass cultivars submitted to the board is distinct and stable, thus, enabling them to be grown as pedigreed seed or clones in state certification programs in the United States. </P> 
<P><STRONG>Agricultural Research Service (ARS) Scientists Participate in Northwest Alfalfa Seed Growers Conference</STRONG>: On January 30 - February 1, research entomologists James Cane, Rosalind James, Theresa Pitts-Singer, and William Kemp, ARS Pollinating Insect Biology, Management, & Systematics Research Unit, Logan, UT attended the annual meeting of the Northwest Alfalfa Seed Growers, in Boise, ID. The scientists delivered invited oral and poster presentations, participated in technical sessions, and interacted extensively with seed producers from throughout the western United States on topics that included solitary bee disease management, increasing pollination levels through improved bee health, and pollination of novel legume seed crops. </P> 
<P><STRONG>USDA-ARS Staff Present at Annual International Farmers Meeting:</STRONG> On February 1st and 2nd, scientists from Mandan, ND and Morris, MN made several presentations at the 27th Annual Manitoba – North Dakota Zero-Tillage Farmer’s Association Workshop in Brandon, Manitoba. The program title for 2005 was, "Understanding Soils or Better Crops". Dr. Steve Merrill, Soil Scientist at the Northern Great Plains Research Laboratory at Mandan presented, "Crop Sequence: Making Soil Water and Biology Improve System Efficiency". Dr. Don Recosky, Soil Scientist at the North Central Soil Conservation Research Lab of Morris, MN, presented, "Zero Tillage’s Impact on Organic Matter". Economist, Dr. Dave Archer, also of the Morris USDA-ARS lab, presented, "Wild Oat Decision Model," focusing on the herbicide selection software product being developed at their laboratory. Dr. Kris Nichols, Soils Microbiologist at the Mandan lab, was scheduled to make the "keynote" presentation to kick-off the workshop. "Glomalin-- The Scummy Soil Builder", but due to significant illness, was unable to attend. Cal Thorson, Technical Information Specialist at the Mandan lab, presented Dr. Nichol’s materials to over 200 Canadian and American farmers on her behalf. Thorson was elected vice-president of the organization at their annual meeting. Dr. Don Tanaka, Soil Scientist at the Northern Great Plains Research Laboratory, served as the group’s advisor. </P> 
<P align=right><A href="#top">Back to top</A></P>

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