<!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 MBSE Tool - Industry Consortium</title>
        <meta name="description" content="">
        <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>
        <!-- display videos in fancybox -->
        <script type="text/javascript">
            $(document).ready(function() {
                $(".various").fancybox({
                    maxWidth    : 800,
                    maxHeight   : 600,
                    fitToView   : false,
                    width       : '70%',
                    height      : '70%',
                    autoSize    : false,
                    closeClick  : false,
                    openEffect  : 'elastic',
                    closeEffect : 'none',
                    beforeLoad  : function(){
                        var url= $(this.element).attr("href");
                        url = url.replace(new RegExp("watch\\?v=", "i"), 'v/');
                        url += '?fs=1&autoplay=1';
                        this.href = url
                    }
                });
            });
        </script>
        <script>
            $(document).ready(function(){
                $(".fancypdf").fancybox({
                    openEffect  : 'none',
                    closeEffect : 'none',
                    iframe : {
                        preload: false
                    }
                });
            });
        </script>
    </head>
    <body ng-app="capella" data-deferred-cloak>
    	<!--
        ==================================================
        Header Section
        ================================================== -->
    	<ng-include src="'angular/blocks/header.html'"></ng-include>
        <!-- 
        ================================================== 
            Global Page Section Start
        ================================================== -->
        <section class="hero-area bg_indigo">
            <div class="container">
                <div class="row">
                    <div class="col-md-12 text-center">
                    	<div class="block wow fadeInUp" data-wow-delay=".3s">
                            
                            <!-- Slider -->
                            <section class="cd-intro">
                               <p><img src="images/logos/logo_capella_ic_white.png" alt="Capella - Industry Consortium"></p>
                            </section> <!-- cd-intro -->
                            <!-- /.slider -->
                            <h2 class="wow fadeInUp animated" data-wow-delay=".6s" >
								The Capella IC hosts the Eclipse Capella&trade; ecosystem stakeholders<br>in a vendor neutral way with an open governance<br>
							</h2>
							
                        </div>
                    </div>
                </div>
            </div>   
        </section><!--/#page-header-->
        
        <section>
            <div class="container">
                <div class="row">
	              	<h3>Mission</h3>
					<p>To fulfill the overall MBSE vision, Capella tool associated with Arcadia method offers a mature, full featured, sustainable solution which can be widely diffused thanks to an open source alternative to existing proprietary modeling tools.</p>
	 
					<p>Capella ecosystem is made up vibrant stakeholders who need to collaborate in a vendor neutral way with an open governance:</p>
					<ul>
						<li>companies developing complex systems and softwares</li>
						<li>suppliers providing offers on the top of Capella</li>
						<li>academics with a MBSE topic for research need</li>
					</ul>
	 
					<p>The Capella Industry Consortium (IC) aims to offer to its members a place to:</p> 
					<ul>
						<li>foster collaborations,</li>
						<li>share investment and best practices,</li> 
						<li>leverage Open Innovation to co-develop new MBSE capabilities.</li>
					</ul>
					<br>
					<h3>Goals</h3>
					<p>Capella IC provides to its members an open governance on several axis related to Capella tool, add-ons and underlying technologies:</p>
					<p><a rel="gallery" class="fancybox" href="images/industry_consortium/schema_capella_ic.png"><img class="center" src="images/industry_consortium/schema_capella_ic.png" alt="" width="60%"></a>
					
					<ul>
						<li>Knowledge Sharing: case studies, technology watch, private exchange workshops on N&N</li>
						<li>Promotion: Promote Capella as a leading solution, Provide material to executive</li>
						<li>Product management: Requirements co-creation, Discuss the roadmap</li>
						<li>Development of the Community: collaboration between research/academia, suppliers, end-users</li>
						<li>Joint development financing: Coordinate investments  to reduce, development time, risks, and cost, and maximize ROI</li>
					</ul>
              </div>
            </div>
        </section>
        
        <section class="bg_indigo text-center txt_white">
            <div class="container">
                <div class="row">
                    <div class="col-md-12">
                        <div class="block">
                            <p class="wow fadeInDown animated" data-wow-delay=".5s" data-wow-duration="500ms" style="visibility: visible; animation-duration: 500ms; animation-delay: 0.5s; animation-name: fadeInDown;">
                            The Capella IC activity is driven by several committees: the Steering Committee, <br>the Product Management Committee and the Marketing Committee.</p>
                            <a href="https://www.eclipse.org/org/workinggroups/capellaic_charter.php" target="_blank" class="btn btn-default btn-contact wow fadeInDown animated" data-wow-delay=".7s" data-wow-duration="500ms" style="visibility: visible; animation-duration: 500ms; animation-delay: 0.7s; animation-name: fadeInDown;">Read the Capella IC Charter</a>
                        </div>
                    </div>
                    
                </div>
            </div>
        </section>
        
       <section class="">
            <div class="container">
                <div class="row">
	              	<h3>Membership</h3>
					<p>The membership classes of the Capella IC are designed to reflect the varied interests of the members.</p> 
					<br>
					<h4>Driver Members</h4>
					<p>Influence the development of Capella and be an integral part of the group of organizations that govern the development of the open source MBSE solution.</p>
					<p><a href="industry-consortium/thales.html" title="Thales"><img src="images/logos/logo_thales.png"></a></p>
					<br> 
					<h4>Participant Members</h4>
					<p>Contribute to the development and adoption of Capella: development of viewpoints, participation at conferences, providing user experiences to end-users, etc.</p>
					<div class="col-md-2"><p><a href="industry-consortium/airbus.html" title="Airbus"><img src="images/logos/logo_airbus.png" height="100"></a></p></div>
					<div class="col-md-2"><p><a href="industry-consortium/artal.html" title="Artal Groupe"><img src="images/logos/logo_artal-groupe.png" height="100"></a></p></div>
					<div class="col-md-2"><p><a href="industry-consortium/glaway.html" title="Tecnalia"><img src="images/logos/logo_glaway.jpeg" height="110"></a></p></div>
					<div class="col-md-2"><p><a href="industry-consortium/obeo.html" title="Obeo"><img src="images/logos/logo_obeo.png" height="100"></a></p></div>
					<div class="col-md-2"><p><a href="industry-consortium/prfc.html" title="PRFC"><img src="images/logos/logo_prfc.png" height="100"></a></p></div>
                    <div class="col-md-2"><p><a href="industry-consortium/tecnalia.html" title="Tecnalia"><img src="images/logos/logo_tecnalia.gif" height="100"></a></p></div>
					<div class="clearfix"></div>
					<h4>Research/Academia Members</h4>
					<p>Universities and research organizations that want to participate in the development of the overall MBSE solution based on Capella.</p>
	            </div>
            </div>
        </section>
        
         <section id="membership" class="bg_lightest_grey text-center">
            <div class="container">
                <div class="row">
                	<p class="wow fadeInDown" data-wow-delay=".5s">Wether you are an end-user, a tool provider or a researcher<br> you can also be part of this vibrant ecosystem!</p><br>
                    <div class="col-md-6 col-xs-12 block-center">
                    	<p><a href="contact.html" class="btn btn-default wow fadeInDown animated" data-wow-delay=".7s" data-wow-duration="500ms">Join Capella IC</a></p>
                    </div>
                </div>
            </div>
        </section> <!-- #membership -->
        
        <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.html'"></ng-include>
       
        <!--
        ==================================================
        Footer Section
        ================================================== -->
        <ng-include src="'angular/blocks/footer.html'"></ng-include>
        <script async src="js/googleAnalytics.js" ></script>
    </body>
</html>