Holarch

SysML v2

SysML v2 टेक्स्ट संकेतन

SysML v2 भाषा जैसी Holarch उसका समर्थन करता है, Hybrid Car डेमो के उदाहरणों, उसकी जांचों और केवल-पठन मानक लाइब्रेरी के साथ।

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

इस पृष्ठ पर
  1. अवलोकन
  2. अवधारणाएं
    1. एलिमेंट, स्वामी और योग्य नाम
    2. पैकेज
    3. Imports और दृश्यता
    4. Definitions और usages
    5. टाइपिंग, specialization और redefinition
    6. Multiplicities
    7. मान और इकाइयां
    8. संरचना: ports, connections, interfaces, bindings और flows
    9. व्यवहार: actions
    10. व्यवहार: states
    11. Requirements, constraints और सत्यापन
    12. यूज़ केस
    13. व्यू
    14. टिप्पणियां, दस्तावेज़ीकरण और metadata
    15. इंडिविजुअल, स्नैपशॉट और टाइम स्लाइस
    16. Variations, variants और configurations
    17. टेक्स्ट निरूपण
  3. इसका उपयोग कैसे करें
    1. एक संरचना मॉडल करें
    2. इकाइयों के साथ मान दें
    3. व्यवहार का वर्णन करें
    4. एक requirement लिखें और उसे ट्रेस करें
    5. किसी मान को TBD या TBR के रूप में चिह्नित करें
    6. लाइब्रेरी का कोई नाम खोजें
  4. हल किया गया उदाहरण: सेडान की requirement पढ़ें
  5. सुझाव और आम ग़लतियां
  6. Holarch क्या समर्थित करता है
    1. लिखे अनुसार रखा गया, व्याख्या नहीं की गई
    2. अभी उपलब्ध नहीं
  7. जांचें
  8. मानक लाइब्रेरी
  9. सीमाएं
  10. संबंधित पेज

अवलोकन

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

यह पेज Hybrid Car (SysML v2) डेमो के उदाहरणों से संकेतन सिखाता है। फिर यह बताता है कि Holarch क्या समर्थित करता है, आपके टेक्स्ट पर कौन सी जांच चलती हैं, और मानक लाइब्रेरी क्या है।

अवधारणाएं

एलिमेंट, स्वामी और योग्य नाम

शीर्ष-स्तरीय पैकेज को छोड़कर हर एलिमेंट का एक स्वामी होता है। किसी एलिमेंट का योग्य नाम उसके स्वामियों के नामों की श्रृंखला है, जो :: से जुड़ी होती है। डेमो में, पावरट्रेन definition की बैटरी Vehicles::Powertrain::battery है।

रिक्त स्थान या दूसरे विशेष अक्षरों वाला नाम एकल उद्धरण चिह्नों में जाता है: 'Fuel Tank'। कोण कोष्ठक में एक छोटा नाम किसी एलिमेंट को दूसरा, छोटा पहचानकर्ता देता है: requirement def <'VR-1'> CurbMass। Holarch किसी requirement के छोटे नाम को उसकी संख्या के रूप में उपयोग करता है।

पैकेज

पैकेज एलिमेंट को फ़ोल्डर की तरह समूहित करता है। पैकेज नेस्ट हो सकते हैं। हर शीर्ष-स्तरीय पैकेज एडिटर में एक दस्तावेज़ है।

package Vehicles {
    doc /* A hybrid passenger car: structure, interfaces and variants. */

    private import ScalarValues::*;
    private import ISQ::*;
    private import SI::*;
}

Imports और दृश्यता

import किसी दूसरे पैकेज के सदस्यों को उनके छोटे नामों से दिखने योग्य बनाता है।

  • import ISQ::*; ISQ के सदस्यों को आयात करता है।
  • import VehicleRequirements::**; नेस्टेड एलिमेंट के सदस्यों को भी आयात करता है (रिकर्सिव)।
  • import Vehicles::Car; एक एलिमेंट आयात करता है।
  • import Vehicles::*[@SysML::PartDefinition]; केवल एक प्रकार के सदस्यों को आयात करता है (एक फ़िल्टर किया गया import)।

private, protected और public तय करते हैं कि किसी सदस्य या import को और कौन देखता है। डेमो private import लिखता है, ताकि imports उन पैकेज तक आगे न जाएं जो इसे आगे आयात करते हैं।

import के बिना, योग्य नाम लिखें: ISQ::MassValue कहीं भी हल होता है, MassValue केवल वहाँ जहाँ ISQ आयात किया गया है।

alias किसी एलिमेंट को दूसरा नाम देता है: alias Hybrid for Car;।

Definitions और usages

definition किसी प्रकार की चीज़ का वर्णन करती है। usage किसी दूसरे एलिमेंट के अंदर किसी definition का एक उपयोग है। अधिकतर keywords दोनों रूपों में आते हैं:

DefinitionUsageयह क्या है
part def Battery;part battery : Battery;एक सिस्टम, सबसिस्टम या घटक
attribute def TirePressure;attribute mass : MassValue = 45 [kg];एक मान, अक्सर इकाइयों के साथ
item def Fuel;item fuel : Fuel;कुछ ऐसा जो बहता है या संभाला जाता है
port def FuelPort { … }port fuelOut : FuelPort;किसी part पर एक कनेक्शन बिंदु
connection def … / interface def FuelLine { … }interface fuel : FuelLine connect …;parts या ports के बीच एक लिंक
action def ProduceTorque { … }action produce : ProduceTorque;व्यवहार: एक चरण जो इनपुट लेता है और आउटपुट देता है
state def PowertrainStates { … }state off;व्यवहार: एक state और उसके transitions
constraint def MassLimit { … }constraint …;मानों पर एक Boolean शर्त
calc def PowerToWeight { … }calc …;return मान वाली एक गणना
requirement def <'VR-1'> CurbMass { … }requirement <'VR-1.1'> sedanMass : CurbMass;एक requirement
use case def DriveToWork { … }use case commute : DriveToWork;एक use case
analysis def PowerToWeightAnalysis { … }analysis sedanPowerToWeight : …;एक analysis case
verification def CurbMassTest { … }verification sedanWeighing : CurbMassTest;एक verification case
view def RequirementsView { … }view driveCycleFlow : ActionFlowView { … }मॉडल का एक व्यू
enum def DriveMode { … }attribute mode : DriveMode;मानों का एक निश्चित समूह

किसी definition में नेस्ट किए गए सदस्य उसके हर usage के होते हैं। part frontAxle : Axle; में Axle के differential, leftWheel और rightWheel बिना दोहराए होते हैं।

टाइपिंग, specialization और redefinition

