Holarch

SysML v2

SysML v2 ट्यूटोरियल

SysML v2 प्रोजेक्ट के लिए नौ गाइडेड ट्यूटोरियल, पहले पैकेज से लेकर पोर्ट, एक्शन, स्टेट, आवश्यकताओं, सत्यापन, बाधाओं और वेरिएंट तक, एक चरण पैनल के साथ जो आपके काम की जांच करता है।

इसका उपयोग कैसे करें →

इस पृष्ठ पर
  1. इसका उपयोग कैसे करें
    1. SysML v2 ट्यूटोरियल शुरू करें
    2. किसी चरण का टेक्स्ट टाइप करें
    3. सुझाव
  2. शुरुआत करना
  3. परिभाषाएं और एट्रिब्यूट
  4. पोर्ट और इंटरफ़ेस
  5. एक्शन और फ़्लो
  6. स्टेट और ट्रांज़िशन
  7. आवश्यकताएं
  8. सत्यापन और ट्रेसेबिलिटी
  9. Constraints और गणनाएं
  10. वेरिएंट और कॉन्फ़िगरेशन
  11. ट्यूटोरियल प्रोजेक्ट
  12. संबंधित

Holarch में SysML v2 प्रोजेक्ट के लिए निर्देशित ट्यूटोरियल की एक श्रृंखला है। हर ट्यूटोरियल एक छोटा SysML v2 स्टार्टर प्रोजेक्ट बनाता है और पेज के बगल में एक चरण पैनल खोलता है। आपके काम करते समय पैनल मॉडल की जांच करता है: जब मॉडल में वह होता है जो चरण मांगता है, तो चरण हरा हो जाता है। यह पेज हर चरण को टेक्स्ट के रूप में देता है, ताकि आप यहाँ भी साथ-साथ चल सकें।

पहला ट्यूटोरियल LML ट्यूटोरियल की तरह WS-1 Weather Station का उपयोग करता है। बाकी एक हाइब्रिड कार के हिस्से बनाते हैं, जो Hybrid Car डेमो का मॉडल है: value types और components, पावरट्रेन के ports और interfaces, एक ड्राइव साइकिल, पावरट्रेन की states, कार की requirements, उनका सत्यापन, सेडान के मानों की जांच और प्रोडक्ट लाइन। हर ट्यूटोरियल का अपना स्टार्टर प्रोजेक्ट है, इसलिए आप उन्हें किसी भी क्रम में कर सकते हैं। हर स्टार्टर प्रोजेक्ट और हर पूरा ट्यूटोरियल 0 समस्याओं के साथ जांच पास करता है।

ट्यूटोरियलसमयआप क्या सीखते हैं
शुरुआत करना15 मिनटSysML v2 टेक्स्ट लिखें, उसे ट्री और व्यू के रूप में देखें, व्यू में ड्रॉ करें और एक requirement जोड़ें
परिभाषाएं और एट्रिब्यूट20 मिनटenumerations, value types और abstract definitions लिखें, मानों और इकाइयों के साथ specialize करें, और पूर्णता, डालें और नाम बदलें का उपयोग करें
पोर्ट और इंटरफ़ेस20 मिनटports और interfaces परिभाषित करें, ports को conjugate करें, parts को जोड़ें और Interconnection View में एक interface ड्रॉ करें
एक्शन और फ़्लो20 मिनटaction definitions और fork, flows और join वाली एक ड्राइव साइकिल लिखें, स्विमलेन जोड़ें और FFBD में चरण बनाएं
स्टेट और ट्रांज़िशन20 मिनटsignals और triggers, guards और state actions वाली एक state machine लिखें, और एक समयबद्ध transition ड्रॉ करें
आवश्यकताएं20 मिनटसीमाएं, requirement definitions और usages लिखें, उन्हें satisfy करें और एक ऐसी requirement देखें जो पूरी नहीं होती
सत्यापन और ट्रेसेबिलिटी15 मिनटएक verification case लिखें, ट्रेसेबिलिटी मैट्रिक्स में एक चरण ट्रेस करें और एक requirement व्युत्पन्न करें
Constraints और गणनाएं20 मिनटconstraints और calculations लिखें, Parametric View में मान बाइंड करें, एक analysis case चलाएं और TBD और TBR मान चिह्नित करें
वेरिएंट और कॉन्फ़िगरेशन15 मिनटvariations और variants, एक नियम वाली प्रोडक्ट लाइन, configurations और अपना खुद का एक keyword लिखें

