In den vorangegangenen Kapiteln dieses Handbuchs wurde bereits behandelt, wie Sie die leistungsstarken Funktionen zur visuellen Programmierung in Dynamo einsetzen können. Ein gutes Verständnis dieser Funktionen ist eine solide Grundlage und der erste Schritt bei der Erstellung zuverlässiger visueller Programme. Bei der Verwendung visueller Programme in der Praxis, der Weitergabe an Kollegen, der Behebung von Fehlern oder beim Testen von Grenzen müssen zusätzliche Aspekte berücksichtigt werden. Wenn andere Benutzer mit Ihrem Programm arbeiten sollen oder Sie damit rechnen, es z. B. sechs Monate später erneut zu öffnen, müssen seine Grafik und seine Logik unmittelbar verständlich sein. Dynamo stellt zahlreiche Werkzeuge zur Verfügung, die Ihnen helfen, die Komplexität Ihres Programms zu bewältigen. In diesem Kapitel finden Sie Richtlinien zu ihren Verwendungszwecken.

Komplexität reduzieren

Während Sie Ihr Dynamo-Diagramm entwickeln und Ihre Ideen testen, kann es rasch an beachtlicher Größe und Komplexität zunehmen. Natürlich ist es wichtig, ein funktionsfähiges Programm zu erstellen, es sollte jedoch auch möglichst einfach gehalten werden. Das Diagramm lässt sich so nicht nur schneller und besser vorhersehbar ausführen, sondern seine Logik ist dadurch für Sie und andere Benutzer problemlos verständlich. Im Folgenden werden einige Methoden beschrieben, mit denen Sie die Logik Ihres Diagramms verdeutlichen können.

Modularisieren mit Gruppen

• Gruppen ermöglichen es, bei der Entwicklung eines Programms separate Teile mit unterschiedlichen Funktionen zu erstellen.

• Mithilfe von Gruppen können Sie darüber hinaus große Teile des Programms verschieben, wobei die Modularität und Ausrichtung erhalten bleiben.

• Sie können die Farbe einer Gruppe zur Differenzierung ihres Verwendungszwecks (Eingaben oder Funktionen) ändern.

Die Farben in diesem Programm kennzeichnen den Verwendungszweck der einzelnen Gruppen. Mithilfe dieses Verfahrens können Sie eine Hierarchie in den von Ihnen entwickelten Grafikstandards oder -vorlagen erstellen.

1. Funktionsgruppe (blau)

2. Eingabengruppe (orange)

3. Skriptgruppe (grün)

Informationen zur Verwendung von Gruppen finden Sie unter

Effizientere Entwicklung mit Codeblöcken

• In manchen Fällen können Sie in einem Codeblock eine Methode für eine Zahl oder einen Block schneller eingeben, als Sie nach ihr suchen könnten (Point.ByCoordinates, Number, String, Formula).

• Codeblöcke sind nützlich zum Definieren benutzerdefinierter Funktionen in DesignScript, damit weniger Blöcke im Diagramm benötigt werden.

1 und 2 führen dieselbe Funktion aus. Dabei nahm das Schreiben einiger Codezeilen wesentlich weniger Zeit in Anspruch als das Suchen und Hinzufügen jedes einzelnen Blocks. Die Angaben im Codeblock sind darüber hinaus wesentlich prägnanter.

1. In Codeblock geschriebenes DesignScript

2. Entsprechendes Programm in Blöcken

Informationen zur Verwendung von Codeblöcken finden Sie unter

Komprimieren mit Block zu Code

• Sie können mithilfe von Block zu Code die Komplexität eines Diagramms reduzieren, wobei eine Gruppe einfacher Blöcke zusammengefasst und das entsprechende DesignScript in einen einzigen Codeblock geschrieben wird.

• Block zu Code kann** Code komprimieren, ohne die Verständlichkeit des Programms zu beeinträchtigen.**

• Die Verwendung von Block zu Code bietet die folgenden Vorteile:

1. Vorhandenes Programm

2. Mithilfe von Block zu Code erstellter Codeblock

Informationen zur Verwendung von Block zu Code finden Sie unter .

Flexibler Zugriff auf Daten mit List@Level

• List@Level kann es Ihnen erleichtern, Ihr Diagramm durch Ersetzen der Blöcke List.Map und List.Combine zu vereinfachen, die viel Platz im Ansichtsbereich beanspruchen können.

• List@Level bietet ein schnelleres Verfahren zum Konstruieren von Blocklogik als List.Map/List.Combine, indem es den Zugriff auf Daten auf einer beliebigen Ebene einer Liste direkt über den Eingabeanschluss eines Blocks ermöglicht.

Sie können überprüfen, wie viele True-Werte BoundingBox.Contains zurückgibt und in welchen Listen diese enthalten sind, indem Sie List@Level für den list-Eingang von CountTrue aktivieren. List@Level ermöglicht es, die Ebene festzulegen, auf der die Eingabe Daten übernimmt. List@Level ist flexibel und effizient und wird gegenüber anderen Verfahren, die List.Map und List.Combine nutzen, dringend empfohlen.

1. Zählen der True-Werte auf Listenebene 2

2. Zählen der True-Werte auf Listenebene 3

Informationen zur Verwendung von List@Level finden Sie unter .

Lesbarkeit gewährleisten

Gestalten Sie Ihr Diagramm nicht nur so einfach und effizient wie möglich, sondern streben Sie auch eine übersichtliche grafische Darstellung an. Beziehungen sind trotz Ihrer Bemühungen, das Diagramm intuitiv mit logischen Gruppen zu gestalten, eventuell nicht ohne Weiteres zu erkennen. Ein einfacher Block innerhalb einer Gruppe oder das Umbenennen eines Schiebereglers kann Ihnen oder anderen Benutzern unnötige Verwirrung oder das Suchen im gesamten Diagramm ersparen. Im Folgenden werden mehrere Verfahren beschrieben, mit deren Hilfe Sie eine einheitliche Grafik innerhalb eines Diagramms und diagrammübergreifend erzielen können.

Visuelle Kontinuität durch Ausrichten der Blöcke

• Um den Arbeitsaufwand nach dem Erstellen des Diagramms zu reduzieren, achten Sie auf eine gute Leserlichkeit des Blocklayouts, indem Sie die Blöcke während der Arbeit häufig ausrichten.

• Wenn andere Benutzer mit Ihrem Diagramm arbeiten sollen, sorgen Sie vor der Bereitstellung für ein Layout mit einem leicht verständlichen Ablauf aus Blöcken und Drähten.

• Um die Ausrichtung zu erleichtern, verwenden Sie die Funktion Blocklayout bereinigen zur automatischen Ausrichtung des Diagramms. Durch manuelles Ausrichten erzielen Sie allerdings präzisere Ergebnisse.

1. Ungeordnetes Diagramm

2. Ausgerichtetes Diagramm

Informationen zur Verwendung der Blockausrichtung finden Sie unter .

Aussagekräftige Beschriftung durch Umbenennen

• Durch Umbenennen von Eingaben machen Sie Ihr Diagramm für andere Benutzer leicht verständlich, insbesondere, wenn Objekte, die sich außerhalb des Bildschirms befinden, verbunden werden sollen.

