Visual Algorithm Composer

Navigation: Analysing with algorithms >

ABACUS' Visual Algorithm Composer feature is a easy to use interface that allows you to build logic on how properties can be calculated and either aggregated up hierarchy or attributed across connections. With this capability, you can build various calculated key performance indicators and other metrics using custom logic, without requiring any programming experience.

Creating/Opening an Algorithm Visual Composer

1.While the Visual Composer is not currently opened, click Tools|Visual Composer which will open a new algorithm.

- or -

1.Click Tools|Manage Algorithms

2.In the Manage Algorithms dialog box, you can open an existing algorithm by double clicking on it or by clicking on the Edit button. If you need to first create an algorithm, this can be achieved by selecting New|New Visual Algorithm.

Using Algorithm Blocks

Algorithm blocks are operations that are sequentially operated and can perform calculations using various properties and attributes in your ABACUS project. The results of these calculations can then be stored in the properties of components. The properties that provide the inputs to an algorithm may be on different components to the properties that store the results.

Every visual algorithm must begin with the Start object (represented by a green circle) which represents where the visual algorithm will begin its operations. The start object must be connected sequentially to building blocks that determine the algorithm flow There are several Algorithm Blocks each with their own unique functions and role including:

•Get Components

•Operation

•Get Property

•Get Output

•Filter

•Attribution

•Constant

•Set Property

Algorithm Blocks

Note

Outputs generated from algorithm blocks can be used at any point after they have been called, regardless of ordering.

Get Components

Retrieves components from the project or a given architecture of a particular type that can used in the input fields.

1.Architecture: The architecture to retrieve the components from.

2.Type: The component type to retrieve components for.

3.SubTypes: Whether subtype components should be included.

Get Connections

Retrieves connections from the project or a given architecture of a particular type that can used in the input fields.

1.Architecture: The architecture to retrieve the connections from.

2.Type: The connection type to retrieve connections for.

Operation

Performs an operation on the given components based on the at least two (2) properties that can be dragged on using the Get Property, Constant or Get Output blocks, storing a temporary property to be used in subsequent Operation, Attribution or Set Property blocks.

Note

The order of the Get Property/Get Output/Constant blocks in the Operation is the order that the operation will occur for Subtract and Divide (for the others, the order doesn't matter). As an example, for Subtract it will be the value of the first item, minus the values of subsequent items.

1.Input: A set of components (does not include components with a property that Attribution outputs).

2.Perform: Type of operation to perform with the given array of inputs (properties/constants). Note that only valid values will be used in the relevant calculation, and in the case of subtraction/division the first value is where the calculation is begun and will be considered a 0 should the data be invalid.

•Average - Calculates the average of the given properties/constants.

•Count - Finds the count of the property values that are not empty/missing (even if not a valid value according to the data type).

•Max - Finds the maximum value from the given properties/constants.

•Min - Finds the minimum value from the given properties/constants.

•Sum - Calculates the sum of the given properties/constants.

Tip

An example of using constants, given solely the Constant block is inside a Sum operation containing the value 5, for the given element type supplied it outputs using a SetProperty block into the selected property a value of 5.

•Multiply - Calculates the multiplied values of the given properties/constants.

•Subtract - Calculates the remaining value after subtracting from the first value of the given properties/constants.

•Divide - Calculates the initial property/constant value divided by the remaining given properties/constants.

•Power - Calculates the powered values of the given properties/constants.

•Log - Calculates the log values of the first child block with the base of the second child block. Typically, the first child block will be the property to log and the second child block will be the base, e.g. Log₁₀x would have 'x' as the first child block and a Constant block (see below) with 10 as the second child block. Note: a Constant block with math.e can be used for a natural logarithm. More than 2 child blocks will cause an error at run-time.

•Round - Calculates the rounded values of the first child block to the decimal places specified in the second child block. The first child block should be the property to round and the second child block will be the number of decimal places, e.g. a Constant block (see below) with 1 as the second child block will round to 1 decimal place and 0 will round decimals to integers. Note: .5 numbers are rounded up so 0.5 becomes 1 if 0 decimal places are used and 2.65 becomes 2.7 if 1 decimal place is used. More than 2 child blocks will cause an error at run-time and a decimal value in the second child block will just use the integer part of the decimal for the rounding value.

•Atan2 - Calculates the atan(y,x) value in radians with the first child block being the y dimension and the second child block being the x dimension. This is particularly useful for converting Cartesian co-ordinates to Polar co-ordinates, for example Information | Business Fit and Information | Technical Fit properties into an angle representing the 'quadrant' that the combined result is in. The result is in radians and so needs to be scaled with math.pi (using another Operation block) into a 0-360 degree angle (and divided into a smaller scale to cast into a List property for (say) Lifecycle | Recommendation).

•Join - Combines the given values together as text format.

•SpaceJoin - Combines the given values together as text format separated by a space.

•CommaJoin - Combines the given values together as text format separated by a comma and space.

Note

Average/Max/Min/Sum/Multiply will perform the operation only on the set of values that are valid for the data type (e.g. "Hello" cannot be converted to a number). Subtract and Divide will perform the operation on the set of values that are valid for the data type, but because the first value in the set is handled differently from the rest (e.g. A-B-C, or A/B/C), if the first value is not a valid value, then the value of 0 will be used for the first item. e.g. 0-B-C or 0/B/C if the value for "A" is invalid. Effectively for divide this will always mean the resulting value will be 0 (if B/C/etc aren’t zero), or infinity (if one of B, C etc is 0). Power will perform the operation on the set of values that are valid for the data type including negative numbers and decimals (e.g. X^0.5 is square root and X^-2 is 1 / X^2).

Operation example

Tip

In the Operation example, the visual algorithm is performing a "sum" of five Budget type properties and storing the value in the "Budget|Total Budget - next 5 years." property for "Grouping" components for all architectures.

Get Property

Retrieves the property values from the given components in the input field. Note: This block can be used within the Operation block.

The Get Property algorithm block retains a reference to the selected property and its component, so when used as a input for a Attribution block it is important to understand the component is also being referenced and used.

1.Input: A set of components to retrieve the property for (unavailable when being used in Operation blocks).

2.Type: The type of the property you are retrieving from.

3.Name: The name of the property you are retrieving from.

4.Ask ABACUS for empty values: Check to enable Ask ABACUS to fill in empty data.

5.Minimum Threshold: Setting for retrieving the predictions that are above the specified confidence threshold.

Tip

You can retrieve general properties which include Created, CreatedBy, Description, Modified, ModifiedBy and Name from components using this block by selecting General Properties from the type drop-down, and select the desired general property from the name drop-down.

Note

To use the Ask ABACUS feature, you will need to ensure that your ABACUS license allows access on top of the Simulators & Algorithm Composer feature.

In ABACUS Enterprise, it's essential to verify the completion status of Ask ABACUS training, which can be done by navigating to Administrator Options > Ask Abacus. See ABACUS Enterprise help documentation for more information.

In the Studio, to finish configuration you will need to enter Enterprise URL. Note: Only Collaboration files will be compatible with this feature.

Note

List properties are indexed when they are loaded and they can then be processed via their indexed values. So Small-Medium-Large will become 1-2-3 and it is possible to then perform Small + Small = Medium with the Operation block (see above). Date properties are loaded in their OLE Automation format which is a floating-point number whose integral component is the number of days before or after midnight, 30 December 1899, and whose fractional component represents the time on that day divided by 24. For example, midnight, 31 December 1899 is represented by 1.0; 6 A.M., 1 January 1900 is represented by 2.25; midnight, 29 December 1899 is represented by -1.0; and 6 A.M., 29 December 1899 is represented by -1.25. It is possible to then perform operations with the date properties.

Constant

Lets the algorithm use a constant value in an Operation, for all elements in the dataset. This is useful for having the ability to use a set value from either a constant number or some other special system commands like Date.Now, Math.PI, etc.

Note

If you want to use a string value it must be in "double quotes". This is needed in order to distinguish string values from commands like Date.Now.

Filter

Filters the given elements based on the value associated with the component in the specific input dataset selected for the filter block. Only the element's whose values satisfy the filter are then passed on into the output dataset. Note that the Filter block works differently to the Constant block and doesn't support special system commands like Date.Now. Also, unlike the filter block, a string filter doesn't require double quotes - if quotes are used then the filter looks for exact matches. Otherwise, without quotes, it will look at whether the element's value (if it is a string) contains the filter text.

Note

As a shortcut, you can use a filter on the name of an element, by adding a Filter block directly after a Get Components block. Otherwise, you would filter after using a Get Property block with General Properties/Name as the property.

1.Input: Value to filter components on.

2.Value: Query to execute values on.

Tip

The query portion of the filtering supports the use of certain operators as well as special characters. These operations and special characters include: NOT, >=, >, <=, <, *, ?, " and '. It is important to note that if your value does not contain an operator (besides NOT) it is implicit that both the start and end of your query will be considered wild cards and attempt match any value that contains your supplied value.

Tip

This query supports multi-type matching, which means the values will match based on the most relevant common type. This is due to the unpredictable nature of property types that can be passed in for a single property type/name and will do the best type comparison it can where both values are the same type (e.g. a text based comparison is the lowest priority and a integer comparison has a higher priority and will execute over the text based comparison).

Some examples include:

•42 - Equal to the integer 42

•>= 10.5 - Greater or equal to the decimal 10.5

•> 2/3/2018 - Greater than 2/3/2018

•< Sep 21 2019 - Less than 21/9/2019

•App - Contains the text "App"

•App*1?5 - Starts with "App" and ends with 1?5 where ? matches any individual character

•"Application 125" - Anything that exactly matches "Application 125"

•"" - Matches blank values

•NOT "" - Matches any non-blank values

Attribution

Lets you perform an attribution on the given properties with certain calculation methods and particular settings, storing a temporary property on a target to be used in other Attribution or Set Property blocks.

1.Input: A set of components and a property.

2.Perform: The type of action to perform the attribution with the given property. See Operations Perform section for more information on the options.

3.Target: The type of relationship to use for attribution for the given input components to the output components.

•Parent - The input components parent.

•Children - The input components children. Note: there can be multiple components from the input targeting the same children.

•Source Component - The input components are at the source end and the output is directed to the specified sink component.

•Sink Component - The input components are at the sink end and the output is directed to the specified source component.

•Outgoing Connections - The outgoing connections of the input components.

•Incoming Connections - The incoming connections of the input components.

Note

If the input of an Attribution block is a Get Connection block, then only Source Component or Sink Component will be available in Target. If either of these are selected, the output of this Attribution block will be a list of components.

4.Split: Whether the value should be set on the target evenly or all the same. This feature is available when there is potential for multiple targets due to the nature of the connection or hierarchy, take care that in some scenarios such as when the value is of "date" type, it would be recommended not to split value.

5.Type: The type of components that the output is being sent to.

6.Connection: The type of connection to use for linking the components the input components with the selected Type, used when the Target is "Source Component" or "Sink Component".

Attribution example

Tip

In the Attribution example the visual algorithm is finding the minimum found value of property "Lifecycle|5. End of Life Date" in "Application" components among the "Application" components that are at the source end connecting to a "Process" component via a "Uses" connection type and storing the found minimum value in the "Process" components property called "Lifecycle|5. End of Life Date" for all architectures.

Get Output

Retrieves the property values from either a Get Property, Operation or Attribution block. Note: This block can only be used within the Operation block.

Set Property

Sets an input value on a selected property of the component that was associated with the input. This is the only time that values are written and saved to the objectmodel, where Attribution and Operation are only temporarily storing the values.

1.Input: A set of components and a property.

2.Type: The type of the property you are setting.

3.Name: The name of the property you are setting.

Note

Decimal values are rounded to 2 decimal places, so slight rounding errors can be introduced if several algorithms are cascaded together using Set Property blocks in between them while using the outputted values in following algorithms. Also, numerical values are cast into the List property 'bins' (using rounding if a decimal) so a value of 3.2 when cast into a List property with range Low|Low-Medium|Medium|Medium-High|High will be set to Medium, 1.8 will be set to Low-Medium. However, if rounding of decimals does not bring the value into the indexed ranged, the 'raw' numerical value will be written and likely cause data type warnings or errors. I.e. A numerical value > 5.5 or < 0.5 will be written as the raw value in the Low...High range above. Date properties are internally processed in their OLE Automation format (a floating-point number of days before or after midnight, 30 December 1899) but when any value is written to a date property with the Set Property block an attempt to convert it back to a date format is made and if the value is not a properly formed date then the raw OLE Automation format value will be written and likely cause data type warnings or errors.