इसका उपयोग कैसे करें

SysML v2 ट्यूटोरियल शुरू करें

  1. रेल में सहायता → ट्यूटोरियल खोलें, या ⌘K / Ctrl+K दबाएं और tutorial टाइप करें। प्रोजेक्ट के बाहर ट्यूटोरियल पेज पहले LML ट्यूटोरियल दिखाता है, फिर SysML v2 प्रोजेक्ट के लिए ट्यूटोरियल। किसी SysML v2 प्रोजेक्ट के अंदर यह केवल SysML v2 ट्यूटोरियल दिखाता है।
  2. किसी कार्ड पर शुरू करें पर क्लिक करें। Holarch प्रोजेक्ट बनाता है, उदाहरण के लिए Tutorial: SysML v2 Ports and Interfaces (Hybrid Car), और उसे दाईं ओर चरण पैनल के साथ खोलता है।

चरण पैनल LML ट्यूटोरियल की तरह काम करता है: मुझे दिखाएं उस नियंत्रण को रेखांकित करता है जिसकी चरण को ज़रूरत है, वहाँ जाएं पेज खोलता है, और पढ़ें सहायता विषय खोलता है, और फिर से शुरू करें…, पूर्ण के रूप में चिह्नित करें और × उसी तरह काम करते हैं। देखें ट्यूटोरियल।

किसी चरण का टेक्स्ट टाइप करें

अधिकतर चरण मॉडल → एडिटर में टाइप करने के लिए SysML टेक्स्ट देते हैं। चरण बताता है कि पंक्तियां कहाँ जाती हैं, उदाहरण के लिए "पैकेज के अंतिम बंद ब्रेस से पहले"। टाइप करना रोकने पर टेक्स्ट मॉडल पर लागू होता है; एडिटर के नीचे की स्थिति यह बताती है, और चरण हरा हो जाता है।

  • पंक्तियां वैसे ही टाइप करें जैसे दिखाई गई हैं। इंडेंटेशन से मॉडल पर कोई फ़र्क नहीं पड़ता; एडिटर आपका इंडेंटेशन रखता है।
  • लाल रेखा त्रुटि दिखाती है: संदेश पढ़ने के लिए उस पर पॉइंटर ले जाएं। सिंटैक्स त्रुटि वाला टेक्स्ट ड्राफ़्ट रहता है और ठीक करने तक लागू नहीं होता।
  • ⌘Z / Ctrl+Z पिछला लागू बदलाव पूर्ववत करता है।

सुझाव

  • पहली बार ट्यूटोरियल क्रम से करें: हर एक अपने उपयोग किए टेक्स्ट को समझाता है, और बाद वाले पहले के विचारों को मानकर चलते हैं (definitions और usages, :> और :>>)।
  • जो चरण खुला ही रहता है, उसमें आमतौर पर किसी नाम में टाइपिंग की गलती होती है। अपने टेक्स्ट की तुलना चरण की पंक्तियों से करें; SysML v2 में नाम केस-संवेदी होते हैं।
  • ट्यूटोरियल वही भाषा सिखाते हैं जो SysML v2 की मूल बातें; विवरण टेक्स्ट नोटेशन पेज पर है।

शुरुआत करना

Weather Station का पहला मॉडल लिखें: टेक्स्ट खोलें, मान और इकाई वाली एक part definition जोड़ें, उसे दूसरी definition में उपयोग करें, मॉडल को ब्राउज़र और General View में देखें, व्यू में एक part ड्रॉ करें और उसे टेक्स्ट में आते देखें, satisfy के साथ एक requirement जोड़ें, और मॉडल को .sysml फ़ाइल के रूप में निर्यात करें। चरणों का विवरण SysML v2 प्रोजेक्ट के साथ शुरुआत करना पर है।

परिभाषाएं और एट्रिब्यूट

