on Grasshopper, I'd probably research how people use the tools. For example; take a well known architectural shape and make algorithms that duplicate this shape in a number of languages (written English, drawn images, RhinoScript, MEL, AutoLISP, Grasshopper etc. etc.), then compare these different implementations. Which approach allows you to achieve the goal with least steps? Which representation can be most easily explained to others? Which can be most easily changed? and so on and so forth.
Voronoi diagrams are pretty mundane these days. Not that long ago only the best and brightest could use them for architectural purposes, but now everyone who is smart enough to install a plugin can.
One of the truly useful features of Grasshopper (and -of course- programming in general) over traditional approaches is that it can handle vast amounts of data. Given a couple of hours I can create a Voronoi diagram for 500 points by hand, but I would be hard pressed to manually evaluate the year-average of sun light contribution on every vertex of a 10000 point mesh.
If you're looking to do something reasonably innovative (and I think 10~11 weeks is plenty of time for that), I have yet to see someone do 3D isovist data maps of architectural models. I think Grasshopper can be used to at least aid in researching isovist properties of platonic, organic and custom volumes.
Or... a lot of people worry about shadow-casting properties of building envelopes, but nobody seems to be interested in solar reflection via windows and other reflective surfaces.
Or... given the average dioptre of the human eye, what can we say about the level of detail that is perceivable on every square unit of the facade of a 50 story building?
Or... how are grooves in a floor, wall or facade surface perceived as one walks past them? Or take it even further and research the rate of change of visual properties of a bas-relief surface.
--
David Rutten
david@mcneel.com
Poprad, Slovakia…
Added by David Rutten at 4:41am on November 21, 2009
hopper 0.9.0076, EnergyPlusV8-2-7 and my OS is windows 7.
This time i've used small box shaped building, and drag & drop all my components instead of copying from the old file. I have a warning message from Honeybee Run E+ report which is same as below.
And this is the overall definition:
Don't know whats the problem is but my guess is the version of energy plus V8_2_7? Cause the Honeybee_Honeybee component is the one you modified for Energy PlusV8_2, not from the original downloading directory.One thing I've observed is when i boolean toogle E+ simulation on, the calculation windows pops up and disappears so quick. I'm not sure its working properly.
What should i do next to make it work? I can uninstall my rhino and everything or installing it on other computer to check if it works...
Here is the new definition link:
https://www.dropbox.com/s/lvvnfipqpum7b4p/Honeybee%20issue2.gh?dl=0
Regards.
…
g-in, brief theory of complex systems, introduction to multi-agent systems and non-linear design, flocking, Boid library, basic examples - brownian motion, adhesion, separation, alignment, geometry following.-----------------------TIME: first session10am – GMT, London11am – Paris, Brussels, Rome, Vienna, Budapest, Bratislava, Warsaw9pm - Sidney7pm – Tokyo6pm – Beijing, Shanghai, Shenzhen, Hong Kong, Taipei3:30pm – Mumbai3pm – Karachi2pm - Samara1pm – Baghdad, Moscow, St Petersburg12pm – Istanbul, Athens, Helsinki, Cairo, JohannesburgTIME: second session3pm – GMT, London4pm – Paris, Brussels, Rome, Vienna, Budapest, Bratislava, Warsaw7pm – Dubai, Abu Dhabi, Baku6:30pm – Tehran6pm – Baghdad, Moscow, St Petersburg5pm – Istanbul, Athens, Helsinki, Cairo, Johannesburg1pm – Rio de Janeiro, São Paulo, Montevideo12pm – Buenos Aires, Santiago10am – Toronto, New York City, Bogota, Lima9am – Mexico City7am – Los AngelesWEBINARSThe rese arch Grasshopper® sessions are unique for their thorough explanation of all the features, which creates a sound foundation for your further individual development or direct use in the practice. The webinars are divided into four groups: Essential, Advanced, Iterative and Architectural. If you are a Rhinoceros 3D or Grasshopper® newcomer, you are advised to take all the Essential sessions before proceeding to the next level. If none of the proposed topics suit your needs or if you require special treatment, you can request a custom-tailored 1on1 session. All sessions are held entirely in English.The webinars are series of on-line live courses for people all over the world. The tutor broadcasts the screen of his computer along with his voice to the connected spectators who can ask questions and comment in real time. This makes webinars similar to live workshops and superior to tutorials.…
Added by Jan Pernecky at 3:36pm on February 17, 2015
stributes structural supports for a uniformly loaded domain using e.g. the internal energy of the loaded domain as fitness. Here the uniformly loaded domain is represented by the trimmed surface. My genomes are the support positions (green crosses), which are restricted to a set of predefined grid points. I’m currently using an (i,j)-coordinate indexing for these grid points (illustrated in the viewport just below) as opposed to a sequential , “one-dimensional” numbering (illustrated in the viewport further down).
(i,j)-indexing systemAltenative, sequential indexing system
The support positions are computed by two gene pools; one governing the i-index, Gene List {i}, and one governing the j-index, Gene List {j}, of each support. The value of slider 0 in Gene List {i} is paired with the value of slider 0 in Gene List {j} etc. and the amount of sliders corresponds to the amount of supports. The screen shot below depicts the slider constellation corresponding to the support distribution depicted above. Unfortunately the j-index represented in the sliders needs remapping as the number of j-indices vary for each i-index (horizontal row of grid points). With the current setup I have 12^6 x 9^6 = 1,6 x 10^12 different genomes. If I were to use the sequential, “one-dimensional” numbering, I would only use one gene pool with sliders ranging from 0 to 76 meaning that remapping could be avoided and thereby having only 76^6 = 1,9 x 10^11 different genomes.
So, my current genome setup causes a bunch of issues related to the Evolutionary Solver: Remapping Changing one of the j-index sliders, will not necessarily change the related support position but it will still facilitate another genome to be calculated by the solver. (This problem could be eliminated by using the sequential, “one-dimensional” numbering)
Switching slider values around If the values of e.g. slider 0 were to be switched around with the values of slider 5, this again would yield a new genome but an identical solution. (This problem cannot be eliminated by using the sequential, “one-dimensional” numbering)
Coincident support positions Two or more supports may be located in the same position. (This problem cannot be eliminated by using the sequential, “one-dimensional” numbering)
I find it impossible to imagine the fictive “fitness landscape” of this problem and not only because of the multidimensional genome characteristic but just as much because of these listed, intertwined peculiarities. I’ve tried running the Simulated Annealing Solver as well, but my experience is that the Evolutionary Solver yields better results. To my awareness, the solver uses some kind of topographical proximity searcher. This is why, I think that the solving process itself benefits more from analysing the (i,j)-index system, in which neighbouring grid points hold more uniform topographical information than the sequential, “one-dimensional” numbering, which might have big ID-numbering gaps between neighbours. Have I understood this correctly?
Cheers…
f objects with the main ring body, and that cannot be done in parallel since you are modifying the item once at a time, algorithmically.
The original example of a cylinder and sphere are textbook failures of the Rhino 5 dumb algorithm, since that combination features kissing surfaces that confuse Rhino about where they are intersecting since really in tolerance values they are overlapping along a ribbon instead of a sharp line.
Normally you would slightly move or rescale one of the pair to create a single loop intersection curve that doesn't wander around in jerky fashion trying to combine two surfaces that fail to actually plunge through one another.
Your main Boolean union is 116 prongs with a ring base, and that's slow because Rhino bogs down as the model gets more an more complicated with each internal step, I imagine.
The speed is not all that slow either, only 21 seconds for the Booleans themselves.
If you turn of Grasshopper preview meshing via the toolbar menu it should be significantly faster while you are tweaking the design.
To troubleshoot the slow Boolean, I went into Rhino and tried merely splitting the ring body with the prongs and that itself was just about as slow as the Boolean union, so Rhino is not being badass about it. Then I exploded the ring body and tried splitting just that with the prongs and it was *much* faster to operate on just that single surface! The black box reveals itself a bit.
In kind, splitting the prongs with that single surface was about the same speed as splitting it with the whole ring body, so no speed gain there.
But, to speed up your script, since we *cannot* in fact use parallel processing, we can instead manually create that prong surface by doing our own splits and using Grasshopper's natural order of parts, hopefully consistent, to get rid of the junk.
That prong surface is item 4 of an exploded object.
So I will mutually split them and tease out the good parts from the junk and then rejoin the parts, no Boolean union component needed.
First, I went into your prong cluster and removed the capping, so I have merely an open revolution surface instead of a polysurface, letting me access the surface trim command after quickly finding the BrepBrep intersection curves between the prongs and the single ring surface.
For that Boolean union step I'm down from 11 seconds to 4 seconds, but confusingly we added a second to the Boolean difference that follows:
It's fast since we are manually selecting junk instead of Rhino having to sort which is which, I imagine.
We still have a slow Boolean subtraction of the gems and holes from the finished ring body.
That's not simple so will remain slow and cannot be parallel processed since again there's a single main ring body being modified in each step, and nor are there simple pairs of split object to select from manually to discard junk.
…
ow the steps of the successful run when step 1.2 is bypassed (note that the and OpenFOAM session is open in the background while running the Butterfly demo file):
1. create wind tunnel, and use different parameters of (4,4) for _globalRefLevel_ as suggested by Theodoro in this post
2. run blockMesh:
3. run snappyHexMesh:
4. run checkMesh:
5. connect the case from checkMesh to simpleFOAM and run the simulation:
6. the simulation converged at 1865 iteration, but the results visualization part has some problem:
7. so I revised this part according to suggestions from Hagit:
8. and the results can be visualized for P and U values:
The GH file used for the successful run shown above is attached here.
Now, the following is the error I got when the case from the update fvScheme component is used for simpleFOAM simulation:
the warning message on the simpleFOAM component is:
1. Solution exception: --> OpenFOAM command Failed!#0 Foam::error::printStack(Foam::Ostream&) in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so" #1 Foam::sigFpe::sigHandler(int) in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so" #2 ? in "/lib64/libc.so.6" #3 double Foam::sumProd<double>(Foam::UList<double> const&, Foam::UList<double> const&) in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so" #4 Foam::PCG::solve(Foam::Field<double>&, Foam::Field<double> const&, unsigned char) const in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so" #5 Foam::GAMGSolver::solveCoarsestLevel(Foam::Field<double>&, Foam::Field<double> const&) const in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so" #6 Foam::GAMGSolver::Vcycle(Foam::PtrList<Foam::lduMatrix::smoother> const&, Foam::Field<double>&, Foam::Field<double> const&, Foam::Field<double>&, Foam::Field<double>&, Foam::Field<double>&, Foam::Field<double>&, Foam::Field<double>&, Foam::PtrList<Foam::Field<double> >&, Foam::PtrList<Foam::Field<double> >&, unsigned char) const in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so" #7 Foam::GAMGSolver::solve(Foam::Field<double>&, Foam::Field<double> const&, unsigned char) const in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libOpenFOAM.so" #8 Foam::fvMatrix<double>::solveSegregated(Foam::dictionary const&) in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/lib/libfiniteVolume.so" #9 Foam::fvMatrix<double>::solve(Foam::dictionary const&) in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/bin/simpleFoam" #10 Foam::fvMatrix<double>::solve() in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/bin/simpleFoam" #11 ? in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/bin/simpleFoam" #12 __libc_start_main in "/lib64/libc.so.6" #13 ? in "/opt/OpenFOAM/OpenFOAM-v1606+/platforms/linux64GccDPInt32Opt/bin/simpleFoam"
The error message from the readMe! output node is attached below as a text file.
Hope you can kindly advise what the important steps or parameters I might have missed here. I assume it might be related to OpenFOAM rather than with the Butterfly workflow...
Thank you very much!
- Ji
…
to host the annual parade of Samba Schools during the Carnival festival. For the remaining 361 days of the year it stands empty and desolate as a massive dividing wall within its degraded urban context. Renovated in 2012 and now the future site for the 2016 Olympic marathon finish line and archery events, the Sambadromo is receiving renewed international attention, but it drastically needs to accommodate new types of programme and improve its connection with its surrounding context. AAVS Rio de Janeiro will explore ways to intervene within and transform the Sambadromo, with a potential focus on the VIP and Press Rooms ‘camarotes’, which were originally designed to house classrooms when Carnival was not taking place, and are now the site for over-commercialized, under-designed temporary installations during Carnival, and abandoned throughout the rest of the year. Teaching team:The teaching team will be led by Elena Manferdini, from Atelier Manferdini (www.ateliermanferdini.com), to teach and use advanced digital design and fabrication to generate iterative transformations in the creation of new micro-infrastructures. Computational and fabrication skills: The workshop will teach advanced computational design skills. A series of physical models will be built using digital fabrication techniques, such as laser-cutting and rapid-prototyping, that will be taught during the workshop. No previous digital or fabrication experience is needed. Applications: http://www.aaschool.ac.uk/STUDY/VISITING/rio http://rio.aaschool.ac.uk/2015-aa-marathon-runway-sambadromo/ or mail brazilvisitingschool@aaschool.ac.uk…
he resulting STL file has no problems. I was going to make a 3D print of it but I thought I could make it even more interesting.
When I make a duplicate piece of geometry with reversed curve rotation values and combine the 2 together I get this interesting result:
However, after baking this geometry the exported STL file has a huge number of errors - there are literally thousands of flipped normals, multiple mesh parts, and disconnected triangles.
I have tried lots of things to resolve this and none of them worked: converting to meshes in GH, GH mesh smooth, Rhino Solid Union, Mesh Repair, Align Normals, etc. I use 3D Builder to correct STL problems, but it can't fix this one.
An even more interesting shape happens when I twist the above shape in one direction, and then add it to another that is twisted in the opposite direction:
Of course the STL file for this one is even worse because it just compounds the previous problems.
Is there any way to resolve these problems? My GH file is somewhat messy and perhaps a bit obscure, but I'd be happy to clean it up and share it with anyone who thinks there is a way to get this puppy working.
…
Added by Birk Binnard at 11:56am on September 22, 2016
ace Syntax." eCAADe 2013 18 (2013): 357.
http://www.sss9.or.kr/paperpdf/mmd/sss9_2013_ref048_p.pdf
The measure Entropy is newer. I hereby explain it (from my PhD dissertation):
Entropy values, as described in (Hillier & Hanson, The Social Logic of Space, 1984) and specified in (Turner A. , “Depthmap: A Program to Perform Visibility Graph Analysis, 2007), intuitively describe the difficulty of getting to other spaces from a certain space. In other words, the higher the entropy value, the more difficult it is to reach other spaces from that space and vice-versa. We compute the spatial entropy of the node as using the point depth set:
(11)
“The term is the maximum depth from vertex and is the frequency of point depth *d* from the vertex” (ibid). Technically, we compute it using the function below, which itself uses some outputs and by-products from previous calculations:
Algorithm 4: Entropy Computation
Given the graph (adjacency lists), Depths as List of List of integer, DepthMap as Dictionary of integer
Initialize Entropies as List(double)
For node as integer in range [0, |V|)
integer How_Many_of_D=0
double S_node=0
For depth as integer in range [1, Depths[node].Max()]
How_Many_of_D=DepthMap.Branch[(node,depth)].Count
double frequency= How_Many_of_D/|V|
S_node = S_node - frequency * Math.Log(frequency, 2)
Next
Entropies [node] = S_node
Next
…