चार ऑपरेटर definitions और usages को संबंधित करते हैं। हर एक का एक keyword रूप भी है।

ऑपरेटरKeywordअर्थउदाहरण
:defined byकिसी usage को किसी definition से टाइप करता हैpart engine : Engine;
किसी definition पर :>specializesयह definition दूसरी का एक प्रकार है और उसके सदस्य विरासत में पाती हैpart def FuelTank :> Component
किसी usage पर :>subsetsयह usage किसी दूसरे usage का उपसमुच्चय हैpart spareWheel :> wheels;
:>>redefinesविरासत में मिले usage को बदलता है, उदाहरण के लिए उसे मान देने के लिएattribute redefines mass = 18 [kg];
~किसी port को conjugate करता है: उसके in और out features आपस में बदल जाते हैंport fuelIn : ~FuelPort;

Redefinition वह तरीका है जिससे कोई variant या कॉन्फ़िगर किया गया part अपनी विरासत को बदलता है। डेमो में, SportCar अतिरिक्त पहिये को redefine करके हटा देता है:

part def SportCar :> Car {
    attribute topSpeed : SpeedValue = 210 [km/h];
    part redefines spare [0];
}

abstract ऐसी definition को चिह्नित करता है जिसके सीधे instances नहीं होते (abstract part def Component)। ref ऐसे संदर्भ को चिह्नित करता है जिसका स्वामित्व नहीं है। in, out और inout किसी feature या पैरामीटर की दिशा तय करते हैं। end किसी connection या interface definition के ends को चिह्नित करता है।

Multiplicities

कोष्ठक में multiplicity बताती है कि कितने हैं।

  • [2]: ठीक दो। part runabout : CityCar [2];
  • [0..1]: वैकल्पिक। part spare : Wheel [0..1];
  • [1..*] और [*]: एक या अधिक, कोई भी संख्या।
  • [0]: कोई नहीं, विरासत में मिले part को हटाने के लिए उपयोग होता है।
  • सीमाएं व्यंजक हो सकती हैं। ordered और nonunique कोष्ठक के बाद आते हैं।

मान और इकाइयां

= एक मान बाइंड करता है। := एक प्रारंभिक मान देता है जो बदल सकता है। default एक डिफ़ॉल्ट देता है जिसे redefinition बदल सकता है।

attribute maxCurbMass : MassValue = 1650 [kg];
attribute minBatteryCapacity : EnergyValue = 1.2 [kW*h];
attribute minPowerToWeight = 40 [W/kg];
attribute topSpeed : SpeedValue = 210 [km/h];

मात्रा कोष्ठक में इकाई वाली एक संख्या है। इकाइयां *, / और ^ से जुड़ती हैं ([m/s^2])। MassValue जैसे मात्रा प्रकार ISQ से आते हैं, और kg जैसी इकाइयां SI (या USCustomaryUnits) से। Holarch आयामों की जांच करता है: किसी MassValue को 5 [s] देना त्रुटि है।

व्यंजक अंकगणित, तुलना (<=, ==), तार्किक ऑपरेटर (and, or, not, implies), सशर्त if c ? a else b, feature chains (car.powertrain.battery.capacity), calculations के कॉल (PowerToWeight(power, mass)) और ->sum, ->size, ->select और ->collect जैसे sequence ऑपरेशन का उपयोग करते हैं। Holarch मानों, constraints, व्यू और विश्लेषण पेजों के लिए इन्हें इकाइयों के साथ मूल्यांकित करता है।

संरचना: ports, connections, interfaces, bindings और flows

parts अपने ports के ज़रिए जुड़ते हैं।

part def Powertrain {
    part tank : FuelTank;
    part engine : Engine;
    interface fuel : FuelLine connect tank.fuelOut to engine.fuelIn;
    connect controller.engineCtl to engine.ecu;
    port output : TorquePort;
    bind output = transmission.output;
}
  • connect a to b; दो parts या ports को जोड़ता है।
  • interface ports के बीच एक टाइप किया गया connection है। इसकी definition इसके ends के नाम देती है: interface def FuelLine { end supply : FuelPort; end consumer : ~FuelPort; }।
  • किसी connection या interface के हर end का एक नाम और एक multiplicity हो सकती है: interface motorShaft : Shaft connect [1] driver ::> motor.output to [1] driven ::> transmission.motorIn;। नामित end उस connection का एक feature है, इसलिए motorShaft.driver उसे संदर्भित करता है।
  • bind a = b; बताता है कि दो features एक ही हैं (एक binding connector)।
  • flow of Fuel from supply.fuel to produce.fuel; एक item को एक feature से दूसरे तक ले जाता है। message एक item को parts के बीच एक इवेंट के रूप में भेजता है।

व्यवहार: actions

एक action definition में उसके चरण (action usages), उसके पैरामीटर और चरणों का क्रम होता है।

action def DriveCycle {
    in attribute targetSpeed : Real;
    first start then switchOn;
    action switchOn { attribute duration : DurationValue = 2 [s]; }
    then fork split;
    then supply;
    then produce;
    action supply : SupplyFuel;
    action produce : ProduceTorque;
    flow of Fuel from supply.fuel to produce.fuel;
    first supply then ready;
    first produce then ready;
    join ready;
}
  • Successions चरणों का क्रम तय करते हैं: first a then b;, या a के ठीक बाद then b;। start और done शुरुआत और अंत हैं।
  • नियंत्रण नोड: समानांतर पथों के लिए fork और join; विकल्पों के लिए decide और merge। किसी decision के बाद एक guarded succession if speed > 30 then cruise; लिखा जाता है, और else brake; डिफ़ॉल्ट शाखा है।
  • Terminate: terminate; घेरने वाले action को उसके अभी भी चल रहे चरणों के साथ तुरंत समाप्त करता है; then terminate; इसे पिछले चरण के बाद रखता है। terminate x; occurrence x को समाप्त करता है।
  • अन्य actions: accept किसी signal की प्रतीक्षा करता है, send एक भेजता है, assign x := expr; एक मान बदलता है, if एक ब्लॉक चलाता है या छोड़ देता है, while … { … } until …; और for v in seq { … } एक ब्लॉक दोहराते हैं।
  • व्यवहार का आवंटन: एक part किसी action को perform करता है (perform action trip : DriveCycle;, perform trip.supply;), और allocate a to b; एक एलिमेंट को दूसरे को आवंटित करता है।

व्यवहार: states

एक state definition में states और उनके बीच के transitions होते हैं।

