Documentation

Rotor Balancing Tools Framework

rtrBalanceTools.framework© for iOS®/iPadOS®

Version: 1.02
Author: David Bukowitz

Created: 12 Apr, 2010
Update: 09 Jun, 2021

If you have any questions that are beyond the scope of this help file, Please feel free to email via info@rotovibes.com

Description

rtrBalanceTools© framework is an iOS®/iPadOS® library that contains experienced methods to calculate rotor balancing parameters such as the correction weight vector, trim weight vector, residual imbalance, etc.

Methods are designed for the balancing of rigid-rotors in single-plane and two-planes.

Installation

Follow the steps below to install the rtrBalanceTools.framework

Drag and drop the rtrBalanceTools.framework file into your Xcode project

Select the "Embed & Sign" option in the Framworks, Libraries and Embedded Content menu

Framework Anatomy

Single-Plane Balancing Correction Weight Calculations


// Method to calculate Correction weight magnitude and angle for Single Plane Rotor Balancing
// the magnitude response of the correction weight will be in the same units used for the trial weight (wpMag)
// the angle of the correction weight location will be in degrees
// orMag: Original Imbalance Magnitude (can be any magnitude unit)
// orAng: Original Imbalance Angle (degrees)
// wpMag: Trial weight magnitude (grs, Oz, ...)
// wpAng: Trial weight angle (degrrees)
// opMag: Imbalance with Trial Weight Magnitude (same unit as orMag)
// opAng: Imbalance with Trial Weight Angle (degrees)
// wpRad: Radius for the Trial Weight (inches, mm, cms, ....)
// wcRad: Radius for the Correction Weight (same units as wpRad)
//  wpOn: select TRUE if trial weight will be left on the rotor, select FALSE if trial weight will be removed from teh rotor
// resMag:select TRUE to calculate the Correction Weight Magnitude (resAng should be set to FALSE)
// resAng:select TRUE to calculate the Correction Weight Angle (resMag should be set to FALSE)

+ (double)orMag:(double)orMag
        orAng:(double)orAng
        wpMag:(double)wpMag
        wpAng:(double)wpAng
        opMag:(double)opMag
        opAng:(double)opAng
        wpRad:(double)wpRad
        wcRad:(double)wcRad
        wpOn:(bool)wpOn
        resMag:(bool)resMag
        resAng:(bool)resAng;

In your project import rtrBalanceTools/singlePlaneWcVector.h and use as follow:


#import "rtrBalanceTools/singlePlaneWcVector.h"
...

correctionWeightMagnitude = [singlePlaneWcVector orMag:omag orAng:oang wpMag:wpmag wpAng:wpang opMag:opmag opAng:opang wpRad:radioWp wcRad:radioWc wpOn:true resMag:true resAng:false];

correctionWeightAnglr = [singlePlaneWcVector orMag:omag orAng:oang wpMag:wpmag wpAng:wpang opMag:opmag opAng:opang wpRad:radioWp wcRad:radioWc wpOn:true resMag:false resAng:true];

Single-Plane Balancing Trim Weight Calculations


// Method to calculate trim adjustment weight magnitude and angle for Single Plane Rotor Balancing
// the magnitude response of the trim weight will be in the same units used for the correction weight (wcMag)
// the angle of the trim weight location will be in degrees
// orMag: Original Imbalance Magnitude (can be any magnitude unit)
// orAng: Original Imbalance Angle (degrees)
// wcMag: Correction weight magnitude (grs, Oz, ...)
// wcAng: Correction weight angle (degrrees)
// fvMag: Vibration after correction weight Magnitude (same unit as orMag)
// fvAng: Vibration after correction weight Angle (degrees)
// resMag:select TRUE to calculate the Trim Weight Magnitude (resAng should be set to FALSE)
// resAng:select TRUE to calculate the Trim Weight Angle (resMag should be set to FALSE)

+ (double)orMag:(double)orMag
            orAng:(double)orAng
            wcMag:(double)wcMag
            wcAng:(double)wcAng
            fvMag:(double)fvMag
            fvAng:(double)fvAng
            resMag:(bool)resMag
            resAng:(bool)resAng;

In your project import rtrBalanceTools/singlePlaneTrimVector.h and use as follow:


#import "rtrBalanceTools/singlePlaneTrimVector.h"
...

trimAdjustMagnitude = [singlePlaneTrimVector orMag:omag orAng:oang wcMag:wpmag wcAng:wpang fvMag:opmag fvAng:opang resMag:true resAng:false];

trimAdjustAngle = [singlePlaneTrimVector orMag:omag orAng:oang wcMag:wpmag wcAng:wpang fvMag:opmag fvAng:opang resMag:false resAng:true];

