/// <summary>
/// Calculates the value of the differential equation of motion used for the one degree of freedom case for a specific time, based on the force and angular frequency that are passed.
/// </summary>
/// <param name="input"></param>
/// <param name="time"></param>
/// <param name="previousResult"></param>
/// <returns></returns>
public async Task <double[]> CalculateForOneDegreeOfFreedom(OneDegreeOfFreedomInput input, double time, double[] previousResult)
{
double[] result = new double[Constant.NumberOfRigidBodyVariables_1DF];
double force = await this._force.CalculateForceByType(input.Force, input.AngularFrequency, time, input.ForceType).ConfigureAwait(false);
// Velocity of primary object.
result[0] = previousResult[1];
// Acceleration of primary object.
result[1] = (force - input.Damping * previousResult[1] - input.Stiffness * previousResult[0]) / input.Mass;
return(result);
}
/// <summary>
/// Calculates and write in a file the results for one degree of freedom analysis using Newmark integration method.
/// </summary>
/// <param name="input"></param>
/// <param name="time"></param>
/// <param name="previousResult"></param>
/// <returns></returns>
public override Task <double[]> CalculateOneDegreeOfFreedomResult(OneDegreeOfFreedomInput input, double time, double[] previousResult)
{
this.CalculateIngrationContants(input);
double equivalentStiffness = input.Stiffness + this.a0 * input.Mass + this.a1 * input.DampingRatio;
double equivalentForce =
input.Force * Math.Sin(input.AngularFrequency * time)
+ input.Mass * (this.a0 * previousResult[0] + this.a2 * previousResult[1] + this.a3 * previousResult[2])
+ input.Damping * (this.a1 * previousResult[0] + this.a4 * previousResult[1] + this.a5 * previousResult[2]);
var result = new double[Constant.NumberOfRigidBodyVariables_1DF];
// Displacement
result[0] = equivalentForce / equivalentStiffness;
// Acceleration
result[2] = this.a0 * (result[0] - previousResult[0]) - this.a2 * previousResult[1] - this.a3 * previousResult[2];
// Velocity
result[1] = previousResult[1] + this.a6 * previousResult[2] + this.a7 * result[2];
return(Task.FromResult(result));
}
/// <summary>
/// Calculates and write in a file the results for one degree of freedom analysis using Newmark integration method.
/// </summary>
/// <param name="input"></param>
/// <param name="time"></param>
/// <param name="previousResult"></param>
/// <returns></returns>
public override async Task <double[]> CalculateOneDegreeOfFreedomResult(OneDegreeOfFreedomInput input, double time, double[] previousResult)
{
double equivalentStiffness = (input.Mass / (input.Beta * Math.Pow(input.TimeStep, 2))) + (input.Gama * input.Damping) / (input.Beta * input.TimeStep) + input.Stiffness;
double equivalentDamping = (input.Mass / (input.Beta * input.TimeStep)) + (input.Gama * input.Damping / input.Beta);
double equivalentMass = (1 / (2 * input.Beta)) * input.Mass - input.TimeStep * (1 - input.Gama / (2 * input.Beta)) * input.Damping;
double deltaForce =
await this._force.CalculateForceByType(input.Force, input.AngularFrequency, time + input.TimeStep, input.ForceType).ConfigureAwait(false)
- await this._force.CalculateForceByType(input.Force, input.AngularFrequency, time, input.ForceType).ConfigureAwait(false);
double deltaDisplacement = (deltaForce + equivalentDamping * previousResult[1] + equivalentMass * previousResult[2]) / equivalentStiffness;
double[] result = new double[Constant.NumberOfRigidBodyVariables_1DF];
// Displacement
result[0] = previousResult[0] + deltaDisplacement;
// Velocity
result[1] = (1 - input.Gama / input.Beta) * previousResult[1] + input.TimeStep * (1 - input.Gama / (2 * input.Beta)) * previousResult[2] + (input.Gama / (input.Beta * input.TimeStep)) * deltaDisplacement;
// Acceleration
result[2] = (1 / (input.Beta * Math.Pow(input.TimeStep, 2))) * deltaDisplacement - (1 / (input.Beta * input.TimeStep)) * previousResult[1] + (1 - (1 / (2 * input.Beta))) * previousResult[2];
// The accelerations satisfy the equations of motion and can be calculated by another form:
// Acceleration = (Force * Sin(AngularFrequency * (time + TimeStep)) - Damping * Velocity - Stiffness * Displacement) / Mass
return(result);
}
/// <summary>
/// Calculates and write in a file the results for one degree of freedom analysis using Runge Kutta Forth Order numerical method.
/// </summary>
/// <param name="input"></param>
/// <param name="time"></param>
/// <param name="previousResult"></param>
/// <returns></returns>
public override async Task <double[]> CalculateOneDegreeOfFreedomResult(OneDegreeOfFreedomInput input, double time, double[] previousResult)
{
return(await this.CalculateResult(this._differentialEquationOfMotion.CalculateForOneDegreeOfFreedom, input, time, previousResult).ConfigureAwait(false));
}
/// <summary> /// Calculates and write in a file the results for one degree of freedom analysis. /// </summary> /// <param name="input"></param> /// <param name="time"></param> /// <param name="previousResult"></param> /// <returns></returns> public abstract Task <double[]> CalculateOneDegreeOfFreedomResult(OneDegreeOfFreedomInput input, double time, double[] previousResult);