state def PowertrainStates {
    entry; then off;
    state off;
    accept StartRequest then hybrid;
    state hybrid {
        entry action startEngine;
        do action driveHybrid;
        exit action stopEngine;
    }
    transition recharged first hybrid if charge > 60 then electric;
}
  • entry; then off; प्रारंभिक state तय करता है।
  • Transitions में एक trigger (accept StartRequest), एक वैकल्पिक guard (if charge > 20) और एक वैकल्पिक effect (do …) होता है। छोटा रूप source state के बाद आता है; लंबा रूप transition name first a … then b; है।
  • मॉडल में, किसी transition का trigger और effect अपने आप में एलिमेंट हैं: एक accept action और एक action (send, assign, perform, terminate या कोई नामित action)। ब्राउज़र उन्हें transition के नीचे trigger और effect के रूप में दिखाता है। वे transition के अपने accepter और effect हैं, इसलिए मॉडल के दूसरे हिस्से उनका नाम ले सकते हैं: chargerStates.plugIn.effect.sentMessage वह संदेश है जो effect भेजता है, जैसा कि एक sequence मॉडल उसे बाइंड करता है।
  • किसी port के ज़रिए आने वाले trigger को ऐसी चीज़ स्वीकार करनी होगी जो port ले जाता है: डेमो के ChargeManager में, accept connectCharger : ChargerConnected via chargePort port के in connected : ChargerConnected से मेल खाता है। effect send new ChargeRequest() to controller एक part को भेजता है; attribute जैसा कोई मान संदेश प्राप्त नहीं कर सकता।
  • entry, do और exit actions state में प्रवेश करने पर, उसमें रहते हुए, और उसे छोड़ने पर चलते हैं। parallel states में regions होते हैं जो सभी एक साथ सक्रिय रहते हैं।
  • एक part किसी state को exhibit करता है: exhibit state powertrainStates : PowertrainStates;।

Requirements, constraints और सत्यापन

एक requirement अपना कथन doc में, जिस एलिमेंट पर वह लागू होती है उसे subject के रूप में, और जांची जा सकने वाली शर्त को require constraint के रूप में रखती है।

requirement def <'VR-1'> CurbMass {
    doc /* The car's curb mass shall not exceed the mass limit. */
    subject car : Car;
    attribute limit : MassValue;
    require constraint { car.curbMass <= limit }
}

satisfy carSpec by fleet.sedan;
  • assume constraint एक ऐसी शर्त बताता है जिसे requirement मानकर चलती है। जब वह लागू नहीं होती, तो वह requirement और उसमें नेस्ट की गई requirements पूरी मानी जाती हैं; उसके चारों ओर की requirement और दूसरी नेस्टेड requirements की जांच फिर भी होती है। actor, stakeholder और frame concern बताते हैं कि requirement किसके लिए और किस बारे में है।
  • satisfy R by part; बताता है कि एक part किसी requirement को पूरा करता है।
  • एक verification case अपने objective में requirements का सत्यापन करता है: objective { verify carSpec.sedanMass; }। यह return verdict : Boolean = …; कर सकता है।
  • एक analysis case में एक subject, एक objective और एक return परिणाम होता है, जिसे Holarch तब मूल्यांकित करता है जब हर इनपुट का मान हो। case के बिना मान वाले attributes उसके objective के == समीकरणों से हल किए जाते हैं (अज्ञात वाले analysis cases)।
  • connection : Derivation connect original to derived; एक व्युत्पन्न requirement दर्ज करता है। #refinement dependency x to R; एक refinement दर्ज करता है।
  • dependency from a to b; एक सामान्य ट्रेस दर्ज करता है।

यूज़ केस

use case def DriveToWork { subject car : Car; actor driver : Driver; objective { … } include use case startCar : StartCar; }। एक use case usage अपनी definition का subject और actors लेता है।

व्यू

एक व्यू मॉडल का एक हिस्सा दिखाता है। यह एक मानक view definition से टाइप होता है और जो दिखाता है उसे expose करता है:

view driveCycleFlow : StandardViewDefinitions::ActionFlowView {
    expose DriveCycle;
}

filter एलिमेंट को सीमित करता है (filter @SysML::RequirementUsage;)। render एक रेंडरिंग चुनता है। एक viewpoint उन चिंताओं को तय करता है जिन्हें व्यू को संबोधित करना होगा। SysML v2 व्यू हर व्यू प्रकार को समझाता है।

