<!doctype html>
<html>
<link rel="icon" type="image/png" href="favicon.ico" />

<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>CHESS</title>
<link rel="stylesheet" href="styles.css" type="text/css" />
</head>

<body>
	<header>
		<div class="logo-left width">
			<a href="index.html"><img src="images/logo_chess_350.gif"
				alt="CHESS logo" width=""></a>
		</div>
	</header>
	<nav>

		<div class="width">
			<ul>
				<li class="start"><a href="index.html">Home</a></li>
				<li class="divider-vertical-second-menu"></li>
				<li><a href="features.html">Features</a></li>
				<li class="divider-vertical-second-menu"></li>
				<li class="selected"><a href="start.html">Getting Started</a></li>
				<li class="divider-vertical-second-menu"></li>
				<li><a href="events.html">Events</a></li>
				<li class="divider-vertical-second-menu"></li>
				<li class="end"><a href="community.html">Community</a></li>
				<li style="text-align: right;"><a href="download.html"
					class="box">Download</a></li>
				<li style="float: none;"><br style="clear: both;" /></li>
			</ul>
		</div>

	</nav>

	<div id="hrdiv">
		<img src="images/bg_breadcrumb.jpg" width="" alt="" height="" />
	</div>

	<div id="body" class="width-started">
		<article class="expanded">
			<ul class="tabs">
				<li><input name="tabs" id="tab1" checked="" type="radio">
					<label for="tab1">Installation</label>
					<div id="tab-content1" class="tab-content">
						This page provides all the information needed to setup the
						CHESS tool. Please refer also to the provided <a
							href="publis/CHESS_ToolsetGuide.pdf"><b>user guide</b></a> to
						check the extensions currently available for CHESS.

						<h3>Needed environment</h3>
						<p>
							A Java 8 JRE/JDK is recommended for CHESS v1.0.0.<br />
						</p>

						<p>
							You can download the CHESS Eclipse full distribution from the <a
								href="download.html">Download page</a>; in this case you have
							only to uncompress the provided archive to start using the CHESS
							tool.<br>
						</p>

						<p>If you want to install CHESS with the provided update site
							please follow the steps detailed below:</p>

						<p>
							CHESS Eclipse plugins v1.0.0 has to be installed on top of
							Eclipse Neon 3 platform available from: <a
								href="https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-modeling-tools">https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-modeling-tools</a>.
						</p>

						<p>First EMF Parsley SDK and Ecore Diagram Editor have to be
							uninstalled.</p>
						<p>
						<ul class="listInTabs">
							<li>From the main Eclipse window select the
								Help->Installation Details</li>
							<li>From the &quot;Installed Software&quot; Select the two
								&quot;EMF Parsley SDK&quot; plug-ins.</li>
							<li>Click Uninstall...</li>
							<li>From the &quot;Installed Software&quot; Select
								&quot;Ecore Diagram Editor&quot;.</li>
							<li>Click Uninstall...</li>
							<li>Restart Eclipse, when prompted, in order to apply the
								changes.
						</ul>
						<br> <img src="images/Parsley.jpg" width="85%">
						<div class="caption">Figure 1: Uninstalling Parsley and
							Ecore Diagram Editor plug-ins</div>
						<br>

						<p>
							Then, Install the plug-ins downloading <a
								href="publis/CHESS.p2f" download>CHESS.p2f</a>. To import the file,
							follow these steps inside Eclipse:
						<ul class="listInTabs">
							<li>go to File/Import...</li>
							<li>select Install/Install Software Items from File and
								click Next</li>
							<li>select the given file CHESS.p2f from the filesystem</li>
							<li>uncheck &quot;Install latest version of selected
								software&quot; and proceed with Next/Next/Finish</li>
						</ul>


						<h3>Installing the SDE and EST plug-ins</h3>

						<p>SDE and EST plug-ins can be installed by using the standard
							Eclipse update-site feature.
						<ul class="listInTabs">
							<li>From the main Eclipse window select the Help->Install
								new software… -> menu item</li>
							<li>From the &quot;Install&quot; window Add &quot;SDE&quot;
								(https://es-static.fbk.eu/tools/devel_sde/) in the &quot;Work
								with&quot; field, then wait for the list of available sites to
								appear in the area below, and select them all.</li>
							<li>Click Next and then Finish to terminate the install
								procedure.</li>
							<li>From the &quot;Install&quot; window Add &quot;EST&quot;
								(https://es-static.fbk.eu/tools/devel_est/) in the &quot;Work
								with&quot; field.</li>
							<li>Deselect the checkbox &quot;Group items by
								category&quot;, wait for the list of available sites to appear
								in the area below, and select only the first and last items.</li>
							<li>Click Next and then Finish to terminate the install
								procedure.</li>
							<li>Restart Eclipse, when prompted, in order to apply the
								changes.
						</ul>
						<h3>Installing the CHESS plug-ins</h3>
						<p>CHESS plug-ins can be installed by using the standard
							Eclipse update-site feature.</p>
						<p>
							The CHESS update-site is available through http: <br>the URL
							is
							<tt>https://download.eclipse.org/chess/core/releases/1.0.0/updateSite/</tt>
						<ul class="listInTabs">
							<li>Launch Eclipse Neon</li>
							<li>From the main menu select Help->Install new software… -></li>
							<li>Click &quot;Add…&quot;, then select the CHESS update
								site or digit
								&quot;https://www.eclipse.org/chess/updatesite/1.0.0//&quot;
								(the first time you are using it) in the Location field, and
								click Ok.</li>
							<li>In the Install window uncheck the &quot;Group Items by
								Category&quot; option (see Figure 3).</li>
							<li>In the Install window check the CHESS features
								(see Figure 3), and click Next and Finish to terminate the
								installation.</li>
							<li>Restart Eclipse.</li>
						</ul>
						<br> <img src="images/installingChess.jpg" width="85%">
						<div class="caption">Figure 2: Installing the CHESS plug-ins</div>
					</div></li>
				<li><input name="tabs" id="tab2" type="radio"> <label
					for="tab2">Documentation</label>
					<div id="tab-content2" class="tab-content">
					  <p>
                                            Find below a list of documents that guide that introduce you to CHESS
                                            <h4>Modeling and overview of tool features</h4>
					    Check out the CHESS user guide available <a href="publis/CHESS_ToolsetGuide.pdf"><b>here</b>.</a>
					    The user guide will introduce you to the entire CHESS design
					    flow, starting from the creation of a CHESS project to the
					    different CHESS modelling steps and tool features, with
					    step-by-step examples
                                          </p>
					  <p>
		                            <h4>CHESS Modelling Language profile</h4>
					    Check out the CHESS Modelling Language profile 
					    definition available <a href="publis/CHESSMLprofile.pdf"><b>here</b>.</a>
					  </p>
					  <p>
		                            <h4>CHESS Support to System-Level Analysis</h4>
                                            CHESS provides a variety of model-based analysis, using
					    different backend tools (OCRA, nuXmv, xSAP). The following document guides the user
					    along a system-level design flow from requirements specification and validation, to
                                            contract-based architectural design, to components implementation and verification, to
                                            fault injection and model-based safety analysis. Check out the guide available
                                            <a href="publis/CHESS_ContractBasedAnalysisModelCheckingSafetyAnalysis.pdf"><b>here</b></a>.
                                          </p>
                                          <p>
                                            <h4>CHESS Support to Dependability Analysis</h4>
                                            Check out the guide available 
					    <a href="publis/CHESS_DependabilityGuide.pdf"><b>here</b></a>
                                            to support state-based quantitative analysis and Failure Logic Analysis (FLA)
					    based upon FPTC - Fault Propagation and Transformation Calculus
                                          </p>
                                          <p>
                                            <h4>CHESS Support to Stochastic Analysis</h4>
                                            CHESS supports modelling of safety and security concerns and automated transformations
                                            to SAN models for reliability analysis with the MOBIUS tool. 
                                            Check out the guide available 
                                            <a href="publis/CHESS_MobiusIntegrationGuide.pdf"><b>here</b></a>
				          </p>
                                          <p>
                                            <h4>CHESS Support to Software Development and Analysis</h4>
                                            Check out the guide available 
                                            <a href="publis/CHESS_SWDevelopmentGuide.pdf"><b>here</b></a>
					    for Schedulability Analysis and End2End Response Time Analysis
					    with MAST
                                          </p>
                                          <p>
                                            <h4>CHESS Support to Architectural Patterns</h4>
                                            The CHESS tool includes a library of design patterns to be instantiated in a model.
                                            Check out the guide available 
                                            <a href="publis/CHESS_ArchitecturalPatternsGuides.pdf"><b>here</b></a>
                                          </p>
                                          <p>
                                            <h4>CHESS Support to Runtime Monitoring</h4>
                                            The CHESS tool includes includes trace analysis and back propagation support.
                                            Check out the guide available 
                                            <a href="publis/CHESS_RuntimeMonitoringGuide.pdf"><b>here</b></a>
                                          </p>
				</div></li>
				<li><input name="tabs" id="tab3" type="radio"> <label
					for="tab3">Model Examples</label>
					<div id="tab-content3" class="tab-content">
						<p>
							CHESS model examples are available in the <a href="download.html"><b>download</b></a>
							page; you can import them in your workspace as existing projects
							and then navigate the models, through the available diagrams. The
							provided examples can also be used to test the CHESS model driven
							features, like the analysis and code generation.
						</p>

					</div></li>
			</ul>
		</article>
	</div>

	<footer id="footer-start">
		<div class="footer-content width">
			<ul>
				<li><h4>Eclipse Foundation</h4></li>
				<li><a href="https://www.eclipse.org/org/">About</a></li>
				<li><a href="https://www.eclipse.org/org/foundation/contact.php">Contact Us</a></li>
				<li><a href="https://projects.eclipse.org/projects/polarsys.chess">CHESS
						Project Page</a></li>
			</ul>
			<ul>
				<li><h4>Legal</h4></li>
				<li><a href="http://www.eclipse.org/legal/privacy.php">Privacy
						Policy</a></li>
				<li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms
						of Use</a></li>
				<li><a href="http://www.eclipse.org/legal/copyright.php">Copyright
						Agent</a></li>
				<li><a href="http://www.eclipse.org/org/documents/epl-v10.php">Eclipse
						Public License</a></li>
				<li><a href="http://www.eclipse.org/legal/">Legal Resources</a></li>
			</ul>
			<ul>
				<li><h4>Useful Links</h4></li>
				<li><a
					href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=Chess">Report
						a Bug</a></li>
				<li><a href="https://wiki.eclipse.org/CHESS">Documentation</a></li>
				<li><a
					href="https://wiki.eclipse.org/CHESS/Technical_Information">How
						to Contribute</a></li>
				<li><a href="https://accounts.eclipse.org/mailing-list/chess-dev">Mailing
						List</a></li>
				<li><a href="https://www.eclipse.org/forums/index.php/f/529/">Forum</a></li>
			</ul>
			<ul class="endfooter">
				<li><h4>Other</h4></li>				
				<li><a href="https://es.fbk.eu/">Fondazione Bruno Kessler</a></li>
				<li><a href="http://www.intecs.it/">Intecs</a></li>
				<li><a href="http://www.unipd.it">University of Padova</a></li>
				<li><a href="http://www.mdh.se/">Mälardalen University</a></li>
			</ul>
			<table>
				<tr>
					<td><a href="https://www.yourkit.com"><img
							src="images/yklogo.png" alt="YourKit logo"
							style="width: 25%; height: 25%"></a> <br /> <font size="2">Thanks
							YourKit for providing us free licenses of <a
							href="https://www.yourkit.com/java/profiler/">YourKit Java
								Profiler</a>
					</font></td>
					<td>
						<div class="right-footer">
							<a href="http://www.eclipse.org/"><img
								src="images/eclipse.png" alt="Eclipse logo"></a> <br />
							Copyright ©<span id="year">2016</span> The Eclipse Foundation. <br />
							All Rights Reserved.
						</div>
					</td>
				</tr>				
			</table>

			<div class="clear"></div>
		</div>

	</footer>
</body>
</html>
