<div id="bigbuttons">
<h3>Primary Links</h3>
<ul>
				<li><a id="buttonDownload" href="installing" title="Download">Update Site, Eclipse Distribution</a></li>
				<li><a id="buttonDocumentation" href="documentation" title="Documentation">Tutorials, Examples,
				Screencasts, Reference Documentation</a></li>
				<li><a id="buttonSupport" href="support" title="Support">Bug Tracker, Newsgroups</a></li>
				<li><a id="buttonInvolved" href="developers" title="Getting Involved">CVS, Workspace Setup, Wiki,
				Committers</a></li>
</ul>
</div>

<div id="midcolumn">

<h3>Agent Modeling Platform</h3>
<p>The AMP project provides extensible frameworks and exemplary tools for representing, editing, generating,
executing and visualizing agent-based models (ABMs) and any other domain requiring spatial, behavioral and functional
features. AMP has two main themes that complement but don't depend on one another:</p>

<div id="border">
<p class="top">Modeling</p>
<h4>Agent Modeling Framework (AMF)</h4>
<div id="introText">
<p class="left">AMF provides an ABM meta-model representation, editor, generator and development environment. The
AMF Acore meta-model is similar to EMF Ecore and defined in Ecore, but provides high-level support for complex agents.</p>
<p class="right">AMF generates complete executable models for Escape, Ascape and Repast Simphony, as well as Java
Skeletons and Interfaces, JUnit test cases and documentation and is easily extensible to support additional targets.</p>
</div>
<a href="images/AMFNewScreenshot.png"><img src="images/AMFNewScreenshotSmall.png" alt="AMF window" width="100%" /></a></div>

<div id="padding"></div>
<div id="border">
<p class="top">Platform</p>
<div id="feature_axf">
<h4>Agent Execution Framework (AXF)</h4>
<p class="left">The execution framework provides services and UI for model management, execution, and views.
Arbitrary toolkits can easily integrate with Eclipse and AXF by implementing pluggable providers like engines, agents
and view parts. AXF is not just for ABM -- anyone who needs support for executing, managing and visualizing collections
of objects may find it useful.</p>
</div>
<div id="feature_agf">
<h4>Agent Graphics Framework (AGF)</h4>
<p class="right">The graphics framework extends GEF, GEF3D, Zest, and the BIRT charting engine to support real-time
visualization of and interaction with agent models. AGF currently provides support for 2D, 2 1/2 D. and graph
structures, and will be extended to 3-D, GIS and others. As with other AMP components, the AGF design focus is to
provide an extensible infrastructure so that platform adopters can easily create their own view and editor parts.</p>
</div>
<div id="feature_escape">
<h4>Escape</h4>
<p>Escape is an exemplar ABM toolset. It's based on Ascape, which has been in use for more than 10 years. The core
API is very stable, and that should give users a way to explore the features of AMP without concerns about keeping in
synch with the rapidly evolving AXF /AGF API. It allows modelers to code in Java and/or generate models with AMF and
then execute those models within the same development environment.
</div>
<a href="images/AMPNewScreenshot.png"><img src="images/AMPNewScreenshotSmall.png" alt="AMF window" width="100%" /></a></div>
</div>

<div id="rightcolumn">
<div class="sideitem">
<div align="center"><a href="http://www.eclipse.org/projects/what-is-incubation.php"><img align="right"
				src="http://www.eclipse.org/images/egg-incubation.png" border="0" /></a></div>
<p>AMP is in the<BR />
<a href="http://www.eclipse.org/projects/dev_process/validation-phase.php">Incubation Phase</a>.</p>
</div>
<div class="sideitem">
<h6>Current Status</h6>
<p>We've had our first official Release! Check out all of the <a
				href="documentation/contents/New_and_Noteworthy.html">improvements and new features</a> in 0.8.0. The new Modeling
Discovery site makes <a href="installing/index.php">installation</a> a breeze. And we have new committers joining the
project soon. Please see our updated <a href="http://www.eclipse.org/projects/project-plan.php?projectid=modeling.amp">Project
Plan</a> for more details.</p>
</div>

<div class="sideitem" style="background-color: rgb(225, 230, 78);">
<h6 style="background-color: rgb(250, 253, 87);">Screencasts</h6>
Find out more about ABM and AMP in these presentations.. (Externally hosted.)<BR />

