Compound Cell Node

Question

Hi All, 
 We are currently trying to place multiple different compound cells into an GC model. 
 I have managed to create a script transaction that loops though the required models etc but this is just a loop and when it is finished it obviously only leaves the last one. 
 
 So first question is does the Compound Cell node accept an array of cells in the 'CellName' ? 
 If not how would I go about placing a multiple compound cells byfunction to place an array of cells on corresponding array of points? 
 
 The point of the exercise is I have generated a series of different fa&ccedil;ade panels (they vary in rotation, tilt and size) so we have generated a new Compound Cell for each group of elements (3d objects and plan lines etc) We now wish to place the generated compound cells back into a file resulting in a datagroup report for each panel as well as a clean 2d symbol for our general arrangement plans. 
 Thanks 
 Wayne

Mueller · Answer

Hi Wayne, 
 If I understand your question correctly, then you generated a compound cell library that contains several compound cells, each, of course, with its own name, e.g. 
 CompoundCell.ByNodes(solids[i][j], solids[i][j].CoordinateSystemAtOrigin, "Test.bxc", "myCell" + + i + "_" + j, "description", catalogItem); 
 Then you would use a CompoundCell.ByFunction node with 
 CompoundCell CCell = new CompoundCell(this).FromLibrary(cs[i][j], "Test.bxc", "myCell" + i + "_" + j); 
 to retrieve the cells. If you want the compound cells nested, you'd use "this" in the outer loop as parent for a "cellList" and parent the individual cells on cellList, e.g. 
 for (int i = 0; i < cs.Count - 1; ++i)
 {
 CompoundCell cellList = new CompoundCell(this);
 for (int j = 0; j < cs[i].Count; ++j)
 {
 CompoundCell CCell = new CompoundCell(cellList).FromLibrary(cs[i][j], 'secondTest.bxc', "myCell" + i + "_" + j);
 }
 }
 
 I hope this helps, otherwise I'd need more detail of how you created the cells, specifically the cell names. 
 Regards, 
 Volker

Mueller · Answer

