ae1

Editor GitHub co-design-modelslibraries pretty specs models thingsae1
Editor
Visualization
	mcdp { battery = instance `Battery actuation = instance `Actuation gravity = 9.81 m/s^2 weight = (mass required by battery) * gravity lift provided by actuation >= weight requires power for actuation provides capacity using battery }
Diagramremove
Other informationremove
Internal representation details
CompositeNDP                                                                                                             
│    provides   capacity   SB(≥0) J │ requires   power   SB([1,151]) W                                                   
│  5 nodes, 4 edges                                                                                                      
│   connected rec: ✓                                                                                                     
│  provided capacity           ≤ capacity provided by battery   equiv id                                                 
│  _res required by _mult      ≤ lift provided by actuation     diff  AmbientConversion SB(≥0) N  ⇸  SB([0,10]) N  > D N 
│                                                                      𝒇 ≤ 𝒓                                             
│  power required by actuation ≤ required power                 equiv id                                                 
│  mass required by battery    ≤ _op provided by _mult          equiv id                                                 
├     _mult: SimpleWrap                                                                                                  
│            │  provides   _op   SB(≥0) kg │ requires   _res   SB(≥0) N                                                  
│            └ DP_L_UME SB(≥0) kg  ⇸  SB(≥0) N                                                                           
│               𝒇 ⋅ 9.81 ≤ 𝒓                                                                                             
│              M_C_WrapUnits   kg → N > M_A_Mult1_Upper   SB(≥0)  →   same x ⟼ x ⋅ 9.81                                  
├ actuation: CompositeNDP                                                                                                
│            │    provides   lift   SB([0,10]) N │ requires   power   SB([1,151]) W                                      
│            │  6 nodes, 5 edges                                                                                         
│            │   connected rec: ✓                                                                                        
│            │  provided lift            ≤ _l provided by _lim     diff  (always satisfied)                              
│            │  provided lift            ≤ _op provided by _pow    equiv id                                              
│            │  _res required by _mult   ≤ _op provided by _plus   equiv id                                              
│            │  _res2 required by _plus  ≤ required power          equiv id                                              
│            │  _result required by _pow ≤ _op provided by _mult   equiv id                                              
│            ├  _lim: SimpleWrap                                                                                         
│            │        │  provides   _l   {10 N} │ -                                                                      
│            │        └ DP_Limit {10 N}  ⇸  𝟙  > NVU:10 N                                                                
│            │           𝒇 ≤ 10 N                                                                                        
│            ├ _mult: SimpleWrap                                                                                         
│            │        │  provides   _op   SB([0,100]) N² │ requires   _res   SB([0,150]) W                               
│            │        └ DP_L_UME SB([0,100]) N²  ⇸  SB([0,150]) W                                                        
│            │           𝒇 ⋅ 1.5 ≤ 𝒓                                                                                     
│            │          M_C_WrapUnits   N² → W > M_A_Mult1_Upper   SB([0,100])  →  SB([0,150]) x ⟼ x ⋅ 1.5               
│            ├ _plus: SimpleWrap                                                                                         
│            │        │  provides   _op   SB([0,150]) W │ requires   _res2   SB([1,151]) W                               
│            │        └ DP_L_UME SB([0,150]) W  ⇸  SB([1,151]) W                                                         
│            │           𝒇 + 1 ≤ 𝒓                                                                                       
│            │          M_C_WrapUnits   W → W > M_A_Add1_Upper   SB([0,150])  →  SB([1,151]) x ⟼ x + 1                   
│            └  _pow: SimpleWrap                                                                                         
│                     │  provides   _op   SB([0,10]) N │ requires   _result   SB([0,100]) N²                             
│                     └ DP_L_UME SB([0,10]) N  ⇸  SB([0,100]) N²                                                         
│                        𝒇² ≤ 𝒓                                                                                          
│                       M_C_WrapUnits   N → N² > M_A_PowerFrac_Upper   SB([0,10])  →  SB([0,100]) x ⟼ x²                 
└   battery: CompositeNDP                                                                                                
             │    provides   capacity   SB(≥0) J │ requires   mass   SB(≥0) kg                                           
             │  4 nodes, 3 edges                                                                                         
             │   connected rec: ✓                                                                                        
             │  mass required by _conversion ≤ required mass                  equiv id                                   
             │  _res required by _divr       ≤ _res provided by _conversion   equiv id                                   
             │  provided capacity            ≤ _op provided by _divr          equiv id                                   
             ├ _conversion: SimpleWrap                                                                                   
             │              │  provides   _res   SB(≥0) J*kg/Wh │ requires   mass   SB(≥0) kg                            
             │              └ UnitConversion SB(≥0) J*kg/Wh  ⇸  SB(≥0) kg                                                
             │                 𝒇 [J*kg/Wh] ≤ 𝒓 [kg]                                                                      
             │                ├      F0: SB(≥0)                                                                          
             │                ├  factor: 1/3600                                                                          
             │                ├ F_units: SingleUnits J*kg/Wh                                                             
             │                └ R_units: SingleUnits kg                                                                  
             └       _divr: SimpleWrap                                                                                   
                            │  provides   _op   SB(≥0) J │ requires   _res   SB(≥0) J*kg/Wh                              
                            └ DP_L_UME SB(≥0) J  ⇸  SB(≥0) J*kg/Wh                                                       
                               𝒇 / 100 ≤ 𝒓                                                                               
                              M_C_WrapUnits   J → J*kg/Wh > M_A_Divide1_Upper   SB(≥0)  →   same x ⟼ x / 100