Alibre Design, Tipps und Tricks

Jo sind sie auch nich.
Können gerne mal auf ein Bier

Gruß Christian

Es gibt ja die conclusio ex nihil.

Wenn nix passiert (so denken die EU-Politiker, Juncker hat das ja mal ausgesprochen), denken die, das paßt und die können so weiter machen, uns das letzte Quäntchen Butter vom Brot zu rauben.

Was das ziemliche GEgenteil aus der conclusio ex nihil ist, ist die Aufregung.

Wenn sich alles aufregt, hat man einen wunden Punkt getroffen.

Ich will mich hier nicht streiten, sondern nur feststellen, daß ALLE BETEILIGTEN wissen, daß ein CAD Programm kein Rechenkünstler ist. Ein CAD ist sowas wie das verkrüppelte Adoptivkind von dem verstorbenen Bruder eines Rechenkünstlers.

Wir sind uns einig: CAD PRogramme können nicht rechnen. Ist ja immer schön, wenn man sich einig ist.

Es gibt Argumente dafür, warum sie das nicht können können.

Die Argumente wurden hier vorgetragen. Dabei wurde weggelassen, daß der vermutliche Hauptgrund die fette Henne ist, auf der sie draufhocken. Geschenkt.

Wir sind ja Pragmatiker und keine Ideologen, daher kommen wir mal auf den Boden der Realitäten zurück.

Frage an @yeah!:

Wie genau verschwenkt man in alibre eine Ebene über einem linear ausgetragenen Ring, wie das bei er Teilscheibe der Fall ist?

Ich extrudiere die Teilscheibe als Ring in xy, Maße D_innen=180, D_aussen = 200.

Setzte eine Bohrung rein in zy.

Und will nun die Musterung mit 5 Grad Versatz.

Kannst du mal genau beschreiben, was man dafür machen muß? Mein jetziger Kenntnisstand ist, daß ich dafür eine unnötige Fläche einfügen muß, um den Winkel zu kriegen.

Ohne diese unnötige (später wegzulöschende) Fläche steigt die Anzeige -> Ebene einfügen nicht auf Winkel um.

Das sind so die halb- oder garnicht dokumentierten Features in Alibre, erkenntlich daran, daß es kein Menu gibt, sondern nur direct-click-options.

Sowas hasse ich eigentlich, aber nun, was hilft´s.


Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 10.09.2010, 21:04 Uhr

Also bei Solidedge kann man einfach eine vorhandene Referenzebene kopieren und drehen.

zu den 20 bzw 96 Sekunden "Berechnungszeit", was hast du überhaupt in deinem Rechner drin (Prozessor, GraKa, RAM)?
Ich vermute mal, Alibre könnte schneller aber die GraKa kommt nicht mit.
In dem Fall entweder aufrüsten oder in den Einstellungen von Alibre die Darstellungsqualität verringern, Lichteffekte, Schatten ausschalten, Anzahl der dargestellten Kreissegmente runtersetzen, ect. bis es einigermaßen flüssig läuft.

Hallo,
also mein CAD Programm das ich gerade nebenbei beim kucken meiner Lieblingsserie geschrieben hab läuft auf QBasic mit 3D-Brillenunterstützung, da mir die C89 Variante zu schnell läuft und ich mit dem C-Compiler nich klar komme und das dann sonst auch Auswirkungen auf die Raum-Zeitverschiebung hat wenn der so schnell rechnen tut Außerdem hat sich mein guter Comodore PC 20 gerade auf über 200°C erhitzt, aber hab ihm noch schnell ne Stickstoff-Prozessorkühlung verpaßt,...jetz läuft mein QBasic CAD auch wieder ruckelfrei und ca. 30.000x schnell als dieses alte Alibre Dingens.
10 Print "ohne Schmarrn"



Der Beitrag wurde von V4Aman bearbeitet: 10.09.2010, 22:51 Uhr

Hallo

@ V4Aman
Der war gut!

@sharky
Du bist fei scho a harte Nuß...
Sei doch froh, daß du für kleines Geld was hast, mit dem sich arbeiten läßt!
Das gilt auch für deine Maschinen.

Bis vor kurzem lief mein SE noch auf nem älteren Travel-Book, natürlich mit Abstrichen, aber es lief, ich konnte damit arbeiten und das ist es was zählt.
Es muß nicht das Beste vom Besten sein, es muß zu den Anforderungen passen.
Ich brauche keinen A380, um 30km zur Arbeit zu kommen.
Damit wäre ich zwar schneller, aber mein Auto tuts auch.

Du brauchst zur Konstruktion von durchbohrten Ringen keine Hollywood-mäßigen Spezialeffekte mit Echtzeit-Explosionen.
Wenn du mehr willst, mußt du mehr bezahlen, so einfach ist das.
Wenn dein 99€-CAD mit den Martführeren auf Augenhöhen wäre, wer würde dann noch die Großen brauchen?
Und das liegt nicht nur an der Gier der Global Player, die dir ganz persönlich und mit Nachdruck ans Bein pissen wollen...