टिप्पणियां, दस्तावेज़ीकरण और metadata

  • doc /* text */ अपने स्वामी का दस्तावेज़ीकरण करता है। यह मॉडल का हिस्सा है; किसी requirement के लिए यह requirement का टेक्स्ट है।
  • comment about x /* text */ मॉडल में किसी दूसरे एलिमेंट के बारे में एक नोट है।
  • // text और //* text */ केवल टेक्स्ट में नोट हैं। Holarch उन्हें टेक्स्ट में रखता है, लेकिन वे मॉडल एलिमेंट नहीं हैं।
  • Metadata किसी एलिमेंट पर टिप्पणी जोड़ता है: बॉडी में @TBD { owner = "Powertrain lead"; }, उपसर्ग के रूप में #TBR attribute limit …, या बाहर से metadata Capability about Vehicles::Car;।
  • उपयोगकर्ता-परिभाषित keywords: कोई भी metadata definition keyword के रूप में काम करती है: #safetyCritical part controller : Controller; कंट्रोलर को metadata SafetyCritical (छोटा नाम <safetyCritical>) से चिह्नित करता है। एक metadata definition सीमित कर सकती है कि वह क्या चिह्नित करे: :>> annotatedElement : SysML::PartDefinition; केवल part definitions की अनुमति देता है।
  • Semantic metadata: SemanticMetadata को specialize करने वाली metadata definition एक base type तय करती है, :>> baseType = faults meta SysML::Usage;। फिर हर चिह्नित एलिमेंट base को specialize करता है: एक usage किसी base usage का subset बनता है, एक definition किसी base definition को या किसी base usage की definitions को specialize करती है। इसलिए #fault def BatteryOverheat; और #fault overheat : BatteryOverheat; faults हैं और उनमें Fault के features हैं। semantic metadata के साथ भाषा का keyword छोड़ा जा सकता है, जैसा इन दो पंक्तियों में; ब्राउज़र उन्हें उनके keyword (#fault def) के साथ दिखाता है। बाहर से लिखा गया metadata Fault about x; x को fault नहीं बनाता: जांच चेतावनी देती है और x को ही #fault से चिह्नित करने का सुझाव देती है।
  • अपने अर्थ वाला Metadata: किसी metadata definition के features वे हैं जिन्हें उसके हर उपयोग को बताना होगा, और उसकी constraints उन पर लागू होनी चाहिए। metadata def SafetyRating { attribute level : Natural; assert constraint { level >= 1 and level <= 4 } } के साथ, जांच @SafetyRating; (कोई level नहीं) और @SafetyRating { level = 7; } (सीमा से बाहर) की रिपोर्ट करती है; @SafetyRating { level = 4; } ठीक है। definition में मान या default वाला, या [0..1] घोषित feature छोड़ा जा सकता है। हर मान को अपने feature के प्रकार में फ़िट होना चाहिए: Boolean के लिए true या false, String के लिए उद्धरण चिह्नों में टेक्स्ट, Integer के लिए पूर्ण संख्या (Natural के लिए 0 या अधिक, Positive के लिए 0 से ऊपर), और enumeration के लिए उसके मानों में से एक, जैसे HazardAnalysis::fmea; जांच किसी अन्य मान की, और definition में फ़िट न होने वाले डिफ़ॉल्ट की रिपोर्ट करती है। metadata बॉडी केवल definition के features को मान देती है (level = 4;), और abstract metadata def लागू नहीं की जा सकती। Hybrid Car डेमो अपने कंट्रोलर को @SafetyRating { level = 4; } रेटिंग देता है और बैटरी की समीक्षा को @SafetyReview { method = HazardAnalysis::fmea; closed = true; } के रूप में दर्ज करता है। एडिटर में, डालें ▾ → मेटाडेटा परिभाषा एक feature और एक नियम के साथ definition शुरू करता है, और मेटाडेटा लागू करें किसी बॉडी के अंदर एक लागू करता है। टेक्स्ट लिखे बिना: कोई definition या usage चुनें और इंस्पेक्टर के Metadata सेक्शन का उपयोग करें। मेटाडेटा जोड़ें प्रोजेक्ट की metadata definitions में से एक लागू करता है; फिर हर feature का एक फ़ील्ड होता है (enumeration या Boolean के लिए मानों की सूची, String के लिए सादा टेक्स्ट, जिसे Holarch उद्धरण चिह्नों में लिखता है; definition का डिफ़ॉल्ट संकेत के रूप में दिखता है, और बिना डिफ़ॉल्ट वाला feature आवश्यक के रूप में चिह्नित होता है); उस metadata के लिए जांच के निष्कर्ष उसके नीचे दिखते हैं; निकालें उसे हटा देता है। हर बदलाव एक ही बार पूर्ववत करके वापस लिया जा सकता है। मानक लाइब्रेरी का और Holarch का अपना metadata (सिमुलेशन, objectives, variability) अपने नियंत्रण रखता है और वहाँ सूचीबद्ध नहीं होता।

इंडिविजुअल, स्नैपशॉट और टाइम स्लाइस

individual अपने पूरे जीवन में एक विशेष चीज़ है, जैसे अपने सीरियल नंबर वाली एक कार, न कि किसी प्रकार की चीज़। snapshot उस चीज़ का एक क्षण है; time slice उसके जीवन की एक अवधि है। दोनों उस occurrence के हैं जिसका उन पर स्वामित्व है और उनमें उसके features होते हैं, इसलिए वे उन features को अपने मान दे सकते हैं।

individual part def Car_VIN1234 :> Car {
    snapshot atDelivery { attribute :>> mileage = 0 [km]; }
    timeslice firstOwner { attribute ownerName : String = "Dana Reyes"; }
    snapshot atService { attribute :>> mileage = 15000 [km]; }
    first atDelivery then atService;
    assert constraint mileageGrows { atDelivery.mileage <= atService.mileage }
}
  • individual प्रकार keyword से पहले आता है (individual part def, individual item def) या अकेला आता है (individual def Plate_77;)। individual लिखा गया usage ठीक एक individual definition से टाइप होता है: individual car1 : Car_VIN1234;।
  • snapshot और timeslice किसी प्रकार keyword से पहले या अकेले आते हैं, किसी part, item, action या अन्य occurrence के अंदर। then timeslice secondOwner; एक time slice को उससे पहले वाले सदस्य के बाद रखता है।
  • snapshot या time slice के अंदर का मान पहले वहीं पढ़ा जाता है, फिर individual से, फिर उसकी definition से। उदाहरण में, atService.mileage 15,000 km है और constraint लागू होती है।
  • केवल occurrences ही individuals, snapshots या time slices हो सकते हैं: attributes और enumerations मान हैं।
  • आर्किटेक्चर → पार्ट, डेटाबेस और ग्रिड व्यू में, इंस्टेंस कॉलम हर part की definition के individuals सूचीबद्ध करता है (part sedan : Car के लिए: Car_VIN1234): उसे specialize करने वाली individual definitions और उससे टाइप होने वाले individual usages। Individual (हाँ) और भाग (स्नैपशॉट या टाइम स्लाइस) भी कॉलम हैं (कॉलम ▾ → SysML v2)। मॉडल में कोई individual होते ही पार्ट डिफ़ॉल्ट रूप से इंस्टेंस दिखाता है, और तब Table (CSV) निर्यात में तीनों कॉलम शामिल होते हैं; डेफ़िनिशन निर्यात उन्हें हर उस एलिमेंट के लिए सूचीबद्ध करता है जिसमें वे हैं।
  • इंस्पेक्टर में, Features के नीचे ऑकरेंस Individual तय करता है और, usages के लिए, पूरा जीवन, टाइम स्लाइस या स्नैपशॉट। ब्राउज़र के प्रकार फ़िल्टर में Individual है, और किसी पंक्ति के ⋯ मेनू में नया स्नैपशॉट… और नया टाइम स्लाइस… हैं। General View बॉक्स हेडर में «individual part def», «snapshot» और «timeslice» दिखाता है, किसी बॉक्स के snapshots और time slices को उनके अपने कम्पार्टमेंट में सूचीबद्ध करता है, और बॉक्स के बीच successions को डैश वाले तीरों के रूप में ड्रॉ करता है; व्यवस्थित करें ▾ → टाइमलाइन के रूप में व्यवस्थित करें उन्हें बाएं से दाएं पंक्ति में लगाता है। Hybrid Car डेमो में, General View carLifeline Car_VIN1234 के snapshots और time slice दिखाता है।

Variations, variants और configurations

variation किसी डिज़ाइन के एक बिंदु पर अनुमत विकल्पों को सूचीबद्ध करता है; हर विकल्प एक variant है। एक variation definition (variation part def) विकल्पों का पुन: उपयोग योग्य समूह है; एक variation usage (variation part charger) एक डिज़ाइन के अंदर एक बिंदु है। एक configuration हर बिंदु के लिए एक variant चुनता है।

