Does anyone know of any patches / abstractions / libraries for playing with modal synthesis in pd?
In particular I'm looking at this paper: http://www.cs.ubc.ca/~kvdoel/publications/modalpaper.pdf
But I'd love put together something that looks a little like modalys...
https://www.youtube.com/watch?v=8m-KlgF48mU
The only implementations I'm really aware of is the old STK (https://ccrma.stanford.edu/software/stk/) - which actually isn't maintained for pd or running on modern systems as far as I can tell. Some of it made it's way to faust and I've had some luck cross - compiling, but I imagine there might be better / newer stuff around...
2017-08-05 23:10 GMT-03:00 jmejia@anestheticaudio.com:
Does anyone know of any patches / abstractions / libraries for playing with modal synthesis in pd?
In particular I'm looking at this paper: http://www.cs.ubc.ca/~ kvdoel/publications/modalpaper.pdf
Haven't looked deeply, but seems like just a bank of resonators, huh? Not hard to do in Pd, if so.
The only implementations I'm really aware of is the old STK ( https://ccrma.stanford.edu/software/stk/) - which actually isn't maintained for pd or running on modern systems as far as I can tell. Some of it made it's way to faust and I've had some luck cross - compiling, but I imagine there might be better / newer stuff around...
Me and Mark were interested in compiling STK stuff for Pd again, it's supposed let's see
cheers
2017-08-06 3:05 GMT-03:00 Alexandre Torres Porres porres@gmail.com:
it's supposed
it's supposed to be not much complicated (I meant to write)
Indeed looks like Karplus Strong…
https://en.wikipedia.org/wiki/Karplus%E2%80%93Strong_string_synthesis%5C
On 6 August 2017 at 13:06:54, Alexandre Torres Porres (porres@gmail.com) wrote:
2017-08-06 3:05 GMT-03:00 Alexandre Torres Porres porres@gmail.com:
it's supposed
it's supposed to be not much complicated (I meant to write) _______________________________________________ Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Hello There is at IRCAM a pd implementation of modal synthesis, called modalys. Modal synthesis is different from oscillators or karplus strong, in that it takes account for frequencies AND space data of vibrating structures (modal shapes), making it though possible to synthesize transient sounds and articulations in time domain which are difficult if not impossible to modelize in frequency domain. modalys is a pd library, works in real time and is a (very) simplified version of a lisp / C++ software which was developed in 80s, the latter making sounds more real than natural sounds. For more info, see JM ADRIEN (1989) The missing link : Modal Synthesis, in "The Representations of Sound", G.de Poli, A.Piccially and C.Roads editors. The MIT Press, Cambridge, Mass.
jm
Le 6 août 2017 à 09:12, Mikael at UL mikael.fernstrom@ul.ie a écrit :
http://www.soundobject.org/ http://www.soundobject.org/
Sent from a mobile device. _______________________________________________ Pd-list@lists.iem.at mailto:Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list https://lists.puredata.info/listinfo/pd-list
Le 06/08/2017 à 10:14, Jean-Marie Adrien a écrit :
Hello There is at IRCAM a pd implementation of modal synthesis, called modalys.
unfortunatlly, IRCAM is not famous for sharing what they develop with taxpayer money.
c
Modal synthesis is different from oscillators or karplus strong, in that it takes account for frequencies AND space data of vibrating structures (modal shapes), making it though possible to synthesize transient sounds and articulations in time domain which are difficult if not impossible to modelize in frequency domain. modalys is a pd library, works in real time and is a (very) simplified version of a lisp / C++ software which was developed in 80s, the latter making sounds more real than natural sounds. For more info, see
JM ADRIEN (1989) The missing link : Modal Synthesis, in "The Representations of Sound", G.de http://g.de Poli, A.Piccially and C.Roads editors. The MIT Press, Cambridge, Mass.
jm
Le 6 août 2017 à 09:12, Mikael at UL <mikael.fernstrom@ul.ie mailto:mikael.fernstrom@ul.ie> a écrit :
Sent from a mobile device. _______________________________________________ Pd-list@lists.iem.at mailto:Pd-list@lists.iem.atmailing list UNSUBSCRIBE and account-management ->https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Le 6 août 2017 à 10:58, cyrille henry ch@chnry.net a écrit :
Le 06/08/2017 à 10:14, Jean-Marie Adrien a écrit :
Hello There is at IRCAM a pd implementation of modal synthesis, called modalys.
unfortunatlly, IRCAM is not famous for sharing what they develop with taxpayer money.
:) indeed and i had myself to pay for it, which is something that probably illustrates the "élégance à la française" jm
c
Modal synthesis is different from oscillators or karplus strong, in that it takes account for frequencies AND space data of vibrating structures (modal shapes), making it though possible to synthesize transient sounds and articulations in time domain which are difficult if not impossible to modelize in frequency domain. modalys is a pd library, works in real time and is a (very) simplified version of a lisp / C++ software which was developed in 80s, the latter making sounds more real than natural sounds. For more info, see JM ADRIEN (1989) The missing link : Modal Synthesis, in "The Representations of Sound", G.de http://g.de Poli, A.Piccially and C.Roads editors. The MIT Press, Cambridge, Mass. jm
Le 6 août 2017 à 09:12, Mikael at UL <mikael.fernstrom@ul.ie mailto:mikael.fernstrom@ul.ie> a écrit :
Sent from a mobile device. _______________________________________________ Pd-list@lists.iem.at mailto:Pd-list@lists.iem.atmailing list UNSUBSCRIBE and account-management ->https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89.
The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive.
On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref.
I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. jm
Le 6 août 2017 à 16:50, Jesse Mejia jmejia@anestheticaudio.com a écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Wow Jean-Marie - amazing story! I'm glad to know it, though it's unfortunately quite familiar sounding.
Implementing your work as pd abstractions is a fantastic goal! It would be amazing to work with you on this.
It's worth mentioning another commercially successful - but actually completely open source modal synthesis project: https://mutable-instruments.net/modules/elements/
and while it doesn't sound like you're excited to read code these days - all of the dsp for that module is here: https://github.com/pichenettes/eurorack/tree/master/elements
I'd be curious to learn how similar that might be to your work.
At any rate - I'm going to start digging into this!
-jesse
On Aug 6, 2017, at 12:58 PM, Jean-Marie Adrien jm.adrien.mnt@gmail.com wrote:
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89.
The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive.
On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref.
I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. jm
Le 6 août 2017 à 16:50, Jesse Mejia jmejia@anestheticaudio.com a écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
hello,
I had a look at a modalys-help.pd file. It appear that modalys is not implemented as a pd abstraction, but as a compiled object. I may be wrong, but I think this object use modalys file that define all material / shape / exitator / etc. So it's quite useless without the full modalys software.
anyway, in order to add my piece of answer to the original question: about 20 years ago I made my master degree about a bow / string interaction using a fake motorized bow and a virtual string. 2 different strings where implemented :
-The 1st sting was made using virtual 1D mass, spring and damper in a linear arrangement, just like a spacial discretisation of a real string. This result of incorrect tuning of high harmonics of the virtual string (regarding a real string)
-The 2nd string was made using something also named "modal synthesis" (but very different from modalys) : it was "just" mass/spring/damper 1D resonator connected together, a bit like the paper initially send in this thread.
Since modalys use matrices, I guess that it use more complex interaction between elements than a simple spring/damper interaction like I use to do. This result in being able to also simulate the shape of the vibrating structure.
Anyway, about 15 years ago I start the pmpd library (physical modelling for pure data) that provide simple mass / spring / damper simulation. The pmpd~ object allow this kind of simulation at audio rate. There is an example of the 1st kind of string simulation. The 2nd string can also be implemented thanks to this object, but I did not provide any example since I miss the way to tune the model.
pmpd~ provide only simple interaction, so I don't use it any-more. I use the pmpd object that is lot's more complex (but works only at data rate) and a simple hack to compute audio data. There is also an example in the library distribution.
if you are interested, you can try pmpd using apt-get or deken on linux. I know that Nicolas Montgermont compile pmpd for osX, so a recent binary exist somewhere. I have no idea about recent build for windows.
cheers C
Le 06/08/2017 à 21:58, Jean-Marie Adrien a écrit :
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89.
The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive.
On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref.
I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. jm
Le 6 août 2017 à 16:50, Jesse Mejia jmejia@anestheticaudio.com a écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
yes, and i am very thankful because i use pmpd every day (OsX) to generate beautiful control shapes (i.e. natural gesture simulation) jm
Le 7 août 2017 à 13:56, cyrille henry ch@chnry.net a écrit :
hello,
I had a look at a modalys-help.pd file. It appear that modalys is not implemented as a pd abstraction, but as a compiled object. I may be wrong, but I think this object use modalys file that define all material / shape / exitator / etc. So it's quite useless without the full modalys software.
anyway, in order to add my piece of answer to the original question: about 20 years ago I made my master degree about a bow / string interaction using a fake motorized bow and a virtual string. 2 different strings where implemented :
-The 1st sting was made using virtual 1D mass, spring and damper in a linear arrangement, just like a spacial discretisation of a real string. This result of incorrect tuning of high harmonics of the virtual string (regarding a real string)
-The 2nd string was made using something also named "modal synthesis" (but very different from modalys) : it was "just" mass/spring/damper 1D resonator connected together, a bit like the paper initially send in this thread.
Since modalys use matrices, I guess that it use more complex interaction between elements than a simple spring/damper interaction like I use to do. This result in being able to also simulate the shape of the vibrating structure.
Anyway, about 15 years ago I start the pmpd library (physical modelling for pure data) that provide simple mass / spring / damper simulation. The pmpd~ object allow this kind of simulation at audio rate. There is an example of the 1st kind of string simulation. The 2nd string can also be implemented thanks to this object, but I did not provide any example since I miss the way to tune the model.
pmpd~ provide only simple interaction, so I don't use it any-more. I use the pmpd object that is lot's more complex (but works only at data rate) and a simple hack to compute audio data. There is also an example in the library distribution.
if you are interested, you can try pmpd using apt-get or deken on linux. I know that Nicolas Montgermont compile pmpd for osX, so a recent binary exist somewhere. I have no idea about recent build for windows.
cheers C
Le 06/08/2017 à 21:58, Jean-Marie Adrien a écrit :
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89. The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive. On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref. I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. jm
Le 6 août 2017 à 16:50, Jesse Mejia jmejia@anestheticaudio.com a écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Le 7 août 2017 à 13:56, cyrille henry ch@chnry.net a écrit :
hello,
I had a look at a modalys-help.pd file. It appear that modalys is not implemented as a pd abstraction, but as a compiled object. I may be wrong, but I think this object use modalys file that define all material / shape / exitator / etc. So it's quite useless without the full modalys software.
anyway, in order to add my piece of answer to the original question: about 20 years ago I made my master degree about a bow / string interaction using a fake motorized bow and a virtual string. 2 different strings where implemented :
-The 1st sting was made using virtual 1D mass, spring and damper in a linear arrangement, just like a spacial discretisation of a real string. This result of incorrect tuning of high harmonics of the virtual string (regarding a real string)
-The 2nd string was made using something also named "modal synthesis" (but very different from modalys) : it was "just" mass/spring/damper 1D resonator connected together, a bit like the paper initially send in this thread.
Since modalys use matrices, I guess that it use more complex interaction between elements than a simple spring/damper interaction like I use to do. This result in being able to also simulate the shape of the vibrating structure.
There is a gap between mass spring modeling and modal synthesis with results from the mathematical formalization of the vibration phenomenon : to be short, modal synthesis shifts towards an « abstract » representation of vibrating structures which is general and applies to any vibrating object, mechanical or gas. This formalization considers that a vibrating structure is a set of vibrating modes which are associated to a vibration frequency and a mode deformation shape. Any vibrating deformation is thus computed as the infinite sum of elementary (modal) deformations. This applies obviously to mass/ spring, to strings and … to anything more complex. This formalization is well known in maths (since 200 years or so), and used in the industry since 60 years or so (for vibrations in trains, boats or bridges, means large vibrating structures too complex to model with finite elements), but was at first used for sound synthesis at IRCAM at the end of the eighties as far as i know.
The advantage of seeing things this way is that
Lastly, because the formalization is general, you are not « structure and device design dependent » like you’re are for instance with finite elements of with klarplus strong, and , as a result, you can work and program in a general abstract way, and use interpolation and dynamic evolution (mapping) of vibrating structures on the fly. Mathematically, this boils down in a matrix equation to be solved at sample rate, (means matrix inversion) the dimension of the matrix depending on the number of interactions between vibrating structures. If the structure is stable, you invert the matrix once and that’s it. If things change (vibrato), you invert the matrix each time step. On the top of the software, you have vibrating structures (tubes / rods / plates / strings / membranes etc…), software to produce modal data from physical parameters (size, density etc) and a menu of excitation types (hit, blow, air jet, reed, double reed, glue, etc..) which connect the vibrating structures together (exciters such as hammers, bows and fingers being also vibrating structures). You pick up the multi channel sound where you want on the vibrating structures. Making sound is then assembling structures, and driving exciters with gestures, just like you manipulate your bow and left hand fingers on a violin.
I will try to find my PHD dissertation (it was saved on micro film !) which explains all this with multiple details, and from which the Missing Link publication is a short summary. Because the PHD stuff is kind of official, there is a good chance i can find the text somewhere. Of course i do not have any sample of this text at home (i have to search) and even less a pdf, the dissertation was typed on a VAX mainframe connected to a Versatec with an archeological text editor whose name i do not even remember (no-one remembers though … maybe Miller… what was the name of the text editor ? :) JM
Anyway, about 15 years ago I start the pmpd library (physical modelling for pure data) that provide simple mass / spring / damper simulation. The pmpd~ object allow this kind of simulation at audio rate. There is an example of the 1st kind of string simulation. The 2nd string can also be implemented thanks to this object, but I did not provide any example since I miss the way to tune the model.
pmpd~ provide only simple interaction, so I don't use it any-more. I use the pmpd object that is lot's more complex (but works only at data rate) and a simple hack to compute audio data. There is also an example in the library distribution.
if you are interested, you can try pmpd using apt-get or deken on linux. I know that Nicolas Montgermont compile pmpd for osX, so a recent binary exist somewhere. I have no idea about recent build for windows.
cheers C
Le 06/08/2017 à 21:58, Jean-Marie Adrien a écrit :
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89. The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive. On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref. I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. jm
Le 6 août 2017 à 16:50, Jesse Mejia jmejia@anestheticaudio.com a écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
This is a fascinating and important story.
Does appear that it would be a big multifaceted project though.
Would make a brilliant PhD/Post-Doc for someone and could be very a useful addition to the body of computer music knowledge.
For me, noting the very fine work by Cyrille and others, we're still only scratching the surface of possibilities offered by approaches such as PMPD. In many ways Modalysis is the daddy of them all, and still seems to afford approaches later software cannot accomplish.
I do hope this doesn't go the way of too many Pd projects that fall by the wayside due to overwhelming complexity, lack of contributors and requirements of dedication. This is, again for me, an area that we as a community currently struggle with - getting organised - which is in many ways, if you really think about it, a surprise.
BTW - Isn't it wonderful knowing people like Jean-Marie are just lurking around on here:) - Pd is a powerful force.
Julian
On 8 August 2017 at 08:32, Jean-Marie Adrien jm.adrien.mnt@gmail.com wrote:
Le 7 août 2017 à 13:56, cyrille henry ch@chnry.net a écrit :
hello,
I had a look at a modalys-help.pd file. It appear that modalys is not
implemented as a pd abstraction, but as a compiled object. I may be wrong, but I think this object use modalys file that define all material / shape / exitator / etc. So it's quite useless without the full modalys software.
anyway, in order to add my piece of answer to the original question: about 20 years ago I made my master degree about a bow / string
interaction using a fake motorized bow and a virtual string.
2 different strings where implemented :
-The 1st sting was made using virtual 1D mass, spring and damper in a
linear arrangement, just like a spacial discretisation of a real string. This result of incorrect tuning of high harmonics of the virtual string (regarding a real string)
-The 2nd string was made using something also named "modal synthesis"
(but very different from modalys) : it was "just" mass/spring/damper 1D resonator connected together, a bit like the paper initially send in this thread.
Since modalys use matrices, I guess that it use more complex interaction
between elements than a simple spring/damper interaction like I use to do. This result in being able to also simulate the shape of the vibrating structure.
There is a gap between mass spring modeling and modal synthesis with results from the mathematical formalization of the vibration phenomenon : to be short, modal synthesis shifts towards an « abstract » representation of vibrating structures which is general and applies to any vibrating object, mechanical or gas. This formalization considers that a vibrating structure is a set of vibrating modes which are associated to a vibration frequency and a mode deformation shape. Any vibrating deformation is thus computed as the infinite sum of elementary (modal) deformations. This applies obviously to mass/ spring, to strings and … to anything more complex. This formalization is well known in maths (since 200 years or so), and used in the industry since 60 years or so (for vibrations in trains, boats or bridges, means large vibrating structures too complex to model with finite elements), but was at first used for sound synthesis at IRCAM at the end of the eighties as far as i know.
The advantage of seeing things this way is that
- on one hand you process in time domain, which allows the computation of
natural transients in complex musical situations (things impossible or very difficult with other sound synthesis methods). Means you compute the displacement in time domain of significant points (eg contact points and sound pickup points). To achieve this, you simply program gestures on exciters structures, and you obtain the corresponding complex sound.
- on the other hand you keep an eye on the frequency domain which is very
important in the musical perspective, because freqs are part of the formalization.
Lastly, because the formalization is general, you are not « structure and device design dependent » like you’re are for instance with finite elements of with klarplus strong, and , as a result, you can work and program in a general abstract way, and use interpolation and dynamic evolution (mapping) of vibrating structures on the fly. Mathematically, this boils down in a matrix equation to be solved at sample rate, (means matrix inversion) the dimension of the matrix depending on the number of interactions between vibrating structures. If the structure is stable, you invert the matrix once and that’s it. If things change (vibrato), you invert the matrix each time step. On the top of the software, you have vibrating structures (tubes / rods / plates / strings / membranes etc…), software to produce modal data from physical parameters (size, density etc) and a menu of excitation types (hit, blow, air jet, reed, double reed, glue, etc..) which connect the vibrating structures together (exciters such as hammers, bows and fingers being also vibrating structures). You pick up the multi channel sound where you want on the vibrating structures. Making sound is then assembling structures, and driving exciters with gestures, just like you manipulate your bow and left hand fingers on a violin.
I will try to find my PHD dissertation (it was saved on micro film !) which explains all this with multiple details, and from which the Missing Link publication is a short summary. Because the PHD stuff is kind of official, there is a good chance i can find the text somewhere. Of course i do not have any sample of this text at home (i have to search) and even less a pdf, the dissertation was typed on a VAX mainframe connected to a Versatec with an archeological text editor whose name i do not even remember (no-one remembers though … maybe Miller… what was the name of the text editor ? :) JM
Anyway, about 15 years ago I start the pmpd library (physical modelling
for pure data) that provide simple mass / spring / damper simulation. The pmpd~ object allow this kind of simulation at audio rate. There is an example of the 1st kind of string simulation. The 2nd string can also be implemented thanks to this object, but I did not provide any example since I miss the way to tune the model.
pmpd~ provide only simple interaction, so I don't use it any-more. I use
the pmpd object that is lot's more complex (but works only at data rate) and a simple hack to compute audio data. There is also an example in the library distribution.
if you are interested, you can try pmpd using apt-get or deken on linux.
I know that Nicolas Montgermont compile pmpd for osX, so a recent binary exist somewhere. I have no idea about recent build for windows.
cheers C
Le 06/08/2017 à 21:58, Jean-Marie Adrien a écrit :
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is
incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc.
I was disappointed when, after having developed the method at IRCAM, i
discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89.
The math is not so complex, it is just a matrix equation incremented
step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events.
If you simplify the maths, it will probably become more complex i’d
say, and you will probably hear it, because time domain sound synthesis is quite sensitive.
On the same line, one advantage of modal synthesis is that you can
achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations.
Math simplification is what happened probably when the available pd
modalys software was achieved : i was disappointed by this tool and rarely use it.
Another application has been developed by Apple in Logic with the
"sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref.
I’d love the true vintage thing on pd now : it is just implementing a
matrix equation with updates conditions.
The point is that, thirty years later, i do not understand anymore a
single line in C++, although I’ve written many thousands of lines.
Hmm. I dont believe it myself, how is this even possible ? But i
remember very well the principles. Id be happy to help if i can anyway.
jm
Le 6 août 2017 à 16:50, Jesse Mejia jmejia@anestheticaudio.com a
écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post.
Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but
working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all
there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and
failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that
probably illustrates the "élégance à la française"
jm
I did not encourage piracy, but since pd patch can't be protected I
guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/
listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/
listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/ listinfo/pd-list
mutable instruments elements etc. was ported to axoloti (community.axoloti.com http://community.axoloti.com/) as well, so maybe look at that code also…
On 8 Aug 2017, at 11:41, Julian Brooks jbeezez@gmail.com wrote:
This is a fascinating and important story.
Does appear that it would be a big multifaceted project though.
Would make a brilliant PhD/Post-Doc for someone and could be very a useful addition to the body of computer music knowledge.
For me, noting the very fine work by Cyrille and others, we're still only scratching the surface of possibilities offered by approaches such as PMPD. In many ways Modalysis is the daddy of them all, and still seems to afford approaches later software cannot accomplish.
I do hope this doesn't go the way of too many Pd projects that fall by the wayside due to overwhelming complexity, lack of contributors and requirements of dedication. This is, again for me, an area that we as a community currently struggle with - getting organised - which is in many ways, if you really think about it, a surprise.
BTW - Isn't it wonderful knowing people like Jean-Marie are just lurking around on here:) - Pd is a powerful force.
Julian
On 8 August 2017 at 08:32, Jean-Marie Adrien <jm.adrien.mnt@gmail.com mailto:jm.adrien.mnt@gmail.com> wrote:
Le 7 août 2017 à 13:56, cyrille henry <ch@chnry.net mailto:ch@chnry.net> a écrit :
hello,
I had a look at a modalys-help.pd file. It appear that modalys is not implemented as a pd abstraction, but as a compiled object. I may be wrong, but I think this object use modalys file that define all material / shape / exitator / etc. So it's quite useless without the full modalys software.
anyway, in order to add my piece of answer to the original question: about 20 years ago I made my master degree about a bow / string interaction using a fake motorized bow and a virtual string. 2 different strings where implemented :
-The 1st sting was made using virtual 1D mass, spring and damper in a linear arrangement, just like a spacial discretisation of a real string. This result of incorrect tuning of high harmonics of the virtual string (regarding a real string)
-The 2nd string was made using something also named "modal synthesis" (but very different from modalys) : it was "just" mass/spring/damper 1D resonator connected together, a bit like the paper initially send in this thread.
Since modalys use matrices, I guess that it use more complex interaction between elements than a simple spring/damper interaction like I use to do. This result in being able to also simulate the shape of the vibrating structure.
There is a gap between mass spring modeling and modal synthesis with results from the mathematical formalization of the vibration phenomenon : to be short, modal synthesis shifts towards an « abstract » representation of vibrating structures which is general and applies to any vibrating object, mechanical or gas. This formalization considers that a vibrating structure is a set of vibrating modes which are associated to a vibration frequency and a mode deformation shape. Any vibrating deformation is thus computed as the infinite sum of elementary (modal) deformations. This applies obviously to mass/ spring, to strings and … to anything more complex. This formalization is well known in maths (since 200 years or so), and used in the industry since 60 years or so (for vibrations in trains, boats or bridges, means large vibrating structures too complex to model with finite elements), but was at first used for sound synthesis at IRCAM at the end of the eighties as far as i know.
The advantage of seeing things this way is that
- on one hand you process in time domain, which allows the computation of natural transients in complex musical situations (things impossible or very difficult with other sound synthesis methods). Means you compute the displacement in time domain of significant points (eg contact points and sound pickup points). To achieve this, you simply program gestures on exciters structures, and you obtain the corresponding complex sound.
- on the other hand you keep an eye on the frequency domain which is very important in the musical perspective, because freqs are part of the formalization.
Lastly, because the formalization is general, you are not « structure and device design dependent » like you’re are for instance with finite elements of with klarplus strong, and , as a result, you can work and program in a general abstract way, and use interpolation and dynamic evolution (mapping) of vibrating structures on the fly. Mathematically, this boils down in a matrix equation to be solved at sample rate, (means matrix inversion) the dimension of the matrix depending on the number of interactions between vibrating structures. If the structure is stable, you invert the matrix once and that’s it. If things change (vibrato), you invert the matrix each time step. On the top of the software, you have vibrating structures (tubes / rods / plates / strings / membranes etc…), software to produce modal data from physical parameters (size, density etc) and a menu of excitation types (hit, blow, air jet, reed, double reed, glue, etc..) which connect the vibrating structures together (exciters such as hammers, bows and fingers being also vibrating structures). You pick up the multi channel sound where you want on the vibrating structures. Making sound is then assembling structures, and driving exciters with gestures, just like you manipulate your bow and left hand fingers on a violin.
I will try to find my PHD dissertation (it was saved on micro film !) which explains all this with multiple details, and from which the Missing Link publication is a short summary. Because the PHD stuff is kind of official, there is a good chance i can find the text somewhere. Of course i do not have any sample of this text at home (i have to search) and even less a pdf, the dissertation was typed on a VAX mainframe connected to a Versatec with an archeological text editor whose name i do not even remember (no-one remembers though … maybe Miller… what was the name of the text editor ? :) JM
Anyway, about 15 years ago I start the pmpd library (physical modelling for pure data) that provide simple mass / spring / damper simulation. The pmpd~ object allow this kind of simulation at audio rate. There is an example of the 1st kind of string simulation. The 2nd string can also be implemented thanks to this object, but I did not provide any example since I miss the way to tune the model.
pmpd~ provide only simple interaction, so I don't use it any-more. I use the pmpd object that is lot's more complex (but works only at data rate) and a simple hack to compute audio data. There is also an example in the library distribution.
if you are interested, you can try pmpd using apt-get or deken on linux. I know that Nicolas Montgermont compile pmpd for osX, so a recent binary exist somewhere. I have no idea about recent build for windows.
cheers C
Le 06/08/2017 à 21:58, Jean-Marie Adrien a écrit :
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89. The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive. On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref. I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. jm
Le 6 août 2017 à 16:50, Jesse Mejia <jmejia@anestheticaudio.com mailto:jmejia@anestheticaudio.com> a écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry <ch@chnry.net mailto:ch@chnry.net> wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailto:Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailto:Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailto:Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
I think this instrument use 1D resonator and can be emulated with pmpd~ cheers c
Le 08/08/2017 à 13:15, Simon Iten a écrit :
mutable instruments elements etc. was ported to axoloti (community.axoloti.com http://community.axoloti.com) as well, so maybe look at that code also…
On 8 Aug 2017, at 11:41, Julian Brooks <jbeezez@gmail.com mailto:jbeezez@gmail.com> wrote:
This is a fascinating and important story.
Does appear that it would be a big multifaceted project though.
Would make a brilliant PhD/Post-Doc for someone and could be very a useful addition to the body of computer music knowledge.
For me, noting the very fine work by Cyrille and others, we're still only scratching the surface of possibilities offered by approaches such as PMPD. In many ways Modalysis is the daddy of them all, and still seems to afford approaches later software cannot accomplish.
I do hope this doesn't go the way of too many Pd projects that fall by the wayside due to overwhelming complexity, lack of contributors and requirements of dedication. This is, again for me, an area that we as a community currently struggle with - getting organised - which is in many ways, if you really think about it, a surprise.
BTW - Isn't it wonderful knowing people like Jean-Marie are just lurking around on here:) - Pd is a powerful force.
Julian
On 8 August 2017 at 08:32, Jean-Marie Adrien <jm.adrien.mnt@gmail.com mailto:jm.adrien.mnt@gmail.com> wrote:
> Le 7 août 2017 à 13:56, cyrille henry <ch@chnry.net <mailto:ch@chnry.net>> a écrit : > > hello, > > I had a look at a modalys-help.pd file. It appear that modalys is not implemented as a pd abstraction, but as a compiled object. I may be wrong, but I think this object use modalys file that define all material / shape / exitator / etc. So it's quite useless without the full modalys software. > > anyway, in order to add my piece of answer to the original question: > about 20 years ago I made my master degree about a bow / string interaction using a fake motorized bow and a virtual string. > 2 different strings where implemented : > > -The 1st sting was made using virtual 1D mass, spring and damper in a linear arrangement, just like a spacial discretisation of a real string. This result of incorrect tuning of high harmonics of the virtual string (regarding a real string) > > -The 2nd string was made using something also named "modal synthesis" (but very different from modalys) : it was "just" mass/spring/damper 1D resonator connected together, a bit like the paper initially send in this thread. > > Since modalys use matrices, I guess that it use more complex interaction between elements than a simple spring/damper interaction like I use to do. This result in being able to also simulate the shape of the vibrating structure. There is a gap between mass spring modeling and modal synthesis with results from the mathematical formalization of the vibration phenomenon : to be short, modal synthesis shifts towards an « abstract » representation of vibrating structures which is general and applies to any vibrating object, mechanical or gas. This formalization considers that a vibrating structure is a set of vibrating modes which are associated to a vibration frequency and a mode deformation shape. Any vibrating deformation is thus computed as the infinite sum of elementary (modal) deformations. This applies obviously to mass/ spring, to strings and … to anything more complex. This formalization is well known in maths (since 200 years or so), and used in the industry since 60 years or so (for vibrations in trains, boats or bridges, means large vibrating structures too complex to model with finite elements), but was at first used for sound synthesis at IRCAM at the end of the eighties as far as i know. The advantage of seeing things this way is that - on one hand you process in time domain, which allows the computation of natural transients in complex musical situations (things impossible or very difficult with other sound synthesis methods). Means you compute the displacement in time domain of significant points (eg contact points and sound pickup points). To achieve this, you simply program gestures on exciters structures, and you obtain the corresponding complex sound. - on the other hand you keep an eye on the frequency domain which is very important in the musical perspective, because freqs are part of the formalization. Lastly, because the formalization is general, you are not « structure and device design dependent » like you’re are for instance with finite elements of with klarplus strong, and , as a result, you can work and program in a general abstract way, and use interpolation and dynamic evolution (mapping) of vibrating structures on the fly. Mathematically, this boils down in a matrix equation to be solved at sample rate, (means matrix inversion) the dimension of the matrix depending on the number of interactions between vibrating structures. If the structure is stable, you invert the matrix once and that’s it. If things change (vibrato), you invert the matrix each time step. On the top of the software, you have vibrating structures (tubes / rods / plates / strings / membranes etc…), software to produce modal data from physical parameters (size, density etc) and a menu of excitation types (hit, blow, air jet, reed, double reed, glue, etc..) which connect the vibrating structures together (exciters such as hammers, bows and fingers being also vibrating structures). You pick up the multi channel sound where you want on the vibrating structures. Making sound is then assembling structures, and driving exciters with gestures, just like you manipulate your bow and left hand fingers on a violin. I will try to find my PHD dissertation (it was saved on micro film !) which explains all this with multiple details, and from which the Missing Link publication is a short summary. Because the PHD stuff is kind of official, there is a good chance i can find the text somewhere. Of course i do not have any sample of this text at home (i have to search) and even less a pdf, the dissertation was typed on a VAX mainframe connected to a Versatec with an archeological text editor whose name i do not even remember (no-one remembers though … maybe Miller… what was the name of the text editor ? :) JM > > Anyway, about 15 years ago I start the pmpd library (physical modelling for pure data) that provide simple mass / spring / damper simulation. The pmpd~ object allow this kind of simulation at audio rate. There is an example of the 1st kind of string simulation. The 2nd string can also be implemented thanks to this object, but I did not provide any example since I miss the way to tune the model. > > pmpd~ provide only simple interaction, so I don't use it any-more. I use the pmpd object that is lot's more complex (but works only at data rate) and a simple hack to compute audio data. There is also an example in the library distribution. > > if you are interested, you can try pmpd using apt-get or deken on linux. I know that Nicolas Montgermont compile pmpd for osX, so a recent binary exist somewhere. I have no idea about recent build for windows. > > cheers > C > > > > Le 06/08/2017 à 21:58, Jean-Marie Adrien a écrit : >> would be great if it would be in pd abstractions ! >> everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. >> I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89. >> The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. >> If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive. >> On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. >> Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. >> Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref. >> I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. >> The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. >> Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. >> jm >>> Le 6 août 2017 à 16:50, Jesse Mejia <jmejia@anestheticaudio.com <mailto:jmejia@anestheticaudio.com>> a écrit : >>> >>> Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great. >>> >>> So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls. >>> >>> The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way. >>> >>> Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd. >>> >>>> On Aug 6, 2017, at 3:24 AM, cyrille henry <ch@chnry.net <mailto:ch@chnry.net>> wrote: >>>> >>>> >>>> >>>>> :) >>>>> indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" >>>>> jm >>>> >>>> I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble. >>>> >>>> cheers >>>> c >>>> >>>> _______________________________________________ >>>> Pd-list@lists.iem.at <mailto:Pd-list@lists.iem.at> mailing list >>>> UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list <https://lists.puredata.info/listinfo/pd-list> >>> >>> >>> _______________________________________________ >>> Pd-list@lists.iem.at <mailto:Pd-list@lists.iem.at> mailing list >>> UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list <https://lists.puredata.info/listinfo/pd-list> _______________________________________________ Pd-list@lists.iem.at <mailto:Pd-list@lists.iem.at> mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list <https://lists.puredata.info/listinfo/pd-list>
Pd-list@lists.iem.at mailto:Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Le 08/08/2017 à 09:32, Jean-Marie Adrien a écrit :
Le 7 août 2017 à 13:56, cyrille henry ch@chnry.net a écrit :
hello,
I had a look at a modalys-help.pd file. It appear that modalys is not implemented as a pd abstraction, but as a compiled object. I may be wrong, but I think this object use modalys file that define all material / shape / exitator / etc. So it's quite useless without the full modalys software.
anyway, in order to add my piece of answer to the original question: about 20 years ago I made my master degree about a bow / string interaction using a fake motorized bow and a virtual string. 2 different strings where implemented :
-The 1st sting was made using virtual 1D mass, spring and damper in a linear arrangement, just like a spacial discretisation of a real string. This result of incorrect tuning of high harmonics of the virtual string (regarding a real string)
-The 2nd string was made using something also named "modal synthesis" (but very different from modalys) : it was "just" mass/spring/damper 1D resonator connected together, a bit like the paper initially send in this thread.
Since modalys use matrices, I guess that it use more complex interaction between elements than a simple spring/damper interaction like I use to do. This result in being able to also simulate the shape of the vibrating structure.
There is a gap between mass spring modeling and modal synthesis with results from the mathematical formalization of the vibration phenomenon : to be short, modal synthesis shifts towards an « abstract » representation of vibrating structures which is general and applies to any vibrating object, mechanical or gas. This formalization considers that a vibrating structure is a set of vibrating modes which are associated to a vibration frequency and a mode deformation shape.
You can also do something like that with mass/spring system, event if it was not the primary goal of this simulation! a single mass/spring can create a resonating mode. Multiple mass/spring mode can be coupled in parallel to create complex system. This can gives good result for 1D system (a string) where there is no energy transfer from 1 mode to an other.
Any vibrating deformation is thus computed as the infinite sum of elementary (modal) deformations. This applies obviously to mass/ spring, to strings and … to anything more complex. This formalization is well known in maths (since 200 years or so), and used in the industry since 60 years or so (for vibrations in trains, boats or bridges, means large vibrating structures too complex to model with finite elements), but was at first used for sound synthesis at IRCAM at the end of the eighties as far as i know.
The advantage of seeing things this way is that
- on one hand you process in time domain, which allows the computation of natural transients in complex musical situations (things impossible or very difficult with other sound synthesis methods). Means you compute the displacement in time domain of significant points (eg contact points and sound pickup points). To achieve this, you simply program gestures on exciters structures, and you obtain the corresponding complex sound.
- on the other hand you keep an eye on the frequency domain which is very important in the musical perspective, because freqs are part of the formalization.
Lastly, because the formalization is general, you are not « structure and device design dependent » like you’re are for instance with finite elements of with klarplus strong, and , as a result, you can work and program in a general abstract way, and use interpolation and dynamic evolution (mapping) of vibrating structures on the fly. Mathematically, this boils down in a matrix equation to be solved at sample rate, (means matrix inversion) the dimension of the matrix depending on the number of interactions between vibrating structures. If the structure is stable, you invert the matrix once and that’s it. If things change (vibrato), you invert the matrix each time step. On the top of the software, you have vibrating structures (tubes / rods / plates / strings / membranes etc…), software to produce modal data from physical parameters (size, density etc) and a menu of excitation types (hit, blow, air jet, reed, double reed, glue, etc..) which connect the vibrating structures together (exciters such as hammers, bows and fingers being also vibrating structures). You pick up the multi channel sound where you want on the vibrating structures. Making sound is then assembling structures, and driving exciters with gestures, just like you manipulate your bow and left hand fingers on a violin.
I will try to find my PHD dissertation (it was saved on micro film !) which explains all this with multiple details, and from which the Missing Link publication is a short summary.
thanks, i'll be glad to read it.
cheers c
Because the PHD stuff is kind of official, there is a good chance i can find the text somewhere. Of course i do not have any sample of this text at home (i have to search) and even less a pdf, the dissertation was typed on a VAX mainframe connected to a Versatec with an archeological text editor whose name i do not even remember (no-one remembers though … maybe Miller… what was the name of the text editor ? :)
JM
Anyway, about 15 years ago I start the pmpd library (physical modelling for pure data) that provide simple mass / spring / damper simulation. The pmpd~ object allow this kind of simulation at audio rate. There is an example of the 1st kind of string simulation. The 2nd string can also be implemented thanks to this object, but I did not provide any example since I miss the way to tune the model.
pmpd~ provide only simple interaction, so I don't use it any-more. I use the pmpd object that is lot's more complex (but works only at data rate) and a simple hack to compute audio data. There is also an example in the library distribution.
if you are interested, you can try pmpd using apt-get or deken on linux. I know that Nicolas Montgermont compile pmpd for osX, so a recent binary exist somewhere. I have no idea about recent build for windows.
cheers C
Le 06/08/2017 à 21:58, Jean-Marie Adrien a écrit :
would be great if it would be in pd abstractions ! everything is in the paper though, you are right, and the method is incredibly powerful, so the project was in that time to control it with gestures data bases and artificial intelligence and so on, all of this being existing now, not speaking about multi channel sound diffusion etc. I was disappointed when, after having developed the method at IRCAM, i discovered (and had to pay for it though) some ten years ago the actual modalys thing that was kind of retro engineered after i left IRCAM, from the big C++ initial software with was developed between 1984 and 89. The math is not so complex, it is just a matrix equation incremented step by step, and very straightforward and intuitive discontinuities in time domain which correspond to straightforward updates of the matrix, resulting for instance from contact between objects and other intuitive events. If you simplify the maths, it will probably become more complex i’d say, and you will probably hear it, because time domain sound synthesis is quite sensitive. On the same line, one advantage of modal synthesis is that you can achieve impossible physical excitations on imaginary structures, and interpolate between all this, having transient sounds and articulations, but even with the full math though, you could hear in that case that you were sort of tearing the equations, which corresponds to the fact that there is no existing physical gesture which you could refer to when exploring impossible configurations. Math simplification is what happened probably when the available pd modalys software was achieved : i was disappointed by this tool and rarely use it. Another application has been developed by Apple in Logic with the "sculpture » plugin : it is very much main stream, they probably make money with it and Im still poor. Bref. I’d love the true vintage thing on pd now : it is just implementing a matrix equation with updates conditions. The point is that, thirty years later, i do not understand anymore a single line in C++, although I’ve written many thousands of lines. Hmm. I dont believe it myself, how is this even possible ? But i remember very well the principles. Id be happy to help if i can anyway. jm
Le 6 août 2017 à 16:50, Jesse Mejia jmejia@anestheticaudio.com a écrit :
Yes - I mentioned Ircam's Modalys and that paper in my initial post. Because modal synthesis is so well known, and well documented, I'm surprised there isn't a similar (but free!) pd implementation. Something with abstractions instead of externals would be great.
So let's make one. I know it's a bank of resonant bandpasses, but working out their relationships based on the modal characteristics of physical shapes seems to be key, and abstracting those relationships to friendly controls.
The math in the papers is a bit beyond me but it looks like it's all there. I can't tell by looking at it if it's something that would be too hard/annoying to do with vanilla.. or if it's describable in a less math heavy way.
Alex - newly compiled versions of the stk would be great! I tried and failed at that about a year ago. But the faust implementations compile well from faust to pd.
On Aug 6, 2017, at 3:24 AM, cyrille henry ch@chnry.net wrote:
:) indeed and i had myself to _pay_ for it, which is something that probably illustrates the "élégance à la française" jm
I did not encourage piracy, but since pd patch can't be protected I guess that an anonymous source could leak the files without any trouble.
cheers c
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list