Sample Calcs

You may optionally enable sample calculations for your custom criterion.

To do so, implement the two following configurational options:

var definition = new CriterionDefinitionConfig()
    // ...
    .WithInitSampleCalcFunc(InitSampleCalc)         // <-- Func initializes sample calc inputs.
    .WithAnalyzeSampleCalcFunc(ComputeSampleCalc);  // <-- Func computes sample calc results.

The following is a complete criterion that supports sample calculations:

using HyperX.Solver.Api;
 
namespace Solver.Criteria.Sample;
 
public class MyModule : CriterionModule
{
    public override CriteriaConfig GetCriteria()
    {
        var config = new CriteriaConfig();
        CriterionDefinitionConfig definition;
        SettingDefinitionConfig setting;
 
        definition = new CriterionDefinitionConfig()
            .WithName("My Criterion")
            .WithDescription("A sample criterion")
            .WithVersion(1, 0, 0)
            .WithUid("00000000-0000-0000-0000-REPLACEME001")
            .WithReferenceId("S02")
            .WithThreadSafety(true)
            .WithBatchLoads(false)
            .AddApplicability(RepresentationType.Plate)
            .WithAnalyzeFunc(Compute)
            .WithInitSampleCalcFunc(InitSampleCalc)
            .WithAnalyzeSampleCalcFunc(ComputeSampleCalc);
        _ = config.Add(definition);
 
        setting = new SettingDefinitionConfig()
            .WithName("Stress allowable")
            .WithDescription("A setting")
            .WithUid("00000000-0000-0000-0000-REPLACEME001")
            .WithCategory("Allowables")
            .WithId(1)
            .WithDefaultValue(5.0e6);
        _ = config.Add(setting);
 
        return config;
    }
 
    private AnalysisResult Compute(ICriterionInput input)
    {
        var plate = input.Analyzable.GetPlateRep();
 
        var details = input.Details;
 
        double t = plate.Thickness;
        double a = plate.Length;
        double b = plate.Width;
 
        _ = details.AddSubTree("Geometry")
            .Add("t", t, Unit.Distance, SampleCalcIds.t)
            .Add("a", a, Unit.Distance, SampleCalcIds.a)
            .Add("b", b, Unit.Distance, SampleCalcIds.b);
 
        var forces = plate.GetLoadMidpoint();
 
        _ = details.AddSubTree("Loads")
            .Add("N<_x>", forces.Nx, Unit.UnitForce)
            .Add("N<_y>", forces.Ny, Unit.UnitForce)
            .Add("N<_xy>", forces.Nxy, Unit.UnitForce);
 
        var allowable = input.Analyzable.Settings.GetValue<double>(1);
        _ = details.AddSubTree("Allowables")
            .Add("Allow", allowable, Unit.Stress);
 
        var margin = ComputeCore(t, a, b);
 
        return new AnalysisResult(margin, details);
    }
 
    private static Margin ComputeCore(double t, double a, double b)
    {
        return new Margin(t * a * b);
    }
 
    private static SampleCalcItemList InitSampleCalc()
    {
        var items = new SampleCalcItemList();
        SampleCalcItemConfig item;
 
        item = new SampleCalcItemConfig()
            .WithName("t")
            .WithValue(0.01)
            .WithId(SampleCalcIds.t);
        items.Add(item);
 
        item = new SampleCalcItemConfig()
            .WithName("a")
            .WithValue(10.0)
            .WithId(SampleCalcIds.a);
        items.Add(item);
 
        item = new SampleCalcItemConfig()
            .WithName("b")
            .WithValue(10.0)
            .WithId(SampleCalcIds.b);
        items.Add(item);
 
        return items;
    }
 
    private static ISampleCalcOutput ComputeSampleCalc(ISampleCalcInput sampleInput)
    {
        var items = sampleInput.Items;
        double t = items.GetItem(SampleCalcIds.t).DoubleValue;
        double a = items.GetItem(SampleCalcIds.a).DoubleValue;
        double b = items.GetItem(SampleCalcIds.b).DoubleValue;
 
        var ms = ComputeCore(t, a, b);
 
        var outItems = new SampleCalcItemList();
 
        SampleCalcItemConfig item;
        item = new SampleCalcItemConfig()
            .WithName("t*a")
            .WithValue(t * a);
        outItems.Add(item);
 
        item = new SampleCalcItemConfig()
            .WithName("MS")
            .WithValue(ms);
        outItems.Add(item);
 
        return new SampleCalcOutput(outItems);
    }
}
 
internal enum SampleCalcIds
{
    t, a, b
}

Further reading:

• ISampleCalcInput
• SampleCalcOutput
• SampleCalcItemList
• SampleCalcInitFunc
• SampleCalcComputeFunc