variation part def BatteryPack :> Battery {
  variant part standardPack { attribute :>> capacity = 1.4 [kW*h]; }
  variant part largePack { attribute :>> capacity = 12 [kW*h]; }
}
part def CarLine :> Car {
  part pack : BatteryPack;
  variation part charger : Component {
    variant part noCharger;
    variant part wallbox;
  }
  assert constraint wallboxNeedsLargePack { charger == charger::wallbox implies pack == BatteryPack::largePack }
}
part plugInHybrid : CarLine {
  @HolarchConfiguration;
  part :>> pack = BatteryPack::largePack;
  part :>> charger = charger::wallbox;
}
  • एक variant में उसके variation के features होते हैं और वह उन्हें redefine कर सकता है: largePack में capacity है क्योंकि BatteryPack एक Battery है।
  • प्रकार keyword के बिना variant x; मौजूदा usage x को विकल्पों में से एक बनाता है; इसका नाम x के नाम पर होता है।
  • एक variation के स्वामित्व में केवल variants होते हैं (और definitions, टिप्पणियां, metadata और imports)। variation पहले से abstract है, इसलिए उस पर abstract को अनावश्यक के रूप में नोट किया जाता है।
  • किसी मान के साथ variant चुनें: part :>> pack = BatteryPack::largePack;। ऐसा विकल्प जो उस बिंदु का variant नहीं है, त्रुटि है।
  • जब तक किसी बिंदु का कोई विकल्प नहीं है, उसका मान अज्ञात है, इसलिए उस पर कोई assertion न पूरा होता है न उल्लंघित। किसी configuration में चुने गए variants के मान उपयोग होते हैं।
  • किसी configuration को @HolarchConfiguration से चिह्नित करें (पैकेज HolarchVariability, मानक लाइब्रेरी में Holarch के नीचे): तब एडिटर हर उस बिंदु को नोट करता है जिसे उसने अभी नहीं चुना है।
  • एडिटर में, डालें ▾ इनमें से हर एक लिखता है: वेरिएशन (पैकेज स्तर पर एक definition, किसी part के अंदर एक बिंदु), वेरिएंट (किसी variation के अंदर), कॉन्फ़िगरेशन और वेरिएंट विकल्प (किसी configuration के अंदर)।
  • Hybrid Car डेमो में, CarLine के दो बिंदु हैं (pack और charger), और selfChargingHybrid और plugInHybrid उसके configurations हैं; assertion मानक पैक के साथ वॉलबॉक्स को बाहर कर देता है।

टेक्स्ट निरूपण

textual representation किसी एलिमेंट को दूसरी भाषा में लिखता है: एलिमेंट की बॉडी के अंदर rep language "Python" /* … */। बॉडी टेक्स्ट के रूप में रखी जाती है। मॉडल वही है जो उसके चारों ओर का SysML घोषित करता है; Holarch कभी बॉडी नहीं चलाता।

  • Hybrid Car डेमो में, DriveWheels अपनी गणना Python में रखता है: rep language "Python" /* wheel_speed = torque.value * GEAR_RATIOS[gear] / WHEEL_RADIUS */।
  • "sysml" या "kerml" में लिखी बॉडी की जांच होती है। SpeedLimit को rep language "sysml" /* speed <= limit */ के रूप में लिखा गया है, और Holarch इसे सीधे लिखी गई constraint की तरह मूल्यांकित करता है।
  • एडिटर SysML और KerML बॉडी को रंगीन पृष्ठभूमि पर कोड के रूप में हाइलाइट करता है। दूसरी भाषाएं टिप्पणी टेक्स्ट के रूप में दिखती हैं।
  • इंस्पेक्टर का प्रस्तुति सेक्शन हर representation को उसकी भाषा और बॉडी के साथ सूचीबद्ध करता है। जोड़ने के लिए किसी definition या usage पर प्रतिनिधित्व जोड़ें पर क्लिक करें, और हटाने के लिए निकालें पर।
  • Action Flow View ऐसे action को, जिसकी definition में representation है, ब्रेस में उसकी भाषा से चिह्नित करता है, जैसे {Python}।
  • ज्ञात भाषाएं: SysML, KerML, OCL, Alf, Python, JavaScript, MATLAB, Modelica, C, प्राकृतिक भाषा (naturalLanguage, English, text)। नाम के बाद का संस्करण अनदेखा किया जाता है (OCL2.0, Python 3)।
  • बॉडी में */ नहीं हो सकता, क्योंकि वह टिप्पणी को समाप्त कर देगा।

Holarch की अपनी चर्चा टिप्पणियां, लेबल, असाइनी और नियत तिथियां मॉडल के साथ रखी जाती हैं। वे टेक्स्ट में नहीं लिखी जातीं।

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

एक संरचना मॉडल करें

  1. एडिटर में एक पैकेज खोलें (या + नया पैकेज पर क्लिक करें)।
  2. हर प्रकार के कनेक्शन बिंदु के लिए दिशा वाले features (out attribute torque : TorqueValue;) के साथ एक port def लिखें।
  3. हर प्रकार के घटक के लिए उसके attributes और ports के साथ एक part def लिखें।
  4. असेंबली के लिए एक part def लिखें, जिसमें हर घटक के लिए एक part हो।
  5. parts को जोड़ें: connect a.p to b.q;, या interface name : Def connect a.p to b.q;।
  6. रुकें। स्थिति पंक्ति लागू किया गया दिखाती है और ब्राउज़र नए एलिमेंट दिखाता है।

डालें ▾ (या ⌃⇧Space / Ctrl+Shift+Space) इनमें से हर संरचना आपके लिए भरने वाले फ़ील्ड के साथ लिखता है। देखें संरचना डालें।

इकाइयों के साथ मान दें

  1. पैकेज के शीर्ष पर मात्रा प्रकार और इकाइयां आयात करें: private import ISQ::*; और private import SI::*;।
  2. attribute को मात्रा प्रकार से टाइप करें और मान दें: attribute mass : MassValue = 45 [kg];।
  3. जो definition attribute विरासत में पाती है, उसमें उसे उसके अपने मान के साथ redefine करें: attribute redefines mass = 18 [kg];।
  4. मान पर पॉइंटर ले जाएं। अगर इकाई मात्रा प्रकार से मेल नहीं खाती, तो एक त्रुटि कार्ड दिखता है।

