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

Add calculators cloning logic

Browse Source
This commit is contained in:
Evgeny Redikultsev
2024-12-07 20:50:21 +05:00
parent ccaf9a927c
commit 0538c6b53c
18 changed files with 776 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryCloneStrategy.cs
View File

@@ -42,8 +42,7 @@ namespace StructureHelperLogics.Models.CrossSections
new HasMaterialsUpdateCloningStrategy(null),
new HasPrimitivesUpdateCloningStrategy(null),
new HasCalculatorsUpdateCloningStrategy(null))
{
{
forcesUpdateStrategy = new HasForceActionUpdateCloningStrategy(cloningStrategy);
materialsUpdateStrategy = new HasMaterialsUpdateCloningStrategy(cloningStrategy);
primitivesUpdateStrategy = new HasPrimitivesUpdateCloningStrategy(cloningStrategy);

2
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/ILimitCurvesCalculator.cs
View File

@@ -6,7 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public interface ILimitCurvesCalculator : ISaveable, ICalculator, IHasActionByResult
{
LimitCurvesCalculatorInputData InputData { get; set; }
ILimitCurvesCalculatorInputData InputData { get; set; }
string Name { get; set; }
}
}

4
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculator.cs
View File

@@ -21,7 +21,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public Guid Id { get; }
public string Name { get; set; }
public LimitCurvesCalculatorInputData InputData { get; set; }
public ILimitCurvesCalculatorInputData InputData { get; set; }
public IResult Result => result;
public Action<IResult> ActionToOutputResults { get; set; }
@@ -30,7 +30,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public LimitCurvesCalculator()
{
Name = "New calculator";
InputData = new();
InputData = new LimitCurvesCalculatorInputData();
}
public void Run()
{

1
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorInputDataUpdateStrategy.cs
View File

@@ -19,6 +19,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.LimitStates.Clear();
targetObject.CalcTerms.Clear();
targetObject.PrimitiveSeries.Clear();
targetObject.PredicateEntries.Clear();
targetObject.LimitStates.AddRange(sourceObject.LimitStates);
targetObject.CalcTerms.AddRange(sourceObject.CalcTerms);

58
StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurvesCalculatorUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,58 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Parameters;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve
{
/// <summary>
/// Creates deep copy of limit curves calculator
/// </summary>
public class LimitCurvesCalculatorUpdateCloningStrategy : IUpdateStrategy<ILimitCurvesCalculator>
{
private ICloningStrategy cloningStrategy;
private IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy;
public LimitCurvesCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this (
cloningStrategy,
new LimitCurvesCalculatorInputDataUpdateStrategy())
{
this.cloningStrategy = cloningStrategy;
}
public LimitCurvesCalculatorUpdateCloningStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.limitCurvesInputDataUpdateStrategy = limitCurvesInputDataUpdateStrategy;
}
public void Update(ILimitCurvesCalculator targetObject, ILimitCurvesCalculator sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
var targetData = targetObject.InputData;
limitCurvesInputDataUpdateStrategy.Update(targetData, sourceObject.InputData);
foreach (var series in targetData.PrimitiveSeries)
{
List<INdmPrimitive> collection = UpdatePrimitivesCollection(series);
series.Collection.AddRange(collection);
}
}
private List<INdmPrimitive> UpdatePrimitivesCollection(NamedCollection<INdmPrimitive> series)
{
List<INdmPrimitive> collection = new();
foreach (var item in series.Collection)
{
var newItem = cloningStrategy.Clone(item);
collection.Add(newItem);
}
series.Collection.Clear();
return collection;
}
}
}

46
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CrackCalculatorUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,46 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
{
/// <summary>
/// Creates deep copy of crack calculator
/// </summary>
public class CrackCalculatorUpdateCloningStrategy : IUpdateStrategy<ICrackCalculator>
{
private ICloningStrategy cloningStrategy;
private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
public CrackCalculatorUpdateCloningStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
}
public CrackCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this (
cloningStrategy,
new HasForceActionUpdateCloningStrategy(cloningStrategy),
new HasPrimitivesUpdateCloningStrategy(cloningStrategy))
{
}
public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
var sourceData = sourceObject.InputData;
var targetData = targetObject.InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
}
}
}