Für dich ist wohl der Weg das Ziel, wenn du aber alles mitschleppst was irgendwie geht, kommst du auch auf dem Weg nicht sehr weit.

Wie weiter oben schon steht, arbeite dich erstmal richtig in die Materie ein bevor du mit faulen Tomaten oder gar Datteln auf unschuldige Hennen wirfst.

Gruß
Thomas

Hallo

Zudem die Entwickler der CAD/CAM-Systeme ihre Systeme auch möglichst schnell rechnen lassen wollen. Denn die Berechnungsgeschwindigkeiten können durchaus ein Grund sein sich für das eine oder andere System zu entscheiden -> "Zeit ist Geld".
Es wird also seine Gründe haben, dass die entsprechenden Systeme für solche Berechnungen ihre Zeit brauchen. Auch wenn sich diese Gründe für manche nicht direkt erschließen müssen.

Und wie schon mal geschrieben wurde, was Zeit bei Berechnungen ist weis man dann, wenn man zwischendurch einen Kaffee trinken oder gar eine Mittagspause machen kann. Das kommt dann im CAM-Bereich teilweise gar nicht mal so selten vor. Ich habe selbst teilweise Berechnungen von über 30min für eine Bearbeitung.

Gruß Gerd

Hallo Gekufi,

da sind wir doch einer Meinung:

Hast du keine Zeit, brauchst du C-Compiler. (o.k, kleiner Scherz am Rande).

Verfeinerung des Benchmarking.

Die Frage wäre nämlich, bzgl. Benchmark, ob man pro Koordinate mit 3 Multiplikationen hinkommt (nämlich für x,y,z), oder da mehr Aufwand getrieben werden muß, denn wenn man da mehr rechnen muß, stimmt die Grundannahme der 21 Mio. Multiplikationen nicht mehr und der vorläufige BENCHMARK war für die Katz.

Für die Verfeinerung des Benchmarking muß man differenzierter vorgehen und EXAKT DIESELBE STRUKTUR berechnen, wie es das 3DCAD auch macht, nämlich die referenzierte Musterung von 1000 axial angeordneten Bohrungen mit den identischen Abständen und Durchmessern.

Ich hab jetzt mal, damit man sieht, welches schräge Zeugs ich programmiere, eine GROBE GRAFISCHE DARSTELLUNG zur VERANSCHAULICHUNG dargestellt. Wenn ich mit der Auflösung zu fein rangehe, sieht man nichts mehr, daher also GROBES DRAHTGITTER,

Bild 1 und Bild 2.

Zu sehen sind 24 Teilungen in Grobraster in zwei Ansichten.

Ist das Zeugs mit dem C-Compiler erstmal (vernünftig) programmiert (und das ist es, nämlich mit zentralen Parametern), kann man ansschließend alle Varianten Linienabstand, Anzahl Teilungen, Durchmesser Bohrung, Anzahl Kreispunkte etc. etc. innerhalb Sekunden ändern und neu durchrechnen lassen.

Zu den Feinheiten im nächsten Beitrag.


Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 11.09.2010, 16:27 Uhr

Nun, was machen wir hier?

Antwort: benchmarking.

Referenz waren 1000 radiale Teilungen mit D=6.0, Innenradius der Teilung 171.5. Bohrtiefe Differenz zu D=165.

Sehen wir mal auf die Parameter (Auszug aus dem C-Programm):

float const radius_musterung=58.75;
int const anz_kreispunkte=36;
int const anz_bohrungen=1000;
float const bohrtiefe=23.65; // von D165 durch die Geometrie bis D117.5
float const linienabstand = 0.29; // 72dpi=0.288
int const linien_pro_bohrung= int(bohrtiefe/linienabstand+0.5);
float const radius_bohrung=3.0;
float const schwenkwinkel_musterung=360/(anz_bohrungen*1.0);:



Das sind also genau die Vorgaben von der Referenz, 1000 Bohrungen mustern.

Unten, im MAIN, sieht das dann so aus, um die reine Rechenzeit festzustellen (Auszug aus dem C-Programm):