व्यवहार का वर्णन करें

  1. उसके in और out पैरामीटर के साथ एक action def लिखें।
  2. हर action usage के लिए एक चरण जोड़ें और उन्हें first … then …; या then से क्रमबद्ध करें।
  3. समानांतर चरणों के लिए fork और join, विकल्पों के लिए decide और merge का उपयोग करें।
  4. items पास करने वाले चरणों के बीच flow of Item from a.out to b.in; जोड़ें।
  5. जो part व्यवहार करता है, उसमें perform action name : Def; लिखें और, उसके parts में, perform name.step;।
  6. action को ड्रॉ किया हुआ देखने के लिए उसे Action Flow View में खोलें (देखें SysML v2 व्यू)।

एक requirement लिखें और उसे ट्रेस करें

  1. requirement <'ID'> name { doc /* The system shall … */ subject s : Def; } लिखें।
  2. जब requirement को मानों के विरुद्ध जांचा जा सकता हो, तो require constraint { … } जोड़ें।
  3. जहाँ डिज़ाइन उसे पूरा करता है, वहाँ satisfy name by somePart; लिखें।
  4. एक verification लिखें जिसका objective उसे verify करे।
  5. ज़रूरतें और आवश्यकताएं → आवश्यकताएं खोलें: requirement अपनी संख्या के साथ सूचीबद्ध है, और सत्यापन → RVTM दिखाता है कि उसका सत्यापन कैसे होता है। देखें SysML v2 प्रोजेक्ट में आवश्यकताएं और सत्यापन।

किसी मान को TBD या TBR के रूप में चिह्नित करें

किसी मान की जगह TBD लिखना मान्य SysML नहीं है। इसके बजाय Holarch का metadata उपयोग करें।

  1. इसे आयात करें: private import HolarchMetadata::*;।
  2. attribute के आगे उपसर्ग लगाएं: #TBD attribute chargerPower : PowerValue; (अभी कोई मान नहीं) या #TBR attribute limit : TimeValue = 0.5 [h]; (समीक्षा के लिए एक मान)।
  3. स्वामी और कारण दर्ज करने के लिए attribute की बॉडी में लंबा रूप लिखें: @TBD { owner = "Powertrain lead"; rationale = "The charging standard is not chosen yet."; due = "2026-12-01"; }।

TBD/TBR रजिस्टर इन मानों को सूचीबद्ध करता है। TBD और TBR ModelingMetadata::StatusInfo को specialize करते हैं, इसलिए दूसरे SysML v2 टूल उन्हें स्थिति टिप्पणियों के रूप में पढ़ते हैं। डालें ▾ → TBD मान और TBR मान उन्हें आपके लिए लिखते हैं।

लाइब्रेरी का कोई नाम खोजें

  1. रेल टूल से मानक लाइब्रेरी खोलें।
  2. पैकेज या परिभाषा खोजें… में नाम का हिस्सा टाइप करें, उदाहरण के लिए MassValue।
  3. पंक्ति पर नाम कॉपी करें पर क्लिक करें। योग्य नाम, यहाँ ISQBase::MassValue, कॉपी हो जाता है।
  4. इसे एडिटर में पेस्ट करें, या इसका पैकेज आयात करें और छोटा नाम उपयोग करें।

हल किया गया उदाहरण: सेडान की requirement पढ़ें

यह उदाहरण Hybrid Car डेमो के टेक्स्ट में एक requirement का अनुसरण करता है।

  1. डेमो खोलें और एडिटर की पैकेज सूची में VehicleRequirements चुनें।
  2. requirement def <'VR-1'> CurbMass खोजें। इसकी require constraint { car.curbMass <= limit } subject के कर्ब मास की तुलना limit से करती है।
  3. requirement carSpec खोजें। इसमें requirement <'VR-1.1'> sedanMass : CurbMass { attribute :>> limit = maxCurbMass; } है। यह usage पैकेज-स्तर के लक्ष्य maxCurbMass = 1650 [kg] के साथ limit को redefine करता है।
  4. satisfy carSpec by fleet.sedan; खोजें। sedan पर ⌘ / Ctrl-क्लिक करें: एडिटर Vehicles को part sedan : Car पर खोलता है, जहाँ attribute redefines curbMass = 1580 [kg]; मान देता है।
  5. VehicleRequirements में वापस आकर verification def CurbMassTest खोजें। इसका objective verify carSpec.sedanMass; इसे VR-1.1 का verification case बनाता है, और verification sedanWeighing : CurbMassTest { subject car = fleet.sedan; } इसे सेडान पर लागू करता है।
  6. Vehicles में 1580 [kg] को 1700 [kg] में बदलें और रुकें। सेडान अब 1650 kg की सीमा पार करती है, और एडिटर VehicleRequirements में एक चेतावनी दिखाता है कि sedan requirement पूरी नहीं करती, साथ में असत्य constraint और उसके मान। ⌘Z / Ctrl+Z से पूर्ववत करें।

सुझाव और आम ग़लतियां

  • “…” is not defined here. (“…” यहाँ परिभाषित नहीं है।) नाम की वर्तनी गलत है या उसका पैकेज आयात नहीं किया गया है। private import Package::*; जोड़ें, या योग्य नाम लिखें।
  • छूटा हुआ ;। हर घोषणा ; या { … } बॉडी से समाप्त होती है। The declaration does not end. Add ; or a { … } body. (घोषणा समाप्त नहीं होती।)
  • :> बनाम :>>। specialize या subset करने के लिए :> का उपयोग करें; विरासत में मिले feature को बदलने के लिए :>> का। ऐसे feature को redefine करने पर जो विरासत में नहीं मिला, संदेश आता है: “x” is not inherited by “y”. (“x” “y” को विरासत में नहीं मिला है।)
  • इकाइयों को imports चाहिए। 5 [kg] केवल वहाँ हल होता है जहाँ SI दिखाई देता है।
  • एक नाम वाले दो सदस्य। “x” is already used in this namespace. (“x” इस namespace में पहले से उपयोग में है।) एक का नाम बदलें; variant इसके बजाय redefine करता है।
  • objective के बाहर verify। इसे किसी verification case के objective { verify R; } में रखें।
  • नामों के रूप में keywords। part, state या action जैसे शब्द आरक्षित हैं। उन्हें उद्धरण में रखें ('state') या कोई दूसरा नाम चुनें।

Holarch क्या समर्थित करता है

Holarch, SysML v2 टेक्स्ट संकेतन के निम्नलिखित हिस्सों का समर्थन करता है। एडिटर इन सबकी जांच करता है, और मॉडल इन्हें रखता है।

