<!DOCTYPE html>
<html class="no-js">
<head>
	<!-- Basic Page Needs
        ================================================== -->
	<meta charset="utf-8">
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<link rel="icon" type="image/png" href="images/favicon.ico">
	<title>Capella Days Online 2020</title>
	<meta name="description"
		content="Capella Day is a one-day event dedicated to Capella open source model-based systems engineering tool.">
	<meta name="keywords" content="">
	<meta name="author" content="">
	<!-- Mobile Specific Metas
        ================================================== -->
	<meta name="format-detection" content="telephone=no">
	<meta name="viewport" content="width=device-width, initial-scale=1">
	<!-- Template CSS Files
        ================================================== -->
	<!-- Twitter Bootstrs CSS -->
	<link rel="stylesheet" href="css/bootstrap.min.css">
	<!-- animate css -->
	<link rel="stylesheet" href="css/animate.css">
	<link rel="stylesheet" href="css/jquery.fancybox.css">
	<!-- template main css file -->
	<link rel="stylesheet" href="css/main.css">
	<!-- responsive css -->
	<link rel="stylesheet" href="css/responsive.css">
	<link rel="stylesheet" href="css/latofonts.css">
	<script src="https://use.fontawesome.com/b51f77a16a.js"></script>
	<!-- Cookie content -->
	<link rel="stylesheet" type="text/css"
		href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
	<script
		src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script>
	<!-- Eclipse Foundation Google Tag Manager -->
	<script>
		(function (w, d, s, l, i) {
			w[l] = w[l] || [];
			w[l].push({
				'gtm.start': new Date().getTime(),
				event: 'gtm.js'
			});
			var f = d.getElementsByTagName(s)[0], j = d.createElement(s), dl = l != 'dataLayer' ? '&l='
				+ l
				: '';
			j.async = true;
			j.src = 'https://www.googletagmanager.com/gtm.js?id=' + i + dl;
			f.parentNode.insertBefore(j, f);
		})(window, document, 'script', 'dataLayer', 'GTM-5WLCZXC');
	</script>
	<!-- End Google Tag Manager -->
	<!-- Template Javascript Files
        ================================================== -->
	<!-- Angular -->
	<base href="/capella/">
	<script src="js/angular-1.7.8.min.js"></script>
	<script src="angular/capella.js"></script>
	<!-- modernizr js -->
	<script src="js/vendor/modernizr-2.6.2.min.js"></script>
	<!-- jquery -->
	<script src="js/jquery-3.4.1.min.js"></script>
	<!-- bootstrap js -->
	<script src="js/bootstrap.min.js"></script>
	<!-- wow js -->
	<script src="js/wow.min.js"></script>
	<script src="js/jquery.fancybox.js"></script>
	<!-- template main js -->
	<script src="js/main.js"></script>
