FVA-Workbench KnowledgeBase

Das folgende Script erhöht in jedem Durchlauf den Schrägungswinkel eines Stirnrades um 1°, führt eine Gesamtsystemberechnung inklusive Verzahnungsanregung durch und gibt den maximalen Drehwegfehler auf dem Scripting-Monitor aus.

Download (Modell inkl. Script)

Download (Nur Script)

Ausführung des Scripts in der FVA-Workbench

1var gearUnitID = 1;
2var stageID = getCompByType("cylindrical_mesh")[0];
3var gearID = getCompByType("cylindrical_gear")[0];

4setAttr("gta_switch_deactivate_all_calculations", gearUnitID, true, EDAT);
5setAttr("gta_switch_3d_load_distribution_analytical", gearUnitID, true, EDAT);
6setAttr("gta_switch_3d_force_excitation", gearUnitID, true, EDAT);

7for(angle = 0; angle <= 20; angle++){
8    setAttr("helix angle reference diameter", gearID, angle, EDAT);
9    runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
10    var trans_error_max = getAttr("result_transmission_error_maximum", stageID, RDAT);
11    println("Transmission Error at "+angle+"°: "+trans_error_max+" µm");
     }

Das folgende Script liest die Höhen-, Breitenkoordinaten und die Modifikationsmatrix aus einer Exceldatei ein und schreibt diese Werte in die entsprechenden Attribute einer Modifikationskomponente im FVA-Workbench Modell. Dabei werden die Excel-Scriptfunktionen getValuesRow(), getValueColumn() und getValuesMatrix() verwendet um die Arrays und die Matrix aus der Excel-Datei in Script Variablen zu schreiben.

let excelfile = "C:\\folder\\modification_matrix.xlsx";
let workbook = workbookFactory.createWorkbook(excelfile);

let modificationID = 1399;
let width_coords = workbook.getValuesRow("B1", 5);
let height_coords = workbook.getValuesColumn("A2", 6);
let mod_matrix = workbook.getValuesMatrix("B2", 6, 5);

println(width_coords);
println(height_coords);
println(mod_matrix);

setAttr("sekor_matrixk_enabled", modificationID, true, EDAT);
setAttr("width_coordinates", modificationID, width_coords, EDAT);
setAttr("height_coordinates", modificationID, height_coords, EDAT);
setAttr("modification_matrix", modificationID, mod_matrix, EDAT);

Das folgende Script ermittelt den optimalen Betrag für eine Schrägungswinkelkorrektur, sodass der Breitenlastfaktor KH_Beta minimal wird.

Korrekturen sind in der FVA-Workbench eigene Komponenten, die auf einem Stirnrad eingefügt werden können. Auf der Korrekturkomponente können mehrere Korrekturarten (z.B. Breitenballigkeit, Höhenballigkeit) aktiviert und bedatet werden. In diesem Fall soll die Schrägungswinkelkorrektur aktiviert werden. Im Editor der FVA-Workbench gibt es hierfür unter der Korrekturkomponente den Schalter "Schrägungswinkelkorrektur berücksichtigen". Um diesen Schalter via Scripting zu aktivieren, muss das Attribut "sekor_CHB_enabled" auf true gesetzt werden.

Weiterhin wird das Attribut "Form der Schrägungswinkelkorrektur" auf "Am Beginn der Zahnbreite (kleinere u-Koordinate)" gesetzt. Um diese Auswahl via Scripting zu treffen, muss das Attribut "sekor_hcb_form" auf den Wert "3" gesetzt werden.

Für weitere Informationen zum Thema "Setzen von Attributwerten" siehe Datentypen

Dieses Script benötigt für seine Ausführung ein Modell, dass mindestens eine Stirnradstufe enthält, wobei auf mindestens einem der Räder eine Korrekturkomponente eingefügt ist.

Download (Modell inkl. Script)

Download (Nur Script)

Teil 1: Richtung der Korrektur bestimmen

Im ersten Schritt muss die Richtung der Korrektur bestimmt werden. Da als Form der Schrägungswinkelkorrektur "Am Beginn der Zahnbreite" ausgewählt wurde, bezieht sich die Korrekturrichtung auf den Punkt A in der Abbildung. In diesem Fall ist die Korrekturrichtung links, es wird auf der linken Seite Material abgetragen. Ist die Korrekturrichtung rechts, wird auf der rechten Seite (Punkt B) Material abgetragen. Ist die Richtung rechts, wird der Korrekturbetrag positiv angegeben. Dementsprechend wird bei Korrekturrichtung links ein negativer Betrag angegeben.

Beispiel für einen Korrekturabtrag links von z.B. +15µm, ausgehend vom Punkt A, dem Beginn der Zahnbreite.