• Benennen Sie nach Möglichkeit nicht Blöcke, sondern Eingaben um. Als Alternative dazu können Sie einen benutzerdefinierten Block aus einer Gruppe von Blöcken erstellen und ihn umbenennen. Dabei ist ersichtlich, dass andere Elemente darin enthalten sind.

1. Eingaben für die Bearbeitung der Oberfläche

2. Eingaben für Architekturparameter

3. Eingaben für das Skript zur Simulation der Entwässerung

Um einen Block umzubenennen, klicken Sie mit der rechten Maustaste auf seinen Namen, und wählen Sie Block umbenennen.

Erläuterungen durch Anmerkungen

• Fügen Sie eine Anmerkung hinzu, wenn ein Bestandteil des Diagramms eine Erläuterung in Klartext benötigt, die nicht in den Blöcken selbst gegeben werden kann.

• Fügen Sie eine Anmerkung hinzu, wenn eine Sammlung von Blöcken oder eine Gruppe zu groß oder zu komplex ist und nicht direkt verstanden werden kann.

1. Anmerkung zur Beschreibung des Teils des Programms, der Rohwerte der Verschiebungsstrecken zurückgibt

2. Anmerkung zur Beschreibung des Codes, der diese Werte einer Sinuswelle zuordnet

Informationen zum Hinzufügen einer Anmerkung finden Sie unter .

Laufendes Testen

Es ist wichtig, während der Entwicklung des visuellen Skripts zu überprüfen, ob die zurückgegebenen Ergebnisse Ihren Erwartungen entsprechen. Nicht alle Fehler oder Probleme lassen das Programm sofort fehlschlagen, dies gilt insbesondere für Nullwerte, die sich erst viel später im weiteren Verlauf auswirken können. Diese Vorgehensweise wird auch im Zusammenhang mit Textskripts unter beschrieben. Das folgende Verfahren hilft Ihnen, sicherzustellen, dass Sie das gewünschte Ergebnis erzielen:

Überwachen von Daten mit Beobachtungs- und Vorschaublöcken

• Verwenden Sie während der Entwicklung des Programms Beobachtungs- oder Vorschaublöcke,** um zu überprüfen, ob wichtige Ausgaben das erwartete Ergebnis zurückgeben.**

Mithilfe der Beobachtungsblöcke werden verglichen:

1. Die Rohwerte der Verschiebungsstrecken

2. Die durch die Sinusgleichung geleiteten Werte

Informationen zur Verwendung der Beobachtungsfunktion finden Sie unter .

Wiederverwendbarkeit sicherstellen

Ihr Programm wird sehr wahrscheinlich irgendwann auch von anderen Benutzern geöffnet werden, selbst wenn Sie unabhängig voneinander arbeiten. Diese Benutzer sollten in der Lage sein, anhand der Ein- und Ausgaben rasch zu bestimmen, was das Programm benötigt und was es produziert. Dies ist besonders bei der Entwicklung benutzerdefinierter Blöcke wichtig, die an die Dynamo-Community weitergegeben und in Programmen anderer Benutzer verwendet werden sollen. Mit diesen Vorgehensweisen erhalten Sie zuverlässige, wiederverwendbare Programme und Blöcke.

Verwalten der Ein- und Ausgaben

• Für eine optimale Lesbarkeit und Skalierbarkeit sollten Sie die Ein- und Ausgaben auf ein Minimum beschränken.

• Versuchen Sie, eine Strategie zur Entwicklung der Logik zu erarbeiten, indem Sie zunächst einen groben Plan ihrer Funktionsweise erstellen, bevor Sie den ersten Block im Ansichtsbereich einfügen. Behalten Sie während der Arbeit an diesem Plan im Auge, welche Ein- und Ausgaben in den Skripts verwendet werden sollen.

Verwenden von Voreinstellungen zum Einbetten von Eingabewerten

• Falls bestimmte Optionen oder Bedingungen vorhanden sind, die Sie in das Diagramm einbetten möchten, empfiehlt es sich, Voreinstellungen für den schnellen Zugriff zu verwenden.

• Mithilfe von Voreinstellungen können Sie darüber hinaus durch Caching spezifischer Schiebereglerwerte die Komplexität in Diagrammen mit langen Laufzeiten reduzieren.

Informationen zur Verwendung von Voreinstellungen finden Sie unter .

Verwenden von benutzerdefinierten Blöcken als Container für Programme

• Verwenden Sie einen benutzerdefinierten Block, wenn das Programm in einem einzelnen Container zusammengefasst werden kann.

• Verwenden Sie einen benutzerdefinierten Block, wenn ein Teil des Diagramms oft in anderen Programmen wiederverwendet werden soll.

• Verwenden Sie einen benutzerdefinierten Block, wenn Sie eine Funktion für die Dynamo-Community bereitstellen möchten.

Indem Sie das Programm zur Verschiebung von Punkten in einem benutzerdefinierten Block zusammenfassen, wird dieses zuverlässige, spezielle Programm portierbar und wesentlich leichter verständlich. Aussagekräftige Namen für die Eingabeanschlüsse erleichtern es anderen Benutzern, die Verwendungsweise des Blocks zu verstehen. Achten Sie darauf, für jede Eingabe eine Beschreibung und den erforderlichen Datentyp anzugeben.

1. Bestehendes Programm für Attraktor

2. Benutzerdefinierter Block, in dem dieses Programm, PointGrid, enthalten ist

Weitere Informationen zur Verwendung benutzerdefinierter Blöcke finden Sie unter .

Vorlagen erstellen

• Mithilfe von Vorlagen können Sie Grafikstandards für alle Ihre visuellen Diagramme einrichten, um sie Ihren Kollegen in einheitlicher, verständlicher Weise bereitzustellen.

• Beim Erstellen einer Vorlage können Sie Gruppenfarben und Schriftgrößen standardisieren, um Typen von Arbeitsabläufen oder Datenaktionen zu kategorisieren.

• Sie können beim Erstellen einer Vorlage sogar Beschriftung, Farbe oder Stil für die Unterscheidung zwischen Frontend- und Backend-Arbeitsabläufen in Ihrem Diagramm standardisieren.

1. Die Benutzeroberfläche (das Frontend) des Programms umfasst den Projektnamen, die Eingabe-Schieberegler und die Importgeometrie.

2. Backend des Programms.

3. Kategorien für Gruppenfarben (allgemeines Design, Eingaben, Python-Skripts, importierte Geometrie)

Übung – Dach in der Architektur

Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.

Eine vollständige Liste der Beispieldateien finden Sie im Anhang.

Sie haben eine Reihe optimaler Verfahren festgelegt und wenden diese jetzt auf ein rasch zusammengestelltes Programm an. Das Programm erstellt zwar wie vorgesehen das Dach, das Diagramm stellt jedoch eher eine „Mind-Map“ des Autors dar. Ihm fehlt die Struktur, und es gibt keine Beschreibung des Verwendungszwecks. Sie ordnen, beschreiben und analysieren das Programm unter Verwendung der optimalen Verfahren so, dass andere Benutzer seine Verwendungsweise verstehen.

Das Programm funktioniert, aber dem Diagramm fehlt Struktur.