Two-Plane Balancing Correction Weight Calculations


// Method to calculate Correction weight magnitude and angle for Two Plane Rotor Balancing using Influence Coefficients
// the magnitude response of the correction weights will be in the same units used for the trial weights
// the angle of the correction weights location will be in degrees
// Nmod: Original Imbalance Magnitude in the Near Plane (can be any magnitude unit)
// Nang: Original Imbalance Angle in the Near Plane (degrees)
// Fmod: Original Imbalance Magnitude in the Far Plane (can be any magnitude unit)
// Fang: Original Imbalance Angle in the Far Plane (degrees)
// WPNmod: Trial Weight Magnitude used in the Near Plane (grs, Oz, ...)
// WPNang: Trial Weight Angle used in the Near Plane (degrees)
// NNmod: Vibration magnitude in the Near Plane when using trial weight WPN (same units as Nmod and Fmod)
// NNang: Vibration angle in the Near Plane when using trial weight WPN (degrees)
// FNmod: Vibration magnitude in the Far Plane when using trial weight WPN (same units as Nmod and Fmod)
// FNang: Vibration angle in the Far Plane when using trial weight WPN (degrees)
// WPFmod: Trial Weight Magnitude used in the Near Plane (grs, Oz, ...)
// WPFang: Trial Weight Angle used in the Near Plane (degrees)
// NFmod: Vibration magnitude in the Near Plane when using trial weight WPF (same units as Nmod and Fmod)
// NFang: Vibration angle in the Near Plane when using trial weight WPF (degrees)
// FFmod: Vibration magnitude in the Far Plane when using trial weight WPF (same units as Nmod and Fmod)
// FFang: Vibration angle in the Far Plane when using trial weight WPF (degrees)
// WPNrad: radius used for the trial weight in the Near Plane
// WCNrad: radius for the correction weight in the Near Plane
// WPFrad: radius used for the trial weight in the Far Plane
// WCFrad: radius for the correction weight in the Far Plane
// NresMag:select TRUE to calculate the Correction Weight Magnitude for the Near Plane (choose only one TRUE and the other 3 false)
// NresAng:select TRUE to calculate the Correction Weight Angle for the Near Plane (choose only one TRUE and the other 3 false)
// FresMag:select TRUE to calculate the Correction Weight Magnitude for the Far Plane (choose only one TRUE and the other 3 false)
// FresAng:select TRUE to calculate the Correction Weight Angle for the Far Plane (choose only one TRUE and the other 3 false)

    + (double)Nmod:(double)Nmod
              Nang:(double)Nang
              Fmod:(double)Fmod
              Fang:(double)Fang
            WPNmod:(double)WPNmod
            WPNang:(double)WPNang
             NNmod:(double)NNmod
             NNang:(double)NNang
             FNmod:(double)FNmod
             FNang:(double)FNang
            WPFmod:(double)WPFmod
            WPFang:(double)WPFang
             NFmod:(double)NFmod
             NFang:(double)NFang
             FFmod:(double)FFmod
             FFang:(double)FFang
            WPNrad:(double)WPNrad
            WCNrad:(double)WCNrad
            WPFrad:(double)WPFrad
            WCFrad:(double)WCFrad
           NresMag:(bool)NresMag
           NresAng:(bool)NresAng
           FresMag:(bool)FresMag
           FresAng:(bool)FresAng;

Permissible Residual Imbalance Calculations


// Method to calculate the Permissible Residual Imbalance from ISO-1940/1
// metricUnits: choose TRUE for Metric units and FALSE for Imperial units
// rotorWeight: weight of rotor (Metric: Kg, Imperial: Lbs)
// rotorSpeed: rotor RPM
// Nplanes: Number of Balancing Planes (1 or 2)
// BQG: Balancing Quality Grade, select from:
//      0: 0.4
//      1: 1.0
//      2: 2.5
//      3: 6.3
//      4: 16
//      5: 40
//      6: 100
//      7: 250
//      8: 630

    + (double)metricUnits:(bool)metricUnits
              rotorWeight:(double)rotorWeight
               rotorSpeed:(double)rotorSpeed
                  Nplanes:(int)Nplanes
                      BQG:(int)BQG;

In your project import rtrBalanceTools/permResidualImbalance.h and use as follow:


#import "rtrBalanceTools/permResidualImbalance.h"
...

double residualImbalance = [permResidualImbalance metricUnits:false rotorWeight:mValue rotorSpeed:wValue Nplanes:(int)npValue BQG:bqcValue];

Six Point Residual Imbalance Calculations


