tholic Church (seecalendar), Anglican Communion (see calendars),Eastern Orthodox Church (seecalendar), Lutheran Church(see calendar)
Type
Christian, national, ethnic
Significance
Feast day of Saint Patrick, commemoration of the arrival of Christianity in Ireland[1]
Date
17 March
Celebrations
Attending parades, attendingcéilithe, wearing shamrocks, wearing green, drinking Irish beer, drinking Irish whiskey
Observances
Attending mass or service
…
holes on each so speed increases). Zero radius circles are skipped.
The image dimensions in pixels are defined in small panels (X=485, Y=759) and used to calculate height/width ratio. That is used to define height based on the 'X' slider (500), which defines width overall.
The 'cell size' slider is also in units and determines resolution indirectly. For any given X value, increasing 'cell size' reduces the number of grid cells (resolution) and vice-versa.
Independent of other parameters, 'Isotrim (SubSrf)' splits the base surface into sub-surfaces, onto which the circles are projected. The 'SrfSplit' does the heavy lifting (can be SLOW!) and finally, 'Sort' is used to select the resulting surfaces that contain the holes.
Benchmarks:
X = 500, cell size = 10, 3161 circlesnine subsurfaces: 'SrfSplit' = 6.6 minutes, 'Project' = 13 secs.16 subsurfaces: 'SrfSplit' = 2.3 minutes, 'Project' = 17 secs.
X = 500, cell size = 5, 12542 circles (shown)35 surfaces: 'SrfSplit' = 30.6 minutes, 'Project' = 57 secs.
As noted before, a very long-standing, well-known bug in Grasshopper fails to save the Image Sampler component when I save a copy of your file. Very annoying, but there is a work-around. Copy/paste and connect the Image Sampler from the code you posted above into the place I reserved for it.
"Pro Tip": Always work at low-resolution until your algorithms are proven before cranking up to 10K+ geometry counts!
Attached file has low resolution settings with 'Project' and 'SrfSplit' (red group) disabled.…
ting.
Thanks
Rania
** Warning ** IP: Note -- Some missing fields have been filled with defaults. See the audit output file for details.
** Warning ** Version: in IDF="'8.2.7'" not the same as expected="8.2"
** Warning ** ManageSizing: For a zone sizing run, there must be at least 1 Sizing:Zone input object. SimulationControl Zone Sizing option ignored.
** Warning ** ManageSizing: For a plant sizing run, there must be at least 1 Sizing:Plant object input. SimulationControl Plant Sizing option ignored.
************* Testing Individual Branch Integrity
************* All Branches passed integrity testing
************* Testing Individual Supply Air Path Integrity
************* All Supply Air Paths passed integrity testing
************* Testing Individual Return Air Path Integrity
************* All Return Air Paths passed integrity testing
************* No node connection errors were found.
************* Beginning Simulation
************* Simulation Error Summary *************
** Warning ** The following Report Variables were requested but not generated
** ~~~ ** because IDF did not contain these elements or misspelled variable name -- check .rdd file
************* Key=*, VarName=ZONE IDEAL LOADS SUPPLY AIR TOTAL COOLING ENERGY, Frequency=Hourly
************* Key=*, VarName=ZONE IDEAL LOADS SUPPLY AIR TOTAL HEATING ENERGY, Frequency=Hourly
************* Key=*, VarName=ZONE PACKAGED TERMINAL HEAT PUMP TOTAL COOLING ENERGY, Frequency=Hourly
************* Key=*, VarName=ZONE PACKAGED TERMINAL HEAT PUMP TOTAL HEATING ENERGY, Frequency=Hourly
************* Key=*, VarName=CHILLER ELECTRIC ENERGY, Frequency=Hourly
************* Key=*, VarName=BOILER HEATING ENERGY, Frequency=Hourly
************* Key=*, VarName=FAN ELECTRIC ENERGY, Frequency=Hourly
************* Key=*, VarName=ZONE IDEAL LOADS SUPPLY AIR LATENT HEATING ENERGY, Frequency=Hourly
************* Key=*, VarName=ZONE IDEAL LOADS SUPPLY AIR LATENT COOLING ENERGY, Frequency=Hourly
************* Key=*, VarName=ZONE IDEAL LOADS SUPPLY AIR SENSIBLE HEATING ENERGY, Frequency=Hourly
************* Key=*, VarName=ZONE IDEAL LOADS SUPPLY AIR SENSIBLE COOLING ENERGY, Frequency=Hourly
************* Key=*, VarName=SYSTEM NODE MASS FLOW RATE, Frequency=Hourly
************* Key=*, VarName=SYSTEM NODE TEMPERATURE, Frequency=Hourly
************* Key=*, VarName=SYSTEM NODE RELATIVE HUMIDITY, Frequency=Hourly
************* There are 3 unused schedules in input.
************* There are 5 unused week schedules in input.
************* There are 13 unused day schedules in input.
************* Use Output:Diagnostics,DisplayUnusedSchedules; to see them.
*************
************* ===== Recurring Surface Error Summary =====
************* The following surface error messages occurred.
*************
************* Base Surface does not surround subsurface errors occuring...
************* Check that the GlobalGeometryRules object is expressing the proper starting corner and direction [CounterClockwise/Clockwise]
*************
** Warning ** Base surface does not surround subsurface (CHKSBS), Overlap Status=No-Overlap
** ~~~ ** The base surround errors occurred 1 times.
** ~~~ ** Surface "839A5ADACCE44BC0AF00_GLZP_31" misses SubSurface "839A5ADACCE44BC0AF00_GLZP_31_GLZ_31"
** Warning ** Base surface does not surround subsurface (CHKSBS), Overlap Status=Partial-Overlap
** ~~~ ** The base surround errors occurred 1 times.
** ~~~ ** Surface "839A5ADACCE44BC0AF00_GLZP_34" overlaps SubSurface "839A5ADACCE44BC0AF00_GLZP_34_GLZ_34"
*************
** ~~~ ** The base surround errors occurred 2 times (total).
*************
************* EnergyPlus Warmup Error Summary. During Warmup: 0 Warning; 0 Severe Errors.
************* EnergyPlus Sizing Error Summary. During Sizing: 2 Warning; 0 Severe Errors.
************* EnergyPlus Completed Successfully-- 7 Warning; 0 Severe Errors; Elapsed Time=00hr 07min 35.94sec…
ng is deciding how and where to store your data. If you're writing textual code using any one of a huge number of programming languages there are a lot of different options, each with its own benefits and drawbacks. Sometimes you just need to store a single data point. At other times you may need a list of exactly one hundred data points. At other times still circumstances may demand a list of a variable number of data points.
In programming jargon, lists and arrays are typically used to store an ordered collection of data points, where each item is directly accessible. Bags and hash sets are examples of unordered data storage. These storage mechanisms do not have a concept of which data comes first and which next, but they are much better at searching the data set for specific values. Stacks and queues are ordered data structures where only the youngest or oldest data points are accessible respectively. These are popular structures for code designed to create and execute schedules. Linked lists are chains of consecutive data points, where each point knows only about its direct neighbours. As a result, it's a lot of work to find the one-millionth point in a linked list, but it's incredibly efficient to insert or remove points from the middle of the chain. Dictionaries store data in the form of key-value pairs, allowing one to index complicated data points using simple lookup codes.
The above is a just a small sampling of popular data storage mechanisms, there are many, many others. From multidimensional arrays to SQL databases. From readonly collections to concurrent k-dTrees. It takes a fair amount of knowledge and practice to be able to navigate this bewildering sea of options and pick the best suited storage mechanism for any particular problem. We did not wish to confront our users with this plethora of programmatic principles, and instead decided to offer only a single data storage mechanism.*
Data storage in Grasshopper
In order to see what mechanism would be optimal for Grasshopper, it is necessary to first list the different possible ways in which components may wish to access and store data, and also how families of data points flow through a Grasshopper network, often acquiring more complexity over time.
A lot of components operate on individual values and also output individual values as results. This is the simplest category, let's call it 1:1 (pronounced as "one to one", indicating a mapping from single inputs to single outputs). Two examples of 1:1 components are Subtraction and Construct Point. Subtraction takes two arguments on the left (A and B), and outputs the difference (A-B) to the right. Even when the component is called upon to calculate the difference between two collections of 12 million values each, at any one time it only cares about three values; A, B and the difference between the two. Similarly, Construct Point takes three separate numbers as input arguments and combines them to form a single xyz point.
Another common category of components create lists of data from single input values. We'll refer to these components as 1:N. Range and Divide Curve are oft used examples in this category. Range takes a single numeric domain and a single integer, but it outputs a list of numbers that divide the domain into the specified number of steps. Similarly, Divide Curve requires a single curve and a division count, but it outputs several lists of data, where the length of each list is a function of the division count.
The opposite behaviour also occurs. Common N:1 components are Polyline and Loft, both of which consume a list of points and curves respectively, yet output only a single curve or surface.
Lastly (in the list category), N:N components are also available. A fair number of components operate on lists of data and also output lists of data. Sort and Reverse List are examples of N:N components you will almost certainly encounter when using Grasshopper. It is true that N:N components mostly fall into the data management category, in the sense that they are mostly employed to change the way data is stored, rather than to create entirely new data, but they are common and important nonetheless.
A rare few components are even more complex than 1:N, N:1, or N:N, in that they are not content to operate on or output single lists of data points. The Divide Surface and Square Grid components want to output not just lists of points, but several lists of points, each of which represents a single row or column in a grid. We can refer to these components as 1:N' or N':1 or N:N' or ... depending on how the inputs and outputs are defined.
The above listing of data mapping categories encapsulate all components that ship with Grasshopper, though they do not necessarily minister to all imaginable mappings. However in the spirit of getting on with the software it was decided that a data structure that could handle individual values, lists of values, and lists of lists of values would solve at least 99% of the then existing problems and was thus considered to be a 'good thing'.
Data storage as the outcome of a process
If the problems of 1:N' mappings only occurred in those few components to do with grids, it would probably not warrant support for lists-of-lists in the core data structure. However, 1:N' or N:N' mappings can be the result of the concatenation of two or more 1:N components. Consider the following case: A collection of three polysurfaces (a box, a capped cylinder, and a triangular prism) is imported from Rhino into Grasshopper. The shapes are all exploded into their separate faces, resulting in 6 faces for the box, 3 for the cylinder, and 5 for the prism. Across each face, a collection of isocurves is drawn, resembling a hatching. Ultimately, each isocurve is divided into equally spaced points.
This is not an unreasonably elaborate case, but it already shows how shockingly quickly layers of complexity are introduced into the data as it flows from the left to the right side of the network.
It's no good ending up with a single huge list containing all the points. The data structure we use must be detailed enough to allow us to select from it any logical subset. This means that the ultimate data structure must contain a record of all the mappings that were applied from start to finish. It must be possible to select all the points that are associated with the second polysurface, but not the first or third. It must also be possible to select all points that are associated with the first face of each polysurface, but not any subsequent faces. Or a selection which includes only the fourth point of each division and no others.
The only way such selection sets can be defined, is if the data structure contains a record of the "history" of each data point. I.e. for every point we must be able to figure out which original shape it came from (the cube, the cylinder or the prism), which of the exploded faces it is associated with, which isocurve on that face was involved and the index of the point within the curve division family.
A flexible mechanism for variable history records.
The storage constraints mentioned so far (to wit, the requirement of storing individual values, lists of values, and lists of lists of values), combined with the relational constraints (to wit, the ability to measure the relatedness of various lists within the entire collection) lead us to Data Trees. The data structure we chose is certainly not the only imaginable solution to this problem, and due to its terse notation can appear fairly obtuse to the untrained eye. However since data trees only employ non-negative integers to identify both lists and items within lists, the structure is very amenable to simple arithmetic operations, which makes the structure very pliable from an algorithmic point of view.
A data tree is an ordered collection of lists. Each list is associated with a path, which serves as the identifier of that list. This means that two lists in the same tree cannot have the same path. A path is a collection of one or more non-negative integers. Path notation employs curly brackets and semi-colons as separators. The simplest path contains only the number zero and is written as: {0}. More complicated paths containing more elements are written as: {2;4;6}. Just as a path identifies a list within the tree, an index identifies a data point within a list. An index is always a single, non-negative integer. Indices are written inside square brackets and appended to path notation, in order to fully identify a single piece of data within an entire data tree: {2,4,6}[10].
Since both path elements and indices are zero-based (we start counting at zero, not one), there is a slight disconnect between the ordinality and the cardinality of numbers within data trees. The first element equals index 0, the second element can be found at index 1, the third element maps to index 2, and so on and so forth. This means that the "Eleventh point of the seventh isocurve of the fifth face of the third polysurface" will be written as {2;4;6}[10]. The first path element corresponds with the oldest mapping that occurred within the file, and each subsequent element represents a more recent operation. In this sense the path elements can be likened to taxonomic identifiers. The species {Animalia;Mammalia;Hominidea;Homo} and {Animalia;Mammalia;Hominidea;Pan} are more closely related to each other than to {Animalia;Mammalia; Cervidea;Rangifer}** because they share more codes at the start of their classification. Similarly, the paths {2;4;4} and {2;4;6} are more closely related to each other than they are to {2;3;5}.
The messy reality of data trees.
Although you may agree with me that in theory the data tree approach is solid, you may still get frustrated at the rate at which data trees grow more complex. Often Grasshopper will choose to add additional elements to the paths in a tree where none in fact is needed, resulting in paths that all share a lot of zeroes in certain places. For example a data tree might contain the paths:
{0;0;0;0;0}
{0;0;0;0;1}
{0;0;0;0;2}
{0;0;0;0;3}
{0;0;1;0;0}
{0;0;1;0;1}
{0;0;1;0;2}
{0;0;1;0;3}
instead of the far more economical:
{0;0}
{0;1}
{0;2}
{0;3}
{1;0}
{1;1}
{1;2}
{1;3}
The reason all these zeroes are added is because we value consistency over economics. It doesn't matter whether a component actually outputs more than one list, if the component belongs to the 1:N, 1:N', or N:N' groups, it will always add an extra integer to all the paths, because some day in the future, when the inputs change, it may need that extra integer to keep its lists untangled. We feel it's bad behaviour for the topology of a data tree to be subject to the topical values in that tree. Any component which relies on a specific topology will no longer work when that topology changes, and that should happen as seldom as possible.
Conclusion
Although data trees can be difficult to work with and probably cause more confusion than any other part of Grasshopper, they seem to work well in the majority of cases and we haven't been able to come up with a better solution. That's not to say we never will, but data trees are here to stay for the foreseeable future.
* This is not something we hit on immediately. The very first versions of Grasshopper only allowed for the storage of a single data point per parameter, making operations like [Loft] or [Divide Curve] impossible. Later versions allowed for a single list per parameter, which was still insufficient for all but the most simple algorithms.
** I'm skipping a lot of taxonometric classifications here to keep it simple.…
Added by David Rutten at 2:22pm on January 20, 2015
administration, education and consumption, the contemporary world can be increasingly conceived as a global and systemic environment. All our activities are profoundly influenced by a new condition of fluidity and interdependence of various and very often, unpredictable parameters and factors, introducing us progressively to a systemic and parametric understanding of the world and our position in it. Architecture and the building process are reflecting this new conception of the world by redefining themselves according to new principles and means. The fast development of digital techniques to simulate, represent and generate Architecture promises a continuous design process, including the seamless transfer of information between the involved parties and making performance a key issue in the planning process. In this process, concepts of adaptability, transformability and flexibility are replacing already tested and secure solutions, customization is replacing standardization and metrics, and digital tools are replacing analogue representations. In these new conditions the scaleless and the seamless appear as the two key pillars of the requested integration in contemporary architectural practice and education. Do the design and planning practices and construction industries respond with digital synergies to these new requests? Can the curricula of architecture schools escape from the dominance of traditional fragmentation within their structure and the organisation of the modules and academic units towards more holistic concepts and workflow? How can the traditionally separate courses offered by departments and modules of architectural education institutions be redefined in order to assure a scale-less and seamless thinking about form, materiality and its social and cultural representations, its environmental aspects and its urban and contextual references?
The organisers are inviting architects, teachers and researchers of architecture in Europe to present their views, research outcomes and teaching experiences related to the theme of the Conference.
An abstract of 600-700 words must be submitted by September 5, 2012. Please indicate into which of the five aforementioned themes your abstract falls. You will be asked to submit your final paper by the 22nd of October 2012 for the publication of the proceedings, which will be distributed to all EAAE/ENHSA school members.
For any further queries please do not hesitate to contact us on info@enhsa.net or info@scaleless-seamless.org…
, 2013)
The most popular year was 2008 (5 responses)
Note: According to Wikipedia: "The first version of Grasshopper, called Explicit History at the time, was originally publicly released in September 2007." Interesting coincidence.
The response to question #2 by those that began before 2007 (How long did it take for you to feel comfortable with designing computationally?):
- Years
- Don't remember, but it felt like a natural way to relate to cad.
- After a few projects
- A month.
Compared to some of the responses of those that began since 2007:
- A month
- A few months
- After 6 weeks
- About 8 weeks
- Within my second design project with GH
- five to six months
- after 1 years of self learning + over 2 years of multiple projects and continuous self learning = Computation skill is comfortable but Computational Design can not be comfortable, Crazy learning curve.
There is much diversity, but some patterns begin to emerge.
Looking forward to more responses!…
curve or locus] of a segment AB, in English. The set of all the points from which a segment, AB, is seen under a fixed given angle.
When you construct l'arc capable —by using compass— you obviously need to find the centre of this arc. This can be easily done in GH in many ways by using some trigonometry (e.g. see previous —great— solutions). Whole circles instead of arcs provide supplementary isoptics —β-isoptic and (180º-β)-isoptic—. Coherent normals let you work in any plane.
Or you could just construct β-isoptics of AB by using tangent at A (or B). I mean [Arc SED] component.
If you want the true β-isoptic —the set of all the points— you should use {+β, -β} degrees (2 sides; 2 solutions; 2 arcs), but slider in [-180, +180] degrees provides full range of signed solutions. Orthoptic is provided by ±90º. Notice that ±180º isoptic is just AB segment itself, and 0º isoptic should be the segment outside AB —(-∞, A] U [B, +∞)—. [Radians] component is avoidable.
More compact versions can be achieved by using [F3] component. You can choose among different expressions the one you like the most as long as performs counter clockwise rotation of vector AB, by 180-β degrees, around A; or equivalent. [Panel] is totally avoidable.
Solutions in XY plane —projection; z = 0—, no matter A or B, are easy too. Just be sure about the curve you want to find the intersection with —Curve; your wall— being contained in XY plane.
A few self-explanatory examples showing features.
1 & 5 1st ver. (Supplementary isoptics) (ArcCapableTrigNormals_def_Bel.png)
2 & 6 2nd ver. (SED) (ArcCapableSED_def_Bel.png)
3 & 7 3rd ver. (SED + F3) (ArcCapableSEDF3_def_Bel.png)
4 & 8 4th ver. (SED + F3, Projection) (ArcCapableSEDProjInt_def_Bel.png)
If you want to be compact, 7 could be your best choice. If you prefer orientation robustness, 5. Etcetera.
I hope these versions will help you to compact/visualize; let me know any feedback.
Calculate where 2 points [A & B] meet at a specific angle is just find the geometrical locus called arco capaz in Spanish, arc capable in French (l'isoptique d'un segment de droite) or isoptic [curve or locus]
of a segment AB, in English. The set of all the points from which a segment,
AB, is seen under a fixed given angle.…
inner As Curve() = section.ToNurbsCurve().Offset(normal, pc, -plate, 1e-3, 1e-4, Rhino.Geometry.CurveOffsetCornerStyle.Sharp)
the error message is:
"
{0}0. Error: Het oplossen van de overbelasting is mislukt omdat dit aantal argumenten door geen enkele toegankelijke Offset wordt geaccepteerd. (line 104)
"
this is the VBA script:
"Option Strict OffOption Explicit On'Import SDK and Framework namespacesImports RhinoImports Rhino.GeometryImports Rhino.CollectionsImports GrasshopperImports Grasshopper.KernelImports Grasshopper.Kernel.DataImports Grasshopper.Kernel.TypesImports GH_IOImports GH_IO.SerializationImports SystemImports System.IOImports System.XmlImports System.DataImports System.DrawingImports System.ReflectionImports System.CollectionsImports System.Windows.FormsImports Microsoft.VisualBasicImports System.Collections.GenericImports System.Runtime.InteropServices'Code generated by Grasshopper(R) (except for RunScript() content and Additional content)'Copyright (C) 2011 - Robert McNeel & Associates<System.Runtime.CompilerServices.CompilerGenerated()> _Public Class Script_Instance Implements IGH_ScriptInstance#Region "Members" ''' <summary>List of error messages. Do not modify this list directly.</summary> Private __err As New List(Of String) ''' <summary>List of print messages. Do not modify this list directly, use the Print() and Reflect() functions instead.</summary> Private __out As New List(Of String) ''' <summary>Represents the current Rhino document.</summary> Private doc As RhinoDoc = RhinoDoc.ActiveDoc ''' <summary>Represents the Script component which maintains this script.</summary> Public owner As Grasshopper.Kernel.IGH_ActiveObject#End Region#Region "Utility functions" ''' <summary>Print a String to the [Out] Parameter of the Script component.</summary> ''' <param name="text">String to print.</param> Private Sub Print(ByVal text As String) __out.Add(text) End Sub ''' <summary>Print a formatted String to the [Out] Parameter of the Script component.</summary> ''' <param name="format">String format.</param> ''' <param name="args">Formatting parameters.</param> Private Sub Print(ByVal format As String, ByVal ParamArray args As Object()) __out.Add(String.Format(format, args)) End Sub ''' <summary>Print useful information about an object instance to the [Out] Parameter of the Script component. </summary> ''' <param name="obj">Object instance to parse.</param> Private Sub Reflect(ByVal obj As Object) __out.Add(GH_ScriptComponentUtilities.ReflectType_VB(obj)) End Sub ''' <summary>Print the signatures of all the overloads of a specific method to the [Out] Parameter of the Script component. </summary> ''' <param name="obj">Object instance to parse.</param> Private Sub Reflect(ByVal obj As Object, ByVal method_name As String) __out.Add(GH_ScriptComponentUtilities.ReflectType_VB(obj, method_name)) End Sub#End Region ''' <summary> ''' This procedure contains the user code. Input parameters are provided as ByVal arguments, ''' Output parameter are ByRef arguments. You don't have to assign output parameters, ''' they will be null by default. ''' </summary> Private Sub RunScript(ByVal p0 As Point3d, ByVal p1 As Point3d, ByVal p2 As Point3d, ByVal pc As Point3d, ByVal plate As Double, ByVal itt As Integer, ByVal dev As Double, ByRef crvout As Object, ByRef crvin As Object, ByRef sec As Object, ByRef opp As Object, ByRef div As Object, ByRef pt4 As Object) 'your code goes here… opp = "test01" Dim section As New Polyline(5) section.Add(p0) section.Add(p1) section.Add(p2) section.Add(pc) section.Add(p0) Dim normal As Vector3d = vector3d.CrossProduct((p1 - p0), (p2 - p0)) Dim area As Double Dim chicken_int As Int32 = 0 Dim XX As Double Dim YY As Double Do chicken_int += 1 If (chicken_int > itt) Then Exit Do 'Compute the section offset Dim inner As Curve() = section.ToNurbsCurve().Offset(normal, pc, -plate, 1e-3, 1e-4, Rhino.Geometry.CurveOffsetCornerStyle.Sharp) Dim edges As New CurveList(inner) edges.Add(section.ToNurbsCurve()) crvin = edges Dim sections As Brep() = Brep.CreatePlanarBreps(edges) If (sections Is Nothing) Then Exit Do opp = "test02" 'Compute the centroid of the current section Dim am As AreaMassProperties = AreaMassProperties.Compute(sections(0)) Dim ct As Point3d = am.Centroid XX = am.CentroidCoordinatesMomentsOfInertia.X YY = am.CentroidCoordinatesMomentsOfInertia.Y area = am.Area Dim dx As Vector3d = pc - ct 'Compute the error of the current centroid Dim dl As Double = dx.Length div = dl 'Update output values crvout = section crvin = inner sec = sections(0) opp = area If (dl < dev) Then Exit Do 'Adjust outline with a boosting factor. section(3) += dx * 4 Loop pt4 = section(3) crvout = section End Sub '<Custom additional code> '</Custom additional code> End Class
"…