KnowledgeBase

User inputs and calculation results are stored in attributes with the following data types:

Special case: combo attributes

The FVA-Workbench input editor includes many drop-down lists, where the user can select from several options. This selection is stored in so-called combo attributes. These combo attributes can be either string, integer, or double data types.

"Allocation of addendum modification" combo attribute in the FVA-Workbench editor.

For combo attributes, an internal value list is stored, in which each option is assigned to exactly one value.

The attribute overview explains the value which corresponds to each selection.

setAttr("ratio_X1_X2", stageID, 6, EDAT);

Example script: sets "Allocation of addendum modification" combo attribute to a value of 6 for "uniform rolling contact pressure."

The validity range describes where a variable is available and can be used within a script.

JS variables are either global or local. Global variables are declared using the keyword var. var myVariable = 3.14 Global variables can be accessed from anywhere in the script. However, this can quickly lead to errors, as variables can be assigned more than once or overwritten.

Local variables are declared using the keyword let. let myVariable = 3.14 Local variables can only be accessed within the current code block.

Example - declaring a global variable

 1for(var i=0; i<10; i++){
 2println(i);
    }

Example - declaring a local variable

1for(let i=0; i<10; i++){
2println(i);
   }

JS offers a number of mathematical functions that can be used in scripting in the FVA-Workbench:

Comparison operators are used in logic statements to determine whether variables or values are equal or different. Logical operators are used to logically link two or more conditions together.

Example - if statement condition using comparison and logic operators

let age = 17;
let country = "germany";

if(age >= 16 && country == "germany"){
   println("You are allowed to drink beer");
}

The header of a for loop includes a counting variable, a continuation condition, and an instruction for changing the counting variable.

Example - increase the torque for a load component from 0 to 100 in increments of 10, and run a system calculation after each increase.

let gearUnitID = 1;
let forceID = 20;
for (let i = 0; i <= 100; i+=10){
    setAttr("scaled torque", forceID, i, EDAT);
    runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
}

Example - display the name of each rolling bearing in the model on the Scripting Monitor.

let bearings = getCompByType("bearing");
for (let i = 0; i < bearings.length; i++){
    println(getCompProperty(bearings[i], "NAME"));
}

while loops

While loops repeat instructions as long as the condition at the beginning of the loop is true. If the condition is not true for the first query, the while loop is not executed at all.

var i = 0;
while (i < 10) {
   println(i);
   i = i+1;
}

do-while loops

In contrast to while loops, the loop condition is first checked at the end of the loop. Therefore, the loop is executed at least once.

var i = 0;
do {
   println(i);
   i = i+1
}while (i < 10);

The forEach loop executes an instruction for each element in an array.

Example - multiply each value in an array by 3 and output to the Scripting Monitor.

let array = [2, 4, 5];
array.forEach(function(element){
    println(element * 3);
});

Example - set the input value (EDAT) for ISO 6336 application factor for all cylindrical gear stages to 1.5.

let cylindricalStages = getCompByType("cylindrical_mesh"); 

cylindricalStages.forEach(function(element) { 
    setAttr("iso 6336 application factor", element, 1.5, EDAT);
});

An if statement executes an instruction when a condition becomes true. If the condition is false, a different command can be executed using an else statement.

Example - Query the safety against fatigue fracture of a notch and execute different instructions depending on the value.

1let gearUnitID = 1;
2let notchID = 64;

3setAttr("gta_switch_iso_6336_2006", gearUnitID, true, EDAT);
4runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
5let safety_SD = getAttr("safety_factor_S_D", notchID, RDAT);

6if (safety_SD >= 1.2){
    alert("Success SD = "+safety_SD);
7}else{
    alert("Failure SD = "+safety_SD);
    }

The switch statement is used to execute different actions based on various conditions. The break keyword terminates the switch statement and the corresponding value is returned. The default keyword defines the instruction that is executed if none of the values match.

Example - set different face modification values depending on the module

