/// <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);