क्षेत्रसमर्थित
Packages और namespacespackage, नेस्टेड पैकेज, library package (केवल पढ़ने के लिए), doc, comment … about, नोट // और //* */, alias … for …, public/private/protected, छोटे नाम <'1.2'>, उद्धरण वाले नाम
Importsmembership और namespace imports, ::*, रिकर्सिव ::**, फ़िल्टर किए गए imports [@Kind]
Definitions और usagespart, attribute, item, port, connection, interface, flow, action, state, requirement, constraint, calc, use case, analysis, verification, view, viewpoint, concern, enum, occurrence, allocation, metadata; ref, abstract, in/out/inout, end
Specialization:>/specializes, :/defined by, :>/subsets, :>>/redefines, conjugation ~, disjoint, feature chains a.b.c
Multiplicities[n], [n..m], [*], [0..*], ordered, nonunique, सीमाओं के रूप में व्यंजक
मान और इकाइयां=, :=, default, मात्राएं 5 [kg], इकाई व्यंजक [m/s^2], मानक लाइब्रेरी के ISQ मात्रा प्रकार और SI तथा US customary इकाइयां, आयाम जांच
संरचनाports और conjugated ports, connect, ends वाले interfaces, multiplicities वाले नामित connector ends, bind, flow of T from … to …, message
एक्शनपैरामीटर, perform, successions (first … then …, then), fork, join, decide, merge, guards, accept, send, assign, if, while, for, loop, start, done, terminate
स्टेटentry/do/exit, trigger, guard और effect वाले transitions, parallel states, नेस्टेड states, exhibit
आवश्यकताएंsubject, actor, stakeholder, require constraint, assume constraint, frame concern, satisfy … by …, verify, id के रूप में छोटे नाम, requirement टेक्स्ट के रूप में doc
कंस्ट्रेंट और कैलकुलेशनconstraint और calc definitions और usages, return, assert constraint, कॉल, अंकगणित, तुलना, तर्क, if ? else और sequence ऑपरेशन वाले KerML व्यंजक, इकाइयों के साथ मूल्यांकन
Use cases, विश्लेषण और सत्यापनsubject, actor, objective, include use case, return परिणाम वाले analysis cases, verify और एक verdict वाले verification cases
व्यूview, view def, expose (::*, ::** और फ़िल्टर के साथ), filter, viewpoint, frame, render, मानक view definitions
आवंटन और ट्रेसallocate a to b, allocation definitions, dependency from … to …
Individualindividual definitions और usages, snapshot और timeslice (then के बाद भी), उनके मान और successions
वेरिएबिलिटीvariation definitions और usages, variant सदस्य और variant संदर्भ (variant x;), मान द्वारा विकल्प, @HolarchConfiguration (HolarchVariability) से चिह्नित configurations
Metadata@Name { … }, #Name उपसर्ग, metadata Name about …, Holarch के HolarchMetadata (TBD, TBR) और HolarchFrameworks पैकेज; उपयोगकर्ता-परिभाषित metadata def; उपयोगकर्ता-परिभाषित keywords और semantic metadata (#fault def …)

लिखे अनुसार रखा गया, व्याख्या नहीं की गई

Holarch इन संरचनाओं को ठीक वैसे ही पढ़ता और रखता है जैसे लिखी गई हैं, लेकिन उन्हें अपना कोई अर्थ नहीं देता:

  • SysML और KerML के अलावा दूसरी भाषाओं में textual representations (टेक्स्ट के रूप में रखे जाते हैं; देखें Textual representations)।

अभी उपलब्ध नहीं

  • KerML फ़ाइलें (.kerml) आयात करना।
  • Systems Modeling API के ज़रिए main में कमिट, टैग और मर्ज: दूसरे टूल परिवर्तन अनुरोध ब्रांच में कमिट करते हैं, जिन्हें कोई अनुमोदक Holarch में लागू करता है (देखें SysML v2 प्रोजेक्ट में API और MCP)।
  • उपयोगकर्ता-परिभाषित keywords और semantic metadata से आगे के भाषा विस्तार।

जांचें

Holarch टाइप करते समय टेक्स्ट की जांच करता है। हर समस्या एडिटर के गटर में चिह्नित और रेखांकित होती है; संदेश पहले समस्या बताता है, फिर समाधान। त्रुटियां किसी सदस्य को लागू होने से रोकती हैं; चेतावनियां नहीं।

