<?xml version="1.0" encoding="UTF-8"?>
<!-- All rights reserved. This program and the accompanying materials are 
	made available under the terms of the Eclipse Public License v1.0 which accompanies 
	this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html 
	Contributors: Mauricio Alferez (mauricio.alferez@cea.fr) CEA LIST -->
<cheatsheet title="Create Model-Based Requirements Specification">
	<intro>
		<description>
			This cheat sheet is a step-by-step description of how to create a models-based requirements specification model.
			The first installation steps are optional if you already have a so-called RCP version of Papyrus for Requirements.
		</description>
	</intro>
	<item title="Install Papyrus">
		<description>
			Papyrus is a modeling environment that will be enhanced with extensions for modeling requirements in the next steps.
			<br />
			<br />
			The easiest way for installing Papyrus is to download it from the Papyrus website. Alternatively, you can install Papyrus in any
			Eclipse-installation via its update site (listed on the Papyrus Download page). This is recommended for advanced users only who need
			to integrate Papyrus with other Eclipse-based components.
		</description>
		<command required="false"
			serialization="org.eclipse.ui.browser.openBrowser(url=https://www.eclipse.org/papyrus/download.html)" />
	</item>
	<item title="Install BMM">
		<description>
			To install the BMM editor go to Help -> Install Papyrus Additional Components. Then, select the BMM in the list of editors.
		</description>
		<command required="false"
			serialization="org.eclipse.papyrus.infra.discovery.ui.menu.commands.discoveryCommand" />
	</item>
	<item title="Install Metrics">
		<description>
			To install the Metrics extension go to Help -> Install Papyrus Additional Components. Then, select Metrics in the list of tools.
		</description>
		<command required="false"
			serialization="org.eclipse.papyrus.infra.discovery.ui.menu.commands.discoveryCommand" />
	</item>
	<item title="Install SysML 1.4">
		<description>
			To install the SysML14 editor go to Help -> Install Papyrus Additional Components. Then, select the SysML 1.4 language in
			the list of editors.
		</description>
		<command required="false"
			serialization="org.eclipse.papyrus.infra.discovery.ui.menu.commands.discoveryCommand" />
	</item>
	<item title="Install Papyrus for Requirements extension">
		<description>
			To install the SysML14 editor go to the Eclipse Git website dedicated to Papyrus for Requirements to either clone the code or install the plugins using an update site.
		</description>
      <command
            required="false"
            serialization="org.eclipse.ui.browser.openBrowser(url=https://git.eclipse.org/c/papyrus/org.eclipse.papyrus-requirements.git/)"/>
	</item>
	<item title="1. Elicit and Analyze Business Needs">
		<description>
			Elicitation is to determine the needs of stakeholders from a business
			perspective.
			<br />
			<br />
			Elicitation and modeling of business needs are two activities that can
			be performed iteratively. Elicitation is a synonym of discovering or
			gathering business needs and is supported by interviews, workshops,
			documentation reviews, surveys, questionnaires, etc.
		</description>
	</item>
	<item title="2. Model Business Needs">
		<description>
			The Business Motivation Model (BMM) specification is an OMG standard
			that defines a set of built-in concepts that define the elements of
			business plans including business needs written in terms of vision,
			goals and objectives.
			<br />
			<br />
			The idea is to develop a business model for the elements of the
			business plans before beginning system design or technical
			development, or even detailed business modeling. The business plans
			then become the foundation for such activities, connecting system
			solutions firmly to their business intent. Some high level constraints
			and non-functional needs for example, legal and licensing issues or
			patent-infringement-avoidability, may be included but specified in
			terms that are understandable and relevant to the business staff. A
			detailed explanation of BMM can be found in its official webpage
			(http://www.omg.org/spec/BMM/).
		</description>
		<subitem label="You can skip the following three sub-steps if you have an existing Papyrus project">
		</subitem>
		<subitem label="File &gt;New &gt; Papyrus Project &gt; BMM &gt; Next"
			skip="true">
			<command required="true"
				serialization="org.eclipse.papyrus.requirements.cheatsheet.handlers.CreateBmmProjectWizardHandler" />
		</subitem>
		<subitem label="Write a name for your project">
		</subitem>
		<subitem
			label="Check &quot;BMM Diagram&quot; in the field &quot;Select a Diagram Kind&quot;">
		</subitem>
		<subitem
			label="Click &quot;Browse Registered Profiles&quot; &gt; SysML14 &gt; Finish">
		</subitem>
		<subitem
			label="Open the BMM diagram and create a vision, goals, objectives, etc using the palette on the right of the diagram.">
		</subitem>
	</item>
	<item title="3. Elicit and Analyze Concrete System Requirements">
		<description>
			The purpose of gathering concrete system requirements is to determine
			what the system should do.
			<br />
			<br />
			Elicitation, analysis and modeling of concrete system requirements are activities that can be performed
			interactively. Also, non-functional requirements and constraints
			should be gathered or refined from the business needs discovered
			previously. Discovering what a system should do to satisfy business
			needs is usually done using prototypes, use scenarios, user histories
			analysis, interviews, etc.
		</description>
	</item>
	<item title="4. Model Concrete System Requirements">
		<description>
			Concrete system requirements specify functions or actions that a
			system must implement or a performance condition a system must
			achieve.
			<br />
			<br />
			SysML is a standard that provides modeling constructs to represent
			text-based requirements and relate them to other modeling elements in
			detail system design. The requirements can be depicted in a graphical,
			tabular, or tree structure format. A requirement can also appear on
			other diagrams to show its relationship to other modeling elements. A
			detailed explanation of SysML can be found in its official webpage
			(http://www.omg.org/spec/SysML/).
		</description>
		<subitem
			label="If you applied the SysML14 profile to your model in the step 2. Model Business Needs. You can skip the next three sub-steps."
			skip="false">
		</subitem>
		<subitem
			label="Click on the root element which is a model package in the Model Explorer"
			skip="true">
		</subitem>
		<subitem
			label="Select Apply Registered Profile &gt; OK  in the in the Property view"
			skip="true">
		</subitem>
		<subitem label="Select  SysML14 &gt; Select all &gt; Finish"
			skip="true">
		</subitem>
		<subitem
			label="Configure SysML requirements preference settings: Right click on the model package &gt; Papyrus for Requirements - Preference Settings">
			<command required="false"
				serialization="org.eclipse.papyrus.requirements.sysml14.preferences.handlers.ShowPreferencePageHandler" />
		</subitem>
		<subitem
			label="Create a SysML Requirements diagram and tables by right clicking your model in the model explorer">
		</subitem>
		<subitem
			label="New Diagram &gt; SysML14 Requirement Diagram or New Table &gt; SysML14 Requirement Tree Table">
		</subitem>
	</item>
	<item title="5. Relate Business Needs to Concrete Systems Requirements">
		<description>
			The business needs must be connected to concrete system requirements
			so we can guarantee traceability between technical and business
			views.
			<br />
			To create a traceability matrix between elements belonging to models
			written using the BMM and SysML languages you have to follow the next
			sub-steps:
			<br />
			(Remember that requirement engineering is an iterative process and if
			I you need more information, you can go the previous steps to elicit,
			model and relate business needs and concrete systems requirements)
		</description>
		<subitem
			label="Right click on a package that contains the requirements that you want to trace"
			skip="false">
		</subitem>
		<subitem
			label="Select New table &gt; SysML14 Requirements - Papyrus for Requirements TraceTo Matrix"
			skip="false">
		</subitem>
		<subitem
			label="Right click on a package that contains the requirements that you want to trace"
			skip="false">
		</subitem>
		<subitem label="Enter the name for the new table and finish."
			skip="false">
		</subitem>
	</item>
   <item
         title="6. Verify and Validate Requirements">
     <description>
        It is necessary to validate that the requirements really define the system that the customer wants and that the models pass some verification rules. 
		We provide automated support for checking requirements against a predefined set of rules.
	 </description>
	 	<subitem
			label="Right click on a package or model that contains the requirements that you want to validate"
			skip="false">
		</subitem>
		<subitem
			label="Select SysML14 Requirements - Validation &gt; Select constraints and validate model"
			skip="false">
         <command
               required="false"
               serialization="org.eclipse.papyrus.validation.SelectAndValidateModelCommand"/>
		</subitem>
		<subitem
			label="Check all the constraints to evaluate in the category Papyrus for Requirements &gt; Apply &gt; OK"
			skip="false">
		</subitem>
		<subitem label="See the warnings about potential problems in the diagram, model, property and table views."
			skip="false">
		</subitem>
	</item>
   <item title= "7. Trace Requirements to Design and Tests Models">
      <description>
	  Management of requirements is heavily supported by requirements traceability. 
	  This is crucial for the maintenance and evolution of the requirements models. 
	  		<br />
			<br />
	  We already use a trace matrix to link business needs to concrete system requirements.
	  Now, we will add more relationships as defined by the SysML standard using matrices. 
	  For example, we have the matrices: 
	  <br />
	  DerivedFrom (connects technology independent requirements to more technology-specific requirements), 
	  <br />
	  RefinedBy (connects requirements to use cases or activity diagrams that give more information about them),
	  <br />
	  SatisfiedBy (connects requirements to the design artefacts that implement them), 
	  <br />
	  TracedTo (connects requirements to documentation and to business needs) and	   
	  <br />
	  VarifiedBy (connects requirements to test cases which can be modeled using activity diagrams or state machines).
  	  <br />
	  Follow the next steps to create traceability matrices:
	  </description>
	  	<subitem
			label="Right click on a package that contains the requirements that you want to trace"
			skip="false">
		</subitem>
		<subitem
			label="Select New table &gt; SysML14 Requirements - Papyrus for Requirements * Matrix"
			skip="false">
		</subitem>
		<subitem label="Enter the name for the new table and finish."
			skip="false">
		</subitem>
		<subitem label="Check the intersection between the requirement (column) and other elements (rows)."
			skip="false">
		</subitem>
   </item>
   <item title= "8. Calculate Metrics">
      <description>
	  Management, specification and validation activities are supported by quantitative information usually referred to as metrics.
	  This information can be used to measure the advancement of the requirements engineering activity.
	  Follow the next steps to calculate the values of predefined metrics, such as number of requirements, number of (un)satisfied requirements, number of (un)verified requirements, etc.:
	  </description>
	  	<subitem
			label="Right click on a package that contains the requirements that you want to analyse"
			skip="false">
		</subitem>
		<subitem
			label="Select Papyrus Metrics &gt; Get Measure Values"
			skip="false">
		</subitem>
		<subitem label="See the results in the Metrics view"
			skip="false">
		</subitem>
   </item>
</cheatsheet>