Hi Wayne, 
 There is a lot going on in your post, there are quite a few items that need consideration. Not sure where to start. 
 (1) variable types and names: 
 Your very first test 
 
 Wayne Dickerson said: 
 function() 
 { 
 CompoundCell = new CompoundCell(this).FromLibrary(baseCS,"FacadeCompoundTest.bxc","type5"); 
 } 
 
 may place a compound cell; however, the node should show an error "Value is missing or is not the expected type" because you assign a newly created CompoundCell to the reserved type word "CompoundCell". Still, a compound cell is placed because you create the new CompoundCell as a child of the calling node compoundCellPlace1 . You achieve that by using the keyword this in the argument to new CompoundCell . There are two (or more) options to avoid the "Value is missing or is not the expected type" error: 
 You assign the newly created compound cell to a variable of the type CompoundCell, for example 
 function ()
{
 CompoundCell CCell = new CompoundCell(this).FromLibrary(baseCS, "FacadeCompoundTest.bxc", "type5");
} 
 CompoundCell is the type, CCell is a name for a variable of type CompoundCell (because CCell is prefaced by CompoundCell ), and then a new CompoundCell is assigned to CCell . 
 This is especially useful if you want to do something else with that compound cell in subsequent code. Since this is not the case, another option would be to eliminate the assignment altogether, because the created cell is captured as child of this as noted earlier: 
 function ()
{
 new CompoundCell(this).FromLibrary(baseCS, "TestLib.bxc", "type2");
} 
 This applies to most of your code examples you show in your post above. 
 Your second attempt may have failed because the function does not execute unless you provide the listed arguments to the function. 
 (2) function arguments: 
 When writing 
 function (string cellname, string CSlibrary, CoordinateSystem CS) 
 then the list of items in the parentheses behind the term function are called the function arguments. This list indicates what inputs the function expects to work correctly. These are not variable definitions or declarations. Whatever inputs are provided as those arguments would have to be defined outside of the function and then provided to it. 
 With that argument list in its function definition, your node in the Graph looks like this: 
 
 It expects input to be wired up or typed into the input properties cellname, CSlibrary, and CS, which are the arguments to its function. While CSlibrary and CS could or even should be supplied as external outputs, cellname could be supplied here, or generated in the function the way you do. 
 (3) variable declaration: 
 In latter case, one would not list cellname as function argument and instead declare it as a variable inside of the function: 
 function (string CSlibrary, CoordinateSystem CS)
{
 string cellname = "";
 
 for (int i = 0; i < 5; ++i)
 {
 cellname = "type" + i;
 // should be passed in because they are listed as arguments
 // but can also be "overwritten" here:
 CSlibrary = "TestLib.bxc";
 CS = baseCS;
 CompoundCell cellList = new CompoundCell(this).FromLibrary(CS, CSlibrary, cellname);
 }
} 
 Main issue is, though, that the node does not evaluate unless the input properties are provided to it. Then it will execute also when the values are overwritten inside the function. 
 (4) scope: 
 Your next example is: 
 Wayne Dickerson said: function() { string cellname = ' '; for (int i = 1; i <= polygon1.Flatten().Count; ++i) cellname = "type" + i; CompoundCell = new CompoundCell(this).FromLibrary(baseCS,"FacadeCompoundTest.bxc",cellname); } 
 
 What happens here is that the loop applies only to the statement 
 cellname = "type" + i; 
 Consequently, the line 
 CompoundCell = new CompoundCell(this).FromLibrary(baseCS,"FacadeCompoundTest.bxc",cellname); 
 is executed only once, and cellname is the last cell name that was generated in the loop ("type18"). 
 To place all 18 cells ("type1" to "type18"), both of the statements need to be combined in a code block by using curly brackets. This is also what the Statement Builder in the Editor generates: 
 
 The resultant code would look like this (with the CompoundCell assignment correction included): 
 function()
{
 string cellname = ' ';
 for (int i = 1; i <= polygon1.Flatten().Count; ++i)
 {
 cellname = "type" + i;
 new CompoundCell(this).FromLibrary(baseCS, "FacadeCompoundTest.bxc", cellname);
 }
}
 
 (5) more scope: 
 Collection of the compound cells into a list is helpful only if the result is expected to be a two dimensional array. In this case scope is relevant, too, as is sequence of actions. 
 Based on this premise, the CompoundCell node compoundCellPlace1 is a two-dimensional array, perhaps matching the Polygon array on the fa&ccedil;ade. Then we would need a pair of loops nested into each other, with the outer loop generating cell lists as children of compoundCellPlace1 and then the inner loop placing compound cells as children of these lists. 
 Lacking the proper context, here is a sketch of what that might look like: 
 function (string CSlibrary, CoordinateSystem CS, Polygon[][] facadePolys)
{
 // Assumption is that CSlibrary is the valid name of the compound cell library
 // and that it is passed into the node.
 // CS = baseCS; should be passed into the node (baseCS wired to CS input property).
 // facadePolys is the two-dimensional array of facade polygons.
 // The generated cellname was created in analogous fashion when creating the compound cells.
 
 string cellname = "";
 
 for (int i = 0; i < facadePolys.Count; ++i)
 {
 int i1 = i + 1;
 CompoundCell cellList = new CompoundCell(this); // no need to fill the list with a cell instance
 
 for (int j = 0; j < facadePolys[i].Count; ++j)
 {
 cellname = "type" + i1 + (j + 1); // need same logic when creating the cells!!!
 new CompoundCell(cellList).FromLibrary(CS, CSlibrary, cellname);
 }
 }
}
 
 HTH, 
 Volker

Mueller · Answer

Hi Wayne, 
 For assignments to specific compound cell catalog items' properties, these catalog items need to exist prior to GC attempting to write to them. You'd use the Catalog Editor to add entries with the item names that you'll use later when creating the compound cells. Instead of "Type_All" for all of them, you'd use "Type11", "Type12" etc., requires a bit of copy/paste/modify the name. Then property assignments for each catalog item should stick. 
 In your script, the node compoundcellTest fails (error: "Internal error") because the expected input to the Solids input property is a flat list of Solids. It does not permit replication or otherwise nested lists. Adding Flatten() behind the input {solid1, solid2}. Then the error goes away. The result is the entire fa&ccedil;ade becoming a compound cell. You solve that later by flattening replicated solids and plan symbol lines through the Watch nodes. This can be achieved directly without that detour. For example, compoundcellTest.Solids could receive directly the solids that you need, e.g. {solid2.Flatten()[i], solid1.Flatten()[i]}. 
 When placing the compound cells, please refer to the code from about a week ago. 
 HTH, 
 Volker