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/Concerns.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/Concerns.sysml index 206c315..4e87593 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/Concerns.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/Concerns.sysml @@ -34,9 +34,10 @@ package StakeholderConcerns { private import StakeholdersDef::*; private import MiningFrigate::*; + // 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 { + concern ProfitabilityConcern { subject miningCorporation : Domain::MiningCorporation; require constraint { @@ -47,7 +48,7 @@ package StakeholderConcerns { stakeholder miningCEO : MiningCEO; } - concern def OperationalCostsConcern { + concern OperationalCostsConcern { subject miningCorporation : Domain::MiningCorporation; require constraint { @@ -58,7 +59,7 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def ScalabilityConcern { + concern ScalabilityConcern { subject miningCorporation : Domain::MiningCorporation; assume constraint { @@ -69,7 +70,7 @@ package StakeholderConcerns { stakeholder fleetCommander : FleetCommander; } - concern def MarketResponsivenessConcern { + concern MarketResponsivenessConcern { subject miningCorporation : Domain::MiningCorporation; require constraint { @@ -82,7 +83,7 @@ package StakeholderConcerns { // Concerns Derived from the ConOps - concern def SecurityConcern { + concern SecurityConcern { subject miningFrigate : MiningFrigate::MiningFrigate; require constraint { @@ -94,7 +95,7 @@ package StakeholderConcerns { stakeholder shipEngineer : ShipEngineer; } - concern def ResourceAvailabilityConcern { + concern ResourceAvailabilityConcern { subject miningCorporation : Domain::MiningCorporation; require constraint { @@ -105,7 +106,7 @@ package StakeholderConcerns { stakeholder fleetCommander : FleetCommander; } - concern def DeploymentEfficiencyConcern { + concern DeploymentEfficiencyConcern { subject miningFrigate : MiningFrigate::MiningFrigate; require constraint { @@ -116,7 +117,7 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def ThreatNeutralizationConcern { + concern ThreatNeutralizationConcern { subject miningFrigate : MiningFrigate::MiningFrigate; require constraint { @@ -130,7 +131,7 @@ package StakeholderConcerns { // Concerns Derived from the MoEs - concern def TotalProfitabilityConcern { + concern TotalProfitabilityConcern { subject miningCorporation : Domain::MiningCorporation; require constraint { @@ -141,7 +142,7 @@ package StakeholderConcerns { stakeholder miningCEO : MiningCEO; } - concern def OreYieldConcern { + concern OreYieldConcern { subject miningFrigate : MiningFrigate::MiningFrigate; require constraint { @@ -152,7 +153,7 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def SurvivabilityConcern { + concern SurvivabilityConcern { subject miningFrigate : MiningFrigate::MiningFrigate; require constraint { @@ -163,7 +164,7 @@ package StakeholderConcerns { stakeholder shipEngineer : ShipEngineer; } - concern def FleetDeploymentEfficiencyConcern { + concern FleetDeploymentEfficiencyConcern { subject miningCorporation : Domain::MiningCorporation; require constraint { @@ -175,7 +176,7 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def OreDeliveryEfficiencyConcern { + concern OreDeliveryEfficiencyConcern { subject miningFrigate : MiningFrigate::MiningFrigate; require constraint { @@ -186,7 +187,7 @@ package StakeholderConcerns { stakeholder operationsManager : OperationsManager; } - concern def RiskAdjustedProfitabilityConcern { + concern RiskAdjustedProfitabilityConcern { subject miningCorporation : Domain::MiningCorporation; require constraint { @@ -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..eb59629 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/Domain.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/Domain.sysml @@ -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 { @@ -126,31 +126,28 @@ package Domain { */ } // % - //exhibits a predefined state - part miningFrigate : MiningFrigate::MiningFrigate [1..*] { - exhibit MiningFrigate::miningFrigatesStates { - in miningFrigates = miningFrigate; - } + part miningFrigate : 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 { @@ -241,6 +238,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 +285,7 @@ package Domain { out item droneReport : DroneReport; } - // Interface definition + // Interfaces definition interface def CommandIF { end controlSend : PodPort; end controlReceive : ~PodPort; @@ -373,5 +371,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/MiningFrigate.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigate.sysml index b45255c..ddbc4b7 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigate.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/MiningFrigate.sysml @@ -6,6 +6,7 @@ private import ParametersOfInterestMetadata::*; private import OperationalUseCaseActions::*; private import Domain::*; + private import StakeholderConcerns::*; part def MiningFrigate :> Domain::Spaceship { @@ -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 + part warpCoreStabilizer: WarpCoreStabilizer [0..*]; // Optional defense modules ref part cargo : Domain::CargoContainer [0..*]; ref part charge : Domain::Power; ref part drone : Domain::Drone [0..5]; port controlPort : ~Domain::PodPort; port dockingPort : ~Domain::DockingPort; - port DefensePort : ~Domain::ThreatPort; + port defensePort : ~Domain::ThreatPort; port asteroidOrePort : ~Domain::AsteroidOrePort; - port droneControlPort: ~Domain::DroneControllerPort; - - //actions declaration - action activateMiningLaser : ActivateMiningLaser { - } - + port droneControlPort: ~Domain::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 : Domain::ShipCommand via miningFrigate.controlPort + do action undockFromStation : UndockFromStation {in undockCommand = pilotPodUndockCommandSig;} + then InGrid; + + transition inGrid_to_docked + first InGrid + accept pilotPodDockCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action dockToStation : DockToStation {in dockCommand = pilotPodDockCommandSig;} + then Docked; + + transition inGrid_to_onWarp + first InGrid + accept warpCommandSig : Domain::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 : Domain::ShipCommand via miningFrigate.controlPort + do action transferOre : TransferOre {in unloadCommand = unloadCommandSig;} + then Docked; + + transition cycleMining + first InGrid + accept miningCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action activateMiningLaser : ActivateMiningLaser + then InGrid; + + transition scanThreats + first InGrid + accept scanCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action scanForThreats : ScanForThreats {in scanCommand = scanCommandSig;} + then InGrid; + + transition prioritizeThreat + first InGrid + accept threatSignatureSig : Domain::ScanSignature via miningFrigate.controlPort + do action prioritizeThreats : PrioritizeThreats {in detectedThreats = threatSignatureSig;} + then InGrid; + + transition deployDrones + first InGrid + accept droneCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action selectDronesForDeployment : SelectDronesForDeployment {in droneCommand = droneCommandSig;} + then InGrid; + + transition navigation + first InGrid + accept destinationCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action acceptDestination : AcceptDestination {in destinationCommand = destinationCommandSig;} + then InGrid; + + transition coursePlot + first InGrid + accept courseCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action plotOptimalCourse : PlotOptimalCourse + then InGrid; + + transition engagingPropulsion + first InGrid + accept propulsionCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action engagePropulsion : EngagePropulsion { in engagePropulsion = propulsionCommandSig;} + then InGrid; + + transition adjustingCourse + first InGrid + accept courseCorrectionSig : Domain::ShipCommand via miningFrigate.controlPort + do action monitorAndAdjustCourse : MonitorAndAdjustCourse + then InGrid; + + transition cargoVerification + first Docked + accept warehouseStatusCommandSig : Domain::StationCommand via miningFrigate.controlPort + do action verifyCargoTransfer : VerifyCargoTransfer {in warehouseStatusCommand = warehouseStatusCommandSig;} + then Docked; + + transition detectingThreat + first InGrid + accept threatScanCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action detectThreat : DetectThreat {in scanCommand = threatScanCommandSig;} + then InGrid; + + transition engagingDefenses + first InGrid + accept defenseCommandSig : Domain::ShipCommand via miningFrigate.controlPort + do action engageDefenses : EngageDefenses {in engageCommand = defenseCommandSig;} + then InGrid; + + transition resupplying + first Docked + accept shipStatusCommandSig : Domain::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/OPSCON.sysml b/models/example_EveOnlineMiningFrigate/DomainModel/OPSCON.sysml new file mode 100644 index 0000000..e4b5087 --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/DomainModel/OPSCON.sysml @@ -0,0 +1,129 @@ +package OPSCON { + + private import DocumentStructureMetadata::*; + + // The OPSCON document instance + #document OPSCON { + title = "OPSCON for Mining Frigate-Based Resource Extraction"; + status = "Draft"; + + // Chapter 1 – Mission Overview + #chapter missionOverview { + title = "1. Mission Overview"; + #section overviewSection { + heading = "Overview"; + 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 { + title = "2. Operational Context"; + #section environment { + heading = "Operational Environment"; + 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 { + title = "3. Actors and Roles"; + #section actorRoles { + heading = "Actor Definitions"; + 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 { + title = "4. System Elements"; + #section elementsOverview { + heading = "System Components"; + 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 { + title = "5. Use Case Overview"; + #section useCasesSummary { + heading = "Operational Use Cases"; + 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 { + title = "6. Operational Requirements"; + #section requirementSummary { + heading = "Performance and Capability Requirements"; + 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 { + title = "7. Verification Strategy"; + #section strategy { + heading = "Verification through Simulation and Testing"; + 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 { + title = "8. Measures of Effectiveness"; + #section moesSummary { + heading = "MoEs and Decision Criteria"; + 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 { + title = "9. Risk Considerations"; + #section riskAnalysis { + heading = "Risk-Adjusted Decision Making"; + 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 { + title = "10. Lifecycle Considerations"; + #section traceability { + heading = "Model Traceability and Lifecycle Use"; + 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..82f51d3 100644 --- a/models/example_EveOnlineMiningFrigate/DomainModel/cause-effect.sysml +++ b/models/example_EveOnlineMiningFrigate/DomainModel/cause-effect.sysml @@ -1,34 +1,34 @@ package causeEffect { - private import Domain::MiningCorporation::miningFrigate; + private import Domain::*; + private import MiningFrigate::*; 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::domain.miningCorporation.miningFrigate.miningRateIncreases to Domain::domain.asteroid.oreYieldIncreases; + #causation connect Domain::domain.miningCorporation.miningFrigate.cargoCapacityIncreases to Domain::domain.miningCorporation.fleet.downtimeReduces; + #causation connect Domain::domain.miningCorporation.miningFrigate.shieldStrengthIncreases to Domain::domain.miningCorporation.fleet.survivabilityEnhances; + #causation connect Domain::domain.miningCorporation.miningFrigate.threatDetectionImproves to Domain::domain.miningCorporation.fleet.threatResponseImproves; + #causation connect Domain::domain.miningCorporation.miningFrigate.droneOperationsImprove to Domain::domain.miningCorporation.fleet.operationalEfficiencyIncreases; + #causation connect Domain::domain.miningCorporation.miningFrigate.warpSpeedIncreases to Domain::domain.miningCorporation.fleet.downtimeReduces; + #causation connect Domain::domain.miningCorporation.fleet.fleetCoordinationImproves to Domain::domain.miningCorporation.fleet.operationalEfficiencyIncreases; - //#multicausation connection { - // end #cause ::> miningFrigate.OreYieldIncreases; - // end #cause ::> miningFrigate.DowntimeReduces; - // end #effect ::> miningFrigate.OreExtractionEfficiencyIncreases; - //} + #multicausation connection { + end #cause ::> Domain::domain.asteroid.oreYieldIncreases; + end #cause ::> Domain::domain.miningCorporation.fleet.downtimeReduces; + end #effect ::> Domain::domain.miningCorporation.fleet.oreExtractionEfficiencyIncreases; + } - //#multicausation connection { - // end #cause ::> miningFrigate.SurvivabilityEnhances; - // end #cause ::> miningFrigate.ThreatResponseImproves; - // end #effect ::> miningFrigate.OperationalEfficiencyIncreases; - //} + #multicausation connection { + end #cause ::> Domain::domain.miningCorporation.fleet.survivabilityEnhances; + end #cause ::> Domain::domain.miningCorporation.fleet.threatResponseImproves; + end #effect ::> Domain::domain.miningCorporation.fleet.operationalEfficiencyIncreases; + } - //#multicausation connection { - // end #cause ::> miningFrigate.OperationalEfficiencyIncreases; - // end #cause ::> miningFrigate.OreExtractionEfficiencyIncreases; - // end #effect ::> miningFrigate.ProfitabilityMaximizes; - //} + #multicausation connection { + end #cause ::> Domain::domain.miningCorporation.fleet.operationalEfficiencyIncreases; + end #cause ::> Domain::domain.miningCorporation.fleet.oreExtractionEfficiencyIncreases; + end #effect ::> Domain::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..6c27b54 --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsFrigateLogical.sysml @@ -0,0 +1,42 @@ +package MiningFrigateActions_logical { + + //import packages + private import Domain::*; + private import ScalarValues::*; + private import OperationalUseCaseActions::*; + private import COTS::*; + + //action parameters are inherited + + //Activate Mining Laser + action def PowerupHighPowerModule {in activateMiningLaser : Domain::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 : Domain::ShipReport;} + action def ActivateMiningLaser_logical :> OperationalUseCaseActions::ActivateMiningLaser; + action activateMiningLaser_logical : ActivateMiningLaser_logical { + bind powerupHighPowerModule.activateMiningLaser = activateMiningLaser; + action powerupHighPowerModule : PowerupHighPowerModule {in activateMiningLaser : Domain::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 : Domain::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..0231aa2 100644 --- a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsHull.sysml +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/ActionsHull.sysml @@ -1,52 +1,16 @@ -package MiningFrigateHullHighLevelActions { +package MiningFrigateHullActions { - private import MiningFrigateHullIncludedActions::*; private import Domain::*; 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 : Domain::ShipCommand; + out miningStatus : Domain::ShipReport; } - + // **Action: Manage Energy Supply and Recharge** action def ManageEnergy { in rechargeCommand : Domain::ShipCommand; @@ -56,23 +20,6 @@ package MiningFrigateHullHighLevelActions { 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 { @@ -99,7 +46,7 @@ package MiningFrigateHullIncludedActions { } // **Action: Dock at Station** - action def DockAtStation { + action def DockToStation { in dockingCommand : Domain::ShipCommand; out dockingStatus : Domain::ShipReport; } @@ -110,46 +57,12 @@ package MiningFrigateHullIncludedActions { 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; - } - // **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; - } - // **Action: Report Asteroid Depletion to Pilot** action def ReportToPilot { in asteroidStatus : Domain::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..26fa629 --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateHull.sysml @@ -0,0 +1,52 @@ +package MiningFrigateHull { + + private import Domain::*; + private import MiningFrigate::*; + 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 : ~Domain::PodPort; + port hullDockingPort : ~Domain::DockingPort; + port hullDefensePort : ~Domain::ThreatPort; + port hullDroneControlPort: ~Domain::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..94565a8 --- /dev/null +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/MiningFrigateLogical.sysml @@ -0,0 +1,208 @@ +package MiningFrigateSolutionSpace { + + private import Domain::*; + private import MiningFrigate::*; + 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::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 logicalHull : LogicalMiningFrigateHull :> MiningFrigate::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 miningLaser : MinerModule[2] :> MiningFrigate::miningFrigate.miningLaser { + variant 'Mining Laser EP-S Gaussian Scoped'; + variant 'Mining Laser Particle Bore Compact'; + variant minerI : MinerI; + } + ref part propulsionModule : Afterburner[0..1] :> MiningFrigate::miningFrigate.propulsionModule; + ref part shieldModule : SmallShieldExtenderI[0..1] :> MiningFrigate::miningFrigate.shieldModule; + ref part capacitorModule : SmallCapBatteryI[0..1] :> MiningFrigate::miningFrigate.capacitorBooster; + ref part sensorModule : SurveyScannerI[0..1] :> MiningFrigate::miningFrigate.sensorModule; + ref part warpCoreStabilizer : WarpCoreStabilizerI[0..2] :> MiningFrigate::miningFrigate.warpCoreStabilizer; + + //internal conexions between parts of the LogicalMiningFrigateConfiguration + interface highSlotInterface1 : HighSlotInterface connect + hullPort ::> logicalHull.highSlot1 to + modulePort ::> miningLaser.highSlot; + + interface highSlotInterface2 : HighSlotInterface connect + hullPort ::> logicalHull.highSlot2 to + modulePort ::> miningLaser.highSlot; + + interface mediumSlotInterface1 : MediumSlotInterface connect + hullPort ::> logicalHull.mediumSlot1 to + modulePort ::> propulsionModule.mediumSlot; + + interface mediumSlotInterface2 : MediumSlotInterface connect + hullPort ::> logicalHull.mediumSlot2 to + modulePort ::> shieldModule.mediumSlot; + + interface lowSlotInterface1 : LowSlotInterface connect + hullPort ::> logicalHull.lowSlot1 to + modulePort ::> warpCoreStabilizer.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 = logicalHull.hullControlPort; + bind dockingPort = logicalHull.hullDockingPort; + bind defensePort = logicalHull.hullDefensePort; + bind droneControlPort = logicalHull.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::miningFrigate.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 : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action undockFromStation_logical : UndockFromStation_logical {in undockCommand = pilotPodUndockCommandSig;} + then InGrid; + + transition inGrid_to_docked + first InGrid + accept pilotPodDockCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action dockToStation_logical : DockToStation_logical {in dockCommand = pilotPodDockCommandSig;} + then Docked; + + transition inGrid_to_onWarp + first InGrid + accept warpCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action executeWarpDrive_logical : ExecuteWarpDrive_logical {in warpCommand = warpCommandSig;} + then OnWarp; + + transition onWarp_to_inGrid + first OnWarp + accept when logicalMiningFrigateConfiguration.warpBubbleEnd + then InGrid; + + //Internal transitions + transition unloadCargo + first Docked + accept unloadCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action transferOre_logical : TransferOre_logical {in unloadCommand = unloadCommandSig;} + then Docked; + + transition cycleMining + first InGrid + accept miningCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action activateMiningLaser_logical : ActivateMiningLaser_logical + then InGrid; + + transition scanThreats + first InGrid + accept scanCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action scanForThreats_logical : ScanForThreats_logical {in scanCommand = scanCommandSig;} + then InGrid; + + transition prioritizeThreat + first InGrid + accept threatSignatureSig : Domain::ScanSignature via logicalMiningFrigateConfiguration.controlPort + do action prioritizeThreats_logical : PrioritizeThreats_logical {in detectedThreats = threatSignatureSig;} + then InGrid; + + transition deployDrones + first InGrid + accept droneCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action selectDronesForDeployment_logical : SelectDronesForDeployment_logical {in droneCommand = droneCommandSig;} + then InGrid; + + transition navigation + first InGrid + accept destinationCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action acceptDestination_logical : AcceptDestination_logical {in destinationCommand = destinationCommandSig;} + then InGrid; + + transition coursePlot + first InGrid + accept courseCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action plotOptimalCourse_logical : PlotOptimalCourse_logical + then InGrid; + + transition engagingPropulsion + first InGrid + accept propulsionCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action engagePropulsion_logical : EngagePropulsion_logical { in engagePropulsion = propulsionCommandSig;} + then InGrid; + + transition adjustingCourse + first InGrid + accept courseCorrectionSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action monitorAndAdjustCourse_logical : MonitorAndAdjustCourse_logical + then InGrid; + + transition cargoVerification + first Docked + accept warehouseStatusCommandSig : Domain::StationCommand via logicalMiningFrigateConfiguration.controlPort + do action verifyCargoTransfer_logical : VerifyResupply_logical {in warehouseStatusCommand = warehouseStatusCommandSig;} + then Docked; + + transition detectingThreat + first InGrid + accept threatScanCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action detectThreat_logical : DetectThreat_logical {in scanCommand = threatScanCommandSig;} + then InGrid; + + transition engagingDefenses + first InGrid + accept defenseCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action engageDefenses_logical : EngageDefenses_logical {in engageCommand = defenseCommandSig;} + then InGrid; + + transition resupplying + first Docked + accept shipStatusCommandSig : Domain::ShipCommand via logicalMiningFrigateConfiguration.controlPort + do action verifyResupply_logical : VerifyCargoTransfer_logical + then Docked; + } + + } + + //Three different configurations of mining frigatte are defined here that base on an abstract frigate + part logicalNoviceMiningFrigatte :> logicalMiningFrigateConfiguration{ + part redefines miningLaser = miningLaser::minerI; + } + + part logicalTrainerMiningFrigate :> logicalMiningFrigateConfiguration{ + part redefines miningLaser = miningLaser::'Mining Laser Particle Bore Compact'; + } + + part logicalFieldMiningFrigate :> logicalMiningFrigateConfiguration{ + part redefines miningLaser = miningLaser::'Mining Laser EP-S Gaussian Scoped'; + } + +} diff --git a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml index 0e49b1e..4fc9194 100644 --- a/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml +++ b/models/example_EveOnlineMiningFrigate/LogicalArchitecture/UseCasesHull.sysml @@ -1,145 +1,13 @@ -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 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; + use case ManageEnergy { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; actor smallCapBatteryI : SmallCapBatteryI; @@ -150,22 +18,9 @@ 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; + // **Use Case: Detect Threat** + use case DetectThreat { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; objective { @@ -176,9 +31,9 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Engage Defenses** - use case def EngageDefenses { - subject hull : MiningFrigateHull; + // **Use Case: Engage Defenses** + use case EngageDefenses { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; actor hostileShip : Domain::HostileShip; @@ -190,9 +45,9 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Navigate to Destination** - use case def NavigateToDestination { - subject hull : MiningFrigateHull; + // **Use Case: Navigate to Destination** + use case NavigateToDestination { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; objective { @@ -203,9 +58,9 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Transfer Ore** - use case def TransferOre { - subject hull : MiningFrigateHull; + // **Use Case: Transfer Ore** + use case TransferOre { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; actor station : Domain::Station; @@ -216,9 +71,9 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Dock at Station** - use case def DockAtStation { - subject hull : MiningFrigateHull; + // **Use Case: Dock to Station** + use case DockToStation { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; actor station : Domain::Station; @@ -230,9 +85,9 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Resupply Capacitor** - use case def ResupplyCapacitor { - subject hull : MiningFrigateHull; + // **Use Case: Resupply Capacitor** + use case ResupplyCapacitor { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; actor smallCapBatteryI : SmallCapBatteryI; @@ -243,9 +98,9 @@ package MiningFrigateHullUseCasesDef { } } - // **Use Case Definition: Activate Mining Laser** - use case def ActivateMiningLaser { - subject hull : MiningFrigateHull; + // **Use Case: Activate Mining Laser** + use case ActivateMiningLaser { + subject hull : LogicalMiningFrigateHull; actor pilotPod : Domain::PilotPod; actor miningLaser : MinerI; diff --git a/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml b/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml index 60fb37d..3a38b51 100644 --- a/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml +++ b/models/example_EveOnlineMiningFrigate/UseCases/OperationalUseCaseActions.sysml @@ -2,7 +2,6 @@ package OperationalUseCaseActions { private import Domain::*; private import ScalarValues::*; - private import MiningFrigate::*; // Operational Action Definitions for the Mining Frigate @@ -32,6 +31,8 @@ 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 : Domain::ShipCommand; + out miningCycleReport : Domain::ShipReport; } // Main Use Case definition : Detect Threats and Engage Defenses 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..718cf07 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; @@ -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 minimumAgeForAdoptiveParenthood { + parent1Age >= minAdoptingPartyAge & 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