स्टार्टर प्रोजेक्ट में पैकेज Vehicles है, जिसमें एक part definition Car है।

  1. पैकेज खोलें। मॉडल → एडिटर पर क्लिक करें। हर घोषणा एक keyword और एक नाम है, फिर ब्रेस में एक बॉडी या एक सेमीकोलन।
  2. एक enumeration लिखें। part def Car { के ऊपर enum def DriveMode { enum economy; enum normal; enum sport; } जोड़ें (हर पंक्ति में एक मान)।
  3. एक value type परिभाषित करें। उसके नीचे attribute def TirePressure :> ScalarValue; जोड़ें। :> का अर्थ है specializes।
  4. एक abstract definition लिखें। doc टिप्पणी और attributes mass : MassValue, partNumber : String और power : PowerValue के साथ abstract part def Component जोड़ें। // एक नोट शुरू करता है जो केवल टेक्स्ट में रहता है।
  5. चेकर को गलती ढूंढने दें। attribute redefines mass = 45 [kg]; और, जानबूझकर, attribute redefines power = 60 [kg]; के साथ part def Battery :> Component जोड़ें। चेकर इकाई को रेखांकित करता है: किलोग्राम शक्ति नहीं है।
  6. इकाई ठीक करें। इसे 60 [W] में बदलें।
  7. एक नाम पूरा करें। बैटरी में attribute capacity : Ener टाइप करें, पूर्णता सूची से Enter के साथ EnergyValue स्वीकार करें और ; से समाप्त करें।
  8. इसे मानक लाइब्रेरी में देखें। रेल के नीचे सेटिंग्स → मानक लाइब्रेरी पर क्लिक करें और खोज बॉक्स में EnergyValue टाइप करें।
  9. एक definition डालें। एडिटर में किसी खाली पंक्ति पर ⌃⇧Space / Ctrl+Shift+Space दबाएं (या डालें ▾ पर क्लिक करें), पार्ट परिभाषा चुनें और attribute redefines mass = 110 [kg]; और attribute cylinders : Integer; के साथ part def Engine :> Component पूरा करें।
  10. definitions का उपयोग करें। Car में attribute mode : DriveMode;, part battery : Battery; और part engine : Engine; जोड़ें।
  11. हर जगह नाम बदलें। कर्सर cylinders पर रखें, F2 दबाएं और इसका नाम बदलकर cylinderCount करें।

पोर्ट और इंटरफ़ेस

स्टार्टर प्रोजेक्ट में पावरट्रेन के components उनके torque और power ports के साथ, port definitions TorquePort और PowerPort, और interface definitions Shaft और HighVoltageBus हैं।

  1. एक port परिभाषित करें। port def TorquePort के ऊपर out attribute flowRate : Real; और attribute kind : FuelKind; के साथ port def FuelPort जोड़ें। out का अर्थ है कि मान उस part से बाहर जाता है जिसका यह port है।
  2. parts को उनके ports दें। FuelTank में port fuelOut : FuelPort; और Engine में port fuelIn : ~FuelPort; जोड़ें। ~ port को conjugate करता है: in और out उलट जाते हैं।
  3. एक interface परिभाषित करें। interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; } जोड़ें।
  4. पावरट्रेन बनाएं। पैकेज के अंत में parts tank, engine, motor, battery और transmission, एक port output : TorquePort और bind output = transmission.output; के साथ part def Powertrain जोड़ें।
  5. दो भाग जोड़ें। पावरट्रेन में interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn; जोड़ें।
  6. शाफ़्ट जोड़ें। interface engineShaft : Shaft connect engine.output to transmission.engineIn; और interface motorShaft : Shaft connect motor.output to transmission.motorIn; जोड़ें।
  7. एक Interconnection View बनाएं। आर्किटेक्चर → Interconnection View पर क्लिक करें, फिर + नया आरेख पर। दिखाता है के नीचे Powertrain चुनें और बनाएं पर क्लिक करें।
  8. एक interface ड्रॉ करें। बैटरी के port powerOut के हैंडल से मोटर के port powerIn तक खींचें, और Interface : HighVoltageBus पर छोड़ें।
  9. interface को नाम दें। नई रेखा चुनें और इंस्पेक्टर में उसके नाम के रूप में hvBus दर्ज करें।
  10. इसे टेक्स्ट में देखें। मॉडल → एडिटर पर क्लिक करें: interface अपने नाम, प्रकार और ends के साथ पावरट्रेन में है।

एक्शन और फ़्लो