// Method to calculate Residual Imbalance Magnitude and Angle from 6 Points Measurements
// the algorithm uses the least square method to fit the circle in the specified points
// trialWeight: Trial Weight value (oz, grs, etc)
// twRadius: Trial Weight Radius (inch, mm, etc)
// p1M: Point 1 Magnitude (any units, but consistet with all other points)
// p1A: Point 1 Angle (degrees)
// p2M: Point 2 Mgnitude
// p2A: Point 2 Angle
// p3M: Point 3 Mgnitude
// p3A: Point 3 Angle
// p4M: Point 4 Mgnitude
// p4A: Point 4 Angle
// p5M: Point 5 Mgnitude
// p5A: Point 5 Angle
// p6M: Point 6 Mgnitude
// p6A: Point 6 Angle
// resResImbMag:select TRUE to calculate the Resifual Imbalance Magnitude in unots of the trialWeight/twRadius (choose only one TRUE and the other 4 false)
// resResImbAng:select TRUE to calculate the Resifual Imbalance Angle in degrees
// resCenterX:select TRUE to calculate the X coordinate of the circle center
// resCenterX:select TRUE to calculate the Y coordinate of the circle center
// resRadiusF:select TRUE to calculate the circle Radius

    + (double)trialWeight:(double)trialWeight
                 twRadius:(double)twRadius
                      p1M:(double)p1M
                      p1A:(double)p1A
                      p2M:(double)p2M
                      p2A:(double)p2A
                      p3M:(double)p3M
                      p3A:(double)p3A
                      p4M:(double)p4M
                      p4A:(double)p4A
                      p5M:(double)p5M
                      p5A:(double)p5A
                      p6M:(double)p6M
                      p6A:(double)p6A
             resResImbMag:(bool)resResImbMag
             resResImbAng:(bool)resResImbAng
               resCenterX:(bool)resCenterX
               resCenterY:(bool)resCenterY
               resRadiusF:(bool)resRadiusF;

In your project import rtrBalanceTools/sixPointResidualImbalance.h and use as follow:


#import "rtrBalanceTools/sixPointResidualImbalance.h"
...

double PermResImbalance = [sixPointResidualImbalance trialWeight:trialWeight twRadius:trialWeightRadius p1M:p1M p1A:p1A p2M:p2M p2A:p2A p3M:p3M p3A:p3A p4M:p4M p4A:p4A p5M:p5M p5A:p5A p6M:p6M p6A:p6A resResImbMag:true resResImbAng:false resCenterX:false resCenterY:false resRadiusF:false];

int PermResImbalanceAngle = [sixPointResidualImbalance trialWeight:trialWeight twRadius:trialWeightRadius p1M:p1M p1A:p1A p2M:p2M p2A:p2A p3M:p3M p3A:p3A p4M:p4M p4A:p4A p5M:p5M p5A:p5A p6M:p6M p6A:p6A resResImbMag:false resResImbAng:true resCenterX:false resCenterY:false resRadiusF:false];

radiusF = [sixPointResidualImbalance trialWeight:trialWeight twRadius:trialWeightRadius p1M:p1M p1A:p1A p2M:p2M p2A:p2A p3M:p3M p3A:p3A p4M:p4M p4A:p4A p5M:p5M p5A:p5A p6M:p6M p6A:p6A resResImbMag:false resResImbAng:false resCenterX:false resCenterY:false resRadiusF:true];

double centerX = [sixPointResidualImbalance trialWeight:trialWeight twRadius:trialWeightRadius p1M:p1M p1A:p1A p2M:p2M p2A:p2A p3M:p3M p3A:p3A p4M:p4M p4A:p4A p5M:p5M p5A:p5A p6M:p6M p6A:p6A resResImbMag:false resResImbAng:false resCenterX:true resCenterY:false resRadiusF:false];

double centerY = [sixPointResidualImbalance trialWeight:trialWeight twRadius:trialWeightRadius p1M:p1M p1A:p1A p2M:p2M p2A:p2A p3M:p3M p3A:p3A p4M:p4M p4A:p4A p5M:p5M p5A:p5A p6M:p6M p6A:p6A resResImbMag:false resResImbAng:false resCenterX:false resCenterY:true resRadiusF:false];

Changelog

See what's new added, changed, fixed, improved or updated in the latest versions.

Version 1.02 (09 Jun, 2021)

Updated Optimized for iOS®15

Version 1.01 (19 Sep, 2012)

Added Six point residual imbalance
Fixed Bug fixed in single-plane angle calculations
Updated Optimized for iOS®5

Version 1.0 (12 Apr, 2010)

Initial Release for iOS® based on a previous C++ version