int main(void)
{

nulle_bohrungen();
berechne_referenzbohrung();
berechne_polarkoordinaten();
speichere_referenzbohrung("E:\\cnc_dateien_2010\\alibre_referenz.tap");

cout<<"Start"<<endl;
for (int i=0; i<100; i++) berechne_musterung();
cout<<"Stop"<<endl;




Wir sehen, das Programm erledigt die Vorarbeiten, und wenn es an die zirkulare Musterung geht, erscheint auf dem Bildschirm START (für die Stoppuhr), sobald es mit der Berechnung fertig ist, erscheint auf dem Bildschirm STOP.

Die Stoppuhr machen wir ganz undramatisch mit der Windows-Kalenderanzeige (siehe Bild). Start ist dann bei 12 Uhr.

Damit das nicht zu hektisch wird, habe ich die Musterung 100mal ausgeführt.

Ergebnis sieht man dann im angehängten Bild: STOP ist bei 18 Sekunden, einmal ist er durchgelaufen, macht 78 Sekunden für 100x1000 Musterungen.

Das PRogramm macht also dasselbe, was Alibre macht, aber nicht in 96 Sekunden für einen Durchgang, sondern in 78 Sekunden für 100 Durchgänge.

Der Faktor errechnet sich nach:

96/78*100.

Der C-Compiler ist bei dieser DEZIDIERT IDENTISCHEN AUFGABENSTELLUNG exakt 123 mal schneller als die CAD.

Was heißt das?

Nun, wenn man mit dem C-Compiler eine Rechnung durchführt, die 1 Minute in Anspruch nimmt, braucht Alibre für dieselbe Rechnung 123 Minuten.

Also ca 2 Stunden.

Das ist nicht so schnell, wie ich gedacht hätte.

Möglicherweise ist meine Erst-Programmierung aber noch etwas ungeschickt.

Würde der C-Compiler aber 2 Stunden brauchen, dann müßte man den Alibre-Computer FÜR ZEHN TAGE unter Bewachung stellen, damit keiner aus Versehen eine falsche Taste drückt.

Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 11.09.2010, 18:20 Uhr

Hm, der Benchmark hinkt noch immer, da sich ein paar Fragen aufwerfen: Rechnest du mit einfacher oder doppelter Genauigkeit? Was macht das CAD noch alles mit den Daten? Stichwort Undo-History, Strukturbaum, evtl noch gesicherte Transaktionen damit die Datei nicht defekt ist im falle eines Absturzes, etc.

Weil mit der Aussage "Mein selbstgeschriebenes C Programm ist 1000x schneller als CAD" stellt die Programmierer des CAD irgendwie als Vollidioten hin.

Von mir auch mal ein hinkender Vergleich:
Zwei Bekannte bauen jeder ein Haus, der eine schön mit Plan, Genehmigung und all dem bürokratischen Zeug. Der andere einfach so. Dürfte ja klar sein wer da schneller ist. Nur ob es legal (als richtig) ist ist eine andere Frage.

Grüße, Mike

Nun, zu der Programmierung:

Alle Daten sind in einem Datenbaum gespeichert und jederzeit abrufbar.

Der Datentyp ist float, also 6-7 Nachkommastellen.

Man könnte, anders als im CAD Programm, wo ich jede zweite Bohrung rausgelöscht habe, für diese rausgelöschten Bohrungen eine Flag setzen, damit das Programm die ignoriert (warum das CAD das nicht macht, weiß ich nicht, ich würde das als total ungeschickte Programmierung bezeichnen, erstens die gelöschte Daten immer wieder neu zu berechnen und, um dem die Krone aufzusetzen, die neu berechneten gelöschten Daten wieder zurückzurechnen. Das ist keine Programmierung, das ist Chaos, wahrscheinlich daher, weil die 3DCAD auf einer anderen Programmiermaschine aufgesetzt ist, wo es nicht anders geht, so in Richtung Datenbank ). Die programmieren also nicht originär, sondern müssen die schrägen Datenbankbefehle anwenden. Immer noch mein Eindruck.

Gesichert werden die Daten in 3 Dateien:

Einmal die Referenzbohrung (das Grundmuster).

Dann die Datei mit den entsprechenden ISO-Befehlen (die hier allerdings nur zur Visualisierung gedacht sind).

3. Datei ist eine Datei mit allen Daten, auch denen, die in der ISO-Datei nichts zu suchen haben.

ES IST ALLES JEDERZEIT REKONSTRUIERBAR AUCH BEI SYSTEMABSTURZ.

Also mit den Grundlagen der Programmierung und Datensicherung brauchst du bei mir nicht anfangen.

Ich stell auch keinen CAD Programmierer als Idioten dar. Das ist doch eine völlig hahnebüchene Behauptung.

Ich untersuche hier nur die Rechenleistung von einem CAD Programm.

Nicht mehr und nicht weniger.

Aber eben auch nicht weniger.

Und die CAD Fans können ja froh sein, daß der reine Kalkulationsvorteil des C-Compilers von mehr als 1000 auf 128 zusammengeschmolzen ist.

Jedenfalls zunächst, vielleicht war die Erstprogrammierung der 3D-Teilung etwas ungeschickt.

Immerhin aber, ein Faktor von >100 ist ja so ganz auch nicht zu verachten, oder?


Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 11.09.2010, 18:10 Uhr

Wie programmiert man sowas?

Ich möchte mich hier nicht über die Feinheiten der C-Programmierung auslassen. Zumal ich gar kein C-Programmierer bin, sondern ein originärer Pascal-Programmierer auf DOS-Ebene. Ich programmiere also in C wie in Pascal, das ist ein fürchterliches C, aber am Ende funktionieren die Programme in C erstaunlicherweise immer so wie in Pascal gedacht.

SOndern es geht um die Programmier-Logik.

Und diese Logik müssen diese CAD Programme ja auch befolgen.

Geometrie ist Geometrie, da gibt es keine Meinungen, sondern nur Tatsachen.

Man legt die ganze 3D-Maschine augenblicklich still, wenn man eine 3D-Rotation macht. Weil in Richtung der Rotationsachse gesehen, ist alles 2D.

Sagen wir mal, wir rotieren eine Struktur mit der Y-Achse. Dann sind die zu rotierenden Koordinaten Z und X.

Und was passiert mit den Y-Werten? Wo bleiben die? Antwort: die bleiben natürlich erhalten, die schleppt man von Projektion zu Projektion UNVERÄNDERT HINTERHER.

Ich hab mich heute etwas sehr schwer getan, aus dem Grund, mit dem jeder C-Progrmmierer aber rechnen muß, daß in der laufenden Bearbeitung der ARbeitsspeicher überschrieben wurde. C ist ja sozusagen Tanz auf dem Drahtseil ohne doppelten Boden. Es gibt die Notwendigkeit, die arc-sin in Grad-sin umzuwandeln, und wenn der Speicherbereich überschrieben ist, produziert das Programm Müll. Bis ich das gemerkt hatte ... Daneben mußte ich für diese Projektion auch noch die Rückumwandlung der Winkelfunktionen in Gradzahlen programmieren, heißt in c asin() oder acos(), kann man aber so nicht verwenden, muß man auch in Gradzahlen umrechnen.

Also progammiertechnisch nicht so ganz einfach, ein paar Bohrungen zu rotieren, hat man es aber einmal gemacht, steht das Programm ja zur Verfügung.

Nun, der Trick bei der zirkulären Musterung, programmiertechnisch gesehen, ist so einfach, aber so einfach nicht zu erkennen.

Zirkuläre Musterung ist natürlich ein völliger neudeutscher UNSINNS-BEGRIFF, worum es hier geht ist die Rotation einer dreidimensionalen Struktur um eine Achse.

Musterung! Das ist doch mal wieder zum ... ich sag es nicht.

Wenn wir rotieren wollen, stehen wir vor dem Problem, daß wir mit den xyz Koordinaten absolut nichts anfangen können.

Jedenfalls ich konnte damit nichts anfangen.

Der Trick ist, AUS DEN KARTESISCHEN KOORDINATEN DIE POLARKOORDINATEN DER ROTATIONSACHSE ZU ERRECHNEN.


Man muß also, in Blickrichtung der Achse, die ganzen Koordinaten aus der Perspektive der Rotationsachse neu berechnen, damit man Polarkoordinaten hat, und das sind ja nur zwei, nämlich Winkel in Rotationsachenrichtung plus Distanz zur Rotationsachse, anstatt drei, nämlich x,y.z.

Danach ist alles ganz einfach, Kinderkram. Nur auf die Idee muß man ja erstmal kommen.

Rotiert man in der Y-Achse, dann gilt:

1.) Y Werte bleiben unverändert

