MBSE Arcadia Guide: How to Run a Model-Based Systems Engineering Project with Capella

How to Run an MBSE Project with Arcadia & Capella: A CTO's Practical Guide

You're staring down a complex system design. Your product spans hardware, software, and human operators. Requirements are still fuzzy, stakeholders can't agree on terminology, and the last project ended with a 400-page Word document nobody read.

Model-Based Systems Engineering (MBSE) replaces that document with a single, connected model. But MBSE without a method is just drawing boxes. The Arcadia method — implemented in the open-source Capella tool — gives you a structured way to build that model across five engineering perspectives.

This guide walks through a complete MBSE project on a drone package delivery system, from operational analysis through physical architecture, using Arcadia and Capella (latest v7.0).

Table of Contents

• Why This Matters Now
• Prerequisites
• The Arcadia Method in 60 Seconds
• Complete Walkthrough: Drone Package Delivery System
• Verification: How to Check Your Model
• Comparison: Arcadia vs Other MBSE Methods
• Actionable Checklist
• Pitfalls to Avoid
• FAQ
• Conclusion

Why This Matters Now

Prerequisites

Download Capella at mbse-capella.org/download.html. Install it — it ships with the Arcadia method pre-integrated.

The Arcadia Method in 60 Seconds

Complete Walkthrough: Drone Package Delivery System

We'll model a system where a drone picks up a package from a warehouse, flies to a customer location, and delivers it. The customer needs real-time tracking, and the operator needs safety overrides.

Step 1: Operational Analysis (OA)

Goal: Understand what users need without assuming any system solution.

1. Open Capella. Create a new project: File > New > Capella Project → name it DroneDelivery.

2. The Activity Explorer appears on the left. Under Operational Analysis, click New Diagram > Operational Entity Breakdown.

3. Create an Operational Entity called Customer. Create an Operational Actor called Parcel Sender. Create another called Drone Pilot.

[Customer] <---> [Parcel Sender]
                  [Drone Pilot]

4. Create an Operational Capability called Deliver Package. Right-click on it > New Diagram > Operational Process. Draw the process:

   • Parcel Sender sends package data
   • Drone Pilot plans route
   • Customer receives delivery notification

5. Right-click the capability > New Diagram > Operational Scenario. Create a sequence diagram showing lifelines for each entity and the messages between them.

Key deliverable: An operational process that captures the "as-is" workflow. No system exists yet — just actors and their interactions.

Step 2: System Analysis (SA)

Goal: Define what your drone system must do.

Capella's transition mechanism creates SA elements from OA elements automatically, with traceability links.

1. In the Activity Explorer, click Transition > System Analysis from Operational Analysis.

2. Capella creates System Actors from your Operational Entities. It also creates System Capabilities from your Operational Capabilities.

3. Open the System Architecture Blank diagram. You'll see the System of Interest (SoI) — call it Drone Delivery System — surrounded by actors.

4. Right-click the SoI > New Diagram > System Function Breakdown. Create these functions:

   • Receive Package Request
   • Assign Drone
   • Plan Flight Path
   • Execute Flight
   • Monitor Delivery
   • Confirm Delivery

5. Create a System Data Flow Blank diagram. Connect functions with Functional Exchanges:

   textCopy

   Receive Package Request → Assign Drone → Plan Flight Path → Execute Flight → Confirm Delivery
                                          ↕
                                  Monitor Delivery
   

6. Open the System Architecture Blank diagram. Use Manage Function Allocation to allocate functions to components:

   Component	Allocated Functions
   Drone	Execute Flight, Monitor Delivery
   Ground Station	Assign Drone, Plan Flight Path
   Web Portal	Receive Package Request, Confirm Delivery

7. Create a Functional Chain for the Deliver Package capability. Right-click the capability > New Diagram > Functional Chain Description. Highlight the path through all six functions.

Key deliverable: A functional decomposition with clear component allocation and at least one traceable functional chain. You can now run Capella's Validation (right-click project > Validate) to check for completeness.

Step 3: Logical Architecture (LA)

Goal: Define the notional solution — logical components that fulfill the system functions, without committing to specific technologies.

1. In the Activity Explorer, click Transition > Logical Architecture from System Analysis.

2. Create a Logical Component Breakdown diagram. Define logical components:

   • Flight Manager — handles mission planning and execution
   • Navigation System — handles path planning and obstacle avoidance
   • Payload Manager — handles package pickup and release
   • Communication Relay — handles ground-to-drone messaging
   • User Interface — handles customer and pilot interactions

3. Create a Logical Data Flow Blank diagram. Refine the functions from SA into Logical Functions — these go into more detail:

   textCopy

   Flight Manager:
     - Validate flight path
     - Execute waypoint navigation
     - Monitor battery state
     - Execute emergency landing
   

