Symbolic specifying of locations that are "just" before or "just" after another location. about sympy

[smichr]

There used to be an infinitesimal assumption that symbols could use. Use of a specific symbol seems fragile. What about using an expression eps = 1/Dummy('OO', infinite=True)? Used with L=var('L', positive=True) gives SingularityFunction(L - eps, L/2, 1)->L/2-1/OO For clean-up, replace with oo and you should have what you want.

[moorepants]

Can the epsilon symbol be used to track this symbolically?

[mvg2002]

@moorepants, It is possible to use the epsilon symbol here. This will result in answers that still contain singularity functions. Example 1 with the use of epsilon will look like:

from sympy.physics.continuum_mechanics.beam import Beam
from sympy import Symbol
L = Symbol('L', positive='true')
eps = Symbol('eps', positive='true')
F = Symbol('F')
E = Symbol('E')
I = Symbol('I')
b = Beam(L, E, I)
r0 = b.apply_support(0, type="pin")
rL, mL = b.apply_support(L, type="fixed")
b.apply_load(F, L/2, -1)
b.apply_rotation_hinge(L-eps)
b.solve_for_reaction_loads(r0, rL, mL)
b.reaction_loads

{R_0: -F*SingularityFunction(L - eps, L/2, 1)/SingularityFunction(L - eps, 0, 1),
 R_L: -F + F*SingularityFunction(L - eps, L/2, 1)/SingularityFunction(L - eps, 0, 1),
 M_L: -F*L/2 + F*L*SingularityFunction(L - eps, L/2, 1)/SingularityFunction(L - eps, 0, 1)}

Simplifying this with the knowledge that eps is very close to 0 gives:
{R_0: -F/2, R_L: -F/2, M_L: 0}

This is correct. The problem is that sympy does not know that eps is very close to zero and is only there to show which item should be evaluated first. That is why it can't solve the SingularityFunction(L - eps, L/2, 1) to L/2.

This problem can be solved by hand for these type of equations, but for larger equations this will become a lot of work.

[mvg2002]

@smichr Thanks for thinking with me. This is something I would not have come up with. The strange thing is that the solution changes when doing this.

from sympy.physics.continuum_mechanics.beam import Beam
from sympy import Symbol, Dummy, var

L = var('L', positive=True)
eps = 1/Dummy('OO', infinite=True)
F = Symbol('F')
E = Symbol('E')
I = Symbol('I')
b = Beam(L, E, I)
r0 = b.apply_support(0, type="pin")
rL, mL = b.apply_support(L, type="fixed")
b.apply_load(F, L/2, -1)
b.apply_rotation_hinge(L-eps)
b.solve_for_reaction_loads(r0, rL, mL)
b.reaction_loads

Outputs: {R_0: -F, R_L: 0, M_L: F*L/2}

It should not be possible to get a bending moment in the fixed support as there is a hinge right before it. I am not sure why this still happens.

[mvg2002]

A way that does work:

from sympy.physics.continuum_mechanics.beam import Beam
from sympy import Symbol, Dummy, var

L = var('L', positive=True)
eps = Dummy('eps', positive=True)
F = Symbol('F')
E = Symbol('E')
I = Symbol('I')
b = Beam(L, E, I)
r0 = b.apply_support(0, type="pin")
rL, mL = b.apply_support(L, type="fixed")
b.apply_load(F, L/2, -1)
b.apply_rotation_hinge(L - eps)
b.solve_for_reaction_loads(r0, rL, mL)
b.subbed_reaction_loads = {reaction: eq.subs(eps, 0) for reaction, eq in b.reaction_loads.items()}
b.subbed_reaction_loads

Ouputs: {R_0: -F/2, R_L: -F/2, M_L: 0}

This does not seem like the most robust way to do this, but does give the correct answer for this example.

[mvg2002]

Another strange thing. If you try the same code for example 2, the correct output depends on if you use b.apply_load(M, L/2+eps, -2) or b.apply_rotation_hinge(L/2-eps).

from sympy.physics.continuum_mechanics.beam import Beam
from sympy import Symbol, Dummy, var
L = var('L', positive=True)
eps = Dummy('eps', positive=True)
M = Symbol('M')
E = Symbol('E')
I = Symbol('I')
b = Beam(L, E, I)
r0 = b.apply_support(0, type="pin")
rL, mL = b.apply_support(L, type="fixed")
b.apply_load(M, L/2+eps, -2)
b.apply_rotation_hinge(L/2)
b.solve_for_reaction_loads(r0, rL, mL)
b.reaction_loads

Outputs: {R_0: 0, R_L: 0, M_L: 0}

While

from sympy.physics.continuum_mechanics.beam import Beam
from sympy import Symbol, Dummy, var
L = var('L', positive=True)
eps = Dummy('eps', positive=True)
M = Symbol('M')
E = Symbol('E')
I = Symbol('I')
b = Beam(L, E, I)
r0 = b.apply_support(0, type="pin")
rL, mL = b.apply_support(L, type="fixed")
b.apply_load(M, L/2, -2)
b.apply_rotation_hinge(L/2-eps)
b.solve_for_reaction_loads(r0, rL, mL)
b.reaction_loads

Outputs: {R_0: 0, R_L: 0, M_L: -M}, which is correct.

[smichr]

Rethinking about OO: if it is only infinite, then the sign is unknown so x+1/OO might be greater, equal or less than x. If you make it positive, there is no guarantee about ordering, e.g. x+eps might be bigger than y. But maybe (in this case) that is not a concern?

[smichr]

If you need a number that is guaranteed less than 1 you could use 1/Dummy(prime=True).