स्टार्टर प्रोजेक्ट में पैकेज VehicleBehavior है, जिसमें items Fuel और Torque, functions ProduceTorque (F.2) और DriveWheels (F.3), और तीन part definitions हैं।

  1. एक function परिभाषित करें। in attribute fuelDemand : Real; और out item fuel : Fuel; के साथ action def <'F.1'> SupplyFuel जोड़ें। कोण कोष्ठक में छोटा नाम function की संख्या है।
  2. ड्राइव साइकिल लिखें। first start then split;, fork split;, then supply;, then produce; और चरणों action supply : SupplyFuel और action produce : ProduceTorque के साथ action def <'F'> DriveCycle जोड़ें, हर एक के साथ एक duration।
  3. एक flow जोड़ें। ड्राइव साइकिल में flow of Fuel from supply.fuel to produce.fuel; जोड़ें।
  4. शाखाओं को जोड़ें। first supply then ready;, first produce then ready;, join ready;, then action drive : DriveWheels { … }, then done; और flow produce.torque to drive.torque; जोड़ें।
  5. एक Action Flow View बनाएं। व्यवहार → एक्शन फ़्लो पर क्लिक करें, फिर + नया आरेख पर, और दिखाता है के नीचे DriveCycle चुनें।
  6. बताएं कि हर चरण कौन करता है। perform action trip : DriveCycle; और parts tank, engine और transmission के साथ part def DrivenCar जोड़ें, हर एक के साथ perform trip.supply;, perform trip.produce; या perform trip.drive;। व्यू में हर part के लिए एक स्विमलेन आती है।
  7. फ़ंक्शनल विश्लेषण खोलें। व्यवहार → फ़ंक्शनल विश्लेषण पर क्लिक करें, चुनें… पर क्लिक करें और DriveCycle चुनें।
  8. एक और action घोषित करें। action def EmergencyShutdown; जोड़ें।
  9. FFBD में चरण बनाएं। व्यवहार → FFBD पर क्लिक करें, फिर + नया आरेख पर, और EmergencyShutdown चुनें। जोड़ें पैनल में Open Contactors टाइप करें और Enter दबाएं, फिर Cut Fuel।
  10. चरणों को टेक्स्ट में देखें। मॉडल → एडिटर पर क्लिक करें: FFBD ने चरण और उनके successions लिख दिए हैं।

स्टेट और ट्रांज़िशन

स्टार्टर प्रोजेक्ट में पैकेज PowertrainBehavior है, जिसमें एक खाली part def Car है।

  1. signals परिभाषित करें। attribute def StartRequest; जोड़ें, और उसी तरह StopRequest, PlugIn और Unplug।
  2. एक state definition लिखें। in attribute charge : Real;, entry; then off; और states off, electric और hybrid के साथ state def PowertrainStates जोड़ें।
  3. transitions जोड़ें। state off; के बाद accept StartRequest if charge > 20 then electric; और accept StartRequest then hybrid; जोड़ें।
  4. किसी state को उसके actions दें। state electric; को एक ऐसी बॉडी से बदलें जिसमें entry action spinUpMotor;, do action driveElectric; और exit action holdMotor; हों।
  5. electric state से बाहर निकलें। उसके बाद if charge < 15 then hybrid; और accept StopRequest then off; जोड़ें; state hybrid; के बाद भी accept StopRequest then off; जोड़ें।
  6. नामित transitions वाली एक state जोड़ें। state charging { do action chargeBattery; }, transition plugIn first off accept PlugIn then charging; और transition unplugged first charging accept Unplug then off; जोड़ें।
  7. एक State Transition View बनाएं। व्यवहार → स्टेट मशीन पर क्लिक करें, फिर + नया आरेख पर, और दिखाता है के नीचे PowertrainStates चुनें।
  8. एक समयबद्ध transition ड्रॉ करें। charging के हैंडल से off तक खींचें और Transition पर छोड़ें। transition पैनल में नाम charged और ट्रिगर after 30 [min] दर्ज करें।
  9. इसे टेक्स्ट में देखें। मॉडल → एडिटर पर क्लिक करें: transition एक नामित transition के रूप में लिखा गया है।
  10. कार को states प्रदर्शित करने दें। Car में exhibit state powertrainStates : PowertrainStates; जोड़ें।

आवश्यकताएं

