Ravpower

Editor GitHub co-design-modelslibraries plugs specs models thingsRavpower
Editor
Visualization
mcdp { provides out1 [`DC_power] provides out2 [`DC_power] requires in [`AC_power] requires budget [USD] required budget ≽ 10.99 USD (required in).socket ≽ `socket_type : TypeA (provided out1).voltage ≼ `DC_voltages: v5 (provided out2).voltage ≼ `DC_voltages: v5 (provided out1).connector ≼ `USB_connectors:USB_Std_A (provided out2).connector ≼ `USB_connectors:USB_Std_A # this forces the two voltages to be the same # this says that the power sums amps = (provided out1).amps + (provided out2).amps amps ≼ 2.4 A power = 5 V · (amps) (required in).watts ≽ power (required in).voltage ≽ `AC_voltages: v110 (required in).socket ≽ `socket_type: TypeA (required in).frequency ≽ `AC_frequencies: f50 }
Diagramremove
Other informationremove
Internal representation details
CompositeNDP                                                                                                                                                 
│    provides   out1   WU ⟨-,-,A⟩                   │ requires   in       WU ⟨-,-,-,W⟩ > (socket:{TypeA}×voltage:{v110}×frequency:{f50}×watts:SB([0,24]))    
│                      └ Π<3>                       │ requires   budget   {10.99 USD}                                                                        
│                        ├ connector: ∑             │                                                                                                        
│                        │            ├ ∅           │                                                                                                        
│                        │            └ {USB_Std_A} │                                                                                                        
│                        ├   voltage: {v5}          │                                                                                                        
│                        └      amps: SB([0,2.4])   │                                                                                                        
│    provides   out2   WU ⟨-,-,A⟩                   │                                                                                                        
│                      └ Π<3>                       │                                                                                                        
│                        ├ connector: ∑             │                                                                                                        
│                        │            ├ ∅           │                                                                                                        
│                        │            └ {USB_Std_A} │                                                                                                        
│                        ├   voltage: {v5}          │                                                                                                        
│                        └      amps: SB([0,2.4])   │                                                                                                        
│  21 nodes, 19 edges                                                                                                                                        
│   connected rec: ✓                                                                                                                                         
│  _c required by _c            ≤ required budget                      equiv (always satisfied)                                                              
│  _c2 required by _c2          ≤ socket provided by _if               equiv (always satisfied)                                                              
│  _c3 required by _c3          ≤ voltage provided by _if              equiv (always satisfied)                                                              
│  _c4 required by _c4          ≤ socket provided by _if               equiv (always satisfied)                                                              
│  _c5 required by _c5          ≤ frequency provided by _if            equiv (always satisfied)                                                              
│  _l2 required by _conversion  ≤ _l2 provided by _lim2                equiv (always satisfied)                                                              
│  _l3 required by _conversion1 ≤ _l3 provided by _lim3                equiv (always satisfied)                                                              
│  provided out1                ≤ _muxed provided by _ir               equiv id                                                                              
│  provided out2                ≤ _muxed provided by _ir1              equiv id                                                                              
│  _muxed required by _if       ≤ required in                          equiv id                                                                              
│  amps required by _ir         ≤ _ir_amps provided by _sum            equiv id                                                                              
│  connector required by _ir    ≤ connector provided by _conversion    equiv (always satisfied)                                                              
│  voltage required by _ir      ≤ _l provided by _lim                  equiv (always satisfied)                                                              
│  amps required by _ir1        ≤ _ir1_amps provided by _sum           equiv id                                                                              
│  connector required by _ir1   ≤ connector provided by _conversion1   equiv (always satisfied)                                                              
│  voltage required by _ir1     ≤ _l1 provided by _lim1                equiv (always satisfied)                                                              
│  _res required by _mult       ≤ watts provided by _if                equiv id                                                                              
│  _result required by _sum     ≤ _l4 provided by _lim4                diff  DP_GenericConstant SB([0,4.8]) A  ⇸  {2.4 A}                                    
│                                                                             𝒇 ≤ 2.4 A                                                                      
│                                                                            ├  b: ()                                                                        
│                                                                            ├ lf: LowerSet(maximals=ff❨2.400000000❩)                                        
│                                                                            └ ur: UpperSet(minimals=ff❨2.400000000❩)                                        
│  _result required by _sum     ≤ _op provided by _mult                equiv id                                                                              
├           _c: SimpleWrap                                                                                                                                   
│               │  - │ requires   _c   {10.99 USD}                                                                                                           
│               └ DP_Constant 𝟙  ⇸  {10.99 USD}                                                                                                              
│                  10.99 USD ≤ 𝒓                                                                                                                             
├          _c2: SimpleWrap                                                                                                                                   
│               │  - │ requires   _c2   {TypeA}                                                                                                              
│               └ DP_Constant 𝟙  ⇸  {TypeA}                                                                                                                  
│                  TypeA ≤ 𝒓                                                                                                                                 
├          _c3: SimpleWrap                                                                                                                                   
│               │  - │ requires   _c3   {v110}                                                                                                               
│               └ DP_Constant 𝟙  ⇸  {v110}                                                                                                                   
│                  v110 ≤ 𝒓                                                                                                                                  
├          _c4: SimpleWrap                                                                                                                                   
│               │  - │ requires   _c4   {TypeA}                                                                                                              
│               └ DP_Constant 𝟙  ⇸  {TypeA}                                                                                                                  
│                  TypeA ≤ 𝒓                                                                                                                                 
├          _c5: SimpleWrap                                                                                                                                   
│               │  - │ requires   _c5   {f50}                                                                                                                
│               └ DP_Constant 𝟙  ⇸  {f50}                                                                                                                    
│                  f50 ≤ 𝒓                                                                                                                                   
├  _conversion: SimpleWrap                                                                                                                                   
│               │  provides   connector   ∑             │ requires   _l2   {USB_Std_A}                                                                       
│               │                         ├ ∅           │                                                                                                    
│               │                         └ {USB_Std_A} │                                                                                                    
│               └ DP_True ∑              ⇸  {USB_Std_A} val = * > ()                                                                                         
│                         ├ ∅                                                                                                                                
│                         └ {USB_Std_A}                                                                                                                      
│                  true                                                                                                                                      
├ _conversion1: SimpleWrap                                                                                                                                   
│               │  provides   connector   ∑             │ requires   _l3   {USB_Std_A}                                                                       
│               │                         ├ ∅           │                                                                                                    
│               │                         └ {USB_Std_A} │                                                                                                    
│               └ DP_True ∑              ⇸  {USB_Std_A} val = * > ()                                                                                         
│                         ├ ∅                                                                                                                                
│                         └ {USB_Std_A}                                                                                                                      
│                  true                                                                                                                                      
├          _if: SimpleWrap                                                                                                                                   
│               │  provides   socket      {TypeA}      │ requires   _muxed   WU ⟨-,-,-,W⟩ > (socket:{TypeA}×voltage:{v110}×frequency:{f50}×watts:SB([0,24])) 
│               │  provides   voltage     {v110}       │                                                                                                     
│               │  provides   frequency   {f50}        │                                                                                                     
│               │  provides   watts       SB([0,24]) W │                                                                                                     
│               └ DP_Id WU ⟨-,-,-,W⟩                ⇸  WU ⟨-,-,-,W⟩                                                                                          
│                       └ Π<4>                         └ Π<4>                                                                                                
│                         ├    socket: {TypeA}           ├    socket: {TypeA}                                                                                
│                         ├   voltage: {v110}            ├   voltage: {v110}                                                                                 
│                         ├ frequency: {f50}             ├ frequency: {f50}                                                                                  
│                         └     watts: SB([0,24])        └     watts: SB([0,24])                                                                             
│                  𝒇 ≤ 𝒓                                                                                                                                     
├          _ir: SimpleWrap                                                                                                                                   
│               │  provides   _muxed   WU ⟨-,-,A⟩                   │ requires   connector   ∑                                                               
│               │                      └ Π<3>                       │                        ├ ∅                                                             
│               │                        ├ connector: ∑             │                        └ {USB_Std_A}                                                   
│               │                        │            ├ ∅           │ requires   voltage     {v5}                                                            
│               │                        │            └ {USB_Std_A} │ requires   amps        SB([0,2.4]) A                                                   
│               │                        ├   voltage: {v5}          │                                                                                        
│               │                        └      amps: SB([0,2.4])   │                                                                                        
│               └ DP_Id WU ⟨-,-,A⟩                    ⇸  WU ⟨-,-,A⟩                                                                                          
│                       └ Π<3>                           └ Π<3>                                                                                              
│                         ├ connector: ∑                   ├ connector: ∑                                                                                    
│                         │            ├ ∅                 │            ├ ∅                                                                                  
│                         │            └ {USB_Std_A}       │            └ {USB_Std_A}                                                                        
│                         ├   voltage: {v5}                ├   voltage: {v5}                                                                                 
│                         └      amps: SB([0,2.4])         └      amps: SB([0,2.4])                                                                          
│                  𝒇 ≤ 𝒓                                                                                                                                     
├         _ir1: SimpleWrap                                                                                                                                   
│               │  provides   _muxed   WU ⟨-,-,A⟩                   │ requires   connector   ∑                                                               
│               │                      └ Π<3>                       │                        ├ ∅                                                             
│               │                        ├ connector: ∑             │                        └ {USB_Std_A}                                                   
│               │                        │            ├ ∅           │ requires   voltage     {v5}                                                            
│               │                        │            └ {USB_Std_A} │ requires   amps        SB([0,2.4]) A                                                   
│               │                        ├   voltage: {v5}          │                                                                                        
│               │                        └      amps: SB([0,2.4])   │                                                                                        
│               └ DP_Id WU ⟨-,-,A⟩                    ⇸  WU ⟨-,-,A⟩                                                                                          
│                       └ Π<3>                           └ Π<3>                                                                                              
│                         ├ connector: ∑                   ├ connector: ∑                                                                                    
│                         │            ├ ∅                 │            ├ ∅                                                                                  
│                         │            └ {USB_Std_A}       │            └ {USB_Std_A}                                                                        
│                         ├   voltage: {v5}                ├   voltage: {v5}                                                                                 
│                         └      amps: SB([0,2.4])         └      amps: SB([0,2.4])                                                                          
│                  𝒇 ≤ 𝒓                                                                                                                                     
├         _lim: SimpleWrap                                                                                                                                   
│               │  provides   _l   {v5} │ -                                                                                                                  
│               └ DP_Limit {v5}  ⇸  𝟙  > VU:v5                                                                                                               
│                  𝒇 ≤ v5                                                                                                                                    
├        _lim1: SimpleWrap                                                                                                                                   
│               │  provides   _l1   {v5} │ -                                                                                                                 
│               └ DP_Limit {v5}  ⇸  𝟙  > VU:v5                                                                                                               
│                  𝒇 ≤ v5                                                                                                                                    
├        _lim2: SimpleWrap                                                                                                                                   
│               │  provides   _l2   {USB_Std_A} │ -                                                                                                          
│               └ DP_Limit {USB_Std_A}  ⇸  𝟙  > VU:USB_Std_A                                                                                                 
│                  𝒇 ≤ USB_Std_A                                                                                                                             
├        _lim3: SimpleWrap                                                                                                                                   
│               │  provides   _l3   {USB_Std_A} │ -                                                                                                          
│               └ DP_Limit {USB_Std_A}  ⇸  𝟙  > VU:USB_Std_A                                                                                                 
│                  𝒇 ≤ USB_Std_A                                                                                                                             
├        _lim4: SimpleWrap                                                                                                                                   
│               │  provides   _l4   {2.4 A} │ -                                                                                                              
│               └ DP_Limit {2.4 A}  ⇸  𝟙  > NVU:2.4 A                                                                                                        
│                  𝒇 ≤ 2.4 A                                                                                                                                 
├        _mult: SimpleWrap                                                                                                                                   
│               │  provides   _op   SB([0,4.8]) A │ requires   _res   SB([0,24]) W                                                                           
│               └ DP_L_UME SB([0,4.8]) A  ⇸  SB([0,24]) W                                                                                                    
│                  𝒇 ⋅ 5 ≤ 𝒓                                                                                                                                 
│                 M_C_WrapUnits   A → W > M_A_Mult1_Upper   SB([0,4.8])  →  SB([0,24]) x ⟼ x ⋅ 5                                                             
└         _sum: SimpleWrap                                                                                                                                   
                │  provides   _ir_amps    SB([0,2.4]) A │ requires   _result   SB([0,4.8]) A                                                                 
                │  provides   _ir1_amps   SB([0,2.4]) A │                                                                                                    
                └ M_Res_AddMany_DP SB([0,2.4])×SB([0,2.4]) ⟨A,A⟩  ⇸  SB([0,4.8]) A                                                                           
                   𝒇₁ + 𝒇₂ ≤ 𝒓                                                                                                                               
                  ├      Fs: ├ SB([0,2.4]) A                                                                                                                 
                  │          └ SB([0,2.4]) A                                                                                                                 
                  ├ opspace: SB([0,4.8]) A                                                                                                                   
                  └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT