been covered since 0051 (correct me if I'm wrong):
1) Shoot for the moon first -- "Control Panel Mode" which allows for advanced interface design. See Max/MSP for example of modal function. I spent a lot of time laying out control panels so they are nice for clients and team members to look at. I spend a lot of time disabling wire display and dragging sliders and panels and graphs around into nice little clusters. Could be something as simple as a mode that disables the view of all component handles, cleans up graph objects, sliders, etc. I know the Remote Control Panel has been requested over and over again since it disappeared, but honestly it wouldn't be much use to me unless it was a full blown customizable interface. In the meantime I'll stick to my own "Canvas Control Panel" methods. (See below...)
2) More control over graph objects. Right now the bar graph for instance automatically sets the lowest and highest value displayed. Would be nice to be able to set extents manually so that you can compare apples to apples on two different lists that have different extents. Also would love to force the bar graph to show all values along x axis, not just first and last. Same goes for showing the numbers of instances for each value. Now it only shows instance numbers in oddball cases. Would like to force them to show for statistical purposes. Love percentages, but usually I also want accurate tallies. I tend to use a member index sets to generate my own lists.
3) Color input for Vectors -- there are fakey fake workarounds but none that are as versatile as simply having a color input.
4) COLOR INPUT FOR TEXT TAGS -- sorry to yell... this one really frustrates me. I often build interactive feedback systems that involve a lot of different types of data, and it is difficult to convey that input when all text is red (or green when selected).
5) Ability to justify text tags using paragraph controls -- currently default is left-justified. Would like to be able to center text horizontally and vertically, among other things.
6) Ability for text tags to handle multi-line text. Not sure the best way to implement this, but often I find myself wanting to attach 3 items of information to a particular object, and I have to string it all together in one line. Would be great if I could insert a "^M" character that stands for carriage return and have that display as multiline text (used in conjunction with above justification controls).
7) More control over Text panels. Thank you for including justification options... but sadly now it begs the question for margin and header control. Text slammed up against the left edge is pretty unsightly. Moreover, if you have labeled a text box, the drop shadow from the title bar tends to overshadow the first line of text if you have Path display turned off. Would like to add some header space to fix the problem and create a cleaner look.
8) Easier access to text font size. Buried in a Special Font... menu. I want to be able to up up down down (left right left right select start) if you know what I mean.
I guess that's it for now... just the things on the top of my head in this category. Looking forward to installing the new release, have to wait until this major project is over though.
Cheers,
Marc
…
nd B) daylight autonomy for a single room. A and B are therefore the conflicting objectives, and are connected to the O of octopus component. The geometry iterated is that of a window, on one of the rooms' facades.
I have a grasshopper definition that iterates the window by changing:
1. Window height
2. Window sill height
3. Window width
4. Window position from one side of the wall
1,2,3,4 are therefore the genes. A combination of these genes is a complete window, which is the chromoshome, that i will from now on call solution. All genes are connected to the G of octopus component.
Now regarding the octopus settings, i have these questions so that i can properly calibrate the settings (mutarion rate, crossover rate etc):
1.In the beginning of the octopus simulation, how many are the random solutions generated? (By random i mean totally random, not resulting solutions from mutation or crossover of previous solutions, i am talking about the very first generation). Is this number connected to the population size? Is it 6? How is it defined by octopus? Can somebody control it?
2.The first generation finishes when the number of "individuals to be evaluated" is reached. Then octopus jumps to the second generation. To do so, it keeps a specific number of solutions of the first generation, the so called elite. What is the number of these elite? Is it elitism x population size?
3.The SPEA2 original paper describes step wise the algorithm loop. During the loop, a number of solutions is stored in the elite domain, and from that domain, a number of solutions is used for mating. There are therefore two numbers, one that defines the number of solutions to enter the elite domain, and one that defines the number of solutions to be inserted in the mating pool. In octopus i only see elitism as a setting, which i am guessing is what defines the number of solutions to enter the elite domain. Is that true? How do i define the number of solutions to be copied in the mating pool, where mutation and crossover will occur? This number should be called tournament size, but i can't seem to find it..
4.Why is it that DURING one generation, the number of "individuals to be evaluated" can decrease? Is it because octopus finds out that there are no more possible solutions? (i am using discrete values for the genes)
5.The gene of window width, represented by a grasshopper slider, has 4 possible values: 0,1,2,3. Assuming that the mutation rate is 0.5. Does this mean that mutation of the gene can happen to an extent of 0.5 x 4 = 2? Meaning that the slider position can change for 0 to 2 or from 3 to 1 etc?
6.The mutation probability is dictating whether or not a gene will be mutated, or whether or not the whole solution will be mutated? So for instance, with a mutation probability of 0.5, does it mean that 2 out of the 4 genes are going to be mutated, or 2 out of 4 solutions is going to be mutated. If its the second case, then how is mutation divided between the different genes? Meaning, which of the 4 genes is going to get mutated? Is it random? Is it for all 4 genes?
7.Crossover can occur between 2 subsequent solutions. Crossover rate dictates whether or not crossover will take place? If so, then, assuming that it was chosen for crossover to take place between 2 solutions, which of the genes are going to be exchanged. I mean how many, out of the 4 genes (height, sill height, width, position). Is it random?
8.After clarifying the previous 7 questions, i can run a simulation. Then, is there an indicative number that i can be monitoring, to see that no more generations are required? I know that a good pareto has to be short, with a lot of solutions and with a uniform distribution. But is there a specific number output somewhere, that can inform me that a good pareto has more or less been generated? If there is such indicator...
Thank you all,
i hope this can help others as well,
Iason
…
imes. Your loop should go to y.Count - 1. Or, you could use a For...Each loop, circumventing the problem altogether:
Dim shortLines As New List(Of Line)
For Each segment As Line in y
If (segment.Length < x) Then
shortLines.Add(segment)
End If
Next
A = shortLines
--------------------------------
Another problem is this line of code:
New_Lines.Add(New_Line)
It is located inside the loop but outside the If statement, meaning it gets run every single iteration. This fills up the short line list with duplicates.
-------------------------------
Here's something else which is redundant:
Dim Input_Line As New Line
Apart from the fact that you don't need a special variable for this at all, you also don't need to add a New keyword. The type Line in RhinoCommon (just like Point3d, Vector3d, Plane, BoundingBox etc. etc.) are Structures, not Classes. Structures always exist when they are defined, whereas Classes can be null ("Nothing" in VB).
-------------------------------
Some more advice:
Dim i As Integer
For i = 0 To y.Count()
You can merge these two lines into one. VB.NET allows you to declare your iteration variable inside the loop:
For i As Integer = 0 To y.Count - 1
--------------------------------
If you don't like the For...Each approach at the top of this answer, here's how to write this using a For...To loop:
Dim shortLines As New List(Of Line)
For i As Integer = 0 To y.Count - 1
If (y(i).Length < x) Then
shortLines.Add(y(i))
End If
Next
A = shortLines
ps. A personal preference of mine is that I always encase the expressions inside If...Then statements in brackets. You technically don't need to do this, but I find it makes the code more readable.
--
David Rutten
david@mcneel.com
Poprad, Slovakia…
itects are at the spoke of a number of different specialties, and their work affects many different people. It's not like an architect is a painter, whose work may offend or upset the occasional viewer. As an architect you have a responsibility to produce quality work. How can anybody trust you with this responsibility if you're taking a purely artistic approach? What guarantees do you have that your clients money won't be spend on a poorly designed project if you can provide no rational for why your design is the way it is?
2. What is any sense in purely architectural discourse?
I don't get. Discourse is there to flesh out problems and agree on solutions. It might not always accomplish that, but what's the difference between talking about architecture as opposed to any other topic?
3. strictly looked, can be determined sense generally in a purely architectural discourse?
I'm sorry I don't understand.
4. What is purely architectural discourse?
I imagine it's having a discussion where you only talk about architecture?
5. What is Funktionalismus or Rationalismus without philosophical support?
Functionalism and Rationalism are ideologies. Some would even call them methodologies. They are inherently philosophical things as they are nothing more than a collection of ideas and views. As a society we've decided that a certain level of rationalism is a good thing. The Enlightenment continued this trend after the Dark Age hiatus and it quickly led to a large number of very tangible benefits for almost everyone.
I'm not arguing for or against Functionalism as an architectural style. I'm asking for a measure of rationalism in our academic process.
6. Would not be the pure functional fulfilment empty ?
Let's find out. In the meantime I'll settle for a little functionalism.
7. Would be not a critical position on the promise of purely rational algorithms applied?
Algorithms and algorithmic design are rational in the sense that they do not allow for ambiguity. But that doesn't make them rational in the real-world sense. These are not the same kind of 'rational's. I can make an algorithm that produces total nonsense, but does so completely reliably. I can also use an algorithm in a setting for which it wasn't intended, thus invalidating the results.
This is actually the crux of the problem. Which algorithms does one use to solve a problem and what data do they require? If you can't answer this question or if you do not understand the algorithms you are using (at least on a superficial level) then I'd say you have no business using them.
--
David Rutten
david@mcneel.com
Tirol, Austria…
Added by David Rutten at 12:48pm on August 19, 2013
an almost planar tissue (your case) can cause a variety of issues up to the undo able state (metal parts/components grow in size as well for no reason). See forces estimated by FF below.
2. Therefor I strongly suggest to consider Plan B (a) mastermind a secondary "anchor" capability in order to achieve a far more stable system (b) use a mount design that can support this (and comply with the attractor concept of yours). Here's a variable mount custom system (mostly machined AND not cast) that is suitable for the scope (Rhino reads the stp file OK .... but makes a colossally big file - thus I attach here the original).
3. On first sight lot's of things in this system appear "odd". For instance: is it stable? Why these double cables are used? How far can be adjusted? (that's a classic case for feature driven parametric design - not doable with Rhino).
4. This concept (strut axis exported only) is tested in FORMFINDER and some other far more complex membrane apps that I use quite often (not RhinoMembrane). Here's is what FF tells us about:
Observe a different kind of "stress" when this is converted to radial type:
5. If you insert the stp file to the Rhino file provided (exactly as exported from FORMFINDER - no mods of mine of any kind) you'll see what goes where (and why). That way the usage of double cables is rather obvious (and a lot other things - for instance the way that the struts achieve "equilibrium", see the slots in the base mount plate.
6. If this approach is worth considering your definition requires some serious rethinking (far more simpler/manageable with the drawback that the real parts they are "static" they can adjust only as far this particular solution allows them to do - controlling them parametrically is clearly impossible with the current state of R/GH capabilities).`
All in all: this case works because the cables push the anchor points downwards and the struts push them upwards.
more in a while
…
Angeles, which has 12% of the year made comfortable, and Shiraz, Iran, which also has 12% comfortable (assuming default parameters).
Jerusalem also makes sense to me. There is only a maximum possible 9% of the year that is inside the polygon (you'll see this if you set the timeConstant to a very high number). The default strategyPar makes 6% of these hours comfortable and 3% without cool enough temperatures in the previous hours. This seems reasonable to me.
I could be convinced to change the default time constant to 12 hours (instead of 8) as I know that 12 is the default of climate consultant but that seemed really idealized in my opinion. You'll need really high exposed mass and insulation without much internal heat gain to make conditions stable for more than 8 hours in my opinion.
As for the solarHeatCapacity, I get changes when I drop it down to 10 W/m2 or boost it up to 100 W/m2. It's definitely a parameter that operates on an "order of magnitude" scale and little tweaks to it won't change it too much. You can think of this number as representative of a lot of other physical properties: most notably the depth of the space being passively heated and the thermal mass of that space's materials that participate in heat exchange over the time constant. Climate consultant uses a default assumption of 30 W/m2 but, from my calculations, this is likely assuming a space that has a facade to floor area ratio that is greater than 1. If we say that we need to raise the temperature of 10 cm of an exposed concrete floor for passive heating purposes, and we have a facade-to-floor area ratio of 1:
Required solar flux = ((1 facade-to-floor ratio) x (0.1 m3 of concrete) x (2400 kg/m3 concrete density) x (880 J/kg-K concrete specific heat capacity)) / 3600 seconds/hour
This lands you with a required solar flux of 58 W, which is almost twice the 30 W climate consultant default. While me might say that not all 10 cm of concrete participates over the course of a default 8-hour time constant (most of the action is probably within the first 5 cm), we also have to account for things like transmittance of solar though the window, which, for triple pane, is probably only half of the incident solar. So 50 W seemed to be a more reasonable rule of thumb from my perspective, essentially assuming a facade-to-floor ratio of roughly 1 with 5 cm of concrete participating in an 8 hour heat exchange and a little more than half of solar heat getting through a fully glazed window.
Let me know if that makes sense or if you have any suggestions,
-Chris…
is set up to manipulate strings into an STL file that is quite different from how Grasshopper defines meshes, in that an STL seems to define each face by XYZ points, Grasshopper wants a single list of all vertex points and then has an allied lists of topological connectivity according to vertex number, so for now I just hacked it to spit out points minus so many duplicates it generates for STL:
Right now it has an internal 3D trigonometric function I added input sliders to control, that creates surfaces that look a lot like molecular orbitals.
So how do I make a mesh? I failed to make a single mesh face from each STL face since AddMesh seems to want a list, so I tried making a single list and matching it with a simple ((1,2,3),(4,5,6),(7,8,9)...) array of connectivity but it hasn't worked yet since the STL list of vertices has duplicates that won't work for Grasshopper and removing the duplicates scrambles the connectivity relation.
After some work on this and seeing the output, I figure I could just randomly populate the mathematical function with points instead, unless it really gives a better mesh result than other routines. I'm not sure what to do with it yet, even if I get the mesh figured out.
import rhinoscriptsyntaximport RhinoPOINTS_CONTAINER =[]POINTS = []class Vector: # struct XYZ def __init__(self,x,y,z): self.x=x self.y=y self.z=z def __str__(self): return str(self.x)+" "+str(self.y)+" "+str(self.z) class Gridcell: # struct GRIDCELL def __init__(self,p,n,val): self.p = p # p=[8] self.n = n # n=[8] self.val = val # val=[8] class Triangle: # struct TRIANGLE def __init__(self,p1,p2,p3): self.p = [p1, p2, p3] # vertices # HACK TO GRAB VERTICES FOR PYTHON OUTPUT POINTS_CONTAINER.append( (p1.x,p1.y,p1.z) ) POINTS_CONTAINER.append( (p2.x,p2.y,p2.z) ) POINTS_CONTAINER.append( (p3.x,p3.y,p3.z) )# return a 3d list of values def readdata(f=lambda x,y,z:x*x+y*y+z*z,size=5.0,steps=11): m=int(steps/2) ki = [] for i in range(steps): kj = [] for j in range(steps): kd=[] for k in range(steps): kd.append(f(size*(i-m)/m,size*(j-m)/m,size*(k-m)/m)) kj.append(kd) ki.append(kj) return ki from math import sin,cos,exp,atan2 def lobes(x,y,z): try: theta = atan2(x,y) # sin t = o except: theta = 0 try: phi = atan2(z,y) except: phi = 0 r = x*x+y*y+z*z ct=cos(PARAMETER_A * theta) cp=cos(PARAMETER_B * phi) return ct*ct*cp*cp*exp(-r/10) def main(): data = readdata(lobes,10,40) isolevel = 0.1 #print(data) triangles=[] for i in range(len(data)-1): for j in range(len(data[i])-1): for k in range(len(data[i][j])-1): p=[None]*8 val=[None]*8 #print(i,j,k) p[0]=Vector(i,j,k) val[0] = data[i][j][k] p[1]=Vector(i+1,j,k) val[1] = data[i+1][j][k] p[2]=Vector(i+1,j+1,k) val[2] = data[i+1][j+1][k] p[3]=Vector(i,j+1,k) val[3] = data[i][j+1][k] p[4]=Vector(i,j,k+1) val[4] = data[i][j][k+1] p[5]=Vector(i+1,j,k+1) val[5] = data[i+1][j][k+1] p[6]=Vector(i+1,j+1,k+1) val[6] = data[i+1][j+1][k+1] p[7]=Vector(i,j+1,k+1) val[7] = data[i][j+1][k+1] grid=Gridcell(p,[],val) triangles.extend(PolygoniseTri(grid,isolevel,0,2,3,7)) triangles.extend(PolygoniseTri(grid,isolevel,0,2,6,7)) triangles.extend(PolygoniseTri(grid,isolevel,0,4,6,7)) triangles.extend(PolygoniseTri(grid,isolevel,0,6,1,2)) triangles.extend(PolygoniseTri(grid,isolevel,0,6,1,4)) triangles.extend(PolygoniseTri(grid,isolevel,5,6,1,4)) def t000F(g, iso, v0, v1, v2, v3): return [] def t0E01(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]), VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]), VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3])) ] def t0D02(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v1],g.p[v0],g.val[v1],g.val[v0]), VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3]), VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2])) ] def t0C03(g, iso, v0, v1, v2, v3): tri=Triangle( VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3]), VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]), VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3])) return [tri,Triangle( tri.p[2], VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2]), tri.p[1]) ] def t0B04(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v2],g.p[v0],g.val[v2],g.val[v0]), VertexInterp(iso,g.p[v2],g.p[v1],g.val[v2],g.val[v1]), VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3])) ] def t0A05(g, iso, v0, v1, v2, v3): tri = Triangle( VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]), VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3]), VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3])) return [tri,Triangle( tri.p[0], VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2]), tri.p[1]) ] def t0906(g, iso, v0, v1, v2, v3): tri=Triangle( VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]), VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3]), VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3])) return [tri, Triangle( tri.p[0], VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]), tri.p[2]) ] def t0708(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v3],g.p[v0],g.val[v3],g.val[v0]), VertexInterp(iso,g.p[v3],g.p[v2],g.val[v3],g.val[v2]), VertexInterp(iso,g.p[v3],g.p[v1],g.val[v3],g.val[v1])) ] trianglefs = {7:t0708,8:t0708,9:t0906,6:t0906,10:t0A05,5:t0A05,11:t0B04,4:t0B04,12:t0C03,3:t0C03,13:t0D02,2:t0D02,14:t0E01,1:t0E01,0:t000F,15:t000F} def PolygoniseTri(g, iso, v0, v1, v2, v3): triangles = [] # Determine which of the 16 cases we have given which vertices # are above or below the isosurface triindex = 0; if g.val[v0] < iso: triindex |= 1 if g.val[v1] < iso: triindex |= 2 if g.val[v2] < iso: triindex |= 4 if g.val[v3] < iso: triindex |= 8 return trianglefs[triindex](g, iso, v0, v1, v2, v3) def VertexInterp(isolevel,p1,p2,valp1,valp2): if abs(isolevel-valp1) < 0.00001 : return(p1); if abs(isolevel-valp2) < 0.00001 : return(p2); if abs(valp1-valp2) < 0.00001 : return(p1); mu = (isolevel - valp1) / (valp2 - valp1) return Vector(p1.x + mu * (p2.x - p1.x), p1.y + mu * (p2.y - p1.y), p1.z + mu * (p2.z - p1.z)) if __name__ == "__main__": main() # GRASSHOPPER PYTHON OUTPUTPOINTS = rhinoscriptsyntax.AddPoints(POINTS_CONTAINER)POINTS = rhinoscriptsyntax.CullDuplicatePoints(POINTS)…
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
…
o it would cause troubles with unfolding and fabricating... that's why I used Extrude point component- it will give you similar result, but all surfaces are planar.. you can control extrusion direction with a tip point in rhino...
2)I changed tagging so every tube has 8 points form list A and 8 points from list B... first number of tag is a number of point within one tube... last number of the tag is order of tubes (I draw a little picture in GH, hope you'll understand)...I think original way of tagging wasn't really usefull.. but you can change tagging by yourself...
3) the definition is really messy, sorry about that, but it's just quite complicated task...
4)if you find some incorrect order of tagging, use the slider that controls Shift List component ... it will shift tagging..
5) if you won't be using this definition or find some better way, pleeeease don't tell me - I'll jump out the window :D ... it took me whole day to make it work :D
6)I can't guarantee you anything- I hope it works, but if not - at least I tried... so check everything (especially order of tags and points) twice before you fabricate it.. or print few tubes and make them paper first..
7)there is a part of original definition, that is not useful anymore.. I left it there, but you can delete it (I called it "UNUSED PARTS OF ORIGINAL FILE")
..good luck
Dimitri…
hopper and the GH file.
2. There is a drop down menu at the top of Pure Data that reads "Media". Click on "Midi". If your device connection is working, you should see it show up as an option. Set the device to MIDI in. You don't really need to set a MIDI out unless you are planning to send messages back to the device (not sure why you would want to).
3. The boxes labeled "ctlin" with a number are the Control Change in's. In Pure Data go to the "Edit" menu and click on "Edit Mode". Click on one of the "ctlin #" boxes and change the number to match the Control Change number of your physical controller. Mine starts with 5 in the upper right and goes to 65. Each control change number shows up on the display window of my device when I use it which made it easy.
4. Continue this process for all your controls. Delete the unneccesary "ctlin #" boxes by selecting them with a fence and clicking "delete". When you hover over one of the wires you should see and "x". Press the "backspace" key to delete it.
5. Now go down to the "pack f f f ..." box. There should be as many "f" or "floats" in that box as there are you number of controllers. Delete the remaining "f".
6. Next look at the box below that reads "send /0...". Make sure to keep the "/0". If you delete the "/" it will crash Grasshopper. Change the number "5" to match your first control change number. Leave the $numbers alone. You'll want to keep them sequential. Continue change the control change numbers to match all of yours. The $numbers should match the order in which you wired each controller to the "pack f f f..." box.
7. For testing purposes hover over the input on the upper let of the "print" box and connect it to the out of the "send" box. If everything is mapped correctly, working properly, and you go back to the "main" PD window you should see a list of all controllers will a value (0 to 127) next to it. As you turn a knob, the value next to the control change number will increase from 0 to 127. This will give you a good indication of whether or not everything is working and if you mapped it correctly.
8. Click on the "connect OSC" box. You might need to exit out of "edit mode" and back to "performance" mode in the PD canvas.
9. Go To Grasshopper. If everything is working you should see the Panel read "new message" when you turn a knob. At this point it should be pretty obvious how to modify the Grasshopper components. I've tried to keep everything as consistent as possible. Since I filtered out the "/0", the "explode data treat" component starts at 0, the numbers are shifted down by 1.
I just left the IP address, etc. alone on the gHowl UDP component. Just make sure the "port number" matches the OSC port number on the send in Pure Data. If you crash, you may need to choose a new number.
Hope that helps. Let me know if you have any questions. If your computer is not recognizing your midi controller, you may need to install "Midiyoke". I did at first, but it turns out I didn't need it after all.
Best of luck.
…