Variable constraints

[FedeClaudi]

Hello,

I've managed to finally solve the minimum time maneuvering problem we discussed previously.
Currently, I have a track of fixed width and the goal is to find the fastest trajectory along it (salmon trace):

Without going too much into the details, we have a variable n which represents the distance from the track's center line (the dotted line above), and we impose some bounds on the variable:

-allowed_track_width ≤ n ≤ allowed_track_width, Infinite(s)

However I would like for allowed_track_width itself to vary as a function of the parameter s. I've tried using registered functions that return a value of width as a function of s and I've tried turning allowed_track_width into a vector of values. In both cases the syntax wasn't recognized during the model's creation.

Is there a way to do this, either in @variables or in @Constraints?

Thank you,
Federico

[pulsipher]

These results look awesome!

Yes, you can let the track width vary as a function of s. The easiest way to do this would be using the @parameter_function macro which enables us to embed arbitrary Julia functions (that only depend on infinite parameters) in InfiniteOpt expressions. The syntax details are given here. Note however, that the bounds syntax in @variable currently supports only constants (though perhaps we could generalize this). So, you'll need to enforce the limits via @constraint.

In this case, a simple example would be:

using InfiniteOpt

model = InfiniteModel()
@infinite_parameter(model, s in [0, 1])

my_func(s) = sin(s) # TODO replace with desired function
@parameter_function(model, allowed_track_width == my_func(s))

@variable(model, n, Infinite(s))

@constraint(model, -allowed_track_width <= n)
@constraint(model, n <= allowed_track_width)

[FedeClaudi]

Brilliant! Let's give it a try

[pulsipher]

Sounds good. I opened #253 to track enabling infinite variables to directly support functional bounds.

[FedeClaudi]

Thanks.

This not strictly necessary, but out of curiosity can I then get the values out of allowed_track_width?
Something like: value(control_model[:allowed_track_width]) (which doesn't work)

[pulsipher]

You are right, value doesn't work. This is a bug. I will write a patch for this. In the interim, you can use transcription_variable to retrieve the values.

using InfiniteOpt, Ipopt

model = InfiniteModel(Ipopt.Optimizer)
@infinite_parameter(model, s in [0, 1], num_supports = 4)
@variable(model, y, Infinite(s))
my_func(s) = 42
@parameter_function(model, pfunc == my_func(s))
@objective(model, Min, integral((y - pfunc)^2, s))
optimize!(model)
transcription_variable(pfunc)

[pulsipher]

For reference, #254 tracks this fix.

[FedeClaudi]

It all works beautifully.

I must sound quite repetitive by now, but InfiniteOpt is just awesome 😉

[pulsipher]

Thank you again. At some point in the future it would be awesome to see a write up of your model. It would make for a nice example problem.

[FedeClaudi]

Yeah of course, I can put together an example script

[FedeClaudi]

I was trying to make a minimal working example, but it was ending up being as long as the whole thing.. so might as well share the whole thing.

So, here:
https://github.com/BrancoLab/LocomotionControl/blob/master/analysis/behavior/src/control.jl
is where InfiniteOpt is used to solve the minimum time maneuvering problem.
Here:
https://github.com/BrancoLab/LocomotionControl/blob/master/analysis/behavior/src/forward_model.jl
is where we use the solution to integrate the ODEs that give us the final result.
This:
https://github.com/BrancoLab/LocomotionControl/blob/master/analysis/behavior/do_mtm.jl
is what we use to run the whole thing and plot the results.

The solution strategy involves reformulating the dynamics as progress along the track instead of time and maximizing how quickly the models progresses subject to constraints expressed in the track's curvilinear coordinates system. This gives the controls history which we can then use to integrate and get the dynamics in time and in the allocentric coordinates frame. We're using a simple kinematic bicycle model here. I can send a couple papers in which they explain the approach much better than I ever can.

[pulsipher]

Awesome, thanks for sharing!