avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Force crack calculator was fixed

Browse Source
This commit is contained in:
RedikultsevEvg
2024-08-04 23:01:10 +05:00
parent e7c7211f54
commit 3eb5aa2b96
54 changed files with 1031 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
StructureHelper/Windows/CalculationWindows/CalculatorsViews/CrackDiagramLogic.cs
View File

@@ -23,7 +23,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
{
static IConvertUnitLogic operationLogic = new ConvertUnitLogic();
static IGetUnitLogic unitLogic = new GetUnitLogic();
static readonly CrackForceCalculator calculator = new();
static readonly CrackForceBynarySearchCalculator calculator = new();
private ITriangulatePrimitiveLogic triangulateLogic;
private List<IForcesTupleResult> ValidTupleList { get; set; }
@@ -103,7 +103,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
validTupleList[i].DesignForceTuple.ForceTuple.My * unitMoment.Multiplyer,
validTupleList[i].DesignForceTuple.ForceTuple.Nz * unitForce.Multiplyer
};
calculator.EndTuple = validTupleList[i].DesignForceTuple.ForceTuple;
calculator.InputData.EndTuple = validTupleList[i].DesignForceTuple.ForceTuple;
var limitState = validTupleList[i].DesignForceTuple.LimitState;
var calcTerm = validTupleList[i].DesignForceTuple.CalcTerm;
triangulateLogic = new TriangulatePrimitiveLogic()
@@ -114,7 +114,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
TraceLogger = TraceLogger
};
var ndms = triangulateLogic.GetNdms();
calculator.NdmCollection = ndms;
calculator.InputData.CheckedNdmCollection = calculator.InputData.SectionNdmCollection = ndms;
calculator.Run();
var result = (CrackForceResult)calculator.Result;
if (result.IsValid == false)

2
StructureHelper/Windows/CalculationWindows/CalculatorsViews/Cracks/CrackCalculatorInputDataViewModel.cs
View File

@@ -15,7 +15,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews
public class CrackCalculatorInputDataViewModel : OkCancelViewModelBase
{
private CrackCalculator calculator;
CrackInputData crackInputData;
CrackCalculatorInputData crackInputData;
private bool setUserValueSofteningFactor;
private double softeningFactor;
private string name;

11
StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ShowCrackResultLogic.cs
View File

@@ -17,7 +17,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu
{
internal class ShowCrackResultLogic
{
private CrackForceCalculator calculator;
private CrackForceBynarySearchCalculator calculator;
private ITriangulatePrimitiveLogic triangulateLogic;
public static GeometryNames GeometryNames => ProgramSetting.GeometryNames;
@@ -39,17 +39,18 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu
private void FindCrackFactor(IForceTuple finishDesignTuple, IForceTuple startDesignTuple)
{
calculator = new CrackForceCalculator();
calculator = new CrackForceBynarySearchCalculator();
calculator.TraceLogger = new ShiftTraceLogger();
calculator.StartTuple = startDesignTuple;
calculator.EndTuple = finishDesignTuple;
calculator.InputData.StartTuple = startDesignTuple;
calculator.InputData.EndTuple = finishDesignTuple;
triangulateLogic = new TriangulatePrimitiveLogic()
{
Primitives = ndmPrimitives,
LimitState = LimitState,
CalcTerm = CalcTerm
};
calculator.NdmCollection = triangulateLogic.GetNdms();
var ndms = triangulateLogic.GetNdms();
calculator.InputData.CheckedNdmCollection = calculator.InputData.SectionNdmCollection = ndms;
calculator.Run();
var result = (CrackForceResult)calculator.Result;
if (result.IsValid)

2
StructureHelper/Windows/ViewModels/NdmCrossSections/AnalysisViewModelLogic.cs
View File

@@ -59,7 +59,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections
private void AddCrackCalculator()
{
var inputData = new CrackInputData();
var inputData = new CrackCalculatorInputData();
var calculator = new CrackCalculator(inputData)
{
Name = "New crack calculator",

13
StructureHelperCommon/Infrastructures/Interfaces/ICheckEntityLogic.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperCommon.Infrastructures.Interfaces
{
public interface ICheckEntityLogic<TEntity> : ICheckLogic
{
TEntity Entity { get; set; }
}
}

10
StructureHelperCommon/Infrastructures/Interfaces/ICheckLogic.cs
View File

@@ -6,9 +6,19 @@ using System.Threading.Tasks;
namespace StructureHelperCommon.Infrastructures.Interfaces
{
/// <summary>
/// Logic for checking entities
/// </summary>
public interface ICheckLogic : ILogic
{
/// <summary>
/// Text result of checking
/// </summary>
string CheckResult { get; }
/// <summary>
/// Start checking process
/// </summary>
/// <returns></returns>
bool Check();
}
}

62
StructureHelperCommon/Models/Calculators/CheckAccuracyLogic.cs Normal file
View File

@@ -0,0 +1,62 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperCommon.Models.Calculators
{
public class CheckAccuracyLogic : ICheckEntityLogic<IAccuracy>
{
private string checkResult;
private bool result;
public IAccuracy Entity { get; set; }
public string CheckResult => checkResult;
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckAccuracyLogic(IShiftTraceLogger traceLogger)
{
TraceLogger = traceLogger;
}
public CheckAccuracyLogic() : this (null)
{
}
public bool Check()
{
result = true;
if (Entity is null)
{
result = false;
string errorString = "\nAccuracy requirements is not assigned";
TraceMessage(errorString);
}
else
{
if (Entity.IterationAccuracy <= 0)
{
result = false;
TraceMessage($"\nValue of accuracy {Entity.IterationAccuracy} must be grater than zero");
}
if (Entity.MaxIterationCount <= 0)
{
result = false;
TraceMessage($"\nMax number of iteration {Entity.MaxIterationCount} must be grater than zero");
}
}
return result;
}
private void TraceMessage(string errorString)
{
checkResult += errorString;
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
}
}
}

21
StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs
View File

@@ -10,14 +10,12 @@ using System.Threading.Tasks;
namespace StructureHelperCommon.Models.Calculators
{
public class FindParameterCalculator : ICalculator, IHasActionByResult
public class FindParameterCalculator : IFindParameterCalculator
{
FindParameterResult result;
public string Name { get; set; }
public double StartValue { get; set; }
public double EndValue { get; set; }
public Predicate<double> Predicate { get; set; }
public IAccuracy Accuracy {get;set;}
public IFindParameterCalculatorInputData InputData { get; set; }
public IAccuracy Accuracy { get; set; }
public IResult Result => result;
public Action<IResult> ActionToOutputResults { get; set; }
@@ -25,18 +23,21 @@ namespace StructureHelperCommon.Models.Calculators
public FindParameterCalculator()
{
StartValue = 0d;
EndValue = 1d;
Accuracy = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 1000 };
InputData = new FindParameterCalculatorInputData();
Accuracy = new Accuracy()
{
IterationAccuracy = 0.001d,
MaxIterationCount = 1000
};
}
public void Run()
{
result = new();
try
{
FindMinimumValue(StartValue, EndValue, Predicate);
FindMinimumValue(InputData.StartValue, InputData.EndValue, InputData.Predicate);
}
catch(Exception ex)
catch (Exception ex)
{
result.IsValid = false;
result.Description += ex;

24
StructureHelperCommon/Models/Calculators/FindParameterCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperCommon.Models.Calculators
{
/// <inheritdoc/>
public class FindParameterCalculatorInputData : IFindParameterCalculatorInputData
{
/// <inheritdoc/>
public double StartValue { get; set; }
/// <inheritdoc/>
public double EndValue { get; set; }
/// <inheritdoc/>
public Predicate<double> Predicate { get; set; }
public FindParameterCalculatorInputData()
{
StartValue = 0d;
EndValue = 1d;
}
}
}

8
StructureHelperCommon/Models/Calculators/IFindParameterCalculator.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace StructureHelperCommon.Models.Calculators
{
public interface IFindParameterCalculator : ICalculator, IHasActionByResult
{
IAccuracy Accuracy { get; set; }
IFindParameterCalculatorInputData InputData { get; set; }
}
}

23
StructureHelperCommon/Models/Calculators/IFindParameterCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,23 @@
using System;
namespace StructureHelperCommon.Models.Calculators
{
/// <summary>
/// Input data for calculators of finding parameters
/// </summary>
public interface IFindParameterCalculatorInputData : IInputData
{
/// <summary>
/// Start value of range where parameter looking for
/// </summary>
double StartValue { get; set; }
/// <summary>
/// End value of range where parameter looking for
/// </summary>
double EndValue { get; set; }
/// <summary>
/// Predicate for checking parameter for true;
/// </summary>
Predicate<double> Predicate { get; set; }
}
}

3
StructureHelperCommon/Models/Loggers/ITraceLogger.cs
View File

@@ -9,7 +9,8 @@ namespace StructureHelperCommon.Models
public interface ITraceLogger
{
List<ITraceLoggerEntry> TraceLoggerEntries { get; }
void AddMessage(string message, TraceLogStatuses status = TraceLogStatuses.Info, int shiftPriority = 0);
void AddMessage(string message, TraceLogStatuses status, int shiftPriority = 0);
void AddMessage(string message);
void AddMessage(string message, int priority);
bool KeepErrorStatus { get; set; }
}

7
StructureHelperCommon/Models/Loggers/ShiftTraceLogger.cs
View File

@@ -20,7 +20,7 @@ namespace StructureHelperCommon.Models
KeepErrorStatus = true;
}
public ShiftTraceLogger() : this(new TraceLogger()) { }
public void AddMessage(string message, TraceLogStatuses status = TraceLogStatuses.Info, int shiftPrioriry = 0)
public void AddMessage(string message, TraceLogStatuses status, int shiftPrioriry = 0)
{
// if status in (fatal, error, warning) they must be kept as they are
if (status <= TraceLogStatuses.Warning & KeepErrorStatus == true)
@@ -57,5 +57,10 @@ namespace StructureHelperCommon.Models
}
Logger.TraceLoggerEntries.Add(loggerEntry);
}
public void AddMessage(string message)
{
AddMessage(message, TraceLogStatuses.Info,0);
}
}
}

7
StructureHelperCommon/Models/Loggers/TraceLogger.cs
View File

@@ -19,7 +19,7 @@ namespace StructureHelperCommon.Models
KeepErrorStatus = true;
}
public void AddMessage(string message, TraceLogStatuses status = TraceLogStatuses.Info, int shiftPrioriry = 0)
public void AddMessage(string message, TraceLogStatuses status, int shiftPrioriry = 0)
{
if (status == TraceLogStatuses.Fatal) { message = $"Fatal error! {message}"; }
if (status == TraceLogStatuses.Error) { message = $"Error! {message}"; }
@@ -38,5 +38,10 @@ namespace StructureHelperCommon.Models
Priority = priority
});
}
public void AddMessage(string message)
{
AddMessage(message, TraceLogStatuses.Info,0);
}
}
}

