battery

Editor GitHub co-design-modelslibraries example_battery specs models thingsbattery

Editor

Visualization

mcdp { # We need to fly for this duration provides endurance [s] # ...while carrying this extra payload provides extra_payload [kg] # ...and providing this extra power provides extra_power [W] # Sub-design problem: choose the battery battery = instance mcdp { # A battery provides capacity provides capacity [J] # and requires some mass to be transported requires mass [kg] # requires cost [$] specific_energy_Li_Ion = 500 Wh / kg required mass ≥ provided capacity / specific_energy_Li_Ion } # Sub-design problem: actuation actuation = instance mcdp { # actuators need to provide this lift provides lift [N] # and will require power requires power [W] # simple model: quadratic c = 10.0 W/N² required power ≥ (provided lift)^2 · c } # Co-design constraint: battery must be large enough power = power required by actuation + provided extra_power energy = power · provided endurance capacity provided by battery ≥ energy # Co-design constraint: actuators must be powerful enough gravity = 9.81 m/s² weight = (mass required by battery + provided extra_payload) · gravity lift provided by actuation ≥ weight # suppose we want to optimize for size of the battery requires mass for battery }

Diagramremove
Other informationremove

Internal representation details

CompositeNDP                                                                                                
│    provides   endurance       SB(≥0) s  │ requires   mass   SB(≥0) kg                                     
│    provides   extra_payload   SB(≥0) kg │                                                                 
│    provides   extra_power     SB(≥0) W  │                                                                 
│  10 nodes, 10 edges                                                                                       
│   connected rec: ✓                                                                                        
│  provided endurance          ≤ endurance provided by _prod       equiv id                                 
│  provided extra_payload      ≤ extra_payload provided by _sum1   equiv id                                 
│  provided extra_power        ≤ extra_power provided by _sum      equiv id                                 
│  _res2 required by _mult     ≤ lift provided by actuation        equiv id                                 
│  _res required by _prod      ≤ capacity provided by battery      equiv id                                 
│  _result required by _sum    ≤ power provided by _prod           equiv id                                 
│  _result2 required by _sum1  ≤ _op provided by _mult             equiv id                                 
│  power required by actuation ≤ power provided by _sum            equiv id                                 
│  mass required by battery    ≤ required mass                     equiv id                                 
│  mass required by battery    ≤ mass provided by _sum1            equiv id                                 
├     _mult: SimpleWrap                                                                                     
│            │  provides   _op   SB(≥0) kg │ requires   _res2   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                     
├     _prod: SimpleWrap                                                                                     
│            │  provides   power       SB(≥0) W │ requires   _res   SB(≥0) J                                
│            │  provides   endurance   SB(≥0) s │                                                           
│            └ M_Res_MultiplyMany_DP SB(≥0)×SB(≥0) ⟨W,s⟩  ⇸  SB(≥0) J                                       
│               𝒇₁⋅𝒇₂ ≤ 𝒓                                                                                   
│              ├   Fs: ├ SB(≥0) W                                                                           
│              │       └ SB(≥0) s                                                                           
│              └ algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                     
├      _sum: SimpleWrap                                                                                     
│            │  provides   power         SB(≥0) W │ requires   _result   SB(≥0) W                           
│            │  provides   extra_power   SB(≥0) W │                                                         
│            └ M_Res_AddMany_DP SB(≥0)×SB(≥0) ⟨W,W⟩  ⇸  SB(≥0) W                                            
│               𝒇₁ + 𝒇₂ ≤ 𝒓                                                                                 
│              ├      Fs: ├ SB(≥0) W                                                                        
│              │          └ SB(≥0) W                                                                        
│              ├ opspace: SB(≥0) W                                                                          
│              └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                  
├     _sum1: SimpleWrap                                                                                     
│            │  provides   mass            SB(≥0) kg │ requires   _result2   SB(≥0) kg                      
│            │  provides   extra_payload   SB(≥0) kg │                                                      
│            └ M_Res_AddMany_DP SB(≥0)×SB(≥0) ⟨kg,kg⟩  ⇸  SB(≥0) kg                                         
│               𝒇₁ + 𝒇₂ ≤ 𝒓                                                                                 
│              ├      Fs: ├ SB(≥0) kg                                                                       
│              │          └ SB(≥0) kg                                                                       
│              ├ opspace: SB(≥0) kg                                                                         
│              └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                  
├ actuation: CompositeNDP                                                                                   
│            │    provides   lift   SB(≥0) N │ requires   power   SB(≥0) W                                  
│            │  4 nodes, 3 edges                                                                            
│            │   connected rec: ✓                                                                           
│            │  provided lift            ≤ _op provided by _pow    equiv id                                 
│            │  _res required by _mult   ≤ required power          equiv id                                 
│            │  _result required by _pow ≤ _op provided by _mult   equiv id                                 
│            ├ _mult: SimpleWrap                                                                            
│            │        │  provides   _op   SB(≥0) N² │ requires   _res   SB(≥0) W                            
│            │        └ DP_L_UME SB(≥0) N²  ⇸  SB(≥0) W                                                     
│            │           𝒇 ⋅ 10 ≤ 𝒓                                                                         
│            │          M_C_WrapUnits   N² → W > M_A_Mult1_Upper   SB(≥0)  →   same x ⟼ x ⋅ 10              
│            └  _pow: SimpleWrap                                                                            
│                     │  provides   _op   SB(≥0) N │ requires   _result   SB(≥0) N²                         
│                     └ DP_L_UME SB(≥0) N  ⇸  SB(≥0) N²                                                     
│                        𝒇² ≤ 𝒓                                                                             
│                       M_C_WrapUnits   N → N² > M_A_PowerFrac_Upper   SB(≥0)  →   same 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                                          
                               𝒇 / 500 ≤ 𝒓                                                                  
                              M_C_WrapUnits   J → J*kg/Wh > M_A_Divide1_Upper   SB(≥0)  →   same x ⟼ x / 500