internal LoadIncrementalStateResult Correct(LoadState state, LoadIncrementalState prediction, StructureInfo info)
{
LoadIncrementalStateResult result = new LoadIncrementalStateResult(null, false, "");
LoadState initialState = state;
LoadState currentState = initialState;
LoadIncrementalState predictionIncrement = prediction;
for (int iteration = 1; iteration <= MaximumIterations; iteration++)
{
LoadIncrementalStateResult correction = GetCorrection(currentState, predictionIncrement, info);
predictionIncrement.Add(correction.IncrementalState);
LoadState newState = currentState.Add(correction.IncrementalState);
List <double> errors = GetErrors(newState, currentState, info).ToList( );
bool convergence = CheckConvergence(errors, Tolerances);
currentState = newState;
if (convergence)
{
break;
}
if (iteration >= MaximumIterations)
{
result.Message = Strings.MaxNumberOfIterationsReached;
result.Success = false;
}
}
result.IncrementalState = currentState.Substract(initialState);
return(result);
}
LoadIncrementalStateResult GetCorrection(LoadState state, LoadIncrementalState prediction, StructureInfo info)
{
Matrix <double> stiffnessMatrix = info.Stiffness(state.Displacement);
Vector <double> dut = stiffnessMatrix.Solve(info.ReferenceLoad);
Vector <double> reaction = info.Reaction(state.Displacement);
Vector <double> equilibrium = info.InitialLoad + state.Lambda * info.ReferenceLoad - reaction;
Vector <double> dur = stiffnessMatrix.Solve(equilibrium);
LoadIncrementalStateResult incrementalStateResult = Scheme.GetCorrection(state, prediction, info, dut, dur);
return(incrementalStateResult);
}
public LoadIncrementalStateResult Choose(StructureInfo info, LoadState state, LoadIncrementalState prediction, IEnumerable <LoadIncrementalState> candidates)
{
List <LoadIncrementalState> candidateList = candidates.ToList( );
if (candidateList.Any( ))
{
double Function(LoadIncrementalState candidate) =>
prediction.IncrementDisplacement.DotProduct(candidate.IncrementDisplacement) /
(prediction.IncrementDisplacement.Norm(2) * candidate.IncrementDisplacement.Norm(2));
LoadIncrementalState result = candidateList.MinBy(Function).First( );
return(new LoadIncrementalStateResult(result, true, ""));
}
return(new LoadIncrementalStateResult(null, false, ""));
}
public LoadIncrementalStateResult Choose(StructureInfo info, LoadState state, LoadIncrementalState prediction, IEnumerable <LoadIncrementalState> candidates)
{
List <LoadIncrementalState> candidateList = candidates.ToList( );
if (candidateList.Any( ))
{
double Function(LoadIncrementalState candidate)
{
Vector <double> displacement = state.Displacement + candidate.IncrementDisplacement;
Vector <double> reaction = info.Reaction(displacement);
double lambda = state.Lambda + candidate.IncrementLambda;
Vector <double> equilibriumVector = info.InitialLoad + lambda * info.ReferenceLoad - reaction;
return(equilibriumVector.Norm(2));
}
LoadIncrementalState result = candidateList.MinBy(Function).First( );
return(new LoadIncrementalStateResult(result, true, ""));
}
return(new LoadIncrementalStateResult(null, false, ""));
}
public LoadIncrementalStateResult GetCorrection(LoadState state, LoadIncrementalState prediction, StructureInfo info, Vector <double> dut, Vector <double> dur) => new LoadIncrementalStateResult(new LoadIncrementalState(0, dur), true, "");
/// <summary>
/// Adds a LoadIncrementalState to the current LoadState and returns a new reference.
/// </summary>
/// <param name="increment"></param>
/// <returns></returns>
internal LoadState Add(LoadIncrementalState increment) =>
new LoadState(Lambda + increment.IncrementLambda,
Displacement + increment.IncrementDisplacement);
internal void Add(LoadIncrementalState inc)
{
IncrementDisplacement += inc.IncrementDisplacement;
IncrementLambda += inc.IncrementLambda;
}
