igitais de forma criativa e rigorosa, para a concepção de modelos 3D– Familiarizar-se com as lógicas de criação de geometrias tridimensionais NURBS.- Desenvolver técnicas de criação de imagens fotorealistas com o motor de render V-Ray- Introduzir as lógicas paramétricas e associativas processo criativo.- Introduzir novas lógicas de BIM no processo estrutural (Building Information Modeling).# INFORMAÇÕES E INSCRIÇÕESinfo@rhino3dportugal.comAna Fonseca: 917140716 Mais informações disponíveis no site: www.rhino3dportugal.com# FORMADORES Brimet Silva ( Authorized Rhino Trainer )
...................................................
Curso de Rhino3D Nível I
6, 7 e 9 de Julho9h-13h e 14h-18h (sessões diárias de 8h).....................................................Curso de Vray-Nível I
12 e 14 de Julho9h-13h e 14h-18h (sessões diárias de 8h).................................................Curso de Grasshopper Nível I
16 e 18 de Julho9h-13h e 14h-18h (sessões diárias de 8h).................................................
VisualARQ e Rhino BIM- Nível I
21 e 23 de Julho9h-13h e 14h-18h (sessões diárias de 8h)
…
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…
l the changes you want and then close it again, you'll only have to recalculate once, whereas adding 3 inputs via the ZUI would recalculate 3 times right away and once more after you've changed the cluster to hook up the new inputs.
Does the cluster recalculate the entire solution, even though the new input hooks aren't connected to anything? Would it be possible to not recompute (not call ExpireSolution or its equivalent?) when an input parameter is added via the ZUI only? Could this be done by adding a flag on each input hook added by the ZUI, triggering the flag when the input hook is connected to a parameter, and recalculating the cluster only when the flag has been triggered?
Also, the current behavior, I think, is actually different. In order to work with the cluster, you need to see the geometry/data you're working with, so you have to enter the cluster, add the hooks, leave the cluster, connect the hooks to parameters, enter the cluster, play around in Grasshopper, exit the cluster:
Double click cluster.
Navigate to where you want to add new hooks.
Add hook (either from the toolbars, or by copy/pasting existing ones, or by double click search)
Close and Save Cluster. This will cause a new extra-cluster solution which may take some time to complete. (1 ECSOLUTION)
Connect new inputs with relevant parameters in the parent document.
Double click cluster.
Connect hook to relevant parameter. This will cause a new intra-cluster solution which may take some time to complete. (input * ICSOLUTION)
Repeat 7 until satisfied.
Close and Save Cluster. This will cause a new extra-cluster solution which may take some time to complete. (1 ECSOLUTION)
Which comes to: 2 extra-cluster solutions, and N intra-cluster solutions, where N is the number of new inputs. The cluster was opened and closed twice.
Zoom in on cluster.
Click on the (+) symbols to add inputs. Each input added via the ZUI doesn't recompute, since we know that the input hooks created this way aren't connected.
Connect new inputs with relevant parameters in the parent document. Also no new solutions.
Double click cluster.
Navigate to where the new input hooks were created (Perhaps aligned vertically, below the last-most input hook?)
Probably move the hook to a more meaningful location.
Connect hook to relevant parameter. This will cause a new intra-cluster solution which may take some time to complete. (input * ICSOLUTION)
Repeat 7 until satisfied.
Close and Save Cluster. This will cause a new extra-cluster solution which may take some time to complete. (1 ECSOLUTION)
Which comes to: 1 extra-cluster solutions, and N intra-cluster solutions, where N is the number of new inputs. PLUS, you only had to enter/exit the cluster once.
Thanks again, David!
Dan…
Added by Dan Taeyoung at 8:47am on January 11, 2014
ipe Pecegueiro Type of participants Students, graduate students, researchers, professionals Duration 2 days, Sat – Sun Prerequisites 1 / participants skills Experience in Rhino and Grasshopper; programming experience with Processing or Arduino IDE is recommended but not necessary Prerequisites 2 / hardware Participants should bring their own computer with Windows XP or 7 64 bit OS Prerequisites 3 / software Rhinoceros Version 4 sr9, Grasshopper 0.8.0050, Arduino IDE, Processing, Google Earth* *Software versions should be the most updated versions at the time of the workshop. Rhino 5 is also acceptable. Description An associative model is only as relevant as the information it seeks to manage. This workshop will engage the associative model by feeding it with real time and real world data captured through prefabricated sensor nodes known as the Ambient Sensor Kit (ASKit). The ASKit is an Open Hardware platform for personal data collection and sharing. The ASKit project is based on the premise that a personal understanding of the information around us is key to a sustainable and informed habitation of our environment. http://uask.it. Workshop participants will be working with Grasshopper, a generative,logic based design environment where participants will be able associate real world data to their models. Several other tools will be employed including Processing, Pachube, Google Earth, and gHowl (a set of custom components which extend the functionality of Grasshopper). This two day workshop will focus on a specific area in Berlin to understand, through data, the differences between the physical barriers and invisible forces which define certain urban functions. The participants will engage in: - environmental data collection - site surveying with open hardware/DIY electronics - data visualization and analysis - associative modeling with collected data Day 1: Demonstration of ASKit hardware platform for data collection and associative modeling. Data capture session in specific zones in Berlin. Data visualization and associative modeling in Grasshopper. Day 2: Focused Data Capture Session Directed projects applying associative modeling with collected data.…
Added by Luis Fraguada at 11:34am on August 23, 2011
r visual programming tools in the games world. MS's Kodu, looks interesting. Kismet and Visual3d look even more interesting..... mainly because they are more 'interactive' or 'reactive', rather than DAG-based.
Seems like the evolution path for GH-similar apps is:
1. base 3d or CAD app based on C/C++ code.
2. Add scripting language interface
3. Add some kind of visual interface
4. Add graph sorting / propagation engine
5. Re-jig base 3d or CADD app to make managed/interpreted scripts run faster, multi-threaded.
6. Add dynamic typed language, DLR stuff
6. ....
6. Add constraints solver...?
7. Rebuild CAD display engine to be procedural at the GPU level?
Seems like there are available tools for converting scripts into some kind of flowchart. There are even visual debuggers. MS even has something called the 'Debugger Canvas'. Spreadsheet constraints.
Seems like the time is ripe for lots of new apps like GH.
…
4 explode the text
5 select the exploded text, which are now curves, and the border from step 2 and use the planarsrf command again
6 make your surface using the two curves at top and bottom and a section. Use the sweep2 command
7 select your negative text surfaces and use the flowalongsrf command
maybe the scale of the text can be edited by the size of the surface or of the text but I bet you can figure that out! good luck!…
l design.
2/ Optimization
2.1/ in prefabrication
2.2/ combinatorial
2.3/ approach comparisons (i.e. deterministic vs stochastic)
2.4/ share your research
2.5/ ... etc. the list goes on and on
3/ Share you design rationale and how computation fits in
4/ Need help with this problem...
5/ Challenges and workshops announcements
6/ CD News
7/ Share computational design projects under construction or built (akin to skyscrapercity)
8/ and so many other categories and sub-categories...
Just my first thoughts. That breakdown in optimization is just an example. Maybe 'sections' is an old-school way of seeing things, I just wanted to share some thoughts on the kind of content I look forward to seeing. It can be pragmatic topics, but also theoretical, and allow folks to share their projects and research. Some categories are specific, others broad. I suppose I'm interested in community building with regards to computational design. I think SmartGeometry attempted to accomplish this at some point in the past, to some degree. However their focus appears to be in the workshops and challenges.
I recall the silly flame wars that the CG industry had 20 years ago (lame). I'd avoid that, even if it meant forbidding the mention of any specific software in certain areas or in the entire forum. Which would be tricky, but the endless flame wars and silly comparisons were such a waste of everyone's time in CG.
Without dwelling on this too much yet, I think that the software specific questions belong in software specific forums. If we already had a common language for computational design, you'd just need to add the right description as a meta-tag to any Dynamo or Grasshopper forum post, and you'd be able to find analogous solutions in either forum effortlessly, right?
The Dynamo and Grasshopper forums lack design-centric content. The emphasis is generally on the tools and workflow. Computational design is hybrid in essence, it involves both design and computer programming (be it visual or textual). We could really use a forum for knowledge exchange where the expectation is that both are discussed with equal status.
I disagree that such a forum ought to exclude professional programmers. It should include professional programmers whom have an interest in design, and also include professional designers whom have an interest in computer programming, and everyone in between, and enthusiasts, and artists whom are curious about algorithms as a creative medium, and academics, and students, and etc etc. As long as there is rich content and activity on design as well, not only the computational bit, then the crowd will be diverse and we'll all have more to learn from one another.…
this was about some boring building I wouldn't respond ... but here we are talking sardines.
Here's my take on that matter:
1. The 4 C# first create/use a nurbs, then define some random planes (and transformations) and then (a) either they place some humble stripes or ... er ... (b) sardines as instance definitions (NOTE: Load Rhino file first).
2. All important decisions are the ones in yellow groups.
3. You control what you get via this (priority on stripes or sardines? that's the 1M Q):
4. If you decide for sardines (the right thing to do) then you must ENABLE the Sardiniser(C)(tm)(US patent pending) as follows:
5. The vodkaFactor on that Sardiniser C# adds some spice in the sardine placement (it does that by altering the priority on the "composite" transformation in use: first randomly rotate then planeToPlane .... or the other thing?).
6. Only the finest Da Morgada sardines are used in this definition:
7. Spot the WARNING in the filter related with what sardine to choose > do it wrong and no hard disk on your workstation > no risk no fun > sorry Amigos, he he.
8. 1M question for you all: why placing sardines (it's real-time you know) is WAY faster than creating these humble stripes?
9. Although the sardines are placed in real time as regards your CPU ... the critical factor is your GPU (display mode: rendered).
10.Still WIP (dancing sardines in the next update).
have some sardine fun, best, Lord of SardineLand…
ay how many valid permutations exist.
But allow me to guesstimate a number for 20 components (no more, no less). Here are my starting assumptions:
Let's say the average input and output parameter count of any component is 2. So we have 20 components, each with 2 inputs and 2 outputs.
There are roughly 35 types of parameter, so the odds of connecting two parameters at random that have the same type are roughly 3%. However there are many conversions defined and often you want a parameter of type A to seed a parameter of type B. So let's say that 10% of random connections are in fact valid. (This assumption ignores the obvious fact that certain parameters (number, point, vector) are far more common than others, so the odds of connecting identical types are actually much higher than 3%)
Now even when data can be shared between two parameters, that doesn't mean that hooking them up will result in a valid operation (let's ignore for the time being that the far majority of combinations that are valid are also bullshit). So let's say that even when we manage to pick two parameters that can communicate, the odds of us ending up with a valid component combo are still only 1 in 2.
We will limit ourselves to only single connections between parameters. At no point will a single parameter seed more than one recipient and at no point will any parameter have more than one source. We do allow for parameters which do not share or receive data.
So let's start by creating the total number of permutations that are possible simply by positioning all 20 components from left to right. This is important because we're not allowed to make wires go from right to left. The left most component can be any one of 20. So we have 20 possible permutations for the first one. Then for each of those we have 19 options to fill the second-left-most slot. 20×19×18×17×...×3×2×1 = 20! ~2.5×1018.
We can now start drawing wires from the output of component #1 to the inputs of any of the other components. We can choose to share no outputs, output #1, output #2 or both with any of the downstream components (19 of them, with two inputs each). That's 2×(19×2) + (19×2)×(19×2-1) ~ 1500 possible connections we can make for the outputs of the first component. The second component is very similar, but it only has 18 possible targets and some of the inputs will already have been used. So now we have 2×(18×2-1) + (18×2-1)×(18×2-1) ~1300. If we very roughly (not to mention very incorrectly, but I'm too tired to do the math properly) extrapolate to the other 18 components where the number of possible connections decreases in a similar fashion thoughout, we end up with a total number of 1500×1300×1140×1007×891×789×697×...×83×51×24×1 which is roughly 6.5×1050. However note that only 10% of these wires connect compatible parameters and only 50% of those will connect compatible components. So the number of valid connections we can make is roughly 3×1049.
All we have to do now is multiply the total number of valid connection per permutation with the total number of possible permutations; 20! × 3×1049 which comes to 7×1067 or 72 unvigintillion as Wolfram|Alpha tells me.
Impressive as these numbers sound, remember that by far the most of these permutations result in utter nonsense. Nonsense that produces a result, but not a meaningful one.
EDIT: This computation is way off, see this response for an improved estimate.
--
David Rutten
david@mcneel.com
Poprad, Slovakia…
Added by David Rutten at 12:06pm on March 15, 2013
During the the first 3 days we have prepared a training course where the participants will get acquainted with the basic notions and elementary algorithms in Grasshopper. Within the following 4 days you will have to apply your general knowledge in order to design and produce a 1:1 mockup of the digital model.
It’s going to be massive!
_SPECIAL GUESTS:
Andrei Gheorghe [Die Angewandte] Bence Pap [ZHA Architects]
_GUEST:
Alexander Kalachev [AL-TU]
_HOSTS:
Tudor Cosmatu [AL-TU, T_A_I] Andrei Raducanu [T_A_I] Irina Bogdan [T_A_I]
Make sure to keep an eye our blog and keep yourself updated by following our facebook page.
See you at UAUIM, Bucharest on the 23rd of May!…