hzhang/Enigmos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor programmable modules

Browse Source
This commit is contained in:
h z
2024-07-06 02:12:54 +01:00
parent be5428d708
commit 3eec8a1345
26 changed files with 329 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
Modules/ProgrammableModules/OptimizationModule/OptimizationInputProviderModule.cs Normal file
View File

@@ -0,0 +1,36 @@
using Enigmos.Boards;
using Godot;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Skeleton.DataStructure;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationInputProviderModule : SubModule, IComputationalModule
{
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public IDataOutPort? Output { get; set; }
public OptimizationModuleBoard? ParentBoard { get; set; }
public void Init(OptimizationModuleBoard board)
{
base.Init();
ParentBoard = board;
this.DataOutInit("Output", 1);
Output = DataOutPorts[0];
PostInit();
}
public void Define()
{
(object, StringName) Func(CacheItem c)
{
IData w = ParentBoard!.OptimizationModule!.CachedInput[ParentBoard.OptimizationModule.ProcessingIndex];
return (w.Data, w.Type)!;
}
Output!.OutData.UpdateCalculation(Func);
}
}

186
Modules/ProgrammableModules/OptimizationModule/OptimizationModule.cs Normal file
View File

@@ -0,0 +1,186 @@
using Enigmos.Boards;
using Enigmos.Modules.InterlayerModules;
using Enigmos.Ports.DataPorts;
using Godot;
using Nocturnis.DataStructures;
using Nocturnis.DataStructures.ConfigurableParameters;
using Nocturnis.DataStructures.DataPortGroups;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationModule : ProgrammableModule,
IPolymorphismModule,
IParameterizedModule,
IOptimizationModule
{
public bool OptimizationFinished { get; set; }
public bool OptimizationStarted { get; set; }
private double? CachedOptimizeValue { get; set; }
public IDataInPort? ArrayInput { get; set; }
public IInterlayerDataInModule[] ExplicitOutputs { get; set; } = Array.Empty<IInterlayerDataInModule>();
public IInterlayerDataOutModule[] ImplicitInputs { get; set; } = Array.Empty<IInterlayerDataOutModule>();
public IData[] CachedInput { get; set; } = Array.Empty<IData>();
public int ProcessingIndex { get; set; }
private IBoolParameter? UsingMax { get; set; }
public IData CachedResult { get; set; } =
GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
public IDataInPort? InternalIterOut { get; set; }
public IDataOutPort? InternalArrayIn { get; set; }
private IDataPortGroup[] InterlayerGroups { get; set; } = Array.Empty<IDataPortGroup>();
private IDataPortGroup? OptimizationGroup { get; set; }
private InterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<InterlayerDataInModule>();
private OptimizationSelectorModule? Selector { get; set; }
private OptimizationOutputModule? Output { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { ArrayInput! };
public new OptimizationModuleBoard UnderlyingBoard
{
get => (base.UnderlyingBoard as OptimizationModuleBoard)!;
set => base.UnderlyingBoard = value;
}
public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
public override IEnumerable<IBasePort> ExplicitPorts =>
new IBasePort[] { ArrayInput!, Output!.Output! }
.Union<IBasePort>(ExplicitInputs.Select(c => c.DataIn)!);
public override BaseModule[] SubModules =>
ExplicitInputs
.Union(new BaseModule[] { Output! })
.ToArray();
public override IEnumerable<IBasePort> ImplicitPorts =>
new IBasePort[] { UnderlyingBoard.InputProvider!.Output!, UnderlyingBoard.Selector!.Selector! }
.Union(UnderlyingBoard.ImplicitDataOuts.Select(c => c.DataOut))!;
public override void Init()
{
base.Init();
UnderlyingBoard = GlobalProvider.SceneProvider!
.AssetMapper<OptimizationModuleBoard>()
.Instantiate<OptimizationModuleBoard>();
UnderlyingBoard.Init();
InterlayerGroups = new IDataPortGroup[3];
ExplicitInputs = new InterlayerDataInModule[3];
InternalIterOut = this.GetPort<IDataInPort>("InternalIterOut");
Output = GetModule<OptimizationOutputModule>("Output");
Output.Init();
for (int i = 0; i < 3; i++)
{
ExplicitInputs[i] = GetModule<InterlayerDataInModule>($"EI{i + 1}");
ExplicitInputs[i].DualModule = UnderlyingBoard.ImplicitDataOuts[i];
UnderlyingBoard.ImplicitDataOuts[i].DualModule = ExplicitInputs[i];
}
OptimizationFinished = true;
CachedInput = Array.Empty<IData>();
//CachedArray = Array.Empty<DataPackage>();
ProcessingIndex = 0;
CachedResult = GlobalProvider.DataStructureProvider!.NullData;
CachedOptimizeValue = null;
ArrayInput = this.GetPort<DataInPort>("ArrayInput");
for (int i = 0; i < 3; i++)
{
InterlayerGroups[i] = GlobalProvider.DataStructureProvider.NewDataPortGroup(
this,
new IDataPort[] { ExplicitInputs[i].DataIn!, UnderlyingBoard.ImplicitDataOuts[i].DataOut! },
$"Exterior In -> Interior Out{i}",
EnigmosConstant.DataPortTypes.Real,
EnigmosConstant.DataPortTypes.AnyType
);
ExplicitInputs[i].Board = Board;
}
OptimizationGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
this,
new IDataPort[] { ArrayInput },
"Array Input Type",
EnigmosConstant.DataPortTypes.AnyArrayType,
EnigmosConstant.DataPortTypes.AnyArray
);
UsingMax = GlobalProvider.DataStructureProvider.NewBoolParameter(
"Method",
"Max",
"Min",
true
);
Output.Output!.SetDataType(EnigmosConstant.DataPortTypes.Real);
Selector!.Selector!.SetDataType(EnigmosConstant.DataPortTypes.Real);
ConfigurableParameters = new HashSet<IConfigurableParameter> { UsingMax };
ConfigurablePortGroups =
InterlayerGroups.Union(new[] { OptimizationGroup }).ToHashSet();
PostInit();
}
public void Inference()
{
StringName elementType = GlobalProvider.DataPackageTypeProvider!.ToElement(OptimizationGroup!.SelectedType);
Output!.Output!.SetDataType(elementType);
UnderlyingBoard.InputProvider!.Output!.SetDataType(elementType);
}
private void SoftReset() => UnderlyingBoard.Reset();
public void Optimize()
{
if (OptimizationFinished)
{
CachedOptimizeValue = null;
CachedInput = InternalArrayIn!.OutData.Get!.Array;
CachedResult = GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
ProcessingIndex = 0;
}
while (ProcessingIndex < CachedInput.Length)
{
SoftReset();
UnderlyingBoard.InputProvider!.Output!.OutData.UpdateCalculation(
cache =>
(CachedInput[ProcessingIndex].Data, CachedInput[ProcessingIndex].Type)!
);
UnderlyingBoard.InputProvider.Output.OutData.Expire();
double currentValue = UnderlyingBoard.Selector!.Selector!.GetData.Get!.Double;
IData currentOut = InternalIterOut!.GetData.Get!;
if (UsingMax!.ParameterValue)
{
if (CachedOptimizeValue == null || (CachedOptimizeValue < currentValue))
{
CachedOptimizeValue = currentValue;
CachedResult.Assign(currentOut.Data!, currentOut.Type!);
}
}
else
{
if (CachedOptimizeValue == null || CachedOptimizeValue > currentValue)
{
CachedOptimizeValue = currentValue;
CachedResult.Assign(currentOut.Data!, currentOut.Type!);
}
}
ProcessingIndex++;
}
Output!.Define();
OptimizationFinished = true;
}
public bool Calculated { get; set; }
}

25
Modules/ProgrammableModules/OptimizationModule/OptimizationOutputModule.cs Normal file
View File

@@ -0,0 +1,25 @@
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationOutputModule : SubModule, IComputationalModule
{
public IDataOutPort? Output { get; set; }
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public override void Init()
{
this.DataOutInit("DataOut", 1);
Output = DataOutPorts[0];
}
public void Define()
{
throw new NotImplementedException();
}
}

14
Modules/ProgrammableModules/OptimizationModule/OptimizationSelectorModule.cs Normal file
View File

@@ -0,0 +1,14 @@
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationSelectorModule : SubModule
{
public IDataInPort? Selector { get; set; }
public override void Init()
{
base.Init();
Selector = this.GetPort<IDataInPort>("Selector");
}
}