Bestimmen Sie als Erstes die Daten und die Geometrie, die das Programm zurückgibt.

Um logische Unterteilungen, d. h. Modularität zu erzielen, müssen Sie die Stellen kennen, an denen wesentliche Änderungen an den Daten erfolgen. Analysieren Sie den Rest des Programms mithilfe von Beobachtungsblöcken, um festzustellen, ob Gruppen erkennbar sind, bevor Sie mit dem nächsten Schritt fortfahren.

1. Dieser Codeblock mit einer mathematischen Gleichung scheint ein wichtiger Bestandteil des Programms zu sein. Ein Watch-Block wird angezeigt, der Listen von Verschiebungsstrecken zurückgibt.

2. Der Zweck dieses Bereichs ist nicht ohne Weiteres ersichtlich. Die Anordnung der True-Werte auf der Listenebene L2 aus BoundingBox.Contains und das Vorhandensein von List.FilterByBoolMask lassen darauf schließen, dass ein Teil des Punktrasters als Beispiel entnommen wird.

Nachdem Sie die zugrunde liegenden Bestandteile des Programms verstanden haben, fassen Sie sie in Gruppen zusammen.

Gruppen ermöglichen dem Benutzer die visuelle Unterscheidung der Programmbestandteile.

1. 3D-Grundstücksmodell importieren

2. Punktraster entsprechend der Sinusgleichung verschieben

3. Bestandteil des Punktrasters als Beispiel

Nachdem Sie die Gruppen eingerichtet haben, richten Sie die Blöcke innerhalb des Diagramms auf einheitliche Weise aus.

Eine einheitliche Darstellung macht den Programmablauf und die impliziten Beziehungen zwischen den Blöcken für den Benutzer leichter erkennbar.

Machen Sie das Programm noch leichter verständlich, indem Sie eine weitere Ebene grafischer Verbesserungen hinzufügen. Fügen Sie Anmerkungen hinzu, mit denen Sie die Funktionsweise eines bestimmten Programmteils beschreiben, geben Sie den Eingaben benutzerdefinierte Namen, und weisen Sie verschiedenen Typen von Gruppen Farben zu.

Diese grafischen Verbesserungen geben dem Benutzer genaueren Aufschluss über den Verwendungszweck des Programms. Die unterschiedlichen Farben der Gruppen helfen bei der Unterscheidung von Eingaben und Funktionen.

1. Anmerkungen

2. Eingaben mit aussagekräftigen Namen

Bevor Sie damit beginnen, das Programm zusammenzufassen, suchen Sie nach einem geeigneten Platz für den Python-Skript-Entwässerungssimulator. Verbinden Sie die Ausgabe der ersten skalierten Dachoberfläche mit der dazugehörigen Skripteingabe.

Durch die Entscheidung, das Skript an dieser Stelle des Programms zu integrieren, wird erreicht, dass die Entwässerungssimulation für die einfache Originaloberfläche des Dachs durchgeführt wird. Diese spezielle Oberfläche wird nicht in der Vorschau angezeigt, aber durch diesen Schritt entfällt die separate Auswahl der oberen Fläche in der gefasten PolySurface.

1. Quellgeometrie für Skripteingabe

2. Python-Block

3. Eingabe-Schieberegler

Damit befinden sich alle Elemente an ihrem Platz, und als Nächstes vereinfachen Sie das Diagramm.

Durch Zusammenfassen des Programms mit Block zu Code und benutzerdefinierten Blöcken haben Sie das Diagramm erheblich verkleinert. Die Gruppen für die Erstellung der Dachoberfläche und der Wände wurden in Code konvertiert, da sie für dieses Programm hochspezifisch sind. Die Gruppe zur Verschiebung von Punkten ist in einem benutzerdefinierten Block eingeschlossen, da sie auch in anderen Programmen verwendet werden könnte. Erstellen Sie in der Beispieldatei Ihren eigenen benutzerdefinierten Block aus der Gruppe zur Verschiebung von Punkten.

1. Benutzerdefinierter Block als Container für die Gruppe zur Verschiebung von Punkten

2. Block zu Code für die Zusammenfassung der Gruppen zum Erstellen der Oberfläche für das Dach in der Architektur und der Wände

Im letzten Schritt erstellen Sie Voreinstellungen für als Beispiele zu verwendende Dachformen.

Diese Eingaben sind die wesentlichen Angaben zum Steuern der Dachform und geben den Benutzern Hinweise auf die Möglichkeiten des Programms.

Das Programm mit Ansichten zweier Voreinstellungen.

Die Muster der Dachentwässerung bieten dem Benutzer eine analytische Ansicht der jeweiligen Voreinstellungen.

Dieser Teil des Leitfadens ist quasi ein laufendes Protokoll für optimale Verfahren. Wir stellen hier eine Reihe von Vorgehensweisen vor, die sich unserer Erfahrung nach und bei Recherchen als besonders nützlich für hochwertige parametrische Arbeitsabläufe erwiesen haben. Als Designer und Programmierer legen wir einen Qualitätsmaßstab mit den Hauptkriterien einfache Wartung, Zuverlässigkeit, Benutzerfreundlichkeit und Effizienz unserer Werkzeuge zugrunde. In diesen optimalen Verfahren werden zwar spezielle Beispiele für visuelle oder textbasierte Skripterstellung gegeben, ihre Prinzipien gelten jedoch für alle Programmierumgebungen und können als Anregung für viele berechnungsbasierte Arbeitsabläufe dienen.

Der visuelle Programmierungsprozesses ist eine äußerst leistungsstarke, kreative Aktivität, wobei der Programmablauf und die wichtigsten Benutzereingaben jedoch schnell durch ihre Komplexität und/oder das Layout des Arbeitsbereichs unübersichtlich werden können. Machen Sie sich im Folgenden mit einigen bewährten Verfahren für die Verwaltung von Programmen vertraut.

Ausrichtung

Nachdem Sie bereits zahlreiche Blöcke zum Arbeitsbereich hinzugefügt haben, möchten Sie sie möglicherweise neu anordnen, um das Layout übersichtlicher zu gestalten. Indem Sie mehrere Blöcke auswählen und mit der rechten Maustaste in den Arbeitsbereich klicken, wird ein Popup-Fenster mit dem Menü Auswahl ausrichten angezeigt, das Optionen zum Ausrichten und Verteilen in X- und Y-Richtung enthält.

1. Wählen Sie mehrere Blöcke aus.

2. Klicken Sie mit der rechten Maustaste in den Arbeitsbereich.

3. Verwenden Sie die Optionen von Auswahl ausrichten.

Anmerkungen

Mit etwas Erfahrung werden Sie auch in der Lage sein, visuelle Programme zu "lesen", indem Sie die Blocknamen überprüfen und den Programmablauf verfolgen. Für Benutzer unterschiedlicher Erfahrungsniveaus hat es sich ebenfalls bewährt, aussagekräftige Beschriftungen und Beschreibungen einzufügen. In Dynamo ist hierfür ein Notes-Block mit einem bearbeitbaren Textfeld verfügbar. Für das Hinzufügen von Anmerkungen zum Arbeitsbereich bestehen zwei Möglichkeiten:

1. Navigieren Sie zum Menü Datei > Anmerkung erstellen.

