The¶

Willing Kingdon Clifford¶

Algebra Library¶

Martin Roelfs

Flanders Make, University of Antwerp

Introduction¶

• Why another GA library?
  • Design Philosophy
  • Basic Examples
• Inner Workings
• Industrial Examples
• Get started with kingdon

Why Another GA Library¶

• Python is very popular with the scientific community
  • ease of use
  • rapid prototyping
  • rich ecosystem of (scientific) tooling

kingdon Design Philosophy¶

kingdon was developed with the following goals in mind:

• Easy to use API.
• Rapid prototyping.
  • Visualization: ganja.js enabled graphics in jupyter notebooks.
• Input agnostic: symbols, floats, tensors, etc.
  • If it supports $+, -, *$ and optionally $/$ and $\sqrt{}$ then it is a valid coefficient for a multivector.
• Performance: symbolic code generation and just-in-time compilation.

Add GA to any workflow

Basic Examples

Dimension Agnostic Thinking¶

Automatic Differentiation¶

Dual numbers $\mathbb{R}_{0,0,1}$ can be used for automatic differentiation:

>>> from kingdon import Algebra
>>> dualalg = Algebra(r=1)
>>> x = dualalg.multivector(e='x', e0=1)
>>> x
x + 1 𝐞₀

>>> x**3
(x**3) + (3*x**2) 𝐞₀

And because dual numbers support $+, -, *, /$ and $\sqrt{}$, we can use them as multivector coefficients in other algebras!

>>> alg = Algebra(3, 0, 1)
>>> tvals = numpy.linspace(0, 3)
>>> t = alg.multivector(e=dualalg.multivector(e=tvals, e0=1))
>>> R = (t * alg.blades.e12).exp(...)

More on this later...

Inner Workings¶

Let's explain the inner workings of kingdon by means of a simple example: Within $\mathbb{R}_{2, 0, 1}$ (2DPGA) consider the inner product between a bivector $B$ and a vector $v$: $$ w = B \cdot v $$

To perform this computation symbolically with kingdon looks as follows:

>>> from kingdon import Algebra

>>> alg = Algebra(2, 0, 1)
>>> B = alg.bivector(name='B')
>>> B
B01 𝐞₀₁ + B02 𝐞₀₂ + B12 𝐞₁₂

>>> v = alg.vector(name='v')
>>> v
v0 𝐞₀ + v1 𝐞₁ + v2 𝐞₂

>>> B | v
(B01*v1 + B02*v2) 𝐞₀ + (B12*v2) 𝐞₁ + (-B12*v1) 𝐞₂

Inner Workings¶

Binary representation of basis blades:

kingdon multivectors are mappings of key/value pairs:

>>> v = alg.vector(name='v')
>>> v
v0 𝐞₀ + v1 𝐞₁ + v2 𝐞₂
>>> v.keys()
(1, 2, 4)
>>> v.values()
[v0, v1, v2]

>>> B = alg.bivector(name='B')
>>> B
B01 𝐞₀₁ + B02 𝐞₀₂ + B12 𝐞₁₂
>>> B.keys()
(3, 5, 6)
>>> B.values()
[B01, B02, B12]

Inner Workings¶

The kingdon internals are lazy: code is only generated once it is needed.

>>> alg = Algebra(2, 0, 1)
>>> alg.ip
OperatorDict(codegen=<function codegen_ip at 0x0000025BFE604DC0>, ..., operator_dict={})

>>> alg.ip
OperatorDict(codegen=<function codegen_ip at 0x0000025BFE604DC0>, ..., operator_dict={
    ((3, 5, 6), (1, 2, 4)): ((1, 2, 4), <function codegen_ip_112_x_14 at 0x...>)
})

def codegen_ip_112_x_14(A, B):
    [a01, a02, a12] = A
    [b0, b1, b2] = B
    return [a01*b1+a02*b2, a12*b2, -a12*b1]

Inner Workings¶

Advanced customization:

• graded mode to reduce the number of types.
  • In the future this will be expanded to a more advanced typing system.
• cse to eliminate common subexpressions
• wrapper function to decorate the generated code with, e.g.

  @numba.njit
  def codegen_ip_112_x_14(A, B):
     [a01, a02, a12] = A
     [b0, b1, b2] = B
     return [a01*b1+a02*b2, a12*b2, -a12*b1]
  

• simp_func is a filter function that is applied after every call, e.g. sympy.simplify in symbolic mode or lambda x: abs(x) > 1e-9 for numerical input.
• symbolcls/codegen_symbolcls specify the symbol class to use during codegen and when making symbolic multivectors.

Industrial Examples¶

Flanders Make is a strategic research centre for the make industry in the Flanders region of Belgium.

I'd like to share with you the usage of kingdon in two projects at Flanders Make:

• Aandrijflijn Concept Optimalisatie (AnCoOpt). Goal: [...] to develop [...] tools and methods to convert a customer request into an optimal machine concept for electrically driven positioning applications. A machine concept is optimal when it allows to minimize the machine component costs, energy consumption, material use in further detailed design and at the same time maximize the performance (speed, precision, etc.).
• Tolerance Design Optimization (ToleDO). Goal: provide a novel workflow and toolchain to enable engineers to obtain the best performance of their designs at a minimal production cost, by showing the impact of key manufacturing tolerances on functional performance early in the design phase.

AnCoOpt¶

Nedschroef & covid ventilator examples

AnCoOpt¶

AnCoOpt¶

ToleDO¶

Tolerance Analysis¶

Core idea: add up all the tolerances between parts to find their influence on the Functional Requirement (FR). E.g. the parallelism of the two shafts in the gearbox.

ToleDO¶

Tolerance Analysis: Unified Jacobian Torsor Method¶

Core principle: represent each tolerance zones using a torsor (screw): $$ T = \begin{pmatrix} u \\ v \\ w \\ \alpha \\ \beta \\ \gamma \end{pmatrix} \qquad \rightarrow \qquad T = u \mathbf{e}_{01} + v \mathbf{e}_{02} + w \mathbf{e}_{03} + \alpha \mathbf{e}_{23} + \beta \mathbf{e}_{13} + \gamma \mathbf{e}_{12} $$

ToleDO¶

PGA based Tolerance Analysis (Publication Pending)¶

• Unifies different approaches in literature:
  • when acting on lines, we recover the Unified Jacobian Torsor Method
  • when acting on points, we recover the Matrix Method
• Correctly accounts for the impact of each Tolerance Zone on the final Functional Requirement.
• Novel: PGA allows generalization to angular functional requirement.

ToleDO¶

PGA based Tolerance Analysis (Publication Pending)¶

Live Demo?

Get Started with kingdon¶

• Just like ganja.js has its coffeeshop, kingdon has its teahouse: https://tbuli.github.io/teahouse/.

  

  Ganja usage is tolerated in the Teahouse!

• Or just install using pip install kingdon!

BACK-UP SLIDES¶

ToleDO¶

Tolerance Analysis¶

Common technique: Stack-up analysis. Stack-up is typically done in 1D or 2D, e.g. with the advanced tool that is Excel.

Stack-up software is readily available, with some going up to 3D. Inventor Tolerance Analysis, Creo EZ Tolerance Analysis, 3DCS Variation Analyst (Dedicated software)

We want to go beyond 1D stack-up analysis

ToleDO¶

Tolerance Analysis: Unified Jacobian Torsor Method¶

The Functional Requirement is then found by summing up all the tolerance zones:

Screw torsors, we can do this with PGA!