2.) X rotiert nach der cos-Funktion.

3. Z rotiert nach der sin-Funktion.

Das war es schon.

Nee, nicht ganz: man muß für JEDE EINZELNE KOORDINATE den ABSTAND ZUR ROTATIONSACHSE haben, sonst geht das nicht.

Aber das sollte ja wohl klar sein.

Aus der Abteilung: Tipps und Tricks der PRogrammierung in 3D FOR BEGINNERS. .

Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 11.09.2010, 19:06 Uhr

Umrechnung der kartesischen auf Polarkoordinaten, Auszug aus dem C-Programm:

void berechne_polarkoordinaten()
{
float cosinus=0.0; float sinus=0.0;float alpha=0.0; float probe=0.0;
float mittendistanz_x, suchradius,musterungswinkel;
for (int i=0;i<anz_bohrungen;i++)
{
for (int j=0;j<linien_pro_bohrung;j++)
{
for (int k=0;k<anz_kreispunkte;k++)
{
mittendistanz_x= bohrung[i].kreis[j].kreispunkt[k].x/2;
// if (mittendistanz_x<0) mittendistanz_x=mittendistanz_x*(-1);
cosinus=mittendistanz_x/radius_musterung;
alpha=acos_grad(cosinus);
probe=sin_grad(alpha);
if (pruefe_auf_null(probe)!=0) // heißt was es heißt: ungleich 0
{
suchradius=radius_musterung/sin_grad(alpha)
+ bohrung[i].kreis[j].kreispunkt[k].z;

;
}
else suchradius=radius_musterung
+ bohrung[i].kreis[j].kreispunkt[k].z;

bohrung[i].kreis[j].kreispunkt[k].polar_d=suchradius;
bohrung[i].kreis[j].kreispunkt[k].polar_w=alpha;

}// for k
} // for j
}// for i

} // funktion


Wir sehen hier eine dreifach ineinander verschachtelte Schleife, nämlich innen werden die Kreispunkte ausgerechnet, in der Ebene darüber die nächste Kreisebene, und darüber sitzt die Anzahl der Teilungen =Bohrungen.

Da kommen so rechnerisch je nachdem einige Millionen Kalkulationen zu stande, die man mit dem Taschenrechner nicht so elegant erledigen könnte.

Das Problem hier ist, durch eine Winkelfunktion zu teilen. Nämlich dieses:

suchradius=radius_musterung/sin_grad(alpha)