2. Die Tastenkombination Strg+W verwenden

Nachdem Sie eine Anmerkung zum Arbeitsbereich hinzugefügt haben, wird ein Popup-Textfeld angezeigt, in dem Sie den Text für die Anmerkung bearbeiten können. Nach der Erstellung einer Anmerkung können Sie sie bearbeiten, indem Sie darauf doppelklicken oder mit der rechten Maustaste auf den Note-Block klicken.

Gruppieren

Je umfangreicher ein visuelles Programm wird, desto hilfreicher kann es sein, größere Schritte zu identifizieren, die ausgeführt werden. Sie können größere Sammlungen von Blöcken durch ein Rechteck mit farbigem Hintergrund und einen Titel zu einer Gruppe zusammenfassen. Für das Erstellen einer Gruppe mit mehreren ausgewählten Blöcken sind drei Möglichkeiten verfügbar:

1. Navigieren Sie zum Menü Datei > Gruppe erstellen.

2. Die Tastenkombination Strg+G verwenden

3. Klicken Sie mit der rechten Maustaste in den Arbeitsbereich und wählen Sie "Gruppe erstellen".

Nachdem Sie eine Gruppe erstellt haben, können Sie deren Einstellungen wie den Titel und die Farbe bearbeiten.

Hier sehen Sie ein Beispiel für ein Programm mit hinzugefügten Anmerkungen und Gruppen:

1. Anmerkung: "Rasterparameter"

2. Anmerkung: "Rasterpunkte"

3. Gruppe: "Raster aus Punkten erstellen"

4. Gruppe: "Attraktorpunkt erstellen"

Auf dieser Seite finden Sie einige Faustregeln für das effiziente Arbeiten mit großen Datensätzen in Dynamo. Sie können die Tipps hoffentlich verwenden, um Engpässe in Ihren Diagrammen zu identifizieren, sodass Ihr Diagramm in wenigen Minuten statt in mehreren Stunden ausgeführt werden kann.

Inhalt:

• Geometriegenerierung und Tessellation im Vergleich

• Speichernutzung

• Revit API

Geometriegenerierung und Tessellation im Vergleich

In Dynamo sind das Erstellen eines Geometrieobjekts und das Zeichnen zwei völlig unterschiedliche Ereignisse. Im Allgemeinen ist das Erstellen von Geometrie viel schneller und erfordert weniger Speicherplatz als das Zeichnen des Objekts. Sie können sich die Geometrie als eine Liste von Maßen vorstellen, um einen Anzug herzustellen, während die Tessellation der Anzug selbst ist. Anhand seiner Maße können Sie ziemlich viel über den Anzug aussagen: wie lang die Arme sind, wie viel er kostet usw., aber Sie müssen den fertigen Anzug fast immer sehen und anprobieren, um zu erfahren, ob er passt. Auf ähnliche Weise können Sie bei nicht tessellierter Geometrie den Begrenzungsrahmen, die Fläche und das Volumen bestimmen, sie mit anderer Geometrie schneiden und im SAT- oder Revit-Format exportieren. Sie müssen die Geometrie jedoch fast immer tessellieren, um ein Gefühl dafür zu bekommen, ob sie korrekt ist oder nicht.

Wenn Ihr Dynamo-Diagramm viele Objekte enthält und während der Ausführung langsamer wird, können Sie möglicherweise die Tessellationsschritte aus dem Diagramm entfernen, um den Vorgang zu beschleunigen.

Geometrieblöcke in Dynamo werden immer tesselliert*. Somit stehen Ihnen zwei Optionen für die Arbeit mit nicht tessellierter Geometrie zur Verfügung: Python-Blöcke und ZeroTouch-Blöcke. Solange Sie ein Geometrieobjekt nicht aus Ihrem Python- oder ZeroTouch-Block zurückgeben, wird die Geometrie nicht tesselliert. Wenn Ihr Diagramm beispielsweise mehrere Punktblöcke aufweist, die mit mehreren Linienblöcken verbunden sind, die mit mehreren Erhebungsblöcken verbunden sind, die mit mehreren Verdickungsblöcken verbunden sind, wird die Geometrie bei jedem Schritt tesselliert. Stattdessen können Sie diese Logik in einem Python- oder ZeroTouch-Block bündeln und nur das endgültige Objekt aus dem Block zurückgeben.

Weitere Informationen zur Verwendung von ZeroTouch-Blöcken finden Sie im Abschnitt in diesem Primer.

Speichernutzung

Wenn Sie keine Geometrie mehr tessellieren, kann durch überschüssige Geometrieansammlung möglicherweise ein Speicherengpass entstehen. Geometrieobjekte in Dynamo benötigen bei ihrer Erstellung eine geringe, aber nicht unerhebliche Menge an Speicher. Wenn Sie mit Hunderttausenden oder gar Millionen von Objekten arbeiten, kann dies zu einem Absturz von Dynamo oder Revit führen. In Dynamo Version 2.5 und höher wird dies implizit durch das Verwerfen nicht verwendeter Objekte gelöst. Wenn Sie jedoch eine Version vor Version 2.5 verwenden, besteht eine Möglichkeit zum Vermeiden der Erstellung von übermäßig viel Geometrie darin, die Objekte zu verwerfen, wenn Sie sie nicht mehr benötigen. Nehmen wir beispielsweise an, Sie würden Hunderttausende von NurbsCurves-Objekten erstellen, von denen jedes Dutzende von Punkten erfordert. Eine Möglichkeit, sie zu erstellen, ist eine zweidimensionale Liste in Dynamo, die in einen NurbsCurve.ByPoints-Block eingegeben wird. Dazu müssen jedoch Millionen von Punkten erstellt werden. Eine andere Möglichkeit ist die Verwendung eines Python- oder ZeroTouch-Blocks. In diesem Block können Sie ein Dutzend Punkte erstellen, diese in den Block NurbsCurve.ByPoints eingeben und dann das Dutzend Punkte mit dem Methodenaufruf .Dispose() entfernen. Weitere Informationen zur Verwendung von ZeroTouch-Blöcken finden Sie im Abschnitt in diesem Primer. Wenn Sie die Geometrieobjekte nach der Erstellung entfernen, kann der verwendete Speicherplatz unter bestimmten Umständen drastisch reduziert werden. Obwohl dies für Benutzer ab Dynamo 2.5 kein Problem mehr ist, wird dennoch empfohlen, dass die Benutzer Geometrie explizit löschen, wenn der Anwendungsfall es erfordert, zu einem bestimmten Zeitpunkt den verwendeten Arbeitsspeicher zu reduzieren. Weitere Informationen zu den neuen Stabilitätsfunktionen ab Dynamo 2.5 finden Sie im Artikel zu .

Revit API

Wenn Sie Objekte in einem ZeroTouch- oder Python-Block generell immer verwerfen und dennoch Speicher- oder Leistungsprobleme auftreten, müssen Sie Dynamo möglicherweise vollständig umgehen und Revit-Objekte direkt über die API erstellen. Sie können beispielsweise eine Excel-Datei auf Punktinformationen analysieren und diese Informationen verwenden, um XYZ- und andere Revit-Elemente über die entsprechende API zu erstellen. An diesem Punkt wird Revit zum ultimativen Engpass, was sich nicht vermeiden lässt.