स्टार्टर प्रोजेक्ट में पैकेज VehicleRequirements है, जिसमें डिज़ाइन की एक छोटी प्रति है: Battery, Car और 1580 kg कर्ब मास वाली बेड़े की sedan।

  1. सीमाओं को नाम दें। attribute maxCurbMass : MassValue = 1650 [kg]; और attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h]; जोड़ें।
  2. एक requirement definition लिखें। एक doc कथन, subject car : Car;, attribute limit : MassValue; और require constraint { car.curbMass <= limit } के साथ requirement def <'VR-1'> CurbMass जोड़ें।
  3. एक requirement डालें। किसी खाली पंक्ति पर ⌃⇧Space / Ctrl+Shift+Space दबाएं, आवश्यकता परिभाषा चुनें और subject battery : Battery और require constraint { battery.capacity >= minBatteryCapacity } के साथ VR-3 BatteryCapacity लिखें।
  4. requirements को एक specification में नेस्ट करें। subject car : Car; और requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; } के साथ requirement carSpec जोड़ें।
  5. बताएं कि उन्हें क्या satisfy करता है। satisfy carSpec by fleet.sedan; और satisfy requirement batterySpec : BatteryCapacity by fleet.sedan.battery; जोड़ें।
  6. एक requirement तोड़ें। सेडान का कर्ब मास 1700 [kg] में बदलें। एडिटर satisfy को चिह्नित करता है: सेडान अब VR-1.1 पूरी नहीं करती।
  7. इसे फिर पूरा करें। ⌘Z / Ctrl+Z दबाएं, या इसे वापस 1580 [kg] करें।
  8. requirements तालिका देखें। ज़रूरतें और आवश्यकताएं → आवश्यकताएं पर क्लिक करें।
  9. एक Requirement View बनाएं। आरेख पेज पर + नया आरेख पर क्लिक करें, Requirement View चुनें और दिखाता है के नीचे carSpec चुनें।
  10. कथनों की जांच करें। ज़रूरतें और आवश्यकताएं → गुणवत्ता पर क्लिक करें और गुणवत्ता जांचें पर क्लिक करें।

सत्यापन और ट्रेसेबिलिटी

स्टार्टर प्रोजेक्ट में कर्ब मास requirement और कार specification, चरणों cruise और brake वाली एक ड्राइव साइकिल, VR-6 batteryMassLimit और VR-7 stopFromCruise हैं।

  1. एक verification case लिखें। subject car : Car;, objective massObjective { verify carSpec.sedanMass; } और return verdict : Boolean = car.curbMass <= maxCurbMass; के साथ verification def <'VC-1'> CurbMassTest जोड़ें।
  2. इसे सेडान पर लागू करें। verification <'VC-1.1'> sedanWeighing : CurbMassTest { subject car = fleet.sedan; } जोड़ें।
  3. सत्यापन केस खोलें। सत्यापन → सत्यापन केस पर क्लिक करें। चरण, परिणाम और स्थिति मॉडल के साथ रखा Holarch डेटा हैं। Sedan Weighing की पंक्ति में + चरण पर क्लिक करें, फिर + स्टेप जोड़ें पर, Action के नीचे Weigh the car टाइप करें और लागू करें पर क्लिक करें। फिर उसके स्थिति बटनों में पास हुए पर क्लिक करें।
  4. RVTM पढ़ें। सत्यापन → RVTM पर क्लिक करें।
  5. किसी चरण को requirement तक ट्रेस करें। सत्यापन → ट्रेसेबिलिटी मैट्रिक्स पर क्लिक करें, requirements को पंक्तियों और actions को कॉलम के रूप में दिखाएं, stopFromCruise और brake के सेल पर क्लिक करें, और satisfied by चुनें।
  6. एक requirement व्युत्पन्न करें। private import RequirementDerivation::*; और connection batteryMassDerivation : Derivation connect carSpec.sedanMass to batteryMassLimit; जोड़ें।
  7. मॉडल जांच चलाएं। सत्यापन → मॉडल जांच पर क्लिक करें।

Constraints और गणनाएं

