orei

Editor GitHub co-design-modelslibraries plugs specs models thingsorei
Editor
Visualization
# This device converts from TypeC to either TypeL or TypeA mcdp { provides out [`AC_power] requires in [`AC_power] requires budget [USD] required budget >= 7.31 USD (required in).socket >= `socket_type : TypeL (required in).voltage >= (provided out).voltage (required in).frequency >= (provided out).frequency (required in).watts >= (provided out).watts (provided out).socket <= any-of({`socket_type : TypeA, `socket_type : TypeC}) }
Diagramremove
Other informationremove
Internal representation details
CompositeNDP                                                                                                                                                                                                                                        
│    provides   out   WU ⟨-,-,-,W⟩ > (socket:{TypeA,TypeC}×voltage:Fin {v110,v220,⊥}×frequency:Fin {f50,f60,⊥}×watts:SB(≥0)) │ requires   in       WU ⟨-,-,-,W⟩ > (socket:{TypeL}×voltage:Fin {v110,v220,⊥}×frequency:Fin {f50,f60,⊥}×watts:SB(≥0)) 
│                                                                                                                            │ requires   budget   {7.31 USD}                                                                                       
│  8 nodes, 8 edges                                                                                                                                                                                                                                 
│   connected rec: ✓                                                                                                                                                                                                                                
│  _c required by _c         ≤ required budget               equiv (always satisfied)                                                                                                                                                               
│  _c2 required by _c2       ≤ socket provided by _if        equiv (always satisfied)                                                                                                                                                               
│  provided out              ≤ _muxed provided by _ir        equiv id                                                                                                                                                                               
│  _muxed required by _if    ≤ required in                   equiv id                                                                                                                                                                               
│  frequency required by _ir ≤ frequency provided by _if     equiv id                                                                                                                                                                               
│  socket required by _ir    ≤ _res provided by _DP_Limits   equiv id                                                                                                                                                                               
│  voltage required by _ir   ≤ voltage provided by _if       equiv id                                                                                                                                                                               
│  watts required by _ir     ≤ watts provided by _if         equiv id                                                                                                                                                                               
├ _DP_Limits: SimpleWrap                                                                                                                                                                                                                            
│             │  provides   _res   {TypeA,TypeC} │ -                                                                                                                                                                                                
│             └ DP_True {TypeA,TypeC}  ⇸  𝟙 val = * > ()                                                                                                                                                                                            
│                true                                                                                                                                                                                                                               
├         _c: SimpleWrap                                                                                                                                                                                                                            
│             │  - │ requires   _c   {7.31 USD}                                                                                                                                                                                                     
│             └ DP_Constant 𝟙  ⇸  {7.31 USD}                                                                                                                                                                                                        
│                7.31 USD ≤ 𝒓                                                                                                                                                                                                                       
├        _c2: SimpleWrap                                                                                                                                                                                                                            
│             │  - │ requires   _c2   {TypeL}                                                                                                                                                                                                       
│             └ DP_Constant 𝟙  ⇸  {TypeL}                                                                                                                                                                                                           
│                TypeL ≤ 𝒓                                                                                                                                                                                                                          
├        _if: SimpleWrap                                                                                                                                                                                                                            
│             │  provides   socket      {TypeL}           │ requires   _muxed   WU ⟨-,-,-,W⟩                                                                                                                                                        
│             │  provides   voltage     Fin {v110,v220,⊥} │                     (socket:{TypeL}×voltage:Fin {v110,v220,⊥}×frequency:Fin {f50,f60,⊥}×watts:SB(≥0))                                                                                   
│             │  provides   frequency   Fin {f50,f60,⊥}   │                                                                                                                                                                                         
│             │  provides   watts       SB(≥0) W          │                                                                                                                                                                                         
│             └ DP_Id WU ⟨-,-,-,W⟩                      ⇸  WU ⟨-,-,-,W⟩                                                                                                                                                                             
│                     └ Π<4>                               └ Π<4>                                                                                                                                                                                   
│                       ├    socket: {TypeL}                 ├    socket: {TypeL}                                                                                                                                                                   
│                       ├   voltage: Fin {v110,v220,⊥}       ├   voltage: Fin {v110,v220,⊥}                                                                                                                                                         
│                       ├ frequency: Fin {f50,f60,⊥}         ├ frequency: Fin {f50,f60,⊥}                                                                                                                                                           
│                       └     watts: SB(≥0)                  └     watts: SB(≥0)                                                                                                                                                                    
│                𝒇 ≤ 𝒓                                                                                                                                                                                                                              
└        _ir: SimpleWrap                                                                                                                                                                                                                            
              │  provides   _muxed   WU ⟨-,-,-,W⟩                                                                            │ requires   socket      {TypeA,TypeC}                                                                                 
              │                      (socket:{TypeA,TypeC}×voltage:Fin {v110,v220,⊥}×frequency:Fin {f50,f60,⊥}×watts:SB(≥0)) │ requires   voltage     Fin {v110,v220,⊥}                                                                             
              │                                                                                                              │ requires   frequency   Fin {f50,f60,⊥}                                                                               
              │                                                                                                              │ requires   watts       SB(≥0) W                                                                                      
              └ DP_Id WU ⟨-,-,-,W⟩                      ⇸  WU ⟨-,-,-,W⟩                                                                                                                                                                             
                      └ Π<4>                               └ Π<4>                                                                                                                                                                                   
                        ├    socket: {TypeA,TypeC}           ├    socket: {TypeA,TypeC}                                                                                                                                                             
                        ├   voltage: Fin {v110,v220,⊥}       ├   voltage: Fin {v110,v220,⊥}                                                                                                                                                         
                        ├ frequency: Fin {f50,f60,⊥}         ├ frequency: Fin {f50,f60,⊥}                                                                                                                                                           
                        └     watts: SB(≥0)                  └     watts: SB(≥0)                                                                                                                                                                    
                 𝒇 ≤ 𝒓