Diese Referenzseite bietet ausführlichere Informationen zu Codebibliotheken, Beschriftungen und Stil aus den optimalen Verfahren, die unter „Vorgehensweisen zur Skripterstellung“ beschrieben wurden. Zur Verdeutlichung der im Folgenden beschriebenen Konzepte wird hier Python verwendet, es gelten jedoch dieselben Prinzipien sowohl in Python als auch in C# (Zerotouch), allerdings mit unterschiedlicher Syntax.

Wahl geeigneter Bibliotheken

Standardbibliotheken sind außerhalb von Dynamo verfügbar und liegen in den Programmiersprachen Python und C# (Zerotouch) vor. Dynamo verfügt darüber hinaus über eigene Bibliotheken, die direkt seiner Blockhierarchie entsprechen und es dem Benutzer ermöglichen, alle Abläufe, die aus Blöcken und Drähten konstruiert werden können, auch in Form von Code zu erstellen. Der folgende Leitfaden zeigt, worauf Sie in den einzelnen Dynamo-Bibliotheken Zugriff erhalten und wann Sie eine Standardbibliothek verwenden sollten.

Standardbibliotheken und Dynamo-Bibliotheken

• Standardbibliotheken in Python und C# können zum Erstellen erweiterter Daten- und Ablaufstrukturen in der Dynamo-Umgebung genutzt werden.

• Dynamo-Bibliotheken entsprechen direkt der Blockhierarchie zum Erstellen von Geometrie und anderer Dynamo-Objekte.

Dynamo-Bibliotheken

1. ProtoGeometry*

   • Funktionen: Bogen, Begrenzungsrahmen, Kreis, Kegel, Koordinatensystem, Quader, Kurve, Zylinder, Kante, Ellipse, elliptischer Bogen, Fläche, Geometrie, Spirale, Indexgruppe, Linie, Netz, NURBS-Kurve, NURBS-Oberfläche, Ebene, Punkt, Polygon, Rechteck, Volumenkörper, Kugel, Oberfläche, Topologie, TSpline, UV, Vektor, Scheitelpunkt.

   • Importverfahren: import Autodesk.DesignScript.Geometry

Sorgfältige Kennzeichnung

Beim Erstellen von Skripts werden Elemente wie Variablen, Typen, Funktionen und andere Objekte laufend mit IDs gekennzeichnet. Durch dieses System der symbolischen Schreibweise können Sie beim Entwickeln von Algorithmen ganz einfach über Beschriftungen, die in der Regel aus einer Folge von Zeichen bestehen, auf Informationen verweisen. Die aussagekräftige Benennung von Elementen spielt eine wichtige Rolle beim Erstellen von Code, den sowohl andere Benutzer als auch Sie selbst zu einem späteren Zeitpunkt problemlos lesen und verstehen können. Beachten Sie beim Benennen von Elementen in Ihrem Skript die folgenden Tipps:

Sie können Abkürzungen verwenden, müssen diese jedoch in einem Kommentar erläutern:

Vermeiden Sie überzählige Beschriftungen:

Verwenden Sie für Variablennamen positive anstatt negativer Logik:

Geben Sie der Rückwärtsschreibweise den Vorzug:

Dies ist unter dem Aspekt der Struktur sinnvoller.

Verwenden Sie Aliasse zur Verkürzung überlanger und häufig wiederholter Ketten:

Aliasse führen rasch zu verwirrenden und nicht standardmäßigen Programmen.

Verwenden Sie nur die erforderlichen Wörter:

Man muss die Dinge so einfach wie möglich machen. Aber nicht einfacher. - Albert Einstein

Einheitlicher Stil

Im Allgemeinen gibt es beim Programmieren von Anwendungen jeder Art mehrere Möglichkeiten. Ihr „persönlicher Stil“ beim Schreiben von Skripts ist daher das Ergebnis zahlloser Detailentscheidungen für oder gegen einzelne Schritte während der Arbeit. Wie leserlich und leicht zu warten Ihr Code ist, ist dennoch gleichermaßen das direkte Ergebnis seiner internen Kohärenz und der Einhaltung allgemeiner Stilkonventionen. Als Faustregel gilt, dass Code, der an zwei unterschiedlichen Stellen gleich aussieht, auch dieselbe Funktion ausführen muss. Die folgenden Tipps sollen beim Schreiben von verständlichem und einheitlichem Code helfen.

Namenskonventionen: (Wählen Sie eine der folgenden Konventionen für jede Art von Element in Ihrem Code und behalten Sie sie konsequent bei.)

• Variablen, Funktionen, Methoden, Pakete, Module: lower_case_with_underscores

• Objektklassen und Ausnahmen: CapWords

• Geschützte Methoden und interne Funktionen: _single_leading_underscore(self, ...)

Tipp: Vermeiden Sie Variablen, die aus nur einem Buchstaben bestehen (insbesondere L, O, I), ausgenommen in sehr kurzen Blöcken, wenn die Bedeutung unmissverständlich aus dem unmittelbaren Kontext hervorgeht.

Verwendung leerer Zeilen:

• Fügen Sie vor und nach Definitionen von Funktionen auf oberster Ebene und von Klassen je zwei Leerzeilen ein.

  • Schließen Sie Methodendefinitionen innerhalb einer Klasse in einfache leere Zeilen ein.

  • Zusätzliche Leerzeilen können (in Maßen) dazu verwendet werden, um Gruppen zusammengehöriger Funktionen voneinander zu trennen.

Vermeiden Sie überflüssigen Leerraum an den folgenden Stellen:

• direkt in runden, geschweiften oder eckigen Klammern:

• unmittelbar vor einem Komma, Semikolon oder Doppelpunkt:

• unmittelbar vor der öffnenden Klammer am Anfang der Liste der Argumente für einen Funktionsaufruf:

• unmittelbar vor der öffnenden Klammer am Anfang von Indizierungen und Teilbereichen:

Beachten Sie die Länge:

• Sie sollte 79 Zeichen möglichst nicht überschreiten.

• Indem Sie die Breite der benötigten Editor-Fenster beschränken, können Sie mehrere Dateien nebeneinander anzeigen. Dies ist besonders bei der Verwendung von Codeprüfungs-Tools hilfreich, die die beiden Versionen in benachbarten Spalten zeigen.

• Lange Zeilen können umbrochen und auf mehrere Zeilen verteilt werden, indem Sie Ausdrücke in Klammern setzen:

Vermeiden Sie allzu offensichtliche und überflüssige Kommentare:

• Durch weniger Kommentare erhalten Sie zuweilen leichter lesbaren Code. Dies gilt insbesondere, wenn Sie infolgedessen auf aussagekräftige Symbolnamen achten müssen.

• Durch sinnvolle Arbeitsgewohnheiten beim Schreiben von Code benötigen Sie weniger Kommentare:

Tipp: Kommentare beantworten die Frage nach dem Warum, Code nach dem Wie.

Orientieren Sie sich an Open-Source-Code:

• Open-Source-Projekte werden durch die Zusammenarbeit vieler Entwickler vorangetrieben. In diesen Projekten ist die leichte Verständlichkeit des Codes unverzichtbar, damit das Team so effizient wie möglich zusammenarbeiten kann. Aus diesem Grund empfiehlt es sich, den Quellcode dieser Projekte durchzusehen und aus der Arbeitsweise dieser Entwickler Anregungen zu schöpfen.

• Verbessern Sie Ihre Konventionen:

  • Überprüfen Sie für jede einzelne Konvention. ob sie für den aktuellen Verwendungszweck geeignet ist.

Standards für C# (Zerotouch)

Auf den folgenden Wiki-Seiten finden Sie Anweisungen zum Schreiben von C# für Zerotouch und wie Sie zu Dynamo beitragen können:

• Im folgenden Wiki werden allgemeine Kodierungsstandards zum Dokumentieren und Testen Ihres Codes beschrieben:

• Im folgenden Wiki wird speziell auf Namenskonventionen für Bibliotheken, Kategorien, Blocknamen, Anschlussnamen und Abkürzungen eingegangen:

Nicht verwaltete Objekte:

Wenn Sie die Geometriebibliothek von Dynamo (ProtoGeometry) in Python oder C# verwenden, werden von Ihnen erstellte Geometrieobjekte nicht durch die virtuelle Maschine verwaltet, und der Speicher für viele dieser Objekte muss manuell bereinigt werden. Zum Bereinigen nativer oder nicht verwalteter Objekte können Sie die Dispose-Methode oder das using-Schlüsselwort verwenden. Einen Überblick hierzu finden Sie in diesem Wiki-Eintrag: .

Sie müssen nur diejenigen nicht verwalteten Ressourcen beseitigen, die Sie nicht in das Diagramm ausgeben und auf die keine Verweise gespeichert werden. Für den Rest dieses Abschnitts werden diese Objekte als temporäre Geometrie bezeichnet. Das Codebeispiel unten zeigt ein Beispiel für diese Klasse von Objekten. Diese Zerotouch C#-Funktion namens singleCube gibt einen einzelnen Würfel zurück, erstellt jedoch während ihrer Ausführung 10000 zusätzliche Würfel. Nehmen wir an, dass diese zusätzliche Geometrie als temporäre Geometrie zur Konstruktion verwendet wurde.

Diese Zerotouch-Funktion bringt Dynamo mit großer Wahrscheinlichkeit zum Absturz. Es wurden 10000 Volumenkörper erstellt, jedoch nur einer davon gespeichert, und nur dieser wurde zurückgegeben. Stattdessen sollten alle temporären Würfel, ausgenommen derjenige, der zurückgegeben werden soll, beseitigt werden. Der zurückzugebende Würfel darf nicht beseitigt werden, da er an das Diagramm weitergeleitet und von anderen Blöcken verwendet werden soll.

Der feste Code sieht ungefähr so aus:

Im Allgemeinen müssen Sie nur Geometrie wie Surfaces, Curves und Solids entfernen. Um jedoch sicher zu sein, können Sie alle Geometrietypen (Vectors, Points, CoordinateSystems) entfernen.