</head>
<body ng-app="capella" data-deferred-cloak>
	<!--
        ==================================================
        Header Section
        ================================================== -->
	<ng-include src="'angular/blocks/header.html'"></ng-include>
	<!--
        ==================================================
        Intro Section
        ================================================== -->
	<section class="hero-area contact">
		<div class="container">
			<div class="row">
				<div class="col-md-12 text-center">
					<div class="block wow fadeInUp" data-wow-delay=".3s">
						<section class="cd-intro">
							<h1 class="wow fadeInUp animated" data-wow-delay=".4s">
								Capella Days Online 2020<br>
							</h1>
						</section> <!-- cd-intro -->
						<h2 class="wow fadeInUp animated" data-wow-delay=".6s">
							October 12-15, 2020
						</h2>
						<p></p>
						<a href="https://www.crowdcast.io/e/capella-days-2020/register" target="_blank"
							class="btn btn-default btn-contact wow fadeInDown" data-wow-delay=".7s"
							data-wow-duration="500ms">Register</a>
					</div>
				</div>
			</div>
		</div>
	</section>
	<!--/#intro_banner-->
	<section id="overview">
		<div class="container">
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<p>This year, Capella Day becomes <b>Capella Days Online</b>!</p>
				<p>During 4 days, we will propose 12 sessions dedicated to Capella:  3 per day, from 4:00 pm CEST to 6:10 pm CEST.</p>
				<img src="images/capella_days_2020/logo_capella_days_2020.png" width="800">
				<p>After a great 2019 edition in Munich, mainly featuring Capella complimentary tools and add-ons, this year we have decided to focus on industrial MBSE case-studies.</p>
				<p>Check-out the program featuring very interesting talks from Capella's feedback on experience from different engineering domains:</p>
				<ul>
					<li><b>CNES</b> (space systems)</li>
					<li><b>GMV</b> (space systems)</li>
					<li><b>NextRail</b> (rail systems)</li>
					<li><b>Siemens</b> (medical devices)</li>
					<li><b>Stille AB</b> (surgical solutions)</li>
					<li><b>Thales Group</b> (aerospace, defence, transportation and security)</li>
					<li><b>The SeaCleaners</b> (waste collecting, clean shipping)</li>
					<li><b>Virgin Hyperloop</b> (high-speed transportation technology)</li>
					<li><b>Vitesco Technologies</b> (powertrain technologies)</li>
				</ul>
				<p>&nbsp;</p>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h2>About</h2>
				<h3>What is Capella Days?</h3>
				<p>This event organized by Obeo, in partnership with Thales, Altran and TNO-ESI, brings together the community of Capella and Arcadia:</p>
				<ul>
					<li>creators of this innovative systems engineering solution,</li>
					<li>providers of Capella add-ons and services,</li>
					<li>MBSE experts and industrial users.</li>
				</ul>
				<p>This year Capella Days will happen in conjunction with <a href="https://esi.nl/news/webinars/esi-webinar-day-2020" target="_blank">ESI webinar day</a>, the 6th of October 2020.</p>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h3>What is Capella?</h3>
				<p>Capella is an open-source and field-proven Model-Based Systems Engineering (MBSE) solution to
					successfully design systems architecture.</p>
				<p>It provides systems, software and hardware architects with rich methodological guidance relying on
					Arcadia, a comprehensive model-based engineering method based on both industrial experimentations
					and system engineers' feedback</p>
				<p>Natively supporting Arcadia , Capella can be customized to fit the specific needs of many industrial
					domains.</p>
				<p><a href="https://www.eclipse.org/capella/">Learn more <i class="fa fa-arrow-circle-right" aria-hidden="true"></i></a></p>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h3>Why you should attend?</h3>
				<p>Capella Days is your opportunity to learn from Capella ecosystem members.</p>
				<p>Discover the roadmap, get insights about methodology, MBSE trends and latest Capella features.</p>
				<p>Benefit from the experience of industrial adopters who have sucessfully deployed an MBSE approach with Arcadia and Capella on their projects.</p>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h3>Previous editions</h3>
				<ul>
					<li><a href="https://www.eclipse.org/capella/capella_day_munich_2019.html" target="_blank">Capella Day
							Munich 2019</a></li>
					<li><a href="https://wiki.eclipse.org/Capella_Day_Stuttgart_2018" target="_blank">Capella Day
							Stuttgart 2018</a></li>
					<li><a href="https://www.eclipsecon.org/france2017/capella-day" target="_blank">Capella Day Toulouse
							2017</a></li>
				</ul>
			</div>
			</div>
		</div>
	</section>
	<section id="organized_by">
		<div class="container">
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h2 class="title">Organized by</h2>
				<p>Capella Days is organized by Obeo, in partnership with Thales, Altran and TNO-ESI</p>
				<p></p>
				<a href="https://www.obeo.fr/en/capella-professional-offer" target="_blank"><img src="images/logo_obeo.png" width="280"></a>
				<a href="industry-consortium/thales.html" target="_blank"><img src="images/logo_thales.png" width="280"></a>
				<a href="https://www.altran.com/nl/en/engineering/" target="_blank"><img src="images/capella_days_2020/logo_altran.png" width="280"></a>
				<a href="https://www.esi.nl/about-esi/" target="_blank"><img src="images/capella_days_2020/logo_esi.png" width="200"></a>
			</div>
		</div>
	</section>


	<section id="sponsored_by">
		<div class="container">
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h2 class="title">Sponsored by</h2>
				<p>Capella Days is sponsored by vibrant members of the Capella ecosystem</p>
				<p></p>
<!--				<a href="http://www.ita.br/" target="_blank"><img src="images/logos/adopters/logo_ita.png" width="250"></a> -->
				<a href="https://maplesoft.com/" target="_blank"><img src="images/logos/adopters/logo_maplesoft.png" width="280"></a>
				<a href="https://www.pure-systems.com/" target="_blank"><img src="images/capella_days_2020/logo_pure-systems.png" width="280"></a>
				<a href="https://www.samares-engineering.com/fr/" target="_blank"><img src="images/logos/adopters/logo_samares.png" width="280"></a><br>
				<a href="https://www.sodiuswillert.com/" target="_blank"><img src="images/capella_days_2020/logo_sodius.png" width="280"></a>
				<a href="https://www.reusecompany.com/" target="_blank"><img src="images/logos/adopters/logo_thereusecompany.png" width="280"></a><br>
				<p>Interested in sponsoring Capella days ? <a href="mailto:marketing@obeo.fr">Contact us</a></p>
			</div>
		</div>
	</section>

	<section id="register">
		<div class="container">
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h2 class="title">Registration</h2>
				<p>Capella Days is a free event.</p>
				<p>Just register on the video conferencing platform to access to online sessions.</p>
						<a href="https://www.crowdcast.io/e/capella-days-2020/register" target="_blank"
							class="btn btn-default btn-contact wow fadeInDown" data-wow-delay=".7s"
							data-wow-duration="500ms">Register</a>
			</div>
		</div>
	</section>

	<section id="program">
		<div class="container">
			<div class="row">
				<h2 class="title wow fadeInDown" data-wow-delay=".3s">Agenda</h2>
				<h3 class="table table-striped wow fadeInDown" data-wow-delay=".3s">Day 1: Monday 12th of October</h2>
				<table class="table table-striped wow fadeInDown" data-wow-delay=".3s">
					<thead>
						<tr>
							<th width="10%">Time</th>
							<th width="50%">Session</th>
							<th width="50%">Speakers</th>
						</tr>
					</thead>
					<tbody>
						<tr>
							<td class="txt_indigo">4:00 pm CET</td>
							<td class="txt_indigo">Welcome and Introduction</td>
							<td class="txt_indigo"></td>
						</tr>
						<tr>
							<td class="txt_indigo">4:05 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#keynote" href="capella_days_2020.html#keynote">Keynote: MBSE with Arcadia and Capella - Reconciling with the past and moving towards the future</a></strong></td>
							<td class="txt_indigo">Juan Navas (Thales)</td>
						</tr>
						<tr>
							<td class="txt_indigo">4:45 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_siemens" href="capella_days_2020.html#talk_siemens">Innovating with MBSE – Medical Device Example</a></strong></td>
							<td class="txt_indigo">Tony Komar (Siemens)</td>
						</tr>
						<tr>
							<td class="txt_indigo">5:25 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_cnes" href="capella_days_2020.html#talk_cnes">Successful Capella Landing on a CNES Operational Use-Case</a></strong></td>
							<td class="txt_indigo">Jonathan Lasalle (Artal/Magellium)</td>
						</tr>
						<tr>
							<td class="txt_indigo">6:05 pm CET</td>
							<td class="txt_indigo">Closing</td>
							<td class="txt_indigo"></td>
						</tr>
					</tbody>
				</table>
				<h3 class="table table-striped wow fadeInDown" data-wow-delay=".3s">Day 2: Tuesday 13th of October</h2>
				<table class="table table-striped wow fadeInDown" data-wow-delay=".3s">
					<thead>
						<tr>
							<th width="10%">Time</th>
							<th width="50%">Session</th>
							<th width="50%">Speakers</th>
						</tr>
					</thead>
					<tbody>
						<tr>
							<td class="txt_indigo">4:00 pm CET</td>
							<td class="txt_indigo">Welcome and Introduction</td>
							<td class="txt_indigo"></td>
						</tr>
						<tr>
							<td class="txt_indigo">4:05 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_tno-esi" href="capella_days_2020.html#talk_tno-esi">MBSE and the High-Tech Equipment Industry,
							how do they match up?</a></strong></td>
							<td class="txt_indigo">Teun Hendriks (ESI-TNO)</td>
						</tr>
						<tr>
							<td class="txt_indigo">4:45 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_thales" href="capella_days_2020.html#talk_thales">Capella Development Status & Future Work</a></strong></td>
							<td class="txt_indigo">Juan Navas (Thales)<br>Minh Tu Ton That (Thales)<br>Sandu Postaru (Thales)</td>
						</tr>
						<tr>
							<td class="txt_indigo">5:25 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_obeo" href="capella_days_2020.html#talk_obeo">Integrating MBSE and Life Cycle Assessment
							for Removing Plastics from the Oceans with The SeaCleaners</a></strong></td>
							<td class="txt_indigo">Arnaud Dieumegard (Obeo)<br>Raphaël Pagé (Obeo)</td>
						</tr>
						<tr>
							<td class="txt_indigo">6:05 pm CET</td>
							<td class="txt_indigo">Closing</td>
							<td class="txt_indigo"></td>
						</tr>
					</tbody>
				</table>
				<h3 class="table table-striped wow fadeInDown" data-wow-delay=".3s">Day 3: Wednesday 14th of October</h2>
				<table class="table table-striped wow fadeInDown" data-wow-delay=".3s">
					<thead>
						<tr>
							<th width="10%">Time</th>
							<th width="50%">Session</th>
							<th width="50%">Speakers</th>
						</tr>
					</thead>
					<tbody>
						<tr>
							<td class="txt_indigo">4:00 pm CET</td>
							<td class="txt_indigo">Welcome and Introduction</td>
							<td class="txt_indigo"></td>
						</tr>
						<tr>
							<td class="txt_indigo">4:05 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_gmv" href="capella_days_2020.html#talk_gmv">Specification and Architecture of a
							System Factory for Space Systems using Capella</a></strong></td>
							<td class="txt_indigo">Elena Alaña Salazar (GMV)<br>Tiago Manuel Da Silva Jorge (GMV)</td>
						</tr>
						<tr>
							<td class="txt_indigo">4:45 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_nextrail" href="capella_days_2020.html#talk_nextrail">An Adventure with Capella - A study from NEXTRAIL</a></strong></td>
							<td class="txt_indigo">Harish Narayanan (NEXTRAIL)</td>
						</tr>
						<tr>
							<td class="txt_indigo">5:25 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_virgin" href="capella_days_2020.html#talk_virgin">High-Speed Transportation Case-Study, by Virgin Hyperloop</a></strong></td>
							<td class="txt_indigo">Brandon Blau (Virgin Hyperloop)<br>Betrand Knop (Virgin Hyperloop)</td>
						</tr>
						<tr>
							<td class="txt_indigo">6:05 pm CET</td>
							<td class="txt_indigo">Closing</td>
							<td class="txt_indigo"></td>
						</tr>
					</tbody>
				</table>
				<h3 class="table table-striped wow fadeInDown" data-wow-delay=".3s">Day 4: Thursday 15th of October</h2>
				<table class="table table-striped wow fadeInDown" data-wow-delay=".3s">
					<thead>
						<tr>
							<th width="10%">Time</th>
							<th width="50%">Session</th>
							<th width="50%">Speakers</th>
						</tr>
					</thead>
					<tbody>
						<tr>
							<td class="txt_indigo">4:00 pm CET</td>
							<td class="txt_indigo">Welcome and Introduction</td>
							<td class="txt_indigo"></td>
						</tr>
						<tr>
							<td class="txt_indigo">4:05 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_vitesco" href="capella_days_2020.html#talk_vitesco">Beyond CAPELLA, STELLAR: an Agile System Engineering Framework</a></strong></td>
							<td class="txt_indigo">Jérôme Montigny (Vitesco Technologies)</td>
						</tr>
						<tr>
							<td class="txt_indigo">4:45 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#talk_stille" href="capella_days_2020.html#talk_stille">Modelling in a regulatory centric domain</a></strong></td>
							<td class="txt_indigo">John Andersson (Stille AB)</td>
						</tr>
						<tr>
							<td class="txt_indigo">5:25 pm CET</td>
							<td class="txt_indigo"><strong><a class="wow smooth-scroll" data-row="#qa" href="capella_days_2020.html#qa">Arcadia/Capella Open Q&A Session</a></strong></td>
							<td class="txt_indigo">Jean-Luc Voirin (Thales)<br>Juan Navas (Thales)</td>
						</tr>
						<tr>
							<td class="txt_indigo">6:05 pm CET</td>
							<td class="txt_indigo">Closing</td>
							<td class="txt_indigo"></td>
						</tr>
					</tbody>
				</table>
			</div>
		</div>
	</section>


	<section id="talks">
		<div class="container">
			<div class="row wow fadeInDown" data-wow-delay=".3s">
				<h2 class="title">Talks</h2>
						<h3 id="keynote">Keynote: MBSE with Arcadia and Capella - Reconciling with the past and moving towards the future</h3>
						<p>MONDAY 12th of OCTOBER | 4:05 pm CET</p>
						<p>Complex systems engineering programs not only deal with the inherent complexity of the systems they develop, but also shall be able to adapt very quickly to changes.</p>
						<p>This requires adapting existing well-proven engineering practices in order to support shorter time-to-markets, more frequent variations in operational contexts and usages,
						and more complex engineering organizations. In this talk, Juan Navas will present the latest methodological progress on Arcadia and Capella that tackle these stakes.</p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/juan_navas.png" width="120"></td>
								<td>
								<h4>Juan Navas (Thales)</h4>
								<i>Juan is a System Architect with +10 years’ experience on performing and implementing Systems Engineering practices in industrial organizations.
								He currently leads the team that accompanies managers and architects implement MBSE approaches on operational projects, helping them define their engineering schemes,
								objectives, and guidelines. He holds a PhD on Computer Science, a MSc on control and computer science, and Electronics and Electrical Engineering Degrees.</i>
								</td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_siemens">Innovating with MBSE – Medical Device Example</h3>
						<p>MONDAY 12th of OCTOBER | 4:45 pm CET</p>
						<p>Sustained innovation is a goal of many development organizations. Sustaining innovation is depicted on an Innovation as matrix as the result of well-defined problem,
						and a well-defined domain definition. An example will be presented how an MBSE tool, based on open source tool Capella, can enhance both the problem definition and domain
						definition of a ventilator. It will show how the MBSE tool enhanced the understanding of the problem, and how that understanding can lead to an innovative solution.</p>
						<p><a href="https://blog.obeo.fr/capella-days-modeling-a-medical-device-with-capella-by-siemens" target="_blank">Learn more</a></p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/tony_komar.png" width="120"></td>
								<td>
								<h4>Tony Komar (Siemens)</h4>
								<i>Tony Komar has been practicing and supporting systems engineering for over 35 years.
								His career began as a System Engineer supporting the development of engine and flight controls in the early 80’s. He led his team supporting FADEC I for CF6 engine
								control through FAA software certification.His research and development of flight control system based on COTS platforms, led him to work 10 in consulting in the automotive
								controls domain. Helping customer establish architecture their rapidly growing software control systems. He joined Siemens 17 years ago and has helped customers establish
								Requirement management and Systems Engineering solutions in variety of industries. In 2011, Tony completed a Master of Engineering in System Engineering from Penn
								State University and turned a focus toward architecting Siemens solutions. Today he is a key contributor to the development and deployment of Model Based System Engineering
								products for Siemens Digital Industries Software. He not only is enabling Siemens staff on MBSE tools, but is also working with the next generation of engineers by developing “open” hands on
								training in electronics and systems engineering though open source products and electronics. </i>
								</td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_cnes">Successful Capella landing on a CNES operational use case</h3>
						<p>MONDAY 12th of OCTOBER | 5:25 pm CET</p>
						<p>The Space Variable Objects Monitor (SVOM) is a space system dedicated to gamma ray detection and study, under development by China National Space Administration (CNSA)
						and the French Space Agency (CNES), to be launched in 2021. The system shall be able to trigger alerts of Gamma Ray Burst (GRB) in real-time with a maximum of associated data.
						It is composed of a space segment (a set of various sensors embedded on a satellite) associated to a worldwide antenna ground network, all managed by the two agencies.</p>
						<p>The design of this system was conducted within the framework of the CNES engineering process, based on a set of documents cascading the textual requirements from
						the high-level concept of operations to the technical specification of equipment. The validation of the obtained specification mainly relies on human expertise and on the
						validation campaign. The complexity of the system made it a perfect candidate for an experimentation of MBSE using Capella.
						Two projects took place successively in this context: a first one was an R&T study, dedicated to the analysis of the current process and the evaluation of the potential
						benefits that MBSE could bring (restricted to some part of the system but spread on several engineering layers (architecture, simulation, satellite database definition...)).
						Due to promising results, a second project, based on the models realized during the first study, was dedicated to the operational capture of the system validation.</p>
    					<p>The smooth incursion of Capella in CNES engineering process was undeniably well received. The SVOM experts were converted to this new way of working.
    					The building of an operational model-based toolchain to capture the system architecture and its associated V&V specification is an achievement which opens the door to a wider
    					reach of MBSE within CNES. </p>
						<p><a href="https://blog.obeo.fr/capella-days-cnes-experimenting-capella-on-a-high-mass-stellar-explosions-detection-system" target="_blank">Learn more</a></p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/jonathan_lasalle.jpg" width="120"></td>
								<td>
								<h4>Jonathan Lasalle (Artal/Magellium)</h4>
								<i>Jonathan Lasalle is in charge of MBSE-related activities at Artal/Magellium. His daily job mainly consist in guiding engineers through the introduction and the
								propagation of the MBSE principles on their own context. In addition to providing training sessions (principally Capella-based), he manages third-part software
								customizations (Capella viewpoints, Papyrus extensions...) and he is the architect of the Citrus framework dedicated to the model-based capture of the simulation
								means specifications.</i>
								</td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_tno-esi">MBSE and the High-Tech Equipment Industry, how do they match up?</h3>
						<p>TUESDAY 13th of OCTOBER | 4:05 pm CET</p>
						<p>MBSE is by now widely adopted in the Aerospace and Defense industry. These industries however typically develop their systems with very large, one-of-a-kind system projects,
						following the V model. A large upfront (MB)SE effort is justified then as the cost of late failures are extremely high. </p>
						<p>The High-Tech Equipment Industry on the other hand develops their systems incrementally with an agile Systems Engineering process,
						supporting many product variants and often a configure-to-order sales process.</p>
						<p>How does MBSE match up with the characteristics of the High-Tech Equipment Industry? ESI and its partners have started a collaborative project to study together whether,
						and if so how, MBSE, or MBSE elements, can improve Systems Engineering in this industry business context.</p>
						This talk will provide an update on the state of SE in the High-Tech Equipment Industry, its use of models, and the outlook on the fit of MBSE in this industry context.</p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/teun_hendriks.jpg" width="120"></td>
								<td>
								<h4>Teun Hendriks, Senior Research Fellow (TNO-ESI)</h4>
								<i>Teun is an experienced system architect with a keen interest to advance the field of Systems Engineering. Creating order out of chaos,
								shaping the ‘fuzzy front end’ of systems engineering is what intrigues him. His professional interest is to understand what foundations and way-of-working help
								design teams to better make the crucial design decisions early on and so better navigate this fuzzy front end.
								His competencies include system architecting; systems thinking; technical leadership; road mapping; planning and monitoring; facilitation and coaching;
								all in a systems engineering context. Teun Hendriks has worked across the globe with US, European, and Asian clients in diverse product areas,
								ranging from semiconductors, consumer & automotive electronics, professional vehicles (trucks) to complex high-tech cyber physical systems,
								and has worked both on systems as service aspects.</i></td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_thales">Capella Development Status & Future Work</h3>
						<p>TUESDAY 13th of OCTOBER | 4:45 pm CET</p>
						<p>In this talk Thales’ Capella development team will present some of the latest Capella features and enhancements, noteworthy add-ons from the Capella eco-system,
						and what future work will bring to the tool.</p>
						<p></p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/juan_navas.png" width="120"></td>
								<td>
								<h4>Juan Navas (Thales)</h4>
								<i>Juan is a System Architect with +10 years’ experience on performing and implementing Systems Engineering practices in industrial organizations.
								He currently leads the team that accompanies managers and architects implement MBSE approaches on operational projects, helping them define their engineering schemes,
								objectives, and guidelines. He holds a PhD on Computer Science, a MSc on control and computer science, and Electronics and Electrical Engineering Degrees.</i>
								</td>
							</tr>
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/minh_tu_ton_that.png" width="120"></td>
								<td>
								<h4>Minh Tu Ton That (Thales)</h4>
								<i>After earning my PhD in Computer Sciences from University of Southern Brittany, I entered the industry world to explore my passion for software development.
								For over 5 years, I work as a software developer at Thales Global Services, where I involve in different activities related to the development of Capella product,
								including software design, coding, product integration, etc. I am interested in all things tech-related and I spend my free time learning new programming languages
								and technologies. I enjoy watching sci-fi movies, playing badminton and walking in Saint-Cloud park on a sunny day.</i>
								</td>
							</tr>
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/sandu_postaru.jpg" width="120"></td>
								<td>
								<h4>Sandu Postaru (Thales)</h4>
								<i>Sandu is a Software Engineer with 2+ years experience, participating in the agile development lifecycle of Capella.
								Open Source enthusiast and Eclipse committer, he is passionate about clean code, performance optimization and loves to work on challenging technical problems.</i>
								</td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_obeo">Integrating MBSE and Life Cycle Assessment for Removing Plastics from the Oceans with The SeaCleaners</h3>
						<p>TUESDAY 13th of OCTOBER | 5:25 pm CET</p>
						<p>More than 8 million tons of plastic are dumped in the oceans every year. If we don’t take action, in 2050, there will be more plastic than fishes in the oceans!</p>
						<p>The SeaCleaners association has been founded to provide global, long-term and worldwide solutions for fighting against ocean plastic pollution.
						The flagship project initiated by The SeaCleaners is the MANTA, the first seagoing vessel capable of collecting and processing in continuous flow large quantities
						of macro plastic waste floating at the surface of oceans.Its design has been focusing on many innovative technologies
						in the field of renewable energy production or by limiting her global carbon footprint maximizing the energy self-sufficiency.</p>
						<p>In this talk we will present a Capella extension developped by Obeo in partnership with The SeaCleaners and Altran to facilitate the Life-Cycle Assessment (LCA)
						of complex systems. This extension consists of additional concepts added to Capella for inventorying components' physical characteristics and the substances
						they consume and/or emit. This information attached to the system architecture can be automatically exported as an initial inventory analysis to LCA tools
						used by environmental experts to perform their impact analysis (such as SimaPro and OpenLCA).</p>
						<p>Experimented on a MANTA subsystem, we will show how this integration between Capella and LCA Tools accelerates the evaluation of the impacts a
						system has on its environment, and helps system designers to make architecture decisions that are better for the planet.</p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/arnaud_dieumegard.png" width="120"></td>
								<td>
								<h4>Arnaud Dieumegard (Obeo)</h4>
								<i>Arnaud is a Software Engineer specialist in Model-Driven Development. He holds a PhD from IRIT on automated code generation verification for critical embedded systems.</i>
								</td>
							</tr>
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/raphael_page.jpg" width="120"></td>
								<td>
								<h4>Raphaël Pagé (Obeo)</h4>
								<i>Raphaël is a Software Engineer at Obeo.</i>
								</td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_gmv">Specification and Architecture of a System Factory for Space Systems using Capella</h3>
						<p>WEDNESDAY 14th of OCTOBER | 4:05 pm CET</p>
						<p>The deployment of Model-Based System Engineering in space projects is not straightforward. The interactions among stakeholders at various levels happen to
						be difficult because the various tools involved are not fully interoperable. </p>
						<p>One of the key elements that would facilitate and ensure the exchange of engineering data information, is the definition of a System Engineering supporting infrastructure,
						also called System Factory, that would allow implementing this interoperability.</p>
						<p>This presentation introduces the approach that is being followed to define the functional architecture of this System Factory which follows the Arcadia method and uses the Capella tool.</p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/elena_salazar.jpg" width="120"></td>
								<td>
								<h4>Elena Alaña Salazar (GMV)</h4>
								<i>Elena Alaña is the Software Engineering Section Head of the Space Segment and Robotics Business Unit at GMV.
								She entered GMV’s ranks in 2006, and has been mostly involved in operational projects (e.g., Sentinel-3, Intermediate eXperimental Vehicle-IXV)
								and R&D activities for the European Space Agency. She has an excellent knowledge on modelling languages, tools and methodologies based on her experience using MBSE
								for the Space Systems and on the prototype development of several software engineering tools for ESA and the European Commission</i>
								</td>
							</tr>
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/tiago_da-silva.jpg" width="120"></td>
								<td>
								<h4>Tiago Manuel Da Silva Jorge (GMV)</h4>
								<i>Tiago Jorge is a Software Engineer in the Space Segment and Robotics Business Unit at GMV.
								He has an important background and special interest in model driven methodologies.
								He has in particular participated in projects involving co-engineering processes, namely software-hardware, and system-software.
								He was a trainee at the European Space Agency (ESA), within the Software Systems division, before joining GMV in 2017.</i>
								</td>
							</tr>
						</table>
						</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_nextrail">An Adventure with Capella - A study from NEXTRAIL</h3>
						<p>WEDNESDAY 14th of OCTOBER | 4:45 pm CET</p>
						<p>In this talk, Harish will share his experiences on a project where he had to develop system requirement specifications
						for an Automatic Train Operation -Trackside (ATO-TS) system, one of the key components that helps with Automatic Train Operations.</p>
						<p>He will present his personal experiences with Capella, as a new user, and will explain the different focus points where NEXTRAIL
						applies Capella including systems modelling and data modelling (for Interfaces).</p>
						<p>You will discover the project specific analysis with Capella and will get answers of the following questions:
						<ul>
						<li>How Capella was related to the scope of the project? Including basic understandings of the systems.</li>
	   					<li>How it helped NEXTRAIL achieve targets of the projects?</li>
	   					<li>What were their modelling practices? Ease of modelling, workflow using a meta model, MBSE activities, integration with teams, beneficial aspects of Capella... </li>
	   					<li>What were the problems NEXTRAIL faced while modelling? </li>
	   					</ul>
						Harish will conclude with possible additions/suggestions for modelling improvements.</p>
						<p><a href="https://blog.obeo.fr/capella-days-functional-system-requirements-for-automatic-train-operation-trackside-unit-by-nextrail" target="_blank">Learn more</a></p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/harish_narayanan.jpg" width="120"></td>
								<td>
								<h4>Harish Narayanan (NEXTRAIL)</h4>
								<i>Harish is a railway engineer expert in Automatic Train Operation systems.</i>
								</td>
							</tr>
						</table>
						</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_virgin">High-Speed Transportation Case-Study, by Virgin Hyperloop</h3>
						<p>WEDNESDAY 14th of OCTOBER | 5:25 pm CET</p>
						<p>Virgin Hyperloop is developing a system that can propel passenger or cargo pods at speeds of over 1000 km/h.
						That is 3x faster than high-speed rail and more than 10x faster than traditional rail.</p>
						<p>In this talk, Brandon blau and Bertrand Knop will present how Capella is used on this project.</p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/brandon_blau.jpg" width="120"></td>
								<td>
								<h4>Brandon Blau (Virgin Hyperloop)</h4>
								<i>Systems Engineering professional in Los Angeles with Electrical and Computer Engineering background and experience working with systems in the Military Air
								and Space industries. Unique understanding of electronic and hardware intersection through professional experience and advanced coursework.
								Demonstrated ability to address big-picture requirements at the ground floor, and excellent skill developing effective intra-team and customer relationships,
								both of which reliant on clear and developed communication abilities. </i>
								</td>
							</tr>
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/icon_users.png" width="120"></td>
								<td>
								<h4>Bertrand Knop (Virgin Hyperloop)</h4>
								<i>Bertrand is System Engineering Manager at Hyperloop One. He has 14 years of experience in specifying, designing,
								qualifying and supporting complex aircraft systems (airframe, avionics, mechanical and weapon systems). </i>
								</td>
							</tr>
						</table>
						</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_vitesco">Beyond CAPELLA, STELLAR: an Agile System Engineering Framework</h3>
						<p>THURSDAY 15th of OCTOBER | 4:05 pm CET</p>
						<p>The STELLAR project in Vitesco Technologies consist in defining and piloting a complete Agile Tool chain based on Capella tool and its growing ecosystem.</p>
						<p>Experimented on an electrified vehicle system platform,  we will present how the tight integration between Capella, Add-ons and Agile tools helps system architects on their daily job.</p>
						<p>The STELLAR framework covers the most important System Engineering activities like Change and Configuration Management, Requirement Engineering, PLE/Variant Management,
						Model Sharing and Reviewing, End to End Traceability.</p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/jerome_montigny.jpg" width="120"></td>
								<td>
								<h4>Jérôme Montigny (Vitesco Technologies)</h4>
								<i>As Senior System Architect, Jérôme has been working in the field of Model Engineering for the past 10 years.
								In Vitesco Technologies, he supports Electrification and Servitization projects, deploying Digital Engineering and Model-Driven solutions.
								Since 2020, he is also teaching MBSE to future system engineers at INSA Toulouse.</i>
								</td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="talk_stille">Modelling in a regulatory centric domain</h3>
						<p>THURSDAY 15th of OCTOBER | 4:45 pm CET</p>
						<p>The medical device domain is heavily driven by regulatory requirements and processes that to many feel very old fashion. The aim for these notifying bodies is to ensure
						safety for the patient, user and environment. Even though the concept of MBSE is widely accepted when it comes to execution of a project it still often waterfall and
						V-model methodology.</p>
						<p>For long medical device development has been document focused domain and we with it. Now we exploring to move into a modelling centric way of developing our products,
						and it’s not only technical issues but processes, readability, accessibility and teamwork that we need to adjust.</p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/john_andersson.jpg" width="120"></td>
								<td>
								<h4>John Andersson (Stille AB)</h4>
								<i>John is the VP of Product Development at Stille AB in Sweden. A company that has been developing medical devices since mid-19th centaury.
								He has a broad experience from system engineering in different technical domains ranging from MedTech to defence to power transmission (HVDC).
								What defines his work is engineering transformation and he likes to be hands-on.</i>
								</td>
							</tr>
						</table>
			</div>
			<div class="row wow fadeInDown" data-wow-delay=".3s">
						<p>&nbsp;</p>
						<h3 id="qa">Arcadia/Capella Open Q&A Session</h3>
						<p>THURSDAY 15th of OCTOBER | 5:25 pm CET</p>
						<p>Ask questions in advance or live to Arcadia and Capella experts.</p>
						<p>To submit questions go to the special <a href="https://bit.ly/CapellaDays_QnA" target="_blank">Q&A page</a></p>
						<table style="margin:10px">
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/juan_navas.png" width="120"></td>
								<td>
								<h4>Juan Navas (Thales)</h4>
								<i>Juan is a System Architect with +10 years’ experience on performing and implementing Systems Engineering practices in industrial organizations.
								He currently leads the team that accompanies managers and architects implement MBSE approaches on operational projects, helping them define their engineering schemes,
								objectives, and guidelines. He holds a PhD on Computer Science, a MSc on control and computer science, and Electronics and Electrical Engineering Degrees.</i>
								</td>
							</tr>
							<tr>
								<td class="vertical_align_top" width="10%"><img src="images/capella_days_2020/jean-luc_voirin.jpg" width="120"></td>
								<td>
								<h4>Jean-Luc Voirin (Thales)</h4>
								<i>Jean-Luc is Director, Engineering and Modeling, in Thales Defense Missions Systems business unit and Technical Directorate.
								He has been an architect of real-time and near real-time computing and mission systems on civil and mission aircraft and fighters.
								He is the principal author of the Arcadia method and an active contributor to the definition of methods and tools.
								He is involved in coaching activities across all Thales business units, in particular on flagship and critical projects.</i>
								</td>
							</tr>
						</table>
						</div>
						<p>&nbsp;</p>
				</div>
			</div>
		</section>




	<div id="back-to-top" data-spy="affix" data-offset-top="100" class="back-to-top hidden-xs hidden-sm affix-top">
		<button class="btn btn-default" title="Back to Top">
			<i class="fa fa-caret-up"></i>
		</button>
	</div>
	<script type="text/javascript">
		// Back to top
		jQuery('#back-to-top').on('click', function () {
			jQuery("html, body").animate({
				scrollTop: 0
			}, 500);
			return false;
		});
	</script>
	<!--
        ==================================================
        Call To Action Section Start
        ================================================== -->
	<ng-include src="'angular/blocks/call2action_capella_day.html'"></ng-include>
	<!--
        ==================================================
        Footer Section
        ================================================== -->
	<ng-include src="'angular/blocks/footer.html'"></ng-include>
	<script async src="js/googleAnalytics.js"></script>
</body>
</html>