Damit das folgende Script auf beliebige Modelle angewendet werden kann, werden die Komponenten IDs nicht fest in Variablen gespeichert, sondern über die prompt() Funktion vom Scriptbenutzer zur Laufzeit abgefragt.

Die Ermittlung der Korrekturrichtung erfolgt folgendermaßen:

1. Berechnung von KH_Beta ohne Korrektur

2. Berechnung von KH_Beta mit einem Korrekturbetrag von +1µm

3. Berechnung von KH_Beta mit einem Korrekturbetrag von -1µm

4. Ist der Wert von KH_Beta bei +1µm größer als bei -1µm ist die Korrekturrichtung Rechts, ansonsten Links

1var stageID = prompt("Enter Cylindrical Stage ID");
2var gearID = prompt("Enter Cylindrical Gear ID");
3var modificationID = getSubComponents(gearID, "gear_correction")[0];
4var gearUnitID = 1;

5setAttr("sekor_CHB_enabled", modificationID, true, EDAT);
6setAttr("sekor_hcb_form", modificationID, "3", EDAT);

7setAttr("sekor_chb_bet", modificationID, 0, EDAT);
8runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
9var khBetaNoMod = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);
10println("KH_Beta unkorrigiert: " + khBetaNoMod);

11setAttr("sekor_chb_bet", modificationID, 1, EDAT);
12runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
13var khBetaPosMod = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);

14setAttr("sekor_chb_bet", modificationID, -1, EDAT);
15runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
16khBetaNegMod = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);

17if (khBetaPosMod > khBetaNegMod){
18    var direction = "right";
19}else {var direction = "left";} //kleine u-Koordinate

20println("Direction of modification: "+direction);

1	Nutzereingabe der Stufen ID in Variable stageID schreiben.
2	Nutzereingabe der Rad ID in Variable gearID schreiben.
3	Über getSubComponents() werden alle Korrekturkomponenten auf dem Stirnrad abgefragt. Über [0] wird nur die ID der ersten Korrektur in modificationID geschrieben.
4	Variable gearUnitID mit der ID der Getriebeeinheit belegen.
5	Attribut "Schrägungswinkelkorrektur berücksichtigen" auf der Korrekturkomponente auf true setzen.
6	Attribut "Form der Schrägungswinkelkorrektur" auf den Wert "3" setzen.
7	Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf den Wert 0 (µm) setzen.
8	Gesamtsystemberechnung durchführen.
9	Ergebniswert (RDAT) des Attributs "Berechneter Breitenlastfaktor Flanke" auf der Stirnradstufe in khBetaNoMod schreiben.
10	Den Wert für KHBeta (unkorrigiert) auf der Scripting-Monitor ausgeben.
11	Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf den Wert 1 (µm) setzen.
12	Gesamtsystemberechnung durchführen.
13	Ergebniswert (RDAT) des Attributs "Berechneter Breitenlastfaktor Flanke" auf der Stirnradstufe in khBetaPosMod schreiben.
14	Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf den Wert -1 (µm) setzen.
15	Gesamtsystemberechnung durchführen.
16	Ergebniswert (RDAT) des Attributs "Berechneter Breitenlastfaktor Flanke" auf der Stirnradstufe in khBetaNegMod schreiben.
17	Wenn khBetaPosMod kleiner als khBetaNegMod:
18	Dann Variable direction mit dem String "right" belegen.
19	Sonst Variable direction mit dem String "left" belegen.
20	Ausgabe der Korrekturrichtung auf dem Scripting-Monitor.

Teil 2: Iterative Ermittlung des optimalen Korrekturbetrags

Ein Ergebnis der Gesamtsystemberechnung ist der 2D-Korrekturvorschlag für eine gleichmäßige Lastverteilung. Dabei wird der Korrekturbetrag auf mehrere Stützstellen über der Zahnbreite in einem Arrayattribut (correction_proposal_system_calculation) gespeichert. Ziel der Optimierung in diesem Script soll sein, dass die Differenz zwischen dem ersten Punkt im Array (1) und dem letzten (2) kleiner als 1 wird.

Dabei wird folgendermaßen vorgegangen:

1. Aktuellen Korrekturwert in Variable speichern.

2. Differenz zwischen erstem und letztem Punkt im Array ermitteln.

3. Je nach Korrekturrichtung die Differenz zum aktuellen Korrekturbetrag addieren oder subtrahieren.

4. Gesamtsystemberechnung mit dem neuen Korrekturwert durchführen.

5. Erneut die Differenz ermitteln -> Ist die Differenz kleiner als 1 wird das Script beendet.

Das Berechnungsergebnis Korrekturvorschlag kann über das Attribut correction_proposal_system_calculation abgefragt werden.

1do {
2   runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
3   var helixAngleModAmount = getAttr("sekor_chb_bet", modificationID, RDAT);
4   var correctionProposal = getAttr("correction_proposal_system_calculation", stageID, RDAT);

5   var delta = correctionProposal[0] - correctionProposal[correctionProposal.length-1];
6   if (direction == "left"){
7       var newHelixAngleModAmount = helixAngleModAmount + delta;
8   }else{  newHelixAngleModAmount = helixAngleModAmount - delta;}

9   setAttr("sekor_chb_bet", modificationID, newHelixAngleModAmount, EDAT);
10   println("Modification Amount: "+newHelixAngleModAmount+" mym"+" -> delta: "+ delta);
11}while(delta < 1);

12runCalcMethod("001_SYSTEM_CALCULATION", gearUnitID);
13var finalKhBeta = getAttr("gta_result_face_load_factor_flank", stageID, RDAT);
14println("Final KH_Beta: "+finalKhBeta);

1	Start der do-while Schleife.
2	Gesamtsystemberechnung starten.
3	Ergebniswert (RDAT) des Attributs "Schrägungswinkelkorrekturbetrag" in die Variable helixAngleModAmount schreiben.
4	Ergebniswert des Arrayattributs "Korrekturvorschlag aus Gesamtsystemberechnung" in die Variable correctionProposal schreiben.
5	Den letzten Wert im Array correctionProposal vom ersten Wert abziehen und in die Variable delta schreiben
6	Wenn Korrekturrichtung Links:
7	Differenzbetrag zur Variable helixAngleModAmount addieren und Wert in newHelixAngleModAmount schreiben.
8	Sonst: Differenzbetrag von der Variable helixAngleModAmount abziehen und Wert in newHelixAngleModAmount schreiben.
9	Eingabewert (EDAT) des Attributs "Betrag der Schrägungswinkelkorrektur" auf newHelixAngleModAmount setzen.
10	Neuen Korrekturbetrag + Differenz auf dem Scripting-Monitor ausgeben.
11	do-while Schleife solange wiederholen bis die Differenz kleiner als 1 ist.
12	Nach Beendigung der Schleife -> Gesamtsystemberechnung mit dem finalen Korrekturbetrag durchführen.
13	Den finalen KHBeta Wert auf dem Scripting-Monitor ausgeben.

Das folgende Script erzeugt eine Textdatei, in der Name, Formelzeichen, Wert und Einheit mehrerer Attribute formatiert dargestellt werden. Für die Formatierung wird die format() Funktion verwendet. Die Ausgabe in eine Datei erfolgt über die Funktion writeToFile().

Ausgabedatei des Scripts

1function formatAttr(attributeID, compID, DAT) { 
2   let name = getAttrProperty(attributeID, compID , 'NAME');
3   let symbol = getAttrProperty(attributeID, compID , 'SYMBOL');
4   let value = getAttr(attributeID, compID, DAT)+0.0;
5   let unit = getAttrProperty(attributeID, compID , 'UNIT_NAME'); 
    
6   let format_name   = format("%-35s", name);
7   let format_symbol = format("%-10s",  symbol);
8   let format_value;
9   let valueType = typeof value;
  
10  if(valueType == "number" && value %1 == 0){
11	 valueType = "int";
       }
12  switch (valueType) {
13     case "number": format_value = format("%-12.3f", value); break;
14     case "int":    format_value = format("%-12.0f", value); break; 
15     case "string": format_value = format("%-12s", value); break;
16     default:       format_value = format("%-12s", "Error"); break;
       }
17  let format_unit = format("%-3s", unit);
18  let resultstring = format_name + format_symbol + format_value + format_unit +"\n";
19  return resultstring;
}

1let filepath = "C:\\geometry.txt";
2let stageID = 3;
3let gearID = 8;

4writeToFile(filepath, "---------------------- Geometry ---------------------------\n", "c", "UTF-8");
5writeToFile(filepath, formatAttr("normal module", gearID, EDAT), "a", "UTF-8");
6writeToFile(filepath, formatAttr("face width", gearID, EDAT), "a", "UTF-8");
7writeToFile(filepath, formatAttr("center_distance_editor", stageID, RDAT), "a", "UTF-8");
8writeToFile(filepath, formatAttr("helix angle reference diameter", gearID, EDAT), "a", "UTF-8");
9writeToFile(filepath, formatAttr("addendum modification coefficient", gearID, EDAT), "a", "UTF-8");
10writeToFile(filepath, formatAttr("minimum_tip_clearance_factor", gearID, EDAT), "a", "UTF-8");

