Hubbing

Hubbing is a metalworking process that is used to make dies. It is a cold-working process, which means that it occurs well below the melting temperature of the metal being worked.

Process

In hubbing, a male hub (master) is created with a profile that will form an impression on the female piece. The male hub is generally hardened and the female die block softened by annealing to help form the impression. As the metal flows the face of the die block is deformed, and, generally, must be machined flat. The die block is often a cylinder that is reinforced with a surrounding steel ring during the hubbing process. Hubbing is usually less expensive than die sinking, i.e., machining the female die, and multiple dies can be made from the male hub.

In the case of mild steel, a typical hubbing press exerts a pressure of approximately 1500 short tons-force per square inch (21 GPa) to transfer the image from a master hub into the master die.

gollark: ... also array literals, bee their bad docs.
gollark: Please also give me write access to the repo.
gollark: Oh, right, array indexing.
gollark: ```python# parsita-based pseudocode syntax parserfrom stmt import *from parsita import *from parsita.util import constantdef compose(f, g): return lambda x: f(g(x))def map_expr(x): start, end = x if end == "": return start return Op([start, end[1]], end[0])def map_unop_expr(x): return Op(x[1], x[0])def aliases(name, aliases): p = lit(name) for alias in aliases: p |= (lit(alias) > (lambda _: name)) return pclass ExprParser(TextParsers): ε = lit("") IntLit = reg("\-?[0-9]+") > compose(IntLit, int) StrLit = "'" >> reg("[^']*") << "'" > StrLit # TODO escapes (not in "spec" but could be needed) FloatLit = reg("\-?[0-9]+\.[0-9]+") > compose(FloatLit, float) Identifier = reg("[a-zA-Z_]+[a-zA-Z_0-9]*") > Var BracketedExpr = "(" >> Expr << ")" UnaryOperator = lit("NOT") Start = FloatLit | StrLit | IntLit | BracketedExpr | (UnaryOperator & Expr > map_unop_expr) | Identifier # avoid left recursion problems by not doing left recursion # AQA pseudocode does not appear to have a notion of "operator precedence", simplifying parsing logic nicely BinaryOperator = aliases("≤", ["<="]) | aliases("≠", ["!="]) | aliases("≥", [">="]) | lit("DIV") | lit("MOD") | lit("AND") | lit("OR") | reg("[+/*\-=<>]") End = (BinaryOperator & Expr) | ε Expr = (Start & End) > map_exprparse = ExprParser.Expr.parsex = parse("1+2+3 != 6 AND NOT 4 AND x + y")if isinstance(x, Failure): print(x.message)else: print(x.value)```
gollark: <@332271551481118732> Expression parsing is done, I think.

See also

References
  • DeGarmo, E. Paul, J T. Black, and Ronald A. Kohser. Materials and Processes in Manufacturing. Upper Saddle River, New Jersey: Prentice Hall, 1997. ISBN 0-02-328621-0
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.