whole design intent, but this is what Inventor is good at. The way it packages bits of 'scripted' components into 'little models' that can be stored and re-assembled is central to MCAD working.
The Inventor model shown is almost 5 years old. We don't model like that any more, however it does offer a good idea of general MCAD modeling approaches.
iParts is useful in certain situations, it could've been useful in the above model, its usefulness is often in function of the quantity of variants/configurations.
So much is scripted in GH, maybe it should also be possible to script/define/constrain/assist the placement/gluing of the results?
...
Starting point: I think we are talking across purposes. AFAIK, the solving sequence of GH's scripted components is fixed. It won't do circular dependencies... without a fight. The inter-component dependencies not 'managed' like constraints solvers do for MCAD apps.
Components and assemblies are individual files in MCAD.
Placement of these within assemblies in MCAD is a product of matrix transforms and persistent constraints. There is no bi-directional link, the link is unidirectional (downflow only), because of the use of proxies.
Consequently, scripting the placement of components is irrelevant in GH, unless you decide that each component needs to be contained in its own separate file.
This also brings up the point that generating components and assemblies in MCAD is not as straightforward. In iParts and iAssemblies, each configuration needs to be generated as a "child" (the individual file needs to be created for each child) before those children can be used elsewhere.
You notice the dilemma, if you generate 100 parts, and then you realize you only need 20, you've created 80 extra parts which you have no need for, thus generating wasteful data that may cause file management issues later on.
GH remains in a transient world, and when you decide to bake geometry (if you need to at all), you can do that in one Rhino file, and save it as the state of the design at that given moment. Very convenient for design, though unacceptable for most non-digital manufacturing methods, which greatly limits Rhino's use for manufacturing unless you combine it with an MCAD app.
One of the reasons why the distributed file approach makes perfect sense in MCAD, is that in industry you deal with a finite set of objects. Generative tools are usually not a requirement. Most mechanical engineers, product engineers and machinists would never have any use for that.
The other thing that MCAD apps like Inventor have, is the 'structured' interface that offers up all that setting out information like the coordinate systems, work planes, parameters etc in a concise fashion in the 'history tree'. This will translate into user speed. GH's canvas is a bit more freeform. I suppose the info is all there and linked, so a bit of re-jigging is easy. Also, see how T-Flex can even embed sliders and other parameter input boxes into the model itself. Pretty handy/fast to understand, which also means more speed.
True. As long as you keep the browser pane/specification tree organized and easy to query.
:)
Would love to understand what you did by sketching.
I'll start by showing what was done years ago in the Inventor model, and then share with you what I did in GH, but in another post.
Let's use one of the beams as an example:
We can isolate this component for clarity.
Notice that I've highlighted the sectional sketch with dimensions, and the point of reference, which is in relation to the CL of the column which the beam bears on. The orientation and location of the beam is already set by underlying geometry.
Here's a perspective view of the same:
The extent of the beam was also driven by reference geometry, 2 planes offset from the beam's XY plane, driven by parameters from another underlying file which serves as a parameter container:
Reference axes and points are present for all other components, here are some of them:
It starts getting cluttered if you see the reference planes as well:
Is I mentioned earlier, over time we've found better ways to define and associate geometry, parameters, manage design change, improving the efficiency of parametric models. But this model is a fair representation of a basic modeling approach, and since an Inventor-GH comparison is like comparing apples and oranges anyways, this model can be used to understand the differences and similarities, for those interested.
I haven't even gotten to your latest post yet, I will eventually.…
Added by Santiago Diaz at 10:36am on February 26, 2011
u might already noticed.
Second great thing is that is quite fast, precise and versatile (for this kind of things); also is way OPEN (meaning you can attach and or interface it with almost anything you can imagine, meaning hardware, and other sw components, etc (like a CNC machine (additive manufacturing toys..) or any sw like C# component)) making a GREAT HUGE difference with almost any other CAD (and CAM sw i must say)
i made a simple fully functional CAM component - highly powerful ! - in a couple of days...
also tested an arduino interface (meaning control over almost any elctronic device out there)... in a matter of hours...
and saw and can easily think about lots and lots of extremely cool usages of this great tool in almost any area ...
So that's why i would suggest - and will do something about for - it (or similar tools) to be teached at first stages of education !
But power comes with responsability. and is far better exploited when your are smart ;)
I think people that uses GH will be n-times as good when they don`t forget manufacturing.
This includes teachers btw....
Interesting thing to account is that all things that GH is great at (a LOT) means reducing dramatically the time spent to model almost anything...
But usually the purpose (unless the objective is just learning or doing some kind of virtual art (both legal stuff btw...;) but guess it might not be your case now and after graduating..)) is to end up by actually building some real 3D stuff...
So what Joseph is poining is key...
If you have a good teacher.. i guess it should pay more and more attention not just at your gh skills but rather the way in which you use the power, versatility and extra time gh (and additive manufacturing tech) saves, to think about how to design the stuff focusing on the ultimately relevant stuff...
optimisation...
So..
I would say that any heat interchanger like the one involved in your thesis, has to deal with fluids.. have to account for some sort of life span (involving cheaper an ideally no maintenance needed along its life...), and of course also critical the costs of manufacturing.
so... be the best one...
use GH smartly ! ie...
account for different profile paths for oil and water.. they're different fluids meaning they have different specific heat, viscosity, blah... and so... they might not even traverse the interchanger at same flow ratio, etc.
So... maybe you want to start by reshaping the grid... (parametrically...!) so you can arbitrarily and dynamically modify and get to see interactively in your definition the areas ratio of sections so as to finaly get to set the "ideal" (meainng optimum) relative areas (sections) ratio of oil to water paths... (or whatever other fluids could be !), and the material also...
Secondly you might also consider that triangles might not be well suited for the conduit sections because are not the best shape to carry most fluids... (hoses are of circular sections...worst case are kinda rectangular with rounded corners..;) not only because the're easy to manufacture but also because they minimise (optimize) flowing energy losses AND are less prone to (ie salt or debree deposits in the interior) ). so think about rounded shapes, of if you want some regular polygons stuff but 5 or more faces...kinda circular...got it ?
I love bees by the way..
and if you happen to need more interchange area (obviously another (and probably the #1 key one) figure you should be displaying interactively in your definition ) you can always add some more extrusion length...
third... the twisting stuff is cool... (artistically ;)) but i 100% agree with Joseph is far likely to involve higer costs for manufacturing with no clear benefit on surface maximization... and most probably some other losses in added friction to the flow of fluids (meaning higher costs for pumping, etc...)...
fourth...
consider the area, (then the volume!) of the "building material"... you should optimise that too ! so this could be another one of your interactive displays...
in this case... you not only can see optimisation by reducing the amount of materials to build your interchanger...
but you can also notice that if the "building tech" involves the well and common additive manufacturing process of extrusion deposits... that surface area, and that extrusion length, meaning volume and cost of raw material, also mean TIME to manufacture... and i guess you teacher will find good for you to consider and mention that one too...
fifth...
finally (for now hehe), and globally most important in the short term :)
if the objective of yor teacher is for you just to learn GH and impress him and the rest of the world then, ok, do the twist the swirl and imagine all kind of sea star and or ondulated conduit sections (maybe some recursive forms (fractals...) like snowflakes... or any n-arms (mutant !) starfishes shapes) but make sure you first get to know and validate what it will be the objectives of your evaluator...
.. in the near end this is all about passing your thesis while learning GH while having fun.. isn't it ?
go for it and best of luck !
ps: for the mid and long term.. some day take a look at linear optimisaton if you already didn't.
i think GH is a great tool to try out some linear optimisation stuff directly linking geometry related figures (areas, volumes...) along with costs figures !...
I haven't seen anything like that yet (but since i'm only a few months old in gh, i think is likely to already be something or this stuff out there. )
If not... well you can always be the first !
(and this particular case of your thesis is a great example (few key variables) to try out "automatic optimisation")
https://en.wikipedia.org/wiki/Simplex_algorithm
that... by the way...has lots to do with spatial geometry...
…
ere I'm using a GH_ObjectWrapper type. This may not be the best way about doing this, but it does work.
localSettings of type EM_Settings is the data that gets wrapped and then added to the Parameter.
Whilst everything works fine first time around, when I re-open the GH file the persistent data is lost. I need to serialize the data in some way in order to write it to a GH file and I'm not entirely sure how to do this.... I've tried for quite a while now, looking through the forum & SDK which offer clues but no joy... so I'm admitting defeat and running here!!!
Here are some of the CS bits:
public class MyComponent : GH_Component { ......... private EM_SettingsParam myParam;
private EM_Settings localSettings;
private EM_Settings mySettings;
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pm) {
... myParam = new EM_SettingsParam(); EM_Settings localSettings = new EM_Settings(); myParam.PersistentData.Append(new GH_ObjectWrapper(localSettings)); pm.AddParameter(myParam, "Settings", "Se", "MySettings", GH_ParamAccess.item); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_ObjectWrapper temp = new GH_ObjectWrapper(); if (!DA.GetData(5, ref temp)){ return; } mySettings = (EM_Settings)temp.Value;
...
} } public class EM_SettingsParam : GH_PersistentParam<GH_ObjectWrapper> { public EM_SettingsParam(): base(new GH_InstanceDescription("Settings", "Settings", "Represents a collection of Settings", "Params", "Primitive")) { } ...blah singular blah plural blah exposure.hidden blah... } public class EM_Settings { public bool Preview {get; set;} // (more parameters here) public EM_Settings() { Preview = true; }
}
Any help much appreciated $:)
John.…
t. This was a reasonably effective workflow for the purposes of solving the initial problem. (in reviewing this post, it seems a bit lengthy, but hopefully it's of use to others).
Link to Illustrator Script example:https://forums.adobe.com/thread/508138
Portion I used: This applies to entire illustrator document. I am using Illustrator CC 64 bit and this worked okay. Tested a few times and it failed once, but a restart of Illustrator fixed it.
var v_selection = app.activeDocument.pathItems;SwapFillStroke(v_selection); function SwapFillStroke(objSel) { for(k = 0; k < objSel.length; k++){ var subSel = objSel[k]; var c_fill = subSel.fillColor; var c_stroke = subSel.strokeColor; subSel.fillColor = c_stroke; if(!subSel.stroked) subSel.stroked = true; subSel.strokeColor = c_fill; }} redraw();
My goal was to export colored geometry, (analysis meshes for example), from Rhino and get it into illustrator with solid fills.
If you want to know how meshes are colored in rhino...there are many explanations here on the forum, a quick search will get you more detailed information.
Short version: export your lines from rhino to illustrator and run the script listed above to make the stroke color the fill color. (in illustrator, shift+X will swap the fill and stroke colors on individual objects, but does not work on multiple objects..hence the need for the script).
Detailed Version:
In my case, I had 2 case studies I was working with.1 - wind rose meshes generated from Ladybug/honeybee2 - A mesh terrain that was colored by pre-set slope values.
NOTE: There are a few plugins to bake objects with color. I used Human tools, (Bake Geometry and JustifiedText3D).http://www.grasshopper3d.com/group/human (lots of other great stuff in there too!)
I had two types of geometry. (2 different definitions)
1- An analysis mesh, (HoneyBee/LadyBug),
2 - Lines generated from mesh faces. (mesh terrain/slope values).
Export results as a DXF, and choose "do not explode". (these were my settings)
DXF seemed to produce the most consistent results.
(you could export/save as an AI file and just open them in illustrator, but that seemed to give inconsistent results with the script).
Open DXF in Illustrator:
Apply Script in illustrator:
In the terrain example, there are only 5 colors, so selection in illustrator, by color, is very easy. In the results from honeybee/ladybug, (or any analysis process I imagine), the default colors are created with a much wider range of values. I presume the legend is then created by an average of those values within a range. My point is that, with the analysis results, selecting objects by color in Illustrator is probably not a very effective workflow.
I only tested this on my instance of rhino and Illustrator. mileage may vary.
In summation, at this point, it seems that the best way to get colored mesh faces, into illustrator, is to export the meshes, (which really ends up being the mesh face edges...curves), and bringing them into illustrator and running a quick script to swap the colors. Once that is complete, you can then select ALL the objects, and change the stroke color/weight at once.…
as mine but couldn't manage to make it work.
The following script was working on the python module in Rhino, but not in Ghpython.
Note that I have imported a library, and it seems to be importing on Ghpython
--------------------------------------------------------------------------------------------------
from khepri.rhino import *
def iterate_quads(f, ptss):
return [[f(p0, p1, p2, p3)
for p0, p1, p2, p3
in zip(pts0, pts1, pts1[1:], pts0[1:])]
for pts0, pts1
in zip(ptss, ptss[1:])]
def iterate_hexagono(pts, n, v):
return iterate_quads(lambda p0, p1, p2, p3: hexagono_quad(p0, p1, p2, p3, n, v), pts)
def hexagono_quad(p0, p1, p2, p3, n, v):
def chapa(pts):
return intersection(extrusion(line(pts), 280), shape_from_ref(v.copy_ref(v.realize()._ref)))
#return extrusion(line(pts), -40)
topo = intermediate_loc(p3, p2) + vx(distance(p3, p2)/4 * n), intermediate_loc(p3, p2) - vx(distance(p3, p2)/4 * n)
base = intermediate_loc(p0, p1) + vx(distance(p0, p1)/4 * n), intermediate_loc(p0, p1) - vx(distance(p0, p1)/4 * n)
lateral_esq = intermediate_loc(p3, p0), intermediate_loc(p3, p0) + vx(distance(intermediate_loc(p3, p0),intermediate_loc(p2, p1))/4 * n)
lateral_dir = intermediate_loc(p2, p1), intermediate_loc(p2, p1) - vx(distance(intermediate_loc(p2, p1),intermediate_loc(p3, p0))/4 * n)
conex_1 = intermediate_loc(p3, p2) - vx(distance(p3, p2)/4 * n), intermediate_loc(p3, p0) + vx(distance(intermediate_loc(p3, p0),intermediate_loc(p2, p1))/4 * n)
conex_2 = intermediate_loc(p3, p0) + vx(distance(intermediate_loc(p3, p0), intermediate_loc(p2, p1))/4 * n), intermediate_loc(p0, p1) - vx(distance(p0, p1)/4 * n)
conex_3 = intermediate_loc(p0, p1) + vx(distance(p0, p1)/4 * n), intermediate_loc(p2, p1) - vx(distance(intermediate_loc(p2, p1),intermediate_loc(p3, p0))/4 * n)
conex_4 = intermediate_loc(p2, p1) - vx(distance(intermediate_loc(p2, p1),intermediate_loc(p3, p0))/4 * n), intermediate_loc(p3, p2) + vx(distance(p3, p2)/4 * n)
return chapa(topo), chapa(base), chapa(lateral_esq), chapa(lateral_dir), chapa(conex_1), chapa(conex_2), chapa(conex_3), chapa(conex_4)
s = prompt_shape("Escolha superficie")
v = prompt_shape("Escolha solido")
iterate_hexagono(map_surface_division(lambda p:p, s, 5, 15), 0.5, v)
---------------------------------------------------------------------------------------------------
I imported the geometry from another cad software, and then I would select the surface and solid to perform a pattern iteration on the surface to be constrained inside the solid as a internal structure.
The problem is that the surface comes with u, v and normals all weird from the other software so I wanted to pass it through Grasshopper so I can get more control and also perform other computations on Gh on the Ghpython output. Sorry, maybe I’m over complicating. All I want is the Gh inputs working on Ghpython.
I’ll attach the Gh definition,. Need help with the Ghpython component, the rest is just me fooling around.
When I try to run the sript in Ghpython I get:
Runtime error (MissingMemberException): 'NurbsSurface' object has no attribute 'realize'
Traceback:
line 39, in map_surface_division, "<string>"
I'm also attaching the module I've imported
Any help will be very appreciated and sorry about my english
Thanks!
…
r." I'm sorry to hear that, I take the interface and ease-of-use rather seriously so this sounds like a fundamental failure on my part. On the other hand, Grasshopper isn't supposed to be on a par with most other 3D programs. It is emphatically not meant for manual/direct modelling. If you would normally tackle a problem by drawing geometry by hand, Grasshopper is not (and should never be advertised as) a good alternative."What in other programs is a dialog box, is 8 or 10 components strung together in grasshopper. The wisdom for this I often hear among the grasshopper community is that this allows for parametric design."Grasshopper ships with about 1000 components (rounded to the nearest power of ten). I'm adding more all the time, either because new functionality has been exposed in the Rhino SDK or because a certain component makes a lot of sense to a lot of people. Adding pre-canned components that do the same as '8 or 10 components strung together' for the heck of it will balloon the total number of components everyone has to deal with. If you find yourself using the same 8 to 10 components together all the time, then please mention it on this forum. A lot of the currently existing components have been added because someone asked for it."[...] has a far cleaner and more intuitive interface. So does SolidWorks, Inventor, CATIA, NX, and a bunch of others."Again, GH was not designed to be an alternative to these sort of modellers. I don't like referring to GH as 'parameteric' as that term has been co-opted by relational modellers. I prefer to use 'algorithmic' instead. The idea behind parameteric seems to be that one models by hand, but every click exists within a context, and when the context changes the software figures out where to move the click to. The idea behind algorithmic is that you don't model by hand.This is not to say there is no value in the parametric approach. Obviously it is a winning strategy and many people love to use it. We have considered adding some features to GH that would make manual modelling less of a chore and we would still very much like to do so. However this is such a large chunk of work that we have to be very careful about investing the time. Before I start down this road I want to make sure that the choice I'm making is not 'lame-ass algorithmic modeller with some lame-ass parametrics tacked on' vs. 'kick-ass algorithmic modeller with no parametrics tacked on'.
Visual Programming.I'm not exactly sure I understand your grievance here, but I suspect I agree. The visual part is front and centre at the moment and it should remain there. However we need to improve upon it and at the same time give programmers more tools to achieve what they want.
Context sensitivity."There is no reason a program in 2014 should allow me to make decisions that will not work. For example, if a component input is in all cases incompatible with another component's output, I shouldn't be able to connect them."Unfortunately it's not as simple as that. Whether or not a conversion between two data types makes sense is often dependent on the actual values. If you plug a list of curves into a Line component, none of them may be convertible. Should I therefore not allow this connection to be made? What if there is a single curve that could be converted to a line? What if you want to make the connection now, but only later plan to add some convertible curves to the data? What you made the connection back when it was valid, but now it's no longer valid, wouldn't it be weird if there was a connection you couldn't make again?I've started work on GH2 and one of the first things I'm writing now is the new data-conversion logic. The goal this time around is to not just try and convert type A into type B, but include information about what sort of conversion was needed (straightforward, exotic, far-fetched. etc.) and information regarding why that type was assigned.You are right that under some conditions, we can be sure that a conversion will always fail. For example connecting a Boolean output with a Curve input. But even there my preferred solution is to tell people why that doesn't make sense rather than not allowing it in the first place.
Sliders."I think they should be optional."They are optional."The “N” should turn into the number if set."What if you assign more than one integer? I think I'd rather see a component with inputs 'N', 'P' and 'X' rather than '5', '8' and '35.7', but I concede that is a personal preference."But if I plug it into something that'll only accept a 1, a 2, or a 3, that slider should self set accordingly."Agreed.
Components."Give components a little “+” or a drawer on the bottom or something that by clicking, opens the component into something akin to a dialog box. This should give access to all of the variables in the component. I shouldn't have to r-click on each thing on a component to do all of the settings."I was thinking of just zooming in on a component would eventually provide easier ways to access settings and data."Could some of these items disappear if they are contextually inappropriate or gray out if they're unlikely?"It's almost impossible for me to know whether these things are 'unlikely' in any given situation. There are probably some cases where a suggestion along the lines of "Hey, this component is about to run 40,524 times. It seems like it would make sense to Graft the 'P' input." would be useful.
Integration."Why isn't it just live geometry?"This is an unfortunate side-effect of the way the Rhino SDK was designed. Pumping all my geometry through the Rhino document would severely impact performance and memory usage. It also complicates the matter to an almost impossible degree as any command and plugin running in Rhino now has access to 'my' geometry."Maybe add more Rhino functionality to GH. GH has no 3D offset."That's the plan moving forward. A lot of algorithms in Rhino (Make2D, FilletEdge, Shelling, BlendSrf, the list goes on) are not available as part of the public SDK. The Rhino development team is going to try and rectify this for Rhino6 and beyond. As soon as these functions become available I'll start adding them to GH (provided they make sense of course).On the whole I agree that integration needs a lot of work, and it's work that has to happen on both sides of the isle.
Documentation.Absolutely. Development for GH1 has slowed because I'm now working on GH2. We decided that GH1 is 'feature complete', basically to avoid feature creep. GH2 is a ground-up rewrite so it will take a long time until something is ready for testing. During this time, minor additions and of course bug fixes will be available for GH1, but on a much lower frequency.Documentation is woefully inadequate at present. The primer is being updated (and the new version looks great), but for GH2 we're planning a completely new help system. People have been hired to provide the content. With a bit of luck and a lot of work this will be one of the main selling points of GH2.
2D-ness."I know you'll disagree completely, but I'm sticking to this. How else could an omission like offsetsurf happen?"I don't fully disagree. A lot of geometry is either flat or happens inside surfaces. The reason there's no shelling (I'm assuming that's what you meant, there are two Offset Surface components in GH) is because (a) it's a very new feature in Rhino and doesn't work too well yet and (b) as a result of that isn't available to plugins.
Organisation.Agreed. We need to come up with better ways to organise, document, version, share and simplify GH files. GH1 UI is ok for small projects (<100 components) but can't handle more complexity.
Don't get me wrong, I appreciate the feedback, I really do, but I want to be honest and open about my own plans and where they might conflict with your wishes. Grasshopper is being used far beyond the boundaries of what we expected and it's clear that there are major shortcomings that must be addressed before too long. We didn't get it right with the first version, I don't expect we'll get it completely right with the second version but if we can improve upon the -say- five biggest drawbacks (performance, documentation, organisation, plugin management and no mac version) I'll be a happy puppy.
--
David Rutten
david@mcneel.com…
ou will see a list of potential matches, sorted from most relevant to least relevant:
Some components and objects support initialisation codes, which means you can assign certain values directly from the popup box. You can do this by adding an equals symbol after the name and then the value you wish to assign. For example, the [Curve Offset] component allows you to specify the offset distance via the popup box by typing =5 after the offset command:
However the popup box also supports a set of special formats that allow you to create specific objects without even typing their names. As of 0.9.0077 (which hasn't been released yet at the time of writing) you can use the following shortcuts to create special objects. In the notation below optional parts of a format will be surrounded by square brackets and hashes (#) will be used to indicate numeric values. So #,#[,#] means;
at least two numeric values separated by a comma, with an optional second comma and third number.
A complete list of special formats (not all of these are supported yet in 0.9.0076):
"∙∙∙ If the format starts with a double quote, then the entire contents (minus any other double quotes) will be placed into a Text Panel.
//∙∙∙ If the format starts with two forward slashes, then the entire contents will be placed in a Text Panel.
~∙∙∙ If the format starts with a tilde, then the entire contents will be placed in a Scribble object.
#,#[,#] If the format contains two or three numerics separated by commas, a Point parameter will be created with the specified coordinates.
+[#] If the format starts with a plus symbol followed by a numeric, then an Addition component will be created.
-[#] If the format starts with a minus symbol followed by a numeric, then a Subtraction component will be created.
*[#] If the format starts with an asterisk symbol followed by a numeric, then a Multiplication component will be created.
/[#] If the format starts with a forward slash symbol followed by a numeric, then a Division component will be created.
\[#] If the format starts with a backward slash symbol followed by a numeric, then an Integer Division component will be created.
%[#] If the format starts with a percent symbol followed by a numeric, then a Modulus component will be created.
&[∙∙∙] If the format starts with an ampersand symbol, then a Concatenation component will be created.
=[∙∙∙] If the format starts with an equals symbol, then an Equality component will be created.
<[*] If the format starts with a smaller than symbol, then a Smaller Than component will be created.
>[*] If the format starts with a larger than symbol, then a Larger Than component will be created.
[# *] Pi If the format contains the text "Pi" with an optional multiplication factor, then a Pi component will be created.
# If the format can be evaluated as a single numeric value, then a Slider will be created with the specified initial value and sensible™ lower and upper limits.
#<# If the format contains two numerics separated by a smaller than symbol, a Slider with the specified limits will be created. The initial slider value will be equal to the lower limit.
#<#<# If the format contains three numerics separated by a smaller than symbol, a Slider with the specified limits will be created. The initial slider value will be the value in the middle.
#..# If the format contains two numerics separated by two or more consecutive dots, a Slider with the specified limits will be created. The initial slider value will be equal to the lower limit.
#..#..# If the format contains three numerics separated by two or more consecutive dots, a Slider with the specified limits will be created. The initial slider value will be the value in the middle.
#/#/[#] If the format contains two or three numerics separated by forward slashes, a Calendar object will be created. The order of value is day/month/year. If year is omitted then the current year is used. Note that a second slash is required because #/# is interpreted as a number and thus results in a Slider.
#:#[:#] [am/pm] If the format contains at least two numerics separated by a colon, a Clock object is created. Seconds are optional, as are am/pm suffixes.
f([...[,...[,...]]]) [= *]If the format starts with a lower case f followed by an opening bracket, an Expression component is created. A list of comma separated arguments can be provided as inputs, and anything after the optional equals symbol becomes the expression string.
Note that decimal places will be harvested from formats that indicate sliders. I.e. the format 0..2..10 is not the same as 0..2..10.00, as the former will create an integer slider from zero to ten whereas the latter will create a floating point slider with two decimal places from zero to ten.…
Added by David Rutten at 3:24pm on February 18, 2013
This blog post is a rough approximation of the lecture I gave at the AAG10 conference in Vienna on September 21st 2010. Naturally it will be quite a different experience as the medium is quite…
Added by David Rutten at 3:27pm on September 24, 2010
ager As Grasshopper.Kernel.GH_Component.GH_InputParamManager)
pManager.AddTextParameter(
"Name", "N", "String", GH_ParamAccess.item)
pManager.AddPointParameter(
"Point", "P", "Point3d", GH_ParamAccess.item)
pManager.AddGenericParameter(
"Local Axis", "LA", "Null/Surface/Plane", GH_ParamAccess.item)
pManager.AddGenericParameter(
"Support", "S", "I_Model_Support", GH_ParamAccess.item)
pManager.AddGenericParameter(
"PointLoad", "PL", "List (of I_Model_PointLoad)", GH_ParamAccess.list)
pManager.AddGenericParameter(
"Group", "G", "List (of (I_Model_Group)", GH_ParamAccess.list)
End Sub
Protected Overrides Sub RegisterOutputParams(ByVal pManager As Grasshopper.Kernel.GH_Component.GH_OutputParamManager)
pManager.AddGenericParameter(
"Node", "N", "I_Model_Node",GH_ParamAccess.item)
End Sub
Protected Overrides Sub SolveInstance(ByVal DA As Grasshopper.Kernel.IGH_DataAccess)
Dim inName As String = Nothing
Dim inP As Point3d = Nothing
Dim inLA As Plane = Nothing
Dim inS As I_Model.I_Model_NodeSupport = Nothing
Dim inPL As New List(Of I_Model.I_Model_PointLoad)
Dim inG As New List(Of I_Model.I_Model_Group)
Dim outNode As I_Model.I_Model_Node
If Not DA.GetData(0, inName) Then Return
If Not DA.GetData(1, inP) Then Return
If Not DA.GetData(2, inLA) Then Return
If Not DA.GetData(3, inS) Then Return
If Not DA.GetData(4, inPL) Then Return
If Not DA.GetData(5, inG) Then Return
Dim IM_P As I_Model_Node
IM_P =
New I_Model_Node(inP, Nothing, inName)
If Not DA.GetData(2, inLA) Then IM_P.SetLocalAxis(inLA)
If Not DA.GetData(3, inS) Then IM_P.SetSupport(inS)
If Not DA.GetData(4, inPL) Then
Dim PL As I_Model_PointLoad
For Each PL In inPL
IM_P.AddPointLoad(PL)
Next
End If
If Not DA.GetData(5, inG) Then
Dim G As I_Model_Group
For Each G In inG
IM_P.AddToGroup(G)
Next
End If
outNode = IM_P
DA.SetData(0, outNode)
End Sub
…
Added by Daniel Bosia at 9:22am on January 11, 2013
tal at food4Rhino:
http://www.food4rhino.com/project/ladybug-Honeybee?ufh
Before addressing the changes in the software itself, we would like to announce the start of two new resources that have been added to help everyone learn and share knowledge across our community.
NEW RESOURCES
GH Example File Sharing - After recognizing how important example files are for sharing knowledge and capabilities in our community, we have initiated a github-based platform for sharing Grasshopper definitions called Hydra:https://hydrashare.github.io/hydra/index.htmlWhile the database of files is a little over 50 files at the moment, it is hoped that this will become THE forum where much of collective knowledge is exchanged and shared into the future. As you can see by clicking on any of the examples, you now are able to get a high-res visual of both the Rhino scene and the GH canvas without having to download files to your machine. Furthermore the search functionality through the database enables you to quickly and easily see all that our community has contributed on certain subjects (just by searching “shade” or “wind” for example).In addition to other files that have been contributed, you can find all of the original Ladybug examples here:https://hydrashare.github.io/hydra/index.html?keywords=LBExampleFilesAnd all of the original Honeybee examples here:https://hydrashare.github.io/hydra/index.html?keywords=HBExampleFiles
LB+HB Documentation - While our historical practice of including all documentation within component descriptions may have sufficed up until this point, we have since recognized that an online database of all this documentation would be helpful. Now, you can search for key terms throughout the entire documentation of the project in our beautiful online documentation database created by Mostapha:https://www.gitbook.com/book/mostapharoudsari/ladybug-primer/detailshttps://www.gitbook.com/book/mostapharoudsari/honeybee-primer/details
And now, onto the major changes and enhancements in the software:
LADYBUG
Photovoltaics Components - Based on original code from NREL’s PVWatts (http://pvwatts.nrel.gov), Djordje Spasic and Jason Sensibaugh have built a set of 5 components that perform detailed estimate of the electricity generated by Rhino/Grasshopper surfaces when populated with Photovoltaics (PV) modules.Components allow definition of losses and shading, finding optimal tilt and orientation angles, analysing performance, energy value, consumption and emissions of the PV system.
Enhanced Solar Envelope - Boris Plotnikov has contributed a solar envelope component that is not only much faster and more stable than the previous component but also allows you to input the geometries of buildings for which you would like to ensure solar access. This enables customization of the solar envelope to specific urban contexts in a manner that the previous envelope did not. The component also features a “solar access” option that draws the envelope above which a given site receives sun from a set of sun vectors. An example file can be found here:http://hydrashare.github.io/hydra/viewer?owner=boris-p&fork=hydra&id=SolarEnvelope
Adaptive Comfort Chart - To assist with understanding the variations of the adaptive comfort model, an Adaptive Comfort Chart component has been added that functions in a similar manner to the psychrometric chart for the PMV model. In addition to granting a visualization of the adaptive standard itself, the chart is also particularly helpful for displaying the results of energy simulations in relation to the comfort polygon. The chart is based off of the UC Berkeley Center for the Built Environment’s Comfort Tool (http://comfort.cbe.berkeley.edu/) (https://github.com/CenterForTheBuiltEnvironment/comfort_tool). An example file can be found here:http://hydrashare.github.io/hydra/viewer?owner=chriswmackey&fork=hydra_2&id=Adaptive_Comfort_Chart
Full Support for US + European Thermal Comfort Standards - Ladybug now supports the ability to model any of the variations of the Adaptive/PMV models for both the US (ASHRAE) and European (ISO) standards. This includes varying thresholds of percentage of people dissatisfied (PPD), varying thresholds for humidity ratios, the ability to use either a monthly average or daily running mean temperatures in the adaptive model, and even some functions that are not yet a part of these standards but are referenced widely in thermal comfort research. Such widely referenced functions include the ability to apply the adaptive model’s method to conditioned or mixed-mode buildings as well as the application of the adaptive model to times of the year when it is considered too cold by ASHRAE and the ISO for an adaptive standard. All of these variations on the standards can be accessed through the new “PMV Comfort Parameters” and “Adaptive Comfort Parameters” components. As a final nod to dual support for US/European standards, it is now possible to view the psychrometric chart as a Molier i,x diagram.
EPWMap - After years of struggling with the text-based indexing of the DOE’s epw file database, it is now possible to search for weather files using a map interface and search bar thanks to Mostapha’s recent web interface built with D3 and GoogleMaps (http://mostapharoudsari.github.io/epwmap/). From here on out, the Ladybug “Download EPW” component will direct you to this interface.
“RunItAll” Released as “Fly” - In preparation for future features that will assist with exploring of large multidimensional design spaces, this release of Ladybug includes a component by the name of “Fly” that is meant to run through all of the combinations of a given set of sliders. Those who follow this forum closely might recognize it as a reincarnated version of a component called “RunItAll” that appeared in some older example files. You can find an example file here: http://hydrashare.github.io/hydra/viewer?owner=mostaphaRoudsari&fork=hydra_1&id=Parametric_Daylight_Analysis
Shade Benefit Evaluator Validated + Published - After a long process of testing, the key functions within the comfort and energy shade benefit evaluator components have been validated against several similar software and energy modeling tools. A paper published to the SimAUD conference regarding this validation can be found here: https://www.dropbox.com/s/tvdj6d2giswurew/SIMAUD_Paper12.pdf?dl=0. Special recognition goes to Panagiotis Samaras, who ran many of these intensive tests for his thesis. Along with this validation, there are a few more variables that have been exposed to allow more freedom of running the shade benefit functions including the use of higher sky resolutions and multiple shade benefit test regions for a given shade.
Color Gradient Library - After realizing that several of us wanted quick access to common color gradients that we frequently plug into the Legend Parameters component, we have now added a component called “Color Gradient Library” to do just this. An image displaying all of these gradients can be found here:https://github.com/mostaphaRoudsari/ladybug/blob/master/resources/gradients.jpgAnd an example file showing how to use the library can be found here:http://hydrashare.github.io/hydra/viewer?owner=chriswmackey&fork=hydra_2&id=Color_LibraryIf you feel that there is a common gradient that is currently missing, feel free to start a discussion on our GH group about it and we should include it soon.
Solar Time Available - The Ladybug Sunpath now includes an option to display solar time, which many have found to be more intuitive and easy to work with when designing with solar geometry. Solar time is also useful for minimizing an east vs west bias that can develop in sunlight hour studies without having to generate sun vectors at very small timesteps.
Monthly/Daily Totals for Hourly Data - The Ladybug “Average Data” component now includes the ability to total the values for months and days (as opposed to timply averaging them). This is useful particularly when you want to get monthly or daily values of total energy or visualize these totals on the monthly bar chart.
Increased IP Functionality - This release of Ladybug includes several more features that assist with converting data for an IP audience including the ability to view an IP Psychrometric or Adaptive Chart by plugging in temperature values in Farenheit as well as a number of and new converter components for the following: Wh to BTU, R-Value SI to R-Value IP, m/s to mph, Liters to Gallons. Note that Honeybee is still largely SI (requiring your Rhino model to be in meters to run energy simulations).
Mesh-to-Hatch and Future BakeIt Plans - Given that the current BakeIt_ option has only been implemented on a few components with relatively minimal use, it has been decided that future implementations of BakeIt_ will provide not just a means of recording parametric results in the Rhino scene but will also support a full pathway to vector-based programs (like Illustrator and Inkscape). As such, BakeIt_ will place text in the Rhino scene as actual editable text (not meshes) and colored meshes will be output as groups of colored hatches (so that they appear as color-filled polygons in vector-based programs). In order to give those interested in this future capability a chance to experiment at the present, a “Mesh-To-Hatch” component has been added to the Extra tab.
HONEYBEE
Fully Functional Microclimate Maps - Finally, after a long and arduous thesis followed by a couple of months of bug-fixing, Chris Mackey is pleased to announce that the ability to produce high resolution temperature maps from EnergyPlus results is complete. Together, these maps account for four key variables that produce microclimatic diversity in and around buildings - MRT variation from different surface temperatures, solar radiation shining directly on occupants, average air temperature diversity, and air temperature stratification. In addition to using these 4 variables to produce high-resolution visuals of temperature, it is also possible to produce maps of thermal comfort by using any of the three primary thermal comfort models in Ladybug (PMV, Adaptive, and Outdoor (UTCI)). Support currently exists to produce maps for both indoor and outdoor conditions and, while the temperature values and indoor comfort values currently produced are highly accurate, the outdoor wind speeds are calculated using the simplified assumptions of EnergyPlus and will be revised to enable more accurate accounting for the effects of wind on outdoor comfort in the next stable release. The whole workflow is broken down into eight components that can all be found under the 9 | Energy Energy tab. For some videos showing some time-lapse thermal renderings made from these tools see this video playlist:https://www.youtube.com/playlist?list=PLruLh1AdY-Sj3ehUTSfKa1IHPSiuJU52AFor the full 150-page documentation of the tools produced for Chris’s thesis, see this link:https://www.dropbox.com/s/k4r4rd279y4td9n/Mackey_Thesis.pdf?dl=0Finally, if you want to dive in and produce some comfort maps for yourself, you can find an example file here for indoor maps:http://hydrashare.github.io/hydra/viewer?owner=chriswmackey&fork=hydra_2&id=Indoor_Microclimate_MapAnd an example file here for outdoor maps:http://hydrashare.github.io/hydra/viewer?owner=chriswmackey&fork=hydra_2&id=Outdoor_Microclimate_Map
Thermal Autonomy / Thermal Comfort Percent - In addition to the new thermal mapping capabilities, this release includes the ability to use these maps to calculate a series of spatial thermal comfort metrics that are meant to mirror the metrics currently used to evaluate daylight (daylight autonomy, UDI, etc.). Specifically, these metrics are the following:Thermal Comfort Percent - The percentage of occupied time that a given point in space is thermally comfortable.Thermal Autonomy - The percentage of occupied time that a given point in space is thermally comfortable without the addition of any heating or cooling energy.Overheated Hours - The percentage of occupied time when a given point is space is too hot to be thermally comfortable.Underheated Hours - The percentage of occupied time when a given point is space is too cold to be thermally comfortable.All of these metrics can be accessed through the “Thermal Autonomy Analysis” component and you can find an example file here:http://hydrashare.github.io/hydra/viewer?owner=chriswmackey&fork=hydra_2&id=Comfort_Autonomy
Energy Balance Visualizations - In order to help understand the flow of energy through Honeybee energy models, it is now possible to completely reconstruct the energy balance calculation of EnergyPlus from the energy simulation results. This is facilitated by the new EnergyPlus “Construct Energy Balance” component and some new features added to the monthly bar chart. See here for an example:http://hydrashare.github.io/hydra/viewer?owner=chriswmackey&fork=hydra_2&id=Energy_Balance
More Geometry Control for Glazing - In order to make it faster to assign several different types of glazing geometries to your energy models, the “AddHBGlz” can now be used to add glazing surfaces to HBzones (not just HBsurfaces). Furthermore, the “Glazing Based on Ratio” component now contains several more inputs that enable you to customize window geometry on orthogonal surfaces, including the ability to set the horizontal distance between windows and the ability to split windows vertically into a lower view window and higher daylight window.
Earth Tube Capability - Thanks to the efforts of Anton Szilasi, it is now possible to assign earth tubes to your energy models in order to test the potential of this powerful passive strategy. See here for an example file:http://hydrashare.github.io/hydra/viewer?owner=antonszilasi&fork=hydra&id=HB_EarthTube
North Input For Annual Daylight - After the toil of having to rotate your model any time you wanted to run an annual daylight analysis, we are happy to announce that the annual daylight recipe now contains a working “North” input.
Honeybee Object Transforms - After realizing that many of us wanted to construct energy models of multi-story buildings by duplicating and moving zones, this capability is now easily facilitated with a set of three components to duplicate and transform your HBObjects. Specifically, this includes a component to move (translate) your HBObject, mirror (reflect) your HBObject, and rotate your HBObject. Using these components ensures that any properties that you have assigned to your original HBObject will be present in the transformed HBOjbect, allowing you to build large energy models very quickly. The three components can currently be found under the WIP tab.
And finally, it is with great pleasure that we welcome Boris Plotnikov to the team. As mentioned in the above release notes, Boris has added a highly advanced solar envelope component to the project.
As always let us know your comments and suggestions.
Enjoy!
Ladybug+Honeybee development team
…