क्षेत्रक्या जांचा जाता हैउदाहरण संदेश
सिंटैक्सअक्षर, टिप्पणियां, strings, ब्रेस, ;, अपेक्षित नाम और टोकनThis brace has no partner. Add the matching { or }, or delete this one. (इस ब्रेस का कोई जोड़ीदार नहीं है।)
नामअनसुलझे, अस्पष्ट, अमान्य, दोहराए गए (चेतावनी) और private नाम“Batery” is not defined here. Check the spelling, or import its package. (“Batery” यहाँ परिभाषित नहीं है।)
टाइपिंग और specializationचक्र; सही प्रकार की definition से टाइप और specialize करना; features का subset और redefine करना; केवल विरासत में मिले features का redefinition“capacity” is not inherited by “Car”. Specialize its type, or subset it with :> instead. (“capacity” “Car” को विरासत में नहीं मिला है।)
Multiplicitiesमान्य और पूर्ण-संख्या सीमाएं; ऐसा redefinition जो उससे चौड़ा न हो जिसे वह redefine करता हैMultiplicity [3..1] is not valid. Use a lower bound from 0 up to the upper bound. (Multiplicity [3..1] मान्य नहीं है।)
इकाइयां और मानमेल खाते आयाम, छूटी इकाइयां, इकाई नाम, संख्या प्रकारThe units do not match: kg and s. Convert one side to a compatible unit. (इकाइयां मेल नहीं खातीं।)
व्यंजकसिंटैक्स, operand प्रकार, calculation arguments, Boolean शर्तेंThe condition must be true or false; it is a number. Write a comparison such as x > 0. (शर्त true या false होनी चाहिए।)
संरचनाconnection ends features होते हैं, interfaces ports को जोड़ते हैं, port, flow और message की दिशाएं, flow item प्रकार, binding प्रकारThese port directions do not fit together. Conjugate one port (~) or change a direction. (ये port दिशाएं आपस में मेल नहीं खातीं।)
एक्शनएक ही बॉडी के actions के बीच successions, control node की in/out गिनती, decision guards और else, start और done, assignments, perform लक्ष्य, वे मान जिन पर for लूप चलता है, लूप वेरिएबल के प्रकार के विरुद्धthen needs an earlier action. Add an action or first … then …. (then को पहले के action की ज़रूरत है।)
स्टेटएक ही बॉडी की states के बीच transitions, हर एक में एक entry/do/exit, प्रारंभिक transitions, parallel regions, exhibit लक्ष्य, किसी transition का do effect (ऐसी चीज़ को send जो प्राप्त कर सके, assign, accept, action या कोई नामित action), किसी trigger का payload उसके port के items के विरुद्ध, Real जैसे सादे लाइब्रेरी मान पर trigger (चेतावनी), समय बताने वाले at triggers“electric” has substates but no initial transition, so none of them is entered. Add entry; then <first state>;. (“electric” में substates हैं लेकिन कोई प्रारंभिक transition नहीं है।)
Requirements, cases और व्यूसही जगह पर सदस्य, एक subject, satisfy/verify/require लक्ष्य, subject प्रकार, expose और import लक्ष्य, frame लक्ष्यverify belongs in the objective of a verification case. Move it into objective { … }. (verify किसी verification case के objective में होता है।)
टेक्स्ट निरूपणSysML और KerML बॉडी पार्स होती हैं, और उस एलिमेंट को घोषित करती हैं जिसका वे प्रतिनिधित्व करती हैं; अज्ञात भाषाएं नोट की जाती हैंThe representation of “SpeedLimit” declares a part definition, not a constraint definition. Make the body declare “SpeedLimit” itself. (“SpeedLimit” का representation constraint definition नहीं, part definition घोषित करता है।)
इंडिविजुअल, स्नैपशॉट और टाइम स्लाइसindividual केवल occurrences पर और ठीक एक individual definition के साथ; snapshot/timeslice केवल किसी occurrence के अंदर occurrence usages पर; snapshot के अंदर time slice (चेतावनी)“parked” is individual, but none of its definitions is. Type it by an individual definition, or remove individual. (“parked” individual है, लेकिन उसकी कोई definition individual नहीं है।)
वेरिएबिलिटीvariation के स्वामित्व में केवल variants होते हैं; variant किसी variation में होता है और उसी प्रकार का होता है; विकल्प अपने बिंदु का variant होता है; variation पर abstract अनावश्यक है (नोट); किसी configuration के खुले बिंदु (नोट)“compact” is not a variant of “pack”. Choose one of: standardPack, largePack. (“compact” “pack” का variant नहीं है।)
उपयोगकर्ता-परिभाषित keywords#Name किसी metadata definition का नाम लेता है; भाषा keyword के बिना घोषणा semantic metadata उपयोग करती है (चेतावनी); metadata केवल उन्हीं प्रकारों को चिह्नित करता है जिनकी उसका annotatedElement अनुमति देता है; semantic base type एक definition या usage होता है, जिस एलिमेंट को चिह्नित करता है उसमें फ़िट होता है (चेतावनी) और कोई चक्र नहीं बनाता“safetyCritical” applies to PartDefinition, not to “invert” (ActionUsage). Move it, or remove it. (“safetyCritical” PartDefinition पर लागू होता है, “invert” पर नहीं।)
Metadata मानउपयोगकर्ता-परिभाषित metadata definition के हर आवश्यक feature को मान मिलता है (चेतावनी); हर मान और डिफ़ॉल्ट अपने feature के प्रकार (Boolean, String, पूर्ण संख्याएं, enumerations) में फ़िट होता है; दिए गए मानों पर definition की constraints लागू होती हैं; metadata बॉडी केवल definition के features को redefine करती है; abstract metadata definitions लागू नहीं की जातीं; about के साथ लिखा semantic metadata (चेतावनी)The values of “SafetyRating” break its constraint levelRange: level >= 1 and level <= 4. Change the values. (“SafetyRating” के मान उसकी constraint levelRange तोड़ते हैं।)
मूल्यांकनConstraints, requirements और objectives जो मौजूदा मानों पर लागू नहीं होते“sedanMass” is not met by “sedan”: … is false (…). Change the design values or the requirement. (“sedan” “sedanMass” को पूरा नहीं करता।)

मानक लाइब्रेरी

मानक लाइब्रेरी पेज उन पैकेज और definitions को सूचीबद्ध करता है जिनका उपयोग हर SysML v2 प्रोजेक्ट कर सकता है: मान और इकाइयां, मात्राएं, parts, ports, actions, states, requirements, विश्लेषण और भी बहुत कुछ। यह केवल पढ़ने के लिए है।

  • रेल टूल में सेटिंग्स → मानक लाइब्रेरी से इसे खोलें। LML प्रोजेक्ट में यह नहीं होती।
  • फ़ोल्डर। बाईं ओर लाइब्रेरी फ़ाइलें फ़ोल्डर के अनुसार सूचीबद्ध हैं: Kernel Libraries, Systems Library, Domain Libraries (Analysis, Cause and Effect, Geometry, Metadata, Quantities and Units, Requirement Derivation) और Holarch (TBD और TBR वाला HolarchMetadata पैकेज, HolarchConfiguration वाला HolarchVariability, और Objective वाला HolarchRequirements)।
  • एक फ़ाइल। किसी फ़ाइल को चुनकर उसके पैकेज देखें, हर एक अपने दस्तावेज़ीकरण और अपनी definitions की तालिका के साथ: नाम, प्रकार और दस्तावेज़ीकरण।
  • खोजें। हर फ़ाइल के नाम और दस्तावेज़ीकरण में खोजने के लिए पैकेज या परिभाषा खोजें… में टाइप करें। परिणाम फ़ाइल दिखाते हैं; उस फ़ाइल को खोलने के लिए उस पर क्लिक करें। साफ़ करने के लिए Esc दबाएं।
  • नाम कॉपी करें किसी एलिमेंट का योग्य नाम, जैसे ISQ::MassValue, एडिटर में उपयोग के लिए कॉपी करता है।
  • टेक्स्ट दिखाएं लाइब्रेरी फ़ाइल को लिखे अनुसार दिखाता है; परिभाषाएं दिखाएं तालिकाओं पर लौटता है।

यह लाइब्रेरी SysML v2 रिलीज़ लाइब्रेरी है, एक सुधार के साथ: एक tonne (alias 'metric ton') 1000 kg में बदलता है; रिलीज़ फ़ाइल 0.001 kg कहती है। आपका मॉडल इसे नाम से संदर्भित करता है; यह प्रोजेक्ट में कॉपी नहीं होती, और .sysml निर्यात का हिस्सा नहीं है।

सीमाएं

  • 8 MB से बड़े टेक्स्ट दस्तावेज़ की जांच नहीं होती: This text is larger than 8 MB and is not checked. Split it into several packages. (यह टेक्स्ट 8 MB से बड़ा है और इसकी जांच नहीं होती।)
  • 64 KB से लंबी पंक्ति की जांच नहीं होती।
  • 256 स्तरों से गहरी नेस्टिंग की जांच नहीं होती।
  • मानक लाइब्रेरी संपादित नहीं की जा सकती।

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