public void ModifyObjectData(int l_modify_damper, object modify_damper_list, bool redo_Identifier)
{
///<summary>
///In this section of the code, the tire is bring modified and it is placed under the method called Execute because it is an Undoable operation
///</summary>
#region Editing the Damper Object in the list of Damper Objects
Damper damper_list;
if (redo_Identifier == false)
{
damper_list = new Damper((DamperGUI)modify_damper_list);
}
else
{
damper_list = (Damper)modify_damper_list;
}
ICommand cmd = Assy_List_Damper[l_modify_damper];
Assy_List_Damper[l_modify_damper]._UndocommandsDamper.Push(cmd);
damper_list._UndocommandsDamper = Assy_List_Damper[l_modify_damper]._UndocommandsDamper;
damper_list._RedocommandsDamper = Assy_List_Damper[l_modify_damper]._RedocommandsDamper;
damper_list._DamperName = Assy_List_Damper[l_modify_damper]._DamperName;
Assy_List_Damper[l_modify_damper] = damper_list;
Assy_List_Damper[l_modify_damper].DamperDataTable = damper_list.DamperDataTable;
Assy_List_Damper[l_modify_damper].DamperID = l_modify_damper + 1;
Assy_List_Damper[l_modify_damper].DamperIsModified = true;
PopulateDataTable(l_modify_damper);
#endregion
if (redo_Identifier == false)
{
_RedocommandsDamper.Clear();
}
DamperGUI.DisplayDamperItem(Assy_List_Damper[l_modify_damper]);
Kinematics_Software_New.Damper_ModifyInVehicle(l_modify_damper, Assy_List_Damper[l_modify_damper]);
}
public static void DisplayDamperItem(Damper damper)
{
r1.gridControl2.DataSource = damper.DamperDataTable;
}
//Kinematics Solver for McPherson Suspension
public void KinematicsMcPherson(int Identifier, SuspensionCoordinatesMaster scm, WheelAlignment wa, Tire tire, AntiRollBar arb, double ARB_Rate_Nmm, Spring spring, Damper damper, List <OutputClass> oc, Vehicle _vehicleForMcPherson, List <double> WheelOrSpringDeflections, bool MotionExists, bool RecalculateSteering /*, bool FirstIteration*/)
{
dummy1 = dummy2 = 0;
#region Initialization methods
///<remarks>
///The IF loop is employed so that if the < c > Kinematics </ c > method is being run to calculate the Points for Steering then local coordinate variables should be initialized with the Output Class coordinates rather than the Input Suspension Coordinates as
///the method has already been executed and is been run for the second time for the purpose of calcualting steering
/// </remarks>
// Initialization of the Local Coordinate variables
if (!RecalculateSteering)
{
AssignLocalCoordinateVariables_FixesPoints(scm);
AssignLocalCoordinateVariables_MovingPoints(scm);
}
else if (RecalculateSteering)
{
AssignLocalCoordinateVariables_FixesPoints(oc[dummy1].scmOP);
AssignLocalCoordinateVariables_MovingPoints(oc[dummy1].scmOP);
L1x = oc[dummy1].scmOP.L1x; L1y = oc[dummy1].scmOP.L1y; L1z = oc[dummy1].scmOP.L1z;
}
if (MotionExists)
{
N = _vehicleForMcPherson.vehicle_Motion.Final_WheelDeflectionsY.Count;
// Initializating the Local Wheel Alignment variables
InitializeWheelAlignmentVariables(wa, oc[dummy1], Identifier, _vehicleForMcPherson.vehicle_Motion.SteeringExists);
// Initialize array which holds the previous value of spring deflection
SpringDeflection_Prev = new double[_vehicleForMcPherson.vehicle_Motion.Final_WheelDeflectionsX.Count];
}
else if (!MotionExists)
{
N = 200;
// Initializating the Local Wheel Alignment variables
InitializeWheelAlignmentVariables(wa, oc[dummy1], Identifier, false);
}
// The value of Ride will be calculated at the end as the relative value of Ride Height. This will be used to translate all the coordinates to reflect the car falling on the ground.
if (!RecalculateSteering)
{
///<remarks> Resetting the wheel defelction due to steering to prevent residue error</remarks>
for (int i = 0; i < 100; i++)
{
scm.WheelDeflection_Steering[i] = 0;
}
// Converting Coordinates from World Coordinate System to Car Coordinate System
TranslateToLocalCS(_vehicleForMcPherson.sc_FL);
// Initializing the Spindle End
InitializeSpindleEndCoordinates(tire);
// To Calculate position of far end of the spindle vector using Static Camber and Toe
RotateSpindleVector(oc[dummy1].waOP.StaticCamber, oc[dummy1].waOP.StaticToe, false, 0, 0, 0, 0, 0, 0, Lx, Ly, Lz, out L1x, out L1y, out L1z);
// Initial Motion Ratio for McPherson Strut
scm.MotionRatio(_vehicleForMcPherson.McPhersonFront, _vehicleForMcPherson.McPhersonRear, _vehicleForMcPherson.PullRodIdentifierFront, _vehicleForMcPherson.PullRodIdentifierRear, Identifier);
// Passing the Motion Ratio to the Output Class
oc[dummy1].InitialMR = scm.InitialMR;
oc[dummy1].Initial_ARB_MR = scm.Initial_ARB_MR;
// Preliminary Calculations to find the New Camber and Toe
CalculateInitialSpindleVector();
}
#endregion
#region Wheel Deflection Calculations for Stand to Ground Calculations
if (!MotionExists)
{
//
//Only for Stand to Ground
//
CalculateWheelAndSpringDeflection(scm, spring, damper, _vehicleForMcPherson, null, oc[0], tire, Identifier, ARB_Rate_Nmm, MotionExists, RecalculateSteering, 0);
}
#endregion
#region For Loop to Calculate the SUSPENSION POINTS
for (a1 = 1; a1 < N; a1++)
{
oc[dummy1].scmOP.NoOfCouplings = _vehicleForMcPherson.sc_FL.NoOfCouplings;
#region Wheel Deflection Calculations for Motion Calculation
if (MotionExists && ((!RecalculateSteering) /*|| ((RecalculateRearSteering) && (Identifier == 3 || Identifier == 4) && dummy1 != 0)*/))
{
//
// For Motion Simulation
//
CalculateWheelAndSpringDeflection(scm, spring, damper, _vehicleForMcPherson, WheelOrSpringDeflections, oc[dummy1], tire, Identifier, ARB_Rate_Nmm, MotionExists, RecalculateSteering, dummy1);
}
else if (MotionExists && (RecalculateSteering /*&& (Identifier == 1 || Identifier == 2)*/))
{
CalculateSpringDeflection_AfterVehicleModel(oc, Identifier, WheelOrSpringDeflections[dummy1], oc[dummy1].FinalMR, dummy1);
}
#endregion
#region Confirm if needed and delete if not
///////<remarks>
///////The IF loop is employed so that if the < c > Kinematics </ c > method is being run to calculate the Points for Steering then local coordinate variables should be initialized with the Output Class coordinates rather than the Input Suspension Coordinates as
///////the method has already been executed and is been run for the second time for the purpose of calcualting steering
///////This loop is executed only once as the
/////// </remarks>
//if (RecalculateSteering && dummy1 != 0)
//{
// AssignLocalCoordinateVariables_FixesPoints(oc[dummy1].scmOP);
// AssignLocalCoordinateVariables_MovingPoints(oc[dummy1].scmOP);
// L1x = oc[dummy1].scmOP.L1x; L1y = oc[dummy1].scmOP.L1y; L1z = oc[dummy1].scmOP.L1z;
//}
#endregion
#region Progress Bar Operations
_vehicleForMcPherson.vehicleGUI.ProgressBarVehicleGUI.PerformStep();
_vehicleForMcPherson.vehicleGUI.ProgressBarVehicleGUI.Update();
#endregion
#region Calculating the deflection of the spring in Steps
CalculateAngleOfRotationOrDamperLength(oc[dummy1], MotionExists, dummy1, damper, RecalculateSteering);
#endregion
#region Calculating the Caster and KPI
CalculateKPIandCaster(oc[dummy1], false, Identifier);
#endregion
if (!RecalculateSteering || ((RecalculateSteering) && (Identifier == 3 || Identifier == 4)))
{
#region Calculate the remaining Outboard Points
CalculateOutboardPoints(oc[dummy1], scm);
#endregion
#region Point L - Wheel Spindle End
// TO CALCULATE THE NEW POSITION OF L i.e., TO CALCULATE L'
// Vectors used -> L'M', L'J' & L'E' // THE INITIAL COORDINATES OF L SHOULD NOT BE TAKEN FROM USER. THEY SHOULD BE CALCULATED USING 'K' , THE INPUT CAMBER AND TOE
double XL1 = 0, YL1 = 0, ZL1 = 0;
QuadraticEquationSolver.Solver(L1x, L1y, L1z, l_M1x, l_M1y, l_M1z, 0, l_J1x, l_J1y, l_J1z, l_E1x, l_E1y, l_E1z, oc[dummy1].scmOP.M1x, oc[dummy1].scmOP.M1y, oc[dummy1].scmOP.M1z, oc[dummy1].scmOP.J1x, oc[dummy1].scmOP.J1y, oc[dummy1].scmOP.J1z, oc[dummy1].scmOP.E1x, oc[dummy1].scmOP.E1y, oc[dummy1].scmOP.E1z, oc[dummy1].scmOP.J1y * 2, true, out XL1, out YL1, out ZL1);
oc[dummy1].scmOP.L1x = XL1;
oc[dummy1].scmOP.L1y = YL1;
oc[dummy1].scmOP.L1z = ZL1;
#endregion
#region Point W - Contact Patch
// TO CALCULATE THE NEW POSITION OF W i.e., TO CALCULATE W'
// Vectors used -> W'L', W'J' & W'E'
double XW1 = 0, YW1 = 0, ZW1 = 0;
QuadraticEquationSolver.Solver(l_W1x, l_W1y, l_W1z, L1x, L1y, L1z, 0, l_J1x, l_J1y, l_J1z, l_E1x, l_E1y, l_E1z, oc[dummy1].scmOP.L1x, oc[dummy1].scmOP.L1y, oc[dummy1].scmOP.L1z, oc[dummy1].scmOP.J1x, oc[dummy1].scmOP.J1y, oc[dummy1].scmOP.J1z, oc[dummy1].scmOP.E1x, oc[dummy1].scmOP.E1y, oc[dummy1].scmOP.E1z, oc[dummy1].scmOP.E1y, true, out XW1, out YW1, out ZW1);
oc[dummy1].scmOP.W1x = XW1;
oc[dummy1].scmOP.W1y = YW1;
oc[dummy1].scmOP.W1z = ZW1;
#endregion
}
BreakPointA:
//Calculating the Tire Loaded Radius
oc[dummy1].TireLoadedRadius = (l_K1y - l_W1y) + (_vehicleForMcPherson.CW[Identifier - 1] / tire.TireRate);
//Calculating The Final Ride Height
oc[dummy1].FinalRideHeight = Math.Abs((oc[dummy1].scmOP.W1y) - l_RideHeightRefy + (_vehicleForMcPherson.CW[Identifier - 1] / tire.TireRate));
if (_vehicleForMcPherson.Vehicle_Results_Tracker == 0)
{
oc[dummy1].FinalRideHeight_1 = oc[dummy1].FinalRideHeight;
}
oc[dummy1].FinalRideHeight_ForTrans = (oc[dummy1].scmOP.W1y) - l_RideHeightRefy + (_vehicleForMcPherson.CW[Identifier - 1] / tire.TireRate); // This value of Ride will represent represent the relative and not absolute value of Ride Height.
// This is necessary to translate all the coordinate to the ground by an amount equal to the negative of Ride Height
//if (!RecalculateSteering)
//{
//Re-assigning the the new coordinates to initial coordinates so that the loop carries on
AssignLocalCoordinateVariables_MovingPoints(oc[dummy1].scmOP);
L1x = oc[dummy1].scmOP.L1x; L1y = oc[dummy1].scmOP.L1y; L1z = oc[dummy1].scmOP.L1z;
//}
if ((MotionExists) && dummy1 != 0 && (Identifier != 3 && Identifier != 4) && (_vehicleForMcPherson.vehicle_Motion.SteeringExists))
{
///<summary>
///This IF loop takes care of 2 things and is used ONLY for the Front in the event of SteeringExists is true
///Calculating the new Spindel End, Steering Upright and Contact Patch Coordinates which is done inside the IF part of the loop
///Calculating the Outboard and Inboard Points Seperately for the Front.
/// </summary>
if (!RecalculateSteering)
{
//
//Calculating the new coordinates of the Toe Rod Inboard and Outboard End
//
ToeRod_Steering(oc[dummy1], dummy1, _vehicleForMcPherson, wa);
//
// Calculating the Delta Camber due to steering
//
CalculateDCamberDToe_Steering(oc[dummy1], _vehicleForMcPherson, dummy1);
//
// Calculating the New Camber due to Steering
//
CalculateNewCamberAndToe_Steering(oc, dummy1, _vehicleForMcPherson);
//
// Calculating the new Wheel Spindle End due to Steering
//
RotateSpindleVector(dCamber_Steering, dToe_Steering, true, l_J1x, l_J1y, l_J1z, l_E1x, l_E1y, l_E1z, L1x, L1y, L1z, out oc[dummy1].scmOP.L1x, out oc[dummy1].scmOP.L1y, out oc[dummy1].scmOP.L1z);
//
//Recalculting the Contact Patch due to steering
//
ContactPatch_Steering(oc[dummy1]);
double DeltaWheelDef_Steering;
DeltaWheelDef_Steering = oc[dummy1].scmOP.W1y - l_W1y;
scm.WheelDeflection_Steering[dummy1] = -DeltaWheelDef_Steering;
}
else
{
/////<remarks>
/////Call for the finding the new coordinates of the Outboard points will be made here
///// </remarks>
//WheelCentre_Steering(oc, _vehicleKinematicsDWSolver, dummy1);
//UBJandLBJ_Steering(oc, dummy1);
//Pushrod_Steering(oc, dummy1);
}
//CalculateSpringDeflection_ForSteering_Front(oc,Identifier, DeltaWheelDef_Steering, oc[dummy1].FinalMR, dummy1);
//CalculateAngleOfRotationOrDamperLength(oc[dummy1], MotionExists, dummy1, damper);
//InitializeRotationMatrices(Identifier, oc[dummy1]);
//BellCrankPoints(oc[dummy1]);
l_M1x = oc[dummy1].scmOP.M1x; l_M1y = oc[dummy1].scmOP.M1y; l_M1z = oc[dummy1].scmOP.M1z;
AssignLocalCoordinateVariables_MovingPoints(oc[dummy1].scmOP);
L1x = oc[dummy1].scmOP.L1x; L1y = oc[dummy1].scmOP.L1y; L1z = oc[dummy1].scmOP.L1z;
}
_vehicleForMcPherson.SuspensionIsSolved = true;
if (MotionExists)
{
dummy1++;
}
}
#endregion
#region Initializing loop variables for other Outputs
if (MotionExists)
{
N = _vehicleForMcPherson.vehicle_Motion.Final_WheelDeflectionsY.Count;
dummy2 = 0;
}
else if (!MotionExists)
{
N = 200;
dummy2 = 0;
}
#endregion
#region For Loop for other Outputs
for (a1 = 1; a1 < N; a1++)
{
// This variable keeps track of the total value or magnitude of the Spring Deflection.
oc[dummy2].Corrected_SpringDeflection_1 += oc[dummy2].Corrected_SpringDeflection; // This
// This variable keeps track of the total value or magnitude of the Spring Deflection.
oc[dummy2].Corrected_WheelDeflection_1 = oc[dummy2].Corrected_WheelDeflection - oc[dummy2].Corrected_WheelDeflection_1;
if (dummy2 != 0 && ((MotionExists) && ((Identifier == 3 || Identifier == 4) || ((Identifier == 1 || Identifier == 2) && (!_vehicleForMcPherson.vehicle_Motion.SteeringExists)))))
{
CalculatenewCamberAndToe_Rear(oc, dummy2, _vehicleForMcPherson, Identifier);
}
else if (!MotionExists)
{
CalculatenewCamberAndToe_Rear(oc, dummy2, _vehicleForMcPherson, Identifier);
}
#region Coordinate Translations
///<remarks>
///Need this if loop here because otherwise, this will Vehicle will be translated by the InputOrigin as many times as there are for loops
/// </remarks>
if (MotionExists)
{
TranslateToRequiredCS(scm, oc[dummy2], _vehicleForMcPherson, MotionExists, 0, 0, 0, 0, 0, 0);
}
else if (!MotionExists)
{
TranslateToRequiredCS(scm, oc[dummy2], _vehicleForMcPherson, MotionExists, _vehicleForMcPherson.sc_FL.InputOriginX, _vehicleForMcPherson.sc_FL.InputOriginY, _vehicleForMcPherson.sc_FL.InputOriginZ,
_vehicleForMcPherson.OutputOrigin_x, _vehicleForMcPherson.OutputOrigin_y, _vehicleForMcPherson.OutputOrigin_z);
}
#endregion
//New Non Suspended Mass CG Calculation
oc[dummy2].New_NonSuspendedMassCoGx = (oc[dummy2].scmOP.K1x + oc[dummy2].scmOP.L1x) / 2;
oc[dummy2].New_NonSuspendedMassCoGy = (oc[dummy2].scmOP.K1y + oc[dummy2].scmOP.L1y) / 2;
oc[dummy2].New_NonSuspendedMassCoGz = (oc[dummy2].scmOP.K1z + oc[dummy2].scmOP.L1z) / 2;
//// Passing the Corner Weight to the Outputclass
//oc[dummy2].CW = _vehicleForMcPherson.CW[Identifier - 1];
//oc[dummy2].CW_1 = _vehicleForMcPherson.CW[Identifier - 1];
#region Passing the Motion Ratio to the Output Class
oc[dummy2].InitialMR = scm.InitialMR;
oc[dummy2].Initial_ARB_MR = scm.Initial_ARB_MR;
#endregion
//Calculating the Suspension Wishbone Forces
//Unit Vectors
double UV_D2E2x, UV_D2E2y, UV_D2E2z, UV_C2E2x, UV_C2E2y, UV_C2E2z, UV_M2N2x, UV_M2N2y, UV_M2N2z, UV_J2Jox, UV_J2Joy, UV_J2Joz;
//Calculating the Unit vectors
UV_D2E2x = (oc[dummy2].scmOP.D1x - oc[dummy2].scmOP.E1x) / scm.LowerFrontLength;
UV_D2E2y = (oc[dummy2].scmOP.D1y - oc[dummy2].scmOP.E1y) / scm.LowerFrontLength;
UV_D2E2z = (oc[dummy2].scmOP.D1z - oc[dummy2].scmOP.E1z) / scm.LowerFrontLength;
UV_C2E2x = (oc[dummy2].scmOP.C1x - oc[dummy2].scmOP.E1x) / scm.LowerRearLength;
UV_C2E2y = (oc[dummy2].scmOP.C1y - oc[dummy2].scmOP.E1y) / scm.LowerRearLength;
UV_C2E2z = (oc[dummy2].scmOP.C1z - oc[dummy2].scmOP.E1z) / scm.LowerRearLength;
UV_M2N2x = (oc[dummy2].scmOP.N1x - oc[dummy2].scmOP.M1x) / scm.ToeLinkLength;
UV_M2N2y = (oc[dummy2].scmOP.N1y - oc[dummy2].scmOP.M1y) / scm.ToeLinkLength;
UV_M2N2z = (oc[dummy2].scmOP.N1z - oc[dummy2].scmOP.M1z) / scm.ToeLinkLength;
UV_J2Jox = (oc[dummy2].scmOP.JO1x - oc[dummy2].scmOP.J1x) / scm.PushRodLength;
UV_J2Joy = (oc[dummy2].scmOP.JO1y - oc[dummy2].scmOP.J1y) / scm.PushRodLength;
UV_J2Joz = (oc[dummy2].scmOP.JO1z - oc[dummy2].scmOP.J1z) / scm.PushRodLength;
// Matrix A - Unit Vectors and Cross Products
double[,] matrixa;
matrixa = new double[3, 3];
matrixa[0, 0] = UV_D2E2x;
matrixa[1, 0] = UV_D2E2y;
matrixa[2, 0] = UV_D2E2z;
matrixa[0, 1] = UV_C2E2x;
matrixa[1, 1] = UV_C2E2y;
matrixa[2, 1] = UV_C2E2z;
matrixa[0, 2] = UV_M2N2x;
matrixa[1, 2] = UV_M2N2y;
matrixa[2, 2] = UV_M2N2z;
//Unit Matrix
double[,] unitmatrixa;
unitmatrixa = new double[3, 3];
for (i = 0; i < 3; ++i)
{
for (j = 0; j < 6; ++j)
{
if (j == i)
{
unitmatrixa[i, j] = 1;
}
}
}
//Pseudo Matrix
double psuedo, psuedo2;
//Inverse of Matrix A
for (j = 0; j < 3; j++)
{
psuedo = matrixa[j, j];
for (i = 0; i < 3; i++)
{
matrixa[j, i] = matrixa[j, i] / psuedo;
unitmatrixa[j, i] = unitmatrixa[j, i] / psuedo;
}
for (k = 0; k < 3; k++)
{
if (k == j)
{
}
else
{
psuedo2 = matrixa[k, j];
for (i = 0; i < 3; i++)
{
matrixa[k, i] = matrixa[k, i] - (matrixa[j, i] * psuedo2);
unitmatrixa[k, i] = unitmatrixa[k, i] - (unitmatrixa[j, i] * psuedo2);
}
}
}
}
//Forces and Moments generated by the Front Left Tire (Considering Braking + Left Turn)
double LatF, LongF, MOMx, MOMy, MOMz;
LatF = LatForce;
LongF = LongForce;
MOMx = ((LongF * oc[dummy2].scmOP.W1y / 1000) - (oc[dummy2].scmOP.W1z * (oc[dummy2].CW + VerticalForce) / 1000));
///<remarks>
/// Y axis for my software is the vertixal Axis so I have added Mz to the Moment about the Y Axis as Mz is the Moment about the vertical axis as defined by the User
/// </remarks>
MOMy = ((LatF * oc[dummy2].scmOP.W1z / 1000) - (LongF * oc[dummy2].scmOP.W1x / 1000)) + Mz;
///<remarks>
///Z axis for my software is the Longitudinal Axis so I have added Mx to the Moment about the Z Axis as Mx is the Moment about the Longitudinal axis as defined by the User
///</remarks>
MOMz = (((oc[dummy2].CW + VerticalForce) * oc[dummy2].scmOP.W1x / 1000) - (LatF * oc[dummy2].scmOP.W1y / 1000)) + Mx;
//Matrx B
double[,] matrixb;
matrixb = new double[3, 1];
matrixb[0, 0] = LatF;
///<remarks>The <c>oc[dummy2].deltaNet_CornerWeight</c> is already included in the <c>oc[dummy2].CW</c> <seealso cref="VehicleModel.ComputeVehicleModel_SummationOfResults(Vehicle)"/> </remarks>
matrixb[1, 0] = oc[dummy2].CW + (VerticalForce /*- oc[dummy2].deltaNet_CornerWeight*/);
matrixb[2, 0] = LongF;
//Matrix X
double X;
double[,] matrixX;
matrixX = new double[3, 1];
for (j = 0; j <= 2; j++)
{
X = 0;
for (i = 0; i <= 2; i++)
{
X += (unitmatrixa[j, i] * matrixb[i, 0]);
}
matrixX[j, 0] = X;
}
oc[dummy2].LowerFront = (matrixX[0, 0]); // Lower Front
oc[dummy2].LowerRear = (matrixX[1, 0]); // Lower Rear
oc[dummy2].ToeLink = (matrixX[2, 0]); // Toe Link
oc[dummy2].PushRod = (oc[dummy2].Corrected_SpringDeflection * spring.SpringRate);
//Forces in Each Pick Up Points
oc[dummy2].LowerFront_x = oc[dummy2].LowerFront * UV_D2E2x;
oc[dummy2].LowerFront_y = oc[dummy2].LowerFront * UV_D2E2y;
oc[dummy2].LowerFront_z = oc[dummy2].LowerFront * UV_D2E2z;
oc[dummy2].LowerRear_x = oc[dummy2].LowerRear * UV_C2E2x;
oc[dummy2].LowerRear_y = oc[dummy2].LowerRear * UV_C2E2y;
oc[dummy2].LowerRear_z = oc[dummy2].LowerRear * UV_C2E2z;
oc[dummy2].ToeLink_x = oc[dummy2].ToeLink * UV_M2N2x;
oc[dummy2].ToeLink_y = oc[dummy2].ToeLink * UV_M2N2y;
oc[dummy2].ToeLink_z = oc[dummy2].ToeLink * UV_M2N2z;
oc[dummy2].PushRod_x = oc[dummy2].PushRod * UV_J2Jox;
oc[dummy2].PushRod_y = oc[dummy2].PushRod * UV_J2Joy;
oc[dummy2].PushRod_z = oc[dummy2].PushRod * UV_J2Joz;
if (MotionExists)
{
dummy2++;
}
}
#endregion
}