Das folgende Script fragt die maximale Zahnfußspannung für jeden individuelle Zahneingriff in einer Planetenstufe ab und gibt die Ergebnisse in einer Baumstruktur auf dem Scripting-Monitor aus.

Im Modellbaum der FVA-Workbench werden für das oben gezeigte Planetengetriebe nur 2 Stirnradstufen angezeigt, der Eingriff Planet-Hohlrad und der Eingriff Planet-Sonne. Diese 2 Mutterstufen enthalten alle Eingabedaten, die Anzeige aller 6 Verzahnungseingriffe ist nicht nötig. Die Berechnungsergebnisse hingegeben können sich für die individuellen Verzahnungseingriffe (1-6 in der Abbildung) unterscheiden. Daher hat jede der 2 Mutterstufen 3 Instanzkomponenten für die individuellen Stufen. Der Zugriff auf Ergebnisattribute diese Instanzkomponenten wird im folgenden Script gezeigt.

Ausgabe des Scriptes auf dem Scripting-Monitor.

let planetaryStageID = 9;
let stageIDs = getSubComponents(planetaryStageID, "general_stage");

for (let i = 0; i < stageIDs.length; i++){
    let stageInstanceIDs = getSubComponents(stageIDs[i], "planet_instance");
    let gearsInStageIDs =  getSubComponents(stageIDs[i], "general_gear");
	println(getCompProperty(stageIDs[i], "NAME"));
	
	for (let i = 0; i < stageInstanceIDs.length; i++){
		let planetAngle = getAttr("polar_angle_of_planet_instance", stageInstanceIDs[i], EDAT);
		println("\tIndividual tooth engagement ["+stageInstanceIDs[i]+"] @ "+planetAngle+"°");
		let stageGearDataID1 = getStageGearData(stageInstanceIDs[i], gearsInStageIDs[0]);
		let stageGearDataID2 = getStageGearData(stageInstanceIDs[i], gearsInStageIDs[1]);
		let toothRootStressGear1 = getAttr("result_tooth_root_stress_compression_maximum", stageGearDataID1, RDAT);
		let toothRootStressGear2 = getAttr("result_tooth_root_stress_compression_maximum", stageGearDataID2, RDAT);
	
		println("\t\tTooth root stress maximum "+getCompProperty(gearsInStageIDs[0], "NAME")+": "
		+toothRootStressGear1);
		println("\t\tTooth root stress maximum "+getCompProperty(gearsInStageIDs[1], "NAME")+": "
		+toothRootStressGear2);
	}
}

Das folgende Beispiel zeigt, wie XML-Dateien eingelesen, geändert und herausgeschrieben werden können.

Für weitere Informationen siehe: ECMAScript for XML (E4x) specification

Beispiel XML-Datei (people.xml)

<people>
   <person gender="male">
      <name>John Doe</name>
      <hair>Brown</hair>
      <eyes>Blue</eyes>
      <height measure="metric">176</height>
   </person>
   <person gender="female">
      <name>Jane Doe</name>
      <hair>Black</hair>
      <eyes>Grey</eyes>
      <height measure="imperial">5'7</height>
   </person>
</people>

Beispiel Script

1let xmlString =readFileAsString("C:/people.xml");
2xmlString = xmlString.replace(/<\?xml[^>]*\?>/, "");
3var xml = new XML(xmlString);

4println(xml.person[0].name);
5println(xml.person[0].@gender);

6xml.person[0].name = "Matthias";
7println(xml.person[0].name);

8xml.person[0]["nationality"] = "German";
9xml.person[0].@["title"] = "Mr";
10xml.person[1].@["title"] = "Mrs";

11writeToFile("C:/people.xml", xml, "c", "UTF-8");

Das folgende Beispiel zeigt, wie JSON-Dateien eingelesen, geändert und herausgeschrieben werden können.

Beispiel JSON-Datei (people.json)

[
  {
    "gender": "male",
    "name": "John Doe",
    "hair": "Brown",
    "eyes": "Blue",
    "height": {
      "measure": "metric",
      "value": "176"
    }
  },
  {
    "gender": "female",
    "name": "Jane Doe",
    "hair": "Black",
    "eyes": "Grey",
    "height": {
      "measure": "imperial",
      "value": "5'7"
    }
  }
]

Beispiel Script

1let jsonString =readFileAsString("C:/people.json");
2let json = JSON.parse(jsonString);

3println(json[0].name);
4println(json[0].gender);

5json[0].name = "Matthias";
6println(json[0].name);

7json[0]["nationality"] = "German";
8json[0]["title"] = "Mr";
9json[1]["title"] = "Mrs";
10let jsonStringifyed = JSON.stringify(json, null, 2);

11writeToFile("C:/people.json", jsonStringifyed, "c", "UTF-8");