Die textbasierte Skripterstellung innerhalb der Umgebung für visuelle Skripterstellung ermöglicht leistungsstarke und visuelle Beziehungen mithilfe von DesignScript, Python und ZeroTouch (C#). Die Benutzer können in ein und demselben Arbeitsbereich Elemente wie Eingabe-Schieberegler bereitstellen, umfangreiche Abläufe in DesignScript zusammenfassen sowie in Python oder C# auf leistungsstarke Werkzeuge und Bibliotheken zugreifen. Diese Vorgehensweisen können bei effizientem Einsatz die Möglichkeiten zur benutzerdefinierten Anpassung, die Verständlichkeit und die Effizienz des gesamten Programms erheblich steigern. Die im Folgenden beschriebenen Richtlinien helfen Ihnen dabei, Ihre visuellen Skripts um Textskripte zu ergänzen.

Wann sollten Skripts verwendet werden?

Mit Textskripts können Sie komplexere Beziehungen erstellen als durch visuelle Programmierung, jedoch sind beiden Verfahren auch zahlreiche Funktionen gemeinsam. Dies ist sinnvoll, da Blöcke letzten Endes vorgefertigter Code sind. Es ist wahrscheinlich möglich, ein ganzes Dynamo-Programm in DesignScript oder Python zu schreiben. Die visuellen Skripte kommen jedoch zum Einsatz, weil die Benutzeroberfläche mit Blöcken und Drähten eine intuitive Darstellung des Ablaufs in grafischer Form bietet. Indem Sie sich klarmachen, inwiefern die Möglichkeiten von Textskripts über diejenigen visueller Skripts hinausgehen, erhalten Sie eine wichtige Grundlage für die Entscheidung, wann Textskripts verwendet werden sollten, ohne dabei die intuitive Arbeitsweise mit Blöcken und Drähten aufgeben zu müssen. Die folgenden Richtlinien beschreiben, wann und in welcher Sprache Skripts erstellt werden sollten.

Verwenden Sie Textskripts für:

• Schleifen

• Rekursionen

• Zugriff auf externe Bibliotheken

Wählen Sie eine Sprache:

Parametrischer Denkansatz

Bei der Skripterstellung in Dynamo, einer zwangsläufig parametrischen Umgebung, ist es sinnvoll, Ihren Code bezogen auf die Blöcke und Drähte zu strukturieren, in denen er zum Einsatz kommt. Betrachten Sie den Block mit Ihrem Textskript als einen normalen Block wie andere Blöcke im Programm mit spezifischen Eingaben, einer Funktion und einer erwarteten Ausgabe. Dadurch stellen Sie dem Code im Block direkt eine kleine Gruppe von Variablen zur Verarbeitung zur Verfügung, was für ein ordnungsgemäßes parametrisches System entscheidend ist. Im Folgenden finden Sie einige Richtlinien für eine bessere Integration von Code in ein visuelles Programm.

Identifizieren der externen Variablen:

• Versuchen Sie, die gegebenen Parameter in der Designaufgabe so festzulegen, dass Sie ein Modell direkt auf Basis dieser Daten konstruieren können.

• Identifizieren Sie die Variablen, bevor Sie mit dem Erstellen von Code beginnen:

  • Eine auf das absolut Notwendige beschränkte Gruppe von Eingaben

Vor dem Schreiben des Codes wurden mehrere Variablen festgelegt.

1. Die in der Simulation dem Regen ausgesetzte Oberfläche.

2. Die gewünschte Anzahl Regentropfen (Agents).

3. Die von den Regentropfen zurückgelegte Strecke.

Entwerfen der internen Beziehungen:

• Das parametrische Prinzip ermöglicht die Bearbeitung bestimmter Parameter oder Variablen, um das Endergebnis einer Gleichung zu ändern oder zu beeinflussen.

• Versuchen Sie stets, Objekte in Ihrem Skript, die logisch miteinander verbunden sind, als Funktionen voneinander zu definieren. Auf diese Weise wird bei einer Änderung eines der Objekte auch das andere proportional dazu aktualisiert.

• Beschränken Sie die Anzahl der Eingaben, indem Sie nur die wichtigsten Parameter bereitstellen:

Die Codemodule aus dem Beispiel unter .

1. Eingaben.

2. Interne Variablen für das Skript.

3. Eine Schleife, die diese Eingaben und Variablen für ihre Funktion nutzt.

Vermeiden von Wiederholungen (das DRY-Prinzip – Don't repeat yourself):

• Falls es mehrere Möglichkeiten für denselben Vorgang in Ihrem Skript gibt, werden die doppelt vorhandenen Darstellungen schließlich asynchron, was die Wartung extrem schwierig macht, die Faktorisierung verschlechtert und interne Widersprüche verursacht.

• Das DRY-Prinzip besagt, dass jede für jede Information genau eine eindeutige und maßgebliche Darstellung im System vorhanden sein muss.

  • Wird dieses Prinzip erfolgreich angewendet, erfolgen Änderungen an allen verbundenen Elementen in Ihrem Skript in vorhersehbarer und einheitlicher Weise und Elemente, die nicht miteinander verbunden sind, haben keine logischen Auswirkungen aufeinander.

Modulares Strukturieren

Mit zunehmender Länge und Komplexität des Codes ist das Grundkonzept bzw. der Gesamtalgorithmus immer schwieriger zu entziffern. Es wird zudem schwieriger, zu verfolgen, welche spezifischen Vorgänge ablaufen (und wo dies geschieht), bei Fehlfunktionen den Fehler zu finden, anderen Code zu integrieren und Entwicklungsaufgaben zuzuweisen. Um diese Probleme zu vermeiden, ist es sinnvoll, Code in Modulen zu erstellen: Bei diesem Organisationsverfahren wird Code anhand der jeweils ausgeführten Aufgaben aufgegliedert. Im Folgenden finden Sie einige Tipps, die es Ihnen erleichtern sollen, durch Modularisierung leichter zu verwaltende Skripts zu erstellen.

Schreiben von Code in Modulen:

• Ein Modul ist eine Sammlung von Code, der eine bestimmte Aufgabe ausführt, ähnlich wie ein Dynamo-Block im Arbeitsbereich.

• Dabei kann es sich um beliebigen Code handeln, der visuell von angrenzendem Code abgetrennt sollte (eine Funktion, eine Klasse, eine Gruppe von Eingaben oder die von Ihnen importierten Bibliotheken).

• Durch die Entwicklung von Code in Form von Modulen können Sie sowohl die visuellen, intuitiven Eigenschaften von Blöcken als auch die komplexen Beziehungen nutzen, die nur mit Textskripts zu erreichen sind.

Diese Schleifen rufen eine Klasse namens „agent“ auf, die in dieser Übung entwickelt wird.

1. Ein Code-Modul, das den Startpunkt jedes Agents definiert.

2. Ein Code-Modul, das den Agent aktualisiert.

3. Ein Code-Modul, das den Pfad zeichnet, dem der Agent folgt.

Erkennen der Wiederverwendung von Code:

• Wenn Sie feststellen, dass Ihr Code dieselbe (oder eine sehr ähnliche) Aufgabe an mehr als einer Stelle ausführt, suchen Sie nach Möglichkeiten, ihn zu einer Funktion zusammenzufassen, die aufgerufen werden kann.

• „Manager“-Funktionen steuern den Programmablauf und enthalten in erster Linie Aufrufe an „Worker“-Funktionen, die Details auf unteren Ebenen, etwa das Verschieben von Daten zwischen Strukturen, verarbeiten.

In diesem Beispiel werden Kugeln erstellt, deren Radien und Farben vom Z-Wert ihrer Mittelpunkte abhängig sind.

1. Zwei übergeordnete „Worker“-Funktionen zum Erstellen von Kugeln mit Radien und mit Anzeigefarben anhand des Z-Werts des Mittelpunkts.

2. Eine übergeordnete „Manager“-Funktion, die die beiden „Worker“-Funktionen kombiniert. Durch Aufrufen dieser Funktion werden beide darin enthaltenen Funktionen aufgerufen.

Beschränken der Anzeige auf das Nötige:

• Die Schnittstelle eines Moduls gibt die vom Modul bereitgestellten und benötigten Elemente an.

• Nachdem Sie die Schnittstellen zwischen den Einheiten definiert haben, kann die detaillierte Entwicklung jeder Einheit separat erfolgen.

Möglichkeit zum Trennen bzw. Ersetzen:

• Module erkennen oder berücksichtigen einander nicht.

Allgemeine Formen der Modularisierung :

• Codegruppierung:

• Funktionen:

• Klassen:

Laufendes Testen

Es ist sinnvoll, während der Entwicklung von Textskripts in Dynamo laufend zu überprüfen, ob die tatsächlich erstellten Funktionen Ihren Erwartungen entsprechen. Dadurch stellen Sie sicher, dass unvorhergesehene Ereignisse wie Syntaxfehler, logische Diskrepanzen, falsche Werte, regelwidrige Ausgaben usw. nicht erst zum Schluss alle zusammen, sondern direkt bei ihrem Auftreten schnell erkannt und korrigiert werden. Da die Textskripts sich innerhalb der Blöcke im Ansichtsbereich befinden, sind sie bereits in den Datenfluss des visuellen Programms integriert. Die laufende Überwachung des Skripts gestaltet sich dadurch so einfach wie das Zuweisen von Daten für die Ausgabe, die Ausführung des Programms und die Auswertung des Skriptergebnisses über einen Beobachtungsblock. Im Folgenden finden Sie einige Tipps für die laufende Überwachung Ihrer Skripts, während Sie sie konstruieren.

Testen Sie während der Entwicklung:

• Wenn Sie eine Gruppe von Funktionen erstellt haben:

  • Überprüfen Sie Ihren Code aus distanzierter Sicht.

  • Seien Sie dabei kritisch. Ist die Funktionsweise für einen Teamkollegen verständlich? Brauche ich das wirklich? Kann diese Funktion effizienter durchgeführt werden? Werden unnötige Duplikate oder Abhängigkeiten erstellt?

1. Überprüfen Sie, ob alle Kanten des Volumenkörpers als Kurven zurückgegeben werden, damit ein Begrenzungsrahmen darum erstellt wird.

2. Überprüfen Sie, ob die Count-Eingaben in Ranges konvertiert werden.

3. Überprüfen Sie, ob Koordinatensysteme in dieser Schleife ordnungsgemäß verschoben und gedreht wurden.

Vorwegnehmen von Grenzfällen:

• Geben Sie während der Skripterstellung die Mindest- und Höchstwerte der Eingabeparameter innerhalb ihrer zugewiesenen Domäne an, um zu testen, ob das Programm auch unter extremen Bedingungen funktioniert.

• Überprüfen Sie auch dann, wenn das Programm mit seinen Extremwerten funktioniert, ob es unbeabsichtigte Nullwerte oder leere Werte zurückgibt.

• Bugs und Fehler, die auf grundlegende Probleme mit dem Skript hinweisen, werden zuweilen nur in solchen Grenzfällen erkennbar.

Effiziente Fehlersuche

Debugging ist der Prozess der Beseitigung von Fehlern („Bugs“) in Ihrem Skript. Bugs können Fehler, Ineffizienzen, Ungenauigkeiten oder beliebige nicht beabsichtigte Ergebnisse sein. Um einen Bug zu beheben, kann ein einfacher Schritt wie die Korrektur eines falsch geschriebenen Variablennamens genügen, es können jedoch auch tiefergehende, die Struktur des Skripts betreffende Probleme vorhanden sein. Im Idealfall erkennen Sie solche potenziellen Probleme frühzeitig, indem Sie das Skript während des Erstellens testen, eine Garantie für Fehlerfreiheit ist dadurch jedoch nicht gegeben. Im Folgenden werden einige der oben genannten optimalen Verfahren genauer beschrieben, um Ihnen die systematische Beseitigung von Bugs zu erleichtern.

Verwenden Sie den Beobachtungsblock:

• Überprüfen Sie die an verschiedenen Stellen des Codes zurückgegebenen Daten, indem Sie ihn ähnlich wie beim Testen des Programms der OUT-Variablen zuweisen:

Schreiben Sie aussagekräftige Kommentare:

• Das Debugging eines Codemoduls ist erheblich einfacher, wenn das beabsichtigte Ergebnis klar beschrieben ist.

Normalerweise wäre dies ein Übermaß an Kommentaren und leeren Zeilen, beim Debugging kann es jedoch hilfreich sein, den Code in überschaubare Abschnitte aufzuteilen.

Nutzen Sie die Modularität des Codes:

• Die Ursache eines Problems kann gezielt auf bestimmte Module zurückgeführt werden.

• Nachdem Sie das fehlerhafte Modul identifiziert haben, lässt sich das Problem wesentlich leichter beheben.

• Wenn ein Programm geändert werden muss, ist Code, der in Form von Modulen entwickelt wurde, erheblich leichter zu ändern.

Debuggen der Beispieldatei aus dem .

1. Die Eingabegeometrie gibt einen Begrenzungsrahmen zurück, der größer ist als sie selbst, wie durch Zuweisen von xDist und yDist zu OUT zu erkennen ist.

2. Die Kantenkurven der Eingabegeometrie geben einen passenden Begrenzungsrahmen mit den richtigen Entfernungen für xDist und yDist zurück.

3. Das zur Behebung des Problems mit den xDist- und yDist-Werten eingefügte Codemodul.

Übung: Steilstmöglicher Pfad

Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.

Eine vollständige Liste der Beispieldateien finden Sie im Anhang.

In dieser Übung schreiben Sie unter Beachtung der optimalen Verfahren für Textskripts ein Skript zur Simulation von Regen. Im Kapitel „Strategien für Diagramme“ war es möglich, optimale Verfahren auf ein unstrukturiertes visuelles Programm anzuwenden. Bei Textskripts ist dies jedoch wesentlich schwieriger. Logische Beziehungen, die in Textskripts erstellt werden, sind weniger sichtbar und können in unzureichend strukturiertem Code kaum unterschieden werden. Die Leistungsfähigkeit der Textskripts bringt einen größeren Organisationsbedarf mit sich. Hier werden die einzelnen Schritte gezeigt und während des ganzen Vorgangs die optimalen Verfahren angewendet.

Das auf eine durch einen Attraktor verformte Oberfläche angewendete Skript.

Als Erstes müssen Sie die benötigten Dynamo-Bibliotheken importieren. Indem Sie dies zu Anfang durchführen, erhalten Sie globalen Zugriff auf Dynamo-Funktionen in Python.

Sie müssen hier sämtliche Bibliotheken importieren, die Sie verwenden möchten.

Anschließend müssen Sie die Eingaben und die Ausgabe definieren, die als Eingabeanschlüsse am Block angezeigt werden. Diese externen Eingaben sind die Grundlage für das Skript und der Schlüssel zum Erstellen einer parametrischen Umgebung.

Sie müssen Eingaben definieren, die Variablen im Python-Skript entsprechen, und die gewünschte Ausgabe bestimmen:

1. Die Oberfläche, über die die Bewegung nach unten erfolgen soll.

2. Die Anzahl der Agents, die sich bewegen sollen.

3. Die maximale Anzahl an Schritten, die die Agents ausführen dürfen.

Erstellen Sie jetzt unter Beachtung des Modularitätsprinzips den Hauptteil des Skripts. Die Simulation des kürzesten Wegs abwärts auf einer Oberfläche ausgehend von unterschiedlichen Startpunkten ist eine größere Aufgabe, die mehrere Funktionen erfordert. Anstatt die verschiedenen Funktionen im Verlauf des ganzen Skripts aufzurufen, können Sie den Code modularisieren, indem Sie sie in einer einzigen Klasse, dem Agent, sammeln. Die verschiedenen Funktionen dieser Klasse – des „Moduls“ – können über unterschiedliche Variablen aufgerufen oder sogar in einem anderen Skripts wiederverwendet werden.

Sie müssen eine Klasse bzw. eine Vorlage für einen Agent definieren, der eine Abwärtsbewegung über eine Oberfläche darstellt, wobei bei jedem Schritt der Bewegung jeweils die Richtung mit der maximalen Neigung gewählt wird:

1. Name.

2. Globale, allen Agents gemeinsame Attribute.

3. Exemplarattribute, die für jeden Agent spezifisch sind.

4. Eine Funktion zum Ausführen eines Schritts.

Initialisieren Sie die Agents, indem Sie ihre Startpositionen definieren. Dies ist eine gute Gelegenheit, das Skript zu testen und sicherzustellen, dass die Agent-Klasse funktioniert.

Sie müssen alle Agents, deren Abwärtsbewegung über die Oberfläche Sie beobachten möchten, instanziieren und ihre Anfangsattribute definieren.

1. Eine neue, leere Pfadliste.

2. Ausgangspunkt der Bewegung über die Oberfläche.

3. Die Liste der Agents wird als Ausgabe zugewiesen, um zu überprüfen, was das Skript hier zurückgibt. Die richtige Anzahl der Agents wird zurückgegeben, das Skript muss jedoch später erneut getestet werden, um die zurückgegebene Geometrie zu prüfen.

Aktualisieren Sie die einzelnen Agents bei jedem Schritt. Anschließend müssen Sie eine verschachtelte Schleife starten, wobei die Position für jeden Agent und jeden Schritt aktualisiert und in der jeweiligen Pfadliste aufgezeichnet wird. Bei jedem Schritt wird außerdem geprüft, ob der Agent einen Punkt auf der Oberfläche erreicht hat, von dem aus keine weiteren Abwärtsschritte mehr möglich sind. Ist diese Bedingung erfüllt, wird die Bewegung des Agent beendet.

Nachdem die Agents vollständig aktualisiert sind, können Sie Geometrie ausgeben, durch die sie dargestellt werden. Nachdem alle Agents entweder den Endpunkt ihrer Abwärtsbewegung erreicht oder die maximale Anzahl Schritte ausgeführt haben, erstellen Sie eine Polykurve durch die Punkte in ihrem Pfad und geben die Polykurvenpfade aus.

Das Skript zur Ermittlung der steilstmöglichen Pfade.

1. Voreinstellung zur Simulation von Regen auf der zugrunde liegenden Oberfläche.

2. Die Agents können umgeschaltet werden, sodass sie nicht die steilstmöglichen Pfade suchen, sondern die Oberfläche überqueren.

Das vollständige Python-Textskript.