2
StructureHelperLogics/Models/Templates/CrossSections/CalculatorLogic.cs
View File

@@ -16,7 +16,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections
TraceLogger = new ShiftTraceLogger()
};
calculators.Add(forceCalculator);
CrackInputData newInputData = new CrackInputData();
CrackCalculatorInputData newInputData = new CrackCalculatorInputData();
var checkLogic = new CheckCrackCalculatorInputDataLogic
{
InputData = newInputData

70
StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs
View File

@@ -1,7 +1,10 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Infrastructures.Settings;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -10,46 +13,77 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
internal class CheckForceCalculatorInputData : ICheckInputDataLogic<ForceInputData>
internal class CheckForceCalculatorInputData : ICheckInputDataLogic<IForceInputData>
{
public ForceInputData InputData { get; set; }
private bool result;
private string checkResult;
private ICheckEntityLogic<IAccuracy> checkAccuracyLogic;
public string CheckResult { get; private set; }
public IForceInputData InputData { get; set; }
public string CheckResult => checkResult;
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckForceCalculatorInputData(ForceInputData inputData)
public CheckForceCalculatorInputData(ICheckEntityLogic<IAccuracy> checkAccuracyLogic)
{
InputData = inputData;
CheckResult = string.Empty;
this.checkAccuracyLogic = checkAccuracyLogic;
}
public CheckForceCalculatorInputData() : this(new CheckAccuracyLogic())
{
}
public bool Check()
{
bool result = true;
CheckResult = string.Empty;
if (!InputData.Primitives.Any())
result = true;
checkResult = string.Empty;
if (InputData is null)
{
CheckResult += "Calculator does not contain any primitives \n";
string errorString = ErrorStrings.ParameterIsNull + ": input data";
TraceMessage(errorString);
throw new StructureHelperException(errorString);
}
if (InputData.Primitives is null || !InputData.Primitives.Any())
{
TraceMessage("Calculator does not contain any primitives");
result = false;
}
if (!InputData.ForceActions.Any())
if (InputData.ForceActions is null || !InputData.ForceActions.Any())
{
CheckResult += "Calculator does not contain any forces \n";
TraceMessage("Calculator does not contain any forces");
result = false;
}
if (!InputData.LimitStatesList.Any())
if (InputData.LimitStatesList is null || !InputData.LimitStatesList.Any())
{
CheckResult += "Calculator does not contain any limit states \n";
TraceMessage("Calculator does not contain any limit states");
result = false;
}
if (!InputData.CalcTermsList.Any())
if (InputData.CalcTermsList is null || !InputData.CalcTermsList.Any())
{
CheckResult += "Calculator does not contain any calc term \n";
TraceMessage("Calculator does not contain any calc term");
result = false;
}
CheckAccuracy();
return result;
}
private void CheckAccuracy()
{
checkAccuracyLogic.Entity = InputData.Accuracy;
checkAccuracyLogic.TraceLogger = TraceLogger;
if (checkAccuracyLogic.Check() == false)
{
result = false;
}
TraceMessage(checkAccuracyLogic.CheckResult);
}
private void TraceMessage(string errorString)
{
checkResult += errorString + "\n";
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
}
}
}

52
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs
View File

@@ -8,8 +8,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public class ForceCalculator : ICalculator, IHasActionByResult
{
private IUpdateStrategy<ForceCalculator> updateStrategy = new ForceCalculatorUpdateStrategy();
private ICheckInputDataLogic<ForceInputData> checkInputDataLogic;
private IUpdateStrategy<ForceCalculator> updateStrategy;
private ICheckInputDataLogic<IForceInputData> checkInputDataLogic;
private IForceCalculatorLogic forceCalculatorLogic;
@@ -19,11 +19,30 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public IShiftTraceLogger? TraceLogger { get; set; }
public IResult Result { get; private set; }
public ForceCalculator(ICheckInputDataLogic<IForceInputData> checkInputDataLogic,
IForceCalculatorLogic forceCalculatorLogic,
IUpdateStrategy<ForceCalculator> updateStrategy
)
{
this.checkInputDataLogic = checkInputDataLogic;
this.forceCalculatorLogic = forceCalculatorLogic;
this.updateStrategy = updateStrategy;
InputData = new ForceInputData();
}
public ForceCalculator() :
this(new CheckForceCalculatorInputData(),
new ForceCalculatorLogic(),
new ForceCalculatorUpdateStrategy())
{
}
public void Run()
{
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);
checkInputDataLogic = new CheckForceCalculatorInputData(InputData);
checkInputDataLogic.TraceLogger?.GetSimilarTraceLogger(50);
checkInputDataLogic.InputData = InputData;
checkInputDataLogic.TraceLogger = TraceLogger;
if (checkInputDataLogic.Check() != true)
{
Result = new ForcesResults()
@@ -33,6 +52,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
};
return;
}
forceCalculatorLogic.InputData = InputData;
if (ActionToOutputResults is not null)
{
forceCalculatorLogic.ActionToOutputResults = ActionToOutputResults;
@@ -46,31 +66,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
throw new NotImplementedException();
}
public ForceCalculator(ForceInputData inputData,
ICheckInputDataLogic<ForceInputData> checkInputDataLogic,
IForceCalculatorLogic forceCalculatorLogic,
IUpdateStrategy<ForceCalculator> updateStrategy
)
{
this.InputData = inputData;
this.checkInputDataLogic = checkInputDataLogic;
this.forceCalculatorLogic = forceCalculatorLogic;
this.updateStrategy = updateStrategy;
}
public ForceCalculator(ForceInputData inputData) :
this(inputData,
new CheckForceCalculatorInputData(inputData),
new ForceCalculatorLogic(inputData),
new ForceCalculatorUpdateStrategy())
{
}
public ForceCalculator() : this(new ForceInputData()) { }
public object Clone()
{
var newCalculator = new ForceCalculator(new ForceInputData());
var newCalculator = new ForceCalculator();
updateStrategy.Update(newCalculator, this);
return newCalculator;
}