1let gearID = 30;
2let modificationID = 51;
3let module = getAttr("normal module", gearID, EDAT);
4let amount = 0;
5switch (module) {
6    case 1:    amount = 3; break; 
        case 1.5:  amount = 3; break;
        case 2:    amount = 5; break;
        case 2.5:  amount = 8; break; 
        case 3:    amount = 10; break; 
        case 4:    amount = 12; break; 
        case 5:    amount = 15; break; 
        case 6:    amount = 15; break; 
        case 7:    amount = 15; break; 
        case 8:    amount = 20; break; 
        case 10:   amount = 25; break; 
7    default:   alert("No modification amount defined for this module"); break; 
  }
8println("Modification Amount: "+amount+" mym");
9setAttr("sekor_cb_bet", modificationID, amount, EDAT);

If an error (exception) occurs during the execution of a script, the script is terminated and the exception is displayed on the Scripting Monitor.

An exception on the FVA-Workbench Scripting Monitor

Try-catch statements can be used to catch errors that occur while the script is running, react to them, and if possible to continue to execute the script despite the error.

To do this, the command in which an exception may occur is framed by a try statement. If an exception occurs, the command in the catch statement is executed.

Example

In the try statement, an attempt is made to execute a calculation. The parameters for the runCalcMethod() are the calculation method and the ID of the component to be calculated. Now, multiple errors can occur during the runtime. The method ID or the component ID may not exist, or the selected combination of the two cannot be calculated. The exception is caught in the catch statement and a message is displayed. The script then continues to run.Calculations in scripting

try {
   runCalcMethod(methodID, compID);
}
catch (e) {
    println("Error in the calculation of the component "+compID+" with calculation method "+methodID);
}
println("Script is continued");

Arrays are data structures in which multiple values can be saved in one variable. The element index in brackets controls the access. The index starts at 0.

let array = [element0, element1, element2];

array[2] returns the third element in the list.

The length, or number of elements, can be queried with the .length method.

array.length returns 3.

Additional elements can be added to the end of the array using the array .push(newElement); method.

In the FVA-Workbench, arrays can contain numbers, strings, and components.

Example - accessing arrays

let array = [2, 4, 5];
let result = array[0] + array[2];
println(result);

In this example, adding 2 elements to an array results in 7.

Example - querying the array length

let numbers = [1, 2, 3, 4, 5];

for (var i = 0; i < numbers.length; i++) {
   numbers[i] = numbers[i]*2;
}
println(numbers);

The for loop will run as often as the number of elements in the array. Each time, the current element is overwritten with the value of the element * 2. When the loop is finished, the array contains the following elements: [2, 4, 6, 8, 10]

Example - adding elements to an array

let carmakers = ["BMW", "Mercedes", "Audi", "Edsel"];
carmakers.push("VW");
println(carmakers);

An additional element, "VW" is added to the "carmakers" array via .push. ["BMW", "Mercedes", "Audi", "Edsel", "VW"]

Example - saving FVA-Workbench components in arrays

let bearings = getCompByType("bearing");

for (i=0; i < bearings.length; i++){
    let catalog_name = getAttr("name", bearings[i], EDAT);
    println(catalog_name);
}

The getCompByType() function returns an array with all components of a type (here, rolling bearings). The for loop queries the "catalog name" attribute for each element (bearing) of the array and displays it on the Scripting Monitor.

The inline statements tab \t and line break \n are available for simple text formatting. The format() function can be used for further text formatting. Multiple strings of text (strings) can be joined together using the + operator.

Figure 30. Line break A line break can be created using \n.

Figure 31. Tab \t indents the text by one tab.

Figure 32. Linking multiple strings

Multiple strings as well as numerical values can be linked together into a long string.

The current year, month, day, hour, minute, second, and milliseconds can be output using the Date JS object. Initialize a variable with new Date(); to query the date. The query is then performed using point notation on this variable.

Example - Outputting the complete date and the current month on the Scripting Monitor

var today = new Date();
println(today);
println(today.getMonth());

In JS, comments can be used to clarify code and make it easier to read. It can also be used to temporarily comment out sections of code, for example to try alternative code.

1//Comments can be used to explain the code
    /*
2  Code between /* and */ is not executed
    */