Wir wollen die Hypotenuse errechnen, also die Polarkoordinate für den Abstand zur Rotationsachse, kennen aber nicht den Betrag des Winkels.

Eine Winkelfunktion wie SIN oder COS kann ja auch den Wert NULL haben.

Division by zero ist aber verbotene Zone, btw. mathematisch nicht definiert oder anders gesagt Systemabsturz.

Eine INT kann man gem. if (int Zahl==0) auf Null prüfen, aber nicht eine float. Der Vergleich geht in die Endlos-Schleife oder hat seltsame Effekte zur Folge.

Daher wurde eine Routine geschrieben, die im Ernstfall 0 zurückgibt (0= es ist Null bzw. nahezu Null):

if (pruefe_auf_null(probe)!=0) // heißt was es heißt: ungleich 0

Die Funktion sieht so aus:


int pruefe_auf_null(float wert)
{
float pruef=wert;
int ergebnis=-1; // -1 heißt in Ordnung
float min=1/(100*100);
if (pruef<0) pruef=pruef*(-1);
if (pruef<min)ergebnis=0; // 0 ist 0, nicht in Ordnung
return(ergebnis);
}


Hier wird also die Fließkomma approximativ auf Null geprüft, und die Feinheit ist auf 1/100*100 =1/10.000 eingestellt.

Ich könnte jetzt die Programmierung noch in allen Feinheiten erklären, weiß aber, daß in diesem Forum das Interesse an Programmierung nicht sehr ausgeprägt ist, zudem daß es hier nur um ziemlich banale Dinge geht, daher spare ich mir das.

Programmierung ist schon eine schöne Sache, sie muß aber auch EFFEKTIV sein, also Strukturen erzeugen, die brauchbar sind.

Bei meinen Programmierungen bin ich mir nicht immer so sicher, ob das der Fall ist.

Aber ich bin mir sicher, wenn ich wollte, daß ich könnte.



Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 11.09.2010, 20:17 Uhr

Projekt 911

Ein bißchen mehr als sehr hat mich das ja schon geärgert, daß ich so ein 3D CAD mit dem C-Compiler nur mit dem Faktor 100 überholen kann.

Ähm, also wenn man mit einem reinrassigen Sportwagen, was der C-Compiler ja ist, an einem Lieferwagen vorbeizieht, mit dem Faktor 100, da fühlt man sich, als wenn von 8 Zylindern praktisch 4 ausgefallen wären.

Warum ist der C-Compiler so lahmarschig, daß der an einer lahmen Henne, die ganz sicher mit breitarschigen Megastrukturen auf sowas wie einer Datenbank aufsitzt, nur mit dem Faktor hundert vorbeizieht?

Bei der Frage der Optimierung schweift das Programmierer-Auge natürlich über die üblichen Verdächtigen, die Funktionen. Jeder Funktionsaufruf ist kritisch. Nicht irgendwo in der Peripherie, sondern da, wo die Luft bleihaltig ist. Nämlich im Kern von mehrfach verschachtelten Schleifen.

Da laufen die Mega-Kalkulationen durch, da bringt ungeschickte Programmierung Mega-Zeitverlust.

Und was dabei herausgekommen ist, ist das Projekt 911.

Ich bilde mir ein, ich könnte eine 3DCAD wie Alibre nicht um den Faktor 100, sondern mindestens um den Faktor 911 überholen.

Wie war das nochmal mit dem Sportwagen?

Herausgekommen sind dann letztlich 1111, aber 911 ist irgendwie nett, oder?

Ich frag jetzt mal den Felix Magath, was ´ne Standardsituation ist. Da sagt der: die anderen haben bei Standard-Situationen Glück gehabt. Das letzte Mal ist Schalke vor 30 Jahren so gestartet, wie Magath in dieser Saison. Damals sind die abgestiegen.

Also eine Standardsituation in 3DCAD ist z. B. eine zirkulare MUSTERUNG.

Das kommt jeden Tag vor, das ist kein Exot.

Mein Programm ist 911 mal schneller als Alibre.



Eigentlich jetzt schon 1111 mal schneller, und Programm ist noch garnichtmal in die letzten Winkel optimiert.

Gruß Sharky

Der Beitrag wurde von CNCFanatiker bearbeitet: 17.09.2010, 22:13 Uhr

Ich hab mir jetzt mit der _time Funktion in C mal eine automatische Stoppuhr geholt, damit ich nicht immer daneben sitzen muß.

Ergebnis ist dann hier zu sehen:

Wofür der C-Compiler zuvor 75 Sekunden gebraucht hat, braucht er jetzt nur noch 9 Sekunden.

Nämlich 1000 Musterungen 100 mal durchzuführen wie weiter oben schon ausgeführt.

Wenn man Alibre zwingt, die 5 Nachkommastellen, die die float in C bringt, auch zu beachten, braucht Alibre für

EINE MUSTERUNG von 1000 Bohrunen 100 Sekunden,

der C-COmpiler für 100 MUSTERUNGEN von 1000 Bohrungen = 100.000 Musterungen = ca 9 Sekunden (können auch 8 sein, aber nicht 10).

Faktor = 1111.

