So, thank you for being here to the end.
So, my talk will be about James, which is a kind of a language for an existing audience.
So, my name is Anthony Steyer.
I'm a research engineer at Altsi, the French, the T.S.U.
So, in terms of size, but also in terms of budget, I guess.
And I have to say that for a week, since we have a significant budget for R&D,
we'll serve the chance to have an R&D management.
So, it's very, it's a favourable tool for construction.
And my, so research area is the many related to one of the institutions of our sea, which is a
conductive prospective analysis of the secretive supply and the innovative evidence on the health of the French government.
So, I start with a small segmentive note, because it matters here.
So, the data change model as data.
What means here, the model in the context of finance?
In this community, the term is a bit overloaded.
So, people use this term to speak about a tool, like faxar, like antares.
Also, people use the name, not only to speak about the study case, like faxar Europe,
but also the antares to any extent.
And also, maybe, you can do the term to speak about the related optimization.
Here, what I would call model is much more simple.
It's just the abstract mathematical distribution of the given type of components of the internal system.
So, for instance, the mathematical equation that we are using, to describe the behavior of the storage unit of the nuclear power plant,
or of the visualization line.
So, some also make all this basic model, but here, what the model is, just the type of model.
And it's a mathematical structure.
So, then, I'll be talking about the language, not a tool or a tool in domain.
And also, the presentation I'm going to give you, speaking about the language.
So, this is an elementary language to represent the components of components.
And therefore, to describe systems in a set-point name, an elementary school.
So, what is jams?
So, jams stands for generate in a system's learning scheme.
So, from a terrestrial prototype, this is a graph-based algebraic coding language.
So, to configure and extend the models of components.
And this is coming with the data structure to represent the analysis.
So, for now, to interpret your projects, have been developed.
So, first, we developed a pattern to interpret your projects.
It was made up to the first step.
And then, we industrialized this pattern to a specific school.
That is, now, inside our task network.
The task network means the tool that is used in traditional and absolutely for a prospective stage.
So, we have now the presentation website that is recently sent out on the language.
So, basically, how we have our jams working here.
So, we are just describing the analysis system as a hyper graph.
So, the vertices of the graph are basically just some components.
And so, the graph is described in a number of I.
So, the components are the vertices and the data instantiate models.
And the models are described in the also file.
That is called the library file.
So, basically, the library file is the file that contains the mathematical expressions of each type of components.
So, I just know the time.
So, basically, I.
So, basically, the edges of the graph are the connections between components and the accurate parts.
So, how does the model look like in a library file?
It just the simple declaration of the parameters, the variables, the parts and some mathematical constraints.
The contribution of the models to the global objective of the system.
So, here, for instance, we see a very simple model for what you can call a best with a splage and a transparent logic.
When an edge is designed.
And then in the system file.
So, the file that you present the system, we just have for each component.
The reference to the model that the component is instantiating.
And the declaration of the numerical value of the parameters that are in the template.
So, basically, the core concepts are, in fact, the optimization concepts like variables parameters.
By equal to variables and parameters are indexed by time and scenarios.
We have also, like, the objective constraints.
And as we regard the graph, we use the notion of port.
And the ports have fields.
Basically, the components can exchange in their expressions to fields.
So, well, those genes fit among existing modeling tools.
So, basically, we try to find a good compromise between algebraic modeling languages like,
an example, and the classical tools, object-oriented tools like,
an entire spectrum, etc.
So, basically, we try to be as expressive in terms of mathematical experience as an example.
That we try also to, naturally, embark the graph nature of the system.
From a mathematical point of view, we are representative,
and mix, mix, integer, enough, and problems.
Over time, cross scenario grids of index indices.
To represent, so, deterministic, or to stage to get stickier to the cases.
And the main targets, the applications are adequacy assessment studies,
production cost simulation, and capacity expansion planning.
I like to make the analogy with model class, so, basically, we are a bit trained to build a modelic habit.
The difference with modelic case is that, when the case is designed for dynamical systems,
to simulate ODS, whereas, we are simulating optimized systems.
So, the systems are simulated by solving the optimization techniques.
So, what were the motivation for this architectural architectural breakthrough?
So, first I will, so, as I remind you, I explained the breakthrough.
So, the idea is that in classical, object-oriented, object-oriented modeling environments,
like PISA, Antis, the mathematical equations of the components.
So, the models of components, they are outputted inside the software.
And then the software builds an optimization problem through a multi-survivant interface,
give it to a software, and then read the results based on the optimization.
And now, we are trying the models from the tools that is to say,
we consider the mathematical equations as inputs.
And then, the instructor is just a piece of code that dynamic reads the equations
to build the optimization problem.
We are still using a multi-survivant interface.
It's not an alternative to a multi-survivant interface like in a pair of atoms.
It's just a small layer of code on top of it.
And then, basically, the idea is to build the community of models,
so, just to say, for instance, we can represent in our library, the legacy models of Antares.
So, the models that before were outputted in Antares,
we have also a library of the pipe's models.
So, the equations of the pipe's circumference, and we can imagine to maintain several libraries
depending on the use cases.
So, this is kind of, actually, a short breakthrough for Antares later,
and I will explain the motivations.
So, as I said, this is our tool for large scale planning studies that have art is,
the official tools for for for for for for for for for for for for this.
So, national studies and European studies.
The first motivation at the beginning of the project is mostly, let's say, versatile modeling,
and then also the main ability of the code in a relative context and interoperability.
So, that's why we designed the language and the interpretorial inside of pipes.
So, first, the first motivation, so versatile local modeling.
So, this topic rose when we saw that it was more and more difficult to maintain a stable code,
while addressing a lot of new questions from the users.
So, for instance, can we add this new type of components?
Can I change my components to have, I don't know, a storage injection capacity,
as depends on the state of charge.
So, a lot of evolution asked by the users.
So, we were saying that the classical options that we add were a bit immediately like.
Historically, we could use modeling artifacts that is, we say, if you want to model a flexible load,
you can say, okay, it's a load, a generator and a crystal for strength.
So, you can use the art grid grammar that is then a bit of mess.
You can also implement a new component in your code, but then you have to manage the impacts
on all your options of interpretation.
Or, in the gents way, now you can just add a few lines in your normal library type,
configuration file, to introduce a new type of component.
Without any change in the software code.
So, we think that it will reduce the time to market of new models for users.
And it will also help seeping more stable properties.
So, that's the second motivation, maintainability in an evolutive context.
So, we think that we manage to, by doing this to decouple modeling from industrial software engineering,
for better, maintainability and for better synergies between teams.
And the last motivation that, let's say, came up later, is the interoperability between tools.
So, why interoperability?
It's mainly that for our academic and industrial algorithms,
our aim is to reduce, let's say, the communication cost with our partners,
and also to better capitalize on common words.
The problem with interoperability is that it's a bit like trying to fit,
and let's say, circle things into square halls, or raise us up.
So, two possible approaches are possible to share steady cases in a tool agnostic way,
reducing the ambiguities.
The classical approach is semantics.
I try to build ontologies to list all the possible, let's say,
components of the energy system that we can sync up and trying to list the parameters.
Now, the way that we are proposing, it's an alternative, it's more like complementary,
that replacing the first one, but we think that a more direct way,
maybe, is just to share the math behind, to share the symbolics.
So, I think that, since to James, we're able to share a steady case with all the
important information that you need to re-simulate the test case, but still,
why can't we add here, we are able to share the mathematical formulation,
but still, a tool is not only a mathematical formulation, it's also a solution workflow.
So, we think that the solution workflow will remain a tool dependent, and we're fine with this,
because it's also what is interesting in the multiplicity of tools.
To finish my talk, I will just introduce you to a small, to test cases that we,
we conducted to illustrate the last motivation, in terms of with pipsa.
So, I think that at this time of the day, you know what is pipsa and probably what is pipsa
and we wonder how we could try to take advantage from this very nice dataset, from this very nice community,
and to make a bridge with our ecosystem.
So, we build a simple converter from a pipsa network to James's study case.
The idea was to confirm the expressiveness of the James language,
also to connect, as I say, with this interesting ecosystem.
And also to be able, in the end, to run internal or public,
on-ties of pipsa test cases, with the same software,
reducing infrastructure and graphical interface, and sharing advanced optimization methods,
like our bend-dose decomposition code that we are developing.
So, basically, we just wrote, as I said earlier, the pipsa nodes,
and for just one yellow file, that represents the mathematical equations of pipsa.
And we just have a small piece of code that takes the pipsa network objects,
and they export the data in our format, but it's just about changing the format of data series.
So, we are conducting numerical comparison tests,
so a parallel run between pipsa and our James interpreter,
and we manage just to have the same numerical result, same objective value.
So, this is a work in progress, so for now, we are not managing all the pipsa components,
but we will soon, and we will also conduct large-scale test cases.
So, to conclude, the James is a project that started almost three years ago now.
So, we first had a prototyping in Python, and now it is integrated into our online simulator,
and then I read about it, because we still have to manage the legacy code of our files.
And for the next year, we are going to have a rough data interface that manage James object,
and you are going to continue working on new features for this language,
and we are going to manage this feature, run up the pipsa.
So, the key takeaways, so we are proposing a high-level language that takes the mathematics parameters,
both of the software code, so that we are able to share self-contained the input data for running
to the case, and for replicating the simulations.
We have two generic and separate interpreters.
So, one eye-performance, let's say, interpreters inside the automation method,
and one, let's say, sandboxing the interpreter in Python called James Python.
And those code are just, let's say, single-is, just mathematical and linear expressions.
There is no business logic happening in those interpreters.
We think that this approach favors the versatile modernity of code, and interoperability.
And for sure, we are open to new collaboration around James.
So, James, let's say, it was developed in the context of an RNG project,
with the external partners.
So, we already have some academic and street partners on the topic,
but we are open to new collaborations.
For instance, to study interoperability with your favorite tool,
or to start structuring it together, reference libraries of models,
or to work on the graphical interface.
So, that's was James, thank you for your attention,
and I'll give you a few questions.
At a PhD student during that,
we had just a year ago.
Did you guys implement a course student as much as you do?
Did you implement a dynamic structure?
We can do it during the course of simulation changes,
and structure of the grid as it goes.
Or is it a great structure fixed during the simulation?
And, you mean, over the waffle process, over time?
If you have a simulation over time,
you can expand your system.
You can provide a new, like, clear the area for expanding,
and then you start simulation in the tries to see what is the structure
that the grid can develop over time.
You don't know then of the structure,
it just tries to test different ways of expansion.
So, the question is whether rival to manage a structure of the network
that is evolving over time?
I would say that you have to put it,
say your expansion for the days from the building,
for the simulation,
but you can afford them to have a real capacity
at the building of the simulation.
That's what I love when I saw your presentation.
We were also working on that in the industry
working on that as well.
I'm using the graph to express the grid.
And graph to the power of its engine as well.
Or do you guys want that with it?
No, it's it.
Let's see that we are focusing on coffee chosen.
So, the question was if we studied the possibility to have a dynamic structure of the graph
or the simulation time,
but it's still to be explored.
So, I'm not the software developer behind this,
but the question is,
are we doing the manager,
how is that expression?
So, I'm not the software developer behind this,
but the question is,
are we doing the manager,
how do we pass the manager expression in our language?
I think it's based on INTRL and graph.
So, it's a package to manage expressions,
but let's say that we are then our own structure
to represent the mathematical expressions.
So, in April, it's cool to be in my work with some of its sounds,
and really be unrelated to what it is doing.
I work with an application, which is the evaluation of the visual,
and then it has this expressive capability,
or references the thing.
So, you have to work on that,
and if you're listening to it,
you have to express the mathematical expressions
on the right hand side as well.
It's funny, it's like,
with the whole thing in the type change,
we need to pay the score actually for the score.
And I think it's a little bit different.
That's one of the things that's used by the library
that has mathematical expressions,
and we could from the graph view,
it's like the always structure of the mathematical expressions,
and the right hand and the right hand and the right hand.
The right is the key, it's pressing,
you get all of that,
the right is really the key to it.
It blocks a lot of stuff when you're building it.
And I saw from a software engineering perspective,
I think it's very interesting,
because it gives a very care,
it's a fast contract between a distance,
a graphical length of face and your simulator.
Thank you very much.
Thank you.
You mentioned that,
the mathematical description was confirmed,
so I'm not going to answer the question,
but I'm not going to answer it,
but I'm going to answer it,
and you describe it through that,
so the question is that,
the question is,
are semantics and symbolics,
complementary or incompatitions somehow?
I would say that,
if I add to choose between both approaches,
the more you go for the second one,
because let's say that you have the old information
that you need to do the simulation,
whereas if you are doing semantics,
then you have to check some documentation of certain specifications
to understand the logic behind.
Still, I think that's to organize our library of models.
It could be interesting to refer to some standards,
because we still have the...
I think we have the material of the issue of organizing this library.
So the question is about a potential use case,
mixing in the upper film,
and you can test from a link.
So the question is about a potential use case,
mixing in the upper film,
or from a link in cash from a link.
So for now,
I think that we will very stick to mixing the gel in our programming problems.
So that's what one of our, let's say, peer direction.
Then I think that still it opens a lot of possibilities
for also use cases,
than the one I mentioned,
like a depostaticist, so expansion time,
because somehow, in the end,
the language is very mathematical.
There is very few almost new energy concepts inside,
maybe the only energy concept is just the time dependency
and scenario dependency,
but let's say that we kept the world energy in the acronym
because this is,
the language is designed intentionally for those applications,
so it's more generative.
So I believe so.
Sorry, the question is whether,
let's say, this tool,
so distinguish with the,
and if the benefit was used also to benefit
to the collaborations between the TS or Europe,
for instance,
I think that the case in the sense that,
in our priorities,
a really true, for,
especially for European studies,
to have a, let's say,
a smooth process between the,
between the different partners,
because there are several tools,
and it's not easy to communicate between the two tools.
So I think with,
that we,
James, we would be able to,
to share,
study cases to share data in a well organized way,
that is,
we can use that,
this is a tool I'm going to integrate with this.
So that's,
I think that's,
providing,
I don't know.
Thank you.