स्टार्टर प्रोजेक्ट में पैकेज VehicleAnalysis है, जिसमें इंजन, बैटरी, कार और सेडान के मान, और लक्ष्य maxCurbMass और minPowerToWeight हैं।

  1. एक constraint definition लिखें। in mass : MassValue;, in limit : MassValue; और व्यंजक mass <= limit के साथ constraint def MassLimit जोड़ें।
  2. एक calculation लिखें। पैरामीटर power और mass और return ratio = power / mass; के साथ calc def PowerToWeight जोड़ें।
  3. सेडान के मान बाइंड करें। constraint sedanMassCheck : MassLimit { in mass = fleet.sedan.curbMass; in limit = maxCurbMass; } जोड़ें।
  4. एक Parametric View बनाएं। आरेख पेज पर + नया आरेख पर क्लिक करें, Parametric View चुनें और दिखाता है के नीचे VehicleAnalysis चुनें। जांच पास होती है: 1580 kg, 1650 kg के भीतर है।
  5. जांच को विफल करें। सेडान का कर्ब मास 1700 [kg] में बदलें; व्यू जांच को विफल होते दिखाता है।
  6. इसे फिर पास करें। पूर्ववत करें, या इसे वापस 1580 [kg] करें। सभी हल करें हर constraint की फिर से जांच करता है।
  7. एक analysis case चलाएं। एक ऐसे objective के साथ जो ratio >= minPowerToWeight मांगता है, analysis def PowerToWeightAnalysis जोड़ें, और analysis sedanPowerToWeight : PowerToWeightAnalysis { subject car = fleet.sedan; } जोड़ें।
  8. खुले मान चिह्नित करें। private import HolarchMetadata::*; जोड़ें और requirement VR-5 ChargeTime जोड़ें, जिसकी समय सीमा पर #TBR हो और चार्जर पावर पर स्वामी, नियत तिथि और औचित्य के साथ @TBD हो। TBD और TBR Holarch की HolarchMetadata लाइब्रेरी से आते हैं, SysML v2 मानक लाइब्रेरी से नहीं; वे मानक StatusInfo metadata को specialize करते हैं।
  9. TBD/TBR रजिस्टर खोलें। ज़रूरतें और आवश्यकताएं → TBD/TBR पर क्लिक करें। चार्ज समय अपने @TBD metadata के स्वामी और नियत तिथि के साथ सूचीबद्ध है। रजिस्टर केवल पढ़ने के लिए है: स्वामी या तिथि एडिटर में metadata में बदलें।
  10. मास का योग निकालें। आर्किटेक्चर → बजट और TPM पर क्लिक करें और रूट part sedan चुनें।

वेरिएंट और कॉन्फ़िगरेशन

स्टार्टर प्रोजेक्ट में Component, Battery, Controller, Car और Powertrain हैं।

  1. variability पैकेज आयात करें। private import HolarchVariability::*; जोड़ें।
  2. एक variation लिखें। किसी खाली पंक्ति पर ⌃⇧Space / Ctrl+Shift+Space दबाएं (या डालें ▾ पर क्लिक करें), वेरिएशन चुनें और variants standardPack (1.4 kWh) और largePack (12 kWh, 120 kg) के साथ variation part def BatteryPack :> Battery पूरा करें।
  3. प्रोडक्ट लाइन लिखें। part pack : BatteryPack;, variants noCharger और wallbox वाले एक variation part charger, और assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack } के साथ part def CarLine :> Car जोड़ें।
  4. एक configuration शुरू करें। डालें ▾ → कॉन्फ़िगरेशन चुनें और part plugInHybrid : CarLine { @HolarchConfiguration; } भरें। एडिटर अभी भी खुले variation points को नोट करता है।
  5. variants चुनें। plugInHybrid में हर point के लिए डालें ▾ → वेरिएंट विकल्प चुनें और part :>> pack = BatteryPack::largePack; और part :>> charger = charger::wallbox; भरें।
  6. दूसरा configuration जोड़ें। उसी तरह selfChargingHybrid जोड़ें, मानक पैक के साथ और बिना चार्जर के।
  7. अपना खुद का keyword परिभाषित करें। metadata def <safetyCritical> SafetyCritical जोड़ें।
  8. keyword का उपयोग करें। Powertrain में #safetyCritical part controller : Controller; लिखें।
  9. प्रोडक्ट लाइन देखें। Vehicles का एक General View बनाएं: बैटरी पैक variation के रूप में चिह्नित है।

ट्यूटोरियल प्रोजेक्ट

SysML v2 ट्यूटोरियल प्रोजेक्ट दूसरे ट्यूटोरियल प्रोजेक्ट जैसे ही नियमों का पालन करते हैं: वे आपके प्लान के सक्रिय प्रोजेक्ट में नहीं गिने जाते, उनमें 300 तक आइटम हो सकते हैं, और हर ट्यूटोरियल के लिए आपके पास एक प्रोजेक्ट हो सकता है। देखें ट्यूटोरियल।

SysML® और OMG®, संयुक्त राज्य अमेरिका और अन्य देशों में Object Management Group, Inc. के पंजीकृत ट्रेडमार्क हैं।