diff --git a/.gitignore b/.gitignore index e970233..ab39fdf 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,55 @@ -.project \ No newline at end of file +.project +.metadata/.lock +.metadata/.lock_info +.metadata/.log +.metadata/version.ini +.metadata/.mylyn/.tasks.xml.zip +.metadata/.mylyn/repositories.xml.zip +.metadata/.mylyn/tasks.xml.zip +.metadata/.mylyn/.taskListIndex/segments_1 +.metadata/.mylyn/.taskListIndex/write.lock +.metadata/.plugins/org.eclipse.buildship.core/gradle/versions.json +.metadata/.plugins/org.eclipse.core.resources/0.snap +.metadata/.plugins/org.eclipse.core.resources/.projects/.org.eclipse.egit.core.cmp/.location +.metadata/.plugins/org.eclipse.core.resources/.projects/.org.eclipse.egit.core.cmp/.markers.snap +.metadata/.plugins/org.eclipse.core.resources/.projects/.org.eclipse.egit.core.cmp/.syncinfo.snap +.metadata/.plugins/org.eclipse.core.resources/.root/.markers.snap +.metadata/.plugins/org.eclipse.core.resources/.root/.indexes/properties.index +.metadata/.plugins/org.eclipse.core.resources/.safetable/org.eclipse.core.resources +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.core.resources.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jdt.ui.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jsch.core.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.mylyn.context.core.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.mylyn.monitor.ui.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.mylyn.tasks.ui.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.ui.prefs +.metadata/.plugins/org.eclipse.e4.workbench/workbench.xmi +.metadata/.plugins/org.eclipse.egit.core/.org.eclipse.egit.core.cmp/.settings/org.eclipse.core.resources.prefs +.metadata/.plugins/org.eclipse.jdt.core/variablesAndContainers.dat +.metadata/.plugins/org.eclipse.m2e.core/workspaceState.ser +.metadata/.plugins/org.eclipse.m2e.logback/0.log +.metadata/.plugins/org.eclipse.m2e.logback/logback.2.7.0.20241001-1350.xml +.metadata/.plugins/org.eclipse.oomph.setup/workspace.setup +.metadata/.plugins/org.eclipse.ui.intro/introstate +.metadata/.plugins/org.eclipse.ui.workbench/workingsets.xml +.metadata/.plugins/org.eclipse.wildwebdeveloper.xml/system-catalog.xml +.metadata/.plugins/org.eclipse.core.resources/.root/1.tree +.metadata/.plugins/org.eclipse.core.resources/.root/.indexes/history.version +.metadata/.plugins/org.eclipse.core.resources/.root/.indexes/properties.version +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.debug.ui.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.m2e.discovery.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.ui.ide.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.ui.navigator.prefs +.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.ui.workbench.prefs +.metadata/.plugins/org.eclipse.jdt.core/assumedExternalFilesCache +.metadata/.plugins/org.eclipse.jdt.core/externalFilesCache +.metadata/.plugins/org.eclipse.jdt.core/javaLikeNames.txt +.metadata/.plugins/org.eclipse.jdt.core/nonChainingJarsCache +.metadata/.plugins/org.eclipse.jdt.ui/dialog_settings.xml +.metadata/.plugins/org.eclipse.jdt.ui/OpenTypeHistory.xml +.metadata/.plugins/org.eclipse.jdt.ui/QualifiedTypeNameHistory.xml +.metadata/.plugins/org.eclipse.mylyn.github.ui/avatars.ser +.metadata/.plugins/org.eclipse.tips.ide/dialog_settings.xml +.metadata/.plugins/org.eclipse.ui.editors/dialog_settings.xml +.metadata/.plugins/org.eclipse.ui.ide/dialog_settings.xml +.metadata/.plugins/org.eclipse.ui.workbench/dialog_settings.xml diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/AnalysisProblemSpace.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/AnalysisProblemSpace.sysml index c234bf1..28d8608 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/AnalysisProblemSpace.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/AnalysisProblemSpace.sysml @@ -4,14 +4,14 @@ package analysisProblemSpace { private import ScalarValues::*; private import ISQ::*; private import SI::*; - private import Domain::*; - private import MiningFrigate::*; + private import DomainPackage::*; + private import MiningFrigatePackage::*; private import BusinessRequirements::BUS01_1; // **General Analysis Definition: Risk-Adjusted Profitability Calculation** analysis def RiskAdjustedProfitability { - subject miningcorporation : Domain::MiningCorporation; + subject miningcorporation : MiningCorporation; objective { doc /* Evaluates profitability across different security zones (High Sec, Low Sec, Null Sec) @@ -112,7 +112,7 @@ package analysisProblemSpace { in operationalCosts = 200000.0; // ISK/hour (high cost due to logistics, security) in survivalProbability = 50.0; // Very high risk, frequent losses } - part analysisMiningCorporation : Domain::MiningCorporation ; + part analysisMiningCorporation : MiningCorporation ; satisfy BUS01_1 by analysisMiningCorporation; } diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/BusinessCaseOpsCon.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/BusinessCaseOpsCon.sysml index 889f66a..11ba8f5 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/BusinessCaseOpsCon.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/BusinessCaseOpsCon.sysml @@ -35,7 +35,7 @@ package ConceptOfOperations { } package BusinessRequirements { - private import Domain::*; + private import DomainPackage::MiningCorporation; private import ScalarValues::*; private import StakeholderConcerns::*; @@ -44,14 +44,14 @@ package BusinessRequirements { doc /* The mining organization shall guarantee a profitability of 25.000 ISK/hour in order to provide * suficcient incentive to pilots to work for the corporation. */ - subject miningFCorporation : Domain::MiningCorporation; + subject miningFCorporation : MiningCorporation; attribute profitability : Real; require constraint { profitability >= 25000 } frame concern ProfitabilityConcern; } requirement profitabilityRequirement : ProfitabilityRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> profitability = miningCorporation.minimumProfit ; } } \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/Concerns.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/Concerns.sysml index 206c315..6ee2757 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/Concerns.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/Concerns.sysml @@ -30,14 +30,15 @@ package StakeholderConcerns { private import ScalarValues::*; private import ISQ::*; - private import Domain::*; + private import DomainPackage::MiningCorporation; private import StakeholdersDef::*; - private import MiningFrigate::*; + private import MiningFrigatePackage::*; + // The concerns are directly declared without definition, beacuse they aren't going to be reused in the scope of this model. // Concerns Derived from the Business Case - concern def ProfitabilityConcern { - subject miningCorporation : Domain::MiningCorporation; + concern ProfitabilityConcern { + subject miningCorporation : MiningCorporation; require constraint { doc /* The Mining Corporation shall ensure that mining operations generate sufficient ISK/hour @@ -47,8 +48,8 @@ package StakeholderConcerns { stakeholder miningCEO : MiningCEO; } - concern def OperationalCostsConcern { - subject miningCorporation : Domain::MiningCorporation; + concern OperationalCostsConcern { + subject miningCorporation : MiningCorporation; require constraint { doc /* The Mining Corporation shall minimize operational costs (e.g., ship replacements, @@ -58,8 +59,8 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def ScalabilityConcern { - subject miningCorporation : Domain::MiningCorporation; + concern ScalabilityConcern { + subject miningCorporation : MiningCorporation; assume constraint { doc /* The Mining Corporation assumes that mining operations can scale effectively with @@ -69,8 +70,8 @@ package StakeholderConcerns { stakeholder fleetCommander : FleetCommander; } - concern def MarketResponsivenessConcern { - subject miningCorporation : Domain::MiningCorporation; + concern MarketResponsivenessConcern { + subject miningCorporation : MiningCorporation; require constraint { doc /* The Mining Corporation shall adapt mining operations to fluctuating market demands @@ -82,8 +83,8 @@ package StakeholderConcerns { // Concerns Derived from the ConOps - concern def SecurityConcern { - subject miningFrigate : MiningFrigate::MiningFrigate; + concern SecurityConcern { + subject miningFrigate : MiningFrigate; require constraint { doc /* The Mining Frigate shall ensure safety and survivability in hostile environments @@ -94,8 +95,8 @@ package StakeholderConcerns { stakeholder shipEngineer : ShipEngineer; } - concern def ResourceAvailabilityConcern { - subject miningCorporation : Domain::MiningCorporation; + concern ResourceAvailabilityConcern { + subject miningCorporation : MiningCorporation; require constraint { doc /* The Mining Corporation shall ensure sufficient access to high-value asteroids, @@ -105,8 +106,8 @@ package StakeholderConcerns { stakeholder fleetCommander : FleetCommander; } - concern def DeploymentEfficiencyConcern { - subject miningFrigate : MiningFrigate::MiningFrigate; + concern DeploymentEfficiencyConcern { + subject miningFrigate : MiningFrigate; require constraint { doc /* The Mining Frigate shall ensure rapid and efficient movement between resource @@ -116,8 +117,8 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def ThreatNeutralizationConcern { - subject miningFrigate : MiningFrigate::MiningFrigate; + concern ThreatNeutralizationConcern { + subject miningFrigate : MiningFrigate; require constraint { doc /* The Mining Frigate shall mitigate risks from NPC pirates and hostile players @@ -130,8 +131,8 @@ package StakeholderConcerns { // Concerns Derived from the MoEs - concern def TotalProfitabilityConcern { - subject miningCorporation : Domain::MiningCorporation; + concern TotalProfitabilityConcern { + subject miningCorporation : MiningCorporation; require constraint { doc /* The Mining Corporation shall maximize the total ISK/hour generated from mining @@ -141,8 +142,8 @@ package StakeholderConcerns { stakeholder miningCEO : MiningCEO; } - concern def OreYieldConcern { - subject miningFrigate : MiningFrigate::MiningFrigate; + concern OreYieldConcern { + subject miningFrigate : MiningFrigate; require constraint { doc /* The Mining Frigate shall maximize ore yield per frigate or fleet while avoiding @@ -152,8 +153,8 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def SurvivabilityConcern { - subject miningFrigate : MiningFrigate::MiningFrigate; + concern SurvivabilityConcern { + subject miningFrigate : MiningFrigate; require constraint { doc /* The Mining Frigate shall ensure high survivability in hostile or dangerous environments. */ @@ -163,8 +164,8 @@ package StakeholderConcerns { stakeholder shipEngineer : ShipEngineer; } - concern def FleetDeploymentEfficiencyConcern { - subject miningCorporation : Domain::MiningCorporation; + concern FleetDeploymentEfficiencyConcern { + subject miningCorporation : MiningCorporation; require constraint { doc /* The Mining Corporation shall ensure optimal fleet deployment to maximize ore extraction @@ -175,8 +176,8 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def OreDeliveryEfficiencyConcern { - subject miningFrigate : MiningFrigate::MiningFrigate; + concern OreDeliveryEfficiencyConcern { + subject miningFrigate : MiningFrigate; require constraint { doc /* The Mining Frigate shall ensure fast and efficient transport of mined ore to stations @@ -186,8 +187,8 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def RiskAdjustedProfitabilityConcern { - subject miningCorporation : Domain::MiningCorporation; + concern RiskAdjustedProfitabilityConcern { + subject miningCorporation : MiningCorporation; require constraint { doc /* The Mining Corporation shall balance profitability with the risks of operating in @@ -198,4 +199,14 @@ package StakeholderConcerns { stakeholder fleetCommander : FleetCommander; } + //Viewpoints + viewpoint 'Operational profitability'{ + frame ProfitabilityConcern; + + require constraint { + doc /*TBD*/ + } + } + + } diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/Domain.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/Domain.sysml index b3c8610..25a726b 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/Domain.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/Domain.sysml @@ -1,11 +1,11 @@ -package Domain { +package DomainPackage { private import ScalarValues::*; private import ISQ::*; private import SI::*; private import ParametersOfInterestMetadata::*; private import OperationalUseCaseActions::*; - private import MiningFrigate::*; + private import MiningFrigatePackage::*; private import CauseAndEffect::*; private import CausationConnections::*; @@ -20,7 +20,9 @@ package Domain { part miningCorporation: MiningCorporation; part drone : Drone[1..*]; } - + part domain : Domain; + + // Definitions of domain objects part def Spaceship { #mop cargoCapacity : Real; // Maximum ore cargo capacity (m³) #mop survivalProbability : Real; // Probability of surviving an operation (%) @@ -33,8 +35,6 @@ package Domain { attribute dockingTime : Real; // seconds, the time required to dock and offload ore (STRQ08) attribute shieldStrength : Real ; //Strength of the core shield (STRQ03) } - - // Definitions of domain objects part def MiningCorporation { #moe minimumProfit : Real { @@ -77,7 +77,7 @@ package Domain { */ } // % - #moe fleetSizeEffectiveness : Real { + #moe fleetSizeEffectiveness : Integer { doc /* Definition: Measures how effectively fleet size contributes to mining efficiency. * Relevance: Avoids over-scaling, which could increase operational costs. * Optimization: Balance fleet size with profit margins, avoiding unnecessary ship deployment. @@ -126,31 +126,28 @@ package Domain { */ } // % - //exhibits a predefined state - part miningFrigate : MiningFrigate::MiningFrigate [1..*] { - exhibit MiningFrigate::miningFrigatesStates { - in miningFrigates = miningFrigate; - } + part miningFrigate : MiningFrigate [1..*]{ + // Cause and Effect Occurrences - event occurrence MiningRateIncreases; - event occurrence CargoCapacityIncreases; - event occurrence ShieldStrengthIncreases; - event occurrence ThreatDetectionImproves; - event occurrence DroneOperationsImprove; - event occurrence WarpSpeedIncreases; - event occurrence FleetCoordinationImproves; - - event occurrence OreYieldIncreases; - event occurrence DowntimeReduces; - event occurrence SurvivabilityEnhances; - event occurrence ThreatResponseImproves; - event occurrence OperationalEfficiencyIncreases; - event occurrence OreExtractionEfficiencyIncreases; - event occurrence ProfitabilityMaximizes; + timeslice miningRateIncreases; + timeslice cargoCapacityIncreases; + timeslice shieldStrengthIncreases; + timeslice threatDetectionImproves; + timeslice droneOperationsImprove; + timeslice warpSpeedIncreases; + } part rorqual : Rorqual [1..*]; ref part pilotPod : PilotPod [1..*] ; - part fleet : Fleet [1..*]; + part fleet : Fleet [1..*]{ + timeslice fleetCoordinationImproves; + timeslice downtimeReduces; + timeslice survivabilityEnhances; + timeslice threatResponseImproves; + timeslice operationalEfficiencyIncreases; + timeslice oreExtractionEfficiencyIncreases; + timeslice profitabilityMaximizes; + } //interactions at the enterprise level occurrence def MiningAsteroid { @@ -224,6 +221,7 @@ package Domain { part def Rorqual :> Spaceship { #mop oreStorageCapacity : Real; //Rorquals can tractor and store storage containers + attribute oreCompressionRatio : Real; part oreCompressionUnit : OreCompressionUnit; //Module used to compress Ores } @@ -241,6 +239,7 @@ package Domain { #mop oreContent : Real; // Quantity of ore available (m³) #mop depletionRate : Real; // Rate at which ore is extracted (m³/hour) port asteroidOrePort : AsteroidOrePort; + timeslice oreYieldIncreases; } part def HostileShip { @@ -287,7 +286,7 @@ package Domain { out item droneReport : DroneReport; } - // Interface definition + // Interfaces definition interface def CommandIF { end controlSend : PodPort; end controlReceive : ~PodPort; @@ -373,5 +372,16 @@ package Domain { item def ScanSignature { attribute type: String; attribute priority: String; - } + } + + //Views and views definition + view def 'Domain Structure View'{ + satisfy StakeholderConcerns::'Operational profitability'; + + filter @SysML::PartUsage; + } + view 'Mining Frigate structure Table View' : 'Domain Structure View' { + expose MiningCorporation::miningFrigate::*; + //render asElementTable; + } } \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDecl.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDecl.sysml index ac4dc73..eb078fa 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDecl.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDecl.sysml @@ -1,67 +1,67 @@ package MiningCorporationRequirementsDecl { - private import Domain::*; + private import DomainPackage::MiningCorporation; private import ScalarValues::*; private import MiningCorporationRequirementsDef::*; // **Mining Corporation Requirement Declarations** requirement profitabilityRequirement : ProfitabilityRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> minimumProfit = miningCorporation.minimumProfit; } requirement fleetUtilizationRequirement : FleetUtilizationRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> fleetUtilization = miningCorporation.fleetUtilization; } requirement oreExtractionRequirement : OreExtractionRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> oreExtractionRate = miningCorporation.oreExtractionEfficiency; } requirement oreDeliveryEfficiencyRequirement : OreDeliveryEfficiencyRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> oreDeliveryTime = miningCorporation.oreDeliveryEfficiency; } requirement storageCapacityRequirement : StorageCapacityRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> oreStorageCapacity = miningCorporation.storageCapacityUtilization; } requirement fleetSizeRequirement : FleetSizeRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> fleetSize = miningCorporation.fleetSizeEffectiveness; } requirement defenseCapabilityRequirement : DefenseCapabilityRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> securityEscortCoverage = miningCorporation.securityCoverageEffectiveness; } requirement threatResponseTimeRequirement : ThreatResponseTimeRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> threatResponseTime = miningCorporation.threatResponseEffectiveness; } requirement operationalUptimeRequirement : OperationalUptimeRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> operationalUptime = miningCorporation.operationalUptime; } requirement deploymentEfficiencyRequirement : DeploymentEfficiencyRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> deploymentEfficiency = miningCorporation.deploymentEfficiency; } requirement operationalCostControlRequirement : OperationalCostControlRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> operationalCosts = miningCorporation.costEfficiency; } requirement marketAdaptabilityRequirement : MarketAdaptabilityRequirement { - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute :>> marketAdaptability = miningCorporation.marketAdaptability; } } diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDef.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDef.sysml index a153493..81865d4 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDef.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/MiningCorporationRequirementsDef.sysml @@ -1,6 +1,6 @@ package MiningCorporationRequirementsDef { - private import Domain::*; + private import DomainPackage::MiningCorporation; private import ScalarValues::*; private import StakeholderConcerns::*; @@ -8,7 +8,7 @@ package MiningCorporationRequirementsDef { requirement def ProfitabilityRequirement { doc /* The mining corporation shall maintain an average profitability of at least 500M ISK per operational cycle, considering ore market value, operational costs, and risk-adjusted returns. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute minimumProfit : Real; require constraint { minimumProfit >= 500000000.0 } // ISK @@ -18,7 +18,7 @@ package MiningCorporationRequirementsDef { requirement def FleetUtilizationRequirement { doc /* The mining corporation shall maintain a fleet utilization rate of at least 80% to ensure high operational efficiency. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute fleetUtilization : Real; require constraint { fleetUtilization >= 80.0 } // % @@ -28,7 +28,7 @@ package MiningCorporationRequirementsDef { // **Resource Extraction and Logistics Requirements** requirement def OreExtractionRequirement { doc /* The mining corporation shall extract at least 1,000,000 m³ of ore per operational cycle. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute oreExtractionRate : Real; require constraint { oreExtractionRate >= 1000000.0 } // m³/cycle @@ -37,7 +37,7 @@ package MiningCorporationRequirementsDef { requirement def OreDeliveryEfficiencyRequirement { doc /* The mining corporation shall ensure an average ore delivery time of no more than 30 minutes per batch. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute oreDeliveryTime : Real; require constraint { oreDeliveryTime <= 1800.0 } // seconds @@ -46,7 +46,7 @@ package MiningCorporationRequirementsDef { requirement def StorageCapacityRequirement { doc /* The mining corporation shall maintain a minimum ore storage capacity of 10,000,000 m³ to accommodate mining operations. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute oreStorageCapacity : Real; require constraint { oreStorageCapacity >= 10000000.0 } // m³ @@ -56,7 +56,7 @@ package MiningCorporationRequirementsDef { // **Fleet and Security Requirements** requirement def FleetSizeRequirement { doc /* The mining corporation shall operate a fleet of at least 10 mining frigates per operational cycle. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute fleetSize : Integer; require constraint { fleetSize >= 10 } @@ -65,7 +65,7 @@ package MiningCorporationRequirementsDef { requirement def DefenseCapabilityRequirement { doc /* The mining corporation shall ensure that at least 30% of mining operations have security escort coverage in Low Sec and Null Sec. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute securityEscortCoverage : Real; require constraint { securityEscortCoverage >= 30.0 } // % @@ -74,7 +74,7 @@ package MiningCorporationRequirementsDef { requirement def ThreatResponseTimeRequirement { doc /* The mining corporation shall ensure that threat response time does not exceed 60 seconds in Low Sec and Null Sec. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute threatResponseTime : Real; require constraint { threatResponseTime <= 60.0 } // seconds @@ -84,7 +84,7 @@ package MiningCorporationRequirementsDef { // **Operational Uptime and Efficiency** requirement def OperationalUptimeRequirement { doc /* The mining corporation shall maintain an operational uptime of at least 85% per cycle. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute operationalUptime : Real; require constraint { operationalUptime >= 85.0 } // % @@ -93,7 +93,7 @@ package MiningCorporationRequirementsDef { requirement def DeploymentEfficiencyRequirement { doc /* The mining corporation shall ensure that at least 90% of planned mining deployments are executed successfully. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute deploymentEfficiency : Real; require constraint { deploymentEfficiency >= 90.0 } // % @@ -102,7 +102,7 @@ package MiningCorporationRequirementsDef { requirement def OperationalCostControlRequirement { doc /* The mining corporation shall minimize operational costs to improve long-term profitability. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute operationalCosts : Real; require constraint { operationalCosts <= 2000000000.0 } // ISK per month @@ -111,7 +111,7 @@ package MiningCorporationRequirementsDef { requirement def MarketAdaptabilityRequirement { doc /* The mining corporation shall adapt its mining operations based on fluctuating ore prices. */ - subject miningCorporation : Domain::MiningCorporation; + subject miningCorporation : MiningCorporation; attribute marketAdaptability : Real; require constraint { marketAdaptability >= 75.0 } // % diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigate.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigate.sysml index b45255c..6180f66 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigate.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigate.sysml @@ -1,13 +1,14 @@ - package MiningFrigate { + package MiningFrigatePackage { private import ScalarValues::*; private import ISQ::*; private import SI::*; private import ParametersOfInterestMetadata::*; private import OperationalUseCaseActions::*; - private import Domain::*; + private import DomainPackage::*; + private import StakeholderConcerns::*; - part def MiningFrigate :> Domain::Spaceship { + part def MiningFrigate :> Spaceship { attribute miningRate : Real; // Volume of ore mined per second (m³/s) attribute droneCapacity : Integer; // Number, the maximum number of drones deployable (STRQ04) @@ -24,147 +25,147 @@ part sensorModule: SensorModule; // Configurable sensor array part oreHoldExpander: OreHoldExpander [0..2]; // Optional cargo expander module part capacitorBooster: CapacitorBooster [0..1]; // Configurable capacitor booster - part defenseTurret: DefenseTurret [0..*]; // Optional defense modules - ref part cargo : Domain::CargoContainer [0..*]; - ref part charge : Domain::Power; - ref part drone : Domain::Drone [0..5]; + part warpCoreStabilizer: WarpCoreStabilizer [0..*]; // Optional defense modules + ref part cargo : CargoContainer [0..*]; + ref part charge : Power; + ref part drone : Drone [0..5]; - port controlPort : ~Domain::PodPort; - port dockingPort : ~Domain::DockingPort; - port DefensePort : ~Domain::ThreatPort; - port asteroidOrePort : ~Domain::AsteroidOrePort; - port droneControlPort: ~Domain::DroneControllerPort; - - //actions declaration - action activateMiningLaser : ActivateMiningLaser { - } - + port controlPort : PodPort; + port dockingPort : DockingPort; + port defensePort : ThreatPort; + port asteroidOrePort : AsteroidOrePort; + port droneControlPort: DroneControllerPort; } - // State Definition for the Mining Frigate - state miningFrigatesStates { - in miningFrigates : MiningFrigate; + part miningFrigate : MiningFrigate{ + // State Definition for the Mining Frigate + state miningFrigatesStates { + + entry; + then Docked; //boarding a ship is not modeled. + + state Packaged { + doc /* The mining frigate is packaged inside a station and can be cargoed. */ + } + state Parked { + doc /* The mining frigate is parked inside a station, but not boarded by a pod. */ + } + state Docked { + doc /* The mining frigate is inside a station, available for refitting, resupply, or cargo transfer. */ + } + state InGrid { + doc /* The mining frigate is in open space, near asteroids, stations, or other celestial objects. */ + } + state OnWarp { + doc /* The mining frigate is in warp, traveling between locations. */ + } + + transition docked_to_inGrid + first Docked + accept pilotPodUndockCommandSig : ShipCommand via miningFrigate.controlPort + do action undockFromStation : UndockFromStation {in undockCommand = pilotPodUndockCommandSig;} + then InGrid; + + transition inGrid_to_docked + first InGrid + accept pilotPodDockCommandSig : ShipCommand via miningFrigate.controlPort + do action dockToStation : DockToStation {in dockCommand = pilotPodDockCommandSig;} + then Docked; + + transition inGrid_to_onWarp + first InGrid + accept warpCommandSig : ShipCommand via miningFrigate.controlPort + do action executeWarpDrive: ExecuteWarpDrive {in warpCommand = warpCommandSig;} + then OnWarp; - entry; - then Docked; //boarding a ship is not modeled. - - state Packaged { - doc /* The mining frigate is packaged inside a station and can be cargoed. */ - } - state Parked { - doc /* The mining frigate is parked inside a station, but not boarded by a pod. */ - } - state Docked { - doc /* The mining frigate is inside a station, available for refitting, resupply, or cargo transfer. */ - } - state InGrid { - doc /* The mining frigate is in open space, near asteroids, stations, or other celestial objects. */ - } - state OnWarp { - doc /* The mining frigate is in warp, traveling between locations. */ - } - - transition docked_to_inGrid - first Docked - accept pilotPodUndockCommand : Domain::ShipCommand via miningFrigates.controlPort - do action undockFromStation : UndockFromStation {in undockCommand = pilotPodUndockCommand;} - then InGrid; - - transition inGrid_to_docked - first InGrid - accept pilotPodDockCommand : Domain::ShipCommand via miningFrigates.controlPort - do action dockToStation : DockToStation {in dockCommand = pilotPodDockCommand;} - then Docked; - - transition inGrid_to_onWarp - first InGrid - accept warpCommand : Domain::ShipCommand via miningFrigates.controlPort - do action executeWarpDrive : ExecuteWarpDrive - then OnWarp; + transition onWarp_to_inGrid + first OnWarp + accept when miningFrigate.warpBubbleEnd + then InGrid; + + //Internal transitions + transition unloadCargo + first Docked + accept unloadCommandSig : ShipCommand via miningFrigate.controlPort + do action transferOre : TransferOre {in unloadCommand = unloadCommandSig;} + then Docked; + + transition cycleMining + first InGrid + accept miningCommandSig : ShipCommand via miningFrigate.controlPort + do action activateMiningLaser : ActivateMiningLaser + then InGrid; + + transition scanThreats + first InGrid + accept scanCommandSig : ShipCommand via miningFrigate.controlPort + do action scanForThreats : ScanForThreats {in scanCommand = scanCommandSig;} + then InGrid; + + transition prioritizeThreat + first InGrid + accept threatSignatureSig : ScanSignature via miningFrigate.controlPort + do action prioritizeThreats : PrioritizeThreats {in detectedThreats = threatSignatureSig;} + then InGrid; + + transition deployDrones + first InGrid + accept droneCommandSig : ShipCommand via miningFrigate.controlPort + do action selectDronesForDeployment : SelectDronesForDeployment {in droneCommand = droneCommandSig;} + then InGrid; + + transition navigation + first InGrid + accept destinationCommandSig : ShipCommand via miningFrigate.controlPort + do action acceptDestination : AcceptDestination {in destinationCommand = destinationCommandSig;} + then InGrid; + + transition coursePlot + first InGrid + accept courseCommandSig : ShipCommand via miningFrigate.controlPort + do action plotOptimalCourse : PlotOptimalCourse + then InGrid; + + transition engagingPropulsion + first InGrid + accept propulsionCommandSig : ShipCommand via miningFrigate.controlPort + do action engagePropulsion : EngagePropulsion { in engagePropulsion = propulsionCommandSig;} + then InGrid; + + transition adjustingCourse + first InGrid + accept courseCorrectionSig : ShipCommand via miningFrigate.controlPort + do action monitorAndAdjustCourse : MonitorAndAdjustCourse + then InGrid; + + transition cargoVerification + first Docked + accept warehouseStatusCommandSig : StationCommand via miningFrigate.controlPort + do action verifyCargoTransfer : VerifyCargoTransfer {in warehouseStatusCommand = warehouseStatusCommandSig;} + then Docked; + + transition detectingThreat + first InGrid + accept threatScanCommandSig : ShipCommand via miningFrigate.controlPort + do action detectThreat : DetectThreat {in scanCommand = threatScanCommandSig;} + then InGrid; + + transition engagingDefenses + first InGrid + accept defenseCommandSig : ShipCommand via miningFrigate.controlPort + do action engageDefenses : EngageDefenses {in engageCommand = defenseCommandSig;} + then InGrid; + + transition resupplying + first Docked + accept shipStatusCommandSig : ShipCommand via miningFrigate.controlPort + do action verifyResupply : VerifyResupply + then Docked; + } + + } + + - transition onWarp_to_inGrid - first OnWarp - accept when miningFrigates.warpBubbleEnd - then InGrid; - - //Internal transitions - transition unloadCargo - first Docked - accept unloadCommand : Domain::ShipCommand via miningFrigates.controlPort - do action transferOre : TransferOre - then Docked; - - transition cycleMining - first InGrid - accept miningCommand : Domain::ShipCommand via miningFrigates.controlPort - do action activateMiningLaser : ActivateMiningLaser - then InGrid; - - transition scanThreats - first InGrid - accept scanCommand : Domain::ShipCommand via miningFrigates.controlPort - do action scanForThreats : ScanForThreats - then InGrid; - - transition prioritizeThreat - first InGrid - accept threatSignature : Domain::ScanSignature via miningFrigates.controlPort - do action prioritizeThreats : PrioritizeThreats - then InGrid; - - transition deployDrones - first InGrid - accept droneCommand : Domain::ShipCommand via miningFrigates.controlPort - do action selectDronesForDeployment : SelectDronesForDeployment - then InGrid; - - transition navigation - first InGrid - accept destinationCommand : Domain::ShipCommand via miningFrigates.controlPort - do action acceptDestination : AcceptDestination - then InGrid; - - transition coursePlot - first InGrid - accept courseCommand : Domain::ShipCommand via miningFrigates.controlPort - do action plotOptimalCourse : PlotOptimalCourse - then InGrid; - - transition engagePropulsion - first InGrid - accept propulsionCommand : Domain::ShipCommand via miningFrigates.controlPort - do action engagePropulsion : EngagePropulsion - then InGrid; - - transition adjustCourse - first InGrid - accept courseCorrection : Domain::ShipCommand via miningFrigates.controlPort - do action monitorAndAdjustCourse : MonitorAndAdjustCourse - then InGrid; - - transition cargoVerification - first Docked - accept warehouseStatusCommand : Domain::StationCommand via miningFrigates.controlPort - do action verifyCargoTransfer : VerifyCargoTransfer - then Docked; - - transition detectThreat - first InGrid - accept threatScanCommand : Domain::ShipCommand via miningFrigates.controlPort - do action detectThreat : DetectThreat - then InGrid; - - transition engageDefense - first InGrid - accept defenseCommand : Domain::ShipCommand via miningFrigates.controlPort - do action engageDefenses : EngageDefenses - then InGrid; - - transition resupply - first Docked - accept shipStatusCommand : Domain::ShipCommand via miningFrigates.controlPort - do action verifyResupply : VerifyResupply - then Docked; - } // Definitions for individual parts of the mining frigate part def SpaceshipModule { @@ -213,12 +214,12 @@ attribute optimalRange : Real; // Optimal engagement range } - part def DroneBay { - attribute maxDrones : Integer; // Maximum drones stored - } - part def NavigationModule { attribute agilityBonus : Real; // Improves ship align time attribute warpSpeedBonus : Real; // Boost to warp speed - } -} \ No newline at end of file + } + + part def WarpCoreStabilizer { + attribute warpCoreStrenght : Real; // Improves ship align time + } + } \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirements.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirements.sysml index cca4d3f..04ea8ab 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirements.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirements.sysml @@ -1,60 +1,49 @@ package MiningFrigateRequirements { - private import Domain::*; + private import DomainPackage::*; private import ScalarValues::*; private import MiningFrigateRequirementsDef::*; - private import MiningFrigate::*; + private import MiningFrigatePackage::*; //Mining Frigate Requirement assertions for the Mining Frigates requirement oreExtractionEfficiencyRequirementLowSec : OreExtractionEfficiencyRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> miningRateLS = miningFrigate.miningRate ; + subject myMiningFrigate : MiningFrigate; } requirement cargoCapacityRequirementLowSec : CargoCapacityRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> cargoCapacity = miningFrigate.cargoCapacity ; + subject myMiningFrigate : MiningFrigate; } requirement survivabilityRequirementLowSec : SurvivabilityRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> shieldStrengthLS = miningFrigate.shieldModule.shieldStrength ; + subject myMiningFrigate : MiningFrigate; } requirement droneOperationsRequirementLowSec : DroneOperationsRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> droneCapacity = miningFrigate.droneCapacity ; + subject myMiningFrigate : MiningFrigate; } requirement threatDetectionRequirementLowSec : ThreatDetectionRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> threatDetectionRange = miningFrigate.threatDetectionRange ; + subject myMiningFrigate : MiningFrigate; } requirement travelEfficiencyRequirementLowSec : TravelEfficiencyRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> warpSpeed = miningFrigate.warpSpeed ; - attribute :>> alignTime = miningFrigate.alignTime ; + subject myMiningFrigate : MiningFrigate; } requirement miningTargetRequirementLowSec : MiningTargetRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> lockedTargets = miningFrigate.lockedTargets ; + subject myMiningFrigate : MiningFrigate; } requirement dockingRequirementLowSec : DockingRequirement { - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute :>> dockingTime = miningFrigate.dockingTime ; + subject myMiningFrigate : MiningFrigate; } //Stakeholder Requirement assertions for the Mining Corporation requirement fleetCoordinationRequirementLowSec : FleetCoordinationRequirement { - subject fleetCommander : Domain::PilotPod; - attribute :>> fleetSize = fleetCommander.fleetSize ; + subject myFleetCommander : PilotPod; } requirement oreCompressionRequirement : OreCompressionRequirement { - subject rorqual : Domain::Rorqual; - attribute :>> compressionFactor = rorqual.oreCompressionUnit.compressionFactor ; + subject myRorqual : Rorqual; } } \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirementsDef.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirementsDef.sysml index e184bbf..47b00ad 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirementsDef.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateRequirementsDef.sysml @@ -1,38 +1,33 @@ package MiningFrigateRequirementsDef { - private import Domain::*; + private import DomainPackage::*; private import ScalarValues::*; private import StakeholderConcerns::*; - private import MiningFrigate::*; + private import MiningFrigatePackage::*; // Stakeholder Requirements Definition. These are a managed as a Configuration item. requirement def OreExtractionEfficiencyRequirement { doc /* The Mining Frigate shall extract ore at a minimum rate of 20 m³/minute in High Sec - and 50 m³/minute in Low Sec, Null Sec, and Wormhole operations. */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute miningRateLS : Real; - require constraint { miningRateLS >= 50.0 } // Low Sec, Null Sec, Wormhole (m³/min) + */ + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.miningRate >= 50.0 } // Low Sec, Null Sec, Wormhole (m³/min) frame concern OreYieldConcern; } requirement def CargoCapacityRequirement { doc /* The Mining Frigate shall have a cargo capacity of at least 5,000 m³ (expandable by modules). */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute cargoCapacity : Real; - require constraint { cargoCapacity >= 5000.0 } // m³ + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.cargoCapacity >= 5000.0 } // m³ frame concern TotalProfitabilityConcern; } requirement def SurvivabilityRequirement { doc /* The Mining Frigate shall withstand at least 200 DPS in High Sec and 400 DPS - in Low Sec, Null Sec, and Wormhole operations. */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute shieldStrengthHS : Real; - attribute shieldStrengthLS : Real; - require constraint { shieldStrengthHS >= 200.0 } // High Sec (DPS) - require constraint { shieldStrengthLS >= 400.0 } // Low Sec, Null Sec, Wormhole (DPS) + */ + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.shieldStrength >= 200.0 } // High Sec (DPS) frame concern SecurityConcern ; frame concern SurvivabilityConcern; @@ -41,9 +36,8 @@ package MiningFrigateRequirementsDef { requirement def DroneOperationsRequirement { doc /* The Mining Frigate shall support the deployment of at least 5 drones for mining and combat operations. */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute droneCapacity : Real; - require constraint { droneCapacity >= 5 } // Minimum number of drones + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.droneCapacity >= 5 } // Minimum number of drones frame concern ThreatNeutralizationConcern; frame concern OreYieldConcern; @@ -51,9 +45,8 @@ package MiningFrigateRequirementsDef { requirement def ThreatDetectionRequirement { doc /* The Mining Frigate shall detect incoming threats within a range of 20 AU. */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute threatDetectionRange : Real; - require constraint { threatDetectionRange >= 20.0 } // AU + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.threatDetectionRange >= 20.0 } // AU frame concern SecurityConcern; frame concern ThreatNeutralizationConcern; @@ -62,38 +55,33 @@ package MiningFrigateRequirementsDef { requirement def TravelEfficiencyRequirement { doc /* The Mining Frigate shall have a warp speed of at least 5 AU/second and an align time of less than 3 seconds. */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute warpSpeed: Real; - attribute alignTime: Real; - require constraint { warpSpeed >= 5.0 } // Warp speed (AU/second) - require constraint { alignTime <= 3.0 } // Align time (seconds) + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.warpSpeed >= 5.0 } // Warp speed (AU/second) + require constraint { miningFrigate.alignTime <= 3.0 } // Align time (seconds) frame concern DeploymentEfficiencyConcern; } requirement def MiningTargetRequirement { doc /* The Mining Frigate shall lock and mine up to 3 asteroid targets simultaneously. */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute lockedTargets : Real; - require constraint { lockedTargets <= 3 } // Maximum asteroid targets + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.lockedTargets <= 3 } // Maximum asteroid targets frame concern OreYieldConcern; } requirement def DockingRequirement { doc /* The Mining Frigate shall dock and offload ore at stations or POS within 1 minute. */ - subject miningFrigate : MiningFrigate::MiningFrigate; - attribute dockingTime : Real; - require constraint { dockingTime <= 60.0 } // Seconds + subject miningFrigate : MiningFrigate; + require constraint { miningFrigate.dockingTime <= 60.0 } // Seconds frame concern OreDeliveryEfficiencyConcern; } requirement def FleetCoordinationRequirement { doc /* The Fleet Commander shall coordinate mining fleets of up to 10 frigates. */ - subject fleetCommander : Domain::PilotPod; - attribute fleetSize : Real; - require constraint { fleetSize <= 10 } // Maximum fleet size + subject fleetCommander : PilotPod; + require constraint { miningFrigate.fleetSize <= 10 } // Maximum fleet size frame concern FleetDeploymentEfficiencyConcern; frame concern ScalabilityConcern; @@ -101,9 +89,8 @@ package MiningFrigateRequirementsDef { requirement def OreCompressionRequirement { doc /* The Rorqual shall support onboard ore compression to reduce ore volume by a factor of 10. */ - subject rorqual : Domain::Rorqual; - attribute compressionFactor : Real; - require constraint { compressionFactor == 10.0 } // Compression factor + subject rorqual : Rorqual; + require constraint { rorqual.oreCompressionRatio == 10.0 } // Compression factor frame concern TotalProfitabilityConcern; } diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateVerificationCases.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateVerificationCases.sysml index 496e679..e0d8dad 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateVerificationCases.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigateVerificationCases.sysml @@ -2,12 +2,12 @@ package MiningFrigateRequirementsVerification { private import MiningFrigateRequirements::*; private import StakeholdersDef::*; - private import Domain::*; + private import DomainPackage::*; private import ScalarValues::*; private import ISQ::*; private import SI::*; private import VerificationCases::*; - private import MiningFrigate::*; + private import MiningFrigatePackage::*; //Verifications at the problem/operational level //These are incidentally the validation actions for the system/soution level @@ -15,7 +15,7 @@ package MiningFrigateRequirementsVerification { // Definition of a test rig that includes all necessary verification parts //Verification actions are assigned to the parts of the verification domain part def MiningFrigateTestRig { - part testMiningFrigate : MiningFrigate::MiningFrigate; + part testMiningFrigate : MiningFrigate; part testEngineer : ShipEngineer; part testEnvironment : TestEnvironment; part dataLogger : DataLogger; @@ -38,7 +38,7 @@ package MiningFrigateRequirementsVerification { doc /* The ShipEngieer is both a stakeholder and an actor in the verification domain */ } - part miningFrigateDUT : MiningFrigate::MiningFrigate { + part miningFrigateDUT : MiningFrigate { doc /* The miningFrigateDUT is a test unit */ perform action collectData; perform action deployDrones; @@ -65,7 +65,7 @@ package MiningFrigateRequirementsVerification { // Verification definitions // Verification Definition for Ore Extraction Efficiency verification def OreExtractionEfficiencyTest { - subject testMiningFrigate : MiningFrigate::MiningFrigate; + subject testMiningFrigate : MiningFrigate; objective oreExtractionEfficiencyVerification { // The subject of the verify is automatically bound to "testMiningFrigate". @@ -76,18 +76,17 @@ package MiningFrigateRequirementsVerification { } action collectData { - in part testMiningFrigate : MiningFrigate::MiningFrigate = OreExtractionEfficiencyTest::testMiningFrigate; + in part testMiningFrigate : MiningFrigate = OreExtractionEfficiencyTest::testMiningFrigate; out miningRateMeasuredHS : Real ; // High Sec (m³/min) out miningRateMeasuredLS : Real; // Low Sec, Null Sec, Wormholes } action evaluateData { - in miningRateMeasuredLS = collectData.miningRateMeasuredLS; + in evalMiningRateMeasuredLS = collectData.miningRateMeasuredLS; out verdict : VerdictKind = // Check if mining rates satisfy the OreExtractionEfficiencyRequirement. PassIf(oreExtractionEfficiencyRequirementLowSec( - testMiningFrigate, - miningRateMeasuredLS)); + myMiningFrigate = testMiningFrigate)); } return :>> verdict : VerdictKind = evaluateData.verdict; @@ -95,7 +94,7 @@ package MiningFrigateRequirementsVerification { // Verification Definition for Cargo Capacity verification def CargoCapacityTest { - subject testMiningFrigate : MiningFrigate::MiningFrigate; + subject testMiningFrigate : MiningFrigate; objective cargoCapacityVerification { // The subject of the verify is automatically bound to "testMiningFrigate". @@ -107,7 +106,7 @@ package MiningFrigateRequirementsVerification { } action collectData { - in part testMiningFrigate : MiningFrigate::MiningFrigate = CargoCapacityTest::testMiningFrigate; + in part testMiningFrigate : MiningFrigate = CargoCapacityTest::testMiningFrigate; out cargoCapacityMeasured : Real; } @@ -116,8 +115,7 @@ package MiningFrigateRequirementsVerification { out verdict : VerdictKind = // Check if cargo capacity satisfies the CargoCapacityRequirement. PassIf(cargoCapacityRequirementLowSec( - testMiningFrigate, - cargoCapacityMeasured)); + myMiningFrigate = testMiningFrigate)); } return verdict : VerdictKind = evaluateData.verdict; @@ -125,7 +123,7 @@ package MiningFrigateRequirementsVerification { // Verification Definition for Survivability verification def SurvivabilityTest { - subject testMiningFrigate : MiningFrigate::MiningFrigate; + subject testMiningFrigate : MiningFrigate; objective survivabilityVerification { // The subject of the verify is automatically bound to "testMiningFrigate". @@ -137,12 +135,12 @@ package MiningFrigateRequirementsVerification { } action simulateHighSecAttack { - in part testMiningFrigate : MiningFrigate::MiningFrigate = SurvivabilityTest::testMiningFrigate; + in part testMiningFrigate : MiningFrigate = SurvivabilityTest::testMiningFrigate; out shieldStrengthMeasuredHS : Real; // High Sec survivability (DPS) } action simulateLowSecAttack { - in part testMiningFrigate : MiningFrigate::MiningFrigate = SurvivabilityTest::testMiningFrigate; + in part testMiningFrigate : MiningFrigate = SurvivabilityTest::testMiningFrigate; out shieldStrengthMeasuredLS : Real; // Low Sec survivability (DPS) } @@ -151,8 +149,7 @@ package MiningFrigateRequirementsVerification { out verdict : VerdictKind = // Check if shield strength satisfies the SurvivabilityRequirement. PassIf(survivabilityRequirementLowSec( - testMiningFrigate, - shieldStrengthMeasuredLS)); + myMiningFrigate = testMiningFrigate)); } return verdict : VerdictKind = evaluateData.verdict; @@ -160,7 +157,7 @@ package MiningFrigateRequirementsVerification { // Verification Definition for Drone Operations verification def DroneOperationsTest { - subject testMiningFrigate : MiningFrigate::MiningFrigate; + subject testMiningFrigate : MiningFrigate; objective droneOperationsVerification { // The subject of the verify is automatically bound to "testMiningFrigate". @@ -172,7 +169,7 @@ package MiningFrigateRequirementsVerification { } action deployDrones { - in part testMiningFrigate : MiningFrigate::MiningFrigate = DroneOperationsTest::testMiningFrigate; + in part testMiningFrigate : MiningFrigate = DroneOperationsTest::testMiningFrigate; out droneCapacityMeasured : Integer; } @@ -181,8 +178,7 @@ package MiningFrigateRequirementsVerification { out verdict : VerdictKind = // Check if the drone capacity satisfies the DroneOperationsRequirement. PassIf(droneOperationsRequirementLowSec( - testMiningFrigate, - droneCapacityMeasured + myMiningFrigate = testMiningFrigate )); } @@ -191,7 +187,7 @@ package MiningFrigateRequirementsVerification { // Verification Definition for Threat Detection verification def ThreatDetectionTest { - subject testMiningFrigate : MiningFrigate::MiningFrigate; + subject testMiningFrigate : MiningFrigate; objective threatDetectionVerification { // The subject of the verify is automatically bound to "testMiningFrigate". @@ -203,7 +199,7 @@ package MiningFrigateRequirementsVerification { } action collectThreatDetectionData { - in part testMiningFrigate : MiningFrigate::MiningFrigate = ThreatDetectionTest::testMiningFrigate; + in part testMiningFrigate : MiningFrigate = ThreatDetectionTest::testMiningFrigate; out threatDetectionRangeMeasured : Real; } @@ -212,8 +208,7 @@ package MiningFrigateRequirementsVerification { out verdict : VerdictKind = // Check if the threat detection range satisfies the ThreatDetectionRequirement. PassIf(threatDetectionRequirementLowSec( - testMiningFrigate, - threatDetectionRangeMeasured + myMiningFrigate = testMiningFrigate )); } diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/OPSCON.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/OPSCON.sysml new file mode 100644 index 0000000..201b731 --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/DomainModel/OPSCON.sysml @@ -0,0 +1,129 @@ +package OPSCON { + + private import DocumentStructureMetadata::*; + + // The OPSCON document instance + #document OPSCON { + titleOpsCon ::> title = "OPSCON for Mining Frigate-Based Resource Extraction"; + statusOpsCon ::> status = "Draft"; + + // Chapter 1 – Mission Overview + #chapter missionOverview { + titleChapter1 ::> title = "1. Mission Overview"; + #section overviewSection { + headingChapter1 ::> heading = "Overview"; + contentChapter1 ::> content = "The Mining Corporation operates fleets of mining frigates in + asteroid belts and wormholes. The goals are maximizing profitability, + ensuring operational safety, and sustaining long-term operations. The + central command coordinates deployments using PilotPods with tactical + oversight from Fleet Commanders."; + } + } + + // Chapter 2 – Operational Context + #chapter context { + titleChapter2 ::> title = "2. Operational Context"; + #section environment { + headingChapter2 ::> heading = "Operational Environment"; + contentChapter2 ::> content = "Operations take place in High Sec, Low Sec, Null Sec, and + Wormhole space, involving hostile encounters, asteroid depletion, and + resupply via stations or POS. System elements and context are defined + in Domain and ConceptOfOperations packages."; + } + } + + // Chapter 3 – Stakeholders and Roles + #chapter stakeholders { + titleChapter3 ::> title = "3. Actors and Roles"; + #section actorRoles { + headingChapter3 ::> heading = "Actor Definitions"; + contentChapter3 ::> content = "Actors include Mining CEO, Operations Manager, Fleet Commander, + Ship Engineer, and Market Analyst. Responsibilities span strategy, cost + control, fleet survivability, system design, and market alignment."; + } + } + + // Chapter 4 – System Elements + #chapter systemElements { + titleChapter4 ::> title = "4. System Elements"; + #section elementsOverview { + headingChapter4 ::> heading = "System Components"; + contentChapter4 ::> content = "Primary elements include MiningFrigate, PilotPod, Rorqual, + Drone, and Station. These components are defined in the Domain and MiningFrigate + packages."; + } + } + + // Chapter 5 – Use Cases + #chapter useCases { + titleChapter5 ::> title = "5. Use Case Overview"; + #section useCasesSummary { + headingChapter5 ::> heading = "Operational Use Cases"; + contentChapter5 ::> content = "Main use cases include Mine Asteroids, Plot Course and Navigate, + Detect Threats and Engage Defenses, Offload Ore and Resupply, and Deploy Drones. + Each is modeled in the MiningFrigateUseCases package and leverages reusable + included use cases."; + } + } + + // Chapter 6 – Operational Requirements + #chapter requirements { + titleChapter6 ::> title = "6. Operational Requirements"; + #section requirementSummary { + headingChapter6 ::> heading = "Performance and Capability Requirements"; + contentChapter6 ::> content = "MiningFrigates are required to extract ≥ 50 m³/min, have ≥ 5000 m³ + cargo capacity, survive 400 DPS, detect threats within 20 AU, warp at ≥ 5 AU/s, + align in ≤ 3 sec, and dock/unload in ≤ 60 sec. These are defined and bound + in MiningFrigateRequirements and MiningFrigateRequirementsDef."; + } + } + + // Chapter 7 – Verification Strategy + #chapter systemVerification { + titleChapter7 ::> title = "7. Verification Strategy"; + #section strategy { + headingChapter7 ::> heading = "Verification through Simulation and Testing"; + contentChapter7 ::> content = "Requirements are verified using formal verification definitions + (e.g., OreExtractionEfficiencyTest) implemented in MiningFrigateRequirementsVerification. + The MiningFrigateTestRig simulates conditions, logs data, and compares outcomes + against defined constraints."; + } + } + + // Chapter 8 – Measures of Effectiveness + #chapter moes { + titleChapter8 ::> title = "8. Measures of Effectiveness"; + #section moesSummary { + headingChapter8 ::> heading = "MoEs and Decision Criteria"; + contentChapter8 ::> content = "MoEs include profitability (ISK/hour), ore throughput, survivability, + threat response time, storage utilization, fleet deployment efficiency, and + adaptability. These are modeled in the Domain and BusinessRequirements packages + and trace to StakeholderConcerns."; + } + } + + // Chapter 9 – Risk Considerations + #chapter risk { + titleChapter9 ::> title = "9. Risk Considerations"; + #section riskAnalysis { + headingChapter9 ::> heading = "Risk-Adjusted Decision Making"; + contentChapter9 ::> content = "The analysisProblemSpace package provides a model-based method for + calculating profitability adjusted by risk factors like survival probability, + operational cost, and market ore prices across different zones."; + } + } + + // Chapter 10 – Lifecycle Considerations + #chapter lifecycle { + titleChapter10 ::> title = "10. Lifecycle Considerations"; + #section traceability { + headingChapter10 ::> heading = "Model Traceability and Lifecycle Use"; + contentChapter10 ::> content = "The full model supports requirement declaration, use case-driven + behavior, formal verification, and traceability across viewpoints. All aspects + are integrated through packages including MiningFrigateRequirementsDecl, + MiningFrigateRequirementsVerification, and StakeholderConcerns."; + } + } + + } +} diff --git a/models/example_EveOnlineMiningFrigate/DomainModel/cause-effect.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/cause-effect.sysml index 4311104..b31d6f8 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/cause-effect.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/cause-effect.sysml @@ -1,34 +1,33 @@ package causeEffect { - private import Domain::MiningCorporation::miningFrigate; + private import DomainPackage::domain; private import CauseAndEffect::*; - private import CausationConnections::*; //The cause-effect relationships //This section is not correctly parsed and needs further corrections - //#causation connect miningFrigate.MiningRateIncreases to miningFrigate.OreYieldIncreases; - //#causation connect miningFrigate.CargoCapacityIncreases to miningFrigate.DowntimeReduces; - //#causation connect miningFrigate.ShieldStrengthIncreases to miningFrigate.SurvivabilityEnhances; - //#causation connect miningFrigate.ThreatDetectionImproves to miningFrigate.ThreatResponseImproves; - //#causation connect miningFrigate.DroneOperationsImprove to miningFrigate.OperationalEfficiencyIncreases; - //#causation connect miningFrigate.WarpSpeedIncreases to miningFrigate.DowntimeReduces; - //#causation connect miningFrigate.FleetCoordinationImproves to miningFrigate.OperationalEfficiencyIncreases; + #causation connect domain.miningCorporation.miningFrigate.miningRateIncreases to domain.asteroid.oreYieldIncreases; + #causation connect domain.miningCorporation.miningFrigate.cargoCapacityIncreases to domain.miningCorporation.fleet.downtimeReduces; + #causation connect domain.miningCorporation.miningFrigate.shieldStrengthIncreases to domain.miningCorporation.fleet.survivabilityEnhances; + #causation connect domain.miningCorporation.miningFrigate.threatDetectionImproves to domain.miningCorporation.fleet.threatResponseImproves; + #causation connect domain.miningCorporation.miningFrigate.droneOperationsImprove to domain.miningCorporation.fleet.operationalEfficiencyIncreases; + #causation connect domain.miningCorporation.miningFrigate.warpSpeedIncreases to domain.miningCorporation.fleet.downtimeReduces; + #causation connect domain.miningCorporation.fleet.fleetCoordinationImproves to domain.miningCorporation.fleet.operationalEfficiencyIncreases; - //#multicausation connection { - // end #cause ::> miningFrigate.OreYieldIncreases; - // end #cause ::> miningFrigate.DowntimeReduces; - // end #effect ::> miningFrigate.OreExtractionEfficiencyIncreases; - //} + #multicausation connection { + end #cause ::> domain.asteroid.oreYieldIncreases; + end #cause ::> domain.miningCorporation.fleet.downtimeReduces; + end #effect ::> domain.miningCorporation.fleet.oreExtractionEfficiencyIncreases; + } - //#multicausation connection { - // end #cause ::> miningFrigate.SurvivabilityEnhances; - // end #cause ::> miningFrigate.ThreatResponseImproves; - // end #effect ::> miningFrigate.OperationalEfficiencyIncreases; - //} + #multicausation connection { + end #cause ::> domain.miningCorporation.fleet.survivabilityEnhances; + end #cause ::> domain.miningCorporation.fleet.threatResponseImproves; + end #effect ::> domain.miningCorporation.fleet.operationalEfficiencyIncreases; + } - //#multicausation connection { - // end #cause ::> miningFrigate.OperationalEfficiencyIncreases; - // end #cause ::> miningFrigate.OreExtractionEfficiencyIncreases; - // end #effect ::> miningFrigate.ProfitabilityMaximizes; - //} + #multicausation connection { + end #cause ::> domain.miningCorporation.fleet.operationalEfficiencyIncreases; + end #cause ::> domain.miningCorporation.fleet.oreExtractionEfficiencyIncreases; + end #effect ::> domain.miningCorporation.fleet.profitabilityMaximizes; + } } \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/Libraries/DocumentStructure.sysml b/models/example_EveOnlineMiningFrigate/Libraries/DocumentStructure.sysml new file mode 100644 index 0000000..1c20905 --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/Libraries/DocumentStructure.sysml @@ -0,0 +1,40 @@ +library package DocumentStructureLibrary { + private import ScalarValues::*; + + // A Document is a top-level semantic container + abstract part def Document { + attribute title : String; + attribute status : String; + part chapters : Chapter[*]; + } + + // Chapters define hierarchical sections + abstract part def Chapter { + attribute title : String; + part sections : Section[*]; + } + + // Sections provide the narrative or model references + abstract part def Section { + attribute heading : String; + attribute content : String; + } + abstract part documents : Document[*] nonunique; + abstract part chapters : Chapter[*] nonunique; + abstract part sections : Section[*] nonunique; + +} +library package DocumentStructureMetadata { + private import DocumentStructureLibrary::*; + private import Metaobjects::SemanticMetadata; + + metadata def document :> SemanticMetadata { + :>> baseType = documents meta SysML::Usage; + } + metadata def chapter :> SemanticMetadata { + :>> baseType = chapters meta SysML::Usage; + } + metadata def section :> SemanticMetadata { + :>> baseType = sections meta SysML::Usage; + } +} \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsFrigateLogical.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsFrigateLogical.sysml new file mode 100644 index 0000000..48414fc --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsFrigateLogical.sysml @@ -0,0 +1,42 @@ +package MiningFrigateActions_logical { + + //import packages + private import DomainPackage::*; + private import ScalarValues::*; + private import OperationalUseCaseActions::*; + private import COTS::*; + + //action parameters are inherited + + //Activate Mining Laser + action def PowerupHighPowerModule {in activateMiningLaser : ShipCommand; out highPowerSupply : Real; } + action def ActivateLaserTurret {in highPowerSupply : Real; in miningLaserTarget : COTS::ModuleCommand; out minigLaserReport : COTS::ModuleReport; } + action def ManageReports {in moduleReport : COTS::ModuleReport; out shipReport : ShipReport;} + action def ActivateMiningLaser_logical :> OperationalUseCaseActions::ActivateMiningLaser; + action activateMiningLaser_logical : ActivateMiningLaser_logical { + bind powerupHighPowerModule.activateMiningLaser = activateMiningLaser; + action powerupHighPowerModule : PowerupHighPowerModule {in activateMiningLaser : ShipCommand; out highPowerSupply; } + flow powerupHighPowerModule.highPowerSupply to activateLaserTurret.highPowerSupply; + action activateLaserTurret : ActivateLaserTurret {in highPowerSupply; in miningLaserTarget; out miningLaserReport; } + flow activateLaserTurret.miningLaserReport to manageLaserTurretReport.laserModuleReport; + action manageLaserTurretReport : ManageReports {in laserModuleReport : COTS::ModuleReport; out shipMiningReport : ShipReport;} + bind manageLaserTurretReport.shipMiningReport = miningCycleReport; + } + + action def UndockFromStation_logical :> OperationalUseCaseActions::UndockFromStation; + action def DockToStation_logical :> OperationalUseCaseActions::DockToStation; + action def ExecuteWarpDrive_logical :> OperationalUseCaseActions::ExecuteWarpDrive; + action def TransferOre_logical :> OperationalUseCaseActions::TransferOre; + action def ScanForThreats_logical :> OperationalUseCaseActions::ScanForThreats; + action def PrioritizeThreats_logical :> OperationalUseCaseActions::PrioritizeThreats; + action def SelectDronesForDeployment_logical :> OperationalUseCaseActions::SelectDronesForDeployment; + action def AcceptDestination_logical :> OperationalUseCaseActions::AcceptDestination; + action def PlotOptimalCourse_logical :> OperationalUseCaseActions::PlotOptimalCourse; + action def EngagePropulsion_logical :> OperationalUseCaseActions::EngagePropulsion; + action def MonitorAndAdjustCourse_logical :> OperationalUseCaseActions::MonitorAndAdjustCourse; + action def VerifyCargoTransfer_logical :> OperationalUseCaseActions::VerifyCargoTransfer; + action def DetectThreat_logical :> OperationalUseCaseActions::DetectThreat; + action def EngageDefenses_logical :> OperationalUseCaseActions::EngageDefenses; + action def VerifyResupply_logical :> OperationalUseCaseActions::VerifyResupply; + +} \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsHull.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsHull.sysml index 4a3d42b..96d689c 100644 --- a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsHull.sysml +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsHull.sysml @@ -1,158 +1,71 @@ -package MiningFrigateHullHighLevelActions { +package MiningFrigateHullActions { - private import MiningFrigateHullIncludedActions::*; - private import Domain::*; + private import DomainPackage::*; private import MiningFrigateSolutionSpace::*; - - // **Action: Withstand Incoming Damage** - action def WithstandIncomingDamage { - in scanCommand : Domain::ShipCommand; - out defenseStatus : Domain::ShipReport; - - bind detectThreat.scanCommand = scanCommand; - action detectThreat : DetectThreat { in scanCommand; out scanReport; } - flow from detectThreat.scanReport to engageDefenses.engageCommand; - first detectThreat then engageDefenses; - action engageDefenses : EngageDefenses { in engageCommand; out defenseStatus; } - bind engageDefenses.defenseStatus = defenseStatus; - } - - // **Action: Navigate and Warp to Destinations** - action def NavigateAndWarp { - in destinationCommand : Domain::ShipCommand; - out navigationStatus : Domain::ShipReport; - - bind navigate.destinationCommand = destinationCommand; - action navigate : NavigateToDestination { in destinationCommand; out navigationStatus; } - bind navigate.navigationStatus = navigationStatus; - } - - // **Action: Store and Transfer Mined Ore** - action def StoreAndTransferOre { - in transferCommand : Domain::ShipCommand; - out transferStatus : Domain::ShipReport; - - bind transferOre.transferCommand = transferCommand; - action transferOre : TransferOre { in transferCommand; out transferStatus; } - bind transferOre.transferStatus = transferStatus; - } - - // **Action: Dock and Undock from Stations** - action def DockAndUndock { - in dockingCommand : Domain::ShipCommand; - out dockingStatus : Domain::ShipReport; - - bind dock.dockingCommand = dockingCommand; - action dock : DockAtStation { in dockingCommand; out dockingStatus; } - bind dock.dockingStatus = dockingStatus; + private import MiningFrigateActions_logical::*; + private import COTS::*; + + // **Action: Activate Mining Laser** + action def PowerupHighPowerModule :> MiningFrigateActions_logical::PowerupHighPowerModule { + in miningCommand : ShipCommand; + out miningStatus : ShipReport; } - + // **Action: Manage Energy Supply and Recharge** action def ManageEnergy { - in rechargeCommand : Domain::ShipCommand; - out rechargeStatus : Domain::ShipReport; + in rechargeCommand : ShipCommand; + out rechargeStatus : ShipReport; bind resupplyCapacitor.rechargeCommand = rechargeCommand; action resupplyCapacitor : ResupplyCapacitor { in rechargeCommand; out rechargeStatus; } bind resupplyCapacitor.rechargeStatus = rechargeStatus; } - - // **Action: Support High, Medium, and Low Slot Modules** - action def SupportModuleFitting { - in miningCommand : Domain::ShipCommand; - out miningStatus : Domain::ShipReport; - - bind activateMiningLaser.miningCommand = miningCommand; - action activateMiningLaser : ActivateMiningLaser { in miningCommand; out miningStatus; } - bind activateMiningLaser.miningStatus = miningStatus; - } -} - - -package MiningFrigateHullIncludedActions { - - private import Domain::*; - private import MiningFrigateSolutionSpace::*; // **Action: Detect Threat** action def DetectThreat { - in scanCommand : Domain::ShipCommand; - out scanReport : Domain::ShipReport; + in scanCommand : ShipCommand; + out scanReport : ShipReport; } // **Action: Engage Defenses** action def EngageDefenses { - in engageCommand : Domain::ShipCommand; - out defenseStatus : Domain::ShipReport; + in engageCommand : ShipCommand; + out defenseStatus : ShipReport; } // **Action: Navigate to Destination** action def NavigateToDestination { - in destinationCommand : Domain::ShipCommand; - out navigationStatus : Domain::ShipReport; + in destinationCommand : ShipCommand; + out navigationStatus : ShipReport; } // **Action: Transfer Ore** action def TransferOre { - in transferCommand : Domain::ShipCommand; - out transferStatus : Domain::ShipReport; + in transferCommand : ShipCommand; + out transferStatus : ShipReport; } // **Action: Dock at Station** - action def DockAtStation { - in dockingCommand : Domain::ShipCommand; - out dockingStatus : Domain::ShipReport; + action def DockToStation { + in dockingCommand : ShipCommand; + out dockingStatus : ShipReport; } // **Action: Resupply Capacitor** action def ResupplyCapacitor { - in rechargeCommand : Domain::ShipCommand; - out rechargeStatus : Domain::ShipReport; - } - - // **Action: Activate Mining Laser** - action def ActivateMiningLaser { - in miningCommand : Domain::ShipCommand; - out miningStatus : Domain::ShipReport; - - bind checkAsteroidStatus.miningCommand = miningCommand; - - action checkAsteroidStatus : CheckAsteroidStatus { - in miningCommand; - out asteroidStatus; - } - - decide; - if checkAsteroidStatus.asteroidStatus == "depleted" then reportDepletion; - else continueMining; - - action continueMining : ExtractOre { - in miningCommand; - out miningStatus; - } - - action reportDepletion : ReportToPilot { - in asteroidStatus; - out report : Domain::ShipReport;} - - bind continueMining.miningStatus = miningStatus; + in rechargeCommand : ShipCommand; + out rechargeStatus : ShipReport; } // **Action: Check Asteroid Status** action def CheckAsteroidStatus { - in miningCommand : Domain::ShipCommand; - out asteroidStatus : Domain::ShipReport; - } - - // **Action: Extract Ore (Standard Mining)** - action def ExtractOre { - in miningCommand : Domain::ShipCommand; - out miningStatus : Domain::ShipReport; + in miningCommand : ShipCommand; + out asteroidStatus : ShipReport; } // **Action: Report Asteroid Depletion to Pilot** action def ReportToPilot { - in asteroidStatus : Domain::ShipReport; - out report : Domain::ShipReport; + in asteroidStatus : ShipReport; + out report : ShipReport; } } diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/COTS.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/COTS.sysml index 833e743..f74d819 100644 --- a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/COTS.sysml +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/COTS.sysml @@ -4,19 +4,68 @@ private import StdPortsAndInterfaces::*; private import FrigateRollupAnalysis::*; - // **COTS Module Definitions with Conjugated Ports** - - part def MinerI :> SimpleFrigateComponent { + //COTS items + item def ModuleCommand { + attribute type: String; + } + item def ModuleReport { + attribute type: String; + } + + + // COTS Module Definitions with Conjugated Ports** + abstract part def MinerModule :> SimpleFrigateComponent { doc /* Standard mining laser used on mining frigates for ore extraction. */ - attribute miningYield : Real = 40.0; - attribute cycleTime : Real = 60.0; - attribute capacitorUsage : Real = 5.0; - redefines mass : Real = 500.0; // Mass in kg - redefines powerUsage = 5.0; + attribute miningYield : Real; + attribute cycleTime : Real; + attribute capacitorUsage : Real; + attribute range : Real; + redefines mass : Real; + redefines powerUsage; port highSlot : ~HighSlotPort; + + // **Action: Extract Ore + perform action extractOre { + in miningLaserPowerSupply : Real; + in miningLaserTarget : ModuleCommand; + out miningLaserStatus : ModuleReport; + } + } + + part def 'EP-S Gaussian Scoped Mining Laser' :> MinerModule { + doc /* Standard mining laser used on mining frigates for ore extraction. */ + redefines miningYield : Real = 50.0; + redefines cycleTime : Real = 60.0; + redefines capacitorUsage : Real = 5.0; + redefines range : Real = 16.0; + redefines mass : Real = 500.0; // Mass in kg + redefines powerUsage = 3.0; + } + part 'Mining Laser EP-S Gaussian Scoped' : 'EP-S Gaussian Scoped Mining Laser'; + + part def MinerI :> MinerModule { + doc /* Standard mining laser used on mining frigates for ore extraction. */ + redefines miningYield : Real = 40.0; + redefines cycleTime : Real = 60.0; + redefines capacitorUsage : Real = 5.0; + redefines range : Real = 10.0; + redefines mass : Real = 500.0; // Mass in kg + redefines powerUsage = 2.0; + } + part minerI : MinerI; + + part def 'Particle Bore Compact Mining Laser' :> MinerModule { + doc /* Standard mining laser used on mining frigates for ore extraction. */ + redefines miningYield : Real = 50.0; + redefines cycleTime : Real = 60.0; + redefines capacitorUsage : Real = 5.0; + redefines range : Real = 11.0; + redefines mass : Real = 500.0; // Mass in kg + redefines powerUsage = 2.0; } - + part 'Mining Laser Particle Bore Compact' : 'Particle Bore Compact Mining Laser'; + part def Afterburner :> SimpleFrigateComponent { doc /* Improves sublight speed by increasing thrust. */ attribute velocityBonus : Real = 112.5; @@ -68,4 +117,11 @@ port lowSlot : ~LowSlotPort; } + + part def DroneLinkAugmentor :> SimpleFrigateComponent { + doc /* These modules extend your drone control range. Drone Link Augmentors + * can be useful for drone ships and ships with nothing else to fit in their spare highslots. */ + + port highSlot : ~HighSlotPort; + } } \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigate.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigate.sysml deleted file mode 100644 index e6fceb3..0000000 --- a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigate.sysml +++ /dev/null @@ -1,93 +0,0 @@ -package MiningFrigateSolutionSpace { - - private import Domain::*; - private import ScalarValues::*; - private import COTS::*; - private import StdPortsAndInterfaces::*; - private import ParametersOfInterestMetadata::*; - private import FrigateRollupAnalysis::*; - private import MiningFrigateHullHighLevelActions::*; - - // **Mining Frigate as the Core System** - part def MiningFrigate :> CompositeFrigateComponent { - doc /* The Mining Frigate consists of a fixed hull structure with modular (COTS) components - * that can be replaced or upgraded depending on operational needs. */ - - part hull : MiningFrigateHull; - - // **COTS Modules (Ref Parts - Exchangeable)** - ref part miningLaser : MinerI[2]; - ref part propulsionModule : Afterburner[0..1]; - ref part shieldModule : SmallShieldExtenderI[0..1]; - ref part capacitorModule : SmallCapBatteryI[0..1]; - ref part sensorModule : SurveyScannerI[0..1]; - ref part defensiveModule : WarpCoreStabilizerI[0..2]; - - interface highSlotInterface1 : HighSlotInterface connect - hullPort ::> hull.highSlot1 to - modulePort ::> miningLaser.highSlot; - - interface highSlotInterface2 : HighSlotInterface connect - hullPort ::> hull.highSlot2 to - modulePort ::> miningLaser.highSlot; - - interface mediumSlotInterface1 : MediumSlotInterface connect - hullPort ::> hull.mediumSlot1 to - modulePort ::> propulsionModule.mediumSlot; - - interface mediumSlotInterface2 : MediumSlotInterface connect - hullPort ::> hull.mediumSlot2 to - modulePort ::> shieldModule.mediumSlot; - - interface lowSlotInterface1 : LowSlotInterface connect - hullPort ::> hull.lowSlot1 to - modulePort ::> defensiveModule.lowSlot; - - interface lowSlotInterface2 : LowSlotInterface connect - hullPort ::> hull.lowSlot2 to - modulePort ::> defensiveModule.lowSlot; - } - - // **Mining Frigate Hull (Black Box with Ports)** - part def MiningFrigateHull :> SimpleFrigateComponent { - doc /* The Venture-class Mining Frigate hull includes integrated features such as - * a built-in warp core stabilizer, ore hold, and base resistances. */ - - attribute hullHP : Real = 400.0; - attribute armorHP : Real = 400.0; - attribute shieldHP : Real = 700.0; - attribute oreHoldCapacity : Real = 5000.0; - attribute maxVelocity : Real = 335.0; - attribute warpSpeed : Real = 5.0; - attribute capacitorCapacity : Real = 250.0; - - // Performed actions of the hull (executed by the ship's integrated systems) - perform action scanForThreats; - perform action engageDefenses; - perform action acceptDestination; - perform action plotOptimalCourse; - perform action engagePropulsion; - perform action monitorAndAdjustCourse; - perform action transferOre; - perform action verifyCargoTransfer; - perform action dockToStation; - perform action undockFromStation; - perform action resupplyCapacitor; - perform action activateMiningLaser; - - // **Ports for COTS Modules** - port highSlot1 : HighSlotPort; - port highSlot2 : HighSlotPort; - port mediumSlot1 : MediumSlotPort; - port mediumSlot2 : MediumSlotPort; - port lowSlot1 : LowSlotPort; - port lowSlot2 : LowSlotPort; - } - - // **Power and Control Interfaces Items inherited from the standardPorts items** - item def VenturePowerSupply :> PowerSupply ; - item def VentureHighSlotCommand :> HighSlotCommand ; - item def VentureMediumSlotCommand :> MediumSlotCommand ; - item def VentureLowSlotCommand :> LowSlotCommand ; - -} diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateHull.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateHull.sysml new file mode 100644 index 0000000..a8e921e --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateHull.sysml @@ -0,0 +1,52 @@ +package MiningFrigateHull { + + private import DomainPackage::*; + private import MiningFrigatePackage::*; + private import ScalarValues::*; + private import COTS::*; + private import StdPortsAndInterfaces::*; + private import FrigateRollupAnalysis::*; + private import MiningFrigateActions_logical::*; + + //Mining Frigate Hull (Black Box with Ports) + part def LogicalMiningFrigateHull :> SimpleFrigateComponent { + doc /* The Venture-class Mining Frigate hull includes integrated features such as + * a built-in warp core stabilizer, ore hold, and base resistances. */ + + attribute hullHP : Real = 400.0; + attribute armorHP : Real = 400.0; + attribute shieldHP : Real = 700.0; + attribute oreHoldCapacity : Real = 5000.0; + attribute maxVelocity : Real = 335.0; + attribute warpSpeed : Real = 5.0; + attribute capacitorSize : Real = 250.0; + attribute warpCoreStrenght : Real = 2.0; + + //Performed actions of the hull (executed by the ship's integrated systems) + + perform activateMiningLaser_logical.activateLaserTurret; + //perform action manageEnergy : MiningFrigateHullActions::ManageEnergy; + //perform action detectThreat : MiningFrigateHullActions::DetectThreat; + //perform action engageDefenses : MiningFrigateHullActions::EngageDefenses; + //perform action navigateToDestination : MiningFrigateHullActions::NavigateToDestination; + //perform action reportToPilot : MiningFrigateHullActions::ReportToPilot; + //perform action transferOre : MiningFrigateHullActions::TransferOre; + //perform action dockToStation : MiningFrigateHullActions::DockToStation; + //perform action checkAsteroidStatus : MiningFrigateHullActions::CheckAsteroidStatus; + //perform action resupplyCapacitor : MiningFrigateHullActions::ResupplyCapacitor; + + //Ports for COTS Modules + port highSlot1 : HighSlotPort; + port highSlot2 : HighSlotPort; + port mediumSlot1 : MediumSlotPort; + port mediumSlot2 : MediumSlotPort; + port lowSlot1 : LowSlotPort; + port lowSlot2 : LowSlotPort; + + //Ports bound to the LogicalMiningFrigateConfiguration + port hullControlPort : ~PodPort; + port hullDockingPort : ~DockingPort; + port hullDefensePort : ~ThreatPort; + port hullDroneControlPort: ~DroneControllerPort; + } +} \ No newline at end of file diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateLogical.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateLogical.sysml new file mode 100644 index 0000000..7f6a7fc --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateLogical.sysml @@ -0,0 +1,208 @@ +package MiningFrigateSolutionSpace { + + private import DomainPackage::*; + private import MiningFrigatePackage::*; + private import ScalarValues::*; + private import COTS::*; + private import StdPortsAndInterfaces::*; + private import ParametersOfInterestMetadata::*; + private import FrigateRollupAnalysis::*; + private import MiningFrigateHullActions::*; + private import MiningFrigateActions_logical::*; + private import MiningFrigateHull::*; + + //The LogicalMiningFrigate is a spezialisation of the MiningFrigate and inherits all its features + abstract part def LogicalMiningFrigateConfiguration :> CompositeFrigateComponent, MiningFrigate { + doc /* The Mining Frigate consists of a fixed hull structure with modular (COTS) components + * that can be replaced or upgraded depending on operational needs. */ + + part Hulllogical : LogicalMiningFrigateHull :> miningFrigate.coreSystem ; + + //The parts of the LogicalMiningFrigate are a subset of the parts of the MiningFrigate + // COTS Modules (Ref Parts - Exchangeable) + //the mining laser is available in three variants + variation ref part miningLaserlogical : MinerModule[2] :> miningFrigate.miningLaser { + variant 'Mining Laser EP-S Gaussian Scoped'; + variant 'Mining Laser Particle Bore Compact'; + variant minerI : MinerI; + } + ref part propulsionModulelogical : Afterburner[0..1] :> miningFrigate.propulsionModule; + ref part shieldModulelogical : SmallShieldExtenderI[0..1] :> miningFrigate.shieldModule; + ref part capacitorModulelogical : SmallCapBatteryI[0..1] :> miningFrigate.capacitorBooster; + ref part sensorModulelogical : SurveyScannerI[0..1] :> miningFrigate.sensorModule; + ref part warpCoreStabilizerlogical : WarpCoreStabilizerI[0..2] :> miningFrigate.warpCoreStabilizer; + + //internal conexions between parts of the LogicalMiningFrigateConfiguration + interface highSlotInterface1 : HighSlotInterface connect + hullPort ::> Hulllogical.highSlot1 to + modulePort ::> miningLaserlogical.highSlot; + + interface highSlotInterface2 : HighSlotInterface connect + hullPort ::> Hulllogical.highSlot2 to + modulePort ::> miningLaserlogical.highSlot; + + interface mediumSlotInterface1 : MediumSlotInterface connect + hullPort ::> Hulllogical.mediumSlot1 to + modulePort ::> propulsionModulelogical.mediumSlot; + + interface mediumSlotInterface2 : MediumSlotInterface connect + hullPort ::> Hulllogical.mediumSlot2 to + modulePort ::> shieldModulelogical.mediumSlot; + + interface lowSlotInterface1 : LowSlotInterface connect + hullPort ::> Hulllogical.lowSlot1 to + modulePort ::> warpCoreStabilizerlogical.lowSlot; + + //the ports of the LogicalMiningFrigateConfiguration are bound to the ports of the LogicalMiningFriagteHull + //the external ports of LogicalMiningFrigateConfiguration are not redefined because they must be same as the ones at the problem space. + bind controlPort = Hulllogical.hullControlPort; + bind dockingPort = Hulllogical.hullDockingPort; + bind defensePort = Hulllogical.hullDefensePort; + bind droneControlPort = Hulllogical.hullDroneControlPort; + + } + + //An abstract frigate is defined here, that will be used as a basis to define possible frigate configurations. + abstract part logicalMiningFrigateConfiguration : LogicalMiningFrigateConfiguration { + + //the state of the LogicalMiningFrigateConfiguration is redefined from the problem space + state logicalMiningFrigateStates :>> miningFrigate.miningFrigatesStates { + + entry; + then Dockedlogical; //boarding a ship is not modeled. + + state Packagedlogical { + doc /* The mining frigate is packaged inside a station and can be cargoed. */ + } + state Parkedlogical { + doc /* The mining frigate is parked inside a station, but not boarded by a pod. */ + } + state Dockedlogical { + doc /* The mining frigate is inside a station, available for refitting, resupply, or cargo transfer. */ + } + state InGridlogical { + doc /* The mining frigate is in open space, near asteroids, stations, or other celestial objects. */ + } + state OnWarplogical { + doc /* The mining frigate is in warp, traveling between locations. */ + } + + transition docked_to_inGridlogical + first Dockedlogical + accept pilotPodUndockCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action undockFromStation_logical : UndockFromStation_logical {in undockCommand = pilotPodUndockCommandSig;} + then InGridlogical; + + transition inGrid_to_dockedlogical + first InGridlogical + accept pilotPodDockCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action dockToStation_logical : DockToStation_logical {in dockCommand = pilotPodDockCommandSig;} + then Dockedlogical; + + transition inGrid_to_onWarplogical + first InGridlogical + accept warpCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action executeWarpDrive_logical : ExecuteWarpDrive_logical {in warpCommand = warpCommandSig;} + then OnWarplogical; + + transition onWarp_to_inGridlogical + first OnWarplogical + accept when logicalMiningFrigateConfiguration.warpBubbleEnd + then InGridlogical; + + //Internal transitions + transition unloadCargological + first Dockedlogical + accept unloadCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action transferOre_logical : TransferOre_logical {in unloadCommand = unloadCommandSig;} + then Dockedlogical; + + transition cycleMininglogical + first InGridlogical + accept miningCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action activateMiningLaser_logical : ActivateMiningLaser_logical + then InGridlogical; + + transition scanThreatslogical + first InGridlogical + accept scanCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action scanForThreats_logical : ScanForThreats_logical {in scanCommand = scanCommandSig;} + then InGridlogical; + + transition prioritizeThreatlogical + first InGridlogical + accept threatSignatureSig : ScanSignature via logicalMiningFrigateConfiguration.controlPort + do action prioritizeThreats_logical : PrioritizeThreats_logical {in detectedThreats = threatSignatureSig;} + then InGridlogical; + + transition deployDroneslogical + first InGridlogical + accept droneCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action selectDronesForDeployment_logical : SelectDronesForDeployment_logical {in droneCommand = droneCommandSig;} + then InGridlogical; + + transition navigationlogical + first InGridlogical + accept destinationCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action acceptDestination_logical : AcceptDestination_logical {in destinationCommand = destinationCommandSig;} + then InGridlogical; + + transition coursePlotlogical + first InGridlogical + accept courseCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action plotOptimalCourse_logical : PlotOptimalCourse_logical + then InGridlogical; + + transition engagingPropulsionlogical + first InGridlogical + accept propulsionCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action engagePropulsion_logical : EngagePropulsion_logical { in engagePropulsion = propulsionCommandSig;} + then InGridlogical; + + transition adjustingCourselogical + first InGridlogical + accept courseCorrectionSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action monitorAndAdjustCourse_logical : MonitorAndAdjustCourse_logical + then InGridlogical; + + transition cargoVerificationlogical + first Dockedlogical + accept warehouseStatusCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action verifyCargoTransfer_logical : VerifyResupply_logical {in warehouseStatusCommand = warehouseStatusCommandSig;} + then Dockedlogical; + + transition detectingThreatlogical + first InGridlogical + accept threatScanCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action detectThreat_logical : DetectThreat_logical {in scanCommand = threatScanCommandSig;} + then InGridlogical; + + transition engagingDefenseslogical + first InGridlogical + accept defenseCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action engageDefenses_logical : EngageDefenses_logical {in engageCommand = defenseCommandSig;} + then InGridlogical; + + transition resupplyinglogical + first Dockedlogical + accept shipStatusCommandSig : ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action verifyResupply_logical : VerifyCargoTransfer_logical + then Dockedlogical; + } + + } + + //Three different configurations of mining frigatte are defined here that base on an abstract frigate + part logicalNoviceMiningFrigatte :> logicalMiningFrigateConfiguration{ + part redefines miningLaserlogical = miningLaserlogical::minerI; + } + + part logicalTrainerMiningFrigate :> logicalMiningFrigateConfiguration{ + part redefines miningLaserlogical = miningLaserlogical::'Mining Laser Particle Bore Compact'; + } + + part logicalFieldMiningFrigate :> logicalMiningFrigateConfiguration{ + part redefines miningLaserlogical = miningLaserlogical::'Mining Laser EP-S Gaussian Scoped'; + } + +} diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml index 0e49b1e..8dd94ce 100644 --- a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml @@ -1,146 +1,14 @@ -package MiningFrigateHullUseCasesUsage { - - private import MiningFrigateHullUseCasesDef::*; - private import Domain::*; - - // **Use Case Usage: Withstand Incoming Damage** - use case withstandIncomingDamage : WithstandIncomingDamage { - first start; - - then include use case detectThreat : DetectThreat { - actor :>> pilotPod = withstandIncomingDamage::pilotPod; - } - - then include use case engageDefenses : EngageDefenses { - actor :>> pilotPod = withstandIncomingDamage::pilotPod; - actor :>> hostileShip = withstandIncomingDamage::hostileShip; - } - - then done; - } - - // **Use Case Usage: Navigate and Warp to Destinations** - use case navigateAndWarp : NavigateAndWarp { - first start; - - then include use case navigateToDestination : NavigateToDestination { - actor :>> pilotPod = navigateAndWarp::pilotPod; - } - - then done; - } - - // **Use Case Usage: Store and Transfer Mined Ore** - use case storeAndTransferOre : StoreAndTransferOre { - first start; - - then include use case transferOre : TransferOre { - actor :>> pilotPod = storeAndTransferOre::pilotPod; - actor :>> station = storeAndTransferOre::station; - } - - then done; - } - - // **Use Case Usage: Dock and Undock from Stations** - use case dockAndUndock : DockAndUndock { - first start; - - then include use case dockAtStation : DockAtStation { - actor :>> pilotPod = dockAndUndock::pilotPod; - actor :>> station = dockAndUndock::station; - } - - then done; - } - - // **Use Case Usage: Manage Energy Supply and Recharge** - use case manageEnergy : ManageEnergy { - first start; - - then include use case resupplyCapacitor : ResupplyCapacitor { - actor :>> pilotPod = manageEnergy::pilotPod; - actor :>> smallCapBatteryI = manageEnergy::smallCapBatteryI; - } - - then done; - } - - // **Use Case Usage: Support High, Medium, and Low Slot Modules** - use case supportModuleFitting : SupportModuleFitting { - first start; - - then include use case activateMiningLaser : ActivateMiningLaser { - actor :>> miningLaser = supportModuleFitting::miningLaser; - } - - then done; - } -} - - -package MiningFrigateHullUseCasesDef { +package MiningFrigateHullUseCases { private import MiningFrigateSolutionSpace::*; - private import Domain::*; + private import DomainPackage::*; private import COTS::*; - - // **Use Case: Withstand Incoming Damage** - use case def WithstandIncomingDamage { - subject hull : MiningFrigateHull; - actor hostileShip : Domain::HostileShip; - actor pilotPod : Domain::PilotPod; - - objective { - doc /* - * The Mining Frigate Hull shall sustain damage from hostile ships while ensuring pilot safety. - */ - } - } - - // **Use Case: Navigate and Warp to Destinations** - use case def NavigateAndWarp { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; - - objective { - doc /* - * The Mining Frigate Hull shall navigate between celestial bodies using its onboard navigation system. - */ - } - } - - // **Use Case: Store and Transfer Mined Ore** - use case def StoreAndTransferOre { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; - actor station : Domain::Station; - - objective { - doc /* - * The Mining Frigate Hull shall store extracted ore in its ore hold - * and transfer it to a station or fleet hauler when required. - */ - } - } - - // **Use Case: Dock and Undock from Stations** - use case def DockAndUndock { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; - actor station : Domain::Station; - - objective { - doc /* - * The Mining Frigate Hull shall support docking and undocking operations at stations or other docking structures. - */ - } - } + private import MiningFrigateHull::*; // **Use Case: Manage Energy Supply and Recharge** - use case def ManageEnergy { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; + use case ManageEnergy { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; actor smallCapBatteryI : SmallCapBatteryI; objective { @@ -150,23 +18,10 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case: Support High, Medium, and Low Slot Modules** - use case def SupportModuleFitting { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; - actor miningLaser : MinerI; - - objective { - doc /* - * The Mining Frigate Hull shall host configurable module slots for different mission profiles. - */ - } - } - - // **Use Case Definition: Detect Threat** - use case def DetectThreat { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; + // **Use Case: Detect Threat** + use case DetectThreat { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; objective { doc /* @@ -176,11 +31,11 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Engage Defenses** - use case def EngageDefenses { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; - actor hostileShip : Domain::HostileShip; + // **Use Case: Engage Defenses** + use case EngageDefenses { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; + actor hostileShip : HostileShip; objective { doc /* @@ -190,10 +45,10 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Navigate to Destination** - use case def NavigateToDestination { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; + // **Use Case: Navigate to Destination** + use case NavigateToDestination { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; objective { doc /* @@ -203,11 +58,11 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Transfer Ore** - use case def TransferOre { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; - actor station : Domain::Station; + // **Use Case: Transfer Ore** + use case TransferOre { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; + actor station : Station; objective { doc /* @@ -216,11 +71,11 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Dock at Station** - use case def DockAtStation { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; - actor station : Domain::Station; + // **Use Case: Dock to Station** + use case DockToStation { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; + actor station : Station; objective { doc /* @@ -230,10 +85,10 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Resupply Capacitor** - use case def ResupplyCapacitor { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; + // **Use Case: Resupply Capacitor** + use case ResupplyCapacitor { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; actor smallCapBatteryI : SmallCapBatteryI; objective { @@ -243,10 +98,10 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Activate Mining Laser** - use case def ActivateMiningLaser { - subject hull : MiningFrigateHull; - actor pilotPod : Domain::PilotPod; + // **Use Case: Activate Mining Laser** + use case ActivateMiningLaser { + subject hull : LogicalMiningFrigateHull; + actor pilotPod : PilotPod; actor miningLaser : MinerI; objective { diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/standardPortsAndInterfaces.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/standardPortsAndInterfaces.sysml index 0ac5ed0..b287b91 100644 --- a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/standardPortsAndInterfaces.sysml +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/standardPortsAndInterfaces.sysml @@ -35,8 +35,8 @@ package StdPortsAndInterfaces { // **High Slot Interface (Power + Activation Command)** interface def HighSlotInterface { - end hullPort : HighSlotPort; - end modulePort : ~HighSlotPort; + end hullPort : ~HighSlotPort; + end modulePort : HighSlotPort; flow of PowerSupply from hullPort.power to modulePort.power; flow of HighSlotCommand from hullPort.control to modulePort.control; @@ -44,8 +44,8 @@ package StdPortsAndInterfaces { // **Medium Slot Interface (Power + Activation Command)** interface def MediumSlotInterface { - end hullPort : MediumSlotPort; - end modulePort : ~MediumSlotPort; + end hullPort : ~MediumSlotPort; + end modulePort : MediumSlotPort; flow of PowerSupply from hullPort.power to modulePort.power; flow of MediumSlotCommand from hullPort.control to modulePort.control; @@ -53,8 +53,8 @@ package StdPortsAndInterfaces { // **Low Slot Interface (Activation Command Only)** interface def LowSlotInterface { - end hullPort : LowSlotPort; - end modulePort : ~LowSlotPort; + end hullPort : ~LowSlotPort; + end modulePort : LowSlotPort; flow of LowSlotCommand from hullPort.control to modulePort.control; } diff --git a/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml b/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml index 60fb37d..745ba65 100644 --- a/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml +++ b/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml @@ -1,8 +1,7 @@ package OperationalUseCaseActions { - private import Domain::*; + private import DomainPackage::*; private import ScalarValues::*; - private import MiningFrigate::*; // Operational Action Definitions for the Mining Frigate @@ -10,7 +9,7 @@ package OperationalUseCaseActions { action def IdentifyDestination { doc /* Identify an asteroid belt or a target asteroid. */ - out targetSignature : Domain::ScanSignature; + out targetSignature : ScanSignature; } action def ActivateMiningLaser { @@ -32,20 +31,22 @@ package OperationalUseCaseActions { * - If capacitor energy is insufficient, fail to activate laser and notify the pilot. * - If ECM interference disrupts target lock, pause extraction until lock is re-established. */ + in activateMiningLaser : ShipCommand; + out miningCycleReport : ShipReport; } // Main Use Case definition : Detect Threats and Engage Defenses action def ScanForThreats { doc /* Scan the surrounding space for potential threats. */ - in scanCommand : Domain::ShipCommand; - out detectedThreats : Domain::ScanSignature; - out scanReport : Domain::ShipReport; + in scanCommand : ShipCommand; + out detectedThreats : ScanSignature; + out scanReport : ShipReport; } action def PrioritizeThreats { doc /* Evaluate detected threats and prioritize response actions. */ - in detectedThreats : Domain::ScanSignature; + in detectedThreats : ScanSignature; out threatPriority : String; } @@ -53,22 +54,22 @@ package OperationalUseCaseActions { action def UndockFromStation { doc /*Undock from a station.*/ - in undockCommand : Domain::ShipCommand; + in undockCommand : ShipCommand; } action def ExecuteWarpDrive { doc /* Engage the warp drive to travel to the destination. */ - in warpCommand : Domain::ShipCommand; - out warpStatusReport : Domain::ShipReport; + in warpCommand : ShipCommand; + out warpStatusReport : ShipReport; } // Main Use Case definition : Offload Ore and Resupply action def DockToStation { doc /*Dock into a station to make repairs, resupply capacitor and support systems.*/ - in dockCommand : Domain::ShipCommand; - in charge : Domain::Power; - out dockingReport : Domain::ShipReport; + in dockCommand : ShipCommand; + in charge : Power; + out dockingReport : ShipReport; } @@ -76,72 +77,72 @@ package OperationalUseCaseActions { action def SelectDronesForDeployment { doc /* Select drones for deployment based on operational needs (mining or defense). */ - in droneCommand : Domain::ShipCommand; - out selectedDrones : Domain::Drone; + in droneCommand : ShipCommand; + out selectedDrones : Drone; } // Included Use Case definition : Navigate to Destination action def AcceptDestination { doc /*Accept a destination from the pilot. */ - in destinationCommand : Domain::ShipCommand; - out destinationReport : Domain::ShipReport; + in destinationCommand : ShipCommand; + out destinationReport : ShipReport; } action def PlotOptimalCourse { doc /*Plot the optimal course using the navigation system.*/ - out optimalCourseReport : Domain::ShipReport; + out optimalCourseReport : ShipReport; } action def EngagePropulsion { doc /*Engage the propulsion system to travel along the plotted course. * Propulsion does not use items (fuel, power) in Eve Online. */ - in engagePropulsion : Domain::ShipCommand; - out propulsionEngagedReport : Domain::ShipReport; + in engagePropulsion : ShipCommand; + out propulsionEngagedReport : ShipReport; } action def MonitorAndAdjustCourse { doc /*Continuously monitor progress and adjust the course as needed.*/ - out selectedCourseReport : Domain::ShipReport; + out selectedCourseReport : ShipReport; } // Included Use Case definition : Transfer Cargo action def TransferOre { doc /*Transfer ore or other cargo to the appropriate storage location.*/ - in unloadCommand : Domain::ShipCommand; - out oreCargo : Domain::CargoContainer; - out storageReport : Domain::ShipReport; + in unloadCommand : ShipCommand; + out oreCargo : CargoContainer; + out storageReport : ShipReport; } action def VerifyCargoTransfer { doc /*Verify the transfer has been completed successfully.*/ - in warehouseStatusCommand : Domain::StationCommand; - out warehouseReport : Domain::StationReport; + in warehouseStatusCommand : StationCommand; + out warehouseReport : StationReport; } // Included Use Case definition : Engage Defense Systems action def DetectThreat { doc /*Detect and classify threats using the sensor array.*/ - in scanCommand : Domain::ShipCommand; - in threatSignature : Domain::ScanSignature; - out scanReport : Domain::ShipReport; + in scanCommand : ShipCommand; + in threatSignature : ScanSignature; + out scanReport : ShipReport; } action def EngageDefenses { doc /*Activate defense turrets and deploy drones to neutralize threats.*/ - in engageCommand : Domain::ShipCommand; - out firePower: Domain::Power; - out damageReport : Domain::ShipReport; + in engageCommand : ShipCommand; + out firePower: Power; + out damageReport : ShipReport; } // Included Use Case definition : Resupply Systems action def VerifyResupply { doc /*Verify the resupply is completed successfully.*/ - in shipStatusCommand : Domain::ShipCommand; - out shipStatusReport : Domain::ShipReport; + in shipStatusCommand : ShipCommand; + out shipStatusReport : ShipReport; } } diff --git a/models/example_EveOnlineMiningFrigate/UseCases/UseCasesFrigate.sysml b/models/example_EveOnlineMiningFrigate/UseCases/UseCasesFrigate.sysml index a378c4c..4d635b0 100644 --- a/models/example_EveOnlineMiningFrigate/UseCases/UseCasesFrigate.sysml +++ b/models/example_EveOnlineMiningFrigate/UseCases/UseCasesFrigate.sysml @@ -1,9 +1,9 @@ package MiningFrigateUseCases { // Import the Domain package for referencing actors - private import Domain::*; + private import DomainPackage::*; private import MiningFrigateRequirements::*; - private import MiningFrigate::*; + private import MiningFrigatePackage::*; //Use Cases of the Mining Frigate @@ -64,8 +64,8 @@ package MiningFrigateUseCases { // Included Use Case definition : Navigate to Destination use case def NavigateToDestination { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor pilotPod : Domain::PilotPod; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor pilotPod : DomainPackage::PilotPod; objective { doc /* Main Flow: @@ -86,8 +86,8 @@ package MiningFrigateUseCases { // Included Use Case definition : Transfer Cargo use case def TransferCargo { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor pilotPod : Domain::PilotPod; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor pilotPod : DomainPackage::PilotPod; objective { doc /* Main Flow: @@ -102,9 +102,9 @@ package MiningFrigateUseCases { // Included Use Case definition : Engage Defense Systems use case def EngageDefenseSystems { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor hostileShip : Domain::HostileShip; - actor pilotPod : Domain::PilotPod; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor hostileShip : DomainPackage::HostileShip; + actor pilotPod : DomainPackage::PilotPod; objective { doc /* Main Flow: * 1. Detect and classify threats using the sensor array. @@ -119,8 +119,8 @@ package MiningFrigateUseCases { // Included Use Case definition : Resupply Systems use case def ResupplySystems { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor station : Domain::Station; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor station : DomainPackage::Station; objective { doc /* Main Flow: @@ -135,9 +135,9 @@ package MiningFrigateUseCases { // Main Use Case definition : Mine Asteroids use case def MineAsteroids { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor pilotPod : Domain::PilotPod; - actor asteroidBelt : Domain::AsteroidBelt; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor pilotPod : DomainPackage::PilotPod; + actor asteroidBelt : DomainPackage::AsteroidBelt; objective { doc /* Main Flow: * 1. Identify an asteroid belt and select a target asteroid. @@ -158,9 +158,9 @@ package MiningFrigateUseCases { // Main Use Case definition : Detect Threats and Engage Defenses use case def DetectThreatsAndEngageDefenses { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor hostileShip : Domain::HostileShip; - actor pilotPod : Domain::PilotPod; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor hostileShip : DomainPackage::HostileShip; + actor pilotPod : DomainPackage::PilotPod; objective { doc /* Main Flow: @@ -180,9 +180,9 @@ package MiningFrigateUseCases { // Main Use Case definition : Plot Course and Navigate use case def PlotCourseAndNavigate { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor pilotPod : Domain::PilotPod; - actor station : Domain::Station; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor pilotPod : DomainPackage::PilotPod; + actor station : DomainPackage::Station; objective { doc /* Main Flow: @@ -202,8 +202,8 @@ package MiningFrigateUseCases { // Main Use Case definition : Offload Ore and Resupply use case def OffloadOreAndResupply { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor station : Domain::Station; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor station : DomainPackage::Station; objective { doc /* Main Flow: @@ -225,9 +225,9 @@ package MiningFrigateUseCases { // Main Use Case definition : Deploy Drones use case def DeployDrones { - subject miningFrigate : MiningFrigate::MiningFrigate; - actor pilotPod : Domain::PilotPod; - actor hostileShip : Domain::HostileShip; + subject miningFrigate : MiningFrigatePackage::MiningFrigate; + actor pilotPod : DomainPackage::PilotPod; + actor hostileShip : DomainPackage::HostileShip; objective { doc /* Main Flow: diff --git a/models/example_family/family.png b/models/example_family/family.png new file mode 100644 index 0000000..1a400a6 Binary files /dev/null and b/models/example_family/family.png differ diff --git a/models/example_family/family.sysml b/models/example_family/family.sysml index f52b657..68020f5 100644 --- a/models/example_family/family.sysml +++ b/models/example_family/family.sysml @@ -1,6 +1,7 @@ package Family { doc /* This package defines a family */ + //verified with SysIDE Modeler //Import packages private import ScalarValues::Natural; @@ -38,7 +39,7 @@ package Family { item def AssertCertificate :> SoundWaveMessage; //parts definitions - part def Person{ + part def Person { doc /* Person is the most generic part representing people */ attribute name : Name; @@ -121,7 +122,7 @@ package Family { end parent2 : Person[1]; end certifiedChild : Child[1]; timeslice adopted[1]{ - snapshot certificate_valid_from = start; + snapshot certificate_valid = start; } } // action definition @@ -148,17 +149,18 @@ package Family { //constraints definition constraint minimumAgeForAdoptiveParenthood { - attribute adoptingPartyAge : Natural; - adoptingPartyAge >= 18 + attribute minAdoptingPartyAge : Natural; + minAdoptingPartyAge == 18 } //requirements definition requirement def LegalAdoptionParenthood { doc /* the age of a legal adoptive parent must be more than 18 years */ - attribute parentAge : Natural; - require minimumAgeForAdoptiveParenthood { - parentAge = adoptingPartyAge; + attribute parent1Age : Natural; + attribute parent2Age : Natural; + require constraint minimumAgeForAdoptiveParenthood { + parent1Age >= minAdoptingPartyAge and parent2Age >= minAdoptingPartyAge } } //Interaction for the defined use case @@ -178,8 +180,8 @@ package Family { //Parts // Multiplicity [1] is default, but it is here displayed to emphasize the multiplicity. - part adult[*] : Person { - :>> isAdult = true; + part adult[*] : Family::Person { + attribute isAdultPerson : Boolean :>> isAdult = true; event occurrence informationOfLaw; then event occurrence acknowledgmentOfLaw; then event occurrence receivalOfCertificate; @@ -225,10 +227,10 @@ package Family { //requirements requirement validAdoptionParenthood : LegalAdoptionParenthood { doc - /*the age of both adoptive parents in a parenthood certificate Type C shall be more than 18 years */ + /*the age of an adoptive parent in a parenthood certificate Type C shall be more than 18 years */ subject adoption_certificate_TypeC; - attribute :>> adoptiveParent_1.age = parentAge; - attribute :>> adoptiveParent_2.age = parentAge; + attribute :>> parent1Age = adoptiveParent_1.age; + attribute :>> parent2Age = adoptiveParent_2.age; } } \ No newline at end of file