There’s a neat ‘trick’ you can perform using Vault Data Standard (VDS) and iLogic that involves creating Engineer-To-Order (ETO)-type components.  If you have a semi-standard product line that changes based on customer spec you can use VDS to help create new iterations of those components, and even off-load the creation of those components to non-CAD users.

Here’s how it works:

• Create iLogic rule(s) in your component to update Model or User parameter values based on custom iProperty values
• Create Vault User Defined Properties (UDPs) and map those UDPs to the relevant custom Inventor iProperties
• Save the components as templates in Vault
• Use the VDS “Create New Standard File” functionality to create new copies of the files, capturing the customer spec in the Vault UDPs
• When you next open the file in Inventor it will update to customer spec

The Vault UDPs could even be lists, so if you have pre-set sizes or options you can ensure users only select between valid inputs.  With a little PowerShell wizardry, you could even create filtered picklists, allowing you to enforce some business logic during input.  Below is a very simple example.

The Part and its iLogic rule

This example has a very simple part with inputs for Length, Width, and Height:

We have corresponding custom iProperties for each parameter as well:

The iLogic rule is also very straightforward:

The rule just sets the value of each Model Parameter to match the custom iProperties.  Depending on any input validation you do on the front end, your rule may also need to validate the custom iProperties.  Also notice the RuleParametersOutput() and InventorVb.DocumentUpdate() lines.  This is necessary for the part to automatically update once it’s opened.  The other bit to cause the part to auto-update is to set an event trigger for the rule:

With all of this in place, you can check the file into Vault.  Its default location should be $/Templates/Inventor, but you can customize the Vault Data Standard to specify another location if necessary.

The Vault Configuration

With the file checked in, you can create and map the necessary UDPs (though you could do this before check-in as well).  This is straightforward; just create the UDP, make sure it’s associated with any categories the ETO parts might be assigned, and map the UDPs to the custom iProperties:

You can even make list properties if you have discrete sizes:

The properties don’t have to be strictly numbers, either; if word-based descriptors are easier for the users, and your iLogic rule can be coded to use them (e.g. Small / Medium / Large or Left Hand / Right Hand) you can use those types of properties as well.

The Data Standard

Now that everything is in place, you can start creating custom parts.  You don’t even have to do anything special in the Vault Data Standard configuration.  Just use the default New Standard File… command:

You’ll be presented with a dialog to fill in the relevant Vault properties, which will include your custom properties that ultimately drive the component’s physical characteristics:

Once everything is filled out, press OK and your component is done!  Now you can open Inventor and it will immediately update to match the entered parameters:

The Payoff

Keep in mind anyone in your organization with access to Vault Professional could create parts like this – even if they don’t have the first clue how to use Inventor.  Now imagine a scenario where sales or order entry can create new components based on customer spec, and Engineering just opens the documents, verifies them, creates any necessary documentation, etc.  Sounds pretty good, right?

This method works very well with single parts.  It won’t work with most assembly documents, at least not without some pretty intense customization of the Data Standard.  Creating new files this way doesn’t capture any file relationships on the new files, so even if your assembly template has Vaulted references, they won’t be present on the newly created Assembly.  An exception would be if your assembly iLogic rule(s) are written in such a way to build an assembly from scratch, which is possible, though not trivial.

Still, the overall workflow is very clean and simple and could offload significant effort from Engineering.  If your ETO needs align with what this method can provide, try it out!