4. Open the Logical Architecture Blank diagram. Allocate logical functions to logical components. Create Component Exchanges between components:

   textCopy

   Flight Manager <--flight plan--> Navigation System
   Flight Manager <--payload cmd--> Payload Manager
   Flight Manager <--telemetry----> Communication Relay
   Communication Relay <--status----> User Interface
   

5. Use Exchange Categories to group related exchanges (e.g., "Safety Data" groups emergency signals).

Key deliverable: A logical component breakdown with allocated functions and clearly defined exchanges between components. This architecture should be technology-agnostic.

Step 4: Physical Architecture (PA)

Goal: Map logical components to real, concrete components with specific technologies.

1. Transition from LA to PA using the Activity Explorer.

2. Create a Physical Component Breakdown diagram. Define two types of physical components:

   • Behavior Components: Software/services that execute behavior
   • Node Components: Hardware platforms that host behavior components

   Node Component	Hosted Behavior Components
   Drone Hardware	Flight Controller, Battery Manager, GPS Receiver, Camera Payload, LTE Modem
   Ground Server	Mission Planner Service, Fleet Manager Database, Auth Service
   Customer App	Delivery Tracker, Notification Handler

3. Define Physical Links — actual wiring or wireless connections:

   textCopy

   Drone Hardware --LTE--> Ground Server
   Drone Hardware --WiFi--> Customer App (at pickup)
   

4. Create Physical Paths that trace how logical exchanges travel through the physical network. For example, the "telemetry" exchange from LA maps through: Flight Controller → LTE Modem → [LTE link] → Ground Server.

5. Use PVMT (Property Values Management Tools) add-on to tag components with mass, cost, and power estimates. This lets you run trade-off analysis on architecture candidates.

Key deliverable: A physical architecture with node-to-behavior component deployment, physical links, and traceable paths back to logical exchanges.

Step 5: EPBS (End-Product Breakdown Structure)

Goal: Define what you need to buy, build, or subcontract.

1. Transition from PA to EPBS.

2. Capella generates an EPBS Breakdown diagram showing configuration items. Each node component becomes a procurement item.

   Configuration Item	Type	Source
   Drone Airframe	Hardware	Supplier A
   Flight Controller Module	COTS	Supplier B
   Mission Planner Service	Software	In-house build
   Ground Server Infrastructure	Hardware	Cloud provider

3. Define Specification Documents for each configuration item. Capella's HTML Generation add-on exports the entire model as a browsable website for stakeholder review.

Verification: How to Check Your Model

Capella's built-in validation catches most consistency errors:

Right-click project > Validate → Check categories:
  - Integrity: broken references
  - Design: naming conventions, port mismatches
  - Completeness: unallocated functions, missing exchanges
  - Traceability: orphaned elements

For the drone delivery model, expect ~15-30 validation warnings on first pass. Each one points to a real modeling gap — fix them before proceeding to the next layer.

Comparison: Arcadia vs Other MBSE Methods

Actionable Checklist

• Download and install Capella 7.0+
• Create a new project using the DroneDelivery example
• Complete Operational Analysis (OA) with entity breakdown and capability
• Transition to System Analysis (SA) using Capella's automated transition
• Define system functions and functional exchanges
• Allocate functions to components
• Define at least one functional chain
• Transition to Logical Architecture (LA)
• Define logical components and allocate refined functions
• Create component exchanges and exchange categories
• Transition to Physical Architecture (PA)
• Define node and behavior physical components
• Define physical links and paths
• Run model validation and fix all errors
• Generate HTML export for stakeholder review
• Define EPBS configuration items

Pitfalls to Avoid

FAQ

Is Capella really free?

Yes. Eclipse Capella is open-source (EPL-2.0). Commercial add-ons (Team for Capella, Docgen, etc.) are available from Obeo and other vendors.

Can I import existing requirements?

Yes. The ReqIF Import add-on brings in requirements from DOORS, Jama, or Polarion. The DOORS 9.x Synchronization add-on supports round-trip sync.

Does Arcadia work with agile?

Yes. Arcadia is lifecycle-agnostic. You can run OA/SA in one sprint, LA in the next, etc. Each perspective produces a validated increment.

How do I collaborate with my team?

Use Team for Capella (server-based collaboration) or store the model in Git (Capella uses standard EMF/XMI files — they diff and merge reasonably well).

What about simulation?

The DESS (Dynamic Execution and System Simulation) add-on lets you simulate state machines and scenarios. For co-simulation, the ModelCenter connector bridges Capella with external analysis tools.

Conclusion

Arcadia and Capella give you a repeatable, tool-enforced process for MBSE. The five-perspective structure — OA, SA, LA, PA, EPBS — forces you to separate what from how and how to build it, reducing rework and improving stakeholder alignment.

If you want a pre-built activity template to plan your own MBSE project, download the MBSE Arcadia matrix from the Capella resources page — it maps every diagram to its engineering purpose and review criteria.

Which option are you leaning toward? Start with the checklist above and let us know where you get stuck.