44
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,44 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
{
/// <summary>
/// Creates deep copy of force calculator
/// </summary>
public class ForceCalculatorUpdateCloningStrategy : IUpdateStrategy<IForceCalculator>
{
private readonly ICloningStrategy cloningStrategy;
private readonly IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private readonly IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
public ForceCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy,
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
}
public ForceCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this (
cloningStrategy,
new HasForceActionUpdateCloningStrategy(cloningStrategy),
new HasPrimitivesUpdateCloningStrategy(cloningStrategy))
{
}
public void Update(IForceCalculator targetObject, IForceCalculator sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
var sourceData = sourceObject.InputData;
var targetData = targetObject.InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
}
}
}

73
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs
View File

@@ -4,6 +4,7 @@ using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Parameters;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
@@ -16,29 +17,29 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public class HasCalculatorsUpdateCloningStrategy : IUpdateStrategy<IHasCalculators>
{
private ICloningStrategy cloningStrategy;
private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
private IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy;
private IUpdateStrategy<IForceCalculator> forceCalculatorUpdateStrategy;
private IUpdateStrategy<ICrackCalculator> crackCalculatorUpdateStrategy;
private IUpdateStrategy<ILimitCurvesCalculator> limitCurvesCalculatorUpdateStrategy;
public HasCalculatorsUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
cloningStrategy,
new HasForceActionUpdateCloningStrategy(cloningStrategy),
new HasPrimitivesUpdateCloningStrategy(cloningStrategy),
new LimitCurvesCalculatorInputDataUpdateStrategy()
new ForceCalculatorUpdateCloningStrategy(cloningStrategy),
new CrackCalculatorUpdateCloningStrategy(cloningStrategy),
new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy)
)
{
}
public HasCalculatorsUpdateCloningStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy,
IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy)
IUpdateStrategy<IForceCalculator> forceCalculatorUpdateStrategy,
IUpdateStrategy<ICrackCalculator> crackCalculatorUpdateStrategy,
IUpdateStrategy<ILimitCurvesCalculator> limitCurvesCalculatorUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
this.limitCurvesInputDataUpdateStrategy = limitCurvesInputDataUpdateStrategy;
this.forceCalculatorUpdateStrategy = forceCalculatorUpdateStrategy;
this.crackCalculatorUpdateStrategy = crackCalculatorUpdateStrategy;
this.limitCurvesCalculatorUpdateStrategy = limitCurvesCalculatorUpdateStrategy;
}
public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
@@ -53,15 +54,15 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
var newCalculator = cloningStrategy.Clone(calculator);
if (calculator is IForceCalculator forceCalculator)
{
ProcessForceCalculator(newCalculator, forceCalculator);
forceCalculatorUpdateStrategy.Update(newCalculator as IForceCalculator, forceCalculator);
}
else if (calculator is CrackCalculator crackCalculator)
else if (calculator is ICrackCalculator crackCalculator)
{
ProcessCrackCalculator(newCalculator, crackCalculator);
crackCalculatorUpdateStrategy.Update(newCalculator as ICrackCalculator, crackCalculator);
}
else if (calculator is ILimitCurvesCalculator limitCalculator)
{
ProcessLimitCurvesCalculator(newCalculator, limitCalculator);
limitCurvesCalculatorUpdateStrategy.Update(newCalculator as ILimitCurvesCalculator, limitCalculator);
}
else
{
@@ -70,45 +71,5 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
targetObject.Calculators.Add(newCalculator);
}
}
private void ProcessLimitCurvesCalculator(ICalculator newCalculator, ILimitCurvesCalculator limitCalculator)
{
var sourceData = limitCalculator.InputData;
var targetData = ((ILimitCurvesCalculator)newCalculator).InputData;
limitCurvesInputDataUpdateStrategy.Update(targetData, sourceData);
foreach (var series in targetData.PrimitiveSeries)
{
List<INdmPrimitive> collection = UpdatePrimitivesCollection(series);
series.Collection.AddRange(collection);
}
}
private void ProcessCrackCalculator(ICalculator newCalculator, CrackCalculator crackCalculator)
{
var sourceData = crackCalculator.InputData;
var targetData = ((ICrackCalculator)newCalculator).InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
}
private void ProcessForceCalculator(ICalculator newCalculator, IForceCalculator forceCalculator)
{
var sourceData = forceCalculator.InputData;
var targetData = ((IForceCalculator)newCalculator).InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
}
private List<INdmPrimitive> UpdatePrimitivesCollection(NamedCollection<INdmPrimitive> series)
{
List<INdmPrimitive> collection = new();
foreach (var item in series.Collection)
{
var newItem = cloningStrategy.Clone(item);
collection.Add(newItem);
}
series.Collection.Clear();
return collection;
}
}
}