/// <summary>
/// This method compares the values and update the result with maximum values.
/// </summary>
/// <param name="result"></param>
/// <param name="maxValuesResult"></param>
/// <returns></returns>
private Task CompareValuesAndUpdateMaxValuesResult(FiniteElementResult result, FiniteElementResult maxValuesResult)
{
int length = result.Displacement.Length;
for (uint i = 0; i < length; i++)
{
if (Math.Abs(maxValuesResult.Displacement[i]) < Math.Abs(result.Displacement[i]))
{
maxValuesResult.Displacement[i] = Math.Abs(result.Displacement[i]);
}
if (Math.Abs(maxValuesResult.Velocity[i]) < Math.Abs(result.Velocity[i]))
{
maxValuesResult.Velocity[i] = Math.Abs(result.Velocity[i]);
}
if (Math.Abs(maxValuesResult.Acceleration[i]) < Math.Abs(result.Acceleration[i]))
{
maxValuesResult.Acceleration[i] = Math.Abs(result.Acceleration[i]);
}
if (Math.Abs(maxValuesResult.Force[i]) < Math.Abs(result.Force[i]))
{
maxValuesResult.Force[i] = Math.Abs(result.Force[i]);
}
}
return(Task.CompletedTask);
}
/// <summary>
/// This method builds the vector with variables: displacement, velocity and acceleration, from a finite element result.
/// This method is used in two degrees os freedom matricial analysis.
/// </summary>
/// <param name="finiteElementResult"></param>
/// <returns></returns>
public Task <double[]> BuildVariableVector(FiniteElementResult finiteElementResult)
{
double[] previousResult = finiteElementResult.Displacement
.CombineVectors(finiteElementResult.Velocity)
.CombineVectors(finiteElementResult.Acceleration);
return(Task.FromResult(previousResult));
}
/// <summary>
/// This method builds the finite element result from a vector with variables: displacement, velocity and acceleration, and the force value.
/// This method is used in two degrees os freedom matricial analysis.
/// </summary>
/// <param name="result"></param>
/// <param name="force"></param>
/// <returns></returns>
public Task <FiniteElementResult> BuildFiniteElementResult(double[] result, double force)
{
var finiteElementResult = new FiniteElementResult
{
Displacement = new double[] { result[0], result[1] },
Velocity = new double[] { result[2], result[3] },
Acceleration = new double[] { result[4], result[5] },
Force = new double[] { force, 0 }
};
return(Task.FromResult(finiteElementResult));
}
/// <summary>
/// Calculates and write in a file the results for two degrees of freedom analysis.
/// </summary>
/// <param name="input"></param>
/// <param name="time"></param>
/// <param name="previousResult"></param>
/// <returns></returns>
public virtual async Task <double[]> CalculateTwoDegreesOfFreedomResult(TwoDegreesOfFreedomInput input, double time, double[] previousResult)
{
FiniteElementMethodInput finiteElementMethodInput = await this._mappingResolver.BuildFiniteElementMethodInput(input).ConfigureAwait(false);
FiniteElementResult previousFiniteElementResult = await this._mappingResolver.BuildFiniteElementResult(previousResult, input.Force).ConfigureAwait(false);
FiniteElementResult finiteElementResult = await this.CalculateFiniteElementResult(finiteElementMethodInput, previousFiniteElementResult, time).ConfigureAwait(false);
double[] result = await this._mappingResolver.BuildVariableVector(finiteElementResult).ConfigureAwait(false);
return(result);
}
/// <summary>
/// Calculates and write in a file the results for a finite element analysis using Newmark integration method.
/// </summary>
/// <param name="input"></param>
/// <param name="previousResult"></param>
/// <param name="time"></param>
/// <returns></returns>
public override async Task <FiniteElementResult> CalculateFiniteElementResult(FiniteElementMethodInput input, FiniteElementResult previousResult, double time)
{
FiniteElementResult result = new FiniteElementResult
{
Displacement = new double[input.NumberOfTrueBoundaryConditions],
Velocity = new double[input.NumberOfTrueBoundaryConditions],
Acceleration = new double[input.NumberOfTrueBoundaryConditions],
Force = previousResult.Force
};
this.CalculateIngrationContants(input);
double[,] equivalentStiffness = await this.CalculateEquivalentStiffness(input.Mass, input.Stiffness, input.Damping, input.NumberOfTrueBoundaryConditions).ConfigureAwait(false);
double[,] inversedEquivalentStiffness = await equivalentStiffness.InverseMatrixAsync().ConfigureAwait(false);
double[] equivalentForce = await this.CalculateEquivalentForce(input, previousResult.Displacement, previousResult.Velocity, previousResult.Acceleration, time).ConfigureAwait(false);
result.Displacement = await inversedEquivalentStiffness.MultiplyAsync(equivalentForce).ConfigureAwait(false);
string path = @"C:\Users\bruno\OneDrive\Área de Trabalho\Testes - IC Vibrações\Matrizes resultantes\master.csv";
using (StreamWriter streamWriter = new StreamWriter(path))
{
this.WriteMatrix(streamWriter, equivalentStiffness, "Keq");
this.WriteMatrix(streamWriter, inversedEquivalentStiffness, "IKeq");
this.WriteVector(streamWriter, equivalentForce, "Feq");
this.WriteVector(streamWriter, result.Displacement, "Y");
}
for (int i = 0; i < input.NumberOfTrueBoundaryConditions; i++)
{
result.Acceleration[i] = a0 * (result.Displacement[i] - previousResult.Displacement[i]) - a2 * previousResult.Velocity[i] - a3 * previousResult.Acceleration[i];
result.Velocity[i] = previousResult.Velocity[i] + a6 * previousResult.Acceleration[i] + a7 * result.Acceleration[i];
}
return(result);
}
/// <summary>
/// This method calculates the vibration using finite element concepts and writes the results in a file.
/// Each line in the file contains the result in an instant of time at an angular frequency.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
protected override async Task <FiniteElementResponse> ProcessOperation(TRequest request)
{
var response = new FiniteElementResponse {
Data = new FiniteElementResponseData()
};
response.SetSuccessCreated();
// Step 1 - Sets the numerical method to be used in analysis.
base._numericalMethod = NumericalMethodFactory.CreateMethod(request.NumericalMethod);
// Step 2 - Creates the input to numerical method.
FiniteElementMethodInput input = await this.CreateInput(request).ConfigureAwait(false);
// Step 3 - Generates the path to save the maximum values of analysis results and save the file URI.
string maxValuesPath = await this.CreateMaxValuesPath(request, input).ConfigureAwait(false);
ICollection <string> fileUris = new Collection <string>();
fileUris.Add(Path.GetDirectoryName(maxValuesPath));
while (input.AngularFrequency <= input.FinalAngularFrequency)
{
// Step 4 - Sets the value for time step and final time based on angular frequency and element mechanical properties.
input.TimeStep = await this._time.CalculateTimeStep(input.AngularFrequency, request.PeriodDivision).ConfigureAwait(false);
input.FinalTime = await this._time.CalculateFinalTime(input.AngularFrequency, request.PeriodCount).ConfigureAwait(false);
// Step 5 - Generates the path to save the analysis results.
// Each combination of damping ratio and angular frequency will have a specific path.
string solutionPath = await this.CreateSolutionPath(request, input).ConfigureAwait(false);
string solutionFolder = Path.GetDirectoryName(solutionPath);
if (fileUris.Contains(solutionFolder) == false)
{
fileUris.Add(Path.GetDirectoryName(solutionPath));
}
var previousResult = new FiniteElementResult
{
Displacement = new double[input.NumberOfTrueBoundaryConditions],
Velocity = new double[input.NumberOfTrueBoundaryConditions],
Acceleration = new double[input.NumberOfTrueBoundaryConditions],
Force = input.OriginalForce
};
var maxValuesResult = new FiniteElementResult
{
Displacement = new double[input.NumberOfTrueBoundaryConditions],
Velocity = new double[input.NumberOfTrueBoundaryConditions],
Acceleration = new double[input.NumberOfTrueBoundaryConditions],
Force = new double[input.NumberOfTrueBoundaryConditions]
};
try
{
using (StreamWriter streamWriter = new StreamWriter(solutionPath))
{
// Step 6 - Calculates the initial results and writes it into a file.
FiniteElementResult result = await this._numericalMethod.CalculateFiniteElementResultForInitialTime(input).ConfigureAwait(false);
streamWriter.WriteResult(input.InitialTime, result.Displacement);
// Step 7 - Sets the next time.
double time = input.InitialTime + input.TimeStep;
while (time <= input.FinalTime)
{
// Step 8 - Calculates the results and writes it into a file.
result = await this._numericalMethod.CalculateFiniteElementResult(input, previousResult, time).ConfigureAwait(false);
streamWriter.WriteResult(time, result.Displacement);
previousResult = result;
// Step 9 - Compares the previous results with the new calculated to catch the maximum values.
await this.CompareValuesAndUpdateMaxValuesResult(result, maxValuesResult).ConfigureAwait(false);
time += input.TimeStep;
}
}
}
catch (Exception ex)
{
response.AddError(OperationErrorCode.InternalServerError, $"Occurred error while calculating the analysis results and writing them in the file. {ex.Message}", HttpStatusCode.InternalServerError);
response.SetInternalServerError();
return(response);
}
try
{
// Step 10 - Writes the maximum values of analysis result into a file.
using (StreamWriter streamWriter = new StreamWriter(maxValuesPath, true))
{
streamWriter.WriteResult(input.AngularFrequency, maxValuesResult.Displacement);
}
}
catch (Exception ex)
{
response.AddError(OperationErrorCode.InternalServerError, $"Occurred error while writing the maximum values in the file. {ex.Message}", HttpStatusCode.InternalServerError);
response.SetInternalServerError();
return(response);
}
input.AngularFrequency += input.AngularFrequencyStep;
}
// Step 11 - Calculates the structure natural frequencies and writes them into a file.
//double[] naturalFrequencies = await this._naturalFrequency.CalculateByQRDecomposition(input.Mass, input.Stiffness, tolerance: 1e-3).ConfigureAwait(false);
//this._file.Write("Natural Frequencies", naturalFrequencies, maxValuesPath);
// Step 12 - Maps the response.
response.Data.Author = request.Author;
response.Data.AnalysisExplanation = "Not implemented.";
response.Data.FileUris = fileUris;
return(response);
}
/// <summary>
/// Calculates and write in a file the results for a finite element analysis using Runge Kutta Forth Order numerical method.
/// </summary>
/// <param name="input"></param>
/// <param name="previousResult"></param>
/// <param name="time"></param>
/// <returns></returns>
public override Task <FiniteElementResult> CalculateFiniteElementResult(FiniteElementMethodInput input, FiniteElementResult previousResult, double time)
{
throw new NotImplementedException();
}
/// <summary>
/// Calculates and write in a file the results for a one degree of freedom analysis using Newmark-Beta integration method.
/// </summary>
/// <param name="input"></param>
/// <param name="previousResult"></param>
/// <param name="time"></param>
/// <returns></returns>
public override async Task <FiniteElementResult> CalculateFiniteElementResult(FiniteElementMethodInput input, FiniteElementResult previousResult, double time)
{
double[,] equivalentStiffness = await this.CalculateEquivalentStiffness(input).ConfigureAwait(false);
double[,] inversedEquivalentStiffness = await equivalentStiffness.InverseMatrixAsync().ConfigureAwait(false);
double[] equivalentForce = await this.CalculateEquivalentForce(input, previousResult, time).ConfigureAwait(false);
double[] deltaDisplacement = await inversedEquivalentStiffness.MultiplyAsync(equivalentForce).ConfigureAwait(false);
double[] deltaVelocity = new double[input.NumberOfTrueBoundaryConditions];
double[] deltaAcceleration = new double[input.NumberOfTrueBoundaryConditions];
for (int i = 0; i < input.NumberOfTrueBoundaryConditions; i++)
{
deltaVelocity[i] = input.Gama / (input.Beta * input.TimeStep) * deltaDisplacement[i] - input.Gama / input.Beta * previousResult.Velocity[i] + input.TimeStep * (1 - input.Gama / (2 * input.Beta)) * previousResult.Acceleration[i];
deltaAcceleration[i] = (1 / (input.Beta * Math.Pow(input.TimeStep, 2))) * deltaDisplacement[i] - (1 / (input.Beta * input.TimeStep)) * previousResult.Velocity[i] - (1 / (2 * input.Beta)) * previousResult.Acceleration[i];
}
return(new FiniteElementResult
{
Displacement = await previousResult.Displacement.SumAsync(deltaDisplacement).ConfigureAwait(false),
Velocity = await previousResult.Velocity.SumAsync(deltaVelocity).ConfigureAwait(false),
Acceleration = await previousResult.Acceleration.SumAsync(deltaAcceleration).ConfigureAwait(false),
Force = await this._force.CalculateForceByType(input.OriginalForce, input.AngularFrequency, time, input.ForceType).ConfigureAwait(false)
});
}
/// <summary>
/// Calculates the equivalent force to calculate the displacement in Newmark-Beta method.
/// </summary>
/// <param name="input"></param>
/// <param name="previousResult"></param>
/// <param name="time"></param>
/// <returns></returns>
public async Task <double[]> CalculateEquivalentForce(FiniteElementMethodInput input, FiniteElementResult previousResult, double time)
{
double[,] equivalentDamping = await this.CalculateEquivalentDamping(input).ConfigureAwait(false);
double[,] equivalentMass = await this.CalculateEquivalentMass(input).ConfigureAwait(false);
double[] damping_vel = await equivalentDamping.MultiplyAsync(previousResult.Velocity).ConfigureAwait(false);
double[] mass_accel = await equivalentMass.MultiplyAsync(previousResult.Acceleration).ConfigureAwait(false);
double[] previousForce = await this._force.CalculateForceByType(input.OriginalForce, input.AngularFrequency, time, input.ForceType).ConfigureAwait(false);
double[] force = await this._force.CalculateForceByType(input.OriginalForce, input.AngularFrequency, time + input.TimeStep, input.ForceType).ConfigureAwait(false);
double[] deltaForce = await force.SubtractAsync(previousForce).ConfigureAwait(false);
double[] equivalentForce = await deltaForce.SumAsync(damping_vel, mass_accel).ConfigureAwait(false);
return(equivalentForce);
}
/// <summary> /// Calculates and write in a file the results for a finite element analysis. /// </summary> /// <param name="input"></param> /// <param name="previousResult"></param> /// <param name="time"></param> /// <returns></returns> public abstract Task <FiniteElementResult> CalculateFiniteElementResult(FiniteElementMethodInput input, FiniteElementResult previousResult, double time);
