, Engineer and Researcher from France with broad programming experience. He is the author of the City in 3D Rhinoceros plugin for creation of buildings according to geojson file and with real elevation. Guillaume already created a new component: "Address to Location". It enables getting latitude and longitude values for the given address:
2) Support of Bathymetry data: automatic creation of underwater (sea/river/lake floor) terrain. This feature is now available through new source_ input of the "Terrain generator" component. Here is an example of terrain of the Loihi underwater volcano, of the coast of Hawaii:
3) A new terrain source has been added: ALOS World 3D 30m. ALOS is a Japanese global terrain data. Gismo "Terrain Generator" component has been using SRTM 30m terrain data, which hasn't been global and was limited to -56 to +60 latitude range. With this addition, it is possible to switch between SRTM and ALOS World 3D 30m models with the use of source_ input.
4) 9 new components have been added:
"Address To Location" - finds latitude and longitude coordinates for the given address.
"XY To Location" - finds latitude and longitude coordinates for the given Rhino XY coordinates. "Location To XY" - vice versa from the previous component: finds Rhino XY coordinates for the given latitude longitude coordinates. "Z To Elevation" - finds elevation for particular Rhino point. "Rhino text to number" - convert numeric text from Rhino to grasshopper number. "Rhino unit to meters" - convert Rhino units to meters. "Deconstruct location" - deconstructs .epw location. "New Component Example" - this component explains how to make a new Gismo component, in case you are interested to make one. We welcome new developers, even if you contribute a single component to Gismo! "Support Gismo" - gives some suggestions on how to make Gismo better, how to improve it and support it.
5) Ladybug "Terrain Generator" component now supports all units, not only Meters. So any Gismo example file which uses this component, can now use Rhino units other than Meters as well. Thank you Antonello Di Nunzio for making this happen!!
Basically just forget about this yellow panel:
This panel is not valid anymore, so just use any unit you want.
6) A number of bugs have been fixed, reported in topics for the last couple of weeks. We would like to thank members in the community who invested their time in testing, finding these bugs and reporting them: Rafat Ahmed, Peter Zatko, Mathieu Venot, Abraham Yezioro, Rafael Alonso. Thank you guys!!! Apologies if we forgot to mention someone.
The version 0.0.2 can be downloaded from here:
https://github.com/stgeorges/gismo/zipball/master
And example files from here:
https://github.com/stgeorges/gismo/tree/master/examples
Any new suggestions, testing and bug reports are welcome!!…
Added by djordje to Gismo at 5:13pm on March 1, 2017
ies and ideas (in this case agent-based modelling) simply because they are the new cool thing to do and, if we think carefully about how the integration of agent-based modeling will improve the accuracy and usefulness of our models, we are more likely to make lasting contributions through their integration.
For example, it seems vital to me that such agent-based models be grounded in some clear quantifiable observations of human behavior in real buildings as opposed to relying on our own coefficients to represent how valuable we think certain things are to the occupants. I will give an example of two agent-based ideas that I have had - one of which has turned out to seem much more valuable in the long-run because of it's grounding in real-world data and I plan to implement soon.
To start with the more valuable example, ever since I read this awesome book on adaptive thermal comfort (https://books.google.com/books?id=vE7FBQAAQBAJ&printsec=frontcover&dq=adaptive+thermal+comfort&hl=en&sa=X&ved=0ahUKEwjDmO6avNnJAhUD9h4KHXWVBuAQ6AEIHDAA#v=onepage&q=adaptive%20thermal%20comfort&f=false), I have had several ideas for how to integrate the findings of recent comfort surveys into our energy models. Generally, the focus of thermal comfort research seems to be shifting from theoretical human energy balance calculations to surveys of occupant behavior, giving us a lot of great data that helps incorporate these behavioral factors in our energy models. To continue one of the ideas that you mention, Theodore, here is a plot from the book that describes the window-opening behavior of occupants as the indoor temperature increases:
Currently, EnergyPlus does not easily allow you to set such a function for window-opening, as you point out but the incorporation of this behavior seems necessary to produce an accurate model of a naturally ventilated building (since opening all of the windows as soon as the indoor temperature hits 21 C is far from realistic). To get around this, I was thinking of including an option on the nat vent component that will put in a series of IF/THEN nat vent objects that approximate this smooth function through a step function:
IF 19 < indoor temperature < 20 THEN WindowOpening = 10%
IF 20 < indoor temperature < 21 THEN WindowOpening = 15%
IF 21 < indoor temperature < 22 THEN WindowOpening = 21%
IF 22 < indoor temperature < 23 THEN WindowOpening = 35%
...
I am hoping to implement this soon.
To describe the example that I have realized was not so helpful with time, when I was first drafting the idea for high-resolution comfort maps (https://www.youtube.com/playlist?list=PLruLh1AdY-Sj3ehUTSfKa1IHPSiuJU52A), I originally thought that I would develop computer models an animations of occupants moving around the thermally diverse space to make themselves more comfortable. Once I started to get into this, however, I realized that the social characteristics of a space usually have a much larger impact on where people place themselves than the thermal characteristics and it is not until the thermal characteristics become very uncomfortable or the presence of other people is completely removed that the thermal environment dominates the movement behavior. Thus, in order to model the occupant behavior, I would have to code in the relative importance of a large number of these social characteristics in relation to thermal comfort, which would have been a process of me simply making up coefficients to produce cool-looking but somewhat meaningless animations. It is only when my nicely-designed thermal environments were aligned with the social/programmatic characteristics of the space that I could argue that I was justifiably adding value since the thermal characteristics were not in contradiction to or being weighted against the social ones. So, in the end, realized that all I needed in order to produce a good design was to align the thermal environment with the placing of program and the agent-based modelling would not have enabled the production of a much better design. This is the reason why the human silhouettes are manually placed in the thermal animations on the youtube playlist in the above link and is the reason why I do not intend to incorporate agent-based modelling in this particular manner.
Let me know your thoughts on this as I realize I may also be looking at this from a narrow perspective that is not informed by all that agent-based modelling has to offer.
-Chris…
size component supported only ground PV panels and angled roof PV panels.
Download the newest PV SWH system size component from here (Click on "View Raw" to download it. Then move the downloaded .ghuser file to File->Special Folders->User Objects Folder, an confirm to overwrite it with previously located one).
Just a few opinions on the project you are currently working on:This kind of fixed, non-transparent (overhang) PV panels attached to a building facade are vert convenient for locations with higher latitudes.The reason for this is because they (fixed overhang PV panels) are dimensioned according to the sun position at summer solstice. Elevation angles on summer solstice at higher latitude locations are lower, than those of lower latitude locations.Due to Incheon's low latitude (37), you will get rather short length of the PV panels* : less than 10 centimeters (0.097 meters in the attached .gh file below). As you have mentioned, Galapagos needs to be used too.I will just mention some of the good and bad ways in which the upper issue could be somewhat avoided:1) Increasing the vertical distance between PV panels (PV panels appear above every second window).2) Increase the tilt angle. This will increase the length of PV panels also, but will decrease the final annual AC energy output.An example of this solution has been applied at FKI building in Seoul (latitude: 37N):I already did some tests (with tilt angles: 40, 45, 55) and this does not seem like a good solution, though.3) Shrinking the "sun window" by using the minimalSpacingPeriod_ input. In Photovoltaics, a planner is suppose to make the 9h to 15h part of the sun window free of any obstructions. If you try to decrease the "sun window" to 10 to 14h, the length of your PV panels will increase. You can try to experiment a little bit with this (set your minimalSpacingPeriod_ to 21th of June 10 to 14hours). In general, shrinking the sun window on summer solstice is not a good principle during planning.4) Using tracking PV panels, not fixed ones. But Ladybug Photovoltaics components do not support this kind of PV systems. They only support fixed ones.I would personally go with the first option. You can also experiment with the second and third one.Comment back if you have any other questions.-----------------------* By "length of the PV panels" I mean the: tiltedArrayHeight_ input of the PV SWH system size component.…
ed file and code below:
Color ColorAt(Mesh mesh, int faceIndex, double t0, double t1, double t2, double t3) { // int rc = -1; var color = Rhino.Display.Color4f.Black;
if( mesh.VertexColors.Count != 0) { // test to see if face exists if( faceIndex >= 0 && faceIndex < mesh.Faces.Count ) { /// Barycentric quad coordinates for the point on the mesh /// face mesh.Faces[FaceIndex].
/// If the face is a triangle /// disregard T[3] (it should be set to 0.0).
/// If the face is /// a quad and is split between vertexes 0 and 2, then T[3] /// will be 0.0 when point is on the triangle defined by vi[0], /// vi[1], vi[2]
/// T[1] will be 0.0 when point is on the /// triangle defined by vi[0], vi[2], vi[3].
/// If the face is a /// quad and is split between vertexes 1 and 3, then T[2] will /// be -1 when point is on the triangle defined by vi[0], /// vi[1], vi[3]
/// and m_t[0] will be -1 when point is on the /// triangle defined by vi[1], vi[2], vi[3].
MeshFace face = mesh.Faces[faceIndex];
// Collect data for barycentric evaluation. Color p0, p1, p2;
if(face.IsTriangle) { p0 = mesh.VertexColors[face.A]; p1 = mesh.VertexColors[face.B]; p2 = mesh.VertexColors[face.C]; } else { if( t3 == 0 ) { // point is on subtriangle {0,1,2} p0 = mesh.VertexColors[face.A]; p1 = mesh.VertexColors[face.B]; p2 = mesh.VertexColors[face.C]; } else if( t1 == 0 ) { // point is on subtriangle {0,2,3} p0 = mesh.VertexColors[face.A]; p1 = mesh.VertexColors[face.C]; p2 = mesh.VertexColors[face.D]; //t0 = t0; t1 = t2; t2 = t3; } else if( t2 == -1 ) { // point is on subtriangle {0,1,3} p0 = mesh.VertexColors[face.A]; p1 = mesh.VertexColors[face.B]; p2 = mesh.VertexColors[face.D]; //t0 = t0; //t1 = t1; t2 = t3; } else { // point must be on remaining subtriangle {1,2,3} p0 = mesh.VertexColors[face.B]; p1 = mesh.VertexColors[face.C]; p2 = mesh.VertexColors[face.D]; t0 = t1; t1 = t2; t2 = t3; } }
/** double r = t0 * p0.FractionRed() + t1 * p1.FractionRed() + t2 * p2.FractionRed(); double g = t0 * p0.FractionGreen() + t1 * p1.FractionGreen() + t2 * p2.FractionGreen(); double b = t0 * p0.FractionBlue() + t1 * p1.FractionBlue() + t2 * p2.FractionBlue();
ON_Color color; color.SetFractionalRGB(r, g, b);
unsigned int abgr = (unsigned int)color; rc = (int) ABGR_to_ARGB(abgr); **/ var c0 = new Rhino.Display.Color4f(p0); var c1 = new Rhino.Display.Color4f(p1); var c2 = new Rhino.Display.Color4f(p2); float s0 = (float) t0; float s1 = (float) t1; float s2 = (float) t2;
float R = s0 * c0.R + s1 * c1.R + s2 * c2.R; float G = s0 * c0.G + s1 * c1.G + s2 * c2.G; float B = s0 * c0.B + s1 * c1.B + s2 * c2.B; color = new Rhino.Display.Color4f(R, G, B, 1); } } return color.AsSystemColor(); }
…
ort and export from the images below and also from the HELP file of DB in attachments (Page 71: Importing Geometric Data; Page 78-80: Import 3 - D CAD Data). In their HELP file, they mention about "import geometric data".
However, regarding the input of schedules, loads, constructions and etc., DB normally uses "Component " and "Template" (Page 29: Templates And Components; Page 591: Templates; Page 533: Components). "Templates" are databases of typical generic data, including Activity templates, Construction templates, Glazing templates, Facade templates, HVAC templates, Location Templates, and etc. "Component " are databases of individual data items (e.g. a construction type, material, window pane).
Both "Component " and "Template" are allowed to be imported and exported by using "Import / Export library data" command (.ddf format - DB Database File; Page 734: Import Components/Templates, Export Components/Templates). DB also allows us to build up our own libraries of templates and components (Page 731: Library Management; Page 733: Template Library Management).
In order to import both geometric information and other information related to schedules, loads, constructions and etc. from GH to BD, we supposed the following two ways:
1. GH(HB+GB) --> gbXML (both geometric and "Component " and "Template" information) --> DB
This is the way we most prefer. We did see information related to schedules, loads, constructions encoded in the gbXML file generated by GB, but still do not know the reason why DB did not take this information (I also mentioned this in Q6 within the gh file). We assume this might because the gbXML file we create encodes the schedules based on a different template / schema than the one DB expects. We also post this question to the DB forum for help.
(http://www.designbuilder.co.uk/component/option,com_forum/Itemid,25/page,viewtopic/p,13755/#13755)
2. GH(HB+GB) --> gbXML (geometric information only) + .ddf ("Component " and "Template" information only) --> DB
If the first way doesn't work and DB only takes geometric information from the gbXML, then we might think of the other way - generating the .ddf files from GH(HB+GB) to pass the schedule, load and construction information to DB.
I was wondering if it is feasible for HB and GB to have this function? And what is your suggestion to achieve this?
In addition, we notice that DB can export XML files (not gbXML), so we are trying to figure out if DB also accepts / reads the XML file. If so, we might be able to convert the gbXML (with both geometric and schedule information) to XML. What do you think about that?
Thank you again for all your help!
Best,
Ding
DB import
DB export
Template libraries
Component libraries
…
will work slightly different from before. Sorry about breaking this, but it proved impossible to improve the selection logic with the fairly ambiguous notation that was implemented already.
Not every change is breaking though and I hope that most simple matching rules will work as before. There will be a McNeel webinar on Wednesday the 6th of November where I discuss the new selection rules (as well as path mapping syntax and relative offsets within one or more data trees). This will be a pretty hard-core webinar aimed at expert users. The event will be recorded so you can always go and watch it later. I figured I'd briefly explain the new selection rules on Ning before I release the update though.
-------------------------------------------------------------------------------
Imagine we have the following data tree, containing a bunch of textual characters:
{0;0} = [a,e,i,o,u,y] {0;1} = [ä,ë,ê,ï,î,ö,ô,õ,ü,û,ÿ,ý] {1;0} = [b,c,d,f,g,h,j,k,l,m,n,p,q,r,s,t,v,w,x,z] {1;1} = [ç,ĉ,č,ĝ,ř,š,ş,ž]
There are a total of four branches {0;0}, {0;1}, {1;0} and {1;1}. The first branch contains all the vowels that are part of the standard English alphabet. The second branch contains all non-standard vowels and branches three and four contain the standard and non-standard consonants respectively.
So what if we want to select from this tree only the standard vowels? Basically include everything in the first branch and disregard everything else. We can use the [Tree Split] component with a selection rule to achieve this:
{0;0}
This selection rule hard-codes the number zero in both tree path locations. It doesn't define an item index rule, so all items in {0;0} will be selected.
If we want all the vowels (both standard and non-standard), then we have several options:
{0;?} = select all branches that start with 0
{0;(0,1)} = select all branches that start with 0 and end in either 0 or 1
{0;(0 to 1)} = ......................................... and end in the range 0 to 1.
Conversely, selecting all standard vowels and consonants while disregarding all non-standard character can be achieved with rules as follows:
{?;0}
{(0,1);0}
{(0 to 1);0}
It is also possible to select items from each branch in addition to limiting the selection to specific branches. In this case another rule stated in square brackets needs to be appended:
{0;?}[0 to 2]
The above rule will select the first three vowels from the standard and the non-standard lists.
Basically, rules work in a very consistent way, but there are some syntax conventions you need to know. The first thing to realize is that every individual piece of data in a data-tree can be uniquely and unambiguously identified by a collection of integers. One integer describes its index within the branch and the others are used to identify the branch within the tree. As a result a rule for selection items always looks the same:
{A;B;C;...;Z}[i] where A, B, C, Z and i represent rules.
It's very similar to the Path Mapper syntax except it uses square brackets instead of parenthesis for the index (the Path Mapper will follow suit soon, but that won't be a breaking change). You always have to define the path selector rule in between curly brackets. You can supply any number of rules as long as you separate them with semi-colons.
The index rule is optional, but -when provided- it has to be encased in square brackets after the path selection rule(s).
The following rule notations are allowed:
* Any number of integers in a path
? Any single integer
6 Any specific integer
!6 Anything except a specific integer
(2,6,7) Any one of the specific integers in this group.
!(2,6,7) Anything except one of the integers in this group.
(2 to 20) Any integer in this range (including both 2 and 20).
!(2 to 20) Any integer outside this range.
(0,2,...) Any integer part of this infinite sequence. Sequences have to be at least two integers long, and every subsequent integer has to be bigger than the previous one (sorry, that may be a temporary limitation, don't know yet).
(0,2,...,48) Any integer part of this finite sequence. You can optionally provide a single sequence limit after the three dots.
!(3,5,...) Any integer not part of this infinite sequence. The sequence doesn't extend to the left, only towards the right. So this rule would select the numbers 0, 1, 2, 4, 6, 8, 10, 12 and all remaining even numbers.
!(7,10,21,...,425) Any integer not part of this finite sequence.
Furthermore, it is possible to combine two or more rules using the boolean and/or operators. If you want to select the first five items in every list of a datatree and also the items 7, 12 and 42, then the selection rule would look as follows:
{*}[(0 to 4) or (6,11,41)]
The asterisk allows you to include all branches, no matter what their paths looks like.
It is at present not possible to use the parenthesis to define rule precedence, rules are always evaluated from left to right. It is at present also not possible to use negative integers to identify items from the end of a list.
If you want to know more, join the Webinar on Wednesday!
--
David Rutten
david@mcneel.com
Seattle, WA…
Added by David Rutten at 8:57pm on November 3, 2013
y using the Honeybee_Update Honeybee component.
The video below (best viewed in full-screen mode) provides an idea of what these components are capable of being used for:
The video below shows how these components can be used in an existing Honeybee project (for additional links please open this video in youtube):
I have uploaded two examples as Hydra files that show how these components can be used for grid-point and image-based simulations:
Example1 : Grid Point Calculations
Example2: Image based simulation
Finally, a more esoteric application is demonstrated in this video:
These components are still in the beta-testing stage. Some of the limitations of the components are:
1. Only Type C photometry IES files are supported at present.
2. Rhino is likely to get sluggish if there are too many luminaires (i.e. light fixtures) present in a scene.
3. Due to the spectral limitations of the ray-tracing software (RADIANCE), simulations involving color mixing might not be physically realizable.
Additional details about photometric and spectral calculations are probably an overkill for this forum. However, I'd be glad to answer any related questions. Please report any bugs or request new features either on this forum or on Github.
Mostapha, Leland Curtis, Reinhardt Swart and Dr. Richard Mistrick provided valuable inputs during the development of these components.
Thanks,
Sarith
Update 16th January 2017:
An example with some new components and bug fixes since the initial release announcement can be found here
…
Introduction to Grasshopper Videos by David Rutten.
Wondering how to get started with Grasshopper? Look no further. Spend an some time with the creator of Grasshopper, David Rutten, to learn the
of the new challenges presented to the society and architecture in Portugal. With technological developments, tools once limited to not creative areas begin to be part of the everyday life of students in University Architecture Laboratories and change its design processes. The architecture design methods are changing rapidly with the introduction of CAD-CAM software’s. In recent years, new software’s have been available for 3D representation and digital fabrication, which have allowed creating new ways of interacting with the computer and architecture. Contemporary architecture in its various scales, seeks greater flexibility, adaptability and interactivity taking into account both the means and goals of kinetic systems. Thus, it is essential to the creative industry players to acquire new knowledge about the latest technological innovations and how they can solve some of the problems and challenges of today’s society.
The workshop will explore the use of Grasshopper, Firefly and Arduino as creative and technical tools in all the design process, to simulation and prototype 3D interactive architecture solutions.
The theoretical and practical workshop (64 hours) taught in English and Portuguese, will be composed of two modules: (1) LS_01: Firefly +Grasshopper + Arduino and Scale Model Fabrication; (2) LS_02: Design Studio – Discursive Wall.
This workshop is intended for students and professionals from different areas of knowledge, (architecture, design, fine arts, engineering, music and programming) who are interested in the process of design: from ideation to prototyping. The participants will generate scale models.
Registration is limited to 20 participants with or without software knowledge. Participants will work individually and in group. Participants must take their own laptops to the workshop. Registrants should complete the form by 28 February 2012. Once registered, you will receive an email confirming your acceptance.
Questions or doubts contact us:
alivingsystem@gmail.com
…
Added by Brimet Silva at 7:07pm on January 16, 2012