Using parameters to select custom iParts in an assembly.

[jgrubbsK7TWJ]

TLDR: Is there a way to make an assembly choose from existing iParts or create new iParts from an iPart factory based on parameters set within that assembly?

I am attempting to create an assembly factory which chooses component parts of the right (specified) length, or if they don't already exist, to create new ones accordingly. In this instance, one of the component parts is a rod of variable length. Several lengths of rod have already been created to choose from, but there are an indefinite number of possible variations. For this reason, I have made a custom iPart with its length as the defining variable between its different versions. This allows new variations to be created as necessary. 

I would like a parameter in the assembly to drive which rod is selected out of the existing set, or to create a new one if necessary. 

One option already explored was to have the rod be a normal part, and simply have an iLogic rule in the assembly set the rod length to a user-specified parameter. The problem with this is that the part is then the same length for all assemblies, which breaks all but the most recent assembly. The rod component was made into an iPart to avoid this problem, but now every instance of the part would have to be placed in each new assembly by hand, which is impractical given the large number of these parts on the real assembly. I would like to do this same kind of thing, except with iParts from a factory.

Should I make this an iAssembly? How could parameters drive part selection in this way? Is there any mechanism which would allow for such an 'assembly factory'? Let me know if you need more information. I'm just getting started learning iLogic and configurators, so any solutions, suggestions, or comments you may have are greatly appreciated. Thanks.

Images of an example part and assembly are attached below.

Rod iPart. Note length is the differentiating variable:

Assembly. Would like the 'value' column on the right to take a variable, rather than a fixed number.

[A.Acheson · Accepted solution]

Hi @jgrubbsK7TWJ 

iAssemblies do not accept custom iparts so that option is out. 

The only configuration that is going to be robust would be an ilogic assembly and use place ilogic component to place the assembly and any custom part will be automatically saved to the workspace. You cannot control the filename with this method. Any iproperty changes will need to be done manually or with ilogic script after the configuration has been placed. See video of how to it works here

This method should solve the issue of parts in your current assembly being changed in previous assembly. This is due to the parts being an independent file. 

While it would be possible to place factory member by code and create a new member in the factory and place the member to the assembly this may not work out to well in practice. An ipart factory should live in library folder and be read only so when the assembly files get copied the ipart member are skipped.

[jgrubbsK7TWJ]

A.Acheson, thank you for your answer, it was most illuminating.

After some experimentation, I was able to create a sort of dynamic assembly where I could change both component parts and features of the assembly cleanly just by manipulating some variables in the assembly itself. This makes the process of modifying an assembly quick and easy. When these changes affect part dimensions, it will automatically create new part files for these variants. I'll explain how to set this up for those who might be curious:

1. Create normal component parts for your assembly.
2. Optional but recommended: when setting dimensions for these parts, give them intelligible names by entering 'newParameterName = dimensionValue'. Not every parameter needs some nice name, but at least do this for the ones you want to be able to manipulate from the assembly level.
   
3. Save these component parts.
4. Create and save a new assembly. You won't be able to place your new dynamic parts until you save the assembly.
5. Consider which dimensions you want to be able to manipulate from the assembly level and any relations between them. You will find a table of your assembly parameters under Assemble>Parameters. Use 'add numeric' to create parameters and name them according to the features they correspond to. Don't worry too much about their current values.
6. Place your dynamic parts using 'Place iLogic Component', then connect your part parameters to their corresponding assembly parameters.
   
7. Note: Make sure to declare all your variables in the assembly before adding the dynamic parts which need them, since you can't declare new assembly parameters or use equations when you go to place a part. All the logic will need to happen in the assembly parameter table.
8. Put together the assembly using your dynamic and regular parts. You can use these assembly parameters to affect not just the part dimensions, but also the position of the parts in the assembly. 
9. Component Patterns: you can use component patterns to your advantage and set their number and spacing with assembly parameters for ultimate flexibility. Notice in this example how (1) the length of both manifold and baseplate are altered, but also (2) the number of pipes, since the pipes are part of a component pattern.
10. Files: Whenever you use 'Place iLogic Component' to place one of these dynamic parts, regardless of the parameter you use to drive its dimensions, it will create a new part variation under the same folder as the assembly you are placing it in. New part files will take on the base name plus their version number as a filename. These new versions will have unique version numbers locally in their working folder, but not globally.
    

I hope this will help anyone looking to automate modifying their assemblies without using iParts and iAssemblies. This approach is, in my opinion, more intuitive, elegant, and flexible than staring down giant inscrutable tables of parts and configurations, though perhaps this is merely a reflection of my lack of experience with iAssemblies. Either way, I hope this will be at least somewhat useful, best of luck.