<table>
				<tr>
								<td><a href="http://www.youtube.com/watch?v=pSYzf_p6StY"><img src="images/screenicons/gettingstarted.jpg">Get Started</a>
								</td>
								<td><a href="http://www.youtube.com/watch?v=1bVVptIEjoA"><img src="images/screenicons/overview.jpg">Overview</a>
								</td>
				</tr>
				<tr>
								<td><a href="http://www.youtube.com/watch?v=g4v511f5FBc"><img
												src="images/screenicons/architectureI.jpg"><BR />
								Architecture</a></td>
								<td><a href="http://www.youtube.com/watch?v=abPguU0QVqw"><img
												src="images/screenicons/architectureII.jpg"><BR />
								Part II</a></td>
				</tr>
				<tr>
								<td><a href="http://www.youtube.com/watch?v=J1gvszjjuGI"><img src="images/screenicons/abmwhyI.jpg"><BR />
								Why ABM?</a></td>
								<td><a href="http://www.youtube.com/watch?v=oOvCIxbxGAA"><img src="images/screenicons/abmwhyII.jpg"><BR />
								Part II</a></td>
				</tr>
				<tr>
								<td><a href="http://www.youtube.com/watch?v=lYp7Pq44CNM"><img src="images/screenicons/abmhowdesign.jpg"><BR />
								ABM How?</a></td>
								<td><a href="http://www.youtube.com/watch?v=B9HzdKMItEA"><img src="images/screenicons/abmhowruns.jpg"><BR />
								Part II</a></td>
				</tr>
</table>
</div>
<div class="sideitem">
<table border=0 bgcolor="rgb(230,228,242)">
				<tr>
								<td>
								<h6>"What's an Agent-Based Model?"</h6>
								The primary focus of AMP is "Agent-Based Modeling". ABMs share characteristics with object models, but are:
								<ul>
												<li>Spatial: Models have explicit environment(s) in which agents interact. (An environment need not be
												a physical landscape; other examples of spatial relationships include social networks or positions within a
												logic system.)</li>
												<li>Temporal: Models change over discrete units of time.</li>
												<li>Autonomous: Agent behaviors are activated independently from other object requests.</li>
												<li>Heterogenous: Agents may share behavior definitions but have apparent and distinct states and
												behaviors.</li>
												<li>Collective: Models contain large communities of agents which exhibit collaborative and competitive
												behaviors.</li>
												<li>Emergent: Agents have collective macro-behaviors that are non-obvious from agent
												micro-specifications.</li>
								</ul>
								</td>
				</tr>
</table>
</div>

<div class="sideitem">
<h6>Other Resources</h6>
<div>Please note that these are not Eclipse hosted and Eclipse is not responsible for their content. <BR />
<b>Websites</b>
<ul>
				<li><a href="http://metaabm.org">MetaABM</a></li>
				<li><a href="http://ascape.sourceforge.net">Ascape</a></li>
</ul>
<BR />
<b>Papers</b>
<ul>
				<li><a href="http://www.pnas.org/content/99/suppl.3/7280.full">Agent-Based Modeling</a></li>
				<li><a href="http://jasss.soc.surrey.ac.uk/11/4/12.html">"Why Model?"</a></li>
				<li><a href="http://www.agent2006.anl.gov/2006procpdf/Parker_Agent_2006.pdf">Agent-Based Meta-Models</a>(An
				earlier implementation.)</li>
				<li><a href="http://metascapeabm.com/images/news/tr1-metaabminpictures.pdf">MetaABM in Pictures</a></li>
				<li><a href="http://www.pnas.org/content/99/suppl.3/7304.full">Ascape</a></li>
</ul>
</div>
<div class="sideitem">
<h6>Acknowledgments</h6>
<p>The AMP project is a realization of the efforts and ideas of many organizations and people in the Agent-Based
Modeling community. In particular:</p>
<ul>
				<li>The AMP logo was inspired by the <a href="http://swarm.org/index.php/Main_Page">Swarm</a> logo.</li>
				<li><a href="http://metascapeabm.com">Metascape, LLC</a> contributed the initial code-base and supports
				on-going development.</li>
				<li><a href="http://www.anl.gov/">ANL</a> contributed the original code-base for the AMF meta-modeling
				components.</li>
</ul>
</div>
</div>
</div>

<script type="text/javascript" charset="utf-8">
$(document).ready(function(){
	$("a.gallery[rel^='prettyPhoto']").prettyPhoto({animationSpeed:'slow',theme:'light_square',slideshow:2000,default_width: 640, default_height: 480, opacity: 0.40, slideshow: false});
//	$("a.featureScreencast").add('div').addClass("overlay");
});
</script>