Das Projekt 911 läuft.

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 16:11 Uhr

Wow. . . . . .

kann dann Dein Progi das ganze auch so weitergeben, dass das Ergebnis auf den Monitor(en) zu sehen ist oder enen NUR rechnen?!?
Ersteres bezweifle ich stark, da das CAD ja wie schon des öfteren erwähnt nebenbei noch andere Dinge zu tun hat.
Wärend dein Prog nur die Koordinaten Punkte etc etc berechnen kann, zeigt das CAD dir das ganze in 3D an und und und . . . .

Nach wie vor ist Dein ""Benchmark"" kein Benchmark weil ich einenen 911er nicht mit einem Lieferwagen vergleichen kann.

Oder machst Du einen ""Benchmark"" mit deinem Heim PC gegen den Supercomputer Cray XT5 . . . .

Wenn man in C programmiert, geht man ja zu Fuß. Ohne Netz und doppelten Boden.

Während die Profis dicke Datenbankbefehle reinklicken, und haben dann schon das Programm fast fertig.

Nur: alles hat seinen Preis.

Eine fette Datenbankhenne ist eben kein Sportwagen, that´s it.

Und so ein fettes Alibre zu überholen, das mach ich mir jetzt mal zum Sport. Ist ja unterträglich, was diese fette Henne an Rechenleistung ausspuckt. Da könnte ´ne alte Frau mit einem Krückstock noch hinterherlaufen.

Thema:

Originär-Programmierung.

Alles selbst programmiert, alles zu Fuß.

Kennen die Profis heute gar nicht mehr oder die dürfen nicht. Ob die überhaupt selbst noch programmieren können, ohne in irgendwelche .NET Baukästen zu greifen, bzw. ob die unter Programmierung nur Arrangement von vorhandenen Komponenten verstehen, wäre eine interessante Frage.

Es ist der Kreis der Verdächtigen so klein, daß man sagen kann: der Mörder ist der Butler oder der Gärtner.

Hier ist er sogar noch kleiner. Es ist der Gärtner.

DENN:

Was im Inneren von der 3fach Schleife abläuft, wo die Luft bleihaltig ist, das sind trigonometrische Funktionen.

Ich hab das mal überprüft. Nicht daß man nicht wüßte, daß ein Funktionsaufruf irgendwie länger dauert, die Frage ist quantitativ.

Multi, Divi, Adii, Subt= alles gleich.

Trigonometrische Funktionen stehen dagegen in einem Verhältnis von 85:1.

Also, ran ans Werk.

Wir müssen die trigonometrischen Funktionen soweit eliminieren, wie immer möglich.

Dann winkt als Belohnung ein Faktor 80.

Nun:

Wie kann man aus einer 3-D Berechnung trigonometrische Funktionen eliminieren?

Das ist nicht ganz einfach.

Wenn man auf einer Datenbankhenne aufsitzt, ist es ganz unmöglich.

Wenn man zu Fuß in C programmiert, ist aber GARNICHTS unmöglich.

Das ist eben der kleine Unterschied.

Bild 1:

Wir machen Trigonometrie mit den Füßen von den Teilen.

Fußmassage.

Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 16:03 Uhr

So, nachdem die Basisflächen stehen ...

Es geht ja darum, trigonometrische Funktionen durch INTELLIGENTE PROGRAMMIERUNG so weit wie möglich zu ELIMINIEREN.

Und man hat gesehen, daß das Programm für dieselbe Rechenleistung, für die es vorher 75 Sekunden gebraucht hat, jetzt nur noch ca. 9 Sekunden benötigt.

Wie schafft man das, das Programm auf 911 Niveau zu beschleunigen?

Wie kann man in 3D Koordinaten berechnen ohne Trigonometrie?

Tja, interessante Frage.

Wir setzen jetzt erstmal auf die Basen die Restkörper drauf.

Bild.

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 16:19 Uhr

Mein Programm rechnet in der 2. Optimierungsstufe 1000mal schneller als Alibre, auf demselben stinknorman PC.

Oder sagen wir 911mal schneller.

Gibt dir das nicht zu denken oder glaubst du, die Anwender von 3DCAD haben Lust, stundenlang neben dem Rechner zu stehen, ohne daß der was ausspuckt?

Sei nicht so leichtfertig mit der Arbeitszeit deiner Kunden! Du brauchst sie noch! (die Kunden)

Gruß Sharky

Leider hab ich nur den Faktor 8 geschafft, von 75 Sekunden auf 9 Sekunden runter.

Das hängt mit meiner Faulheit zusammen, ich hab das Programm (natürlich) nicht komplett neu geschrieben, sondern per copy&paste angepaßt. Da sind noch Optimierungsreserven drin.

DER TRICK IST, die 3D-Restkörper ohne TRIGONOMETRIE aufzubauen.


Das bringt einen Speed-Faktor von x8 zusätzlich.

Damit bin ich 911mal schneller als Alibre für dieselbe Standardsituation, ZIRKULARE MUSTERUNG.

Vielleicht sollten sich die Programmierer von 3DCAD mal überlegen, was ihnen die Zeit ihrer Kunden wert ist.

