fft oder dft für c++

rasidrasid

hallo,

ich habe ein programm für die schwingung von massen geschrieben. das programm schreibt eine txt-datei heraus mit zwei spalten (zeit, kraft). nun würde ich gerne zu dieser datei eine fft oder dft machen. habe im google gesucht, doch alles was ich gefunden habe war so allgemein und ich konnte es nicht auf mein problem anwenden bzw. umbauen. hat einer von euch eine ahnung wo ich ein code finden kann, dass genau diese datei einlesen und eine fast fourier transformation oder eine discrete fourier transformation vollführen kann?

danke

knivil

genau diese datei einlesen

... man muss immer selbst Hand anlegen. Du wirst auch nichts im INet finden, dass genau deinem Datenformat entspricht. Du muss deine Werte fuer entsprechenden Funktionen aufbereiten, so dass sie von dieser verstanden wird. Dazu muss man etwas programmieren koennen. Alternativ kannst du auch mit Matlab arbeiten, dort gibt es wahrscheinlich schon fertige Beispiele und Anleitungen.

rasidrasid

danke

rasidrasid

hallo,

ich habe ein kleines mks-programm geschrieben und es gibt die bewegung der masse aus. das format der ausgabedatei (*.txt, zeit ort) sieht so aus:
0 0
0.1 2
0.2 3
0.3 5
usw.

ich würde gerne diese datei einlesen und eine fft machen. hätte jemad ein code für mich das ich in mein programm implementieren kann? also diese ausgabedatei mit diesem format soll eingelesen und zur fft verarbeitet werden.

danke

Hier im Unterforum "Projekte" kannst du Auftragsarbeiten vergeben.
Verständlicherweise wird das wohl niemand konstelos machen.

Meinst du nicht dass du wenigstens mal zeigen solltest was du bisher hast?

rasidrasid

#include <iostream>
#include <string>
#include <cmath>
#include <fstream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <sstream>
#include <istream>
#include <cstdlib>
#include <windows.h>
#include <cstring>
#include "fft.h"
#include <math.h>
//#include <complex.h>

using namespace std;

