FastFourierTransform | Compute the Fast Fourier Transform of sampled data | Video Utils library

Ok at the end i found a good nuget to realize that:

https://github.com/swharden/Spectrogram

https://www.nuget.org/packages/Spectrogram/

Looks like a bug in OpenModelica. Please open a ticket about it on trac.openmodelica.org.

Problem 1 Huge result files are breaking
When simulating with OpenModelica (v1.14.0-dev-26633-gd9901afc5b) for 0.05 sec simulation time the result mat-file is already 1.06 GB. For 0.1 sec you get around 2.1 GB and a corrupt header.

Problem 2 Wrong results
When you simulate interval [0, 0.2] the solution is completely wrong. Values of y are somewhere around 1.4e+31 and time goes up to 5e+218. Could be because of the broken result file.
But even if you reduce tolerance and interval it won't simulate correctly, maybe because of the huge amount of events.

Works in Dymola 2019, but needs a lot of time to open the result files.

Some things I observed (using Dymola) that could cause some troubles:

1. The block FFTmultiphase has a Multiphase Interface, which is usually not done in Modelica. Blocks only have causal in-/outputs. I've changed the class from a block to a model. You could as well use a Real input to the model using a sensor to measure the voltage.
2. Your initial set of equations seem to be over-determined due to the fixed=true in Real y[3](start = fill(0, 3), each fixed = true, each unit = "V");. I would try to remove each fixed = true.

The second seems likelier to cause the problems you describe.

The result seems reasonable then giving A_i = {0,0,4.87,0,0,0} (although I guess it should be 5 for the 3rd entry).

It seems that I made 4 mistakes:

1) Here I'm asumming that sampling freq is 44100. This was not the reason my code wasn't working, though

You can use the Catalano Framework, you can easily perform the fast fourier transform. Also works for MxN-sized images.

At first: Thank you very much. I had thought of something like that, but wasn't sure. Thank got there a nice people like you who care about beginners.

So I changed the snippet as following:

The Discrete Fourier transform and its inverse require a certain normalization so that ifft(fft(x))==x. How this normalization is done changes from implementation to implementation.

It seems that, in this case, NAudio has chosen a different normalization than MATLAB.

MATLAB uses the most common normalization, where fft(x) at k=0 is equal to sum(x), and the inverse transform does the same thing but divides by n (number of samples). This is also the equation as described in the Wikipedia page for the DFT. In this case, the inverse transform matches the equation for the Fourier series.

NAudio seems to do the division by n in the forward transform, such that at k=0 you have mean(x).

Given the above, you can use the first frequency bin (the DC component) to verify what normalization is used (assuming there is a DC component, if the signal has a zero mean this will not work): If the DC component is equal to the sum of all the sample values, then the "common" normalization is used. It can also be equal to the sum divided by sqrt(n), in the case of a symmetric definition, where the forward and inverse transform carry the same normalization. In the case of NAudio it will be equal to the sum divided by n (i.e. the mean of the sample values). In general, take the DC component and divide it by the sum of the sample values. The result q is the normalization term used. The inverse transform should have a normalization term 1/qn.

If your X is real and thus your Y is conjugate symmetric you can use the "symmetric" option to run fft or ifft more efficiently. You are not supposed to use "symmetric" option if this precondition doesn't apply. Probably your X is not real, is it?