Extruder

Editor GitHub co-design-modelslibraries fdm specs models thingsExtruder
Editor
Visualization
mcdp { provides part_volume [mm³] 'Volume of the part to be produced.' provides part_resolution [1/mm] '(Inverse) resolution of the part to be produced.' provides service_temperature [C] 'Temperature that the produced part can resist.' requires electric_power [W] 'Total power drawn during production' requires time [s] 'Time necessary to produce each part' requires mass [g] 'Total mass of the extruder' requires budget [$] 'Total cost of the extruder' requires budget_per_part [$] 'Budget for each part to be produced' # The extruder's components nozzle = instance `Nozzle liquefier = instance `Liquefier # The material (filament) used material = instance `Materials2 # The parts that provide force to the filament actuated_gears = instance `ActuatedGears # The properties of the part produced that depend on the material service_temperature provided by material ≽ provided service_temperature # The resolution depends on the nozzle (as well as material?) part_resolution provided by nozzle ≽ provided part_resolution # Each material has a liquefaction temperature temperature provided by liquefier ≽ liquefaction_temperature required by material force provided by actuated_gears ≽ force required by nozzle # The time it takes to produce the part depends on the part volume # and the nozzle properties (time_per_unit_volume) required time ≽ (time_per_unit_volume required by nozzle) · provided part_volume # The cost of materials depends on the part volume and the specific cost # of the material material_mass = provided part_volume · density required by material cost_of_filament = (specific_cost required by material) · material_mass required budget_per_part ≽ cost_of_filament # The total budget is the sum of budgets required budget ≽ ∑ budget required by * required electric_power ≽ ∑ electric_power required by * required mass ≽ ∑ mass required by * }
Diagramremove
Other informationremove
Internal representation details
CompositeNDP                                                                                                                                                                                
│    provides   part_volume           SB(≥0) mm³     │ requires   electric_power    SB(≥0) W                                                                                                
│    provides   part_resolution       SB(≥0) 1/mm    │ requires   time              SB(≥0) s                                                                                                
│    provides   service_temperature   {65,217,105} C │ requires   mass              SB(≥20) g                                                                                               
│                                                    │ requires   budget            SB(≥1) USD                                                                                              
│                                                    │ requires   budget_per_part   SB(≥0) $                                                                                                
│  21 nodes, 28 edges                                                                                                                                                                       
│   connected rec: ✓                                                                                                                                                                        
│  budget_per_part required by _conversion       ≤ required budget_per_part                          equiv id                                                                               
│  provided part_resolution                      ≤ part_resolution provided by nozzle                equiv id                                                                               
│  provided part_volume                          ≤ part_volume provided by _prod                     equiv id                                                                               
│  provided part_volume                          ≤ part_volume provided by _prod1_0                  equiv id                                                                               
│  provided service_temperature                  ≤ service_temperature provided by material          equiv id                                                                               
│  _res required by _prod                        ≤ required time                                     equiv id                                                                               
│  _r required by _prod1_0                       ≤ _f provided by _prod1_1                           equiv id                                                                               
│  _res2 required by _prod1_1                    ≤ material_mass provided by _prod2                  equiv id                                                                               
│  _res3 required by _prod2                      ≤ cost_of_filament provided by _conversion          equiv id                                                                               
│  _result required by _sum                      ≤ required budget                                   equiv id                                                                               
│  _result2 required by _sum1                    ≤ required electric_power                           equiv id                                                                               
│  _0 required by _sum2_0                        ≤ _0 provided by _sum2_1                            equiv id                                                                               
│  _1 required by _sum2_0                        ≤ _1 provided by _sum2_1                            equiv id                                                                               
│  _2 required by _sum2_0                        ≤ _2 provided by _sum2_1                            equiv id                                                                               
│  _result3 required by _sum2_1                  ≤ required mass                                     equiv id                                                                               
│  budget required by actuated_gears             ≤ actuated_gears_budget provided by _sum            equiv id                                                                               
│  electric_power required by actuated_gears     ≤ actuated_gears_electric_power provided by _sum1   equiv id                                                                               
│  mass required by actuated_gears               ≤ actuated_gears_mass provided by _sum2_0           equiv id                                                                               
│  budget required by liquefier                  ≤ liquefier_budget provided by _sum                 equiv id                                                                               
│  electric_power required by liquefier          ≤ liquefier_electric_power provided by _sum1        equiv id                                                                               
│  mass required by liquefier                    ≤ liquefier_mass provided by _sum2_0                equiv id                                                                               
│  density required by material                  ≤ density provided by _prod1_0                      equiv (always satisfied)                                                               
│  liquefaction_temperature required by material ≤ temperature provided by liquefier                 diff  DP_C_Series {240,205,335} C  ⇸  SB(≥0) C                                         
│                                                                                                           ∃q: (𝒇 ≤ q₁) ∧ (q₁ ≤ 𝒓)                                                         
│                                                                                                          ├ AmbientConversion {240,205,335} C  ⇸  SB([205,335]::5) C  > SB([205,335]::5) C 
│                                                                                                          │  𝒇 ≤ 𝒓                                                                         
│                                                                                                          └ AmbientConversion SB([205,335]::5) C  ⇸  SB(≥0) C  > D C                       
│                                                                                                             𝒇 ≤ 𝒓                                                                         
│  specific_cost required by material            ≤ specific_cost provided by _prod2                  equiv id                                                                               
│  budget required by nozzle                     ≤ nozzle_budget provided by _sum                    equiv id                                                                               
│  force required by nozzle                      ≤ force provided by actuated_gears                  equiv id                                                                               
│  mass required by nozzle                       ≤ nozzle_mass provided by _sum2_0                   equiv id                                                                               
│  time_per_unit_volume required by nozzle       ≤ time_per_unit_volume provided by _prod            equiv id                                                                               
├    _conversion: SimpleWrap                                                                                                                                                                
│                 │  provides   cost_of_filament   SB(≥0) USD*g/kg │ requires   budget_per_part   SB(≥0) $                                                                                  
│                 └ UnitConversion SB(≥0) USD*g/kg  ⇸  SB(≥0) $                                                                                                                             
│                    𝒇 [USD*g/kg] ≤ 𝒓 [$]                                                                                                                                                   
│                   ├      F0: SB(≥0)                                                                                                                                                       
│                   ├  factor: 1/1000                                                                                                                                                       
│                   ├ F_units: SingleUnits USD*g/kg                                                                                                                                         
│                   └ R_units: SingleUnits $                                                                                                                                                
├          _prod: SimpleWrap                                                                                                                                                                
│                 │  provides   time_per_unit_volume   SB(≥0) s/mm³ │ requires   _res   SB(≥0) s                                                                                            
│                 │  provides   part_volume            SB(≥0) mm³   │                                                                                                                       
│                 └ M_Res_MultiplyMany_DP SB(≥0)×SB(≥0) ⟨s/mm³,mm³⟩  ⇸  SB(≥0) s                                                                                                            
│                    𝒇₁⋅𝒇₂ ≤ 𝒓                                                                                                                                                              
│                   ├   Fs: ├ SB(≥0) s/mm³                                                                                                                                                  
│                   │       └ SB(≥0) mm³                                                                                                                                                    
│                   └ algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                                                                                                
├       _prod1_0: SimpleWrap                                                                                                                                                                
│                 │  provides   part_volume   SB(≥0) mm³ │ requires   _r   SB(≥0) mm³                                                                                                       
│                 │  provides   density       {1 g/mm³}  │                                                                                                                                  
│                 └ DP_Mux SB(≥0)×SB(1) ⟨mm³,g/mm³⟩  ⇸  SB(≥0) mm³                                                                                                                          
│                    iso(𝒇, 𝒓)                                     ⟨a,b⟩ ↦ a                                                                                                                
│                                                                  ⟨α,1 g/mm³⟩ ↤ α                                                                                                          
├       _prod1_1: SimpleWrap                                                                                                                                                                
│                 │  provides   _f   SB(≥0) mm³ │ requires   _res2   SB(≥0) g                                                                                                               
│                 └ DP_L_UME SB(≥0) mm³  ⇸  SB(≥0) g                                                                                                                                        
│                    𝒇 ≤ 𝒓                                                                                                                                                                  
│                   M_C_WrapUnits   mm³ → g > M_Identity   SB(≥0)  →   same x ⟼ x                                                                                                           
├         _prod2: SimpleWrap                                                                                                                                                                
│                 │  provides   specific_cost   SB({20, 200}) $/kg │ requires   _res3   SB(≥0) USD*g/kg                                                                                     
│                 │  provides   material_mass   SB(≥0) g           │                                                                                                                        
│                 └ M_Res_MultiplyMany_DP SB({20, 200})×SB(≥0) ⟨$/kg,g⟩  ⇸  SB(≥0) USD*g/kg                                                                                                 
│                    𝒇₁⋅𝒇₂ ≤ 𝒓                                                                                                                                                              
│                   ├   Fs: ├ SB({20, 200}) $/kg                                                                                                                                            
│                   │       └ SB(≥0) g                                                                                                                                                      
│                   └ algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                                                                                                
├           _sum: SimpleWrap                                                                                                                                                                
│                 │  provides   actuated_gears_budget   SB(≥1) USD │ requires   _result   SB(≥1) USD                                                                                        
│                 │  provides   liquefier_budget        SB(≥0) $   │                                                                                                                        
│                 │  provides   nozzle_budget           SB(≥0) $   │                                                                                                                        
│                 └ M_Res_AddMany_DP SB(≥1)×SB(≥0)×SB(≥0) ⟨USD,$,$⟩  ⇸  SB(≥1) USD                                                                                                          
│                    𝒇₁ + 𝒇₂ + 𝒇₃ ≤ 𝒓                                                                                                                                                       
│                   ├      Fs: ├ SB(≥1) USD                                                                                                                                                 
│                   │          ├ SB(≥0) $                                                                                                                                                   
│                   │          └ SB(≥0) $                                                                                                                                                   
│                   ├ opspace: SB(≥0) $                                                                                                                                                     
│                   └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                                                                                             
├          _sum1: SimpleWrap                                                                                                                                                                
│                 │  provides   actuated_gears_electric_power   SB(≥0) W │ requires   _result2   SB(≥0) W                                                                                   
│                 │  provides   liquefier_electric_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                                                                                             
├        _sum2_0: SimpleWrap                                                                                                                                                                
│                 │  provides   actuated_gears_mass   SB(≥20) g │ requires   _0   SB(≥20) g                                                                                                 
│                 │  provides   liquefier_mass        SB(≥0) kg │ requires   _1   SB(≥0) g                                                                                                  
│                 │  provides   nozzle_mass           SB(≥0) kg │ requires   _2   SB(≥0) g                                                                                                  
│                 └ DP_L_UME SB(≥20)×SB(≥0)×SB(≥0) ⟨g,kg,kg⟩  ⇸  SB(≥20)×SB(≥0)×SB(≥0) ⟨g,g,g⟩                                                                                              
│                    ⟨𝒇₁,𝒇₂ * 1000,𝒇₃ * 1000⟩ ≤ 𝒓                                                                                                                                           
│                   └ M_C_WrapUnits   ⟨g,kg,kg⟩ → ⟨g,g,g⟩                                                                                                                                   
│                     └ M_C_Parallel   (SB(≥20)×SB(≥0)×SB(≥0))  →   same ⟨x₁,x₂,x₃⟩ ⟼ ⟨x₁,x₂ * 1000,x₃ * 1000⟩                                                                              
│                       ├ M_Identity   SB(≥20)  →   same x ⟼ x                                                                                                                              
│                       ├ M_A_Scale_Upper   SB(≥0)  →   same x ⟼ x * 1000                                                                                                                   
│                       └ M_A_Scale_Upper   SB(≥0)  →   same x ⟼ x * 1000                                                                                                                   
├        _sum2_1: SimpleWrap                                                                                                                                                                
│                 │  provides   _0   SB(≥20) g │ requires   _result3   SB(≥20) g                                                                                                            
│                 │  provides   _1   SB(≥0) g  │                                                                                                                                            
│                 │  provides   _2   SB(≥0) g  │                                                                                                                                            
│                 └ M_Res_AddMany_DP SB(≥20)×SB(≥0)×SB(≥0) ⟨g,g,g⟩  ⇸  SB(≥20) g                                                                                                            
│                    𝒇₁ + 𝒇₂ + 𝒇₃ ≤ 𝒓                                                                                                                                                       
│                   ├      Fs: ├ SB(≥20) g                                                                                                                                                  
│                   │          ├ SB(≥0) g                                                                                                                                                   
│                   │          └ SB(≥0) g                                                                                                                                                   
│                   ├ opspace: SB(≥0) g                                                                                                                                                     
│                   └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                                                                                             
├ actuated_gears: CompositeNDP                                                                                                                                                              
│                 │    provides   force   SB(≥0) N │ requires   mass             SB(≥20) g                                                                                                  
│                 │                                │ requires   budget           SB(≥1) USD                                                                                                 
│                 │                                │ requires   electric_power   SB(≥0) W                                                                                                   
│                 │  15 nodes, 22 edges                                                                                                                                                     
│                 │   connected rec: ✓                                                                                                                                                      
│                 │  _c required by _c                   ≤ _c provided by _conversion                equiv (always satisfied)                                                               
│                 │  velocity required by _conversion    ≤ velocity provided by gears                diff  DP_GenericConstant {0.003 m/s}  ⇸  SB(≥0) m/s                                    
│                 │                                                                                         0.003 m/s ≤ 𝒓                                                                   
│                 │                                                                                        ├  b: ()                                                                         
│                 │                                                                                        ├ lf: LowerSet(maximals=ff❨0.003000000❩)                                         
│                 │                                                                                        └ ur: UpperSet(minimals=ff❨0.003000000❩)                                         
│                 │  provided force                      ≤ force provided by gears                   equiv id                                                                               
│                 │  _0 required by _sum1_0              ≤ _0 provided by _sum1_1                    equiv id                                                                               
│                 │  _1 required by _sum1_0              ≤ _1 provided by _sum1_1                    equiv id                                                                               
│                 │  _r required by _sum1_1              ≤ _f provided by _sum1_2                    equiv id                                                                               
│                 │  _result2 required by _sum1_2        ≤ required budget                           equiv id                                                                               
│                 │  _0 required by _sum_0               ≤ _0 provided by _sum_1                     equiv id                                                                               
│                 │  _1 required by _sum_0               ≤ _1 provided by _sum_1                     equiv id                                                                               
│                 │  _r required by _sum_1               ≤ _f provided by _sum_2                     equiv id                                                                               
│                 │  _result required by _sum_2          ≤ required mass                             equiv id                                                                               
│                 │  budget required by gears            ≤ gears_budget provided by _sum1_0          equiv id                                                                               
│                 │  mass required by gears              ≤ gears_mass provided by _sum_0             equiv id                                                                               
│                 │  torque required by gears            ≤ torque_o provided by transmission         equiv id                                                                               
│                 │  velocity required by gears          ≤ velocity_o provided by transmission       equiv id                                                                               
│                 │  budget required by motor            ≤ motor_budget provided by _sum1_0          equiv id                                                                               
│                 │  electric_power required by motor    ≤ required electric_power                   equiv id                                                                               
│                 │  mass required by motor              ≤ motor_mass provided by _sum_0             equiv id                                                                               
│                 │  budget required by transmission     ≤ transmission_budget provided by _sum1_0   equiv (always satisfied)                                                               
│                 │  mass required by transmission       ≤ transmission_mass provided by _sum_0      equiv (always satisfied)                                                               
│                 │  torque_i required by transmission   ≤ torque provided by motor                  equiv id                                                                               
│                 │  velocity_i required by transmission ≤ velocity provided by motor                equiv id                                                                               
│                 ├           _c: SimpleWrap                                                                                                                                                
│                 │               │  - │ requires   _c   {3 mm/s}                                                                                                                           
│                 │               └ DP_Constant 𝟙  ⇸  {3 mm/s}                                                                                                                              
│                 │                  3 mm/s ≤ 𝒓                                                                                                                                             
│                 ├  _conversion: SimpleWrap                                                                                                                                                
│                 │               │  provides   _c   {3 mm/s} │ requires   velocity   {0.003 m/s}                                                                                           
│                 │               └ DP_True {3 mm/s}  ⇸  {0.003 m/s} val = * > ()                                                                                                           
│                 │                  true                                                                                                                                                   
│                 ├      _sum1_0: SimpleWrap                                                                                                                                                
│                 │               │  provides   gears_budget          SB(≥0) USD │ requires   _0   SB(≥0) USD                                                                               
│                 │               │  provides   motor_budget          SB(≥0) USD │ requires   _1   SB(≥0) USD                                                                               
│                 │               │  provides   transmission_budget   {1 USD}    │                                                                                                          
│                 │               └ DP_Mux SB(≥0)×SB(≥0)×SB(1) ⟨USD,USD,USD⟩  ⇸  SB(≥0)×SB(≥0) ⟨USD,USD⟩                                                                                    
│                 │                  iso(𝒇, 𝒓)                                                           ⟨a,b,c⟩ ↦ ⟨a,b⟩                                                                    
│                 │                                                                                      ⟨α,β,1 USD⟩ ↤ ⟨α,β⟩                                                                
│                 ├      _sum1_1: SimpleWrap                                                                                                                                                
│                 │               │  provides   _0   SB(≥0) USD │ requires   _r   SB(≥0) USD                                                                                                
│                 │               │  provides   _1   SB(≥0) USD │                                                                                                                           
│                 │               └ M_Res_AddMany_DP SB(≥0)×SB(≥0) ⟨USD,USD⟩  ⇸  SB(≥0) USD                                                                                                 
│                 │                  𝒇₁ + 𝒇₂ ≤ 𝒓                                                                                                                                            
│                 │                 ├      Fs: ├ SB(≥0) USD                                                                                                                                 
│                 │                 │          └ SB(≥0) USD                                                                                                                                 
│                 │                 ├ opspace: SB(≥0) USD                                                                                                                                   
│                 │                 └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                                                                             
│                 ├      _sum1_2: SimpleWrap                                                                                                                                                
│                 │               │  provides   _f   SB(≥0) USD │ requires   _result2   SB(≥1) USD                                                                                          
│                 │               └ DP_L_UME SB(≥0) USD  ⇸  SB(≥1) USD                                                                                                                      
│                 │                  𝒇 + 1 ≤ 𝒓                                                                                                                                              
│                 │                 M_C_WrapUnits   USD → USD > M_A_Add1_Upper   SB(≥0)  →  SB(≥1) x ⟼ x + 1                                                                                
│                 ├       _sum_0: SimpleWrap                                                                                                                                                
│                 │               │  provides   gears_mass          SB(≥0) g │ requires   _0   SB(≥0) g                                                                                     
│                 │               │  provides   motor_mass          SB(≥0) g │ requires   _1   SB(≥0) g                                                                                     
│                 │               │  provides   transmission_mass   {20 g}   │                                                                                                              
│                 │               └ DP_Mux SB(≥0)×SB(≥0)×SB(20) ⟨g,g,g⟩  ⇸  SB(≥0)×SB(≥0) ⟨g,g⟩                                                                                             
│                 │                  iso(𝒇, 𝒓)                                                  ⟨a,b,c⟩ ↦ ⟨a,b⟩                                                                             
│                 │                                                                             ⟨α,β,20 g⟩ ↤ ⟨α,β⟩                                                                          
│                 ├       _sum_1: SimpleWrap                                                                                                                                                
│                 │               │  provides   _0   SB(≥0) g │ requires   _r   SB(≥0) g                                                                                                    
│                 │               │  provides   _1   SB(≥0) g │                                                                                                                             
│                 │               └ M_Res_AddMany_DP SB(≥0)×SB(≥0) ⟨g,g⟩  ⇸  SB(≥0) g                                                                                                       
│                 │                  𝒇₁ + 𝒇₂ ≤ 𝒓                                                                                                                                            
│                 │                 ├      Fs: ├ SB(≥0) g                                                                                                                                   
│                 │                 │          └ SB(≥0) g                                                                                                                                   
│                 │                 ├ opspace: SB(≥0) g                                                                                                                                     
│                 │                 └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT                                                                             
│                 ├       _sum_2: SimpleWrap                                                                                                                                                
│                 │               │  provides   _f   SB(≥0) g │ requires   _result   SB(≥20) g                                                                                              
│                 │               └ DP_L_UME SB(≥0) g  ⇸  SB(≥20) g                                                                                                                         
│                 │                  𝒇 + 20 ≤ 𝒓                                                                                                                                             
│                 │                 M_C_WrapUnits   g → g > M_A_Add1_Upper   SB(≥0)  →  SB(≥20) x ⟼ x + 20                                                                                  
│                 ├        gears: Templatized                                                                                                                                               
│                 │               │  provides   force      SB(≥0) N   │ requires   torque     SB(≥0) N*m                                                                                    
│                 │               │  provides   velocity   SB(≥0) m/s │ requires   velocity   SB(≥0) rad/s                                                                                  
│                 │               │                                   │ requires   mass       SB(≥0) g                                                                                      
│                 │               │                                   │ requires   budget     SB(≥0) USD                                                                                    
│                 │               └ Template SB(≥0)×SB(≥0) ⟨N,m/s⟩  ⇸  WU ⟨N*m,rad/s,g,USD⟩  val = * > ()                                                                                   
│                 │                                                    └ Π<4>                                                                                                               
│                 │                                                      ├   torque: SB(≥0)                                                                                                 
│                 │                                                      ├ velocity: SB(≥0)                                                                                                 
│                 │                                                      ├     mass: SB(≥0)                                                                                                 
│                 │                                                      └   budget: SB(≥0)                                                                                                 
│                 │                  template                                                                                                                                               
│                 ├        motor: Templatized                                                                                                                                               
│                 │               │  provides   torque     SB(≥0) N*m   │ requires   electric_power   SB(≥0) W                                                                              
│                 │               │  provides   velocity   SB(≥0) rad/s │ requires   mass             SB(≥0) g                                                                              
│                 │               │                                     │ requires   budget           SB(≥0) USD                                                                            
│                 │               └ Template SB(≥0)×SB(≥0) ⟨N*m,rad/s⟩  ⇸  SB(≥0)×SB(≥0)×SB(≥0) ⟨W,g,USD⟩ val = *                                                                           
│                 │                  template                                                                                                                                               
│                 │                 ()                                                                                                                                                      
│                 └ transmission: CompositeNDP                                                                                                                                              
│                                 │    provides   torque_o     SB(≥0) N*m   │ requires   torque_i     SB(≥0) J                                                                              
│                                 │    provides   velocity_o   SB(≥0) rad/s │ requires   velocity_i   SB(≥0) rad/s                                                                          
│                                 │                                         │ requires   mass         {20 g}                                                                                
│                                 │                                         │ requires   budget       {1 USD}                                                                               
│                                 │  10 nodes, 6 edges                                                                                                                                      
│                                 │   connected rec: ✓                                                                                                                                      
│                                 │  _c required by _c       ≤ required mass           equiv (always satisfied)                                                                             
│                                 │  _c2 required by _c2     ≤ required budget         equiv (always satisfied)                                                                             
│                                 │  _res required by _divr  ≤ required velocity_i     equiv id                                                                                             
│                                 │  provided torque_o       ≤ _op provided by _mult   equiv id                                                                                             
│                                 │  provided velocity_o     ≤ _op provided by _divr   equiv id                                                                                             
│                                 │  _res2 required by _mult ≤ required torque_i       equiv id                                                                                             
│                                 ├    _c: SimpleWrap                                                                                                                                       
│                                 │        │  - │ requires   _c   {20 g}                                                                                                                    
│                                 │        └ DP_Constant 𝟙  ⇸  {20 g}                                                                                                                       
│                                 │           20 g ≤ 𝒓                                                                                                                                      
│                                 ├   _c2: SimpleWrap                                                                                                                                       
│                                 │        │  - │ requires   _c2   {1 USD}                                                                                                                  
│                                 │        └ DP_Constant 𝟙  ⇸  {1 USD}                                                                                                                      
│                                 │           1 USD ≤ 𝒓                                                                                                                                     
│                                 ├ _divr: SimpleWrap                                                                                                                                       
│                                 │        │  provides   _op   SB(≥0) rad/s │ requires   _res   SB(≥0) rad/s                                                                                
│                                 │        └ DP_L_UME SB(≥0) rad/s  ⇸  SB(≥0) rad/s                                                                                                         
│                                 │           𝒇 / 0.5 ≤ 𝒓                                                                                                                                   
│                                 │          └ M_C_WrapUnits   rad/s → rad/s                                                                                                                
│                                 │            M_A_Divide1_Upper   SB(≥0)  →   same x ⟼ x / 0.5                                                                                             
│                                 └ _mult: SimpleWrap                                                                                                                                       
│                                          │  provides   _op   SB(≥0) N*m │ requires   _res2   SB(≥0) J                                                                                     
│                                          └ DP_L_UME SB(≥0) N*m  ⇸  SB(≥0) J                                                                                                               
│                                             𝒇 ⋅ 0.495 ≤ 𝒓                                                                                                                                 
│                                            └ M_C_WrapUnits   N*m → J                                                                                                                      
│                                              M_A_Mult1_Upper   SB(≥0)  →   same x ⟼ x ⋅ 0.495                                                                                             
├      liquefier: Templatized                                                                                                                                                               
│                 │  provides   temperature   SB(≥0) C │ requires   budget           SB(≥0) $                                                                                               
│                 │                                    │ requires   mass             SB(≥0) kg                                                                                              
│                 │                                    │ requires   electric_power   SB(≥0) W                                                                                               
│                 └ DP_True SB(≥0) C  ⇸  SB(≥0)×SB(≥0)×SB(≥0) ⟨$,kg,W⟩ val = * > ()                                                                                                         
│                    true                                                                                                                                                                   
├       material: SimpleWrap                                                                                                                                                                
│                 │  provides   service_temperature   {65,217,105} C │ requires   liquefaction_temperature   {240,205,335} C                                                                
│                 │                                                  │ requires   specific_cost              SB({20, 200}) $/kg                                                             
│                 │                                                  │ requires   density                    {1 g/mm³}                                                                      
│                 └ DP_Catalog {65,217,105} C  ⇸  WU ⟨C,$/kg,g/mm³⟩                                                                                                                         
│                                                 └ Π<3>                                       65 C   ↤  PLA    ↦  ⟨205 C,20 $/kg,1 g/mm³⟩                                                  
│                                                   ├ liquefaction_temperature: {240,205,335}  105 C  ↤  ABS    ↦  ⟨240 C,20 $/kg,1 g/mm³⟩                                                  
│                                                   ├            specific_cost: SB({20, 200})  217 C  ↤  ULTEM  ↦  ⟨335 C,200 $/kg,1 g/mm³⟩                                                 
│                                                   └                  density: SB(1)                                                                                                       
│                    catalogue(𝒇, 𝒓)                                                                                                                                                        
└         nozzle: Templatized                                                                                                                                                               
                  │  provides   part_resolution   SB(≥0) 1/mm │ requires   time_per_unit_volume   SB(≥0) s/mm³                                                                              
                  │                                           │ requires   force                  SB(≥0) N                                                                                  
                  │                                           │ requires   mass                   SB(≥0) kg                                                                                 
                  │                                           │ requires   budget                 SB(≥0) $                                                                                  
                  └ DP_True SB(≥0) 1/mm  ⇸  WU ⟨s/mm³,N,kg,$⟩                 val = * > ()                                                                                                  
                                            └ Π<4>                                                                                                                                          
                                              ├ time_per_unit_volume: SB(≥0)                                                                                                                
                                              ├                force: SB(≥0)                                                                                                                
                                              ├                 mass: SB(≥0)                                                                                                                
                                              └               budget: SB(≥0)                                                                                                                
                     true