int main (int argc, char *argv[]) {
long double deltazeit, pi=3.141593, amp;
long double m, c, d, lambda, ksi, psi, t, xdot;
char Simulationszeit[40], Schwingmasse[40], Federsteifigkeit[40];
char Daempfung[40], Anfangsamplitude[40], Anfangsgeschwindigkeit[40];
int N=8192;
long double x[N+1];
cout << endl;
cout << endl;
// cout << " Bis zur welchen Zeit [s] soll simuliert werden? " << endl;
// cin >> t;
// cout << " Welche Masse [kg] hat das System? " << endl;
// cin >> m;
// cout << " Welche Steifigkeit [N/m] hat die Feder? " << endl;
// cin >> c;
// cout << " Welche Daempfung [Ns/m] hat der Daempfer? " << endl;
// cin >> d;
// cout << " Welche Anfangsauslenkung (Amplitude) [m] hat das System? " << endl;
// cin >> amp;
// cout << " Welche Anfangsgeschwindigkeit [m/s] hat das System? " << endl;
// cin >> xdot;

ifstream datei("AA_eingangsdaten.txt");
datei >> Simulationszeit >> t;
datei >> Schwingmasse >> m;
datei >> Federsteifigkeit >> c;
datei >> Daempfung >> d;
datei >> Anfangsamplitude >> amp;
datei >> Anfangsgeschwindigkeit >> xdot;

cout << " Simulationszeit [s] = " << t << endl;
cout << " Schwingmasse [Kg] = " << m << endl;
cout << " Federsteifigkeit [N/m] = " << c << endl;
cout << " Daempfung [Ns/m] = " << d << endl;
cout << " Anfangsamplitude [m] = " << amp << endl;
cout << " Anfangsgeschwindigkeit [m/s] = " << xdot << endl;

cout << endl;
cout << " Die Eigenfrequenz und Schwingdauer betragen: " << endl;
cout << " [Hz] = " << sqrt(c/m)/2/pi << " [1/s] = " << 1/(sqrt(c/m)/2/pi) << endl;
cout << endl;

lambda=sqrt(c/m);
ksi=d/m;
psi=ksi/2;
// t=vielpi*pi;
deltazeit=t/N;

//Berechnung findet statt

// erstellen einer Ausgabedatei
ofstream xeindatei;
xeindatei.open("eimass_x.dat");
for(int i=1;i<N+2;i++){
xeindatei << (i-1)*deltazeit << " " << x[i] << endl;
}

xeindatei.close();

// erstellen einer Ausgabedatei
ofstream veindatei;
veindatei.open("eimass_v.dat");
for(int i=1;i<N+1;i++){
veindatei << (i-1)*deltazeit << " " << (x[i+1]-x[i-1])/2/deltazeit << endl;
}

veindatei.close();

// erstellen einer Ausgabedatei
ofstream aeindatei;
aeindatei.open("eimass_a.dat");
for(int i=1;i<N+1;i++){
aeindatei << (i-1)*deltazeit << " " << (x[i+1]-2*x[i]+x[i-1])/(deltazeit*deltazeit) << endl;
}

aeindatei.close();

// erstellen einer Ausgabedatei
ofstream phaseeindatei;
phaseeindatei.open("eimass_phase.dat");
for(int i=1;i<N+1;i++){
phaseeindatei << (x[i+1]-x[i-1])/2/deltazeit << " " << (x[i+1]-2*x[i]+x[i-1])/(deltazeit*deltazeit) << endl;
}

phaseeindatei.close();

// erstellen einer Ausgabedatei für cmd
ofstream cmdeindatei;
cmdeindatei.open("ausw_einmass.cmd");
cmdeindatei << "call gnuplot x.gp" << endl;
cmdeindatei << "call gnuplot v.gp" << endl;
cmdeindatei << "call gnuplot a.gp" << endl;
cmdeindatei << "call gnuplot all.gp" << endl;
cmdeindatei << "call gnuplot phase.gp" << endl;

cmdeindatei.close();

// erstellen einer Ausgabedatei für gnuplot
ofstream gnuxeindatei;
gnuxeindatei.open("x.gp");
gnuxeindatei << "set title 'Einmassenschwinger/Auslenkung'" << endl;
gnuxeindatei << "set grid" << endl;
gnuxeindatei << endl;
gnuxeindatei << "set tmargin 8.0" << endl;
gnuxeindatei << "set bmargin 4.0" << endl;
gnuxeindatei << "set lmargin 12.0" << endl;
gnuxeindatei << "set rmargin 6.0" << endl;
gnuxeindatei << endl;
// gnuxeindatei << "set xrange [0:" << t << "]" << endl;
// gnuxeindatei << "set yrange [" << -amp << ":" << amp << "]" << endl;
gnuxeindatei << endl;
gnuxeindatei << "set xlabel 'Zeit [s]'" << endl;
gnuxeindatei << "set ylabel 'Auslenkung [m]'" << endl;
gnuxeindatei << "plot 'eimass_x.dat' using 1:2 t '' with lines lt 10 lw 2" << endl;
gnuxeindatei << endl;
gnuxeindatei << "set terminal png giant size 750,500" << endl;
gnuxeindatei << "set output 'x.png'" << endl;
gnuxeindatei << "replot" << endl;

gnuxeindatei.close();

// erstellen einer Ausgabedatei für gnuplot
ofstream gnuveindatei;
gnuveindatei.open("v.gp");
gnuveindatei << "set title 'Einmassenschwinger/Geschwindigkeit'" << endl;
gnuveindatei << "set grid" << endl;
gnuveindatei << endl;
gnuveindatei << "set tmargin 8.0" << endl;
gnuveindatei << "set bmargin 4.0" << endl;
gnuveindatei << "set lmargin 12.0" << endl;
gnuveindatei << "set rmargin 6.0" << endl;
gnuveindatei << endl;
// gnuveindatei << "set xrange [0:" << t << "]" << endl;
// gnuveindatei << "set yrange [" << -amp << ":" << amp << "]" << endl;
gnuveindatei << endl;
gnuveindatei << "set xlabel 'Zeit [s]'" << endl;
gnuveindatei << "set ylabel 'Geschwindigkeit [m/s]'" << endl;
gnuveindatei << "plot 'eimass_v.dat' using 1:2 t '' with lines lt 20 lw 2" << endl;
gnuveindatei << endl;
gnuveindatei << "set terminal png giant size 750,500" << endl;
gnuveindatei << "set output 'v.png'" << endl;
gnuveindatei << "replot" << endl;

gnuveindatei.close();

// erstellen einer Ausgabedatei für gnuplot
ofstream gnuaeindatei;
gnuaeindatei.open("a.gp");
gnuaeindatei << "set title 'Einmassenschwinger/Beschleunigung'" << endl;
gnuaeindatei << "set grid" << endl;
gnuaeindatei << endl;
gnuaeindatei << "set tmargin 8.0" << endl;
gnuaeindatei << "set bmargin 4.0" << endl;
gnuaeindatei << "set lmargin 12.0" << endl;
gnuaeindatei << "set rmargin 6.0" << endl;
gnuaeindatei << endl;
// gnuaeindatei << "set xrange [0:" << t << "]" << endl;
// gnuaeindatei << "set yrange [" << -(x[2]-2*x[1]+x[0])/(deltazeit*deltazeit) << ":" << (x[2]-2*x[1]+x[0])/(deltazeit*deltazeit) << "]" << endl;
gnuaeindatei << endl;
gnuaeindatei << "set xlabel 'Zeit [s]'" << endl;
gnuaeindatei << "set ylabel 'Beschleunigung [m/(s*s)]'" << endl;
gnuaeindatei << "plot 'eimass_a.dat' using 1:2 t '' with lines lt 30 lw 2" << endl;
gnuaeindatei << endl;
gnuaeindatei << "set terminal png giant size 750,500" << endl;
gnuaeindatei << "set output 'a.png'" << endl;
gnuaeindatei << "replot" << endl;

gnuaeindatei.close();

// erstellen einer Ausgabedatei für gnuplot
ofstream gnualleindatei;
gnualleindatei.open("all.gp");
gnualleindatei << "set title 'Einmassenschwinger-Auslenkung/Geschwindigkeit/Beschleunigung'" << endl;
gnualleindatei << "set grid" << endl;
gnualleindatei << endl;
gnualleindatei << "set tmargin 8.0" << endl;
gnualleindatei << "set bmargin 4.0" << endl;
gnualleindatei << "set lmargin 12.0" << endl;
gnualleindatei << "set rmargin 6.0" << endl;
gnualleindatei << endl;
// gnualleindatei << "set xrange [0:" << t << "]" << endl;
// gnualleindatei << "set yrange [" << -(x[2]-2*x[1]+x[0])/(deltazeit*deltazeit) << ":" << (x[2]-2*x[1]+x[0])/(deltazeit*deltazeit) << "]" << endl;
gnualleindatei << endl;
gnualleindatei << "set xlabel 'Zeit [s]'" << endl;
gnualleindatei << "set ylabel 'x-[m] / v-[m/s] / a-[m/(s*s)]'" << endl;
gnualleindatei << "plot 'eimass_x.dat' using 1:2 t 'Auslenkung' with lines lt 10 lw 1" << endl;
gnualleindatei << "replot 'eimass_v.dat' using 1:2 t 'Geschwindigkeit' with lines lt 20 lw 1" << endl;
gnualleindatei << "replot 'eimass_a.dat' using 1:2 t 'Beschleunigung' with lines lt 40 lw 1" << endl;
gnualleindatei << endl;
gnualleindatei << "set terminal png giant size 750,500" << endl;
gnualleindatei << "set output 'all.png'" << endl;
gnualleindatei << "replot" << endl;

gnualleindatei.close();

// erstellen einer Ausgabedatei für gnuplot
ofstream gnuphaseeindatei;
gnuphaseeindatei.open("phase.gp");
gnuphaseeindatei << "set title 'Einmassenschwinger-Phase'" << endl;
gnuphaseeindatei << "set grid" << endl;
gnuphaseeindatei << endl;
gnuphaseeindatei << "set tmargin 8.0" << endl;
gnuphaseeindatei << "set bmargin 4.0" << endl;
gnuphaseeindatei << "set lmargin 12.0" << endl;
gnuphaseeindatei << "set rmargin 6.0" << endl;
gnuphaseeindatei << endl;
// gnuphaseeindatei << "set xrange [0:" << t << "]" << endl;
// gnuphaseeindatei << "set yrange [" << -(x[2]-2*x[1]+x[0])/(deltazeit*deltazeit) << ":" << (x[2]-2*x[1]+x[0])/(deltazeit*deltazeit) << "]" << endl;
gnuphaseeindatei << endl;
gnuphaseeindatei << "set xlabel 'v-[m/s]'" << endl;
gnuphaseeindatei << "set ylabel 'a-[m/(s*s)]'" << endl;
gnuphaseeindatei << "plot 'eimass_phase.dat' using 1:2 t '' with lines lt 10 lw 2" << endl;
gnuphaseeindatei << endl;
gnuphaseeindatei << "set terminal png giant size 750,500" << endl;
gnuphaseeindatei << "set output 'phase.png'" << endl;
gnuphaseeindatei << "replot" << endl;

gnuphaseeindatei.close();

// erstellen einer Ausgabedatei
ofstream ausdatei;
ausdatei.open("Werte.dat");
ausdatei << "**** Ausgabe der Werte für die Auslenkung, Geschwindigkeit und Beschleunigung " << endl;
ausdatei << "****************************************************************************" << endl;
ausdatei << endl;
ausdatei << " Simulationszeit [s] = " << t << endl;
ausdatei << " Schwingmasse [Kg] = " << m << endl;
ausdatei << " Federsteifigkeit [N/m] = " << c << endl;
ausdatei << " Daempfung [Ns/m] = " << d << endl;
ausdatei << " Anfangsamplitude [m] = " << amp << endl;
ausdatei << " Anfangsgeschwindigkeit [m/s] = " << xdot << endl;
ausdatei << endl;
ausdatei << "Frequenz [Hz] = " << sqrt(c/m)/2/pi << " Schwingdauer [1/s] = " << 1/(sqrt(c/m)/2/pi) << endl;
ausdatei << endl;
ausdatei << "Zeit [s]" << " " << "Auslenkung [m]" << " " << "Geschwindigkeit [m/s]" << " " << "Beschleunigung [m/s^2]" << endl;
ausdatei << endl;
ausdatei << (1-1)*deltazeit << '\t' << x[1] << " " << '\t' << (x[1+1]-x[1-1])/2/deltazeit << " " << '\t' << (x[1+1]-2*x[1]+x[1-1])/(deltazeitdeltazeit) << endl;
for(int i=2;i<N+1;i++){
ausdatei << (i-1)*deltazeit << '\t' << x[i] << '\t' << (x[i+1]-x[i-1])/2/deltazeit << '\t' << (x[i+1]-2*x[i]+x[i-1])/(deltazeitdeltazeit) << endl;
}
ausdatei.close();

// for(int i=1;i<N+2;i++){
// cout << (i-1)*deltazeit << '\t' << m*(x[i+1]-2*x[i]+x[i-1])/(deltazeit*deltazeit)+d*(x[i+1]-x[i-1])/2/deltazeit+c*x[i] << endl;
// }

system("ausw_einmass.cmd");
}