XYZ_concrete

Editor GitHub co-design-modelslibraries mechanisms specs models thingsXYZ_concrete
Editor
Visualization
mcdp { # We implent XYZ by having a XY mechanism to which we attach a prismatic joint implements `XYZInterface XY = instance `XY_concrete workspace provided by XY ≽ provided workspace precision provided by XY ≽ provided precision velocity provided by XY ≽ provided velocity acceleration provided by XY ≽ provided acceleration force provided by XY ≽ provided force Z = instance `Joint payload_mass provided by Z ≽ provided payload_mass velocity provided by Z ≽ provided velocity acceleration provided by Z ≽ provided acceleration precision provided by Z ≽ provided precision force provided by Z ≽ provided force workspace provided by Z ≽ provided workspace # Now XY must carry both Z and the payload total_payload_mass = mass required by Z + provided payload_mass payload_mass provided by XY ≽ total_payload_mass required electric_power ≽ ∑ electric_power required by * required mass ≽ ∑ mass required by * required budget ≽ ∑ budget required by * }
Diagramremove
Other informationremove
Internal representation details
CompositeNDP                                                                                                    
│    provides   workspace      {0.4 m}    │ requires   electric_power   {0.2 W}                                 
│    provides   payload_mass   {200 g}    │ requires   mass             {200 g}                                 
│    provides   precision      {2 1/mm}   │ requires   budget           {20 $}                                  
│    provides   velocity       {4 mm/s}   │                                                                     
│    provides   acceleration   {10 mm/s²} │                                                                     
│    provides   force          {0.001 N}  │                                                                     
│  15 nodes, 23 edges                                                                                           
│   connected rec: ✓                                                                                            
│  budget required by XY         ≤ XY_budget provided by _sum3           equiv (always satisfied)               
│  electric_power required by XY ≤ XY_electric_power provided by _sum1   equiv (always satisfied)               
│  mass required by XY           ≤ XY_mass provided by _sum2             equiv (always satisfied)               
│  budget required by Z          ≤ Z_budget provided by _sum3            equiv (always satisfied)               
│  electric_power required by Z  ≤ Z_electric_power provided by _sum1    equiv (always satisfied)               
│  mass required by Z            ≤ mass provided by _sum                 equiv (always satisfied)               
│  mass required by Z            ≤ Z_mass provided by _sum2              equiv (always satisfied)               
│  provided acceleration         ≤ acceleration provided by XY           equiv (always satisfied)               
│  provided acceleration         ≤ acceleration provided by Z            diff  (always satisfied)               
│  provided force                ≤ force provided by XY                  equiv (always satisfied)               
│  provided force                ≤ force provided by Z                   diff  (always satisfied)               
│  provided payload_mass         ≤ payload_mass provided by Z            diff  (always satisfied)               
│  provided payload_mass         ≤ payload_mass provided by _sum         equiv (always satisfied)               
│  provided precision            ≤ precision provided by XY              equiv (always satisfied)               
│  provided precision            ≤ precision provided by Z               diff  (always satisfied)               
│  provided velocity             ≤ velocity provided by XY               equiv (always satisfied)               
│  provided velocity             ≤ velocity provided by Z                diff  (always satisfied)               
│  provided workspace            ≤ workspace provided by XY              equiv (always satisfied)               
│  provided workspace            ≤ workspace provided by Z               diff  (always satisfied)               
│  _result required by _sum      ≤ payload_mass provided by XY           equiv (always satisfied)               
│  _result2 required by _sum1    ≤ required electric_power               equiv (always satisfied)               
│  _result3 required by _sum2    ≤ required mass                         equiv (always satisfied)               
│  _result4 required by _sum3    ≤ required budget                       equiv (always satisfied)               
├    XY: CompositeNDP                                                                                           
│        │    provides   workspace      {0.4 m}    │ requires   electric_power   {0.2 W}                        
│        │    provides   payload_mass   {200 g}    │ requires   mass             {200 g}                        
│        │    provides   precision      {2 1/mm}   │ requires   budget           {20 $}                         
│        │    provides   velocity       {4 mm/s}   │                                                            
│        │    provides   acceleration   {10 mm/s²} │                                                            
│        │    provides   force          {0.001 N}  │                                                            
│        │  19 nodes, 10 edges                                                                                  
│        │   connected rec: ✓                                                                                   
│        │  _c required by _c          ≤ required electric_power             equiv (always satisfied)           
│        │  _c2 required by _c2        ≤ required mass                       equiv (always satisfied)           
│        │  _c3 required by _c3        ≤ required budget                     equiv (always satisfied)           
│        │  _l required by _conversion ≤ _l provided by _lim                 equiv (always satisfied)           
│        │  provided acceleration      ≤ _l4 provided by _lim4               equiv (always satisfied)           
│        │  provided force             ≤ _l5 provided by _lim5               equiv (always satisfied)           
│        │  provided payload_mass      ≤ _l1 provided by _lim1               equiv (always satisfied)           
│        │  provided precision         ≤ _l2 provided by _lim2               equiv id                           
│        │  provided velocity          ≤ _l3 provided by _lim3               equiv (always satisfied)           
│        │  provided workspace         ≤ workspace provided by _conversion   equiv (always satisfied)           
│        ├          _c: SimpleWrap                                                                              
│        │              │  - │ requires   _c   {0.2 W}                                                          
│        │              └ DP_Constant 𝟙  ⇸  {0.2 W}                                                             
│        │                 0.2 W ≤ 𝒓                                                                            
│        ├         _c2: SimpleWrap                                                                              
│        │              │  - │ requires   _c2   {200 g}                                                         
│        │              └ DP_Constant 𝟙  ⇸  {200 g}                                                             
│        │                 200 g ≤ 𝒓                                                                            
│        ├         _c3: SimpleWrap                                                                              
│        │              │  - │ requires   _c3   {20 $}                                                          
│        │              └ DP_Constant 𝟙  ⇸  {20 $}                                                              
│        │                 20 $ ≤ 𝒓                                                                             
│        ├ _conversion: SimpleWrap                                                                              
│        │              │  provides   workspace   {0.4 m} │ requires   _l   {40 cm}                             
│        │              └ DP_True {0.4 m}  ⇸  {40 cm} val = * > ()                                              
│        │                 true                                                                                 
│        ├        _lim: SimpleWrap                                                                              
│        │              │  provides   _l   {40 cm} │ -                                                          
│        │              └ DP_Limit {40 cm}  ⇸  𝟙  > NVU:40 cm                                                   
│        │                 𝒇 ≤ 40 cm                                                                            
│        ├       _lim1: SimpleWrap                                                                              
│        │              │  provides   _l1   {200 g} │ -                                                         
│        │              └ DP_Limit {200 g}  ⇸  𝟙  > NVU:200 g                                                   
│        │                 𝒇 ≤ 200 g                                                                            
│        ├       _lim2: SimpleWrap                                                                              
│        │              │  provides   _l2   {2 1/mm} │ -                                                        
│        │              └ DP_Limit {2 1/mm}  ⇸  𝟙  > NVU:2 1/mm                                                 
│        │                 𝒇 ≤ 2 1/mm                                                                           
│        ├       _lim3: SimpleWrap                                                                              
│        │              │  provides   _l3   {4 mm/s} │ -                                                        
│        │              └ DP_Limit {4 mm/s}  ⇸  𝟙  > NVU:4 mm/s                                                 
│        │                 𝒇 ≤ 4 mm/s                                                                           
│        ├       _lim4: SimpleWrap                                                                              
│        │              │  provides   _l4   {10 mm/s²} │ -                                                      
│        │              └ DP_Limit {10 mm/s²}  ⇸  𝟙  > NVU:10 mm/s²                                             
│        │                 𝒇 ≤ 10 mm/s²                                                                         
│        └       _lim5: SimpleWrap                                                                              
│                       │  provides   _l5   {0.001 N} │ -                                                       
│                       └ DP_Limit {0.001 N}  ⇸  𝟙  > NVU:0.001 N                                               
│                          𝒇 ≤ 0.001 N                                                                          
├     Z: CompositeNDP                                                                                           
│        │    provides   workspace      {∞ m}     │ requires   electric_power   {0 W}                           
│        │    provides   payload_mass   {∞ g}     │ requires   mass             {0 g}                           
│        │    provides   precision      {∞ 1/mm}  │ requires   budget           {0 $}                           
│        │    provides   velocity       {∞ mm/s}  │                                                             
│        │    provides   acceleration   {∞ mm/s²} │                                                             
│        │    provides   force          {∞ N}     │                                                             
│        │  18 nodes, 9 edges                                                                                   
│        │   connected rec: ✓                                                                                   
│        │  mass required by _constant            ≤ required mass                      equiv (always satisfied) 
│        │  electric_power required by _constant1 ≤ required electric_power            equiv (always satisfied) 
│        │  budget required by _constant2         ≤ required budget                    equiv (always satisfied) 
│        │  provided acceleration                 ≤ acceleration provided by _limit2   equiv (always satisfied) 
│        │  provided force                        ≤ force provided by _limit1          equiv (always satisfied) 
│        │  provided payload_mass                 ≤ payload_mass provided by _limit    equiv (always satisfied) 
│        │  provided precision                    ≤ precision provided by _limit4      equiv (always satisfied) 
│        │  provided velocity                     ≤ velocity provided by _limit5       equiv (always satisfied) 
│        │  provided workspace                    ≤ workspace provided by _limit3      equiv (always satisfied) 
│        ├  _constant: SimpleWrap                                                                               
│        │             │  - │ requires   mass   {0 g}                                                           
│        │             └ DP_Constant 𝟙  ⇸  {0 g}                                                                
│        │                0 g ≤ 𝒓                                                                               
│        ├ _constant1: SimpleWrap                                                                               
│        │             │  - │ requires   electric_power   {0 W}                                                 
│        │             └ DP_Constant 𝟙  ⇸  {0 W}                                                                
│        │                0 W ≤ 𝒓                                                                               
│        ├ _constant2: SimpleWrap                                                                               
│        │             │  - │ requires   budget   {0 $}                                                         
│        │             └ DP_Constant 𝟙  ⇸  {0 $}                                                                
│        │                0 $ ≤ 𝒓                                                                               
│        ├     _limit: SimpleWrap                                                                               
│        │             │  provides   payload_mass   {∞ g} │ -                                                   
│        │             └ DP_Limit {∞ g}  ⇸  𝟙  > NVU:∞ g                                                        
│        │                𝒇 ≤ ∞ g                                                                               
│        ├    _limit1: SimpleWrap                                                                               
│        │             │  provides   force   {∞ N} │ -                                                          
│        │             └ DP_Limit {∞ N}  ⇸  𝟙  > NVU:∞ N                                                        
│        │                𝒇 ≤ ∞ N                                                                               
│        ├    _limit2: SimpleWrap                                                                               
│        │             │  provides   acceleration   {∞ mm/s²} │ -                                               
│        │             └ DP_Limit {∞ mm/s²}  ⇸  𝟙  > NVU:∞ mm/s²                                                
│        │                𝒇 ≤ ∞ mm/s²                                                                           
│        ├    _limit3: SimpleWrap                                                                               
│        │             │  provides   workspace   {∞ m} │ -                                                      
│        │             └ DP_Limit {∞ m}  ⇸  𝟙  > NVU:∞ m                                                        
│        │                𝒇 ≤ ∞ m                                                                               
│        ├    _limit4: SimpleWrap                                                                               
│        │             │  provides   precision   {∞ 1/mm} │ -                                                   
│        │             └ DP_Limit {∞ 1/mm}  ⇸  𝟙  > NVU:∞ 1/mm                                                  
│        │                𝒇 ≤ ∞ 1/mm                                                                            
│        └    _limit5: SimpleWrap                                                                               
│                      │  provides   velocity   {∞ mm/s} │ -                                                    
│                      └ DP_Limit {∞ mm/s}  ⇸  𝟙  > NVU:∞ mm/s                                                  
│                         𝒇 ≤ ∞ mm/s                                                                            
├  _sum: SimpleWrap                                                                                             
│        │  provides   mass           {0 g}   │ requires   _result   {200 g}                                    
│        │  provides   payload_mass   {200 g} │                                                                 
│        └ DP_True {⟨0,200⟩ ⟨g,g⟩}  ⇸  {200 g} val = * > ()                                                     
│           true                                                                                                
├ _sum1: SimpleWrap                                                                                             
│        │  provides   XY_electric_power   {0.2 W} │ requires   _result2   {0.2 W}                              
│        │  provides   Z_electric_power    {0 W}   │                                                            
│        └ DP_True {⟨0.2,0⟩ ⟨W,W⟩}  ⇸  {0.2 W} val = * > ()                                                     
│           true                                                                                                
├ _sum2: SimpleWrap                                                                                             
│        │  provides   XY_mass   {200 g} │ requires   _result3   {200 g}                                        
│        │  provides   Z_mass    {0 g}   │                                                                      
│        └ DP_True {⟨200,0⟩ ⟨g,g⟩}  ⇸  {200 g} val = * > ()                                                     
│           true                                                                                                
└ _sum3: SimpleWrap                                                                                             
         │  provides   XY_budget   {20 $} │ requires   _result4   {20 $}                                        
         │  provides   Z_budget    {0 $}  │                                                                     
         └ DP_True {⟨20,0⟩ ⟨$,$⟩}  ⇸  {20 $} val = * > ()                                                       
            true