Oder eben auch nicht, kann mir als Hobby-Programmierer ja egal sein.

Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 16:36 Uhr

Nochmal überprüfen ...

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 17:07 Uhr

Wurde überprüft.

Für 500.000 Musterungen braucht das optimierte Programm 26 Sekunden.

Alibre braucht für 1000 Musterungen mit Fließkomma 5 exakt 100 Sekunden.

---------------------------------------------

Wir haben es hier tatsächlich mit 500*1000 Musterungen zu tun. Ist mir entgangen. Sieht man hier:

(Bild)

Das bedeutet, der C-Compiler berechnet diese Geometrie

2000mal so schnell wie Alibre.

Und ich hatte mich schon gewundert, wenn zwischen Multiplikation und Trigonometrie in C der Faktor 85 sitzt, warum das Programm nur 8mal schneller wird.

Das Projekt wird jetzt umbenannt von Projekt 911 auf


FAKTOR 2000

Und ist noch nicht optimiert, sondern erstmal an-optimiert.

Ich weiß ja nicht, was die 3DCAD-Programmierer da für´n Kram zusammenstoppeln, aber überzeugen tut das nicht, wenn ein Hobby-Programmierer an denen bei einer Standard-Situation mit dem Faktor 2000 vorbeizieht.

Faktor 2000 bedeutet:

Wenn der C-Compiler 10 Minuten rechnet, daß dann der Alibre-PC 2 WOCHEN ausfällt.

Wieso? 10Min*2000=20.000 Min., = 333 Stunden= 14 Tage.

Sonst noch Fragen?


Gruß Sharky


PS: Dabei muß ich allerdings nachtragen, ich habe den Linienabstand auf 0.5 erhöht (was immer noch eine gute grafische Darstellung in Pixeln ermöglicht), und die Anzahl der Kreispunkte auf 24 reduziert. Dann ist der Faktor 2000.

Spricht aber so oder so für sich, denn Alibre profitiert von 24 Kreispunkten überhaupt nicht (mal wieder Beweis, daß es nicht originär programmiert ist). Und der Linienabstand ist zum Nachteil von der C-Programmierung, weil 3DCAD mit Sicherheit die fetten Direct-X Befehle verwendet, die mir nicht verfügbar sind.

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 17:54 Uhr

Der Trick sitzt hier:


void berechne_versatz()

// Y=Rotationsachse, in Y kein versatz!
{

for (int i=0;i<anz_bohrungen;i++)
{
bohrung[i].versatz_z=
bohrung[i].kreis[1].kreispunkt[0].z
-bohrung[i].kreis[0].kreispunkt[0].z;
bohrung[i].versatz_x=
bohrung[i].kreis[1].kreispunkt[0].x
-bohrung[i].kreis[0].kreispunkt[0].x;
} // for i
}

KURZ UND BÜNDIG, ODER?

Egal, wie schräg die Geometrie im Raum ausgerichtet ist, finden wir von der unteren zur nächsten Schnittebene immer denselben Versatz.

Daher braucht man trigonometrisch eigentlich nur die Basis auszurechnen (und wenn man faul ist, wie meinereiner, noch die zweite Ebene), um dann, faulheitsbedingt, den Versatz zwischen Ebene 1 und 2 fortzukalkulieren. Das zeigt die oben stehende Funktion. Wenn man Angst hat wegen der Nachkommastellen, kann man auch erst die entfernteste Position ausrechnen und dann teilen. In C braucht man aber keine Angst zu haben wegen Nachkomma. Mit 7 Nachkomma ist man eh im Nanobereich, und wenn,kann man double einsetzen, mit 128 NK-Stellen. Ist aber hier alles völlig überflüssig.

Den Restkörper draufzusetzen, erledigt diese Funktion:


void modelliere_restkoerper()
{
float diffx ,diffz;
for (int i=0;i<anz_bohrungen;i++)
{
diffx=bohrung[i].versatz_x;
diffz=bohrung[i].versatz_z;

for (int j=2;j<linien_pro_bohrung;j++)
{
for (int k=0;k<anz_kreispunkte;k++)
{
bohrung[i].kreis[j].kreispunkt[k].x=
bohrung[i].kreis[j-1].kreispunkt[k].x+diffx;
bohrung[i].kreis[j].kreispunkt[k].z=
bohrung[i].kreis[j-1].kreispunkt[k].z + diffz;

} // for k
} // for j
}// for i

}// funktion


Das ist eine dreifach verschachtelte Schleife, eben so ein Ding, wo die Luft sehr bleihaltig ist, da gehen pro Sekunden Milliarden Kalkulationen durch, ein HÖCHSTSENSIBLER BEREICH.

Ähm ....

sieht da irgendjemand irgendeine trigonometrische Funktion?

Siehste, das ist das eben.

Das ist der Speed.



Die Datenbank-Draufhocker können sowas vielleicht denken, aber nicht realisieren.

In C nimmt man so eine geometrische Steilvorlage natürlich mit.

Ergebnis: Faktor 2000.



Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 18:52 Uhr

