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:{TypeC,TypeA}×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   {TypeC,TypeA} │ -                                                                                                                                                                                        
│             └ DP_True {TypeC,TypeA}  ⇸  𝟙 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      {TypeC,TypeA}                                                                             
              │                      (socket:{TypeC,TypeA}×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: {TypeC,TypeA}         ├    socket: {TypeC,TypeA}                                                                                                                                                       
                        ├   voltage: Fin {v110,v220}       ├   voltage: Fin {v110,v220}                                                                                                                                                     
                        ├ frequency: Fin {f50,f60}         ├ frequency: Fin {f50,f60}                                                                                                                                                       
                        └     watts: SB(≥0)                └     watts: SB(≥0)                                                                                                                                                              
                 𝒇 ≤ 𝒓