7
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs
View File

@@ -18,14 +18,11 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
private IProcessorLogic<IForceTuple> eccentricityLogic;
private ForceTupleBucklingLogic bucklingLogic;
private ITriangulatePrimitiveLogic triangulateLogic;
public ForceInputData InputData { get; set; }
public IForceInputData InputData { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public Action<IResult> ActionToOutputResults { get; set; }
public ForceCalculatorLogic(ForceInputData inputData)
{
InputData = inputData;
}
public ForcesResults GetForcesResults()
{
TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service);

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs
View File

@@ -13,7 +13,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public class ForceInputData : IInputData, IHasPrimitives, IHasForceCombinations
public class ForceInputData : IForceInputData
{
public List<LimitStates> LimitStatesList { get; private set; }
public List<CalcTerms> CalcTermsList { get; private set; }

141
StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs
View File

@@ -4,6 +4,7 @@ using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Data.ResultData;
using LoaderCalculator.Data.SourceData;
using LoaderCalculator.Logics;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
@@ -13,122 +14,78 @@ using StructureHelperLogics.Services;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public class ForceTupleCalculator : IForceTupleCalculator, IHasActionByResult
public class ForceTupleCalculator : IForceTupleCalculator
{
IForceTupleTraceResultLogic forceTupleTraceResultLogic;
IForcesTupleResult result;
private ICheckInputDataLogic<IForceTupleInputData> checkInputDataLogic;
private IForceTupleCalcLogic calcLogic;
public IForceTupleInputData InputData { get; set; }
public string Name { get; set; }
public IResult Result { get; private set; }
public IResult Result => result;
public Action<IResult> ActionToOutputResults { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public ForceTupleCalculator()
public ForceTupleCalculator(ICheckInputDataLogic<IForceTupleInputData> checkInputDataLogic, IForceTupleCalcLogic calcLogic)
{
this.checkInputDataLogic = checkInputDataLogic;
this.calcLogic = calcLogic;
}
public ForceTupleCalculator() : this(new CheckForceTupleInputDataLogic(), new ForceTupleCalcLogic())
{
}
public void Run()
{
Result = CalculateResult();
PrepareNewResult();
if (CheckInputData() == false)
{
return;
}
CalculateResult();
}
private IForcesTupleResult CalculateResult()
{
TraceLogger?.AddMessage(string.Intern($"Calculator type: {GetType()}"), TraceLogStatuses.Service);
TraceLogger?.AddMessage(string.Intern("Calculator logic based on calculating strain in plain section by elementary parts of finished size"));
var ndmCollection = InputData.NdmCollection;
if (TraceLogger is not null)
{
TraceService.TraceNdmCollection(TraceLogger, ndmCollection);
}
var tuple = InputData.Tuple;
var accuracy = InputData.Accuracy;
TraceLogger?.AddMessage(string.Intern("Input force combination"));
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tuple));
var mx = tuple.Mx;
var my = tuple.My;
var nz = tuple.Nz;
TraceLogger?.AddMessage($"Required accuracy rate {accuracy.IterationAccuracy}");
TraceLogger?.AddMessage($"Maximum iteration count {accuracy.MaxIterationCount}");
try
{
var loaderData = new LoaderOptions
{
Preconditions = new Preconditions
{
ConditionRate = accuracy.IterationAccuracy,
MaxIterationCount = accuracy.MaxIterationCount,
StartForceMatrix = new ForceMatrix { Mx = mx, My = my, Nz = nz }
},
ActionToOutputResults = ShowResultToTrace,
NdmCollection = ndmCollection
};
var calculator = new Calculator();
TraceLogger?.AddMessage(string.Intern("Calculation is started"), TraceLogStatuses.Debug);
calculator.Run(loaderData, new CancellationToken());
TraceLogger?.AddMessage(string.Intern("Calculation result is obtained"), TraceLogStatuses.Debug);
var calcResult = calculator.Result;
if (calcResult.AccuracyRate <= accuracy.IterationAccuracy)
{
var result = new ForcesTupleResult()
{
IsValid = true,
Description = LoggerStrings.CalculationHasDone,
LoaderResults = calcResult
};
forceTupleTraceResultLogic = new ForceTupleTraceResultLogic(ndmCollection) { TraceLogger = TraceLogger };
forceTupleTraceResultLogic.TraceResult(result);
return result;
}
else
{
TraceLogger?.AddMessage(string.Intern("Required accuracy rate has not achieved"), TraceLogStatuses.Error);
TraceLogger?.AddMessage($"Current accuracy {calcResult.AccuracyRate}, {calcResult.IterationCounter} iteration has done", TraceLogStatuses.Warning);
return new ForcesTupleResult()
{
IsValid = false,
Description = string.Intern("Required accuracy rate has not achieved"),
LoaderResults = calcResult
};
}
}
catch (Exception ex)
{
TraceLogger?.AddMessage($"Critical error ocured during calculation\n{ex}", TraceLogStatuses.Error);
var result = new ForcesTupleResult()
{
IsValid = false
};
if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero")
{
TraceLogger?.AddMessage(string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed"), TraceLogStatuses.Error);
result.Description = string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed");
}
else
{
result.Description = $"Error is appeared due to analysis. Error: {ex}";
}
return result;
}
}
public object Clone()
{
var newItem = new ForceTupleCalculator();
return newItem;
}
private static void ShowResultToConsole(ILoaderResults result)
private void CalculateResult()
{
var strain = result.StrainMatrix;
//MessageBox.Show($" Текущие результаты в {result.IterationCounter} итерации:");
calcLogic.InputData = InputData;
calcLogic.ActionToOutputResults = ActionToOutputResults;
calcLogic.TraceLogger = TraceLogger;
calcLogic.Calculate();
result = calcLogic.Result;
}
private void ShowResultToTrace(ILoaderResults result)
private void PrepareNewResult()
{
var strain = result.StrainMatrix;
TraceLogger?.AddMessage($"Iteration {result.IterationCounter}, current accuracy rate {result.AccuracyRate}", TraceLogStatuses.Debug,100);
result = new ForcesTupleResult()
{
IsValid = true,
Description = string.Empty,
};
}
private bool CheckInputData()
{
checkInputDataLogic.InputData = InputData;
checkInputDataLogic.TraceLogger = TraceLogger;
if (checkInputDataLogic.Check() == false)
{
result.IsValid = false;
result.Description += checkInputDataLogic.CheckResult;
return false;
}
return true;
}
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs
View File

@@ -10,7 +10,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public interface IForceCalculatorLogic : ILogic, IHasActionByResult
{
ForceInputData InputData { get; set; }
IForceInputData InputData { get; set; }
ForcesResults GetForcesResults();
}
}

18
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs Normal file
View File

@@ -0,0 +1,18 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Sections;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public interface IForceInputData : IInputData, IHasPrimitives, IHasForceCombinations
{
IAccuracy Accuracy { get; set; }
List<CalcTerms> CalcTermsList { get; }
ICompressedMember CompressedMember { get; set; }
List<IForceCombinationList> ForceCombinationLists { get; set; }
List<LimitStates> LimitStatesList { get; }
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleCalculator.cs
View File

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public interface IForceTupleCalculator : ICalculator
public interface IForceTupleCalculator : ICalculator, IHasActionByResult
{
IForceTupleInputData InputData {get;set;}
}

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceTupleInputData.cs
View File

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public interface IForceTupleInputData
public interface IForceTupleInputData : IInputData
{
IEnumerable<INdm> NdmCollection { get; set; }
IForceTuple Tuple { get; set; }

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs
View File

@@ -83,7 +83,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
private bool IsSectionCracked(IPoint2D point2D)
{
logger?.TraceLoggerEntries.Clear();
var logic = new SectionCrackedLogic();
var logic = new IsSectionCrackedByForceLogic();
var point3D = ConvertLogic.GetPoint3D(point2D);
tuple = new()
{

6
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveParameterLogic.cs
View File

@@ -20,10 +20,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public double GetParameter()
{
var parameterCalculator = new FindParameterCalculator()
{
Predicate = GetFactorPredicate,
};
var parameterCalculator = new FindParameterCalculator();
parameterCalculator.InputData.Predicate = GetFactorPredicate;
if (TraceLogger is not null)
{
parameterCalculator.TraceLogger = TraceLogger;

84
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CheckForceTupleInputDataLogic.cs Normal file
View File

@@ -0,0 +1,84 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public class CheckForceTupleInputDataLogic : ICheckInputDataLogic<IForceTupleInputData>
{
private bool result;
private string checkResult;
public IForceTupleInputData InputData { get; set; }
public string CheckResult => checkResult;
public IShiftTraceLogger? TraceLogger { get; set; }
public CheckForceTupleInputDataLogic(IForceTupleInputData inputData, IShiftTraceLogger traceLogger)
{
InputData = inputData;
TraceLogger = traceLogger;
}
public CheckForceTupleInputDataLogic()
{
}
public bool Check()
{
result = true;
checkResult = string.Empty;
if (InputData is null)
{
string errorString = ErrorStrings.ParameterIsNull + ": Input data";
TraceLogger?.AddMessage(errorString);
throw new StructureHelperException(errorString);
}
if (InputData.NdmCollection is null || ! InputData.NdmCollection.Any())
{
result = false;
string errorString = "\nNdm collection is null or empty";
TraceMessage(errorString);
}
if (InputData.Tuple is null)
{
result = false;
string errorString = "\nForce tuple is null";
TraceMessage(errorString);
}
if (InputData.Accuracy is null)
{
result = false;
string errorString = "\nAccuracy requirements is not assigned";
TraceMessage(errorString);
}
else
{
if (InputData.Accuracy.IterationAccuracy <= 0)
{
result = false;
TraceMessage($"\nValue of accuracy {InputData.Accuracy.IterationAccuracy} must be grater than zero");
}
if (InputData.Accuracy.MaxIterationCount <= 0)
{
result = false;
TraceMessage($"\nMax number of iteration {InputData.Accuracy.MaxIterationCount} must be grater than zero");
}
}
return result;
}
private void TraceMessage(string errorString)
{
checkResult += errorString;
TraceLogger?.AddMessage(errorString);
}
}
}

155
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceTupleCalcLogic.cs Normal file
View File

@@ -0,0 +1,155 @@
using LoaderCalculator.Data.Matrix;
using LoaderCalculator;
using LoaderCalculator.Data.ResultData;
using LoaderCalculator.Data.SourceData;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Loggers;
using StructureHelperLogics.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public class ForceTupleCalcLogic : IForceTupleCalcLogic
{
private IForcesTupleResult result;
private ForceTupleTraceResultLogic forceTupleTraceResultLogic;
private LoaderOptions loaderData;
private Calculator calculator;
private ILoaderResults calcResult;
public IForceTupleInputData InputData { get; set; }
public IForcesTupleResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public Action<IResult> ActionToOutputResults { get; set; }
public void Calculate()
{
PrepareNewResult();
CalculateResult();
}
private void PrepareNewResult()
{
result = new ForcesTupleResult()
{
IsValid = true,
Description = string.Empty,
};
}
private void CalculateResult()
{
TraceStartOfCalculation();
try
{
GetLoaderResult();
ProcessLoaderResult();
}
catch (Exception ex)
{
ProcessCalculationException(ex);
}
}
private void TraceStartOfCalculation()
{
TraceLogger?.AddMessage(string.Intern($"Calculator type: {GetType()}"), TraceLogStatuses.Service);
TraceLogger?.AddMessage(string.Intern("Calculator logic based on calculating strain in plain section by elementary parts of finished size"));
if (TraceLogger is not null)
{
TraceService.TraceNdmCollection(TraceLogger, InputData.NdmCollection);
}
TraceLogger?.AddMessage(string.Intern("Input force combination"));
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.Tuple));
TraceLogger?.AddMessage($"Required accuracy rate {InputData.Accuracy.IterationAccuracy}");
TraceLogger?.AddMessage($"Maximum iteration count {InputData.Accuracy.MaxIterationCount}");
}
private void ProcessCalculationException(Exception ex)
{
TraceLogger?.AddMessage($"Critical error ocured during calculation\n{ex}", TraceLogStatuses.Error);
result.IsValid = false;
if (ex.Message == "Calculation result is not valid: stiffness matrix is equal to zero")
{
TraceLogger?.AddMessage(string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed"), TraceLogStatuses.Error);
result.Description = string.Intern("Stiffness matrix is equal to zero\nProbably section was collapsed");
}
else
{
result.Description = $"Error is appeared due to analysis. Error: {ex}";
}
}
private void ProcessLoaderResult()
{
if (calcResult.AccuracyRate <= InputData.Accuracy.IterationAccuracy)
{
ProcessCorrectLoaderResult();
}
else
{
ProcessInCorrectLoaderResult();
}
}
private void ProcessInCorrectLoaderResult()
{
TraceLogger?.AddMessage(string.Intern("Required accuracy rate has not achieved"), TraceLogStatuses.Error);
TraceLogger?.AddMessage($"Current accuracy {calcResult.AccuracyRate}, {calcResult.IterationCounter} iteration has done", TraceLogStatuses.Warning);
result.IsValid = false;
result.Description = string.Intern("Required accuracy rate has not achieved");
result.LoaderResults = calcResult;
}
private void ProcessCorrectLoaderResult()
{
result.IsValid = true;
result.Description = LoggerStrings.CalculationHasDone;
result.LoaderResults = calcResult;
forceTupleTraceResultLogic = new ForceTupleTraceResultLogic(InputData.NdmCollection)
{
TraceLogger = TraceLogger
};
forceTupleTraceResultLogic.TraceResult(result);
}
private void GetLoaderResult()
{
loaderData = new LoaderOptions
{
Preconditions = new Preconditions
{
ConditionRate = InputData.Accuracy.IterationAccuracy,
MaxIterationCount = InputData.Accuracy.MaxIterationCount,
StartForceMatrix = new ForceMatrix
{
Mx = InputData.Tuple.Mx,
My = InputData.Tuple.My,
Nz = InputData.Tuple.Nz
}
},
ActionToOutputResults = ShowResultToTrace,
NdmCollection = InputData.NdmCollection
};
calculator = new Calculator();
TraceLogger?.AddMessage(string.Intern("Calculation is started"), TraceLogStatuses.Debug);
calculator.Run(loaderData, new CancellationToken());
TraceLogger?.AddMessage(string.Intern("Calculation result is obtained"), TraceLogStatuses.Debug);
calcResult = calculator.Result;
}
private void ShowResultToTrace(ILoaderResults result)
{
var strain = result.StrainMatrix;
TraceLogger?.AddMessage($"Iteration {result.IterationCounter}, current accuracy rate {result.AccuracyRate}", TraceLogStatuses.Debug, 100);
}
}
}

17
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/IForceTupleCalcLogic.cs Normal file
View File

@@ -0,0 +1,17 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public interface IForceTupleCalcLogic: ILogic, IHasActionByResult
{
IForceTupleInputData InputData { get; set; }
IForcesTupleResult Result { get; }
void Calculate();
}
}

4
StructureHelperLogics/NdmCalculations/Cracking/CheckCrackCalculatorInputDataLogic.cs
View File

@@ -18,12 +18,12 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <summary>
/// Logic of checking of input data for crack calcultor
/// </summary>
public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<CrackInputData>
public class CheckCrackCalculatorInputDataLogic : ICheckInputDataLogic<CrackCalculatorInputData>
{
private bool result;
private ICheckPrimitiveCollectionLogic checkPrimitiveCollectionLogic;
public CrackInputData InputData { get; set; }
public CrackCalculatorInputData InputData { get; set; }
public string CheckResult { get; private set; }

63
StructureHelperLogics/NdmCalculations/Cracking/CheckCrackForceCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,63 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CheckCrackForceCalculatorInputData : ICheckInputDataLogic<ICrackForceCalculatorInputData>
{
private string checkResult;
private bool result;
public ICrackForceCalculatorInputData InputData { get; set; }
public string CheckResult => checkResult;
public IShiftTraceLogger? TraceLogger { get; set; }
public bool Check()
{
result = true;
if (InputData is null)
{
TraceMessage("InputData is null");
return false;
}
if (InputData.CheckedNdmCollection is null || ! InputData.CheckedNdmCollection.Any())
{
result = false;
TraceMessage("Checked ndm collection is null or empty");
}
if (InputData.SectionNdmCollection is null || !InputData.SectionNdmCollection.Any())
{
result = false;
TraceMessage("Section ndm collection is null or empty");
}
if (InputData.StartTuple is null)
{
result = false;
TraceMessage("Start force tuple is null");
}
if (InputData.EndTuple is null)
{
result = false;
TraceMessage("End force tuple is null");
}
if (InputData.StartTuple == InputData.EndTuple)
{
result = false;
TraceMessage("Start tuple is equal to end tuple");
}
return result;
}
private void TraceMessage(string errorString)
{
checkResult += errorString + "\n";
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
}
}
}

10
StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs
View File

@@ -23,21 +23,21 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private CrackResult result;
private IGetTupleInputDatasLogic datasLogic;
private CrackCalculatorUpdateStrategy updateStrategy = new();
private ICheckInputDataLogic<CrackInputData> checkInputDataLogic;
private ICheckInputDataLogic<CrackCalculatorInputData> checkInputDataLogic;
public string Name { get; set; }
public CrackInputData InputData { get; set; }
public CrackCalculatorInputData InputData { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public CrackCalculator(CrackInputData inputData, ICheckInputDataLogic<CrackInputData> checkInputDataLogic)
public CrackCalculator(CrackCalculatorInputData inputData, ICheckInputDataLogic<CrackCalculatorInputData> checkInputDataLogic)
{
InputData = inputData;
this.checkInputDataLogic = checkInputDataLogic;
Name = string.Empty;
}
public CrackCalculator(CrackInputData inputData)
public CrackCalculator(CrackCalculatorInputData inputData)
: this(inputData,
new CheckCrackCalculatorInputDataLogic()
{ InputData = inputData}
@@ -45,7 +45,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
public object Clone()
{
CrackInputData crackInputData = new CrackInputData();
CrackCalculatorInputData crackInputData = new CrackCalculatorInputData();
var checkDataLogic = new CheckCrackCalculatorInputDataLogic()
{
InputData = InputData

4
StructureHelperLogics/NdmCalculations/Cracking/CrackInputData.cs → StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs
View File

@@ -10,14 +10,14 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackInputData : IInputData, IHasPrimitives, IHasForceCombinations
public class CrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations
{
/// <inheritdoc/>
public List<INdmPrimitive> Primitives { get; private set; }
/// <inheritdoc/>
public List<IForceAction> ForceActions { get; private set; }
public UserCrackInputData UserCrackInputData { get; set; }
public CrackInputData()
public CrackCalculatorInputData()
{
Primitives = new();
ForceActions = new();

4
StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs
View File

@@ -10,9 +10,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackCalculatorUpdateStrategy : IUpdateStrategy<CrackCalculator>
{
private IUpdateStrategy<CrackInputData> inputDataUpdateStrategy;
private IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy;
public CrackCalculatorUpdateStrategy(IUpdateStrategy<CrackInputData> inputDataUpdateStrategy)
public CrackCalculatorUpdateStrategy(IUpdateStrategy<CrackCalculatorInputData> inputDataUpdateStrategy)
{
this.inputDataUpdateStrategy = inputDataUpdateStrategy;
}

104
StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculator.cs → StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs
View File

@@ -1,5 +1,6 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Infrastructures.Settings;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
@@ -11,9 +12,10 @@ using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackForceCalculator : ICalculator
public class CrackForceBynarySearchCalculator : ICrackForceCalculator
{
private CrackedLogic crackedLogic;
private IIsSectionCrackedByFactorLogic crackedByFactorLogic;
private ICheckInputDataLogic<ICrackForceCalculatorInputData> checkInputDataLogic;
ExpSofteningLogic softeningLogic = new();
static readonly CrackStrainLogic crackStrainLogic = new();
static readonly SofteningFactorLogic softeningFactorLogic = new();
@@ -22,64 +24,72 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private FindParameterCalculator parameterCalculator;
public string Name { get; set; }
public IForceTuple StartTuple { get; set; }
public IForceTuple EndTuple { get; set; }
public IEnumerable<INdm> NdmCollection { get; set; }
public Accuracy Accuracy {get;set; }
public ICrackForceCalculatorInputData InputData { get; set; }
public Accuracy Accuracy { get; set; }
public IResult Result => result;
public IShiftTraceLogger? TraceLogger { get; set; }
public CrackForceCalculator(CrackedLogic crackedLogic)
public CrackForceBynarySearchCalculator(
IIsSectionCrackedByFactorLogic crackedByFactorLogic,
ICheckInputDataLogic<ICrackForceCalculatorInputData> checkInputDataLogic
)
{
StartTuple ??= new ForceTuple();
Accuracy ??= new Accuracy() { IterationAccuracy = 0.0001d, MaxIterationCount = 10000 };
this.crackedByFactorLogic = crackedByFactorLogic;
this.checkInputDataLogic = checkInputDataLogic;
Accuracy ??= new Accuracy()
{
IterationAccuracy = 0.0001d,
MaxIterationCount = 10000
};
forceTupleCalculator = new ForceTupleCalculator();
this.crackedLogic = crackedLogic;
InputData = new CrackForceCalculatorInputData();
}
public CrackForceCalculator() : this(new CrackedLogic())
public CrackForceBynarySearchCalculator() : this(new IsSectionCrackedByFactorLogic(), new CheckCrackForceCalculatorInputData())
{
}
public void Run()
{
parameterCalculator = new FindParameterCalculator()
{
Accuracy = Accuracy,
Predicate = crackedLogic.IsSectionCracked
};
PrepareNewResult();
if (CheckInputData() == false) { return; }
parameterCalculator = new FindParameterCalculator();
parameterCalculator.InputData.Predicate = crackedByFactorLogic.IsSectionCracked;
if (TraceLogger is not null)
{
forceTupleCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(100);
parameterCalculator.TraceLogger = TraceLogger.GetSimilarTraceLogger(50);
crackedLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(150);
crackedByFactorLogic.TraceLogger = TraceLogger.GetSimilarTraceLogger(150);
}
TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service);
result = new CrackForceResult();
TraceLogger?.AddMessage($"Start force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(StartTuple));
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.StartTuple));
TraceLogger?.AddMessage($"Actual (end) force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(EndTuple));
crackedLogic.StartTuple = StartTuple;
crackedLogic.EndTuple = EndTuple;
crackedLogic.NdmCollection = NdmCollection;
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(InputData.EndTuple));
crackedByFactorLogic.IsSectionCrackedByForceLogic = new IsSectionCrackedByForceLogic()
{
CheckedNdmCollection = InputData.CheckedNdmCollection,
SectionNdmCollection = InputData.SectionNdmCollection,
};
crackedByFactorLogic.StartTuple = InputData.StartTuple;
crackedByFactorLogic.EndTuple = InputData.EndTuple;
try
{
Check();
CheckInputData();
}
catch(Exception ex)
catch (Exception ex)
{
result.IsValid = false;
result.Description += ex;
return;
}
if (crackedLogic.IsSectionCracked(0d) == true)
if (crackedByFactorLogic.IsSectionCracked(0d) == true)
{
TraceLogger?.AddMessage($"Crack is appeared in start corce combination", TraceLogStatuses.Warning);
TraceLogger?.AddMessage($"Crack is appeared in start force combination", TraceLogStatuses.Warning);
SectionCrackedAtStart();
return;
}
if (crackedLogic.IsSectionCracked(1d) == false)
if (crackedByFactorLogic.IsSectionCracked(1d) == false)
{
TraceLogger?.AddMessage($"Crack is not appeared from actual (end) force combination", TraceLogStatuses.Warning);
SectionIsNotCracked();
@@ -100,6 +110,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
}
}
private void PrepareNewResult()
{
result = new CrackForceResult();
}
private void SectionIsCrackedBetween(FindParameterResult? paramResult)
{
var factorOfCrackAppearance = paramResult.Parameter;
@@ -111,11 +126,11 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
}
softeningLogic.ForceRatio = factorOfCrackAppearance;
var psiS = softeningLogic.GetSofteningFactor();
var tupleOfCrackApeearence = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance);
var tupleOfCrackApeearence = ForceTupleService.InterpolateTuples(InputData.EndTuple, InputData.StartTuple, factorOfCrackAppearance);
TraceLogger?.AddMessage($"Crack is appeared in force combination");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(tupleOfCrackApeearence));
var reducedStrainTuple = GetReducedStrainTuple(factorOfCrackAppearance, psiS);
var crackedStrainTuple = GetStrainTuple(EndTuple);
var crackedStrainTuple = GetStrainTuple(InputData.EndTuple);
TraceLogger?.AddMessage($"Strains in cracked section from actual (end) force");
TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(crackedStrainTuple));
TraceLogger?.AddMessage($"Average strains of cracked part of element");
@@ -129,14 +144,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
result.TupleOfCrackAppearance = tupleOfCrackApeearence;
result.CrackedStrainTuple = crackedStrainTuple;
result.ReducedStrainTuple = reducedStrainTuple;
result.SofteningFactors= softeningFactors;
result.SofteningFactors = softeningFactors;
result.PsiS = psiS;
TraceLogger?.AddMessage($"Valid result was obtained", TraceLogStatuses.Debug);
}
private StrainTuple GetSofteningFactors(StrainTuple reducedStrainTuple)
{
softeningFactorLogic.NdmCollection = NdmCollection;
softeningFactorLogic.NdmCollection = InputData.SectionNdmCollection;
softeningFactorLogic.StrainTuple = reducedStrainTuple;
return softeningFactorLogic.GetSofteningFactors();
}
@@ -144,9 +159,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private StrainTuple GetReducedStrainTuple(double factorOfCrackAppearance, double softeningFactor)
{
const double notCrackedForceFactor = 0.99d;
var notCrackedForceTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple;
var notCrackedForceTuple = ForceTupleService.InterpolateTuples(InputData.EndTuple, InputData.StartTuple, factorOfCrackAppearance * notCrackedForceFactor) as ForceTuple;
var crackAppearanceStrainTuple = GetStrainTuple(notCrackedForceTuple);
var actualStrainTuple = GetStrainTuple(EndTuple);
var actualStrainTuple = GetStrainTuple(InputData.EndTuple);
crackStrainLogic.BeforeCrackingTuple = crackAppearanceStrainTuple;
crackStrainLogic.AfterCrackingTuple = actualStrainTuple;
crackStrainLogic.SofteningFactor = softeningFactor;
@@ -160,10 +175,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
result.IsValid = true;
result.FactorOfCrackAppearance = 0d;
result.TupleOfCrackAppearance = (IForceTuple)StartTuple.Clone();
result.TupleOfCrackAppearance = (IForceTuple)InputData.StartTuple.Clone();
softeningLogic.ForceRatio = result.FactorOfCrackAppearance;
result.PsiS = softeningLogic.GetSofteningFactor();
result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(EndTuple);
result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(InputData.EndTuple);
result.SofteningFactors = GetSofteningFactors(result.ReducedStrainTuple);
result.IsSectionCracked = true;
result.Description += "Section cracked in start tuple";
@@ -172,14 +187,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
result.IsValid = true;
result.IsSectionCracked = false;
result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(EndTuple);
result.CrackedStrainTuple = result.ReducedStrainTuple = GetStrainTuple(InputData.EndTuple);
result.SofteningFactors = GetSofteningFactors(result.ReducedStrainTuple);
result.Description = "Section is not cracked";
}
private StrainTuple GetStrainTuple(IForceTuple forceTuple)
{
ForceTupleInputData inputData = new();
inputData.NdmCollection = NdmCollection;
inputData.NdmCollection = InputData.SectionNdmCollection;
inputData.Tuple = forceTuple;
forceTupleCalculator.InputData = inputData;
forceTupleCalculator.Run();
@@ -188,13 +203,16 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
StrainTuple strainTuple = TupleConverter.ConvertToStrainTuple(loaderStrainMatrix);
return strainTuple;
}
private void Check()
private bool CheckInputData()
{
CheckObject.IsNull(EndTuple);
if (StartTuple == EndTuple)
checkInputDataLogic.InputData = InputData;
if (checkInputDataLogic.Check() == false)
{
throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": Section is not cracked");
result.IsValid = false;
result.Description += checkInputDataLogic.CheckResult;
return false;
}
return true;
}
public object Clone()
{

24
StructureHelperLogics/NdmCalculations/Cracking/CrackForceCalculatorInputData.cs Normal file
View File

@@ -0,0 +1,24 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackForceCalculatorInputData : ICrackForceCalculatorInputData
{
public IForceTuple StartTuple { get; set; }
public IForceTuple EndTuple { get; set; }
public IEnumerable<INdm> CheckedNdmCollection { get; set; }
public IEnumerable<INdm> SectionNdmCollection { get; set; }
public CrackForceCalculatorInputData()
{
StartTuple = new ForceTuple();
EndTuple = new ForceTuple();
}
}
}

30
StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs Normal file
View File

@@ -0,0 +1,30 @@
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackForceSteppedSearchCalculator : ICrackForceCalculator
{
public ICrackForceCalculatorInputData InputData { get; set; }
public string Name { get; set; }
public IResult Result => throw new NotImplementedException();
public IShiftTraceLogger? TraceLogger { get; set; }
public object Clone()
{
throw new NotImplementedException();
}
public void Run()
{
throw new NotImplementedException();
}
}
}

4
StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs
View File

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackInputDataUpdateStrategy : IUpdateStrategy<CrackInputData>
public class CrackInputDataUpdateStrategy : IUpdateStrategy<CrackCalculatorInputData>
{
private IUpdateStrategy<UserCrackInputData> userCrackInputDataUpdateStrategy;
public CrackInputDataUpdateStrategy(IUpdateStrategy<UserCrackInputData> userCrackInputDataUpdateStrategy)
@@ -20,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
}
public void Update(CrackInputData targetObject, CrackInputData sourceObject)
public void Update(CrackCalculatorInputData targetObject, CrackCalculatorInputData sourceObject)
{
if (ReferenceEquals(targetObject, sourceObject)) { return; }
CheckObject.CompareTypes(targetObject, sourceObject);

2
StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs
View File

@@ -10,7 +10,7 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
/// <inheritdoc/>
public class CrackedConcreteNdmLogic : ISectionCrackedLogic
public class CrackedConcreteNdmLogic : IIsSectionCrackedByForceLogic
{
/// <inheritdoc/>
public INdm ConcreteNdm { get; set; }

2
StructureHelperLogics/NdmCalculations/Cracking/Factories/CrackWidthLogicInputDataFactory.cs
View File

@@ -58,7 +58,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
data.PsiSFactor = softeningLogic.GetSofteningFactor();
data.StressStateFactor = stressStateFactorLogic.GetStressStateFactor();
data.BondFactor = 0.5d;
data.Length = InputData.Length;
data.Length = InputData.LengthBeetwenCracks;
data.ConcreteStrain = ConcreteStrain;
data.RebarStrain = RebarStrain;
return data;

10
StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculator.cs Normal file
View File

@@ -0,0 +1,10 @@
using StructureHelperCommon.Models.Calculators;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public interface ICrackForceCalculator : ICalculator
{
ICrackForceCalculatorInputData InputData { get; set; }
string Name { get; set; }
}
}

9
StructureHelperLogics/NdmCalculations/Cracking/ICrackedLogic.cs → StructureHelperLogics/NdmCalculations/Cracking/ICrackForceCalculatorInputData.cs
View File

@@ -1,5 +1,5 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
@@ -9,11 +9,12 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
internal interface ICrackedLogic : ILogic
public interface ICrackForceCalculatorInputData: IInputData
{
IForceTuple StartTuple { get; set; }
IForceTuple EndTuple { get; set; }
IEnumerable<INdm> NdmCollection { get; set; }
bool IsSectionCracked(double factor);
IEnumerable<INdm> CheckedNdmCollection { get; set; }
IEnumerable<INdm> SectionNdmCollection { get; set; }
}
}

15
StructureHelperLogics/NdmCalculations/Cracking/ICrackWidthTupleResult.cs
View File

@@ -1,12 +1,23 @@
namespace StructureHelperLogics.NdmCalculations.Cracking
using StructureHelperCommon.Models.Forces;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
/// <summary>
///
/// </summary>
public interface ICrackWidthTupleResult
{
/// <summary>
/// Calculated crack width
/// Calculated crack width, m
/// </summary>
double CrackWidth { get; set; }
/// <summary>
/// True if actual crack width less than limit one
/// </summary>
bool IsCrackLessThanUltimate { get; }
/// <summary>
/// Limit crack width, m
/// </summary>
double UltimateCrackWidth { get; set; }
}
}

34
StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByFactorLogic.cs Normal file
View File

@@ -0,0 +1,34 @@
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
/// <summary>
/// Check crack appearence beetwen start force tuple and end force tuple
/// </summary>
public interface IIsSectionCrackedByFactorLogic : ILogic
{
IIsSectionCrackedByForceLogic IsSectionCrackedByForceLogic { get; set; }
/// <summary>
/// Start force tupple
/// </summary>
IForceTuple StartTuple { get; set; }
/// <summary>
/// End force tuple
/// </summary>
IForceTuple EndTuple { get; set; }
/// <summary>
/// Returns result of checking of crack appearence
/// </summary>
/// <param name="factor">factor beetwen start and end tuple, 0 is start tuple, 1 is end tuple</param>
/// <returns>true when section is cracked</returns>
bool IsSectionCracked(double factor);
}
}

4
StructureHelperLogics/NdmCalculations/Cracking/ISectionCrackedLogic.cs → StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs
View File

@@ -12,14 +12,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
/// <summary>
/// Logic for checking collection of ndms for appearance of crack
/// </summary>
public interface ISectionCrackedLogic : ILogic
public interface IIsSectionCrackedByForceLogic : ILogic
{
/// <summary>
/// Force tuple for checking of cracks appearence
/// </summary>
IForceTuple Tuple { get; set; }
/// <summary>
/// Collection of ndms which is checking fo cracking
/// Collection of ndms which is checking for cracking
/// </summary>
IEnumerable<INdm> CheckedNdmCollection { get; set; }
/// <summary>

21
StructureHelperLogics/NdmCalculations/Cracking/CrackedLogic.cs → StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs
View File

@@ -11,30 +11,29 @@ using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class CrackedLogic : ICrackedLogic
public class IsSectionCrackedByFactorLogic : IIsSectionCrackedByFactorLogic
{
private ISectionCrackedLogic sectionCrackedLogic;
public IIsSectionCrackedByForceLogic IsSectionCrackedByForceLogic { get; set; }
public IForceTuple StartTuple { get; set; }
public IForceTuple EndTuple { get; set; }
public IEnumerable<INdm> NdmCollection { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public CrackedLogic(ISectionCrackedLogic sectionLogic)
public IsSectionCrackedByFactorLogic(IIsSectionCrackedByForceLogic sectionLogic)
{
sectionCrackedLogic = sectionLogic;
IsSectionCrackedByForceLogic = sectionLogic;
}
public CrackedLogic() : this (new SectionCrackedLogic())
public IsSectionCrackedByFactorLogic() : this(new IsSectionCrackedByForceLogic())
{
}
public bool IsSectionCracked(double factor)
{
sectionCrackedLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50);
IsSectionCrackedByForceLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50);
var actualTuple = ForceTupleService.InterpolateTuples(EndTuple, StartTuple, factor);
sectionCrackedLogic.Tuple = actualTuple;
sectionCrackedLogic.SectionNdmCollection = NdmCollection;
return sectionCrackedLogic.IsSectionCracked();
IsSectionCrackedByForceLogic.Tuple = actualTuple;
return IsSectionCrackedByForceLogic.IsSectionCracked();
}
}
}

15
StructureHelperLogics/NdmCalculations/Cracking/SectionCrackedLogic.cs → StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs
View File

@@ -10,16 +10,17 @@ using System.Diagnostics.Eventing.Reader;
namespace StructureHelperLogics.NdmCalculations.Cracking
{
/// <inheritdoc/>
internal class SectionCrackedLogic : ISectionCrackedLogic
internal class IsSectionCrackedByForceLogic : IIsSectionCrackedByForceLogic
{
static readonly IStressLogic stressLogic = new StressLogic();
/// <inheritdoc/>
public IForceTuple Tuple { get; set; }
public IEnumerable<INdm> CheckedNdmCollection { get; set; }
public IEnumerable<INdm> SectionNdmCollection { get; set; }
public Accuracy Accuracy { get; set; }
public IShiftTraceLogger? TraceLogger { get; set; }
public SectionCrackedLogic()
public IsSectionCrackedByForceLogic()
{
if (Accuracy is null)
{
@@ -56,15 +57,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
}
var strainMatrix = calcResult.LoaderResults.ForceStrainPair.StrainMatrix;
IEnumerable<INdm> checkedNdmCollection;
if (CheckedNdmCollection is null)
{
checkedNdmCollection = SectionNdmCollection;
}
else
{
checkedNdmCollection = CheckedNdmCollection;
}
var isSectionCracked = stressLogic.IsSectionCracked(strainMatrix, checkedNdmCollection);
var isSectionCracked = stressLogic.IsSectionCracked(strainMatrix, CheckedNdmCollection);
if (isSectionCracked == true)
{
TraceLogger?.AddMessage($"Cracks are appeared in cross-section for current force combination");

14
StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputData.cs
View File

@@ -13,9 +13,21 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
{
public class RebarCrackInputData : IInputData
{
/// <summary>
/// Collection of ndms where work of crackable material in tension was assigned according to material properties
/// </summary>
public IEnumerable<INdm> CrackableNdmCollection { get; set; }
/// <summary>
/// Collection of ndms where work of concrete is disabled
/// </summary>
public IEnumerable<INdm> CrackedNdmCollection { get; set; }
/// <summary>
/// Force tuple for calculation
/// </summary>
public ForceTuple ForceTuple { get; set; }
public double Length { get; set; }
/// <summary>
/// Base length beetwen cracks
/// </summary>
public double LengthBeetwenCracks { get; set; }
}
}

4
StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs
View File

@@ -54,14 +54,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
CrackableNdmCollection = crackableNdmsLoc,
CrackedNdmCollection = crackedNdmsLoc,
ForceTuple = InputData.LongTermTuple.Clone() as ForceTuple,
Length = LongLength
LengthBeetwenCracks = LongLength
};
var shortRebarData = new RebarCrackInputData()
{
CrackableNdmCollection = crackableNdmsLoc,
CrackedNdmCollection = crackedNdmsLoc,
ForceTuple = InputData.ShortTermTuple.Clone() as ForceTuple,
Length = ShortLength
LengthBeetwenCracks = ShortLength
};
var rebarCalculatorData = new RebarCrackCalculatorInputData()
{

20
StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs
View File

@@ -148,22 +148,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
private CrackForceResult calculateCrackTuples(ForceTuple forceTuple, IEnumerable<INdm> ndms)
{
var sectionCrackedLogic = new SectionCrackedLogic()
var calculator = new CrackForceBynarySearchCalculator()
{
SectionNdmCollection = ndms,
CheckedNdmCollection = new List<INdm>() { concreteNdm },
//TraceLogger = TraceLogger?.GetSimilarTraceLogger(100)
};
var crackedLogis = new CrackedLogic(sectionCrackedLogic)
{
StartTuple = new ForceTuple(),
EndTuple = forceTuple,
//TraceLogger = TraceLogger?.GetSimilarTraceLogger(100)
};
var calculator = new CrackForceCalculator(crackedLogis)
{
NdmCollection = ndms,
EndTuple = forceTuple,
Accuracy = new Accuracy()
{
IterationAccuracy = 0.01d,
@@ -171,6 +157,10 @@ namespace StructureHelperLogics.NdmCalculations.Cracking
},
//TraceLogger = TraceLogger?.GetSimilarTraceLogger(150)
};
calculator.InputData.StartTuple = new ForceTuple();
calculator.InputData.EndTuple = forceTuple;
calculator.InputData.CheckedNdmCollection = new List<INdm>() { concreteNdm };
calculator.InputData.SectionNdmCollection = ndms;
calculator.Run();
return calculator.Result as CrackForceResult;
}

6
StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs
View File

@@ -66,9 +66,11 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
CenterX = options.Center.X,
CenterY = options.Center.Y,
Area = options.Area,
//Area = options.Area, //to do solve problem with additional concrete ndm
Area = 0,//options.Area, //to do solve problem with additional concrete ndm
Material = material,
StressScale = -1d
//StressScale = -1d
StressScale = 1d//-1d
};
NdmTransform.SetPrestrain(concreteNdm, TupleConverter.ConvertToLoaderStrainMatrix(prestrain));
return concreteNdm;

6
StructureHelperTests/FunctionalTests/Ndms/Calculators/CrackCalculatorTests/CrackCalculatorTest.cs
View File

@@ -34,9 +34,9 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.CrackCalculatorT
CalcTerm = CalcTerms.ShortTerm
};
var ndms = triangulateLogic.GetNdms();
var calculator = new CrackForceCalculator();
calculator.EndTuple = new ForceTuple() { Mx = -50e3d, My = -50e3d, Nz = 0d };
calculator.NdmCollection = ndms;
var calculator = new CrackForceBynarySearchCalculator();
calculator.InputData.EndTuple = new ForceTuple() { Mx = -50e3d, My = -50e3d, Nz = 0d };
calculator.InputData.CheckedNdmCollection = calculator.InputData.SectionNdmCollection = ndms;
//Act
calculator.Run();
var result = (CrackForceResult)calculator.Result;

136
StructureHelperTests/UnitTests/Calcuators/CheckForceTupleInputDataLogicTests.cs Normal file
View File

@@ -0,0 +1,136 @@
using NUnit.Framework;
using Moq;
using System.Collections.Generic;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Primitives;
using LoaderCalculator.Data.Ndms;
using StructureHelperCommon.Models.Forces;
namespace StructureHelperTests.UnitTests.Calcuators
{
[TestFixture]
public class CheckForceTupleInputDataLogicTests
{
private Mock<IForceTupleInputData> _mockInputData;
private Mock<IShiftTraceLogger> _mockTraceLogger;
private CheckForceTupleInputDataLogic _checkLogic;
[SetUp]
public void SetUp()
{
_mockInputData = new Mock<IForceTupleInputData>();
_mockTraceLogger = new Mock<IShiftTraceLogger>();
_checkLogic = new CheckForceTupleInputDataLogic(_mockInputData.Object, _mockTraceLogger.Object);
}
[Test]
public void Check_InputDataIsNull_ThrowsStructureHelperException()
{
// Arrange
_checkLogic = new CheckForceTupleInputDataLogic(null, _mockTraceLogger.Object);
// Act & Assert
var ex = Assert.Throws<StructureHelperException>(() => _checkLogic.Check());
Assert.That(ex.Message, Is.EqualTo(ErrorStrings.ParameterIsNull + ": Input data"));
_mockTraceLogger.Verify(x => x.AddMessage(ErrorStrings.ParameterIsNull + ": Input data"), Times.Once);
}
[Test]
public void Check_NdmCollectionIsNullOrEmpty_ReturnsFalseAndLogsError()
{
// Arrange
_mockInputData.Setup(x => x.NdmCollection).Returns((IEnumerable<INdm>)null);
// Act
var result = _checkLogic.Check();
// Assert
Assert.IsFalse(result);
//Assert.That(_checkLogic.CheckResult, Is.EqualTo("Ndm collection is null or empty"));
_mockTraceLogger.Verify(x => x.AddMessage("\nNdm collection is null or empty"), Times.Once);
}
[Test]
public void Check_TupleIsNull_ReturnsFalseAndLogsError()
{
// Arrange
_mockInputData.Setup(x => x.NdmCollection).Returns(new List<INdm>());
_mockInputData.Setup(x => x.Tuple).Returns((IForceTuple)null);
// Act
var result = _checkLogic.Check();
// Assert
Assert.IsFalse(result);
//Assert.That(_checkLogic.CheckResult, Is.EqualTo("Force tuple is null"));
_mockTraceLogger.Verify(x => x.AddMessage("\nForce tuple is null"), Times.Once);
}
[Test]
public void Check_AccuracyIsNull_ReturnsFalseAndLogsError()
{
// Arrange
_mockInputData.Setup(x => x.NdmCollection).Returns(new List<INdm>());
_mockInputData.Setup(x => x.Tuple).Returns(new ForceTuple());
_mockInputData.Setup(x => x.Accuracy).Returns((IAccuracy)null);
// Act
var result = _checkLogic.Check();
// Assert
Assert.IsFalse(result);
//Assert.That(_checkLogic.CheckResult, Is.EqualTo("Accuracy requirements is not assigned"));
_mockTraceLogger.Verify(x => x.AddMessage("\nAccuracy requirements is not assigned"), Times.Once);
}
[Test]
public void Check_AccuracyValuesAreInvalid_ReturnsFalseAndLogsErrors()
{
// Arrange
var mockAccuracy = new Mock<IAccuracy>();
mockAccuracy.Setup(x => x.IterationAccuracy).Returns(0);
mockAccuracy.Setup(x => x.MaxIterationCount).Returns(0);
_mockInputData.Setup(x => x.NdmCollection).Returns(new List<INdm>());
_mockInputData.Setup(x => x.Tuple).Returns(new ForceTuple());
_mockInputData.Setup(x => x.Accuracy).Returns(mockAccuracy.Object);
// Act
var result = _checkLogic.Check();
// Assert
Assert.IsFalse(result);
//Assert.That(_checkLogic.CheckResult, Is.EqualTo("Value of accuracy 0 must be grater than zeroMax number of iteration 0 must be grater than zero"));
_mockTraceLogger.Verify(x => x.AddMessage("\nValue of accuracy 0 must be grater than zero"), Times.Once);
_mockTraceLogger.Verify(x => x.AddMessage("\nMax number of iteration 0 must be grater than zero"), Times.Once);
}
[Test]
public void Check_AllConditionsMet_ReturnsTrue()
{
// Arrange
var mockAccuracy = new Mock<IAccuracy>();
mockAccuracy.Setup(x => x.IterationAccuracy).Returns(1);
mockAccuracy.Setup(x => x.MaxIterationCount).Returns(10);
_mockInputData.Setup(x => x.NdmCollection).Returns(new List<INdm> { new Mock<INdm>().Object });
_mockInputData.Setup(x => x.Tuple).Returns(new ForceTuple());
_mockInputData.Setup(x => x.Accuracy).Returns(mockAccuracy.Object);
// Act
var result = _checkLogic.Check();
// Assert
Assert.IsTrue(result);
Assert.That(_checkLogic.CheckResult, Is.EqualTo(string.Empty));
}
}
}

25
StructureHelperTests/UnitTests/Calcuators/FindParameterTest.cs
View File

@@ -7,15 +7,14 @@ namespace StructureHelperTests.UnitTests.Calcuators
{
[TestCase(0d, 1d, 0.5d, 0.5d)]
[TestCase(0d, 10d, 5d, 5d)]
public void Run_ShouldPass_Valid(double startValue, double EndValue, double predicateValue, double expectedValue)
public void Run_ShouldPass_Valid(double startValue, double endValue, double predicateValue, double expectedValue)
{
//Arrange
var calculator = new FindParameterCalculator()
{
StartValue = startValue,
EndValue = EndValue,
Predicate = x => x > predicateValue
};
var calculator = new FindParameterCalculator();
calculator.InputData.StartValue = startValue;
calculator.InputData.EndValue = endValue; ;
calculator.InputData.Predicate = x => x > predicateValue;
//Act
calculator.Run();
var result = calculator.Result as FindParameterResult;
@@ -26,15 +25,13 @@ namespace StructureHelperTests.UnitTests.Calcuators
}
[TestCase(0d, 1d, 5d, 5d, false)]
[TestCase(0d, 10d, 15d, 15d, false)]
public void Run_ShouldPass_NotValid(double startValue, double EndValue, double predicateValue, double expectedValue, bool isValid)
public void Run_ShouldPass_NotValid(double startValue, double endValue, double predicateValue, double expectedValue, bool isValid)
{
//Arrange
var calculator = new FindParameterCalculator()
{
StartValue = startValue,
EndValue = EndValue,
Predicate = x => x > predicateValue
};
var calculator = new FindParameterCalculator();
calculator.InputData.StartValue = startValue;
calculator.InputData.EndValue = endValue; ;
calculator.InputData.Predicate = x => x > predicateValue;
//Act
calculator.Run();
var result = calculator.Result as FindParameterResult;