Iihhh, explizite Euler Verfahren… Wie gewöhnlich 
Tja 
Aber es ist auch velocity verlet
Was ist velocity verlet? Ist das irgendein Fach-Terminus, den ich nicht kenne?
Grade bei Systemen mit interner Erhaltungsgröße (wie Energie hier) gibt es spezielle Verfahren, die die Energie-Erhaltung garantieren.
Wenn ich morgen nichts mehr schreibe bin ich an den Muscheln gestorben!
1 „Gefällt mir“
Genau das ist das Das ist ein Verfahren aus der MD Simulation das Energieerhalt garantiert was bei bei großen Ensemblen von Molekülen die miteinanderstoßen ja der fall sein sollte, weil sonst der 1.HS verletzt wird. Ich sollte deshalb Euler mit VV vergleichen um zu schauen wie gerade die Energieerhaltung bei den Stößen aussieht und die beiden Verfahren da so abschneiden
Bist du zum Lahmus oder zum Laschoking geworden ?
3 „Gefällt mir“
Stimmt wohl 
Ist das eigentlich C, oder C#? Hab seit fast 15 Jahren nix mehr in C gemacht (und auch damals sehr wenig) und #define kommt mir so ungewöhnlich vor…kann man auch die Kugel mehr nach oben tun? Oder ist das nicht implementiert?
Das ist C #define ist halt ein precompiler befehl, der im code alle x0 mit -2.0 ersetzt sodass man eben einfach direkt am anfang des codes die parameter ändern kann ohne in allen einzelheiten manuell diese abzuändern. Und dadurch, dass x0 und y0 durch die Länge der Fäden verknüpft sind, hängt die Ausgangshöhe von der ersten Kugel auch von x0 ab, oder man ändert die Pendellänge. Es ist wie gesagt alles implementiert und alles änderbar, da es eben alles basic geschrieben ist. die einziegen pakete die benutzt werden ist das mathepaket damit man hoch und wurzeln machen kann ^^
Wissenschaftliches Rechnen im Anfängermodus ist natürlich ganz anders als jetzt anwendungsorientiertes rechnen. Die ganze Speicherkacke mit dem heap, Pointer etc habe ich mehr oder weniger vergessen, aber ich finds auch erschreckend wie oft noch C benutzt wird in der Software branche ^^
Hmm…also ist das quasi eine deklaration einer globalen Variablen?!
nur das es eben keine variable ist, die iwie nen speicherplatz hat, da wenn der compiler startet, da schonlange die reine zahl steht entsprechend sind es keine variablen und die sind auch unmöglich im programm änderbar
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
//Feste Systemparameter (nicht von Anwender manipulierbar)######################################################
#define m 0.01 // Masse der Kugeln in kg
#define L 8.0 // Länge der Pendel im Gravitationsfeld in cm
#define a 1.0 // Abstand der Ruhepositionen in cm
#define g 1000.0 // Gravitationsbeschleunigung in -y-Richtung in cm/s^2
#define k 1000.0 // Federkonstante in kg/s^2
#define L0 7.99 // Ruhelänge des Pedels im Gravitationsfeld in cm
#define x0 (-2.0) // x-Postion der 0. Kugel in cm
#define epsilon 10000.0 // Lenard-Jones-Parameter Epsilon in kg <em>cm^2/s^2
#define sigma 0.9 // Lenard-Jones-Parameter Sigma in cm
#define t_end 10.0 // End-Zeit in s
//#############################################################################################################
// Funktion, die Abstand zwischen zwei Kugeln i,j misst---------------------------
double Abstand(double feld[][2][2], int i, int j ){
double Erg;
Erg = sqrt(pow(feld[i][0][0]-feld[j][0][0],2)+ pow(feld[i][1][0]-feld[j][1][0],2));
return Erg;
}//-------------------------------------------------------------------------------
//Länge der Feder-----------------------------------------------------------------
double Laenge(double feld[][2][2], int i){
double Erg;
Erg = sqrt(pow(feld[i][0][0]-i</em> a,2)+pow(feld[i][1][0]-L,2));
return Erg;
}//------------------------------------------------------------------------------
//Kinetische Energie eines Teilchens i-------------------------------------------
double T_i(double feld[][2][2], int i){
double Erg;
Erg = 0.5 *m* (pow(feld[i][0][1],2)+pow(feld[i][1][1],2));
return Erg;
}//------------------------------------------------------------------------------
//Potenzielle Energie eines Teilchens i ohne Lenard-Jones-Potenzial--------------
double V0_i(double feld[][2][2], int i){
double Erg;
Erg = 0.5 *k* pow(Laenge(feld,i)-L0,2) + m *g* feld[i][1][0];
return Erg;
}//------------------------------------------------------------------------------
//Lenard-Jones-Potenzial zwischen Teilchen i und j:-------------------------------
double VLJ_ij(double feld[][2][2], int i, int j){
double Erg;
if(Abstand(feld,i,j)<sigma && i!=j){
Erg = epsilon*(pow(sigma/Abstand(feld,i,j),12)-2 pow(sigma/Abstand(feld,i,j),6)+1);
}else{
Erg = 0.0;
}
return Erg;
}
//Summe aller Lenard-Jones-Wechselwirkungen für ein Teilchen i-------------------
double VLJ_i(double feld[][2][2], int i, int N ){
double Erg=0.0;
int j;
for(j=0; j<N; j++){
Erg= Erg+ 0.5</em> VLJ_ij(feld,i,j);
}
return Erg;
}
//Differentialgleichung für Teilchen i ohne Lenard-Jones-Potenzial…------------
//… für x-Komponente:+++++++++++++++++++++++++++++++++
double F0x_i(double feld[][2][2], int i){
double Erg;
Erg = -k/m*(Laenge(feld,i)-L0) *(feld[i][0][0]-i* a)/Laenge(feld,i);
return Erg;
}//+++++++++++++++++++++++++++++++++++++++++++++++++++++
//… für y-Komponente:+++++++++++++++++++++++++++++++++
double F0y_i(double feld[][2][2], int i){
double Erg;
Erg = -k/m*(Laenge(feld,i)-L0) <em>(feld[i][1][0]-L)/Laenge(feld,i)-g;
return Erg;
}//+++++++++++++++++++++++++++++++++++++++++++++++++++++
//--------------------------------------------------------------------------------
//Differentialgleichung für Lenard-Jones-Wechselwirkung zwischen Teilchen i,j:----
double FLJ_ij(double feld[][2][2], int i, int j){
double Erg;
if(Abstand(feld,i,j)<sigma&&i!=j){
Erg = 12 epsilon*(pow(sigma,6) pow(Abstand(feld,i,j),-7)-pow(sigma,12) pow(Abstand(feld,i,j),-13));
}else{
Erg = 0.0;
}
return Erg;
}
//Differentialgleichung für Lenard-Jones-Wechselwirkung für die beiden Komponenten:
//…x-Komponente:+++++++++++++++++++++++++++++++++++++++
double FLJx_i(double feld[][2][2], int i, int N){
double Erg = 0.0;
int j;
for(j=0; j<N; j++){
if(i!=j){
Erg = Erg -FLJ_ij(feld,i,j)</em> (feld[i][0][0]-feld[j][0][0])/Abstand(feld,i,j);
}else{
Erg = Erg;
}
}
return Erg;
}//+++++++++++++++++++++++++++++++++++++++++++++++++++++++
//…y-Komponente:++++++++++++++++++++++++++++++++++++
double FLJy_i(double feld[][2][2], int i, int N ){
double Erg=0.0;
int j;
for(j=0; j<N; j++){
if(i!=j){
Erg = Erg - FLJ_ij(feld,i,j)</em> (feld[i][1][0]-feld[j][1][0])/Abstand(feld,i,j);
}else{
Erg = Erg;
}
}
return Erg;
}
//gesamte Beschleunigungsterme+++++++++++++++++++++++++++++++++++++++++++++++
//…für x-Komponente
double Fx_i(double feld[][2][2], int i, int N){
double Erg;
Erg = F0x_i(feld,i) + 0.5/m <em>FLJx_i(feld,i,N);
return Erg;
}//---------------------------------------------------
//für y-Komponente-------------------------------------
double Fy_i(double feld[][2][2], int i, int N){
double Erg;
Erg = F0y_i(feld,i) + 0.5/m</em> FLJy_i(feld,i,N);
return Erg;
}//----------------------------------------------------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int main(int argc, char <em>argv[]){
//Konfigurations-Array-------------------------------(erklären wies funktioniert
int N = 2;
//int N = atoi(argv[1]);// Teilchenanzahl aus Programmaufruf
//double dt = atof(argv[2]);// Zeitschrittweite aus Programmaufruf
int algorithm = 0;
double Sys_alt[N][2][2];// Systemkonfiguration erste Komponente = Teilchen, zweite Komponente = x oder y , dritte Komponente x oder x’
double Sys_neu[N][2][2];
int i,j,l;
//----------------------------------------------------------------------------
//Initialisieren des Konfigurations- Arrays#####################################################################
//Orte der 0. Kugel++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Sys_alt[0][0][0] = x0;
Sys_alt[0][1][0] = L-sqrt(pow(L,2)-pow(x0,2));
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Orte der anderen Kugeln +++++++++++++++++++++++++++++++++++++++++++++++++++++
for(i=1; i<N; i++){
Sys_alt[i][0][0]=i</em> a;
Sys_alt[i][1][0]=0.0;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Geschwindigkeiten aller Kugeln+++++++++++++++++++++++++++++++++++++++++++++++
for(i=0; i<N;i++){
Sys_alt[i][0][1]= 0.0;
Sys_alt[i][1][1]= 0.0;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//#############################################################################################################
if(algorithm == 0){
//Euler- Algorithmus############################################################################################
double t=0.0;
double dt=0.00001;
double KinEnerg, PotEnerg, GesEnerg;
//Output-Files für Koordinaten der Teilchen und für Energien des Systems+++++++
char File1[100];
char File2[100];
sprintf(File2,“Daten_Energie_Euler.txt”);
sprintf(File1,“Daten_Koord_Euler.txt”);
FILE *f1=fopen(File1, “w”);
FILE *f2 =fopen(File2, “w”);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Zeitschleife+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
do{
//Ausgabe der Koordinaten----------------------------------
fprintf(f1, “#t=%.4lf\n”,t);
for(i = 0; i<N; i++){
fprintf(f1,"%.5lf\t", Sys_alt[i][0][0]);
fprintf(f1,"%.5lf\n", Sys_alt[i][1][0]);
}
fprintf(f1, “\n”);//Doppeltes Leerzeichen für Trennung der Blöcke
fprintf(f1, “\n”);//der einzelnen Zeitpunkte für Plotprogramm
//---------------------------------------------------------
//Berechnung der Energien----------------------------------
KinEnerg =0.0;
PotEnerg =0.0;
//Bestimmen der kinetischen und potentiellen Energie durch Summation über T_i und V_i
for(i=0; i<N; i++){
KinEnerg = KinEnerg+ T_i(Sys_alt,i);
PotEnerg = PotEnerg+ V0_i(Sys_alt,i)+VLJ_i(Sys_alt, i, N);
}
GesEnerg = KinEnerg +PotEnerg;
//Ausgabe der Energien des Gesamtsystems zu den verschiedenen Zeitpunkten
fprintf(f2, “%.4lf\t”, t);
fprintf(f2, “%.5lf\t”, KinEnerg);
fprintf(f2, “%.5lf\t”, PotEnerg);
fprintf(f2, “%.5lf\n”, GesEnerg);
//---------------------------------------------------------
//Euler-Integration für jedes der N Teilchen---------------
for(i=0; i< N; i++){
Sys_neu[i][0][1] = Sys_alt[i][0][1]+ Fy_i(Sys_alt,i,N)*dt;//Geschwindigkeit in x-Richtung
Sys_neu[i][1][1] = Sys_alt[i][1][1]+ Fy_i(Sys_alt,i,N)*dt;//Geschwindigkeit in y-Richtung
Sys_neu[i][0][0] = Sys_alt[i][0][0]+ (Sys_alt[i][0][1] + Fx_i(Sys_alt,i,N)*dt)*dt;//x-Koordinaten
Sys_neu[i][1][0] = Sys_alt[i][1][0]+ (Sys_alt[i][1][1] + Fy_i(Sys_alt,i,N)*dt)*dt;//y-Koordinaten
}
//---------------------------------------------------------
//Vertauschen der beiden Arrays----------------------------
for(i=0; i<N;i++){
for(j = 0; j< 2; j++){
for(l=0; l< 2; l++){
Sys_alt[i][j][l] = Sys_neu[i][j][l];
}
}
}
//---------------------------------------------------------
t = t+dt;
}while(t<=t_end);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Schließen der Dateien in die Daten ausgegeben wurden
fclose(f1);
fclose(f2);
}//############################################################################################################
if(algorithm ==1){
//Velocity-Verlet-Algorithmus##################################################################################
double t=0.0;
double dt=0.0001;
double KinEnerg, PotEnerg, GesEnerg;
//Output-Files für Koordinaten der Teilchen und für Energien des Systems+++++++
char File1[100];
char File2[100];
sprintf(File2,“Daten_Energie_VVerlet.txt”);
sprintf(File1,“Daten_Koord_VVerlet.txt”);
FILE *f1=fopen(File1, “w”);
FILE * f2 =fopen(File2, “w”);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Zwischenspeicher für vx_i(t+1/2dt) und vy_i(t+1/2dt)
double Zwischen[N][2];
//Zeitschleife+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
do{
//Ausgabe der Koordinaten----------------------------------
fprintf(f1, “#t=%.4lf\n”,t);
for(i = 0; i<N; i++){
fprintf(f1,"%.5lf\t", Sys_alt[i][0][0]);
fprintf(f1,"%.5lf\n", Sys_alt[i][1][0]);
}
fprintf(f1, “\n”);//Doppeltes Leerzeichen für Trennung der Blöcke …
fprintf(f1, “\n”);//…der einzelnen Zeitpunkte für Plotprogramm
//---------------------------------------------------------
//Berechnung der Energien----------------------------------
KinEnerg =0.0;
PotEnerg =0.0;
//Bestimmen der kinetischen und potentiellen Energie durch Summation über T_i und V_i
for(i=0; i<N; i++){
KinEnerg = KinEnerg+ T_i(Sys_alt,i);
PotEnerg = PotEnerg+ V0_i(Sys_alt,i)+VLJ_i(Sys_alt, i, N);
}
GesEnerg = KinEnerg +PotEnerg;
//Ausgabe der Energien des Gesamtsystems zu den verschiedenen Zeitpunkten
fprintf(f2, “%.4lf\t”, t);
fprintf(f2, “%.5lf\t”, KinEnerg);
fprintf(f2, “%.5lf\t”, PotEnerg);
fprintf(f2, “%.5lf\n”, GesEnerg);
//---------------------------------------------------------
//Velocity-Verlet-Integration für jedes der N Teilchen-----
//Berechnen der Zwischengeschwindigkeiten…
for(i=0;i<N; i++){
Zwischen[i][0]=Sys_alt[i][0][1] + 0.5</em> Fx_i(Sys_alt,i,N) <em>dt;
Zwischen[i][1]=Sys_alt[i][1][1] + 0.5</em> Fy_i(Sys_alt,i,N)*dt;
}
//…
//Berechnen der neuen Orte…
for(i=0;i<N;i++){
Sys_neu[i][0][0] = Sys_alt[i][0][0]+Zwischen[i][0]*dt;
Sys_neu[i][1][0] = Sys_alt[i][1][0]+Zwischen[i][1] <em>dt;
}
//…
//neue Geschwindigkeiten…
for(i=0;i<N;i++){
Sys_neu[i][0][1] = Sys_alt[i][0][1] + 0.5</em> (Fx_i(Sys_alt,i,N)+Fx_i(Sys_neu,i,N)) <em>dt;
Sys_neu[i][1][1] = Sys_alt[i][1][1] + 0.5</em> (Fy_i(Sys_alt,i,N)+Fy_i(Sys_neu,i,N))*dt;
}
//…
//---------------------------------------------------------
//Vertauschen der beiden Arrays----------------------------
for(i=0; i<N;i++){
for(j = 0; j< 2; j++){
for(l=0; l< 2; l++){
Sys_alt[i][j][l] = Sys_neu[i][j][l];
}
}
}
//---------------------------------------------------------
t = t+dt;
}while(t<=t_end);
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Schließen der Dateien in die Daten ausgegeben wurden
fclose(f1);
fclose(f2);
}//############################################################################################################
return 0;
}
Das kann man sich sonst ja nicht ansehen 
2 „Gefällt mir“
Sorry ich habs nur in einer pdf datei noch iwie rumfahren gehabt Der Code müsste irgendwo auf meiner Festplatte sein die aber gerade nicht vom pc erkannt wird. Aber durch den formatierte Text funktion geht das ja alles ez i remember
Dachte das läuft heutzutage alles über Python 
Tut es ja auch aber man muss eben am Anfang C lernen weil es sonst keinen Programmierkurs aus der Info gibt in die man Physiker setzen kann und man muss auch die Wissenschaftliche Rechnen Kurs mit C machen. Man kanna ber bei den Mathematikern Python lernen und dann gibts auch Komplexe Systeme und alles danach was mit Python arbeitet. Aber es gibt auch Profs die sagen, dass Physikerstudenten C können sollen, weil das ja so wichtig in der Industrie ist und sie in erster Linie das im Kopf haben und nicht dass Leute auch in die Forschung gehen sollen. Es ist zum Haareraufen.
1 „Gefällt mir“
Ah verstehe…du sagst durch den Befehl also „Setze überall wo x0 auftaucht -2.0 ein“…also…im Grunde funktioniert es so wie eine Variable…nur dass es keine Variable ist?! 
Ja genau es ist halt der Präcompiler der noch im leserlichen Code herumarbeitet ehe der Compiler anfängt mit Maschinencode zu arbeiten. Man würde es glaub globale Konstante nennen.
Warum sollte man auch Speicherplatz für ne Variable verschwenden wenn diese immer nur ausgelesen aber nie verändert wird ^^
1 „Gefällt mir“
Ich suche Infos wie viel Vitamin D ich im Winter einwerfen muss und die kommen mir mit Fantasie Einheiten wie IE Wie wäre es mit den guten alten (µ)g?
Edit: Um euch einen Klick zu sparen. Der deutsche Mindestwert ist 20µg (oder 800 Fantasieeinheiten) pro Tag, laut Ärzten aber deutlich zu niedrig. Die Empfehlung sind 50µg (2000 Fantasieeinheiten) am Tag.
Naja…als wenn Speicherplatz bei sowas ein „Problem“ wäre
Aber wie war das?
Make it work, make it fast, make it pretty?
Soviel wie möglich…wird schon nicht stören. 