oo culm and the web is mad of bamboo slats connected to the culms on either side of the attachment points. To make things clearer (extracted from the above paper):
The authors of the paper did a numerical beam-model in ANSYS to see if they could replicate their theoretical results, and it is fairly correct (some differences due to the non-linear behavior of the semi-ring joints that they use, they remain of an order of 5-10% difference in maximum deflection).
My problem is that I am not able to obtain the same deflection values that the authors did (11.4 mm for a total service load of 7.063 kN applied punctually on the upper chord where the truss elements meet, or even replicate the load/deflection curve). Using an orthotropic material, with the engineering constants taken from (ResearchGate - A bamboo Beam-Column Connection Capable to Transmit Moment), my model is too flexible and I get a maximum deflection of 24.28 mm. I tried other orthotropic mechanical characterizations from other sources (Kathry & Mishra, 2012, Finite element analysis of bamboo and joints using steel members under various loading conditions for design study and Chand , Shukla & Sharma, 2008, Analysis of Mechanical Behaviour of Bamboo (Dendrocalamus strictus) by Using FEM), to no avail.
Of course, the problem could be with the material properties I inputted but I am trying to contact the research team to see directly with them. In the meantime, I am looking to make sure the model itself is not flawed.
It also seems to me that gravity was not accounted for in the numerical of the paper, but it seemed to much of an oversight to be possible (still, the deflection curve of their paper goes through 0).
There are several points I am not quite sure about: after all I am still fairly new to Karamba3D and may still have some things to learn about the inner mechanics of the plugin.
The very first is: should I put eccentricities of the slat-elements of the truss in the definition of their cross-section (directly with the Cross Section box) or as an offset of the beam element (with the ModifyElem box)? I tried both approaches and they seem to yield similar results (max. deflection change by 0.65mm in my latest model).
Second is: is it good practice to subdivide the beam elements in more than one element (and connecting the pieces rigidly) in order to get better results? I imagine some meshing or subdivision is performed when the analysis is run but there is no way of visualizing it (that I found in any case). Subdividing the chord elements seems to give smoother deformation results (though I did not check stress I have to admit). My issue on this topic is that the subdivision of the slat-elements of the web is problematic. On the screenshot below, where the elements are divided in two, lets take the example of node 18. It seems to me that all elements of the diagonal element (28, 29, 34 & 35) are all rigidly connected to the node 18. 28 & 29 are not connected together, independently from 34 & 35. The added rigidity may not be a bad thing for my model, but it is not correct I think? Is there a way of solving the problem?
Element tags:
Node tags:
And here is my GH file (clean enough hopefully): verification-model-V04.gh
Thank you all in advance for any insight (even on the inner logics of Karamba)!
…
ial command:create: Divide Curve, Voronoi, Area, Circle
If there are multiple instances of a single component, then you can assign them IDs (according to Ángel's suggestion) using square brackets:create: Divide Curve, Circle[1], Circle[2]You can use numbers or words, whatever you want to identify a component.
Parameters are written in parenthesis, in front if they are input parameters, trailing if they are outputs:Voronoi(C) --> (G)AreaThis will conflict somewhat with components which already use parenthesis in their name, but we can simply consider the first or last parenthesis pair to indicate the parameter. In other words, the ambiguity can be resolved because all alternative interpretations are invalid.
K didn't like my usage of an inverse arrow ( <-- ) to assign properties, I didn't like her suggestion of a different inverse arrow ( <== ). The equals symbol seems to be a halfway decent alternative, eventhough K still doesn't like it:Voronoi = Preview:Off
All sorts of properties can be assigned using this notation, including name, position, enabledness etc.
We haven't decided on a good way to assign initial properties quickly. Your first suggestion [Slider=60] may work in conjunction with the create statement, but it is somewhat awkward. I suppose the logical way for this to work is to simply type:slider = 0..10..50using the shorthand notation for creating a new object (by mentioning it out of the blue) and immediately assigning a property to it.
Does this approach violate some of the goals you had in mind originally?
--
David Rutten
david@mcneel.com…
ate 2 lists (nList, fList) as reference, and produce this fnList <List of List of On3dPoints> - when I output the resulting Object, it gives me the Object Type, not the value and therefore unusable. Please see image for the output. In the code below, I think the only lines one would need to evaluate is the bold lines.
Am I getting confused with referencing or something?
Thanks in advance,
kat
Private Sub RunScript(ByVal wPt As List(Of On3dPoint), ByRef NodeList As Object, ByRef FacetList As Object, ByRef FacetNodeList As Object) Dim xlApp As Object Dim i As Integer ' override language Dim oldCI As System.Globalization.CultureInfo = system.Threading.Thread.CurrentThread.CurrentCulture System.Threading.Thread.CurrentThread.CurrentCulture = New System.Globalization.CultureInfo("en-US") 'Grab a running instance of Excel xlApp = System.Runtime.InteropServices.Marshal.GetActiveObject("Excel.Application") Dim wb As Object = xlApp.ActiveWorkbook 'Dim sheet As Object = wb.ActiveSheet Dim xlshNode As Object = wb.Sheets("Nodes") Dim xlshFacet As Object = wb.Sheets("Facet Table") Dim nList As New List(Of On3dPoint) Dim fList As New List(Of On3dPoint) Dim fnList As New List(Of List(Of On3dPoint)) Dim rowBegin As Integer = 3 Dim col_name As Integer = 1 Dim col_1 As Integer = 2 Dim col_2 As Integer = 3 Dim col_3 As Integer = 4 If Not IsNothing(xlshNode) Then nList = readIntoPoints(xlshNode, rowBegin, col_1, col_2, col_3) NodeList = nList End If If Not IsNothing(xlshFacet) Then fList = readIntoPoints(xlshFacet, rowBegin, col_1, col_2, col_3) FacetList = fList End If If Not IsNothing(nList) And Not IsNothing(fList) Then For i = 0 To fList.Count - 1 Dim pt1Name As Double = fList(i).x Dim pt2Name As Double = fList(i).y Dim pt3Name As Double = fList(i).z Print("pt1Name : " + CStr(pt1Name)) Print("pt2Name : " + CStr(pt2Name)) Print("pt3Name : " + CStr(pt3Name)) Dim ptList As New List(Of On3dPoint) Dim ptOne As On3dPoint = nList(CInt(pt1Name) - 1) Dim ptTwo As On3dPoint = nList(CInt(pt2Name) - 1) Dim ptThree As On3dPoint = nList(CInt(pt3Name) - 1)
ptList.Add(ptOne) ptList.Add(ptTwo) ptList.Add(ptThree) Print(" ptList : " + ptList.ToString) fnList.Add(ptList) Next FacetNodeList = fnList End If End Sub…
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
…
t of data it has to operate on. So only those aspects of the algorithm that differ in these cases are relevant.
For example if your algorithm always does exactly the same thing (let's say all it does is measure the size of an array and display it on screen) will be O(1), because it doesn't matter if you run it on an array containing 10 or 1000000 items. Measuring the size of an array is a constant-time operation:
Print(string.Format("Array contains: {0} element(s)", data.Length);
However if your algorithm works on not on arrays but on linked-lists, then it becomes an O(N) operation because counting all the elements in a linked list means you have to iterate over all of them. And the longer the list, the more iterations you need. In fact the number of iterations is exactly the same as the number of items. (ps. if you'd be using the System.Collections.Generic.LinkedList<T> class then it's still O(1), because apparently that particular implementation of linked lists caches the count and keeps it up to date.)
If you have a loop that runs for each item, and then inside that loop there is another loop that also runs for each item, then your complexity becomes O(N²). Or, in a similar case if your algorithm consumes two collections (N and M) and iterates over all items in N, and then inside that loop it iterates over all items in M, the complexity is O(N×M).
The case can be made that only the most severe complexity is relevant enough to report. For example if you have an algorithm that comprises of three steps, the first of which is O(log(N)), the second is O(N²) and the third is O(3ⁿ), then technically the total complexity would be O(log(N) + N² + 3ⁿ), however the first two parts are utterly insignificant compared to the third and therefore can be omitted entirely. Consider for example increasing the input size from 10 to 20 elements:
log(10) + 10² + 3¹⁰ = 1 + 100 + 59049 = 59150
log(20) + 20² + 3²⁰ ≈ 1 + 400 + 3486784401 ≈ 3486784802
As you can see the increase of the complexity is almost entirely due to the O(3ⁿ) portion, so much so that there's almost no point in mentioning the other two.
Now, your specific questions:
Constructors/declarations and method invokes are not necessarily O(1). In this particular case they are, but it is possible that some constructor you call may have a higher complexity. For example if instead of an empty List<T> you're constructing a SortedList<T> based on your inputs, then it definitely may be the most significant complexity in your entire algorithm and it needs to be taken into account.
Correct. A loop like this has complexity O(N), ignore stuff that only happens once like the declaration of the iteration variable.
I don't understand that line of code. cP is already a list. Why are you calling ToList() on it? In general making copies of memory-contiguous collections (like arrays or lists) can be done in O(1), depending on implementation, because blocks of memory can simply be duplicated or moved at one go using the correct hardware ops. However other times it will require a loop in which the complexity goes up.
It's very cheap to add items to lists, provided the list has enough space to add new items. By default a list is big enough to contain only 4 items. If you try and add a fifth one, the list will need to allocate more memory elsewhere, copy the 4 existing items into the newly allocated space and only then add a new item. So, if you know ahead of time how many items you'll be adding to a list (or even if you only know a theoretical upper bound), you should construct the list using that known capacity. This will speed up the process of adding many items to a single list.
Don't know how crypto providers work, but since this part of your algorithm does not depend on cp.Count or the magnitude of populationCount, it doesn't matter for the big-O complexity metric.
…
rth. Current components include:
Format_GPS: Takes NMEA Formatted GPS Latitude and Longitude values and converts them to Decimal Degrees. Will add further converters.
GPS->XYZ: Maps Longitude, Latitude, and Altitude to XYZ.
XYZ->GPS: Maps XYZ to Longitude, Latitude, and Altitude.
KML_Export: Exports imported geometry to KML format. Currently implemented for points, curves, and meshes. Any Breps should be meshed before. Will be adding conditions for other geometry as well as render styles.
Look forward to a WIP release next week.
…
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
…
rectly except for the first material in a series. See attached image... Here is my code:
Private Sub RunScript(ByVal M As Object, ByVal C As Color, ByRef AddName As Object, ByRef AddMat As Object, ByRef AddBool As Object, ByRef baseName As Object, ByRef newMatName As Object)
Dim z As String = "newMatName" Dim y As String = "BaseName" Dim x As Integer = 0 Dim nRestore As String Dim mTemp As Rhino.DocObjects.Material
mTemp = CType(M, Rhino.DocObjects.Material) y = mTemp.Name Dim nTemp As String
If mTemp.Name.Contains("_MOD_R") = False Then
nRestore = mTemp.Name nTemp = mTemp.Name & "_MOD_R" & C.R & "_G" & C.G & "_B" & C.B mTemp.Name = nTemp z = nTemp mTemp.DiffuseColor = C
If Doc.Materials.Find(nTemp, True) < 0 Then
Doc.Materials.Add(mTemp) x = x + 1 AddName = nTemp AddMat = mTemp
End If
mTemp.Name = nRestore
End If
newMatName = z
AddBool = x BaseName = y
End Sub
1) I have checked that all of the materials I am calling by name exist in the document and that data matching is correct. There doesn't seem to be anything special about the offending material except that it is always the first material that was added to the document by my script.
2) The main thing I was missing in the previous script was the "doc.Materials.Add()" -- how on earth should I have known that existed? Even a search for "doc.Materials" in the Rhinocommon SDK doesn't turn that up. I'm having a very hard time using the SDK to my advantage, it seems not to correlate to the actual code I need to write.
2b) Perfect example... now I am trying to rewrite my other component (which exposes all of the document materials) to set a few objects manually in Rhino with the Materials I want to use as templates. Now I am trying to find out how to access the material assigned to an object. Seems easy, but it's clearly not a Property, and I can't find an appropriate Method in either the Objects or Materials classes.
3) One of my problems originally, when feeding the component one material and multiple colors, was that the nTemp variable was not resetting properly for the second color. Same thing if I duplicated the material to match the list of colors. It would create a material on the first pass but concatenate "_MOD_R_G_B" in each subsequent pass and be caught by my String checker. Why is that? I thought that the nTemp Name variable would be reset in each pass by the line "mTemp = CType(M, Rhino.DocObjects.Material)" and "nTemp = mTemp.Name" combination.
Does the mTemp material somehow carry over its properties in each successive pass? That's why I added the nRestore to be sure each pass reset the name back to the original.
Still, I wonder if there is some problem with the way I am conceptualizing this that is causing the first material to be the same as the input material.
Thanks for your help on this...
Cheers,
Marc…
and export the geometry out to VVVV to render it LIVE! RawRRRR. In this case, a digital audio workstation Ableton Live, a leading industrial standard in contemporary music production.
the good news is that VVVV and ableton live lite is both free.
https://www.ableton.com/en/products/live-lite/
i am not trying to use ipad as a controller for grasshoppper. I wanted to work with a timeline (similar to MAYA or Ableton or any other DAW(digital audio workstation)) inside grasshopper in an intuitive way. Currently there is no way of SEQUENCING your definition the way you want to see that i know of.
no more combersome export import workflows... i dont need hyperrealistic renderings most of the time. so much time invested in googling the right way to import, export ... mesh settings...this workflow works for some, for some not ...that workflow works if ... and still you cannot render it live nor change sequence of instruction WHILE THE VIDEO is played. and I think no one wants to present rhinoceros viewport. BUT vvvv veiwport is different. it is used for VJing and many custom audio visual installation for events, done professionally. you can see an example of how sound and visuals come together from this post, using only VVVV and ableton. http://vvvv.org/documentation/meso-amstel-pulse
I propose a NEW method. make a definition, wire it to ableton, draw in some midi notes, and see it thru VVVV LIVE while you sequence the animation the WAY YOU WANT TO BE SEEN DURING YOUR PRESENTATION FROM THE BEGINNING, make a whole set of sequences in ableton, go back change some notes in ableton and the whole sequence will change RIGHT INFRONT of you. yes, you can just add some sound anywhere in the process. or take the sound waves (sqaure, saw, whateve) or take the audio and influence geometric parameters using custom patches via vvvv. I cannot even begin to tell you how sophisticated digital audio sound design technology got last ten year.. this is just one example which isn't even that advanced in todays standard in sound design ( and the famous producers would say its not about the tools at all.) http://www.youtube.com/watch?v=Iwz32bEgV8o
I just want to point out that grasshopper shares the same interface with VVVV (1998) and maxforlive, a plug in inside ableton. audio mulch is yet another one that shares this interface of plugging components to each other and allows users to create their own sound instruments. vvvv is built based on vb, i believe.
so current wish list is ...
1) grasshopper recieves a sequence of commands from ableton DONE
thanks to sebastian's OSCglue vvvv patch and this one http://vvvv.org/contribution/vvvv-and-grasshopper-demo-with-ghowl-udp
after this is done, its a matter of trimming and splitting the incoming string.
2) translate numeric oscillation from ableton to change GH values
video below shows what the controll interface of both values (numbers) and the midi notes look like.
https://vimeo.com/19743303
3) midi note in = toggle GH component (this one could be tricky)
for this... i am thinking it would be great if ...it is possible to make "midi learn" function in grasshopper where one can DROP IN A COMPONENT LIKE GALAPAGOS OR TIMER and assign the component to a signal in, in this case a midi note. there are total 128 midi notes (http://www.midimountain.com/midi/midi_note_numbers.html) and this is only for one channel. there are infinite channels in ableton. I usually use 16.
I have already figured out a way to send string into grasshopper from ableton live. but problem is, how for grasshopper to listen, not just take it in, and interpret midi and cc value changes ( usually runs from 0 to 128) and perform certain actions.
Basically what I am trying to achieve is this : some time passes then a parameter is set to change from value 0 to 50, for example. then some time passes again, then another parameter becomes "previewed", then baked. I have seen some examples of hoopsnake but I couldn't tell that you can really control the values in a clear x and y graph where x is time and y is the value. but this woud be considered a basic feature of modulation and automation in music production. NVM, its been DONE by Mr Heumann. https://vimeo.com/39730831
4) send points, lines, surfaces and meshes back out to VVVV
5) render it using VVVV and play with enormous collection of components in VVVV..its been around since 1998 for the sake of awesomeness.
this kind of a digital operation-hardware connection is usually whats done in digital music production solutions. I did look into midi controller - grasshopper work, and I know its been done, but that has obvious limitations of not being precise. and it only takes 0 o 128. I am thinking that midi can be useful for this because then I can program very precise and complex sequence with ease from music production software like ableton live.
This is an ongoing design research for a performative exhibition due in Bochum, Germany, this January. I will post definition if I get somewhere. A good place to start for me is the nesting sliders by Monique . http://www.grasshopper3d.com/forum/topics/nesting-sliders
…