Hallo Sharky,

ich sehe an Deinem Programm nur Linien nichts als einfache Linien nix mit einer trigonalisierten Oberfläche wie uns das Alibre Design anzeigt ?????
Was rechnest Du da zusammen??? Ich sehe da keine Relevanz zwischen dem was Du da zusammen Dröselst und deiner CAD Software.....
Fakt ist bei Deinem Programm kannst die Echtzeitgrafik vergessen das sind einfaches Mesh Gebilde und dann auch noch mit ner zusätzlichen Software. . .
Deine CAD macht aber die Berechnung für Deine trigonalisierte Oberfläche auch noch mit so das uns auch was vernünftiges angezeigt wird. . . .

Also doch kein richtiger Benchmark sondern wieder nur Äpfel mit Birnen Tomaten und Datteln. . . ..

Aber ich geb die Hoffnung nicht auf, dass Du uns in kürze Sharky CAD CAM Faktor 2010 Release 911 vorstellst
Die Vorteile liegen in der Hand . . . . Berechnungen laufen 2000fach schneller soll heißen das Automobil kann nun endlich an einem Tag komplett gefertigt werden.

Gruß Christian

Der Beitrag wurde von DerDenDuNichtKennst bearbeitet: 12.09.2010, 18:12 Uhr

Was ich mache, ist doch klar:

Ich berechne Koordinaten.

Ich programmiere keine CAD, sondern ich rechne Koordinaten.

Und die Koordinaten, die ich in 10 Minuten ausrechne, dafür braucht Alibre 2 Wochen.

Und du sprichst hier von Bildschirmausgabe.

10 Minuten gegen 2 Wochen Rechenzeit, das ist hier das Thema.

Wie man die errechneten Koordinaten verwendet, kommt auf die Schnittstelle an.

Mit Mach3 habe ich eine Schnittstelle, mit der ich meine Prorgrammierung visualisiere. DirectX.

Die dafür erforderliche ISO-Datei kann ich aber auch einem Lohnfertiger in die Hand drücken. Der kann dann seine Maschine damit füttern und loslegen.

In einem anderen Thread habe ich einen Exzenter in C berechnet, einem Lohnfertiger die Datei in die Hand gedrückt und der hat daraus mit seiner FANUC-Steuerung exakt den Exzenter gefräst, den ich berechnet hatte. Allerdings erst, nachdem ich die Genauigkeit meiner berechnung etwas reduziert hatte, wegen der Bahnkorrektur hatte die FANUC Probleme (war eine ältere Steuerung).

Also,

Ich rechne 2000mal schneller als Alibre,

weil ich ORIGINÄR PROGRAMMIERE

und nicht mit fetten Datenbank-Befehlen auf irgendeiner Fremdprogrammierung aufsitze.

Fette Datenbanken haben ihre Vorteile, aber auch ihren Preis, und der Preis ist die Geschwindigkeit.

No SPEED.

C-Compiler sind, wenn man damit intelligent programmiert, eben IMMER WESENTLICH schneller als FETTE LEGEHENNEN, alias DATENBANKANWENDUNGEN.

Ob ALibre eine solche ist, möchte ich nicht behaupten, aber wenn ich sehe, wie unintelligent da programmiert wurde, bleibt ein starker Verdacht, daß die auf irgendeiner fetten Henne aufsitzen. Das spür ich im Bauch. Und daher kommt auch die katastrophale Rechenleistung.

1:2000 kann man nicht mit der Bildschirmausgabe erklären, oder?


Gruß Sharky

Der Beitrag wurde von sharky bearbeitet: 12.09.2010, 18:37 Uhr

Hallo Sharky,

ich denke mal Du hast nicht im Ansatz begriffen, was ein CAD macht oder nicht macht. . . . .
Mit der CAD berechne ich keine Koordinaten im Raum und spucke dann Koordinaten aus . . . . sondern ich visualisiere meine Ideen in Bits und Bytes.
Und mit visualisieren meine ich nicht irgend ein Drahtgeflecht sondern Flächen und Volumenmodelle.
Nichts anderes... Warum soll mein CAD Koordinaten ausspucken??? Ich will das ganze als 3D Modell in Echtzeit sehen. . .

Und nochmal die "unintelligenten" Programmierer, die sie ja Deiner Meinung nach sind, weil sie ja unintelligent Programmieren,
diese werden mit Sicherheit dazu getrimmt schnellere CADs auf den Markt zu bringen um der Konkurrenz Kunden abzulaufen

Stichwort Zeit ist Geld und Zeit habe ich nicht. . . .

Nehmen wir mal an, Dein Alibre Design CAD müsste auch NUR Koordinaten berechnen, dann sieht es mit dem Faktor gleich ganz anders aus.
(und da hab ich meine Zweifel ob Du das realisierst was auch die Kollegen meinen )
Denn die CAD ist meistens ein Hybridmodellierer sprich Fläche und Volumen also ein vielfaches aufwendiger als Dein "CAD Programm"

Also nochmal das ist so nicht zu vergleichen. . . so oder so dein Faktor ist einfach falsch.

Gruß Christian